react-native-update 10.46.0 → 10.48.0

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"
@@ -347,6 +348,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;
@@ -514,6 +518,51 @@ 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 every
+    // downloaded version. Only the client uuid survives — it identifies the
+    // install for gray release bucketing and must not change on reset.
+    PushyWithStateLock(^{
+        NSUserDefaults *defaults = PushyDefaults();
+
+        // 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 and no versions to keep: remove every downloaded entry.
+        pushy::patch::Status status = pushy::patch::CleanupOldEntries(
+            PushyToStdString([RCTPushy downloadDir]),
+            "",
+            "",
+            0
+        );
+        if (!status.ok) {
+            RCTLogWarn(@"Pushy reset cleanup error: %s", status.message.c_str());
+        }
+    });
+
+    resolve(@true);
+}
+
 
 
 #pragma mark - private
@@ -742,6 +791,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));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update",
-  "version": "10.46.0",
+  "version": "10.48.0",
   "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;

package/src/client.ts

@@ -9,6 +9,7 @@ import {
   cInfo,
   currentVersion,
   currentVersionInfo,
+  supportedDiffVersion,
   isFirstTime,
   isRolledBack,
   packageVersion,
@@ -41,6 +42,11 @@ import {
 import i18n from './i18n';
 import { toUpdateError, UpdateError, UpdateErrorCode } from './error';
 import { dedupeEndpoints, executeEndpointFallback } from './endpoint';
+import {
+  resolveServerEventHash,
+  resolveServerEventType,
+  truncateDetail,
+} from './telemetry';
 
 /**
  * Receives every error the client reports, alongside the report event type.
@@ -130,6 +136,9 @@ export class Pushy {
   clientType: 'Pushy' | 'Cresc' = 'Pushy';
   lastChecking?: number;
   lastRespJson?: Promise<CheckResult>;
+  // Endpoint that most recently served a successful checkUpdate; telemetry
+  // reuses it instead of re-running the fallback race.
+  private lastWorkingEndpoint?: string;
 
   version = cInfo.rnu;
   loggerPromise = (() => {
@@ -207,6 +216,8 @@ export class Pushy {
     data?: Record<string, string | number>;
   }) => {
     log(`${type} ${code ? `[${code}] ` : ''}${message}`);
+    // Fire-and-forget server telemetry; must not wait for the logger below.
+    this.reportToServer({ type, message, code, data });
     if (this.options.logger === noop) {
       // Wait briefly for a logger to arrive via setOptions (e.g. the rollback
       // report fires in the constructor before the user configures one), but
@@ -242,6 +253,72 @@ export class Pushy {
       log('logger error:', e?.message || e);
     }
   };
+  /**
+   * Best-effort lifecycle event reporting to the update server (aggregate
+   * counts + sampled failure details power the version health view and the
+   * rollback safety net server-side). Single POST to the last known working
+   * endpoint, no retry, no fallback race; any failure is swallowed — telemetry
+   * must never affect the update flow. Opt out with disableTelemetry.
+   */
+  private reportToServer = ({
+    type,
+    message = '',
+    code,
+    data = {},
+  }: {
+    type: EventType;
+    message?: string;
+    code?: UpdateErrorCode;
+    data?: Record<string, string | number>;
+  }) => {
+    try {
+      if (__DEV__ || this.options.disableTelemetry) {
+        return;
+      }
+      const serverType = resolveServerEventType(type, code);
+      if (!serverType) {
+        return;
+      }
+      const { appKey } = this.options;
+      const endpoint =
+        this.lastWorkingEndpoint || this.options.server?.main?.[0];
+      if (!appKey || !endpoint) {
+        return;
+      }
+      const hash = resolveServerEventHash({ serverType, data, currentVersion });
+      if (!hash) {
+        return;
+      }
+      const send = (payloadType: typeof serverType, detail?: string) =>
+        fetchWithTimeout(
+          `${endpoint}/report/${appKey}`,
+          {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              type: payloadType,
+              hash,
+              packageVersion:
+                this.options.overridePackageVersion || packageVersion,
+              cInfo,
+              detail: truncateDetail(detail),
+            }),
+          },
+          DEFAULT_FETCH_TIMEOUT_MS,
+        ).catch((e: any) => {
+          log('telemetry report failed:', e?.message || e);
+        });
+      send(serverType, message || undefined);
+      // A download that only succeeded after an incremental patch failed is
+      // still a patch_fail signal server-side (diff quality), carried in
+      // data.error alongside the downloadSuccess event.
+      if (serverType === 'download_success' && data.error) {
+        send('patch_fail', String(data.error));
+      }
+    } catch (e: any) {
+      log('telemetry error:', e?.message || e);
+    }
+  };
   throwIfEnabled = (e: Error) => {
     if (this.options.throwError) {
       throw e;
@@ -387,6 +464,7 @@ export class Pushy {
     });
 
     log('check endpoint success', endpoint);
+    this.lastWorkingEndpoint = endpoint;
     return value;
   };
   assertDebug = (matter: string) => {
@@ -495,6 +573,8 @@ export class Pushy {
       hash: currentVersion,
       buildTime,
       cInfo,
+      // 可消费的 diff 轨道版本(2 = hdiffv2 轨道),服务端据此门控下发
+      ...(supportedDiffVersion ? { diffV: supportedDiffVersion } : {}),
       ...extra,
     };
     if (__DEV__) {
@@ -871,6 +951,49 @@ export class Pushy {
     }
     return PushyModule.restartApp();
   };
+  /**
+   * Reset to the bundle packaged in the binary: wipes every downloaded update
+   * and the whole update state on the native side, so the app loads the
+   * built-in bundle on the next launch (or immediately with
+   * `{ restart: true }`). The client uuid is preserved.
+   *
+   * Returns whether the reset actually happened. Like the other update-flow
+   * APIs it never throws by default — failures land in lastError/onError with
+   * code RESET_FAILED — but the boolean must not be ignored: a false means the
+   * app is still running the hot-updated bundle. Set `throwError` to throw.
+   */
+  resetToPackagedBundle = async (options?: {
+    restart?: boolean;
+  }): Promise<boolean> => {
+    if (typeof PushyModule.resetToPackagedBundle !== 'function') {
+      // The JS layer can arrive via hot update onto an older binary whose
+      // native module predates this method.
+      const err = new UpdateError(
+        this.t('error_reset_not_supported'),
+        'RESET_FAILED',
+      );
+      this.emitError(err, 'errorReset');
+      this.throwIfEnabled(err);
+      return false;
+    }
+    try {
+      await PushyModule.resetToPackagedBundle();
+    } catch (e) {
+      const err = toUpdateError(e, 'RESET_FAILED');
+      this.emitError(err, 'errorReset');
+      this.throwIfEnabled(err);
+      return false;
+    }
+    // The downloaded versions are gone; drop JS bookkeeping referring to them
+    // so a stale downloadedHash cannot be switched to.
+    sharedState.downloadedHash = undefined;
+    sharedState.marked = false;
+    this.report({ type: 'reset' });
+    if (options?.restart) {
+      await this.restartApp();
+    }
+    return true;
+  };
 }
 
 // for international users

package/src/context.ts

@@ -15,6 +15,7 @@ export const defaultContext = {
   downloadUpdate: asyncNoop,
   downloadAndInstallApk: asyncNoop,
   restartApp: asyncNoop,
+  resetToPackagedBundle: asyncNoop,
   getCurrentVersionInfo: () => Promise.resolve({}),
   parseTestQrCode: () => false,
   currentHash: '',
@@ -43,6 +44,9 @@ export const UpdateContext = createContext<{
   } | null;
   parseTestQrCode: (code: string) => boolean;
   restartApp: () => Promise<void>;
+  resetToPackagedBundle: (options?: {
+    restart?: boolean;
+  }) => Promise<boolean | void>;
   currentHash: string;
   packageVersion: string;
   client?: Pushy | Cresc;

package/src/core.ts

@@ -65,6 +65,10 @@ export const rolledBackVersion: string = PushyConstants.rolledBackVersion;
 export const isRolledBack: boolean = !!rolledBackVersion;
 
 export const buildTime: string = PushyConstants.buildTime;
+// 原生 patch 内核可消费的 diff 轨道版本(2 = hdiffv2 轨道:HBC 变换 +
+// 流式容器);旧原生无此常量时为 0(不上报,服务端只发 baseline)
+export const supportedDiffVersion: number =
+	PushyConstants.supportedDiffVersion || 0;
 let uuid = PushyConstants.uuid;
 
 async function getLocalHashInfo(hash: string) {

package/src/error.ts

@@ -26,6 +26,7 @@ export type UpdateErrorCode =
   | 'PATCH_FAILED'
   | 'FILE_OPERATION_FAILED'
   | 'RESTART_FAILED'
+  | 'RESET_FAILED'
   | 'INVALID_HASH_INFO'
   | 'UNSUPPORTED_PLATFORM';
 

package/src/locales/en.ts

@@ -61,6 +61,8 @@ export default {
   error_storage_permission_rejected:
     'Storage permission denied, unable to download the APK',
   error_apk_download_failed: 'Failed to download or install the APK',
+  error_reset_not_supported:
+    'resetToPackagedBundle is not available in the installed native module. Please rebuild the app with the latest react-native-update.',
 
   // Development messages
   dev_debug_disabled:

package/src/locales/zh.ts

@@ -56,6 +56,8 @@ export default {
   error_apk_pending_install: '安装包已下载完成，请在系统安装界面完成安装',
   error_storage_permission_rejected: '存储权限被拒绝，无法下载安装包',
   error_apk_download_failed: '安装包下载或安装失败',
+  error_reset_not_supported:
+    '当前安装的原生模块不支持 resetToPackagedBundle，请使用最新版 react-native-update 重新打包后再试。',
 
   // Development messages
   dev_debug_disabled:

package/src/provider.tsx

@@ -388,6 +388,13 @@ export const UpdateProvider = ({
     return client.restartApp();
   }, [client]);
 
+  const resetToPackagedBundle = useCallback(
+    async (resetOptions?: { restart?: boolean }) => {
+      return client.resetToPackagedBundle(resetOptions);
+    },
+    [client],
+  );
+
   useEffect(() => {
     if (!assertWeb()) {
       return;
@@ -438,6 +445,7 @@ export const UpdateProvider = ({
       currentVersionInfo,
       parseTestQrCode,
       restartApp,
+      resetToPackagedBundle,
     }),
     [
       checkUpdate,
@@ -452,6 +460,7 @@ export const UpdateProvider = ({
       downloadAndInstallApk,
       parseTestQrCode,
       restartApp,
+      resetToPackagedBundle,
     ],
   );
 

package/src/telemetry.ts

@@ -0,0 +1,83 @@
+import type { UpdateErrorCode } from './error';
+import type { EventType } from './type';
+
+// Server-side lifecycle event intake (POST {endpoint}/report/{appKey}); the
+// enum must stay in sync with the server's client_event_type. Only these five
+// aggregate types exist server-side — everything else stays local-only.
+export type ServerEventType =
+  | 'download_success'
+  | 'download_fail'
+  | 'patch_fail'
+  | 'rollback'
+  | 'mark_success';
+
+// Failure detail is stored server-side in a VARCHAR(512); stay under it.
+export const MAX_DETAIL_LENGTH = 500;
+
+export interface ServerReportPayload {
+  type: ServerEventType;
+  hash: string;
+  packageVersion?: string;
+  cInfo?: {
+    rnu?: string;
+    rn?: string;
+    os?: string;
+    uuid?: string;
+  };
+  detail?: string;
+}
+
+/**
+ * Maps a local report event to the server-side aggregate type, or undefined
+ * for events the server does not collect. A DOWNLOAD_FAILED whose underlying
+ * native code was PATCH_FAILED counts as patch_fail (the download itself
+ * worked; applying it did not), same for switch-version failures.
+ */
+export const resolveServerEventType = (
+  type: EventType,
+  code?: UpdateErrorCode,
+): ServerEventType | undefined => {
+  switch (type) {
+    case 'downloadSuccess':
+      return 'download_success';
+    case 'errorUpdate':
+      return code === 'PATCH_FAILED' ? 'patch_fail' : 'download_fail';
+    case 'errorSwitchVersion':
+      return 'patch_fail';
+    case 'markSuccess':
+      return 'mark_success';
+    case 'rollback':
+      return 'rollback';
+    default:
+      return undefined;
+  }
+};
+
+/**
+ * The version hash a server event is about. Server-side rows key on it, so an
+ * event without one is not reportable (returns '').
+ */
+export const resolveServerEventHash = ({
+  serverType,
+  data,
+  currentVersion,
+}: {
+  serverType: ServerEventType;
+  data: Record<string, string | number>;
+  currentVersion: string;
+}): string => {
+  if (serverType === 'rollback') {
+    return String(data.rolledBackVersion || '');
+  }
+  if (serverType === 'mark_success') {
+    return String(data.newVersion || currentVersion || '');
+  }
+  return String(data.newVersion || '');
+};
+
+export const truncateDetail = (detail?: string) => {
+  if (!detail) {
+    return undefined;
+  }
+  return detail.slice(0, MAX_DETAIL_LENGTH);
+};

package/src/type.ts

@@ -55,6 +55,8 @@ export type EventType =
   | 'errorUpdate'
   | 'markSuccess'
   | 'errorMarkSuccess'
+  | 'reset'
+  | 'errorReset'
   | 'errorSwitchVersion'
   | 'downloadingApk'
   | 'rejectStoragePermission'
@@ -129,6 +131,12 @@ export interface ClientOptions {
   overridePackageVersion?: string;
   /** Maximum number of retry attempts for failed downloads (default: 3) */
   maxRetries?: number;
+  /**
+   * Disable reporting update lifecycle events (download/patch failures,
+   * rollback, mark success) to the update server. These aggregate stats power
+   * the version health view in the console. Default: false (enabled).
+   */
+  disableTelemetry?: boolean;
 }
 
 export interface UpdateTestPayload {