@oxyhq/services 6.9.45 → 6.10.1

package/src/ui/hooks/queries/useSecurityQueries.ts

@@ -1,7 +1,7 @@
-import { useQuery } from '@tanstack/react-query';
+import { useQuery, useInfiniteQuery } from '@tanstack/react-query';
 import { queryKeys } from './queryKeys';
 import { useOxy } from '../../context/OxyContext';
-import type { SecurityActivity, SecurityEventType } from '@oxyhq/core';
+import type { SecurityActivity, SecurityActivityResponse, SecurityEventType } from '@oxyhq/core';
 
 /**
  * Get user's security activity with pagination
@@ -62,3 +62,43 @@ export const useRecentSecurityActivity = (limit = 10) => {
   });
 };
 
+/**
+ * Get user's security activity with infinite pagination.
+ * Each page returns up to `limit` events; `getNextPageParam` walks the
+ * `offset` cursor until the API reports `hasMore: false`.
+ */
+export const useInfiniteSecurityActivity = (
+  options?: {
+    limit?: number;
+    eventType?: SecurityEventType;
+    enabled?: boolean;
+  }
+) => {
+  const { oxyServices, activeSessionId } = useOxy();
+  const limit = options?.limit ?? 30;
+
+  return useInfiniteQuery<SecurityActivityResponse, Error>({
+    queryKey: queryKeys.security.infinite(limit, options?.eventType),
+    queryFn: async ({ pageParam }) => {
+      if (!activeSessionId) {
+        throw new Error('No active session');
+      }
+
+      const offset = typeof pageParam === 'number' ? pageParam : 0;
+      return await oxyServices.getSecurityActivity(
+        limit,
+        offset,
+        options?.eventType
+      );
+    },
+    initialPageParam: 0,
+    getNextPageParam: (lastPage) => {
+      if (!lastPage.hasMore) return undefined;
+      return lastPage.offset + lastPage.limit;
+    },
+    enabled: (options?.enabled !== false) && !!activeSessionId,
+    staleTime: 5 * 60 * 1000, // 5 minutes
+    gcTime: 10 * 60 * 1000, // 10 minutes
+  });
+};
+

package/src/ui/hooks/queryClient.ts

@@ -1,74 +1,115 @@
-import { QueryClient } from '@tanstack/react-query';
+/**
+ * Offline-first QueryClient with cross-restart persistence.
+ *
+ * Wires together:
+ * - TanStack Query with `networkMode: 'offlineFirst'` for queries and mutations
+ *   so cached data is served immediately and mutations are queued (paused) while
+ *   the browser/device reports offline.
+ * - `persistQueryClient(...)` from `@tanstack/react-query-persist-client` so that
+ *   query results AND paused mutations survive a cold restart (kill-and-relaunch).
+ * - `onlineManager` resume hook so paused mutations replay the moment the
+ *   network is reported back, even if the host app swapped in a custom
+ *   onlineManager implementation.
+ *
+ * Storage layer:
+ * - React Native -> AsyncStorage via `createAsyncStoragePersister`.
+ * - Web -> localStorage via `createSyncStoragePersister` (wrapped in the
+ *   async persister API for a single call site).
+ * - Both adapters are content-shape compatible with our `StorageInterface`.
+ *
+ * Whitelist policy:
+ * - Persist every account/user/session/privacy query and every queued mutation.
+ * - DO NOT persist large list queries (e.g. activity feeds) — they go stale
+ *   fast and would balloon storage. Add new keys to `PERSISTED_QUERY_PREFIXES`
+ *   when introducing reads that should survive restart.
+ */
+
+import { QueryClient, onlineManager, type Query, type Mutation } from '@tanstack/react-query';
+import {
+  persistQueryClient,
+  type PersistedClient,
+} from '@tanstack/react-query-persist-client';
+import { createAsyncStoragePersister } from '@tanstack/query-async-storage-persister';
 import { isDev } from '@oxyhq/core';
 import type { StorageInterface } from '../utils/storageHelpers';
 
-const QUERY_CACHE_KEY = 'oxy_query_cache';
-const QUERY_CACHE_VERSION = '1';
+const QUERY_CACHE_KEY = 'oxy_query_cache_v2';
+const QUERY_CACHE_MAX_AGE = 30 * 24 * 60 * 60 * 1000; // 30 days
+const QUERY_PERSIST_THROTTLE_MS = 1_000;
+
+/**
+ * Query-key prefixes that should survive cold restart. Anything not listed
+ * is dropped during dehydration so the persisted blob stays small.
+ *
+ * Mutations are persisted independently (always) so the offline write queue
+ * works regardless of the read whitelist.
+ */
+const PERSISTED_QUERY_PREFIXES: ReadonlyArray<string> = [
+  'accounts',
+  'users',
+  'sessions',
+  'devices',
+  'privacy',
+];
 
 /**
- * Custom persistence adapter for TanStack Query using our StorageInterface
+ * Adapt our `StorageInterface` (which always returns `null` for missing keys)
+ * to TanStack's `AsyncStorage` shape. The two are structurally identical
+ * apart from naming; this also gives us a single place to add error
+ * suppression if a host platform's storage throws.
  */
-export const createPersistenceAdapter = (storage: StorageInterface) => {
+function adaptStorage(storage: StorageInterface): {
+  getItem: (key: string) => Promise<string | null>;
+  setItem: (key: string, value: string) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+} {
   return {
-    persistClient: async (client: any) => {
-      try {
-        const serialized = JSON.stringify({
-          clientState: client,
-          timestamp: Date.now(),
-          version: QUERY_CACHE_VERSION,
-        });
-        await storage.setItem(QUERY_CACHE_KEY, serialized);
-      } catch (error) {
-        if (isDev()) {
-          console.warn('[QueryClient] Failed to persist cache:', error);
-        }
-      }
-    },
-    restoreClient: async () => {
-      try {
-        const cached = await storage.getItem(QUERY_CACHE_KEY);
-        if (!cached) return undefined;
-
-        const parsed = JSON.parse(cached);
-        
-        // Check version compatibility
-        if (parsed.version !== QUERY_CACHE_VERSION) {
-          // Clear old cache on version mismatch
-          await storage.removeItem(QUERY_CACHE_KEY);
-          return undefined;
-        }
+    getItem: (key) => storage.getItem(key),
+    setItem: (key, value) => storage.setItem(key, value),
+    removeItem: (key) => storage.removeItem(key),
+  };
+}
 
-        // Check if cache is too old (30 days)
-        const maxAge = 30 * 24 * 60 * 60 * 1000;
-        if (parsed.timestamp && Date.now() - parsed.timestamp > maxAge) {
-          await storage.removeItem(QUERY_CACHE_KEY);
-          return undefined;
-        }
+/**
+ * Decide whether a given query should be written to persistent storage.
+ *
+ * Two gates:
+ * 1. The query must be in our prefix whitelist.
+ * 2. The query must have completed successfully at least once — there's no
+ *    point persisting a `pending`/`error` state, and persisting `error` would
+ *    leak failure objects across restarts.
+ */
+function shouldDehydrateQuery(query: Query): boolean {
+  if (query.state.status !== 'success') {
+    return false;
+  }
+  const head = query.queryKey[0];
+  if (typeof head !== 'string') {
+    return false;
+  }
+  return PERSISTED_QUERY_PREFIXES.includes(head);
+}
 
-        return parsed.clientState;
-      } catch (error) {
-        if (isDev()) {
-          console.warn('[QueryClient] Failed to restore cache:', error);
-        }
-        return undefined;
-      }
-    },
-    removeClient: async () => {
-      try {
-        await storage.removeItem(QUERY_CACHE_KEY);
-      } catch (error) {
-        if (isDev()) {
-          console.warn('[QueryClient] Failed to remove cache:', error);
-        }
-      }
-    },
-  };
-};
+/**
+ * Persist every mutation regardless of status — paused mutations are
+ * exactly the ones that must survive restart to replay when online.
+ */
+function shouldDehydrateMutation(_mutation: Mutation): boolean {
+  return true;
+}
 
 /**
- * Create a QueryClient with offline-first configuration
+ * Create a QueryClient with offline-first defaults.
+ *
+ * Mutations marked with `networkMode: 'offlineFirst'` are queued by TanStack
+ * Query when offline (status "paused") and resumed automatically when
+ * `onlineManager` transitions back to online. Network monitoring wiring lives
+ * in `OxyProvider.tsx`.
+ *
+ * Persistence is attached separately via `attachQueryPersistence(...)`.
+ * Splitting the steps lets test/SSR callers create a stateless client.
  */
-export const createQueryClient = (storage?: StorageInterface | null): QueryClient => {
+export const createQueryClient = (): QueryClient => {
   const client = new QueryClient({
     defaultOptions: {
       queries: {
@@ -79,35 +120,119 @@ export const createQueryClient = (storage?: StorageInterface | null): QueryClien
         // Retry 3 times with exponential backoff
         retry: 3,
         retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
-        // Refetch on reconnect
+        // Refetch on reconnect so stale data is refreshed once online again.
         refetchOnReconnect: true,
         // Don't refetch on window focus (better for mobile)
         refetchOnWindowFocus: false,
-        // Offline-first: use cache when offline
+        // Offline-first: serve cached data immediately, refetch in background.
         networkMode: 'offlineFirst',
       },
       mutations: {
         // Retry once for mutations
         retry: 1,
-        // Offline-first: queue mutations when offline
+        // Offline-first: pause and queue mutations when offline.
         networkMode: 'offlineFirst',
       },
     },
   });
 
-  // Note: Persistence is handled by TanStack Query's built-in persistence
-  // For now, we rely on the query client's default behavior with networkMode: 'offlineFirst'
-  // The cache will be available in memory and queries will use cached data when offline
-  // Full persistence to AsyncStorage can be added later with @tanstack/react-query-persist-client if needed
+  // Defensive: explicitly resume paused mutations whenever the network
+  // transitions back to online. TanStack Query does this internally too,
+  // but wiring it here keeps the behaviour robust if a custom onlineManager
+  // implementation is swapped in by the host app.
+  const unsubscribe = onlineManager.subscribe((isOnline) => {
+    if (isOnline) {
+      void client.getMutationCache().resumePausedMutations();
+    }
+  });
+
+  Object.defineProperty(client, '__oxyOnlineUnsubscribe', {
+    value: unsubscribe,
+    enumerable: false,
+    configurable: true,
+    writable: false,
+  });
 
   return client;
 };
 
+export interface AttachPersistenceResult {
+  /** Promise that resolves once the persisted cache has been restored. */
+  restored: Promise<void>;
+  /** Detach the persistence subscription (tests + teardown). */
+  unsubscribe: () => void;
+}
+
+/**
+ * Wire `persistQueryClient` to the supplied storage adapter.
+ *
+ * Returns once the in-flight restore promise is available so callers can
+ * `await result.restored` before rendering UI that depends on cached data.
+ *
+ * Safe to no-op if `storage` is null/undefined (e.g. server-side render
+ * with no host storage).
+ */
+export const attachQueryPersistence = (
+  queryClient: QueryClient,
+  storage: StorageInterface | null | undefined,
+): AttachPersistenceResult => {
+  if (!storage) {
+    return {
+      restored: Promise.resolve(),
+      unsubscribe: () => {},
+    };
+  }
+
+  const persister = createAsyncStoragePersister({
+    storage: adaptStorage(storage),
+    key: QUERY_CACHE_KEY,
+    throttleTime: QUERY_PERSIST_THROTTLE_MS,
+  });
+
+  const [unsubscribe, restored] = persistQueryClient({
+    queryClient,
+    persister,
+    maxAge: QUERY_CACHE_MAX_AGE,
+    dehydrateOptions: {
+      shouldDehydrateQuery,
+      shouldDehydrateMutation,
+    },
+  });
+
+  restored.catch((error) => {
+    if (isDev()) {
+      console.warn('[QueryClient] Failed to restore persisted cache', error);
+    }
+  });
+
+  return { unsubscribe, restored };
+};
+
+// Legacy v1 cache key — kept so we can opportunistically purge stale blobs
+// written by older builds. Safe to drop after a few releases.
+const LEGACY_QUERY_CACHE_KEYS: ReadonlyArray<string> = ['oxy_query_cache'];
+
 /**
- * Clear persisted query cache
+ * Remove the persisted query+mutation cache (used on full sign-out / data
+ * reset). Safe to call even if persistence was never attached. Also clears
+ * legacy cache keys from older builds.
  */
 export const clearQueryCache = async (storage: StorageInterface): Promise<void> => {
-  const adapter = createPersistenceAdapter(storage);
-  await adapter.removeClient();
+  const keys = [QUERY_CACHE_KEY, ...LEGACY_QUERY_CACHE_KEYS];
+  await Promise.all(
+    keys.map(async (key) => {
+      try {
+        await storage.removeItem(key);
+      } catch (error) {
+        if (isDev()) {
+          console.warn(`[QueryClient] Failed to clear persisted query cache (${key})`, error);
+        }
+      }
+    }),
+  );
 };
 
+/**
+ * Re-export the persisted client shape so callers can type custom persisters.
+ */
+export type { PersistedClient };

package/src/ui/hooks/useAsyncAction.ts

@@ -1,5 +1,5 @@
 import { useState, useCallback } from 'react';
-import { toast } from '../../lib/sonner';
+import { toast } from '@oxyhq/bloom';
 
 interface UseAsyncActionOptions<T> {
     /** Function to execute */
@@ -63,7 +63,7 @@ export function useAsyncAction<T = void>(
         setError(null);
 
         if (showLoadingToast && loadingMessage) {
-            toast.loading(loadingMessage);
+            toast.info(loadingMessage);
         }
 
         try {
@@ -111,7 +111,7 @@ export async function executeWithToast<T>(
     const { successMessage, errorMessage, loadingMessage } = options || {};
 
     if (loadingMessage) {
-        toast.loading(loadingMessage);
+        toast.info(loadingMessage);
     }
 
     try {

package/src/ui/hooks/useAuth.ts

@@ -215,5 +215,3 @@ export function useAuth(): UseAuthReturn {
   };
 }
 
-// Re-export useOxy for backward compatibility and advanced usage
-export { useOxy } from '../context/OxyContext';

package/src/ui/hooks/useAvatarPicker.ts

@@ -2,18 +2,26 @@
  * Avatar Picker Hook
  *
  * Extracts avatar selection logic from OxyContext for better modularity.
- * Opens the FileManagement bottom sheet in select mode for image files,
- * then updates the user's profile avatar.
+ *
+ * Flow:
+ *   1. Open the FileManagement bottom sheet in select mode for image files.
+ *   2. After the user picks an image, route to the AvatarCrop screen so they
+ *      can square-crop + zoom before the avatar is set.
+ *   3. The cropped JPEG is uploaded as a NEW file via `oxyServices.assetUpload`
+ *      and that file becomes the user's avatar.
+ *
+ * `expo-image-manipulator` is required for the crop step (declared as an
+ * optional peer in the consuming app) — see AvatarCropScreen.
  */
 
 import { useCallback } from 'react';
-import type { OxyServices } from '@oxyhq/core';
-import { translate } from '@oxyhq/core';
+import type { FileMetadata, OxyServices } from '@oxyhq/core';
+import { translate, updateAvatarVisibility } from '@oxyhq/core';
 import type { QueryClient } from '@tanstack/react-query';
-import { toast } from '../../lib/sonner';
+import { toast } from '@oxyhq/bloom';
 import type { RouteName } from '../navigation/routes';
-import { updateAvatarVisibility } from '@oxyhq/core';
 import { updateProfileWithAvatar } from '../utils/avatarUtils';
+import type { AvatarCropResult } from '../screens/AvatarCropScreen';
 
 interface UseAvatarPickerOptions {
   oxyServices: OxyServices;
@@ -23,6 +31,22 @@ interface UseAvatarPickerOptions {
   showBottomSheet: (config: { screen: RouteName; props?: Record<string, unknown> }) => void;
 }
 
+/** Upload result shape returned by oxyServices.assetUpload (single-file path). */
+interface AssetUploadResult {
+  file?: { id?: string };
+  files?: Array<{ id?: string }>;
+  id?: string;
+}
+
+function extractUploadedFileId(result: AssetUploadResult | undefined): string | undefined {
+  if (!result) return undefined;
+  if (typeof result.id === 'string') return result.id;
+  if (result.file?.id) return result.file.id;
+  const first = result.files?.[0];
+  if (first?.id) return first.id;
+  return undefined;
+}
+
 export function useAvatarPicker({
   oxyServices,
   currentLanguage,
@@ -30,36 +54,93 @@ export function useAvatarPicker({
   queryClient,
   showBottomSheet,
 }: UseAvatarPickerOptions) {
+  /**
+   * Final step: take the cropped JPEG, upload it as a new public file, then
+   * set it as the user's avatar. Fires success/error toasts.
+   */
+  const finalizeCroppedAvatar = useCallback(
+    async (cropped: AvatarCropResult) => {
+      try {
+        const uploadResult = (await oxyServices.assetUpload(
+          {
+            uri: cropped.uri,
+            type: cropped.mime,
+            name: `avatar-${Date.now()}.jpg`,
+          },
+          'public',
+        )) as AssetUploadResult;
+
+        const newFileId = extractUploadedFileId(uploadResult);
+        if (!newFileId) {
+          throw new Error('Avatar upload succeeded but no file ID was returned');
+        }
+
+        await updateAvatarVisibility(newFileId, oxyServices, 'useAvatarPicker');
+        await updateProfileWithAvatar(
+          { avatar: newFileId },
+          oxyServices,
+          activeSessionId,
+          queryClient,
+        );
+
+        toast.success(
+          translate(currentLanguage ?? undefined, 'editProfile.toasts.avatarUpdated') ||
+            'Avatar updated',
+        );
+      } catch (e: unknown) {
+        const message = e instanceof Error ? e.message : undefined;
+        toast.error(
+          message ||
+            translate(currentLanguage ?? undefined, 'editProfile.toasts.updateAvatarFailed') ||
+            'Failed to update avatar',
+        );
+      }
+    },
+    [activeSessionId, currentLanguage, oxyServices, queryClient],
+  );
+
+  /**
+   * After the user picks a file in the FileManagement sheet, route to the
+   * crop screen with the file's download URL as the source image.
+   */
+  const handleFilePicked = useCallback(
+    (file: FileMetadata) => {
+      if (!file.contentType?.startsWith('image/')) {
+        toast.error(
+          translate(currentLanguage ?? undefined, 'editProfile.toasts.selectImage') ||
+            'Please select an image file',
+        );
+        return;
+      }
+
+      // Use the public download URL of the picked file as the crop source.
+      // The OxyServices file URL endpoints accept image variants, but for
+      // cropping we want the original — passing no variant returns it.
+      const sourceUri = oxyServices.getFileDownloadUrl(file.id);
+
+      showBottomSheet({
+        screen: 'AvatarCrop',
+        props: {
+          imageUri: sourceUri,
+          onConfirm: finalizeCroppedAvatar,
+        },
+      });
+    },
+    [currentLanguage, finalizeCroppedAvatar, oxyServices, showBottomSheet],
+  );
+
   const openAvatarPicker = useCallback(() => {
     showBottomSheet({
-      screen: 'FileManagement' as RouteName,
+      screen: 'FileManagement',
       props: {
         selectMode: true,
         multiSelect: false,
         disabledMimeTypes: ['video/', 'audio/', 'application/pdf'],
         afterSelect: 'none',
-        onSelect: async (file: any) => {
-          if (!file.contentType.startsWith('image/')) {
-            toast.error(translate(currentLanguage ?? undefined, 'editProfile.toasts.selectImage') || 'Please select an image file');
-            return;
-          }
-          try {
-            await updateAvatarVisibility(file.id, oxyServices, 'OxyContext');
-            await updateProfileWithAvatar(
-              { avatar: file.id },
-              oxyServices,
-              activeSessionId,
-              queryClient
-            );
-            toast.success(translate(currentLanguage ?? undefined, 'editProfile.toasts.avatarUpdated') || 'Avatar updated');
-          } catch (e: unknown) {
-            const message = e instanceof Error ? e.message : undefined;
-            toast.error(message || translate(currentLanguage ?? undefined, 'editProfile.toasts.updateAvatarFailed') || 'Failed to update avatar');
-          }
-        },
+        onSelect: handleFilePicked,
       },
     });
-  }, [oxyServices, currentLanguage, showBottomSheet, activeSessionId, queryClient]);
+  }, [handleFilePicked, showBottomSheet]);
 
   return { openAvatarPicker };
 }

package/src/ui/hooks/useFileDownloadUrl.ts

@@ -1,11 +1,5 @@
 import { useEffect, useState } from 'react';
-import { OxyServices } from '@oxyhq/core';
-
-let oxyInstance: OxyServices | null = null;
-
-export const setOxyFileUrlInstance = (instance: OxyServices) => {
-  oxyInstance = instance;
-};
+import type { OxyServices } from '@oxyhq/core';
 
 export interface UseFileDownloadUrlOptions {
   variant?: string;
@@ -21,38 +15,21 @@ export interface UseFileDownloadUrlResult {
 /**
  * Hook to resolve a file's download URL asynchronously.
  *
- * Prefers the provided `oxyServices` instance, falls back to the module-level
- * singleton set via `setOxyFileUrlInstance`.
- *
  * Uses `getFileDownloadUrlAsync` first, falling back to the synchronous
  * `getFileDownloadUrl` if the async call fails.
  */
 export const useFileDownloadUrl = (
-  fileIdOrServices?: string | OxyServices | null,
-  fileIdOrOptions?: string | UseFileDownloadUrlOptions | null,
-  maybeOptions?: UseFileDownloadUrlOptions
+  oxyServices: OxyServices | null | undefined,
+  fileId: string | null | undefined,
+  options?: UseFileDownloadUrlOptions,
 ): UseFileDownloadUrlResult => {
-  // Support two call signatures:
-  // 1. useFileDownloadUrl(oxyServices, fileId, options)  — preferred
-  // 2. useFileDownloadUrl(fileId, options)               — legacy (uses singleton)
-  let services: OxyServices | null;
-  let fileId: string | null | undefined;
-  let options: UseFileDownloadUrlOptions | undefined;
-
-  if (fileIdOrServices instanceof OxyServices) {
-    services = fileIdOrServices;
-    fileId = typeof fileIdOrOptions === 'string' ? fileIdOrOptions : null;
-    options = maybeOptions;
-  } else {
-    services = oxyInstance;
-    fileId = typeof fileIdOrServices === 'string' ? fileIdOrServices : null;
-    options = typeof fileIdOrOptions === 'object' && fileIdOrOptions !== null ? fileIdOrOptions as UseFileDownloadUrlOptions : undefined;
-  }
-
   const [url, setUrl] = useState<string | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
 
+  const variant = options?.variant;
+  const expiresIn = options?.expiresIn;
+
   useEffect(() => {
     if (!fileId) {
       setUrl(null);
@@ -61,7 +38,7 @@ export const useFileDownloadUrl = (
       return;
     }
 
-    if (!services) {
+    if (!oxyServices) {
       setUrl(null);
       setLoading(false);
       setError(new Error('OxyServices instance not configured for useFileDownloadUrl'));
@@ -69,22 +46,22 @@ export const useFileDownloadUrl = (
     }
 
     let cancelled = false;
-    const instance = services;
+    const instance = oxyServices;
+    const targetFileId = fileId;
 
     const load = async () => {
       setLoading(true);
       setError(null);
 
       try {
-        const { variant, expiresIn } = options || {};
         let resolvedUrl: string | null = null;
 
         if (typeof instance.getFileDownloadUrlAsync === 'function') {
-          resolvedUrl = await instance.getFileDownloadUrlAsync(fileId!, variant, expiresIn);
+          resolvedUrl = await instance.getFileDownloadUrlAsync(targetFileId, variant, expiresIn);
         }
 
         if (!resolvedUrl && typeof instance.getFileDownloadUrl === 'function') {
-          resolvedUrl = instance.getFileDownloadUrl(fileId!, variant, expiresIn);
+          resolvedUrl = instance.getFileDownloadUrl(targetFileId, variant, expiresIn);
         }
 
         if (!cancelled) {
@@ -94,8 +71,7 @@ export const useFileDownloadUrl = (
         // Fallback to sync URL on error where possible
         try {
           if (typeof instance.getFileDownloadUrl === 'function') {
-            const { variant, expiresIn } = options || {};
-            const fallbackUrl = instance.getFileDownloadUrl(fileId!, variant, expiresIn);
+            const fallbackUrl = instance.getFileDownloadUrl(targetFileId, variant, expiresIn);
             if (!cancelled) {
               setUrl(fallbackUrl || null);
               setError(err instanceof Error ? err : new Error(String(err)));
@@ -103,7 +79,7 @@ export const useFileDownloadUrl = (
             return;
           }
         } catch {
-          // ignore secondary failure
+          // Secondary failure: surface the original error below.
         }
 
         if (!cancelled) {
@@ -121,7 +97,7 @@ export const useFileDownloadUrl = (
     return () => {
       cancelled = true;
     };
-  }, [fileId, services, options?.variant, options?.expiresIn]);
+  }, [fileId, oxyServices, variant, expiresIn]);
 
   return { url, loading, error };
 };