react-native-update 10.58.0 → 10.59.0

package/README-CN.md

@@ -172,3 +172,10 @@ Hermes 字节码对通用二进制 diff 极不友好，我们在两个环节同
 本组件由[React Native 中文网](https://reactnative.cn/)独家发布，如有定制需求可以[联系我们](https://reactnative.cn/about.html#content)。
 
 关于此插件发现任何问题，可以前往[Issues](https://github.com/reactnativecn/react-native-update/issues)发帖提问。
+
+## 原生宿主接口
+
+原生宿主入口统一为 `prepareBundle`：Android 使用 `PushyRuntime`，
+Apple 平台使用 `RCTPushy`，Harmony 使用已有的 `PushyFileJSBundleProvider`。
+请在正常启动 bundle 解析后调用。改名不改变 JS 桥接契约，但原生接入代码需要迁移并重新构建。
+详见[原生接口迁移说明](NATIVE_HOST_API_MIGRATION.md)。

package/README.md

@@ -153,3 +153,11 @@ Since 10.52.1 every cold start runs one background update check that **does not
 | **Technical Support** | ✅ Paid dedicated support | ⚠️ Community support | ❌ **Discontinued** |
 | **Server Deployment** | ✅ Hosted service or paid private deployment | ✅ Hosted by Expo (EAS Update) | ❌ **Discontinued** |
 | **Bandwidth Usage** | ⭐⭐⭐⭐⭐ Very low (incremental) | ⭐⭐⭐ Higher (full bundle) | ❌ **Discontinued** |
+
+## Native host APIs
+
+Bridge-free hosts use `PushyRuntime.prepareBundle` (Android),
+`RCTPushy.prepareBundle` (Swift), or `PushyFileJSBundleProvider.prepareBundle`
+(HarmonyOS), after normal launch bundle resolution. See the
+[native host API migration guide](NATIVE_HOST_API_MIGRATION.md) for the
+source-breaking rename, unchanged JS bridge contract, and native rebuild steps.

package/android/src/main/java/cn/reactnative/modules/update/{NativeUpdateResult.java → BundlePreparationResult.java}

@@ -4,7 +4,7 @@ package cn.reactnative.modules.update;
  * Snapshot of a native check-and-update round. A downloaded result does not
  * mean that the running React Native instance has been reloaded.
  */
-public final class NativeUpdateResult {
+public final class BundlePreparationResult {
     public static final String SKIPPED = "skipped";
     public static final String NO_UPDATE = "noUpdate";
     public static final String DOWNLOADED = "downloaded";
@@ -16,19 +16,19 @@ public final class NativeUpdateResult {
     private final String hash;
     private final boolean activated;
 
-    private NativeUpdateResult(String status, String reason, String hash, boolean activated) {
+    private BundlePreparationResult(String status, String reason, String hash, boolean activated) {
         this.status = status;
         this.reason = reason;
         this.hash = hash;
         this.activated = activated;
     }
 
-    static NativeUpdateResult of(String status, String reason) {
-        return new NativeUpdateResult(status, reason, "", false);
+    static BundlePreparationResult of(String status, String reason) {
+        return new BundlePreparationResult(status, reason, "", false);
     }
 
-    static NativeUpdateResult downloaded(String hash, boolean activated) {
-        return new NativeUpdateResult(DOWNLOADED, "", hash, activated);
+    static BundlePreparationResult downloaded(String hash, boolean activated) {
+        return new BundlePreparationResult(DOWNLOADED, "", hash, activated);
     }
 
     public String getStatus() {

package/android/src/main/java/cn/reactnative/modules/update/NativeCheckOrchestrator.java

@@ -73,46 +73,46 @@ final class NativeCheckOrchestrator {
     private static volatile String sJsCompletedConfig;
     // Published after the launch rollback snapshot, before host calls are accepted.
     private static volatile boolean nativeReady;
-    private static volatile NativeUpdateResult roundResult =
-        NativeUpdateResult.of(NativeUpdateResult.FAILED, "check_failed");
+    private static volatile BundlePreparationResult roundResult =
+        BundlePreparationResult.of(BundlePreparationResult.FAILED, "check_failed");
     private static volatile long roundGeneration = -1;
     private static volatile long roundConfigGeneration = -1;
     private static volatile String roundConfigJson;
 
     /** Blocking only on the host API's worker; never call on the UI thread. */
-    static NativeUpdateResult checkAndUpdate(UpdateContext context) throws InterruptedException {
+    static BundlePreparationResult prepareBundle(UpdateContext context) throws InterruptedException {
         if (UpdateContext.DEBUG) {
-            return NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "debug");
+            return BundlePreparationResult.of(BundlePreparationResult.SKIPPED, "debug");
         }
         if (!nativeReady || sContext != context || !context.getIsUsingBundleUrl()) {
-            return NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "not_initialized");
+            return BundlePreparationResult.of(BundlePreparationResult.SKIPPED, "not_initialized");
         }
         String configJson = context.getKv(KEY_CONFIG);
         if (configJson == null || configJson.isEmpty()) {
-            return NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "not_configured");
+            return BundlePreparationResult.of(BundlePreparationResult.SKIPPED, "not_configured");
         }
         try {
             JSONObject config = new JSONObject(configJson);
             if (config.optBoolean("disabled", false)) {
-                return NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "disabled");
+                return BundlePreparationResult.of(BundlePreparationResult.SKIPPED, "disabled");
             }
             if (config.optString("appKey", "").isEmpty()) {
-                return NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_config");
+                return BundlePreparationResult.of(BundlePreparationResult.FAILED, "invalid_config");
             }
         } catch (JSONException e) {
-            return NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_config");
+            return BundlePreparationResult.of(BundlePreparationResult.FAILED, "invalid_config");
         }
         startRound(0);
         if (!roundStarted.get()) {
-            return NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "config_changed");
+            return BundlePreparationResult.of(BundlePreparationResult.SKIPPED, "config_changed");
         }
         roundDone.await();
         if (roundConfigGeneration != UpdateContext.getNativeConfigGeneration()
             || !configJson.equals(roundConfigJson) || !configJson.equals(context.getKv(KEY_CONFIG))) {
-            return NativeUpdateResult.of(NativeUpdateResult.CANCELLED, "config_changed");
+            return BundlePreparationResult.of(BundlePreparationResult.CANCELLED, "config_changed");
         }
         if (roundGeneration != UpdateContext.getResetGeneration()) {
-            return NativeUpdateResult.of(NativeUpdateResult.CANCELLED, "reset");
+            return BundlePreparationResult.of(BundlePreparationResult.CANCELLED, "reset");
         }
         return roundResult;
     }
@@ -226,7 +226,7 @@ final class NativeCheckOrchestrator {
             runOnce(sContext, sLaunchRolledBackVersion, deadlineNanos);
         } catch (Throwable e) {
             Log.w(UpdateContext.TAG, "native check failed: " + e);
-            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "internal_error");
+            roundResult = BundlePreparationResult.of(BundlePreparationResult.FAILED, "internal_error");
         } finally {
             roundCompleted = true;
             roundDone.countDown();
@@ -303,27 +303,27 @@ final class NativeCheckOrchestrator {
         final long resetGeneration = UpdateContext.getResetGeneration();
         roundGeneration = resetGeneration;
         roundConfigGeneration = UpdateContext.getNativeConfigGeneration();
-        roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "check_failed");
+        roundResult = BundlePreparationResult.of(BundlePreparationResult.FAILED, "check_failed");
         String configJson = context.getKv(KEY_CONFIG);
         roundConfigJson = configJson;
         if (configJson == null || configJson.isEmpty()) {
-            roundResult = NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "not_configured");
+            roundResult = BundlePreparationResult.of(BundlePreparationResult.SKIPPED, "not_configured");
             return;
         }
         JSONObject config;
         try {
             config = new JSONObject(configJson);
         } catch (JSONException e) {
-            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_config");
+            roundResult = BundlePreparationResult.of(BundlePreparationResult.FAILED, "invalid_config");
             return;
         }
         if (config.optBoolean("disabled", false)) {
-            roundResult = NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "disabled");
+            roundResult = BundlePreparationResult.of(BundlePreparationResult.SKIPPED, "disabled");
             return;
         }
         String appKey = config.optString("appKey", "");
         if (appKey.isEmpty()) {
-            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_config");
+            roundResult = BundlePreparationResult.of(BundlePreparationResult.FAILED, "invalid_config");
             return;
         }
         // Keep the existing interrupted-round breadcrumb and reset generation.
@@ -401,7 +401,7 @@ final class NativeCheckOrchestrator {
 
         String body = NativeUpdateFlow.buildCheckRequestBody(input.toString());
         if (body == null) {
-            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_request");
+            roundResult = BundlePreparationResult.of(BundlePreparationResult.FAILED, "invalid_request");
             return;
         }
 
@@ -418,7 +418,7 @@ final class NativeCheckOrchestrator {
         String decisionJson = NativeUpdateFlow.handleCheckResponse(
             responseText, identity.toString(), config.optString("afterDownload", ""));
         if (decisionJson == null) {
-            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_response");
+            roundResult = BundlePreparationResult.of(BundlePreparationResult.FAILED, "invalid_response");
             return;
         }
         JSONObject decision = new JSONObject(decisionJson);
@@ -427,15 +427,15 @@ final class NativeCheckOrchestrator {
                 resetGeneration, null, null, false,
                 buildResponseCacheJson(configJson, body, responseText, responseAtSeconds));
             roundResult = committed
-                ? NativeUpdateResult.of(NativeUpdateResult.NO_UPDATE, decision.optString("reason"))
-                : NativeUpdateResult.of(NativeUpdateResult.CANCELLED, "reset");
+                ? BundlePreparationResult.of(BundlePreparationResult.NO_UPDATE, decision.optString("reason"))
+                : BundlePreparationResult.of(BundlePreparationResult.CANCELLED, "reset");
             Log.i(UpdateContext.TAG,
                 "native check: nothing to do (" + decision.optString("reason") + ")");
             return;
         }
         String hash = decision.optString("hash", "");
         if (!UpdateFileUtils.isSafePathComponent(hash)) {
-            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_response");
+            roundResult = BundlePreparationResult.of(BundlePreparationResult.FAILED, "invalid_response");
             return;
         }
 
@@ -451,8 +451,8 @@ final class NativeCheckOrchestrator {
             boolean committed = context.commitNativeCheckResult(
                 resetGeneration, null, null, false,
                 buildResponseCacheJson(configJson, body, responseText, responseAtSeconds));
-            roundResult = NativeUpdateResult.of(
-                committed ? NativeUpdateResult.FAILED : NativeUpdateResult.CANCELLED,
+            roundResult = BundlePreparationResult.of(
+                committed ? BundlePreparationResult.FAILED : BundlePreparationResult.CANCELLED,
                 committed ? "download_failed" : "reset");
             return;
         }
@@ -499,7 +499,7 @@ final class NativeCheckOrchestrator {
                 buildResponseCacheJson(configJson, body, responseText, responseAtSeconds));
         } catch (Exception e) {
             Log.w(UpdateContext.TAG, "native check: commit failed: " + e);
-            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "commit_failed");
+            roundResult = BundlePreparationResult.of(BundlePreparationResult.FAILED, "commit_failed");
             return;
         }
         if (!committed) {
@@ -517,8 +517,8 @@ final class NativeCheckOrchestrator {
                 "native check: downloaded " + hash + ", activation left to JS");
         }
         roundResult = committed
-            ? NativeUpdateResult.downloaded(hash, activate)
-            : NativeUpdateResult.of(NativeUpdateResult.CANCELLED, "reset");
+            ? BundlePreparationResult.downloaded(hash, activate)
+            : BundlePreparationResult.of(BundlePreparationResult.CANCELLED, "reset");
     }
 
     private static String buildResponseCacheJson(

package/android/src/main/java/cn/reactnative/modules/update/{NativeUpdateConfig.java → PushyConfiguration.java}

@@ -9,8 +9,8 @@ import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-/** Internal normalizer for the JSONObject accepted by PushyNativeUpdate.configure. */
-final class NativeUpdateConfig {
+/** Internal normalizer for the JSONObject accepted by PushyRuntime.configure. */
+final class PushyConfiguration {
     private static final Set<String> KEYS = new HashSet<>(Arrays.asList(
         "appKey", "endpoints", "queryUrls", "afterDownload", "disabled",
         "packageVersion", "rnu", "rn"));
@@ -24,7 +24,7 @@ final class NativeUpdateConfig {
         "https://cdn.jsdelivr.net/gh/reactnativecn/react-native-update@master/endpoints.json"
     };
 
-    private NativeUpdateConfig() {}
+    private PushyConfiguration() {}
 
     static String normalize(String json) throws JSONException {
         JSONObject options = new JSONObject(json);

package/android/src/main/java/cn/reactnative/modules/update/{PushyNativeUpdate.java → PushyRuntime.java}

@@ -11,10 +11,10 @@ import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
 
 /** Bridge-free native configuration and update APIs. */
-public final class PushyNativeUpdate {
+public final class PushyRuntime {
     public interface Callback {
         /** Always called on the main thread, including skipped and failed checks. */
-        void onComplete(NativeUpdateResult result);
+        void onComplete(BundlePreparationResult result);
     }
 
     // A single waiting worker, not one thread per caller. The actual round is
@@ -46,7 +46,7 @@ public final class PushyNativeUpdate {
     /**
      * Validate and persist a complete configuration, even before JS or bundle
      * resolution. This starts no network work and never resolves a bundle.
-     * Await the callback before continuing startup/checkAndUpdate. Unless JS
+     * Await the callback before continuing startup/prepareBundle. Unless JS
      * uses nativeConfigSource: 'native', later JS config writes can replace it.
      */
     public static void configure(Context context, JSONObject options, final ConfigurationCallback callback) {
@@ -61,7 +61,7 @@ public final class PushyNativeUpdate {
             public void run() {
                 Exception failure = null;
                 try {
-                    String config = NativeUpdateConfig.normalize(snapshot);
+                    String config = PushyConfiguration.normalize(snapshot);
                     UpdateContext.getInstance(applicationContext).setNativeConfig(config);
                 } catch (Exception e) {
                     failure = e;
@@ -79,7 +79,7 @@ public final class PushyNativeUpdate {
         });
     }
 
-    private PushyNativeUpdate() {
+    private PushyRuntime() {
     }
 
     /**
@@ -91,7 +91,7 @@ public final class PushyNativeUpdate {
      * this method: bundle resolution consumes first-load/rollback markers.
      * Missing persisted configuration and debug builds are reported as skipped.
      */
-    public static void checkAndUpdate(Context context, final Callback callback) {
+    public static void prepareBundle(Context context, final Callback callback) {
         if (context == null || callback == null) {
             throw new IllegalArgumentException("context and callback are required");
         }
@@ -99,22 +99,22 @@ public final class PushyNativeUpdate {
         WORKER.execute(new Runnable() {
             @Override
             public void run() {
-                NativeUpdateResult outcome;
+                BundlePreparationResult outcome;
                 try {
                     if (BuildConfig.DEBUG) {
-                        outcome = NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "debug");
+                        outcome = BundlePreparationResult.of(BundlePreparationResult.SKIPPED, "debug");
                     } else {
-                        outcome = NativeCheckOrchestrator.checkAndUpdate(
+                        outcome = NativeCheckOrchestrator.prepareBundle(
                             UpdateContext.getInstance(applicationContext));
                     }
                 } catch (InterruptedException e) {
                     Thread.currentThread().interrupt();
-                    outcome = NativeUpdateResult.of(NativeUpdateResult.CANCELLED, "interrupted");
+                    outcome = BundlePreparationResult.of(BundlePreparationResult.CANCELLED, "interrupted");
                 } catch (Exception | LinkageError e) {
                     Log.w("react-native-update", "native host check failed", e);
-                    outcome = NativeUpdateResult.of(NativeUpdateResult.FAILED, "internal_error");
+                    outcome = BundlePreparationResult.of(BundlePreparationResult.FAILED, "internal_error");
                 }
-                final NativeUpdateResult result = outcome;
+                final BundlePreparationResult result = outcome;
                 new Handler(Looper.getMainLooper()).post(new Runnable() {
                     @Override
                     public void run() {

package/android/src/main/java/cn/reactnative/modules/update/UpdateContext.java

@@ -766,7 +766,7 @@ public class UpdateContext {
             editor.putString(NativeCheckOrchestrator.KEY_CONFIG, config);
             // Persist even an equal value: a previous commit may have updated
             // SharedPreferences memory but failed to write its file.
-            persistEditorOrThrow(editor, "configure native update");
+            persistEditorOrThrow(editor, "persist configuration");
         }
         NativeCheckOrchestrator.onConfigured(this);
     }

package/harmony/pushy/src/main/ets/{NativeUpdateResult.ts → BundlePreparationResult.ts}

@@ -1,5 +1,5 @@
 /** A native round snapshot, not the current state of the running RN instance. */
-export interface NativeUpdateResult {
+export interface BundlePreparationResult {
   /** skipped, noUpdate, downloaded, failed, or cancelled. */
   status: string;
   reason: string;
@@ -8,20 +8,20 @@ export interface NativeUpdateResult {
   activated: boolean;
 }
 
-export function nativeUpdateResult(
+export function bundlePreparationResult(
   status: string,
   reason: string = '',
   hash: string = '',
   activated: boolean = false,
-): NativeUpdateResult {
+): BundlePreparationResult {
   return { status, reason, hash, activated };
 }
 
 /** Internal gate shared by the delayed check and the native host API. */
-export class NativeUpdateRound {
-  private task: Promise<NativeUpdateResult> | undefined;
+export class BundlePreparationRound {
+  private task: Promise<BundlePreparationResult> | undefined;
 
-  run(operation: () => Promise<NativeUpdateResult>): Promise<NativeUpdateResult> {
+  run(operation: () => Promise<BundlePreparationResult>): Promise<BundlePreparationResult> {
     if (this.task !== undefined) {
       return this.task;
     }

package/harmony/pushy/src/main/ets/NativeCheckOrchestrator.ts

@@ -3,8 +3,8 @@ import deviceInfo from '@ohos.deviceInfo';
 import logger from './Logger';
 import NativePatchCore from './NativePatchCore';
 import type { UpdateContext } from './UpdateContext';
-import { NativeUpdateRound, nativeUpdateResult } from './NativeUpdateResult';
-import type { NativeUpdateResult } from './NativeUpdateResult';
+import { BundlePreparationRound, bundlePreparationResult } from './BundlePreparationResult';
+import type { BundlePreparationResult } from './BundlePreparationResult';
 import { isSafePathComponent } from './PathUtils';
 import { monotonicNowMs } from './MonotonicClock';
 import {
@@ -109,18 +109,18 @@ interface RespCacheEntry {
 
 let scheduled = false;
 // The host and delayed check use one promise, including its settled result.
-const hostRound = new NativeUpdateRound();
+const hostRound = new BundlePreparationRound();
 let scheduledContext: UpdateContext | undefined;
 let scheduledRollback = '';
 let roundGeneration = -1;
 let roundConfigGeneration = -1;
 let roundConfigJson: string | undefined;
-let roundResult = nativeUpdateResult('failed', 'check_failed');
+let roundResult = bundlePreparationResult('failed', 'check_failed');
 
 function startNativeRound(
   context: UpdateContext,
   launchRolledBackVersion: string,
-): Promise<NativeUpdateResult> {
+): Promise<BundlePreparationResult> {
   const preflight = configurationError(context);
   if (preflight !== undefined) {
     return Promise.resolve(preflight);
@@ -130,7 +130,7 @@ function startNativeRound(
       await runOnce(context, launchRolledBackVersion);
     } catch (e) {
       logger.error(TAG, `native check failed: ${getErrorMessage(e)}`);
-      roundResult = nativeUpdateResult('failed', 'internal_error');
+      roundResult = bundlePreparationResult('failed', 'internal_error');
     }
     return roundResult;
   });
@@ -138,62 +138,62 @@ function startNativeRound(
 
 // A preflight skip must not consume the process's only round: configuration
 // may arrive after the delayed startup timer on a first-ever launch.
-function configurationError(context: UpdateContext): NativeUpdateResult | undefined {
+function configurationError(context: UpdateContext): BundlePreparationResult | undefined {
   const json = context.getKv(KEY_CONFIG);
   if (!json) {
-    return nativeUpdateResult('skipped', 'not_configured');
+    return bundlePreparationResult('skipped', 'not_configured');
   }
   try {
     const config = JSON.parse(json) as NativeConfig;
     if (!config || typeof config !== 'object' || Array.isArray(config)) {
-      return nativeUpdateResult('failed', 'invalid_config');
+      return bundlePreparationResult('failed', 'invalid_config');
     }
     if (config.disabled) {
-      return nativeUpdateResult('skipped', 'disabled');
+      return bundlePreparationResult('skipped', 'disabled');
     }
     if (typeof config.appKey !== 'string' || config.appKey.trim().length === 0) {
-      return nativeUpdateResult('failed', 'invalid_config');
+      return bundlePreparationResult('failed', 'invalid_config');
     }
   } catch (e) {
-    return nativeUpdateResult('failed', 'invalid_config');
+    return bundlePreparationResult('failed', 'invalid_config');
   }
   return undefined;
 }
 
-export async function checkAndUpdateNative(
+export async function prepareBundleNative(
   context: UpdateContext,
-): Promise<NativeUpdateResult> {
+): Promise<BundlePreparationResult> {
   if (scheduledContext !== context) {
-    return nativeUpdateResult('skipped', 'not_initialized');
+    return bundlePreparationResult('skipped', 'not_initialized');
   }
   const configJson = context.getKv(KEY_CONFIG);
   if (!configJson) {
-    return nativeUpdateResult('skipped', 'not_configured');
+    return bundlePreparationResult('skipped', 'not_configured');
   }
   try {
     const config = JSON.parse(configJson) as NativeConfig;
     if (!config || typeof config !== 'object' || Array.isArray(config)) {
-      return nativeUpdateResult('failed', 'invalid_config');
+      return bundlePreparationResult('failed', 'invalid_config');
     }
     if (config.disabled) {
-      return nativeUpdateResult('skipped', 'disabled');
+      return bundlePreparationResult('skipped', 'disabled');
     }
     if (typeof config.appKey !== 'string' || !config.appKey) {
-      return nativeUpdateResult('failed', 'invalid_config');
+      return bundlePreparationResult('failed', 'invalid_config');
     }
   } catch (e) {
-    return nativeUpdateResult('failed', 'invalid_config');
+    return bundlePreparationResult('failed', 'invalid_config');
   }
   const result = await startNativeRound(context, scheduledRollback);
   if (roundConfigGeneration !== context.getNativeConfigGeneration()
       || configJson !== roundConfigJson || configJson !== context.getKv(KEY_CONFIG)) {
-    return nativeUpdateResult('cancelled', 'config_changed');
+    return bundlePreparationResult('cancelled', 'config_changed');
   }
   if (roundGeneration !== context.getResetGeneration()) {
-    return nativeUpdateResult('cancelled', 'reset');
+    return bundlePreparationResult('cancelled', 'reset');
   }
   // Do not let a caller mutate the cached result observed by later callers.
-  return nativeUpdateResult(result.status, result.reason, result.hash, result.activated);
+  return bundlePreparationResult(result.status, result.reason, result.hash, result.activated);
 }
 
 // JS 在本进程内已拿到有效检查响应时对应的配置 JSON(markJsCheckCompleted)。
@@ -250,32 +250,32 @@ async function runOnce(
   const resetGeneration = context.getResetGeneration();
   roundGeneration = resetGeneration;
   roundConfigGeneration = context.getNativeConfigGeneration();
-  roundResult = nativeUpdateResult('failed', 'check_failed');
+  roundResult = bundlePreparationResult('failed', 'check_failed');
   const configJson = context.getKv(KEY_CONFIG);
   roundConfigJson = configJson;
   if (!configJson) {
     // No persisted configuration: report the rollout gate to native callers.
-    roundResult = nativeUpdateResult('skipped', 'not_configured');
+    roundResult = bundlePreparationResult('skipped', 'not_configured');
     return;
   }
   let config: NativeConfig;
   try {
     config = JSON.parse(configJson) as NativeConfig;
     if (!config || typeof config !== 'object' || Array.isArray(config)) {
-      roundResult = nativeUpdateResult('failed', 'invalid_config');
+      roundResult = bundlePreparationResult('failed', 'invalid_config');
       return;
     }
   } catch (e) {
-    roundResult = nativeUpdateResult('failed', 'invalid_config');
+    roundResult = bundlePreparationResult('failed', 'invalid_config');
     return;
   }
   if (config.disabled) {
-    roundResult = nativeUpdateResult('skipped', 'disabled');
+    roundResult = bundlePreparationResult('skipped', 'disabled');
     return;
   }
   const appKey = config.appKey ?? '';
   if (!appKey) {
-    roundResult = nativeUpdateResult('failed', 'invalid_config');
+    roundResult = bundlePreparationResult('failed', 'invalid_config');
     return;
   }
   // 从这里起本轮开始做真实工作:留下面包屑,死于轮中时下次启动零延迟续传。
@@ -371,7 +371,7 @@ async function runConfiguredRound(
   };
   const body = NativePatchCore.buildCheckRequestBody(JSON.stringify(input));
   if (!body) {
-    roundResult = nativeUpdateResult('failed', 'invalid_request');
+    roundResult = bundlePreparationResult('failed', 'invalid_request');
     return;
   }
 
@@ -390,7 +390,7 @@ async function runConfiguredRound(
     config.afterDownload ?? '',
   );
   if (!decisionJson) {
-    roundResult = nativeUpdateResult('failed', 'invalid_response');
+    roundResult = bundlePreparationResult('failed', 'invalid_response');
     return;
   }
   const decision = JSON.parse(decisionJson) as Decision;
@@ -403,15 +403,15 @@ async function runConfiguredRound(
       buildResponseCacheJson(configJson, body, responseText, responseAtSeconds),
     );
     roundResult = committed
-      ? nativeUpdateResult('noUpdate', decision.reason ?? '')
-      : nativeUpdateResult('cancelled', 'reset');
+      ? bundlePreparationResult('noUpdate', decision.reason ?? '')
+      : bundlePreparationResult('cancelled', 'reset');
     logger.info(TAG, `nothing to do (${decision.reason ?? ''})`);
     return;
   }
   const hash = decision.hash ?? '';
   if (!isSafePathComponent(hash)) {
     logger.warn(TAG, 'decision carries an unsafe hash, ignoring');
-    roundResult = nativeUpdateResult('failed', 'invalid_response');
+    roundResult = bundlePreparationResult('failed', 'invalid_response');
     return;
   }
 
@@ -438,8 +438,8 @@ async function runConfiguredRound(
       buildResponseCacheJson(configJson, body, responseText, responseAtSeconds),
     );
     roundResult = committed
-      ? nativeUpdateResult('failed', 'download_failed')
-      : nativeUpdateResult('cancelled', 'reset');
+      ? bundlePreparationResult('failed', 'download_failed')
+      : bundlePreparationResult('cancelled', 'reset');
     return;
   }
 
@@ -481,7 +481,7 @@ async function runConfiguredRound(
     );
   } catch (e) {
     logger.error(TAG, `commit failed: ${getErrorMessage(e)}`);
-    roundResult = nativeUpdateResult('failed', 'commit_failed');
+    roundResult = bundlePreparationResult('failed', 'commit_failed');
     return;
   }
   if (!committed) {
@@ -492,8 +492,8 @@ async function runConfiguredRound(
     logger.info(TAG, `downloaded ${hash}, activation left to JS`);
   }
   roundResult = committed
-    ? nativeUpdateResult('downloaded', '', hash, activate)
-    : nativeUpdateResult('cancelled', 'reset');
+    ? bundlePreparationResult('downloaded', '', hash, activate)
+    : bundlePreparationResult('cancelled', 'reset');
 }
 
 function buildResponseCacheJson(

package/harmony/pushy/src/main/ets/{NativeUpdateConfig.ts → PushyConfiguration.ts}

@@ -1,5 +1,5 @@
 /** Options accepted by PushyFileJSBundleProvider.configure(). */
-export interface NativeUpdateConfig {
+export interface PushyConfiguration {
   appKey: string;
   /** Omitted: Pushy's built-in endpoints. Custom endpoints never inherit discovery URLs. */
   endpoints?: string[];
@@ -14,7 +14,7 @@ export interface NativeUpdateConfig {
   rn?: string;
 }
 
-interface PersistedNativeUpdateConfig {
+interface PersistedPushyConfiguration {
   appKey: string;
   endpoints: string[];
   queryUrls: string[];
@@ -67,7 +67,7 @@ function configUrls(values: string[], name: string, base: boolean): string[] {
 }
 
 /** Pure validation, before any native state is touched. Does not mutate options. */
-export function normalizeNativeUpdateConfig(options: NativeUpdateConfig): string {
+export function normalizePushyConfiguration(options: PushyConfiguration): string {
   if (!options || typeof options !== 'object' || Array.isArray(options)) {
     throw new Error('Invalid native configuration: expected an object');
   }
@@ -90,7 +90,7 @@ export function normalizeNativeUpdateConfig(options: NativeUpdateConfig): string
   if (options.disabled !== undefined && typeof options.disabled !== 'boolean') {
     throw new Error('Invalid native configuration: disabled must be a boolean');
   }
-  const result: PersistedNativeUpdateConfig = {
+  const result: PersistedPushyConfiguration = {
     appKey, endpoints, queryUrls, afterDownload, disabled: options.disabled ?? false,
     rnu: options.rnu === undefined ? '' : configString(options.rnu, 'rnu', true),
     rn: options.rn === undefined ? '' : configString(options.rn, 'rn', true),

package/harmony/pushy/src/main/ets/PushyFileJSBundleProvider.ets

@@ -6,10 +6,10 @@ import {
 import common from '@ohos.app.ability.common';
 import fs from '@ohos.file.fs';
 import { UpdateContext } from './UpdateContext';
-import { checkAndUpdateNative } from './NativeCheckOrchestrator';
-import type { NativeUpdateResult } from './NativeUpdateResult';
-import { normalizeNativeUpdateConfig } from './NativeUpdateConfig';
-import type { NativeUpdateConfig } from './NativeUpdateConfig';
+import { prepareBundleNative } from './NativeCheckOrchestrator';
+import type { BundlePreparationResult } from './BundlePreparationResult';
+import { normalizePushyConfiguration } from './PushyConfiguration';
+import type { PushyConfiguration } from './PushyConfiguration';
 
 export class PushyFileJSBundleProvider extends JSBundleProvider {
   private updateContext: UpdateContext;
@@ -48,14 +48,14 @@ export class PushyFileJSBundleProvider extends JSBundleProvider {
   }
 
   /** Configure before normal bundle resolution; no JS or network work is required. */
-  async configure(options: NativeUpdateConfig): Promise<void> {
-    const config = normalizeNativeUpdateConfig(options);
+  async configure(options: PushyConfiguration): Promise<void> {
+    const config = normalizePushyConfiguration(options);
     await this.updateContext.setNativeConfig(config);
   }
 
   /** Call after the host's real bundle resolution; never resolves it again. */
-  checkAndUpdate(): Promise<NativeUpdateResult> {
-    return checkAndUpdateNative(this.updateContext);
+  prepareBundle(): Promise<BundlePreparationResult> {
+    return prepareBundleNative(this.updateContext);
   }
 
   getAppKeys(): string[] {

package/harmony/pushy/src/main/ets/UpdateContext.ts

@@ -480,7 +480,7 @@ export class UpdateContext {
       markJsCheckCompleted('');
     }
     // Flush even an equal value so a retry after a storage error can succeed.
-    return this.flushPreferences('configure native update');
+    return this.flushPreferences('persist configuration');
   }
 
   public setKv(key: string, value: string): Promise<void> {

package/ios/RCTPushy/RCTPushy.h

@@ -1,9 +1,9 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
 
-typedef void (^RCTPushyNativeConfigurationCompletion)(NSError * _Nullable error);
+typedef void (^RCTPushyConfigurationCompletion)(NSError * _Nullable error);
 
-typedef void (^RCTPushyNativeUpdateCompletion)(NSDictionary<NSString *, id> * _Nonnull result);
+typedef void (^RCTPushyBundlePreparationCompletion)(NSDictionary<NSString *, id> * _Nonnull result);
 
 @interface RCTPushy : RCTEventEmitter<RCTBridgeModule>
 
@@ -14,20 +14,20 @@ typedef void (^RCTPushyNativeUpdateCompletion)(NSDictionary<NSString *, id> * _N
  * normal launch bundle resolution for first-install native-only provisioning.
  */
 + (void)configure:(NSDictionary<NSString *, id> * _Nonnull)options
-       completion:(RCTPushyNativeConfigurationCompletion _Nullable)completion
+       completion:(RCTPushyConfigurationCompletion _Nullable)completion
     NS_SWIFT_NAME(configure(_:completion:));
 
 /**
- * Start, join, or reuse this process's native update round. Call after the
- * host's real bundleURL resolution; this method never resolves the bundle
- * again, reloads React Native, or displays UI. Configuration is the one
+ * Start, join, or reuse this process's native bundle-preparation round. Call
+ * after the host's real bundleURL resolution; this method never resolves the
+ * bundle again, reloads React Native, or displays UI. Configuration is the one
  * persisted by the JS SDK. The optional completion runs on the main queue.
  *
  * Result keys: status (skipped/noUpdate/downloaded/failed/cancelled), reason,
  * hash (empty when nothing was installed), activated (selected for NEXT
  * launch, not a reload of the running instance).
  */
-+ (void)checkAndUpdateWithCompletion:(RCTPushyNativeUpdateCompletion _Nullable)completion
-    NS_SWIFT_NAME(checkAndUpdate(completion:));
++ (void)prepareBundleWithCompletion:(RCTPushyBundlePreparationCompletion _Nullable)completion
+    NS_SWIFT_NAME(prepareBundle(completion:));
 
 @end

package/ios/RCTPushy/RCTPushy.mm

@@ -1,5 +1,5 @@
 #import "RCTPushy.h"
-#import "RCTPushyNativeConfig.h"
+#import "RCTPushyConfiguration.h"
 #import "RCTPushyDownloader.h"
 #import "ZipArchive.h"
 #include "../../cpp/patch_core/archive_limits.h"
@@ -738,7 +738,7 @@ static void PushySwitchVersionLocked(NSString *hash) {
 @interface RCTPushyOrchestrator : NSObject
 + (void)persistConfiguration:(NSString *)config;
 + (BOOL)hasRunnableConfig;
-+ (NSDictionary *)checkAndUpdate;
++ (NSDictionary *)prepareBundle;
 + (void)scheduleFromColdStart:(NSString *)launchRolledBackVersion;
 #if TARGET_OS_TV && !DEBUG
 + (BOOL)restorePurgedLaunch:(NSString *)purgedVersion
@@ -1104,11 +1104,11 @@ RCT_EXPORT_MODULE(RCTPushy);
 }
 
 + (void)configure:(NSDictionary<NSString *, id> *)options
-       completion:(RCTPushyNativeConfigurationCompletion)completion
+       completion:(RCTPushyConfigurationCompletion)completion
 {
     NSError *validationError = nil;
     // Snapshot nested mutable caller values before crossing a queue boundary.
-    NSString *config = RCTPushyNormalizeNativeConfig(options, &validationError);
+    NSString *config = RCTPushyNormalizeConfiguration(options, &validationError);
     static dispatch_queue_t configQueue;
     static dispatch_once_t once;
     dispatch_once(&once, ^{
@@ -1132,7 +1132,7 @@ RCT_EXPORT_MODULE(RCTPushy);
     });
 }
 
-+ (void)checkAndUpdateWithCompletion:(RCTPushyNativeUpdateCompletion)completion
++ (void)prepareBundleWithCompletion:(RCTPushyBundlePreparationCompletion)completion
 {
     static dispatch_queue_t hostQueue;
     static dispatch_once_t once;
@@ -1142,7 +1142,7 @@ RCT_EXPORT_MODULE(RCTPushy);
     dispatch_async(hostQueue, ^{
         NSDictionary *result;
         @try {
-            result = [RCTPushyOrchestrator checkAndUpdate];
+            result = [RCTPushyOrchestrator prepareBundle];
         } @catch (NSException *exception) {
             RCTLogWarn(@"RCTPushy -- native host check failed: %@", exception.reason);
             result = PushyHostResult(@"failed", @"internal_error", nil, NO);
@@ -2425,7 +2425,7 @@ static BOOL PushyIsValidCheckResponse(NSString *responseText) {
 }
 #endif
 
-+ (NSDictionary *)checkAndUpdate {
++ (NSDictionary *)prepareBundle {
 #if DEBUG
     return PushyHostResult(@"skipped", @"debug", nil, NO);
 #else

package/ios/RCTPushy/{RCTPushyNativeConfig.h → RCTPushyConfiguration.h}

@@ -1,5 +1,5 @@
 #import <Foundation/Foundation.h>
 
 // Validates and snapshots host options without changing any update state.
-FOUNDATION_EXPORT NSString * _Nullable RCTPushyNormalizeNativeConfig(
+FOUNDATION_EXPORT NSString * _Nullable RCTPushyNormalizeConfiguration(
     NSDictionary * _Nonnull options, NSError * _Nullable * _Nullable error);

package/ios/RCTPushy/{RCTPushyNativeConfig.mm → RCTPushyConfiguration.mm}

@@ -1,4 +1,4 @@
-#import "RCTPushyNativeConfig.h"
+#import "RCTPushyConfiguration.h"
 
 static void PushyConfigInvalid(NSString *message) {
     @throw [NSException exceptionWithName:NSInvalidArgumentException
@@ -48,7 +48,7 @@ static NSArray *PushyConfigUrls(id value, NSString *name, BOOL base) {
     return result;
 }
 
-NSString *RCTPushyNormalizeNativeConfig(NSDictionary *options, NSError **error) {
+NSString *RCTPushyNormalizeConfiguration(NSDictionary *options, NSError **error) {
     @try {
         if (![options isKindOfClass:NSDictionary.class]) {
             PushyConfigInvalid(@"expected an object");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update",
-  "version": "10.58.0",
+  "version": "10.59.0",
   "description": "react-native hot update",
   "main": "src/index",
   "types": "src/index.ts",

package/src/client.ts

@@ -742,8 +742,8 @@ export class Pushy {
       let timer: ReturnType<typeof setTimeout> | undefined;
       await Promise.race([
         this.loggerPromise.promise,
-        new Promise((resolve) => {
-          timer = setTimeout(resolve, 10 * 1000);
+        new Promise<void>((resolve) => {
+          timer = setTimeout(() => resolve(), 10 * 1000);
         }),
       ]);
       clearTimeout(timer);
@@ -977,8 +977,9 @@ export class Pushy {
   ) => {
     const resp = await fetchWithTimeout(
       this.getCheckUrl(endpoint),
-      signal ? { ...fetchPayload, signal } : fetchPayload,
-      DEFAULT_FETCH_TIMEOUT_MS
+      fetchPayload,
+      DEFAULT_FETCH_TIMEOUT_MS,
+      signal
     );
 
     if (!resp.ok) {
@@ -1532,7 +1533,7 @@ export class Pushy {
             (0.75 + Math.random() * 0.5)
         );
         log(`retry attempt ${attempt}/${maxRetries}, waiting ${backoffMs}ms`);
-        await new Promise((r) => setTimeout(r, backoffMs));
+        await new Promise<void>((r) => setTimeout(() => r(), backoffMs));
         errorMessages.length = 0;
         errorMessages.push(...exhaustedStrategies.values());
         lastError = undefined;

package/src/core.ts

@@ -3,6 +3,12 @@ import { UpdateError } from './error';
 import i18n from './i18n';
 import { emptyModule, error, log } from './utils';
 
+// RN's JS global object. Declared locally because RN 0.87's own typings no
+// longer define `global` (only @types/node did), and this source is
+// type-checked in consumer projects; the module-scoped declaration also
+// shadows @types/node's without conflicting.
+declare const global: any;
+
 /* eslint-disable @react-native/no-deep-imports */
 const {
   version: v,
@@ -10,7 +16,7 @@ const {
 const RNVersion = `${v.major}.${v.minor}.${v.patch}`;
 const isTurboModuleEnabled =
   // https://github.com/facebook/react-native/pull/48362
-  (global as any).__turboModuleProxy || (global as any).RN$Bridgeless;
+  global.__turboModuleProxy || global.RN$Bridgeless;
 
 const isWebPlatform = Platform.OS === 'web';
 

package/src/utils.ts

@@ -132,7 +132,11 @@ export const computeProgress = (received: number, total: number): number =>
 export const fetchWithTimeout = (
   url: string,
   params: Parameters<typeof fetch>[1],
-  timeoutMs = DEFAULT_FETCH_TIMEOUT_MS
+  timeoutMs = DEFAULT_FETCH_TIMEOUT_MS,
+  // Taken apart from params: merging it into the RequestInit only type-checks
+  // when the global AbortSignal and fetch's RequestInit come from the same
+  // declarations, which RN 0.87 globals mixed with DOM/Node/bun types break.
+  signal?: AbortSignal
 ): Promise<Response> => {
   // AbortController landed in the RN fetch polyfill around 0.60; we support
   // older peers, so fall back to a plain timer race when it is unavailable
@@ -161,7 +165,8 @@ export const fetchWithTimeout = (
   // The timeout controller replaces params.signal on the fetch call, so a
   // caller-provided signal (e.g. the hedged endpoint race cancelling losers)
   // must be chained onto it manually.
-  const externalSignal = (params as any)?.signal as AbortSignal | undefined;
+  const externalSignal =
+    signal ?? ((params as any)?.signal as AbortSignal | undefined);
   const onExternalAbort = () => controller.abort();
   if (externalSignal?.aborted) {
     controller.abort();