react-native-update 10.47.0 → 10.48.1

package/harmony/pushy/src/main/cpp/pushy.cpp

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "archive_patch_core.h"
+#include "hbc_transform_wire.h"
 #include "patch_core.h"
 #include "state_core.h"
 #include "state_ops.h"
@@ -69,7 +70,9 @@ std::string GetString(napi_env env, napi_value value, bool* ok) {
     return std::string();
   }
 
-  std::string result(length, '\0');
+  // length + 1 so NAPI's terminating '\0' lands inside owned storage instead
+  // of the string's past-the-end terminator slot (formally UB to write).
+  std::string result(length + 1, '\0');
   size_t written = 0;
   if (napi_get_value_string_utf8(
           env, value, result.data(), length + 1, &written) != napi_ok) {
@@ -686,6 +689,7 @@ napi_value ApplyPatchFromFileSource(napi_env env, napi_callback_info info) {
   std::string bundle_patch_path;
   std::string bundle_output_path;
   std::string merge_source_subdir;
+  std::string bundle_hbc_transform_meta;
   bool enable_merge = true;
 
   if (!GetOptionalStringArrayProperty(env, args[0], "copyFroms", &copy_froms) ||
@@ -697,6 +701,8 @@ napi_value ApplyPatchFromFileSource(napi_env env, napi_callback_info info) {
       !GetOptionalStringProperty(env, args[0], "bundlePatchPath", &bundle_patch_path) ||
       !GetOptionalStringProperty(env, args[0], "bundleOutputPath", &bundle_output_path) ||
       !GetOptionalStringProperty(env, args[0], "mergeSourceSubdir", &merge_source_subdir) ||
+      !GetOptionalStringProperty(
+          env, args[0], "bundleHbcTransformMeta", &bundle_hbc_transform_meta) ||
       !GetOptionalBoolProperty(env, args[0], "enableMerge", true, &enable_merge)) {
     return nullptr;
   }
@@ -713,6 +719,7 @@ napi_value ApplyPatchFromFileSource(napi_env env, napi_callback_info info) {
   work_data->options.bundle_patch_path = bundle_patch_path;
   work_data->options.bundle_output_path = bundle_output_path;
   work_data->options.merge_source_subdir = merge_source_subdir;
+  work_data->options.bundle_hbc_transform_meta = bundle_hbc_transform_meta;
   work_data->options.enable_merge = enable_merge;
 
   napi_value promise = nullptr;
@@ -733,9 +740,13 @@ napi_value ApplyPatchFromFileSource(napi_env env, napi_callback_info info) {
             auto* w = static_cast<ApplyPatchWork*>(data);
             w->status = pushy::patch::ApplyPatchFromFileSource(w->options);
           },
-          [](napi_env cb_env, napi_status, void* data) {
+          [](napi_env cb_env, napi_status status, void* data) {
             auto* w = static_cast<ApplyPatchWork*>(data);
-            if (w->status.ok) {
+            if (status != napi_ok) {
+              // Cancelled/aborted before execute ran: w->status is
+              // meaningless; still settle the promise so it never hangs.
+              RejectDeferredWithMessage(cb_env, w->deferred, "async work aborted");
+            } else if (w->status.ok) {
               napi_value undefined_value = nullptr;
               napi_get_undefined(cb_env, &undefined_value);
               napi_resolve_deferred(cb_env, w->deferred, undefined_value);
@@ -821,9 +832,11 @@ napi_value CleanupOldEntries(napi_env env, napi_callback_info info) {
             w->status = pushy::patch::CleanupOldEntries(
                 w->root_dir, w->keep_current, w->keep_previous, w->max_age_days);
           },
-          [](napi_env cb_env, napi_status, void* data) {
+          [](napi_env cb_env, napi_status status, void* data) {
             auto* w = static_cast<CleanupWork*>(data);
-            if (w->status.ok) {
+            if (status != napi_ok) {
+              RejectDeferredWithMessage(cb_env, w->deferred, "async work aborted");
+            } else if (w->status.ok) {
               napi_value undefined_value = nullptr;
               napi_get_undefined(cb_env, &undefined_value);
               napi_resolve_deferred(cb_env, w->deferred, undefined_value);
@@ -876,13 +889,25 @@ bool ExportFunction(
 
 }  // namespace
 
+
+// 原生 patch 内核可消费的 diff 轨道版本(2 = hdiffv2 轨道)
+static napi_value GetSupportedDiffVersion(napi_env env, napi_callback_info) {
+  napi_value result = nullptr;
+  napi_create_uint32(
+      env,
+      static_cast<uint32_t>(pushy::hbc::kSupportedDiffVersion),
+      &result);
+  return result;
+}
+
 napi_value Init(napi_env env, napi_value exports) {
   if (!ExportFunction(env, exports, "syncStateWithBinaryVersion", SyncStateWithBinaryVersion) ||
       !ExportFunction(env, exports, "runStateCore", RunStateCore) ||
       !ExportFunction(env, exports, "buildArchivePatchPlan", BuildArchivePatchPlan) ||
       !ExportFunction(env, exports, "buildCopyGroups", BuildCopyGroups) ||
       !ExportFunction(env, exports, "applyPatchFromFileSource", ApplyPatchFromFileSource) ||
-      !ExportFunction(env, exports, "cleanupOldEntries", CleanupOldEntries)) {
+      !ExportFunction(env, exports, "cleanupOldEntries", CleanupOldEntries) ||
+      !ExportFunction(env, exports, "getSupportedDiffVersion", GetSupportedDiffVersion)) {
     return nullptr;
   }
   return exports;

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

@@ -16,6 +16,9 @@ export interface PatchManifestArrays {
   copyFroms: string[];
   copyTos: string[];
   deletes: string[];
+  // __diff.json 中对应 bundle patch 条目的 hbcTransform 元数据(原始 JSON
+  // 字符串);为空时 native 走现状路径
+  hbcTransformMeta: string;
 }
 
 export function parseManifestToArrays(
@@ -44,10 +47,23 @@ export function parseManifestToArrays(
     copyTos.push(to);
   }
 
+  const hbcTransform = manifest.hbcTransform as
+    | Record<string, object>
+    | undefined;
+  const hbcTransformEntry =
+    hbcTransform && typeof hbcTransform === 'object'
+      ? hbcTransform[HARMONY_BUNDLE_PATCH_ENTRY]
+      : undefined;
+  const hbcTransformMeta =
+    hbcTransformEntry && typeof hbcTransformEntry === 'object'
+      ? JSON.stringify(hbcTransformEntry)
+      : '';
+
   return {
     copyFroms,
     copyTos,
     deletes,
+    hbcTransformMeta,
   };
 }
 
@@ -214,6 +230,7 @@ export class DownloadTask {
         copyFroms: [],
         copyTos: [],
         deletes: [],
+        hbcTransformMeta: '',
       };
     }
 
@@ -229,6 +246,7 @@ export class DownloadTask {
     workingDirectory: string,
     bundlePatchPath: string,
     outputFile: string,
+    hbcTransformMeta = '',
   ): Promise<void> {
     const originBundlePath = `${workingDirectory}/${TEMP_ORIGIN_BUNDLE_ENTRY}`;
     try {
@@ -243,6 +261,7 @@ export class DownloadTask {
         bundlePatchPath,
         bundleOutputPath: outputFile,
         enableMerge: false,
+        bundleHbcTransformMeta: hbcTransformMeta,
       });
     } catch (error: any) {
       error.message = `Failed to process bundle patch: ${error.message}`;
@@ -376,8 +395,15 @@ export class DownloadTask {
             resolve();
           })
           .catch(async error => {
-            await closeWriter();
+            // reject 必须先于 closeWriter：此时 watchdog 已清除，若 close
+            // 也失败（同一磁盘故障的常见连锁）而 reject 未执行，下载 Promise
+            // 将永久挂起——正是 HM-2 要消灭的症状。
             reject(error);
+            try {
+              await closeWriter();
+            } catch (closeErr: any) {
+              console.error('closeWriter failed after write error:', closeErr);
+            }
           });
       });
     });
@@ -442,7 +468,6 @@ export class DownloadTask {
         },
       );
 
-      refreshWatchdog();
       const responseCode = await httpRequest.requestInStream(params.url, {
         method: http.RequestMethod.GET,
         readTimeout: 60000,
@@ -455,6 +480,11 @@ export class DownloadTask {
         throw Error(`Server error: ${responseCode}`);
       }
 
+      // watchdog 到这里才首次启动：requestInStream 阶段已有 connect/readTimeout
+      // 覆盖；若提早启动，连接超过 60s 时 inactivityPromise 会在 race 尚无订阅者
+      // 时 reject（unhandled rejection），且 promise 一经 reject 无法复活——
+      // 即使随后数据正常流入，race 也必然以 "Download stalled" 失败。
+      refreshWatchdog();
       await Promise.race([dataEndPromise, inactivityPromise]);
       const stats = await fileIo.stat(params.targetFile);
       const fileSize = stats.size;
@@ -534,6 +564,7 @@ export class DownloadTask {
       params.unzipDirectory,
       bundlePatchPath,
       `${params.unzipDirectory}/bundle.harmony.js`,
+      manifestArrays.hbcTransformMeta,
     );
     await this.copyFromResource(
       NativePatchCore.buildCopyGroups(
@@ -580,6 +611,7 @@ export class DownloadTask {
       bundleOutputPath: `${params.unzipDirectory}/bundle.harmony.js`,
       mergeSourceSubdir: plan.mergeSourceSubdir,
       enableMerge: plan.enableMerge,
+      bundleHbcTransformMeta: manifestArrays.hbcTransformMeta,
     });
     console.info('Patch from PPK completed');
     try {

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

@@ -47,6 +47,8 @@ export interface FileSourcePatchRequest {
   bundleOutputPath: string;
   mergeSourceSubdir?: string;
   enableMerge?: boolean;
+  /** __diff.json 中该 bundle patch 条目的 hbcTransform 元数据(原始 JSON) */
+  bundleHbcTransformMeta?: string;
 }
 
 interface NativePatchCoreBindings {
@@ -78,6 +80,8 @@ interface NativePatchCoreBindings {
     keepPrevious: string,
     maxAgeDays: number,
   ): Promise<void>;
+  /** 原生 patch 内核可消费的 diff 轨道版本(2 = hdiffv2 轨道) */
+  getSupportedDiffVersion(): number;
 }
 
 export default NativeUpdateCore as unknown as NativePatchCoreBindings;

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

@@ -5,6 +5,7 @@ import {
 import common from '@ohos.app.ability.common';
 import { bundleManager } from '@kit.AbilityKit';
 import logger from './Logger';
+import NativePatchCore from './NativePatchCore';
 import { UpdateContext } from './UpdateContext';
 import { EventHub } from './EventHub';
 
@@ -150,6 +151,7 @@ export class PushyTurboModule extends UITurboModule {
       isFirstTime,
       rolledBackVersion,
       uuid,
+      supportedDiffVersion: NativePatchCore.getSupportedDiffVersion(),
     };
     const logResult = {
       downloadRootDir: result.downloadRootDir,
@@ -231,6 +233,16 @@ export class PushyTurboModule extends UITurboModule {
     }
   }
 
+  async resetToPackagedBundle(): Promise<void> {
+    logger.debug(TAG, ',call resetToPackagedBundle');
+    try {
+      this.context.resetToPackagedBundle();
+    } catch (error) {
+      logger.error(TAG, `resetToPackagedBundle failed: ${getErrorMessage(error)}`);
+      throw Error(`resetToPackagedBundle failed: ${getErrorMessage(error)}`);
+    }
+  }
+
   async downloadPatchFromPpk(options: {
     updateUrl: string;
     hash: string;

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

@@ -27,6 +27,10 @@ export class UpdateContext {
   private static DEBUG: boolean = false;
   private static isUsingBundleUrl: boolean = false;
   private static ignoreRollback: boolean = false;
+  // 本进程实际加载的热更版本（getBundleUrl 解析成功时记录）。
+  // resetToPackagedBundle 不能删它的目录：热更包内的图片等资源是运行时按需
+  // 读盘的，静默（不重启）reset 若删掉会导致后续所有未加载过的资源失败。
+  private static launchVersion: string = '';
   private static cachedPackageVersion: string = '';
   private static cachedBuildTime: string = '';
   // 单例：确保 bundle provider 与 TurboModule 共用同一份 preferences 内存状态，
@@ -296,9 +300,26 @@ export class UpdateContext {
     return params;
   }
 
+  // 串行化下载/补丁任务与破坏性清理（reset 的全量删除）：Android 靠单线程
+  // download executor 天然串行，Harmony 的 NAPI 任务跑在 libuv worker 池上，
+  // 若不排队，reset 的 RemovePathRecursively 可能与正在写入的解压/打补丁并发，
+  // 产出"bundle 在、资源半删"的目录且可能被后续 switchVersion 激活。
+  private taskChain: Promise<void> = Promise.resolve();
+
+  private enqueueSerialTask<T>(job: () => Promise<T>): Promise<T> {
+    const run = this.taskChain.then(job);
+    this.taskChain = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    return run;
+  }
+
   private async executeTask(params: DownloadTaskParams): Promise<void> {
-    const downloadTask = new DownloadTask(this.context);
-    await downloadTask.execute(params);
+    await this.enqueueSerialTask(() => {
+      const downloadTask = new DownloadTask(this.context);
+      return downloadTask.execute(params);
+    });
   }
 
   public syncStateWithBinaryVersion(
@@ -372,6 +393,61 @@ export class UpdateContext {
     });
   }
 
+  /**
+   * 恢复到二进制内置包：清空整个更新状态机（下次启动即回内置 bundle）并删除
+   * 已下载版本——仅保留当前运行版本的目录（静默 reset 不能破坏运行中 bundle
+   * 的按需资源加载）。uuid 保留 —— 它标识安装实例、用于灰度分桶，reset 不应改变。
+   */
+  public resetToPackagedBundle(): void {
+    this.trace('resetToPackagedBundle:before');
+    // 实时读取二进制身份（与 Android/iOS 对齐），而非 preferences 快照：
+    // meta.json 读取失败时快照可能为空，reset 持久化空值会让下次启动误判
+    // binary 变更多做一轮 cleanUp+persist。
+    const resetState: StateCoreResult = {
+      packageVersion: this.getPackageVersion(),
+      buildTime: this.getBuildTime(),
+      currentVersion: '',
+      lastVersion: '',
+      firstTime: false,
+      firstTimeOk: true,
+      rolledBackVersion: '',
+    };
+    // 删除已下载版本的 hash_* 元信息（不走 clear()：它是异步的，且会连带清掉
+    // uuid —— 见 syncStateWithBinaryVersion 的注释）。getAllSync 在旧 SDK 上
+    // 可能不存在，此时残留的 hash_* 只是无害孤儿数据，不影响 reset 语义。
+    const prefsWithGetAll = this.preferences as preferences.Preferences & {
+      getAllSync?: () => Record<string, unknown>;
+    };
+    if (typeof prefsWithGetAll.getAllSync === 'function') {
+      try {
+        const all = prefsWithGetAll.getAllSync();
+        for (const key of Object.keys(all)) {
+          if (key.startsWith('hash_')) {
+            this.preferences.deleteSync(key);
+          }
+        }
+      } catch (e: any) {
+        console.error('Failed to clear hash info on reset:', e);
+      }
+    }
+    this.persistState(resetState, { clearFirstLoadMarker: true });
+    UpdateContext.ignoreRollback = false;
+
+    // maxAgeDays=0：删除下载目录内容，仅保留当前运行版本的目录（残留目录由
+    // 下次常规清理回收）。挂到串行任务链尾，避免与在飞的解压/打补丁并发。
+    this.enqueueSerialTask(() =>
+      NativePatchCore.cleanupOldEntries(
+        this.rootDir,
+        UpdateContext.launchVersion,
+        '',
+        0,
+      ),
+    ).catch((error: Object) => {
+      console.error('reset cleanup failed:', error);
+    });
+    this.trace('resetToPackagedBundle:after');
+  }
+
   public async downloadFullUpdate(url: string, hash: string): Promise<void> {
     try {
       const params = this.createTaskParams(
@@ -512,6 +588,7 @@ export class UpdateContext {
           version = this.rollBack();
           continue;
         }
+        UpdateContext.launchVersion = version;
         return bundleFile;
       } catch (e) {
         console.error('Failed to access bundle file:', e);

package/ios/RCTPushy/RCTPushy.mm

@@ -2,6 +2,7 @@
 #import "RCTPushyDownloader.h"
 #import "ZipArchive.h"
 #include "../../cpp/patch_core/archive_patch_core.h"
+#include "../../cpp/patch_core/hbc_transform_wire.h"
 #include "../../cpp/patch_core/error_codes.h"
 #include "../../cpp/patch_core/patch_core.h"
 #include "../../cpp/patch_core/state_core.h"
@@ -63,6 +64,12 @@ typedef NS_ENUM(NSInteger, PushyType) {
 };
 
 static std::atomic<bool> ignoreRollback{false};
+// The version whose bundle this process actually loaded (resolved in
+// +bundleURL). resetToPackagedBundle must not delete its directory: update
+// assets (images/fonts) are read from it on demand at runtime, so wiping it
+// under a silent (no-restart) reset would break every image the running app
+// has not loaded yet. Guarded by the state lock.
+static NSString *pushyLaunchVersion = nil;
 
 // Serializes every read-modify-write of the persisted update state. The state
 // machine itself is a pure function (state_core), but callers run on different
@@ -304,6 +311,7 @@ RCT_EXPORT_MODULE(RCTPushy);
                 [visitedVersions addObject:loadVersion];
                 NSString *bundlePath = [[downloadDir stringByAppendingPathComponent:loadVersion] stringByAppendingPathComponent:BUNDLE_FILE_NAME];
                 if ([[NSFileManager defaultManager] fileExistsAtPath:bundlePath isDirectory:NULL]) {
+                    pushyLaunchVersion = loadVersion;
                     resolvedURL = [NSURL fileURLWithPath:bundlePath];
                     return;
                 } else {
@@ -347,6 +355,9 @@ RCT_EXPORT_MODULE(RCTPushy);
         ret[@"rolledBackVersion"] = [defaults objectForKey:keyRolledBackMarked];
         ret[@"isFirstTime"] = [defaults objectForKey:keyFirstLoadMarked];
         ret[@"uuid"] = [defaults objectForKey:keyUuid];
+        // 原生 patch 内核可消费的 diff 轨道版本(2 = hdiffv2 轨道),
+        // JS 随 checkUpdate 以 diffV 上报,服务端按能力门控下发
+        ret[@"supportedDiffVersion"] = @(pushy::hbc::kSupportedDiffVersion);
         NSDictionary *pushyInfo = [defaults dictionaryForKey:keyPushyInfo];
         NSString *currentVersion = [pushyInfo objectForKey:paramCurrentVersion];
         ret[@"currentVersion"] = currentVersion;
@@ -376,7 +387,16 @@ RCT_EXPORT_MODULE(RCTPushy);
 {
     self = [super init];
     if (self) {
-        _fileQueue = dispatch_queue_create("cn.reactnative.pushy.file", DISPATCH_QUEUE_SERIAL);
+        // One process-wide serial queue, not per-instance: a bridge reload can
+        // briefly keep two RCTPushy instances alive, and destructive file work
+        // (resetToPackagedBundle's full cleanup) must stay serialized with the
+        // other instance's unzip/patch jobs.
+        static dispatch_queue_t sharedFileQueue;
+        static dispatch_once_t onceToken;
+        dispatch_once(&onceToken, ^{
+            sharedFileQueue = dispatch_queue_create("cn.reactnative.pushy.file", DISPATCH_QUEUE_SERIAL);
+        });
+        _fileQueue = sharedFileQueue;
     }
     return self;
 }
@@ -514,6 +534,56 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
     #endif
 }
 
+RCT_EXPORT_METHOD(resetToPackagedBundle:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    // Reset to the bundle packaged in the binary: wipe the whole update state
+    // (so the next launch resolves to the built-in bundle) and delete the
+    // downloaded versions, keeping only the directory of the version this
+    // process is running from (a silent reset must not break its on-demand
+    // asset loads). Only the client uuid survives — it identifies the install
+    // for gray release bucketing and must not change on reset.
+    __block NSString *keepVersion = nil;
+    PushyWithStateLock(^{
+        NSUserDefaults *defaults = PushyDefaults();
+        keepVersion = pushyLaunchVersion;
+
+        // A default-constructed State is exactly the reset state (no current /
+        // last version, first_time=false, first_time_ok=true); keep the binary
+        // identity so the next launch does not re-trigger the package-updated
+        // sync path.
+        pushy::state::State state;
+        state.package_version = PushyToStdString([RCTPushy packageVersion]);
+        state.build_time = PushyToStdString([RCTPushy buildTime]);
+        PushyApplyStateToDefaults(defaults, state);
+
+        for (NSString *key in [defaults dictionaryRepresentation].allKeys) {
+            if ([key hasPrefix:keyHashInfo]) {
+                [defaults removeObjectForKey:key];
+            }
+        }
+        [defaults removeObjectForKey:keyFirstLoadMarked];
+        [defaults removeObjectForKey:KeyPackageUpdatedMarked];
+        ignoreRollback = false;
+    });
+
+    dispatch_async(_fileQueue, ^{
+        // maxAgeDays=0: remove every downloaded entry except the running
+        // version's directory (cleaned up by the next regular cleanup).
+        pushy::patch::Status status = pushy::patch::CleanupOldEntries(
+            PushyToStdString([RCTPushy downloadDir]),
+            PushyToStdString(keepVersion),
+            "",
+            0
+        );
+        if (!status.ok) {
+            RCTLogWarn(@"Pushy reset cleanup error: %s", status.message.c_str());
+        }
+    });
+
+    resolve(@true);
+}
+
 
 
 #pragma mark - private
@@ -742,6 +812,21 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
         return;
     }
 
+    // __diff.json 的 hbcTransform 元数据(HBC 变换域 patch,hdiffv2 轨道):
+    // 存在时透传给 patch 内核执行 T(origin) → hpatch → T⁻¹;缺失走现状路径。
+    NSDictionary *hbcTransform = json[@"hbcTransform"];
+    if ([hbcTransform isKindOfClass:[NSDictionary class]]) {
+        NSDictionary *meta = hbcTransform[BUNDLE_PATCH_NAME];
+        if ([meta isKindOfClass:[NSDictionary class]]) {
+            NSError *metaError = nil;
+            NSData *metaData = [NSJSONSerialization dataWithJSONObject:meta options:0 error:&metaError];
+            if (metaData != nil && metaError == nil) {
+                NSString *metaString = [[NSString alloc] initWithData:metaData encoding:NSUTF8StringEncoding];
+                options.bundle_hbc_transform_meta = PushyToStdString(metaString);
+            }
+        }
+    }
+
     pushy::patch::Status status = pushy::patch::ApplyPatchFromFileSource(options);
     if (!status.ok) {
         callback(PushyNSErrorFromStatus(status));
@@ -819,6 +904,13 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
             NSError *unzipError = error;
             if (!succeeded && unzipError == nil) {
                 unzipError = PushyErrorWithCode(pushy::error_codes::kPatchFailed, @"unzip failed");
+            } else if (unzipError != nil && unzipError.userInfo[PushyErrorCodeKey] == nil) {
+                // SSZipArchive's own NSError (corrupt zip, bad magic, ...) has
+                // no stable code; without one, downloadUpdate's fallback would
+                // classify it as DOWNLOAD_FAILED even though the download
+                // succeeded — keep the classification deterministic.
+                unzipError = PushyErrorWithCode(pushy::error_codes::kPatchFailed,
+                                                unzipError.localizedDescription ?: @"unzip failed");
             }
             completionHandler(unzipError);
         }];

package/ios/RCTPushy/RCTPushyDownloader.mm

@@ -45,9 +45,12 @@ completionHandler:(void (^)(NSString *path, NSError *error))completionHandler
 
     NSURLSessionConfiguration *sessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
     // Avoid hanging forever on a stalled connection (default resource timeout
-    // is 7 days). These are generous enough for large bundles on slow networks.
+    // is 7 days). The 30s idle timeout matches Android's readTimeout and is
+    // what actually catches a stalled transfer; the total-duration cap matches
+    // Android's 10min callTimeout — 300s made a 30MB full package on a slow
+    // (<100KB/s) network fail on iOS while succeeding on Android.
     sessionConfig.timeoutIntervalForRequest = 30;
-    sessionConfig.timeoutIntervalForResource = 300;
+    sessionConfig.timeoutIntervalForResource = 600;
     self.session = [NSURLSession sessionWithConfiguration:sessionConfig
                                                  delegate:self
                                             delegateQueue:nil];
@@ -89,6 +92,12 @@ totalBytesExpectedToWrite:(int64_t)totalBytesExpectedToWrite
     // Normalize an unknown total (NSURLSessionTransferSizeUnknown == -1) to 0 so
     // the JS side does not compute a negative/NaN percentage.
     long long total = totalBytesExpectedToWrite > 0 ? totalBytesExpectedToWrite : 0;
+    if (totalBytesWritten > total) {
+        // Encoded responses (gzip): the expected total counts compressed bytes
+        // while written counts decompressed ones, so the percentage would run
+        // past 100%. Treat the total as unknown instead.
+        total = 0;
+    }
     if (total > 0) {
         int percentage = (int)((totalBytesWritten * 100.0 / total) + 0.5);
         if (percentage <= self.lastReportedPercentage) {

package/package.json

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

package/react-native-update.podspec

@@ -111,6 +111,8 @@ Pod::Spec.new do |s|
   s.subspec 'RCTPushy' do |ss|
     ss.source_files = ['ios/RCTPushy/*.{h,m,mm}',
                        'cpp/patch_core/archive_patch_core.{h,cpp}',
+                       'cpp/patch_core/hbc_transform.{h,cpp}',
+                       'cpp/patch_core/hbc_transform_wire.{h,cpp}',
                        'cpp/patch_core/patch_core.{h,cpp}',
                        'cpp/patch_core/state_core.{h,cpp}',
                        'android/jni/hpatch.{h,c}',

package/src/NativePushy.ts

@@ -19,6 +19,7 @@ export interface Spec extends TurboModule {
   restartApp(): Promise<void>;
   setNeedUpdate(options: { hash: string }): Promise<void>;
   markSuccess(): Promise<void>;
+  resetToPackagedBundle(): Promise<void>;
   downloadPatchFromPpk(options: {
     updateUrl: string;
     hash: string;