@rific/updater 0.3.1 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # @rific/updater
 
-OTA update hook for Expo apps. Checks for updates in the background when the app is foregrounded and prompts to restart as soon as one's found, and exposes a manual `check()` for settings screens. No surprise restarts — the user always confirms before the app reloads.
+OTA update hook for Expo apps. Checks for updates on launch and again whenever the app is foregrounded, prompting to restart as soon as one's found, and exposes a manual `check()` for settings screens. No surprise restarts — the user always confirms before the app reloads.
 
 ---
 
@@ -55,13 +55,23 @@ const { check, checking } = useUpdater({
 })
 ```
 
-### Disable automatic foreground check entirely
+### With custom info alerts
+
+```tsx
+const { check, checking } = useUpdater({
+  onInfo: (title, message) => myInfoDialog(title, message),
+})
+```
+
+Covers `check()`'s three purely-informational cases — dev-mode disabled, web unsupported, and "you're already up to date" — none of which need a confirm/cancel choice, just something to acknowledge. Defaults to `Alert.alert` like `onError`.
+
+### Disable automatic mount/foreground checks entirely
 
 ```tsx
 const { check, checking } = useUpdater({ autoCheck: false })
 ```
 
-Fully manual — no `AppState` listener at all, `check()` always fetches fresh. `autoPrompt` is irrelevant here.
+Fully manual — no mount-time fetch, no `AppState` listener, `check()` always fetches fresh. `autoPrompt` is irrelevant here.
 
 ### Silent background staging only (no auto-prompt)
 
@@ -69,7 +79,7 @@ Fully manual — no `AppState` listener at all, `check()` always fetches fresh.
 const { check, checking, updateReady } = useUpdater({ autoPrompt: false })
 ```
 
-Foreground fetches still run and stage the update (`updateReady` flips `true`), but the confirm dialog only shows up via a manual `check()` — same as the settings-screen example above. Good for games or anything where you don't want a dialog interrupting the user; the staged bundle still applies on the next cold launch even if `check()` is never called.
+Mount and foreground fetches still run and stage the update (`updateReady` flips `true`), but the confirm dialog only shows up via a manual `check()` — same as the settings-screen example above. Good for games or anything where you don't want a dialog interrupting the user.
 
 ---
 
@@ -83,6 +93,7 @@ interface UseUpdaterOptions {
   autoPrompt?: boolean                                   // default: true
   onConfirm?: (manifest: UpdateManifest) => Promise<boolean>
   onError?: (message: string) => void
+  onInfo?: (title: string, message: string) => void
 }
 
 interface UseUpdaterReturn {
@@ -94,10 +105,11 @@ interface UseUpdaterReturn {
 
 | Option | Default | Description |
 |--------|---------|-------------|
-| `autoCheck` | `true` | Registers an `AppState` listener that fetches available updates whenever the app comes to the foreground. Disable for apps that want full manual control. |
-| `autoPrompt` | `true` | When a foreground `autoCheck` fetch finds an update, run the confirmation dialog (and reload on confirm) immediately. Set `false` to fall back to the old behavior — silently stage it for a manual `check()` or the next cold launch instead. Ignored if `autoCheck` is `false`. A manual `check()` call and an auto-prompt won't run concurrently — whichever is in flight blocks the other. |
-| `onConfirm` | — | Custom confirmation dialog. Receives the update manifest, must return `Promise<boolean>` — `true` to reload, `false` to cancel. Defaults to a native `Alert` showing the release date and metadata message. |
+| `autoCheck` | `true` | Fetches available updates once on mount and again via an `AppState` listener whenever the app comes to the foreground. Disable for apps that want full manual control. |
+| `autoPrompt` | `true` | When a mount or foreground `autoCheck` fetch finds an update, run the confirmation dialog (and reload on confirm) immediately. Set `false` to fall back to the old behavior — silently stage it for a manual `check()` or the next cold launch instead. Ignored if `autoCheck` is `false`. A manual `check()` call and an auto-prompt won't run concurrently — whichever is in flight blocks the other. |
+| `onConfirm` | — | Custom confirmation dialog. Receives the update manifest, must return `Promise<boolean>` — `true` to reload, `false` to cancel. Defaults to a native `Alert` showing the release date. |
 | `onError` | — | Called with an error message string if `check()` throws. Defaults to `Alert.alert`. |
+| `onInfo` | — | Called with `(title, message)` for `check()`'s purely-informational cases (dev-mode disabled, web unsupported, no update found) — no confirm/cancel choice, just an acknowledgeable message. Defaults to `Alert.alert`. |
 
 | Return | Description |
 |--------|-------------|
@@ -109,7 +121,7 @@ interface UseUpdaterReturn {
 
 ## How updates work
 
-**Automatic (foreground):** When `autoCheck` is `true`, the hook registers an `AppState` listener. Each time the app returns from background/inactive to active, it calls `checkForUpdateAsync()` + `fetchUpdateAsync()`. By default (`autoPrompt: true`) a found update goes straight into the confirmation dialog and `reloadAsync()` on confirm — no tap required. With `autoPrompt: false`, the downloaded bundle just sits on disk instead — no prompt, no restart — until a manual `check()` or the **next cold launch**, which automatically runs it.
+**Automatic (mount + foreground):** When `autoCheck` is `true`, the hook fetches once on mount (covering cold launch) and also registers an `AppState` listener that re-fetches each time the app returns from background/inactive to active. Both paths call `checkForUpdateAsync()` + `fetchUpdateAsync()` and share the same confirm/reload flow. By default (`autoPrompt: true`) a found update goes straight into the confirmation dialog and `reloadAsync()` on confirm — no tap required. With `autoPrompt: false`, the downloaded bundle just sits on disk instead — no prompt, no restart — until a manual `check()` is called.
 
 **Manual (`check()`):** Runs the full flow — check (or reuse staged manifest) → confirmation dialog → `reloadAsync()`. The user sees what was released and chooses whether to restart now.
 
@@ -158,6 +170,7 @@ The path argument defaults to `src/constants/release.ts` if omitted.
 - `autoPrompt`'s foreground flow shares that same `checkingRef` guard with `check()`, so a manual check and an auto-prompt can't both be mid-confirm at once
 - `updateReady` and the staged manifest ref are cleared in `finally` so they reset on both confirm and cancel
 - `onConfirm` replaces the default `Alert` entirely — useful in apps that have their own dialog primitive (e.g. a `select()` utility or bottom sheet)
+- `onInfo` is the same idea for `check()`'s three non-choice messages (dev-mode disabled, web unsupported, no update found) — separate from `onConfirm` because there's nothing to confirm, just something to show
 - No Provider or context required — the hook is self-contained
 
 ---
@@ -165,11 +178,13 @@ The path argument defaults to `src/constants/release.ts` if omitted.
 ## Consuming apps
 
 > **0.3.0 changed the default:** `autoPrompt` now defaults to `true`, so a bare `useUpdater()` prompts on its own the moment a foreground fetch finds something — it no longer just stages silently for next launch. Every app below was written against the old silent-by-default behavior; pass `autoPrompt: false` explicitly if that's still what you want (this is what Lumber's and CashierFu-Utility's manual-check hooks already do via `autoCheck: false`, so they're unaffected — it's the bare root-layout `useUpdater()` calls and the games that actually change behavior on upgrade).
+>
+> **Next release adds a mount-time check:** `autoCheck` now also fetches once on mount, in addition to the existing foreground `AppState` listener — covering cold launch, which previously only got an update via native `expo-updates` (`checkAutomatically`), silently and outside this hook's confirm/reload flow. Any app with a bare root-layout `useUpdater()` (default `autoPrompt: true`) will now show the confirm dialog on cold launch too, not just on foreground return.
 
 - **Lumber** (`../Lumber`) — account screen, shows version + update badge. Root layout's bare `useUpdater()` will start auto-prompting on upgrade unless changed.
 - **CashierFu-Utility** (`../CashierFu-Utility`) — settings modal, uses `@rific/toaster` for `onError`. Same root-layout caveat as Lumber.
 - **Swirlio** (`../Swirlio`) — top sheet; now just relies on the `autoPrompt` default rather than passing it explicitly.
-- Games (Setter, Hangman, Crumby, HexFleet, etc.) — call `useUpdater()` with no options, relying on the old silent-only default. Will start prompting on foreground return (not during active play — the listener only fires on a background→active transition) unless given `autoPrompt: false`.
+- Games (Setter, Hangman, Crumby, HexFleet, etc.) — call `useUpdater()` with no options, relying on the old silent-only default. Will start prompting on cold launch and on foreground return (not during active play — the listener only fires on a background→active transition) unless given `autoPrompt: false`.
 
 ### Local development (yalc)
 

package/dist/index.d.mts

@@ -1,6 +1,5 @@
 interface UpdateManifest {
     createdAt: string;
-    metadata?: Record<string, string | undefined>;
 }
 
 interface UseUpdaterOptions {
@@ -8,6 +7,7 @@ interface UseUpdaterOptions {
     autoPrompt?: boolean;
     onConfirm?: (manifest: UpdateManifest) => Promise<boolean>;
     onError?: (message: string) => void;
+    onInfo?: (title: string, message: string) => void;
 }
 interface UseUpdaterReturn {
     check: () => Promise<void>;

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 interface UpdateManifest {
     createdAt: string;
-    metadata?: Record<string, string | undefined>;
 }
 
 interface UseUpdaterOptions {
@@ -8,6 +7,7 @@ interface UseUpdaterOptions {
     autoPrompt?: boolean;
     onConfirm?: (manifest: UpdateManifest) => Promise<boolean>;
     onError?: (message: string) => void;
+    onInfo?: (title: string, message: string) => void;
 }
 interface UseUpdaterReturn {
     check: () => Promise<void>;

package/dist/index.js

@@ -42,11 +42,9 @@ var checkForUpdate = async () => {
 var import_react_native = require("react-native");
 var getUpdateConfirmation = (manifest) => {
   const date = new Date(manifest.createdAt);
-  let info = `A new update was released on ${date.toLocaleDateString()} at ${date.toLocaleTimeString()}.`;
-  if (manifest.metadata?.message) info += `
+  const info = `A new update was released on ${date.toLocaleDateString()} at ${date.toLocaleTimeString()}.
 
-Message: ${manifest.metadata.message}.`;
-  info += "\n\nRestart app to update.";
+Restart app to update.`;
   return new Promise((resolve) => {
     import_react_native.Alert.alert("Update available", info, [
       { text: "Cancel", style: "cancel", onPress: () => resolve(false) },
@@ -58,43 +56,54 @@ Message: ${manifest.metadata.message}.`;
 // src/useUpdater.ts
 var isUnsupported = () => __DEV__ || import_react_native2.Platform.OS === "web";
 var useUpdater = (options = {}) => {
-  const { autoCheck = true, autoPrompt = true, onConfirm, onError } = options;
+  const { autoCheck = true, autoPrompt = true, onConfirm, onError, onInfo } = options;
   const [checking, setChecking] = (0, import_react.useState)(false);
   const [updateReady, setUpdateReady] = (0, import_react.useState)(false);
   const checkingRef = (0, import_react.useRef)(false);
+  const autoCheckPendingRef = (0, import_react.useRef)(false);
   const appState = (0, import_react.useRef)(import_react_native2.AppState.currentState);
   const stagedManifest = (0, import_react.useRef)(null);
   const onConfirmRef = (0, import_react.useRef)(onConfirm);
   const onErrorRef = (0, import_react.useRef)(onError);
-  onConfirmRef.current = onConfirm;
-  onErrorRef.current = onError;
+  (0, import_react.useEffect)(() => {
+    onConfirmRef.current = onConfirm;
+    onErrorRef.current = onError;
+  });
   (0, import_react.useEffect)(() => {
     if (!autoCheck || isUnsupported()) return;
+    const runAutoCheck = () => {
+      if (autoCheckPendingRef.current) return;
+      autoCheckPendingRef.current = true;
+      checkForUpdate().then(async (manifest) => {
+        if (!manifest) return;
+        stagedManifest.current = manifest;
+        setUpdateReady(true);
+        if (!autoPrompt || checkingRef.current) return;
+        checkingRef.current = true;
+        setChecking(true);
+        try {
+          const confirmFn = onConfirmRef.current ?? getUpdateConfirmation;
+          const confirmed = await confirmFn(manifest);
+          if (confirmed) await (0, import_expo_updates2.reloadAsync)();
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Could not check for updates.";
+          if (onErrorRef.current) onErrorRef.current(message);
+          else import_react_native2.Alert.alert("Update error", message);
+        } finally {
+          stagedManifest.current = null;
+          setUpdateReady(false);
+          checkingRef.current = false;
+          setChecking(false);
+        }
+      }).catch(() => {
+      }).finally(() => {
+        autoCheckPendingRef.current = false;
+      });
+    };
+    runAutoCheck();
     const subscription = import_react_native2.AppState.addEventListener("change", (nextState) => {
       if (/inactive|background/.test(appState.current) && nextState === "active") {
-        checkForUpdate().then(async (manifest) => {
-          if (!manifest) return;
-          stagedManifest.current = manifest;
-          setUpdateReady(true);
-          if (!autoPrompt || checkingRef.current) return;
-          checkingRef.current = true;
-          setChecking(true);
-          try {
-            const confirmFn = onConfirmRef.current ?? getUpdateConfirmation;
-            const confirmed = await confirmFn(manifest);
-            if (confirmed) await (0, import_expo_updates2.reloadAsync)();
-          } catch (err) {
-            const message = err instanceof Error ? err.message : "Could not check for updates.";
-            if (onErrorRef.current) onErrorRef.current(message);
-            else import_react_native2.Alert.alert("Update error", message);
-          } finally {
-            stagedManifest.current = null;
-            setUpdateReady(false);
-            checkingRef.current = false;
-            setChecking(false);
-          }
-        }).catch(() => {
-        });
+        runAutoCheck();
       }
       appState.current = nextState;
     });
@@ -102,11 +111,15 @@ var useUpdater = (options = {}) => {
   }, [autoCheck, autoPrompt]);
   const check = async () => {
     if (__DEV__) {
-      import_react_native2.Alert.alert("Updates unavailable", "Update checks are disabled in development mode.");
+      const message = "Update checks are disabled in development mode.";
+      if (onInfo) onInfo("Updates unavailable", message);
+      else import_react_native2.Alert.alert("Updates unavailable", message);
       return;
     }
     if (import_react_native2.Platform.OS === "web") {
-      import_react_native2.Alert.alert("Updates unavailable", "Update checks are not supported on web.");
+      const message = "Update checks are not supported on web.";
+      if (onInfo) onInfo("Updates unavailable", message);
+      else import_react_native2.Alert.alert("Updates unavailable", message);
       return;
     }
     if (checkingRef.current) return;
@@ -115,7 +128,9 @@ var useUpdater = (options = {}) => {
     try {
       const manifest = stagedManifest.current ?? await checkForUpdate();
       if (!manifest) {
-        import_react_native2.Alert.alert("No update", "You are on the most recent version.");
+        const message = "You are on the most recent version.";
+        if (onInfo) onInfo("No update", message);
+        else import_react_native2.Alert.alert("No update", message);
         return;
       }
       const confirmFn = onConfirm ?? getUpdateConfirmation;

package/dist/index.mjs

@@ -16,11 +16,9 @@ var checkForUpdate = async () => {
 import { Alert } from "react-native";
 var getUpdateConfirmation = (manifest) => {
   const date = new Date(manifest.createdAt);
-  let info = `A new update was released on ${date.toLocaleDateString()} at ${date.toLocaleTimeString()}.`;
-  if (manifest.metadata?.message) info += `
+  const info = `A new update was released on ${date.toLocaleDateString()} at ${date.toLocaleTimeString()}.
 
-Message: ${manifest.metadata.message}.`;
-  info += "\n\nRestart app to update.";
+Restart app to update.`;
   return new Promise((resolve) => {
     Alert.alert("Update available", info, [
       { text: "Cancel", style: "cancel", onPress: () => resolve(false) },
@@ -32,43 +30,54 @@ Message: ${manifest.metadata.message}.`;
 // src/useUpdater.ts
 var isUnsupported = () => __DEV__ || Platform.OS === "web";
 var useUpdater = (options = {}) => {
-  const { autoCheck = true, autoPrompt = true, onConfirm, onError } = options;
+  const { autoCheck = true, autoPrompt = true, onConfirm, onError, onInfo } = options;
   const [checking, setChecking] = useState(false);
   const [updateReady, setUpdateReady] = useState(false);
   const checkingRef = useRef(false);
+  const autoCheckPendingRef = useRef(false);
   const appState = useRef(AppState.currentState);
   const stagedManifest = useRef(null);
   const onConfirmRef = useRef(onConfirm);
   const onErrorRef = useRef(onError);
-  onConfirmRef.current = onConfirm;
-  onErrorRef.current = onError;
+  useEffect(() => {
+    onConfirmRef.current = onConfirm;
+    onErrorRef.current = onError;
+  });
   useEffect(() => {
     if (!autoCheck || isUnsupported()) return;
+    const runAutoCheck = () => {
+      if (autoCheckPendingRef.current) return;
+      autoCheckPendingRef.current = true;
+      checkForUpdate().then(async (manifest) => {
+        if (!manifest) return;
+        stagedManifest.current = manifest;
+        setUpdateReady(true);
+        if (!autoPrompt || checkingRef.current) return;
+        checkingRef.current = true;
+        setChecking(true);
+        try {
+          const confirmFn = onConfirmRef.current ?? getUpdateConfirmation;
+          const confirmed = await confirmFn(manifest);
+          if (confirmed) await reloadAsync();
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Could not check for updates.";
+          if (onErrorRef.current) onErrorRef.current(message);
+          else Alert2.alert("Update error", message);
+        } finally {
+          stagedManifest.current = null;
+          setUpdateReady(false);
+          checkingRef.current = false;
+          setChecking(false);
+        }
+      }).catch(() => {
+      }).finally(() => {
+        autoCheckPendingRef.current = false;
+      });
+    };
+    runAutoCheck();
     const subscription = AppState.addEventListener("change", (nextState) => {
       if (/inactive|background/.test(appState.current) && nextState === "active") {
-        checkForUpdate().then(async (manifest) => {
-          if (!manifest) return;
-          stagedManifest.current = manifest;
-          setUpdateReady(true);
-          if (!autoPrompt || checkingRef.current) return;
-          checkingRef.current = true;
-          setChecking(true);
-          try {
-            const confirmFn = onConfirmRef.current ?? getUpdateConfirmation;
-            const confirmed = await confirmFn(manifest);
-            if (confirmed) await reloadAsync();
-          } catch (err) {
-            const message = err instanceof Error ? err.message : "Could not check for updates.";
-            if (onErrorRef.current) onErrorRef.current(message);
-            else Alert2.alert("Update error", message);
-          } finally {
-            stagedManifest.current = null;
-            setUpdateReady(false);
-            checkingRef.current = false;
-            setChecking(false);
-          }
-        }).catch(() => {
-        });
+        runAutoCheck();
       }
       appState.current = nextState;
     });
@@ -76,11 +85,15 @@ var useUpdater = (options = {}) => {
   }, [autoCheck, autoPrompt]);
   const check = async () => {
     if (__DEV__) {
-      Alert2.alert("Updates unavailable", "Update checks are disabled in development mode.");
+      const message = "Update checks are disabled in development mode.";
+      if (onInfo) onInfo("Updates unavailable", message);
+      else Alert2.alert("Updates unavailable", message);
       return;
     }
     if (Platform.OS === "web") {
-      Alert2.alert("Updates unavailable", "Update checks are not supported on web.");
+      const message = "Update checks are not supported on web.";
+      if (onInfo) onInfo("Updates unavailable", message);
+      else Alert2.alert("Updates unavailable", message);
       return;
     }
     if (checkingRef.current) return;
@@ -89,7 +102,9 @@ var useUpdater = (options = {}) => {
     try {
       const manifest = stagedManifest.current ?? await checkForUpdate();
       if (!manifest) {
-        Alert2.alert("No update", "You are on the most recent version.");
+        const message = "You are on the most recent version.";
+        if (onInfo) onInfo("No update", message);
+        else Alert2.alert("No update", message);
         return;
       }
       const confirmFn = onConfirm ?? getUpdateConfirmation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rific/updater",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "OTA update hook for Expo apps. Silent background fetch on foreground, manual check with confirmation dialog",
   "keywords": [
     "expo",
@@ -67,6 +67,7 @@
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-package-json": "^1.0.0",
     "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-react-hooks": "^7.1.1",
     "eslint-plugin-react-native": "^5.0.0",
     "eslint-plugin-simple-import-sort": "^13.0.0",
     "expo-updates": ">=0.25.0",

package/src/getUpdateConfirmation.ts

@@ -4,9 +4,7 @@ import { UpdateManifest } from './types'
 
 export const getUpdateConfirmation = (manifest: UpdateManifest): Promise<boolean> => {
   const date = new Date(manifest.createdAt)
-  let info = `A new update was released on ${date.toLocaleDateString()} at ${date.toLocaleTimeString()}.`
-  if (manifest.metadata?.message) info += `\n\nMessage: ${manifest.metadata.message}.`
-  info += '\n\nRestart app to update.'
+  const info = `A new update was released on ${date.toLocaleDateString()} at ${date.toLocaleTimeString()}.\n\nRestart app to update.`
 
   return new Promise((resolve) => {
     Alert.alert('Update available', info, [

package/src/types.ts

@@ -1,4 +1,3 @@
 export interface UpdateManifest {
   createdAt: string
-  metadata?: Record<string, string | undefined>
 }

package/src/useUpdater.ts

@@ -11,6 +11,11 @@ export interface UseUpdaterOptions {
   autoPrompt?: boolean
   onConfirm?: (manifest: UpdateManifest) => Promise<boolean>
   onError?: (message: string) => void
+  // Purely informational — no confirm/cancel choice, just something to acknowledge. Covers the
+  // three plain Alert.alert calls inside check() below (dev-mode disabled, web unsupported, and
+  // "you're already up to date") — none of them go through onConfirm, since there's no decision
+  // to make.
+  onInfo?: (title: string, message: string) => void
 }
 
 export interface UseUpdaterReturn {
@@ -22,49 +27,70 @@ export interface UseUpdaterReturn {
 const isUnsupported = () => __DEV__ || Platform.OS === 'web'
 
 export const useUpdater = (options: UseUpdaterOptions = {}): UseUpdaterReturn => {
-  const { autoCheck = true, autoPrompt = true, onConfirm, onError } = options
+  const { autoCheck = true, autoPrompt = true, onConfirm, onError, onInfo } = options
   const [checking, setChecking] = useState(false)
   const [updateReady, setUpdateReady] = useState(false)
   const checkingRef = useRef(false)
+  const autoCheckPendingRef = useRef(false)
   const appState = useRef(AppState.currentState)
   const stagedManifest = useRef<UpdateManifest | null>(null)
   // Read via refs inside the AppState listener so onConfirm/onError identity changes (e.g. an
   // inline arrow function) don't tear down and re-subscribe the listener on every render.
   const onConfirmRef = useRef(onConfirm)
   const onErrorRef = useRef(onError)
-  onConfirmRef.current = onConfirm
-  onErrorRef.current = onError
+
+  useEffect(() => {
+    onConfirmRef.current = onConfirm
+    onErrorRef.current = onError
+  })
 
   useEffect(() => {
     if (!autoCheck || isUnsupported()) return
 
+    const runAutoCheck = () => {
+      // Guards against overlapping fetches if AppState fires again (e.g. rapid app-switcher
+      // transitions) before a prior auto-check has resolved. Independent of checkingRef, which
+      // only guards the confirmation prompt and covers manual check() calls too.
+      if (autoCheckPendingRef.current) return
+      autoCheckPendingRef.current = true
+
+      checkForUpdate()
+        .then(async (manifest) => {
+          if (!manifest) return
+          stagedManifest.current = manifest
+          setUpdateReady(true)
+          if (!autoPrompt || checkingRef.current) return
+
+          checkingRef.current = true
+          setChecking(true)
+          try {
+            const confirmFn = onConfirmRef.current ?? getUpdateConfirmation
+            const confirmed = await confirmFn(manifest)
+            if (confirmed) await reloadAsync()
+          } catch (err) {
+            const message = err instanceof Error ? err.message : 'Could not check for updates.'
+            if (onErrorRef.current) onErrorRef.current(message)
+            else Alert.alert('Update error', message)
+          } finally {
+            stagedManifest.current = null
+            setUpdateReady(false)
+            checkingRef.current = false
+            setChecking(false)
+          }
+        })
+        .catch(() => {})
+        .finally(() => {
+          autoCheckPendingRef.current = false
+        })
+    }
+
+    // Cold launch: run the same check+prompt flow as a foreground resume so update
+    // discovery is consistent regardless of how the app was started.
+    runAutoCheck()
+
     const subscription = AppState.addEventListener('change', (nextState: AppStateStatus) => {
       if (/inactive|background/.test(appState.current) && nextState === 'active') {
-        checkForUpdate()
-          .then(async (manifest) => {
-            if (!manifest) return
-            stagedManifest.current = manifest
-            setUpdateReady(true)
-            if (!autoPrompt || checkingRef.current) return
-
-            checkingRef.current = true
-            setChecking(true)
-            try {
-              const confirmFn = onConfirmRef.current ?? getUpdateConfirmation
-              const confirmed = await confirmFn(manifest)
-              if (confirmed) await reloadAsync()
-            } catch (err) {
-              const message = err instanceof Error ? err.message : 'Could not check for updates.'
-              if (onErrorRef.current) onErrorRef.current(message)
-              else Alert.alert('Update error', message)
-            } finally {
-              stagedManifest.current = null
-              setUpdateReady(false)
-              checkingRef.current = false
-              setChecking(false)
-            }
-          })
-          .catch(() => {})
+        runAutoCheck()
       }
       appState.current = nextState
     })
@@ -74,11 +100,15 @@ export const useUpdater = (options: UseUpdaterOptions = {}): UseUpdaterReturn =>
 
   const check = async (): Promise<void> => {
     if (__DEV__) {
-      Alert.alert('Updates unavailable', 'Update checks are disabled in development mode.')
+      const message = 'Update checks are disabled in development mode.'
+      if (onInfo) onInfo('Updates unavailable', message)
+      else Alert.alert('Updates unavailable', message)
       return
     }
     if (Platform.OS === 'web') {
-      Alert.alert('Updates unavailable', 'Update checks are not supported on web.')
+      const message = 'Update checks are not supported on web.'
+      if (onInfo) onInfo('Updates unavailable', message)
+      else Alert.alert('Updates unavailable', message)
       return
     }
     if (checkingRef.current) return
@@ -87,7 +117,9 @@ export const useUpdater = (options: UseUpdaterOptions = {}): UseUpdaterReturn =>
     try {
       const manifest = stagedManifest.current ?? (await checkForUpdate())
       if (!manifest) {
-        Alert.alert('No update', 'You are on the most recent version.')
+        const message = 'You are on the most recent version.'
+        if (onInfo) onInfo('No update', message)
+        else Alert.alert('No update', message)
         return
       }
       const confirmFn = onConfirm ?? getUpdateConfirmation