@ifc-lite/viewer 1.27.0 → 1.28.1

package/src/hooks/ingest/resolveDataStoreOrAbort.test.ts

@@ -1,61 +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 { describe, it } from 'node:test';
-import assert from 'node:assert';
-
-import { resolveDataStoreOrAbort } from './resolveDataStoreOrAbort.js';
-
-const isAbortError = (err: unknown): boolean =>
-  err instanceof DOMException && err.name === 'AbortError';
-
-describe('resolveDataStoreOrAbort', () => {
-  it('returns the parse result when not aborted', async () => {
-    const store = { id: 'store' };
-    const result = await resolveDataStoreOrAbort(Promise.resolve(store), { aborted: false });
-    assert.equal(result, store);
-  });
-
-  it('throws AbortError and terminates without awaiting a blocked parse', async () => {
-    let terminated = false;
-    // A promise that never settles — mirrors a worker parse blocked on
-    // waitForEntityIndex after the geometry loop was cancelled. The previous
-    // code awaited this directly and hung forever.
-    const neverSettles = new Promise<unknown>(() => {});
-
-    await assert.rejects(
-      resolveDataStoreOrAbort(neverSettles, {
-        aborted: true,
-        terminate: () => {
-          terminated = true;
-        },
-      }),
-      isAbortError,
-    );
-
-    assert.equal(terminated, true, 'the worker parser should be terminated on abort');
-  });
-
-  it('swallows the abandoned parse rejection on abort', async () => {
-    // A parse that rejects after we bail must not surface as an unhandled
-    // rejection (this test would fail the process if the .catch guard were
-    // removed from resolveDataStoreOrAbort).
-    const rejecting = Promise.reject(new Error('worker died after abort'));
-
-    await assert.rejects(
-      resolveDataStoreOrAbort(rejecting, { aborted: true }),
-      isAbortError,
-    );
-
-    // Give the swallowed rejection a tick to settle.
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  });
-
-  it('works without a terminate callback', async () => {
-    await assert.rejects(
-      resolveDataStoreOrAbort(new Promise<unknown>(() => {}), { aborted: true }),
-      isAbortError,
-    );
-  });
-});

package/src/hooks/ingest/resolveDataStoreOrAbort.ts

@@ -1,28 +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/. */
-
-/**
- * Resolve a parse promise, unless the load was cancelled.
- *
- * A worker parse started with `waitForEntityIndex` blocks until the streaming
- * geometry pre-pass hands over the entity index. If the geometry loop is
- * cancelled before that handoff, the index never arrives and the parse promise
- * never settles — awaiting it would hang the whole ingest. On abort we instead
- * terminate the worker, abandon (and swallow) the parse promise, and throw an
- * `AbortError` so callers treat it as a clean cancellation (matching the
- * federated loader's `err.name === 'AbortError'` convention).
- */
-export async function resolveDataStoreOrAbort<T>(
-  parsePromise: Promise<T>,
-  opts: { aborted: boolean; terminate?: () => void },
-): Promise<T> {
-  if (opts.aborted) {
-    opts.terminate?.();
-    // Swallow the abandoned parse's eventual rejection so it doesn't surface
-    // as an unhandled rejection after we've already bailed out.
-    void parsePromise.catch(() => {});
-    throw new DOMException('Model load aborted', 'AbortError');
-  }
-  return parsePromise;
-}

package/src/hooks/ingest/watchedGeometryStream.test.ts

@@ -1,78 +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 { describe, it } from 'node:test';
-import assert from 'node:assert';
-
-import { watchedGeometryStream } from './watchedGeometryStream.js';
-
-/** Build a controllable async source that records when return() is called. */
-function makeSource<T>(values: T[]): { source: AsyncIterable<T>; returned: () => boolean } {
-  let didReturn = false;
-  const source: AsyncIterable<T> = {
-    [Symbol.asyncIterator]() {
-      let i = 0;
-      return {
-        next: async () => (i < values.length
-          ? { done: false, value: values[i++] }
-          : { done: true, value: undefined as unknown as T }),
-        return: async () => {
-          didReturn = true;
-          return { done: true, value: undefined as unknown as T };
-        },
-      };
-    },
-  };
-  return { source, returned: () => didReturn };
-}
-
-const baseOpts = {
-  fileName: 'test.ifc',
-  fileSizeMB: 1,
-  getBatchCount: () => 0,
-  getLastTotalMeshes: () => 0,
-  cleanupMs: 50,
-};
-
-describe('watchedGeometryStream', () => {
-  it('re-yields every event in order then completes', async () => {
-    const { source } = makeSource([1, 2, 3]);
-    const seen: number[] = [];
-    for await (const v of watchedGeometryStream(source, baseOpts)) seen.push(v);
-    assert.deepStrictEqual(seen, [1, 2, 3]);
-  });
-
-  it('stops early when shouldAbort() turns true', async () => {
-    const { source } = makeSource([1, 2, 3, 4]);
-    const seen: number[] = [];
-    let calls = 0;
-    for await (const v of watchedGeometryStream(source, {
-      ...baseOpts,
-      // Abort after the second event has been consumed.
-      shouldAbort: () => (++calls > 2),
-    })) {
-      seen.push(v);
-    }
-    assert.deepStrictEqual(seen, [1, 2]);
-  });
-
-  it('tears down the underlying iterator on normal completion', async () => {
-    const { source, returned } = makeSource([1]);
-    let count = 0;
-    for await (const v of watchedGeometryStream(source, baseOpts)) count += v;
-    assert.strictEqual(count, 1);
-    assert.strictEqual(returned(), true);
-  });
-
-  it('tears down the underlying iterator when the consumer breaks early', async () => {
-    const { source, returned } = makeSource([1, 2, 3]);
-    const seen: number[] = [];
-    for await (const v of watchedGeometryStream(source, baseOpts)) {
-      seen.push(v);
-      break;
-    }
-    assert.deepStrictEqual(seen, [1]);
-    assert.strictEqual(returned(), true);
-  });
-});

package/src/hooks/ingest/watchedGeometryStream.ts

@@ -1,76 +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 { getGeometryStreamWatchdogMs } from '@ifc-lite/geometry';
-import { boundedIteratorReturn } from './streamCleanup.js';
-
-export interface WatchedGeometryStreamOptions {
-  /** File name, for the stall error message. */
-  fileName: string;
-  /** File size in MB, feeds the size-aware watchdog deadline. */
-  fileSizeMB: number;
-  /** Abort the stream cooperatively (e.g. user cancelled the load). */
-  shouldAbort?: () => boolean;
-  /** Current batch index — feeds the size-aware watchdog deadline. */
-  getBatchCount: () => number;
-  /** Meshes rendered so far, for the stall error message. */
-  getLastTotalMeshes: () => number;
-  /** Override the abandon-cleanup deadline (mostly for tests). */
-  cleanupMs?: number;
-}
-
-/**
- * Drive a geometry stream under a size-aware watchdog, re-yielding every event.
- *
- * The parallel pipeline only ends once EVERY spawned geometry worker reports
- * `complete`; if the browser fails to instantiate a worker (the "Attempting to
- * create a Worker from an empty source" warning) that worker never reports
- * `ready`/`complete` and never fires `onerror`, so the underlying generator can
- * wedge forever, stranding the load on "Processing geometry (N meshes)". Racing
- * each `next()` against a deadline converts that silent wedge into a thrown,
- * recoverable error. On ANY exit — normal completion, abort, consumer `break`,
- * or a watchdog throw — the `finally` bounds the underlying iterator's shutdown
- * so cleanup (the generator's own `finally`: freeing WASM handles, tearing down
- * workers) runs without re-blocking on the very stall the watchdog just escaped.
- *
- * Generic over the event type so the consumer keeps full type-narrowing in its
- * own `switch`.
- */
-export async function* watchedGeometryStream<T>(
-  source: AsyncIterable<T>,
-  options: WatchedGeometryStreamOptions,
-): AsyncGenerator<T> {
-  const iterator = source[Symbol.asyncIterator]();
-  try {
-    while (true) {
-      const watchdogMs = getGeometryStreamWatchdogMs({
-        desktopStableWasm: false,
-        batchCount: options.getBatchCount(),
-        fileSizeMB: options.fileSizeMB,
-      });
-      let watchdogId: ReturnType<typeof setTimeout> | null = null;
-      let result: IteratorResult<T>;
-      try {
-        result = await Promise.race([
-          iterator.next(),
-          new Promise<never>((_, reject) => {
-            watchdogId = setTimeout(() => {
-              reject(new Error(
-                `Geometry stream stalled after ${watchdogMs}ms while loading ${options.fileName}. `
-                + `Last rendered meshes: ${options.getLastTotalMeshes()}. A geometry worker likely failed to start.`,
-              ));
-            }, watchdogMs);
-          }),
-        ]);
-      } finally {
-        if (watchdogId !== null) clearTimeout(watchdogId);
-      }
-      if (result.done) return;
-      if (options.shouldAbort?.()) return;
-      yield result.value;
-    }
-  } finally {
-    await boundedIteratorReturn(iterator, options.cleanupMs);
-  }
-}

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;
-  }
-}