react-native-update 10.49.0 → 10.51.0

package/src/endpoint.ts

@@ -1,4 +1,7 @@
 import { UpdateError } from './error';
+import { dedupeEndpoints, orderEndpointCandidates } from './updateFlowCore';
+
+export { dedupeEndpoints };
 
 export interface EndpointAttemptSuccess<T> {
   endpoint: string;
@@ -14,9 +17,10 @@ export interface EndpointAttemptFailure {
 export interface ExecuteEndpointFallbackOptions<T> {
   configuredEndpoints: string[];
   getRemoteEndpoints?: () => Promise<string[]>;
-  tryEndpoint: (endpoint: string) => Promise<T>;
+  tryEndpoint: (endpoint: string, signal?: AbortSignal) => Promise<T>;
   random?: () => number;
   now?: () => number;
+  hedgeDelayMs?: number;
   onFirstFailure?: (failure: EndpointAttemptFailure) => void | Promise<void>;
 }
 
@@ -27,87 +31,104 @@ const normalizeError = (error: unknown) => {
   return new Error(String(error));
 };
 
-export const dedupeEndpoints = (
-  endpoints: Array<string | null | undefined>
-): string[] => {
-  const result: string[] = [];
-  const visited = new Set<string>();
-
-  for (const endpoint of endpoints) {
-    if (!endpoint || visited.has(endpoint)) {
-      continue;
-    }
-    visited.add(endpoint);
-    result.push(endpoint);
-  }
-
-  return result;
-};
-
-export const pickRandomEndpoint = (
+export const DEFAULT_HEDGE_DELAY_MS = 250;
+
+/**
+ * Hedged race over the candidate endpoints: the first candidate starts
+ * immediately, each following one is only started after `hedgeDelayMs` of
+ * silence (or immediately when a previous attempt failed). The first
+ * successful response wins and every other in-flight request is aborted, so
+ * one slow endpoint never gates a fast one, and healthy rounds send a single
+ * request instead of blasting every candidate at once.
+ */
+export function selectFastestSuccessfulEndpoint<T>(
   endpoints: string[],
-  random: () => number = Math.random
-) => {
-  if (!endpoints.length) {
-    throw new UpdateError('No endpoints configured', 'NO_ENDPOINTS');
-  }
-  return endpoints[Math.floor(random() * endpoints.length)];
-};
-
-export async function selectFastestSuccessfulEndpoint<T>(
-  endpoints: string[],
-  tryEndpoint: (endpoint: string) => Promise<T>,
-  now: () => number = Date.now
+  tryEndpoint: (endpoint: string, signal?: AbortSignal) => Promise<T>,
+  now: () => number = Date.now,
+  hedgeDelayMs: number = DEFAULT_HEDGE_DELAY_MS
 ): Promise<{
-  successes: EndpointAttemptSuccess<T>[];
+  success?: EndpointAttemptSuccess<T>;
   failures: EndpointAttemptFailure[];
 }> {
-  const attempts = await Promise.all(
-    endpoints.map(async (endpoint) => {
-      const start = now();
-      try {
-        const value = await tryEndpoint(endpoint);
-        return {
-          ok: true as const,
-          endpoint,
-          value,
-          duration: now() - start,
-        };
-      } catch (error) {
-        return {
-          ok: false as const,
-          endpoint,
-          error: normalizeError(error),
-        };
-      }
-    })
-  );
-
-  const successes: EndpointAttemptSuccess<T>[] = [];
-  const failures: EndpointAttemptFailure[] = [];
-
-  for (const attempt of attempts) {
-    if (attempt.ok) {
-      successes.push({
-        endpoint: attempt.endpoint,
-        value: attempt.value,
-        duration: attempt.duration,
-      });
-      continue;
+  return new Promise((resolve) => {
+    if (!endpoints.length) {
+      resolve({ failures: [] });
+      return;
     }
 
-    failures.push({
-      endpoint: attempt.endpoint,
-      error: attempt.error,
-    });
-  }
+    const failures: EndpointAttemptFailure[] = [];
+    const controllers: AbortController[] = [];
+    let nextIndex = 0;
+    let pending = 0;
+    let settled = false;
+    let hedgeTimer: ReturnType<typeof setTimeout> | undefined;
+
+    const finish = (success?: EndpointAttemptSuccess<T>) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (hedgeTimer) {
+        clearTimeout(hedgeTimer);
+      }
+      for (const controller of controllers) {
+        controller.abort();
+      }
+      resolve({ success, failures });
+    };
 
-  successes.sort((left, right) => left.duration - right.duration);
+    const launchNext = () => {
+      if (hedgeTimer) {
+        clearTimeout(hedgeTimer);
+        hedgeTimer = undefined;
+      }
+      if (settled || nextIndex >= endpoints.length) {
+        return;
+      }
+      const endpoint = endpoints[nextIndex++];
+      const controller =
+        typeof AbortController === 'undefined'
+          ? undefined
+          : new AbortController();
+      if (controller) {
+        controllers.push(controller);
+      }
+      pending++;
+      const start = now();
+      tryEndpoint(endpoint, controller?.signal)
+        .then((value) => {
+          if (controller) {
+            // Only the losing requests get aborted, not the winner's own
+            // (already settled) one.
+            const index = controllers.indexOf(controller);
+            if (index >= 0) {
+              controllers.splice(index, 1);
+            }
+          }
+          finish({ endpoint, value, duration: now() - start });
+        })
+        .catch((error) => {
+          pending--;
+          if (settled) {
+            // Losers cancelled after a win must not count as failures.
+            return;
+          }
+          failures.push({ endpoint, error: normalizeError(error) });
+          if (nextIndex < endpoints.length) {
+            // A failure frees its slot: hedge the next candidate right away
+            // instead of waiting out the stagger.
+            launchNext();
+          } else if (pending === 0) {
+            finish(undefined);
+          }
+        });
+      if (!settled && nextIndex < endpoints.length) {
+        hedgeTimer = setTimeout(launchNext, hedgeDelayMs);
+      }
+    };
 
-  return {
-    successes,
-    failures,
-  };
+    launchNext();
+  });
 }
 
 export async function executeEndpointFallback<T>({
@@ -116,16 +137,19 @@ export async function executeEndpointFallback<T>({
   tryEndpoint,
   random = Math.random,
   now = Date.now,
+  hedgeDelayMs = DEFAULT_HEDGE_DELAY_MS,
   onFirstFailure,
 }: ExecuteEndpointFallbackOptions<T>): Promise<EndpointAttemptSuccess<T>> {
   const excludedEndpoints = new Set<string>();
-  let candidates = dedupeEndpoints(configuredEndpoints);
+  // The candidate ordering (random first pick, configured order as fallback)
+  // is pure policy; this side only executes it.
+  let candidates = orderEndpointCandidates(configuredEndpoints, random());
 
   if (!candidates.length) {
     throw new UpdateError('No endpoints configured', 'NO_ENDPOINTS');
   }
 
-  const firstEndpoint = pickRandomEndpoint(candidates, random);
+  const firstEndpoint = candidates[0];
 
   try {
     return {
@@ -154,14 +178,15 @@ export async function executeEndpointFallback<T>({
         throw lastError;
       }
 
-      const { successes, failures } = await selectFastestSuccessfulEndpoint(
+      const { success, failures } = await selectFastestSuccessfulEndpoint(
         candidates,
         tryEndpoint,
-        now
+        now,
+        hedgeDelayMs
       );
 
-      if (successes.length) {
-        return successes[0];
+      if (success) {
+        return success;
       }
 
       for (const failure of failures) {

package/src/error.ts

@@ -24,6 +24,9 @@ export type UpdateErrorCode =
   // A throw from a user-provided hook (e.g. beforeReload) — not an update
   // pipeline failure, and excluded from server-side patch-health telemetry.
   | 'USER_HOOK_ERROR'
+  // A second client/provider in the same process — a hard integration error;
+  // the SDK is a process-level singleton.
+  | 'SINGLETON_VIOLATION'
   // Native codes (see cpp/patch_core/error_codes.h)
   | 'INVALID_OPTIONS'
   | 'PATCH_FAILED'
@@ -47,6 +50,7 @@ const KNOWN_CODES = new Set<string>([
   'STORAGE_PERMISSION_ERROR',
   'APK_DOWNLOAD_FAILED',
   'USER_HOOK_ERROR',
+  'SINGLETON_VIOLATION',
   'INVALID_OPTIONS',
   'PATCH_FAILED',
   'FILE_OPERATION_FAILED',

package/src/locales/en.ts

@@ -43,6 +43,10 @@ export default {
 
   // Error messages
   error_appkey_required: 'appKey is required',
+  error_client_singleton:
+    'A second update client was created: the SDK is a process-level singleton — create one client and reuse it everywhere (use client.setOptions to change options at runtime)',
+  error_provider_singleton:
+    'A second UpdateProvider was mounted: make sure the app renders exactly one UpdateProvider',
   error_parse_version_info: 'Failed to parse currentVersionInfo: {{info}}',
   warn_unknown_bundle:
     'The bundle embedded in this binary is not registered on the update platform; incremental updates are degraded to full downloads. Upload the package with pushy uploadIpa / uploadApk / uploadApp.',

package/src/locales/zh.ts

@@ -41,6 +41,10 @@ export default {
 
   // Error messages
   error_appkey_required: '需要提供 appKey',
+  error_client_singleton:
+    '检测到重复创建热更新 client：SDK 是进程级单例，请只创建一个 client 并在全局复用（运行期改配置请调用 client.setOptions）',
+  error_provider_singleton:
+    '检测到同时挂载多个 UpdateProvider：请确保应用中只有一个 UpdateProvider',
   error_parse_version_info: '解析 currentVersionInfo 失败: {{info}}',
   warn_unknown_bundle:
     '当前二进制内嵌 bundle 未在更新平台注册，增量更新已降级为全量。请使用 pushy uploadIpa / uploadApk / uploadApp 上传对应安装包。',

package/src/provider.tsx

@@ -18,13 +18,15 @@ import { URL } from 'react-native-url-polyfill';
 import { type Cresc, type Pushy, sharedState } from './client';
 import { ProgressContext, UpdateContext } from './context';
 import {
+  cInfo,
   currentVersion,
   currentVersionInfo,
   getCurrentVersionInfo,
   packageVersion,
+  rolledBackVersion,
 } from './core';
-import { resolveCheckResult } from './resolveCheckResult';
 import type { CheckResult, ProgressData, UpdateTestPayload } from './type';
+import { decideDownload, resolveCheckResult } from './updateFlowCore';
 import { assertWeb, log, noop } from './utils';
 
 export const UpdateProvider = ({
@@ -37,6 +39,26 @@ export const UpdateProvider = ({
   client = useRef(client).current;
   const { options } = client;
 
+  // A second concurrently mounted provider is a hard integration error (the
+  // client is a process-level singleton); the client throws on the second
+  // claim. Also releases the claim on unmount.
+  useEffect(() => client.claimProviderMount?.(), [client]);
+
+  // options is mutated in place by client.setOptions (its identity never
+  // changes), so effects keyed on it would never re-run. The client bumps a
+  // version on every setOptions; mirroring it into state re-renders this
+  // provider and re-runs the effects that list it as a dependency.
+  const [optionsVersion, setOptionsVersion] = useState(
+    client.optionsVersion ?? 0
+  );
+  useEffect(
+    () =>
+      client.onOptionsChange?.(() => {
+        setOptionsVersion((version) => version + 1);
+      }),
+    [client]
+  );
+
   const stateListener = useRef<NativeEventSubscription>(undefined);
   const [updateInfo, setUpdateInfo] = useState<CheckResult>();
   const updateInfoRef = useRef(updateInfo);
@@ -202,7 +224,41 @@ export const UpdateProvider = ({
         // known updateInfo instead of overwriting it with an empty object.
         return;
       }
-      const info = resolveCheckResult(rootInfo);
+      let info = resolveCheckResult(
+        rootInfo,
+        {
+          packageVersion: client.getEffectivePackageVersion(),
+          currentVersion,
+          uuid: cInfo.uuid,
+        },
+        log
+      );
+      if (
+        !info.expired &&
+        info.update &&
+        (typeof info.hash !== 'string' || info.hash.length === 0)
+      ) {
+        // A malformed rollout/root entry must not produce an alert whose
+        // confirm button can never download anything. Surface it to the
+        // developer telemetry/logger and present it to the app as no update.
+        client.reportInvalidUpdateOnce('missingHash');
+        info = { upToDate: true };
+      }
+      if (info.update && !info.expired) {
+        const decision = decideDownload(
+          info,
+          { currentVersion, rolledBackVersion },
+          __DEV__
+        );
+        if (decision.action === 'none') {
+          if (decision.reason === 'noArtifact') {
+            // Invalid server data is worth reporting; local rollout guards are
+            // expected no-ops and stay silent.
+            client.reportInvalidUpdateOnce('noArtifact', info.hash || '');
+          }
+          info = { upToDate: true };
+        }
+      }
       if (info.update) {
         info.description = info.description ?? '';
       }
@@ -279,6 +335,7 @@ export const UpdateProvider = ({
 
   const markSuccess = client.markSuccess;
 
+  // biome-ignore lint/correctness/useExhaustiveDependencies: optionsVersion re-runs this when setOptions mutates options in place
   useEffect(() => {
     if (!client.assertDebug('checkUpdate()')) {
       return;
@@ -313,8 +370,11 @@ export const UpdateProvider = ({
       }
       stateListener.current?.remove();
     };
-  }, [checkUpdate, options, markSuccess, client]);
+    // optionsVersion: checkStrategy/autoMarkSuccess are read from the
+    // in-place-mutated options object, so option changes must re-run this.
+  }, [checkUpdate, options, markSuccess, client, optionsVersion]);
 
+  // biome-ignore lint/correctness/useExhaustiveDependencies: optionsVersion re-runs this when setOptions mutates options in place
   useEffect(() => {
     const { dismissErrorAfter } = options;
     if (
@@ -329,17 +389,22 @@ export const UpdateProvider = ({
         clearTimeout(dismissErrorTimer);
       };
     }
-  }, [lastError, options, dismissError]);
+    // optionsVersion: dismissErrorAfter changes must reschedule a running
+    // timer, not only apply to the next error.
+  }, [lastError, options, dismissError, optionsVersion]);
 
   const parseTestPayload = useCallback(
     (payload: UpdateTestPayload) => {
       if (payload?.type?.startsWith('__rnPushy')) {
-        const logger = options.logger || (() => {});
-        options.logger = ({ type, data }) => {
-          logger({ type, data });
-          Alert.alert(type, JSON.stringify(data));
-        };
         if (payload.type === '__rnPushyVersionHash') {
+          // Wrap the logger only for the duration of this test check; wrapping
+          // on any other __rnPushy* payload would never be undone (the finally
+          // below is the only restore point).
+          const logger = options.logger || (() => {});
+          options.logger = ({ type, data }) => {
+            logger({ type, data });
+            Alert.alert(type, JSON.stringify(data));
+          };
           const toHash = payload.data;
           sharedState.toHash = toHash;
           checkUpdate({ extra: { toHash } })

package/src/telemetry.ts

@@ -53,6 +53,14 @@ export const resolveServerEventType = (
       return 'mark_success';
     case 'rollback':
       return 'rollback';
+    case 'downloadFallback':
+      // An incremental strategy failed but a later one rescued the download.
+      // When the incremental patch itself failed to apply (e.g. pdiff
+      // copiesCrc mismatch on a rebuilt binary), that is still a patch-health
+      // signal even though the end user got the update via full. Plain
+      // download errors that full rescued stay local-only — they are network
+      // noise, not patch health.
+      return code === 'PATCH_FAILED' ? 'patch_fail' : undefined;
     default:
       return undefined;
   }

package/src/type.ts

@@ -9,6 +9,14 @@ export interface VersionInfo {
     rollout: {
       [packageVersion: string]: number;
     };
+    /**
+     * Server-set per-version override: the native cold-start check activates
+     * this version for the next launch regardless of the client's
+     * updateStrategy (the brick-rescue directive). Native-only — the JS
+     * interactive flow ignores it. The device-local rolledBack guard still
+     * wins, and first_time crash protection still applies.
+     */
+    forceBoot?: boolean;
     [key: string]: any;
   };
   pdiff?: string;
@@ -83,6 +91,11 @@ export type EventType =
   // registered on the update platform (developer-facing only, local logger;
   // not a server telemetry event).
   | 'bundleMismatch'
+  // An incremental strategy (diff/pdiff) failed but a later strategy saved the
+  // download. Carries which strategy failed and why — the signal that watches
+  // pdiff copiesCrc verification failures (BUNDLEHASH_MIGRATION §4.2.1) in
+  // the field.
+  | 'downloadFallback'
   | 'errorRestart'
   | 'errorSwitchVersion'
   | 'downloadingApk'
@@ -164,6 +177,24 @@ export interface ClientOptions {
    * the version health view in the console. Default: false (enabled).
    */
   disableTelemetry?: boolean;
+  /**
+   * Disable the native cold-start update check: the background check that runs
+   * a few seconds after every launch, independent of JS
+   * (NATIVE_CHECKUPDATE_DESIGN §10). Default: false (enabled).
+   *
+   * That check is what rescues a device bricked by a bad update — its JS never
+   * runs, so nothing else can pull the fix. Turning it off gives up that
+   * recovery path (and the response cache the JS check reuses) in exchange for
+   * one fewer background request per cold start; choose it only when the extra
+   * request is itself the problem (traffic/battery budgets, privacy manifests,
+   * consent-gated networking).
+   *
+   * Orthogonal to `checkStrategy`, which governs activation authority rather
+   * than whether the check runs: with `checkStrategy: null` the native check
+   * still downloads but never activates on its own — only the server's
+   * per-version forceBoot directive may.
+   */
+  disableNativeCheck?: boolean;
 }
 
 export interface UpdateTestPayload {