@ifc-lite/viewer 1.28.0 → 1.28.1

package/src/lib/desktop/desktopEntitlementEvents.ts

@@ -1,39 +0,0 @@
-/* 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

@@ -1,43 +0,0 @@
-/* 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 implementation. They are kept for future
-  // extensibility if a desktop-specific entitlement provider is added.
-  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

@@ -1,130 +0,0 @@
-/* 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'
-  | 'extensions';
-
-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,
-  },
-  extensions: {
-    label: 'Extensions & flavors',
-    description: 'Install user-authored extensions, manage flavors, and access the authoring loop.',
-    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.';
-}

package/src/lib/platform.ts

@@ -1,23 +0,0 @@
-/* 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/. */
-
-/**
- * Platform detection utilities for runtime bridge pattern
- * Routes to WASM (browser) or native (Tauri desktop) implementations
- */
-
-/**
- * Detects if running in Tauri desktop environment
- */
-export function isTauri(): boolean {
-  return typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
-}
-
-/**
- * Platform-specific cache implementation
- * Returns 'indexeddb' for browser, 'filesystem' for desktop
- */
-export function getCacheType(): 'indexeddb' | 'filesystem' {
-  return isTauri() ? 'filesystem' : 'indexeddb';
-}

package/src/services/desktop-cache.ts

@@ -1,186 +0,0 @@
-/* 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/. */
-
-/**
- * Desktop Cache Service
- *
- * File system-based caching for Tauri desktop apps.
- * Replaces IndexedDB caching used in the web version.
- *
- * This module uses dynamic imports to avoid bundler issues in web builds.
- * The @tauri-apps/api package is only loaded at runtime in Tauri environments.
- */
-
-// Tauri API types - dynamically imported to avoid issues in web builds
-type InvokeFn = <T>(cmd: string, args?: Record<string, unknown>) => Promise<T>;
-
-let invoke: InvokeFn | null = null;
-
-async function getInvoke(): Promise<InvokeFn> {
-  if (invoke) return invoke;
-  // Use globalThis.__TAURI_INTERNALS__ which is set by Tauri runtime
-  // This avoids bundler trying to resolve @tauri-apps/api in web builds
-  const win = globalThis as unknown as { __TAURI_INTERNALS__?: { invoke: InvokeFn } };
-  if (win.__TAURI_INTERNALS__?.invoke) {
-    invoke = win.__TAURI_INTERNALS__.invoke;
-    return invoke;
-  }
-  throw new Error('Tauri API not available - this module should only be used in Tauri apps');
-}
-
-export interface CacheEntry {
-  key: string;
-  fileName: string;
-  fileSize: number;
-  cacheSize: number;
-  createdAt: number;
-}
-
-export interface CacheStats {
-  entries: CacheEntry[];
-  totalSize: number;
-  entryCount: number;
-}
-
-export interface CacheResult {
-  buffer: ArrayBuffer;
-  sourceBuffer?: ArrayBuffer;
-}
-
-/**
- * Get cached data by key
- * @param key Cache key (typically file hash)
- * @returns Cached data as CacheResult, or null if not found
- */
-export async function getCached(key: string): Promise<CacheResult | null> {
-  try {
-    const inv = await getInvoke();
-    const data = await inv<number[] | null>('get_cached', { cacheKey: key });
-    if (data) {
-      console.log(`[DesktopCache] Cache HIT for key: ${key} (${data.length} bytes)`);
-      return { buffer: new Uint8Array(data).buffer };
-    }
-    console.log(`[DesktopCache] Cache MISS for key: ${key}`);
-    return null;
-  } catch (error) {
-    console.warn('[DesktopCache] Failed to get cached data:', error);
-    return null;
-  }
-}
-
-/**
- * Save data to cache
- * @param key Cache key (typically file hash)
- * @param buffer Data to cache
- * @param fileName Original file name (for metadata)
- * @param fileSize Original file size (for metadata)
- * @param _sourceBuffer Source buffer (not used in desktop cache, but kept for API compatibility)
- */
-export async function setCached(
-  key: string,
-  buffer: ArrayBuffer,
-  fileName: string,
-  fileSize: number,
-  _sourceBuffer?: ArrayBuffer
-): Promise<void> {
-  try {
-    const inv = await getInvoke();
-    const data = Array.from(new Uint8Array(buffer));
-    console.log(`[DesktopCache] Caching ${fileName} (${data.length} bytes) with key: ${key}`);
-    await inv('set_cached', { cacheKey: key, data });
-    console.log(`[DesktopCache] Successfully cached ${fileName}`);
-  } catch (error) {
-    console.warn('[DesktopCache] Failed to save to cache:', error);
-  }
-}
-
-/**
- * Clear all cached data
- */
-export async function clearCache(): Promise<void> {
-  try {
-    const inv = await getInvoke();
-    await inv('clear_cache');
-    console.log('[DesktopCache] Cache cleared');
-  } catch (error) {
-    console.warn('[DesktopCache] Failed to clear cache:', error);
-  }
-}
-
-/**
- * Get cache statistics
- */
-export async function getCacheStats(): Promise<CacheStats> {
-  try {
-    const inv = await getInvoke();
-    return await inv<CacheStats>('get_cache_stats');
-  } catch (error) {
-    console.warn('[DesktopCache] Failed to get cache stats:', error);
-    return { entries: [], totalSize: 0, entryCount: 0 };
-  }
-}
-
-/**
- * Delete a cache entry
- */
-export async function deleteCached(key: string): Promise<void> {
-  try {
-    const inv = await getInvoke();
-    await inv('delete_cache_entry', { cacheKey: key });
-    console.log('[DesktopCache] Cache entry deleted:', key);
-  } catch (error) {
-    console.warn('[DesktopCache] Failed to delete cache entry:', error);
-  }
-}
-
-/**
- * Check if a key exists in cache
- */
-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-harness.ts

@@ -1,196 +0,0 @@
-/* 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

@@ -1,20 +0,0 @@
-/* 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.
-  }
-}