@ifc-lite/viewer 1.17.3 → 1.17.4

package/src/hooks/useIfcServer.ts

@@ -132,7 +132,6 @@ export function useIfcServer() {
   ): Promise<boolean> => {
     const { setProgress, setIfcDataStore, setGeometryResult } = useViewerStore.getState();
     try {
-      const serverStart = performance.now();
       setProgress({ phase: 'Connecting to server', percent: 5 });
 
       const client = new IfcServerClient({ baseUrl: SERVER_URL });
@@ -151,8 +150,6 @@ export function useIfcServer() {
 
       let allMeshes: MeshData[];
       let result: ServerParseResultType;
-      let parseTime: number;
-      let convertTime: number;
 
       // Use streaming for large files (>150MB) for progressive rendering
       // Smaller files use non-streaming path (faster - avoids ~1.1s background re-processing overhead)
@@ -164,8 +161,6 @@ export function useIfcServer() {
 
       if (parquetSupported && fileSizeMB > USE_STREAMING_THRESHOLD_MB) {
         // STREAMING PATH - for large files, render progressively
-        console.log(`[useIfc] Using STREAMING endpoint for large file (${fileSizeMB.toFixed(1)}MB)`);
-
         allMeshes = [];
         let totalVertices = 0;
         let totalTriangles = 0;
@@ -177,8 +172,6 @@ export function useIfcServer() {
         // Progressive bounds calculation
         const bounds = createEmptyBounds();
 
-        const parseStart = performance.now();
-
         // Throttle server streaming updates - large files get less frequent UI updates
         let lastServerStreamRenderTime = 0;
         const SERVER_STREAM_INTERVAL_MS = getServerStreamIntervalMs(fileSizeMB);
@@ -232,15 +225,10 @@ export function useIfcServer() {
           }
         });
 
-        parseTime = performance.now() - parseStart;
         cacheKey = streamResult.cache_key;
         streamMetadata = streamResult.metadata;
         streamStats = streamResult.stats;
 
-        console.log(`[useIfc] Streaming complete in ${parseTime.toFixed(0)}ms`);
-        console.log(`  ${batchCount} batches, ${allMeshes.length} meshes`);
-        console.log(`  Cache key: ${cacheKey}`);
-
         // Build final result object for data model fetching
         // Note: meshes field is omitted - allMeshes is passed separately to convertServerDataModel
         result = {
@@ -248,7 +236,6 @@ export function useIfcServer() {
           metadata: streamMetadata,
           stats: streamStats,
         } as ParquetStreamResult;
-        convertTime = 0; // Already converted inline
 
         // Final geometry set with complete bounds
         // Server already applies RTC shift to mesh positions, so bounds are shifted
@@ -286,49 +273,23 @@ export function useIfcServer() {
 
       } else if (parquetSupported) {
         // NON-STREAMING PATH - for smaller files, use batch request (with cache check)
-        console.log(`[useIfc] Using PARQUET endpoint - 15x smaller payload, faster transfer`);
-
         // Use Parquet endpoint - much smaller payload (~15x compression)
-        const parseStart = performance.now();
         const parquetResult = await client.parseParquet(file);
         result = parquetResult;
-        parseTime = performance.now() - parseStart;
-
-        console.log(`[useIfc] Server parse response received in ${parseTime.toFixed(0)}ms`);
-        console.log(`  Server stats: ${parquetResult.stats.total_time_ms}ms total (parse: ${parquetResult.stats.parse_time_ms}ms, geometry: ${parquetResult.stats.geometry_time_ms}ms)`);
-        console.log(`  Parquet payload: ${(parquetResult.parquet_stats.payload_size / 1024 / 1024).toFixed(2)}MB, decode: ${parquetResult.parquet_stats.decode_time_ms}ms`);
-        console.log(`  Meshes: ${parquetResult.meshes.length}, Vertices: ${parquetResult.stats.total_vertices}, Triangles: ${parquetResult.stats.total_triangles}`);
-        console.log(`  Cache key: ${parquetResult.cache_key}`);
 
         setProgress({ phase: 'Converting meshes', percent: 70 });
 
         // Convert server mesh format to viewer format (TypedArrays)
-        const convertStart = performance.now();
         allMeshes = parquetResult.meshes.map(convertServerMesh);
-        convertTime = performance.now() - convertStart;
-        console.log(`[useIfc] Mesh conversion: ${convertTime.toFixed(0)}ms for ${allMeshes.length} meshes`);
       } else {
-        console.log(`[useIfc] Parquet not available, using JSON endpoint (install parquet-wasm for 15x faster transfer)`);
-        console.log(`[useIfc] Using FULL PARSE (parallel) - all geometry processed at once`);
-
         // Fallback to JSON endpoint
-        const parseStart = performance.now();
         result = await client.parse(file);
-        parseTime = performance.now() - parseStart;
-
-        console.log(`[useIfc] Server parse response received in ${parseTime.toFixed(0)}ms`);
-        console.log(`  Server stats: ${result.stats.total_time_ms}ms total (parse: ${result.stats.parse_time_ms}ms, geometry: ${result.stats.geometry_time_ms}ms)`);
-        console.log(`  Meshes: ${result.meshes.length}, Vertices: ${result.stats.total_vertices}, Triangles: ${result.stats.total_triangles}`);
-        console.log(`  Cache key: ${result.cache_key}`);
 
         setProgress({ phase: 'Converting meshes', percent: 70 });
 
         // Convert server mesh format to viewer format
-        const convertStart = performance.now();
         const jsonResult = result as ParseResponse;
         allMeshes = jsonResult.meshes.map(convertServerMesh);
-        convertTime = performance.now() - convertStart;
-        console.log(`[useIfc] Mesh conversion: ${convertTime.toFixed(0)}ms for ${allMeshes.length} meshes`);
       }
 
       // For non-streaming paths, calculate bounds and set geometry
@@ -376,23 +337,14 @@ export function useIfcServer() {
           hasLargeCoordinates: serverCoordInfo?.is_geo_referenced ?? false,
         };
 
-        console.log(`[useIfc] Calculated bounds:`, {
-          min: `(${bounds.min.x.toFixed(1)}, ${bounds.min.y.toFixed(1)}, ${bounds.min.z.toFixed(1)})`,
-          max: `(${bounds.max.x.toFixed(1)}, ${bounds.max.y.toFixed(1)}, ${bounds.max.z.toFixed(1)})`,
-          size: `${(bounds.max.x - bounds.min.x).toFixed(1)} x ${(bounds.max.y - bounds.min.y).toFixed(1)} x ${(bounds.max.z - bounds.min.z).toFixed(1)}`,
-        });
-
         // Set all geometry at once
         setProgress({ phase: 'Rendering geometry', percent: 80 });
-        const renderStart = performance.now();
         setGeometryResult({
           meshes: allMeshes,
           totalVertices: result.stats.total_vertices,
           totalTriangles: result.stats.total_triangles,
           coordinateInfo,
         });
-        const renderTime = performance.now() - renderStart;
-        console.log(`[useIfc] Geometry set: ${renderTime.toFixed(0)}ms`);
       }
 
       // Fetch and decode data model asynchronously (geometry already displayed)
@@ -403,8 +355,6 @@ export function useIfcServer() {
       (async () => {
         if (isStale?.()) return;
         setProgress({ phase: 'Fetching data model', percent: 85 });
-        const dataModelStart = performance.now();
-
         try {
           // If data model was included in response (ParquetParseResponse), use it directly
           // Otherwise, fetch from the data model endpoint
@@ -414,25 +364,15 @@ export function useIfcServer() {
           }
 
           if (!dataModelBuffer || dataModelBuffer.byteLength === 0) {
-            console.log('[useIfc] Fetching data model from server (background processing)...');
             dataModelBuffer = await client.fetchDataModel(cacheKey);
           }
 
           if (!dataModelBuffer) {
-            console.log('[useIfc] ⚡ Data model not available - property panel disabled');
             return;
           }
 
           const dataModel: DataModel = await decodeDataModel(dataModelBuffer);
 
-          console.log(`[useIfc] Data model decoded in ${(performance.now() - dataModelStart).toFixed(0)}ms`);
-          console.log(`  Entities: ${dataModel.entities.size}`);
-          console.log(`  PropertySets: ${dataModel.propertySets.size}`);
-          const quantitySetsSize = (dataModel as { quantitySets?: Map<number, unknown> }).quantitySets?.size ?? 0;
-          console.log(`  QuantitySets: ${quantitySetsSize}`);
-          console.log(`  Relationships: ${dataModel.relationships.length}`);
-          console.log(`  Spatial nodes: ${dataModel.spatialHierarchy.nodes.length}`);
-
           // Convert server data model directly to IfcDataStore format
           const dataStore = convertServerDataModel(
             dataModel,
@@ -443,23 +383,14 @@ export function useIfcServer() {
 
           if (isStale?.()) return;
           setIfcDataStore(dataStore);
-          console.log('[useIfc] ✅ Property panel ready with server data model');
-          console.log(`[useIfc] Data model loaded in ${(performance.now() - dataModelStart).toFixed(0)}ms (background)`);
 
           buildSpatialIndexGuarded(allMeshes, dataStore, setIfcDataStore);
         } catch (err) {
-          console.warn('[useIfc] Failed to decode data model:', err);
-          console.log('[useIfc] ⚡ Skipping data model (decoding failed)');
         }
       })(); // End of async data model fetch block - runs in background, doesn't block
 
       // Geometry is ready - mark complete immediately (data model loads in background)
       setProgress({ phase: 'Complete', percent: 100 });
-      const totalServerTime = performance.now() - serverStart;
-      console.log(`[useIfc] SERVER PARALLEL complete: ${file.name}`);
-      console.log(`  Total time: ${totalServerTime.toFixed(0)}ms`);
-      console.log(`  Breakdown: parse=${parseTime.toFixed(0)}ms, convert=${convertTime.toFixed(0)}ms`);
-
       return true;
     } catch (err) {
       console.error('[useIfc] Server parse failed:', err);

package/src/lib/desktop/ClerkDesktopEntitlementSync.tsx

@@ -0,0 +1,175 @@
+/* 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 { useEffect } from 'react';
+import { useAuth, useUser } from '@clerk/clerk-react';
+import { getDefaultDesktopEntitlement, type DesktopEntitlement } from '@/lib/desktop-product';
+import { resolveDesktopEntitlement } from '@/lib/desktop-entitlement';
+import { useViewerStore } from '@/store';
+import { DESKTOP_ENTITLEMENT_REFRESH_EVENT } from './desktopEntitlementEvents';
+
+/**
+ * Sync Clerk auth + entitlement state into the viewer store.
+ * Desktop plan state is authoritative here; chat inherits only the AI-specific permission.
+ */
+const ENTITLEMENT_REFRESH_INTERVAL_MS = 24 * 60 * 60 * 1000;
+
+function entitlementsEqual(left: DesktopEntitlement, right: DesktopEntitlement): boolean {
+  return left.tier === right.tier
+    && left.status === right.status
+    && left.source === right.source
+    && left.userId === right.userId
+    && left.validatedAt === right.validatedAt
+    && left.graceUntil === right.graceUntil
+    && left.trialEndsAt === right.trialEndsAt;
+}
+
+export function ClerkDesktopEntitlementSync() {
+  const { isLoaded, isSignedIn, userId, getToken, has } = useAuth();
+  const { user } = useUser();
+  const setChatAuthToken = useViewerStore((s) => s.setChatAuthToken);
+  const switchChatUserContext = useViewerStore((s) => s.switchChatUserContext);
+  const setDesktopEntitlement = useViewerStore((s) => s.setDesktopEntitlement);
+
+  useEffect(() => {
+    if (!isLoaded) return;
+
+    if (!isSignedIn) {
+      const state = useViewerStore.getState();
+      const next = (
+        state.desktopEntitlement.tier === 'pro'
+        && state.desktopEntitlement.graceUntil
+        && state.desktopEntitlement.graceUntil > Date.now()
+      )
+        ? {
+            ...state.desktopEntitlement,
+            status: 'grace_offline' as const,
+            source: 'cached' as const,
+          }
+        : {
+            ...getDefaultDesktopEntitlement(),
+            status: 'signed_out' as const,
+            source: 'cached' as const,
+          };
+      if (!entitlementsEqual(state.desktopEntitlement, next)) {
+        setDesktopEntitlement(next);
+      }
+      if (next.status === 'grace_offline') {
+        switchChatUserContext(next.userId, false, {
+          clearPersistedCurrent: false,
+          restoreMessages: true,
+        });
+      } else {
+        switchChatUserContext(null, false, {
+          clearPersistedCurrent: state.chatStorageUserId !== null,
+          restoreMessages: false,
+        });
+      }
+      setChatAuthToken(null);
+      return;
+    }
+
+    let cancelled = false;
+
+    const syncAuth = async () => {
+      try {
+        const token = await getToken({ skipCache: true });
+        const { entitlement, aiAssistantEnabled } = resolveDesktopEntitlement({
+          userId: userId ?? null,
+          token,
+          has,
+          publicMetadata: (user?.publicMetadata ?? null) as Record<string, unknown> | null,
+        });
+
+        if (cancelled) {
+          return;
+        }
+
+        const state = useViewerStore.getState();
+        if (!entitlementsEqual(state.desktopEntitlement, entitlement)) {
+          setDesktopEntitlement(entitlement);
+        }
+        if (state.chatStorageUserId !== (userId ?? null) || state.chatHasPro !== aiAssistantEnabled) {
+          switchChatUserContext(userId ?? null, aiAssistantEnabled, {
+            clearPersistedCurrent: state.chatStorageUserId !== null && state.chatStorageUserId !== userId,
+            restoreMessages: true,
+          });
+        }
+        setChatAuthToken(token ?? null);
+      } catch {
+        if (cancelled) {
+          return;
+        }
+
+        const state = useViewerStore.getState();
+        if (
+          state.desktopEntitlement.tier === 'pro'
+          && state.desktopEntitlement.graceUntil
+          && state.desktopEntitlement.graceUntil > Date.now()
+        ) {
+          const next = {
+            ...state.desktopEntitlement,
+            status: 'grace_offline',
+            source: 'cached',
+          } satisfies DesktopEntitlement;
+          if (!entitlementsEqual(state.desktopEntitlement, next)) {
+            setDesktopEntitlement(next);
+          }
+          if (state.chatStorageUserId !== (userId ?? null) || state.chatHasPro !== true) {
+            switchChatUserContext(userId ?? null, true, {
+              clearPersistedCurrent: false,
+              restoreMessages: true,
+            });
+          }
+          return;
+        }
+
+        const next = {
+          ...getDefaultDesktopEntitlement(),
+          userId: userId ?? null,
+          status: 'signed_out' as const,
+          source: 'cached' as const,
+        };
+        if (!entitlementsEqual(state.desktopEntitlement, next)) {
+          setDesktopEntitlement(next);
+        }
+      }
+    };
+
+    void syncAuth();
+    const timer = window.setInterval(() => {
+      void syncAuth();
+    }, ENTITLEMENT_REFRESH_INTERVAL_MS);
+    const onWindowFocus = () => {
+      void syncAuth();
+    };
+    const onManualRefresh = (event: Event) => {
+      const detail = (event as CustomEvent<{ resolve: () => void; reject: (error?: unknown) => void }>).detail;
+      void syncAuth()
+        .then(() => detail?.resolve())
+        .catch((error) => detail?.reject(error));
+    };
+    window.addEventListener('focus', onWindowFocus);
+    window.addEventListener(DESKTOP_ENTITLEMENT_REFRESH_EVENT, onManualRefresh);
+
+    return () => {
+      cancelled = true;
+      window.clearInterval(timer);
+      window.removeEventListener('focus', onWindowFocus);
+      window.removeEventListener(DESKTOP_ENTITLEMENT_REFRESH_EVENT, onManualRefresh);
+    };
+  }, [
+    getToken,
+    has,
+    isLoaded,
+    isSignedIn,
+    setChatAuthToken,
+    setDesktopEntitlement,
+    switchChatUserContext,
+    user?.publicMetadata,
+    userId,
+  ]);
+
+  return null;
+}

package/src/lib/desktop/desktopEntitlementEvents.ts

@@ -0,0 +1,39 @@
+/* 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 const DESKTOP_ENTITLEMENT_REFRESH_EVENT = 'ifc-lite:desktop-entitlement-refresh';
+
+interface DesktopEntitlementRefreshDetail {
+  resolve: () => void;
+  reject: (error?: unknown) => void;
+}
+
+const ENTITLEMENT_REFRESH_TIMEOUT_MS = 10_000;
+
+export function requestDesktopEntitlementRefresh(): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timeoutId = globalThis.setTimeout(() => {
+      reject(new Error(
+        `Desktop entitlement refresh timed out after ${ENTITLEMENT_REFRESH_TIMEOUT_MS}ms — ` +
+        'no listener responded to the refresh event.',
+      ));
+    }, ENTITLEMENT_REFRESH_TIMEOUT_MS);
+
+    window.dispatchEvent(new CustomEvent<DesktopEntitlementRefreshDetail>(
+      DESKTOP_ENTITLEMENT_REFRESH_EVENT,
+      {
+        detail: {
+          resolve: () => {
+            globalThis.clearTimeout(timeoutId);
+            resolve();
+          },
+          reject: (error?: unknown) => {
+            globalThis.clearTimeout(timeoutId);
+            reject(error);
+          },
+        },
+      },
+    ));
+  });
+}

package/src/lib/desktop-entitlement.ts

@@ -0,0 +1,45 @@
+/* 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 {
+  getDefaultDesktopEntitlement,
+  hasDesktopFeatureAccess,
+  type DesktopEntitlement,
+  type DesktopFeature,
+} from './desktop-product';
+
+type HasFn = ((params: { plan?: string; feature?: string }) => boolean) | undefined;
+
+interface ResolveDesktopEntitlementOptions {
+  userId: string | null;
+  token: string | null;
+  has: HasFn;
+  publicMetadata: Record<string, unknown> | null | undefined;
+  now?: number;
+}
+
+interface ResolvedDesktopEntitlement {
+  entitlement: DesktopEntitlement;
+  aiAssistantEnabled: boolean;
+}
+
+export function resolveDesktopEntitlement(options: ResolveDesktopEntitlementOptions): ResolvedDesktopEntitlement {
+  // NOTE: `token`, `has`, `publicMetadata`, and `now` are accepted but
+  // intentionally unused in this initial implementation.  Full Clerk-based
+  // entitlement resolution (plan checks via `has`, metadata-driven overrides,
+  // token validation, and time-based expiry via `now`) will be wired up once
+  // the Clerk integration is available in the desktop shell.
+  const { userId } = options;
+  const entitlement: DesktopEntitlement = {
+    ...getDefaultDesktopEntitlement(),
+    userId,
+  };
+  const aiAssistantEnabled = hasDesktopFeatureAccess(entitlement, 'ai_assistant');
+  return { entitlement, aiAssistantEnabled };
+}
+
+export function canUseDesktopFeatureOffline(entitlement: DesktopEntitlement, feature: DesktopFeature, now = Date.now()): boolean {
+  void now;
+  return hasDesktopFeatureAccess(entitlement, feature);
+}

package/src/lib/desktop-product.ts

@@ -0,0 +1,124 @@
+/* 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 DesktopPlanTier = 'free' | 'pro';
+export type DesktopEntitlementStatus = 'anonymous' | 'signed_out' | 'active' | 'trial' | 'expired' | 'grace_offline';
+export type DesktopEntitlementSource = 'anonymous' | 'clerk_claims' | 'cached';
+
+export type DesktopFeature =
+  | 'viewer_basic'
+  | 'workspace_restore'
+  | 'exports'
+  | 'ids_validation'
+  | 'bcf_issue_management'
+  | 'ai_assistant';
+
+export interface DesktopEntitlement {
+  tier: DesktopPlanTier;
+  status: DesktopEntitlementStatus;
+  source: DesktopEntitlementSource;
+  userId: string | null;
+  validatedAt: number | null;
+  graceUntil: number | null;
+  trialEndsAt: number | null;
+}
+
+export interface DesktopUsageSummary {
+  type: 'credits' | 'requests';
+  used: number;
+  limit: number;
+  pct?: number;
+  resetAt?: number;
+}
+
+interface DesktopFeatureDefinition {
+  label: string;
+  description: string;
+  free: boolean;
+}
+
+const DESKTOP_FEATURES: Record<DesktopFeature, DesktopFeatureDefinition> = {
+  viewer_basic: {
+    label: 'Viewer features',
+    description: 'Core model viewing and inspection capabilities.',
+    free: true,
+  },
+  workspace_restore: {
+    label: 'Workspace restore',
+    description: 'Host-provided workspace persistence features.',
+    free: true,
+  },
+  exports: {
+    label: 'Exports',
+    description: 'Host-provided export integrations.',
+    free: true,
+  },
+  ids_validation: {
+    label: 'IDS validation',
+    description: 'Host-provided IDS workflows.',
+    free: true,
+  },
+  bcf_issue_management: {
+    label: 'BCF issue management',
+    description: 'Host-provided BCF workflows.',
+    free: true,
+  },
+  ai_assistant: {
+    label: 'Host AI assistant',
+    description: 'Optional host-provided AI integrations.',
+    free: true,
+  },
+};
+
+export function isDesktopBillingEnforced(): boolean {
+  return false;
+}
+
+export function getDesktopPlanTier(entitlementOrHasPro: DesktopEntitlement | boolean): DesktopPlanTier {
+  return typeof entitlementOrHasPro === 'boolean'
+    ? (entitlementOrHasPro ? 'pro' : 'free')
+    : entitlementOrHasPro.tier;
+}
+
+export function hasDesktopPro(entitlementOrHasPro: DesktopEntitlement | boolean): boolean {
+  return getDesktopPlanTier(entitlementOrHasPro) === 'pro';
+}
+
+export function hasDesktopFeatureAccess(entitlementOrHasPro: DesktopEntitlement | boolean, feature: DesktopFeature): boolean {
+  return hasDesktopPro(entitlementOrHasPro) || DESKTOP_FEATURES[feature].free;
+}
+
+export function getDesktopFeatureCatalog(entitlementOrHasPro: DesktopEntitlement | boolean) {
+  return (Object.entries(DESKTOP_FEATURES) as Array<[DesktopFeature, DesktopFeatureDefinition]>).map(([key, value]) => ({
+    key,
+    ...value,
+    enabled: hasDesktopFeatureAccess(entitlementOrHasPro, key),
+  }));
+}
+
+export function buildDesktopUpgradeUrl(returnTo?: string): string {
+  const fallbackReturnTo = typeof window !== 'undefined'
+    ? `${window.location.pathname}${window.location.search}`
+    : '/';
+  const nextReturnTo = returnTo ?? fallbackReturnTo;
+  return `/upgrade?returnTo=${encodeURIComponent(nextReturnTo)}`;
+}
+
+export function getDefaultDesktopEntitlement(): DesktopEntitlement {
+  return {
+    tier: 'free',
+    status: 'anonymous',
+    source: 'anonymous',
+    userId: null,
+    validatedAt: null,
+    graceUntil: null,
+    trialEndsAt: null,
+  };
+}
+
+export function getDesktopPlanSummary(entitlementOrHasPro: DesktopEntitlement | boolean, usage: DesktopUsageSummary | null): string {
+  void entitlementOrHasPro;
+  void usage;
+  return 'Desktop entitlements are host-defined and disabled in the open-source web viewer build.';
+}