react-native-update 10.59.1 → 10.60.0

package/ios/RCTPushy/RCTPushyState.mm

@@ -0,0 +1,314 @@
+// Persisted update state: the defaults keys, the state lock, the State <->
+// defaults mapping, the string/error/JSON helpers every other file uses, and
+// the embedded bundle's hash.
+#import "RCTPushyInternal.h"
+#include "../../cpp/patch_core/digest.h"
+
+#import <React/RCTConvert.h>
+#import <os/lock.h>
+
+PUSHY_HIDDEN NSString *const keyPushyInfo = @"REACTNATIVECN_PUSHY_INFO_KEY";
+// Binary identity (SyncBinaryVersion input). Prefixed like every other key:
+// the unprefixed names collided with generic host-app/SDK defaults, and a
+// foreign value there made every launch look like a rebuilt binary and wipe
+// the installed update.
+static NSString *const paramPackageVersion = @"REACTNATIVECN_PUSHY_PACKAGEVERSION";
+static NSString *const paramBuildTime = @"REACTNATIVECN_PUSHY_BUILDTIME";
+// The unprefixed names earlier SDKs wrote. Read only as a fallback until the
+// first state write migrates them (PushyStateFromDefaults /
+// PushyApplyStateToDefaults).
+static NSString *const legacyParamPackageVersion = @"packageVersion";
+static NSString *const legacyParamBuildTime = @"buildTime";
+static NSString *const paramLastVersion = @"lastVersion";
+PUSHY_HIDDEN NSString *const paramCurrentVersion = @"currentVersion";
+static NSString *const paramIsFirstTime = @"isFirstTime";
+static NSString *const paramIsFirstLoadOk = @"isFirstLoadOK";
+PUSHY_HIDDEN NSString *const keyUuid = @"REACTNATIVECN_PUSHY_UUID";
+PUSHY_HIDDEN NSString *const keyHashInfo = @"REACTNATIVECN_PUSHY_HASH_";
+PUSHY_HIDDEN NSString *const keyFirstLoadMarked = @"REACTNATIVECN_PUSHY_FIRSTLOADMARKED_KEY";
+PUSHY_HIDDEN NSString *const keyRolledBackMarked = @"REACTNATIVECN_PUSHY_ROLLEDBACKMARKED_KEY";
+// Encoded constants (RCTPushyRevealText) are decoded on first use, not by
+// static initializers at image load.
+PUSHY_HIDDEN NSString *KeyPackageUpdatedMarked(void) {
+    static NSString *value = RCTPushyRevealText("0832d5f29aa549710b0939daf88ca058790f3dded7e888b451640d2ec3f69099bb43711523cafa8ea7bb4372132a");
+    return value;
+}
+// bundleHash cache: "<cacheKey>|<sha256hex>" where cacheKey identifies the
+// installed binary (packageVersion + embedded bundle size + mtime). Recomputed
+// only when the key changes, i.e. once per install.
+static NSString *const keyBundleHashCache = @"REACTNATIVECN_PUSHY_BUNDLEHASH_KEY";
+// Raw response cache written by the native cold-start check for the JS side
+// to reuse (§10.3), scoped to the request and config that produced it.
+PUSHY_HIDDEN NSString *const keyNativeCheckCache = @"REACTNATIVECN_PUSHY_NATIVE_CHECK_RESP_KEY";
+
+// error def — messages are human-readable; the stable cross-platform codes
+// live in cpp/patch_core/error_codes.h and travel in RCTPushyErrorCodeKey.
+PUSHY_HIDDEN NSString *const ERROR_OPTIONS = @"options error";
+
+PUSHY_HIDDEN std::atomic<bool> ignoreRollback{false};
+// Bumped by resetToPackagedBundle only (config replacement has its own
+// pushyNativeConfigGeneration). The cold-start check runs for minutes and
+// may already hold a decision when the app resets to the packaged bundle; it
+// samples this counter and abandons activation (and its response cache) when
+// the value moved, so an in-flight rescue can never resurrect the version the
+// app just reset away from.
+PUSHY_HIDDEN std::atomic<uint64_t> pushyResetGeneration{0};
+
+PUSHY_HIDDEN NSDictionary *PushyHostResult(NSString *status, NSString *reason,
+                                           NSString *hash, BOOL activated) {
+    return @{@"status": status, @"reason": reason ?: @"",
+             @"hash": hash ?: @"", @"activated": @(activated)};
+}
+
+PUSHY_HIDDEN NSTimeInterval PushyMonotonicNow(void) {
+    return [NSProcessInfo processInfo].systemUptime;
+}
+
+// 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
+// threads (main thread bundleURL, module method queue, the file queue), so the
+// read→transform→write sequence must be atomic to avoid e.g. markSuccess being
+// overwritten by a concurrent bundleURL and the version being rolled back.
+static os_unfair_lock pushyStateLock = OS_UNFAIR_LOCK_INIT;
+
+PUSHY_HIDDEN void PushyWithStateLock(void (NS_NOESCAPE ^block)(void)) {
+#if DEBUG
+    // Not re-entrant: a nested acquisition deadlocks in release, so catch it
+    // where it is written.
+    os_unfair_lock_assert_not_owner(&pushyStateLock);
+#endif
+    os_unfair_lock_lock(&pushyStateLock);
+    @try {
+        block();
+    } @finally {
+        os_unfair_lock_unlock(&pushyStateLock);
+    }
+}
+
+PUSHY_HIDDEN std::string PushyToStdString(NSString *value) {
+    if (value == nil) {
+        return std::string();
+    }
+    return std::string([value UTF8String]);
+}
+
+PUSHY_HIDDEN NSUserDefaults *PushyDefaults(void) {
+    return [NSUserDefaults standardUserDefaults];
+}
+
+PUSHY_HIDDEN NSString *PushyFromStdString(const std::string &value) {
+    if (value.empty()) {
+        return nil;
+    }
+    return [NSString stringWithUTF8String:value.c_str()];
+}
+
+static void PushySetNullableString(NSUserDefaults *defaults, NSString *key, NSString *value) {
+    if (value != nil) {
+        [defaults setObject:value forKey:key];
+    } else {
+        [defaults removeObjectForKey:key];
+    }
+}
+
+PUSHY_HIDDEN NSString *PushyHashInfoKey(NSString *hash) {
+    return [keyHashInfo stringByAppendingString:hash ?: @""];
+}
+
+PUSHY_HIDDEN NSString *PushyOptionString(NSDictionary *options, NSString *key) {
+    return [RCTConvert NSString:options[key]];
+}
+
+PUSHY_HIDDEN BOOL PushyStringIsBlank(NSString *value) {
+    if (value == nil || [value isKindOfClass:[NSNull class]]) {
+        return YES;
+    }
+    return [[value stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]] length] == 0;
+}
+
+// Server-provided identifiers (hash/originHash) are used as child names under
+// the download root; anything that could resolve outside of it (path
+// separators, "..", ".") must be rejected before touching the filesystem.
+PUSHY_HIDDEN BOOL PushyIsSafePathComponent(NSString *value) {
+    if (PushyStringIsBlank(value)) {
+        return NO;
+    }
+    if ([value isEqualToString:@"."] || [value isEqualToString:@".."]) {
+        return NO;
+    }
+    if ([value containsString:@"/"] || [value containsString:@"\\"]) {
+        return NO;
+    }
+    if ([value rangeOfString:@"\0"].location != NSNotFound) {
+        return NO;
+    }
+    return YES;
+}
+
+PUSHY_HIDDEN NSError *PushyErrorWithCode(const char *code, NSString *message) {
+    return [NSError errorWithDomain:RCTPushyErrorDomain
+                               code:-1
+                           userInfo:@{
+                               NSLocalizedDescriptionKey: message ?: @"unknown error",
+                               RCTPushyErrorCodeKey: @(code),
+                           }];
+}
+
+PUSHY_HIDDEN void PushyRejectError(RCTPromiseRejectBlock reject, NSError *error) {
+    // Prefer the stable cross-platform code (error_codes.h); fall back to the
+    // numeric NSError code for system errors that were not classified.
+    NSString *code = error.userInfo[RCTPushyErrorCodeKey];
+    if (code == nil) {
+        code = [NSString stringWithFormat:@"%ld", (long)error.code];
+    }
+    reject(code, error.localizedDescription, error);
+}
+
+PUSHY_HIDDEN NSDictionary *PushyJsonDictionary(id json, NSError **error) {
+    NSData *data = [json isKindOfClass:[NSString class]]
+        ? [(NSString *)json dataUsingEncoding:NSUTF8StringEncoding]
+        : ([json isKindOfClass:[NSData class]] ? (NSData *)json : nil);
+    id object = data == nil ? nil
+        : [NSJSONSerialization JSONObjectWithData:data options:0 error:error];
+    return [object isKindOfClass:[NSDictionary class]] ? (NSDictionary *)object : nil;
+}
+
+PUSHY_HIDDEN NSString *PushyJsonString(id object) {
+    NSData *data = object == nil ? nil
+        : [NSJSONSerialization dataWithJSONObject:object options:0 error:nil];
+    return data == nil ? nil : [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+}
+
+// Binary identity under the prefixed key, or — until the first state write
+// migrates it — the value an earlier SDK left under the unprefixed one, so an
+// installed update survives the SDK upgrade instead of reading as a rebuilt
+// binary.
+static NSString *PushyBinaryIdentityValue(NSUserDefaults *defaults, NSString *key, NSString *legacyKey) {
+    return [defaults stringForKey:key] ?: [defaults stringForKey:legacyKey];
+}
+
+PUSHY_HIDDEN pushy::state::State PushyStateFromDefaults(NSUserDefaults *defaults) {
+    pushy::state::State state;
+    state.package_version = PushyToStdString(
+        PushyBinaryIdentityValue(defaults, paramPackageVersion, legacyParamPackageVersion));
+    state.build_time = PushyToStdString(
+        PushyBinaryIdentityValue(defaults, paramBuildTime, legacyParamBuildTime));
+    NSDictionary *pushyInfo = [defaults dictionaryForKey:keyPushyInfo];
+    if (pushyInfo != nil) {
+        state.current_version = PushyToStdString(pushyInfo[paramCurrentVersion]);
+        state.last_version = PushyToStdString(pushyInfo[paramLastVersion]);
+        state.first_time = [pushyInfo[paramIsFirstTime] boolValue];
+        id firstLoadOk = pushyInfo[paramIsFirstLoadOk];
+        state.first_time_ok = firstLoadOk == nil ? true : [firstLoadOk boolValue];
+    }
+    state.rolled_back_version = PushyToStdString([defaults stringForKey:keyRolledBackMarked]);
+    return state;
+}
+
+PUSHY_HIDDEN void PushyApplyStateToDefaults(NSUserDefaults *defaults, const pushy::state::State &state) {
+    PushySetNullableString(defaults, paramPackageVersion, PushyFromStdString(state.package_version));
+    PushySetNullableString(defaults, paramBuildTime, PushyFromStdString(state.build_time));
+    // One-time migration: once the prefixed keys hold the identity, the
+    // legacy ones are retired so a host-app write there is never read again.
+    [defaults removeObjectForKey:legacyParamPackageVersion];
+    [defaults removeObjectForKey:legacyParamBuildTime];
+
+    BOOL hasPushyInfo = !state.current_version.empty() || !state.last_version.empty() || state.first_time || !state.first_time_ok;
+    if (hasPushyInfo) {
+        NSMutableDictionary *newInfo = [[NSMutableDictionary alloc] init];
+        if (!state.current_version.empty()) {
+            newInfo[paramCurrentVersion] = PushyFromStdString(state.current_version);
+        }
+        if (!state.last_version.empty()) {
+            newInfo[paramLastVersion] = PushyFromStdString(state.last_version);
+        }
+        newInfo[paramIsFirstTime] = @(state.first_time);
+        newInfo[paramIsFirstLoadOk] = @(state.first_time_ok);
+        [defaults setObject:newInfo forKey:keyPushyInfo];
+    } else {
+        [defaults removeObjectForKey:keyPushyInfo];
+    }
+
+    PushySetNullableString(
+        defaults,
+        keyRolledBackMarked,
+        PushyFromStdString(state.rolled_back_version));
+}
+
+// Version switch without acquiring the state lock: the caller must already
+// hold it. Lets the cold-start check commit its whole result (version info,
+// switch, response cache) inside one lock acquisition, so resetToPackagedBundle
+// can never interleave between the generation check and the writes.
+PUSHY_HIDDEN void PushySwitchVersionLocked(NSString *hash) {
+    NSUserDefaults *defaults = PushyDefaults();
+    pushy::state::State next = pushy::state::SwitchVersion(
+        PushyStateFromDefaults(defaults),
+        PushyToStdString(hash)
+    );
+    PushyApplyStateToDefaults(defaults, next);
+    // Re-enable first-load consumption and rollback checks for the newly selected bundle.
+    ignoreRollback = false;
+}
+
+static NSString *PushyCachedBundleHash(NSUserDefaults *defaults, NSString *cachedPrefix) {
+    NSString *cached = [defaults stringForKey:keyBundleHashCache];
+    if ([cached hasPrefix:cachedPrefix]) {
+        return [cached substringFromIndex:cachedPrefix.length];
+    }
+    return nil;
+}
+
+// Shared by the getBundleHash RCT method and the native cold-start check.
+// Returns @"" when unknown. With computeIfMissing the sha256 of the embedded
+// bundle is taken on a cache miss (once per install; blocking — call off the
+// main thread). Without it only the cache is consulted: a crash rescue on
+// the main thread has a 3.5s budget in total, and hashing a large bundle on
+// a fresh install would spend all of it before the first request.
+PUSHY_HIDDEN NSString *PushyBundleHashSync(BOOL computeIfMissing) {
+    NSString *path = [[RCTPushy binaryBundleURL] path];
+    if (path == nil) {
+        return @"";
+    }
+    NSDictionary *attributes =
+        [[NSFileManager defaultManager] attributesOfItemAtPath:path error:nil];
+    if (attributes == nil) {
+        return @"";
+    }
+    NSString *cacheKey = [NSString stringWithFormat:@"%@|%llu|%.0f",
+        [RCTPushy packageVersion],
+        attributes.fileSize,
+        [attributes.fileModificationDate timeIntervalSince1970]];
+
+    NSUserDefaults *defaults = PushyDefaults();
+    NSString *cachedPrefix = [cacheKey stringByAppendingString:@"|"];
+    NSString *cached = PushyCachedBundleHash(defaults, cachedPrefix);
+    if (cached != nil) {
+        return cached;
+    }
+    if (!computeIfMissing) {
+        return @"";
+    }
+
+    // Single-flight for the digest: the delayed cold-start round (utility
+    // queue) and JS getBundleHash (file queue) can both miss the cache right
+    // after an install; the second caller waits for the first and then reads
+    // its cache entry instead of hashing the same multi-MB file twice.
+    static NSLock *lock = [NSLock new];
+    [lock lock];
+    @try {
+        // The previous holder may have filled the cache while we waited.
+        cached = PushyCachedBundleHash(defaults, cachedPrefix);
+        if (cached != nil) {
+            return cached;
+        }
+        NSString *hash = PushyFromStdString(
+            pushy::digest::Sha256File(PushyToStdString(path))) ?: @"";
+        if (hash.length > 0) {
+            [defaults setObject:[cachedPrefix stringByAppendingString:hash]
+                         forKey:keyBundleHashCache];
+        }
+        return hash;
+    } @finally {
+        [lock unlock];
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-update",
-  "version": "10.59.1",
-  "description": "react-native hot update",
+  "version": "10.60.0",
+  "description": "Hot update (OTA) for React Native with Hermes-optimized diff patches, crash rollback and staged rollout. A CodePush alternative for iOS, Android and HarmonyOS.",
   "main": "src/index",
   "types": "src/index.ts",
   "files": [
@@ -15,13 +15,11 @@
     "android/build.gradle",
     "android/proguard.pro",
     "ios",
-    "cpp/patch_core",
-    "cpp/update_flow_core",
+    "cpp",
     "!cpp/**/tests",
     "harmony/pushy.har",
     "harmony/hvigor-plugin.ts",
     "harmony/pushy/src",
-    "!harmony/pushy/src/test",
     "react-native-update.podspec",
     "react-native.config.js",
     "expo-module.config.json",
@@ -30,10 +28,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "prepublishOnly": "NODE_ENV=production bun scripts/prepublish.ts",
-    "publish:local": "SKIP_NATIVE_BUILD=1 npm publish",
     "prepack": "bun submodule && bun lint",
-    "lint": "biome check src && tsc --noEmit && node scripts/check-harmony-types.js && node scripts/check-native-spec-parity.js",
+    "lint": "biome check src && tsc --noEmit && node scripts/check-harmony-types.js && node scripts/check-native-spec-parity.js && node scripts/check-constant-parity.js",
     "lint:harmony": "node scripts/check-harmony-types.js",
     "submodule": "git submodule update --init --recursive",
     "test": "bun test src/__tests__",
@@ -43,14 +39,11 @@
     "build:harmony-har": "node scripts/build-harmony-har.js",
     "build:harmony-e2e": "bash Example/e2etest/scripts/build-harmony-e2e.sh",
     "build:so": "bun submodule && bash scripts/build-android-so.sh",
-    "build:ios-debug": "cd Example/e2etest && bun && bunx detox build --configuration ios.sim.debug",
     "build:ios-release": "cd Example/e2etest && bun && bunx detox build --configuration ios.sim.release",
-    "test:ios-debug": "cd Example/e2etest && E2E_PLATFORM=ios bunx detox test --configuration ios.sim.debug",
     "test:ios-release": "cd Example/e2etest && E2E_PLATFORM=ios bunx detox test --configuration ios.sim.release",
     "build:android-debug": "cd Example/e2etest && bun && bunx detox build --configuration android.emu.debug",
     "build:android-release": "cd Example/e2etest && bun && bunx detox build --configuration android.emu.release",
     "test:android-release": "cd Example/e2etest && E2E_PLATFORM=android bunx detox test --configuration android.emu.release --headless --record-logs all",
-    "test:android-debug": "cd Example/e2etest && E2E_PLATFORM=android bunx detox test --configuration android.emu.debug --headless --record-logs all",
     "smoke:android-debug": "cd Example/e2etest && bunx detox test --configuration android.emu.debug --config e2e/smoke/jest.config.js",
     "e2e:ios": "bun build:ios-release && bun test:ios-release",
     "e2e:android": "bun build:android-release && bun test:android-release"
@@ -63,7 +56,21 @@
     "react-native",
     "ios",
     "android",
-    "update"
+    "update",
+    "hot-update",
+    "hotfix",
+    "ota",
+    "over-the-air",
+    "codepush",
+    "code-push",
+    "codepush-alternative",
+    "hermes",
+    "harmonyos",
+    "expo",
+    "incremental-update",
+    "bsdiff",
+    "pushy",
+    "cresc"
   ],
   "author": "reactnativecn",
   "license": "MIT",
@@ -75,26 +82,21 @@
     "react-native": "*"
   },
   "homepage": "https://github.com/reactnativecn/react-native-update#readme",
-  "dependencies": {
-    "nanoid": "^3.3.3"
-  },
   "codegenConfig": {
     "name": "RCTPushySpec",
     "type": "modules",
     "jsSrcsDir": "src"
   },
   "devDependencies": {
-    "@babel/core": "^7.25.8",
     "@biomejs/biome": "^2.5.5",
-    "@react-native/babel-preset": "^0.73.21",
-    "@react-native/typescript-config": "0.84.1",
+    "@react-native/typescript-config": "0.85.2",
     "@types/bun": "^1.3.11",
     "@types/node": "^25.5.0",
     "@types/react": "^19.2.14",
-    "@types/react-test-renderer": "18.0.7",
-    "react": "18.2.0",
-    "react-native": "0.73",
-    "react-test-renderer": "18.2.0",
+    "@types/react-test-renderer": "19.1.0",
+    "react": "19.2.3",
+    "react-native": "0.85.2",
+    "react-test-renderer": "19.2.3",
     "typescript": "^7.0.2"
   }
-}
+}

package/react-native-update.podspec

@@ -1,8 +1,6 @@
 require 'json'
 require 'rubygems' # Required for version comparison
 
-
-new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
 package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
 podspec_dir = File.dirname(__FILE__)
 
@@ -20,37 +18,40 @@ Pod::Spec.new do |s|
      # Silently ignore errors during check
   end
 
-  # expo-modules-core is a dependency of expo, not of the app: resolve it from
-  # expo's own location. A bare require from this podspec's directory misses
-  # it when npm nests it under expo/node_modules (seen with react-native-tvos),
-  # which left EXPO_SUPPORTS_BUNDLEURL unset; the createBridge fallback that
-  # selects no longer exists in ExpoModulesCore (SDK 57), so the build failed.
-  expo_modules_core_package_json_js =
-    "require.resolve('expo-modules-core/package.json', " \
-    "{ paths: [require('path').dirname(require.resolve('expo/package.json'))] })"
-
-  # Determine final validity by checking Podfile presence AND Expo version
-  valid_expo_project = false # Default
+  # One node call answers every Expo question: expo's version, and where
+  # expo-modules-core lives and its version. expo-modules-core is a dependency
+  # of expo, not of the app: resolve it from expo's own location. A bare
+  # require from this podspec's directory misses it when npm nests it under
+  # expo/node_modules (seen with react-native-tvos), which left
+  # EXPO_SUPPORTS_BUNDLEURL unset; the createBridge fallback that selects no
+  # longer exists in ExpoModulesCore (SDK 57), so the build failed.
+  expo_info = {}
   if is_expo_in_podfile
-    # Only check expo version if use_expo_modules! is present
-    is_version_sufficient = false
+    expo_info_js = <<~JS
+      const path = require('path');
+      const info = {};
+      try {
+        const expoJson = require.resolve('expo/package.json');
+        info.expoVersion = require(expoJson).version;
+        const coreJson = require.resolve('expo-modules-core/package.json',
+                                         { paths: [path.dirname(expoJson)] });
+        info.coreDir = path.dirname(coreJson);
+        info.coreVersion = require(coreJson).version;
+      } catch (e) {}
+      console.log(JSON.stringify(info));
+    JS
     begin
-        expo_version_str = `node --print \"require('expo/package.json').version\"`.strip
-        if expo_version_str && !expo_version_str.empty?
-          match = expo_version_str.match(/^\d+/)
-          if match
-            major_version = match[0].to_i
-            is_version_sufficient = major_version >= 50
-          end
-        end
-    rescue
-        # Node command failed, version remains insufficient
+      output = IO.popen(['node', '-e', expo_info_js], &:read)
+      expo_info = JSON.parse(output) if $?.success?
+    rescue StandardError
+      # node missing or unparseable output: not a supported Expo project.
     end
-    
-    # Final check
-    valid_expo_project = is_version_sufficient
   end
 
+  # use_expo_modules! in the Podfile and Expo SDK >= 50.
+  valid_expo_project =
+    is_expo_in_podfile && expo_info['expoVersion'].to_s[/^\d+/].to_i >= 50
+
   # Set platform based on whether it's a valid Expo project and if we can parse its target
   # React Native's own minimum (defined by react_native_pods.rb, which the
   # Podfile loads before evaluating podspecs). The pod platform version also
@@ -59,16 +60,23 @@ Pod::Spec.new do |s|
   # anything below 15.0 there, so a hard-coded 11.0 fails the build.
   final_ios_deployment_target =
     defined?(min_ios_version_supported) ? min_ios_version_supported : '11.0'
+  # tvOS has its own version line: react-native-tvos reports it through
+  # min_supported_versions[:tvos] (stock React Native has no :tvos entry).
+  # 15.1 is react-native-tvos's own floor since 0.76, and clears the same
+  # Xcode 27 resource-bundle minimum as iOS.
+  final_tvos_deployment_target = begin
+    defined?(min_supported_versions) ? min_supported_versions[:tvos] : nil
+  rescue StandardError
+    nil
+  end
+  final_tvos_deployment_target ||= '15.1'
 
   if valid_expo_project
     # --- Try to find and parse ExpoModulesCore.podspec only if it's an Expo project ---
     parsed_expo_ios_target = nil
-    expo_modules_core_podspec_path = begin
-        package_json_path = `node -p "#{expo_modules_core_package_json_js}"`.strip
-        File.join(File.dirname(package_json_path), 'ExpoModulesCore.podspec') if $?.success? && package_json_path && !package_json_path.empty?
-    rescue
-        nil
-    end
+    parsed_expo_tvos_target = nil
+    expo_modules_core_podspec_path =
+      expo_info['coreDir'] && File.join(expo_info['coreDir'], 'ExpoModulesCore.podspec')
 
     if expo_modules_core_podspec_path && File.exist?(expo_modules_core_podspec_path)
       begin
@@ -76,11 +84,8 @@ Pod::Spec.new do |s|
         match = content.match(/s\.platforms\s*=\s*\{[\s\S]*?:ios\s*=>\s*'([^\']+)'/) # Match within s.platforms hash
         if match && match[1]
           parsed_expo_ios_target = match[1]
-        else
-          match = content.match(/s\.platform\s*=\s*:ios,\s*'([^\']+)'/) # Fallback to s.platform = :ios, 'version'
-          if match && match[1]
-            parsed_expo_ios_target = match[1]
-          end
+          tvos_match = content.match(/s\.platforms\s*=\s*\{[\s\S]*?:tvos\s*=>\s*'([^\']+)'/)
+          parsed_expo_tvos_target = tvos_match[1] if tvos_match
         end
       rescue => e
         # Pod::UI.warn "Failed to read or parse ExpoModulesCore.podspec content: #{e.message}"
@@ -89,12 +94,15 @@ Pod::Spec.new do |s|
     if parsed_expo_ios_target
         final_ios_deployment_target = parsed_expo_ios_target
     end
+    if parsed_expo_tvos_target
+        final_tvos_deployment_target = parsed_expo_tvos_target
+    end
   end
 
   # tvOS (react-native-tvos) shares the iOS sources; the only platform
-  # differences live behind TARGET_OS_TV in RCTPushy.mm (download directory,
+  # differences live behind TARGET_OS_TV in ios/RCTPushy (download directory,
   # purged-cache recovery).
-  s.platforms = { :ios => final_ios_deployment_target, :tvos => final_ios_deployment_target }
+  s.platforms = { :ios => final_ios_deployment_target, :tvos => final_tvos_deployment_target }
 
   s.name         = package['name']
   s.version      = package['version']
@@ -109,6 +117,9 @@ Pod::Spec.new do |s|
   s.source = { :git => 'https://github.com/reactnativecn/react-native-update.git', :tag => "#{s.version}" }
 
   s.libraries = 'bz2', 'z'
+  # tvOS checks for a network path before blocking a launch on the
+  # purged-version restore (nw_path_monitor).
+  s.tvos.frameworks = 'Network'
   # No search path into the pod source: every include under ios/ resolves
   # relative to the including file (the cpp/ core via ../../cpp/...), and the
   # former absolute "#{podspec_dir}/ios" entry made the generated xcconfig
@@ -116,9 +127,9 @@ Pod::Spec.new do |s|
   # DEFINES_MODULE writes the umbrella under Headers/Public/react_native_update/
   # (underscores). CocoaPods copies public headers to react-native-update/
   # (hyphens). Include the latter so the umbrella can #import "ImportReact.h".
-  s.pod_target_xcconfig = { 
-    'USER_HEADER_SEARCH_PATHS' => "\"$(PODS_ROOT)/Headers/Public/react-native-update\" \"$(PODS_ROOT)/Headers/Public/SSZipArchive\" \"$(PODS_ROOT)/Headers/Public/React-Codegen/RCTPushySpec\"", 
-    "DEFINES_MODULE" => "YES" 
+  s.pod_target_xcconfig = {
+    'USER_HEADER_SEARCH_PATHS' => "\"$(PODS_ROOT)/Headers/Public/react-native-update\"",
+    "DEFINES_MODULE" => "YES"
   }
   # buildTime for binary-rebuild detection (SyncBinaryVersion) and the check
   # request. The stamp is refreshed on every build and ships as a resource.
@@ -147,9 +158,8 @@ Pod::Spec.new do |s|
   # Privacy manifest (required-reason APIs: disk space, file timestamps,
   # system boot time, user defaults) delivered as its own resource bundle so
   # static and dynamic integrations both carry it.
-  s.resource_bundles = { 'react-native-update_privacy' => ['ios/PrivacyInfo.xcprivacy'] }
+  s.resource_bundles = { 'PushyPrivacy' => ['ios/PrivacyInfo.xcprivacy'] }
 
-  s.dependency 'React'
   s.dependency "React-Core"
   # The unzip guard relies on the 2.x delegate contract
   # (zipArchiveShouldUnzipFileAtIndex:... cancels, _sanitizedPath); a future
@@ -171,15 +181,12 @@ Pod::Spec.new do |s|
   # Objective-C classes in the RCTPushy subspec keep default visibility, which
   # the host app and the Expo module need to link against RCTPushy.
   s.subspec 'Core' do |ss|
-    ss.source_files = ['cpp/update_flow_core/flow_json.{h,cpp}',
-                       'cpp/update_flow_core/update_flow_core.{h,cpp}',
-                       'cpp/patch_core/archive_patch_core.{h,cpp}',
-                       'cpp/patch_core/digest.{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}',
+    # The cores are picked up by directory (non-recursive: tests/ stays out,
+    # and the Android JNI glue lives in cpp/android_jni), so a new
+    # platform-neutral source needs no edit here.
+    ss.source_files = ['cpp/patch_core/*.{h,cpp}',
+                       'cpp/update_flow_core/*.{h,cpp}',
+                       'cpp/hpatch/*.{h,c}',
                        'android/jni/HDiffPatch/libHDiffPatch/HPatch/*.{h,c}',
                        'android/jni/HDiffPatch/file_for_patch.{h,c}',
                        'android/jni/lzma/C/LzmaDec.{h,c}',
@@ -193,23 +200,21 @@ Pod::Spec.new do |s|
   s.subspec 'RCTPushy' do |ss|
     ss.dependency 'react-native-update/Core'
     ss.source_files = ['ios/RCTPushy/*.{h,m,mm}']
-    ss.public_header_files = ['ios/RCTPushy/*.h']
+    ss.public_header_files = ['ios/RCTPushy/RCTPushy.h',
+                              'ios/RCTPushy/RCTPushyConfiguration.h',
+                              'ios/RCTPushy/RCTPushyDownloader.h']
+    # Shared by the pod's own sources only (RCTPushyInternal.h pulls in C++
+    # headers), so they must stay out of the module umbrella.
+    ss.private_header_files = ['ios/RCTPushy/RCTPushyCommon.h',
+                               'ios/RCTPushy/RCTPushyInternal.h']
   end
 
   # Conditionally add Expo subspec and check ExpoModulesCore version
   if valid_expo_project
     supports_bundle_url_final = false # Default
 
-    # 1. Try executing node to get the version string
-    expo_modules_core_version_str = begin
-      `node --print "require(#{expo_modules_core_package_json_js}).version"` # Execute, keep raw output
-    rescue
-      # Node command failed (e.g., node not found, package not found). Return empty string.
-      ''
-    end
-
-    # 2. Process the obtained version string (if not empty)
-    if expo_modules_core_version_str && !expo_modules_core_version_str.empty?
+    expo_modules_core_version_str = expo_info['coreVersion'].to_s
+    if !expo_modules_core_version_str.empty?
         begin
             # Compare versions using Gem::Version (handles trailing newline)
             installed_version = Gem::Version.new(expo_modules_core_version_str)
@@ -228,23 +233,9 @@ Pod::Spec.new do |s|
     end
   end
 
+  # React Native >= 0.71 (react_native_pods.rb) wires codegen, the new
+  # architecture and its dependencies.
   if defined?(install_modules_dependencies()) != nil
-    install_modules_dependencies(s);
-  else
-    if new_arch_enabled
-      folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
-
-      s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
-
-      s.pod_target_xcconfig = {
-          "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
-          "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
-      }.merge(s.pod_target_xcconfig)
-      s.dependency "React-Codegen"
-      s.dependency "RCT-Folly"
-      s.dependency "RCTRequired"
-      s.dependency "RCTTypeSafety"
-      s.dependency "ReactCommon/turbomodule/core"
-    end
+    install_modules_dependencies(s)
   end
 end