react-native-update 10.44.0 → 10.46.0

package/android/jni/Android.mk

@@ -20,7 +20,6 @@ Hdp_Files := \
     lzma/C/Lzma2Dec.c
 
 LOCAL_SRC_FILES := \
-	DownloadTask.c \
 	../../cpp/patch_core/archive_patch_core.cpp \
 	../../cpp/patch_core/patch_core.cpp \
 	../../cpp/patch_core/patch_core_android.cpp \

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

@@ -33,7 +33,16 @@ class DownloadTask implements Runnable {
     // events on percentage change, so throttle by bytes to avoid flooding the
     // bridge (e.g. a 20MB chunked download would otherwise emit ~5000 events).
     private static final long PROGRESS_BYTES_THRESHOLD = 256 * 1024;
-    private static final OkHttpClient HTTP_CLIENT = new OkHttpClient();
+    // Explicit timeouts: the default client has no call timeout, so a
+    // slow-dripping connection could occupy the single-threaded download
+    // executor indefinitely and starve queued tasks. The call timeout is a
+    // generous upper bound sized for large full-package downloads.
+    private static final OkHttpClient HTTP_CLIENT = new OkHttpClient.Builder()
+            .connectTimeout(15, java.util.concurrent.TimeUnit.SECONDS)
+            .readTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+            .writeTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+            .callTimeout(10, java.util.concurrent.TimeUnit.MINUTES)
+            .build();
 
     static {
         NativeUpdateCore.ensureLoaded();

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

@@ -0,0 +1,24 @@
+package cn.reactnative.modules.update;
+
+/**
+ * Stable, machine-readable error codes used as the promise rejection code so
+ * the JS layer and user loggers can aggregate errors across platforms.
+ *
+ * MUST stay in sync with cpp/patch_core/error_codes.h (the single source of
+ * truth) and src/error.ts (UpdateErrorCode). Messages are free-form; only the
+ * codes are part of the contract.
+ */
+final class ErrorCodes {
+    static final String INVALID_OPTIONS = "INVALID_OPTIONS";
+    static final String DOWNLOAD_FAILED = "DOWNLOAD_FAILED";
+    static final String PATCH_FAILED = "PATCH_FAILED";
+    static final String FILE_OPERATION_FAILED = "FILE_OPERATION_FAILED";
+    static final String SWITCH_VERSION_FAILED = "SWITCH_VERSION_FAILED";
+    static final String MARK_SUCCESS_FAILED = "MARK_SUCCESS_FAILED";
+    static final String RESTART_FAILED = "RESTART_FAILED";
+    static final String INVALID_HASH_INFO = "INVALID_HASH_INFO";
+    static final String UNSUPPORTED_PLATFORM = "UNSUPPORTED_PLATFORM";
+
+    private ErrorCodes() {
+    }
+}

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

@@ -43,6 +43,7 @@ final class StateSerialRunner {
 
     static void run(
         @Nullable final Promise promise,
+        final String errorCode,
         final String operationName,
         final Operation operation
     ) {
@@ -53,7 +54,7 @@ final class StateSerialRunner {
                     operation.run();
                 } catch (Throwable error) {
                     if (promise != null) {
-                        promise.reject(operationName + " failed", error);
+                        promise.reject(errorCode, operationName + " failed", error);
                     } else {
                         Log.e(UpdateContext.TAG, operationName + " failed", error);
                     }

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

@@ -15,6 +15,7 @@ final class UiThreadRunner {
 
     static void run(
         @Nullable final Promise promise,
+        final String errorCode,
         final String operationName,
         final Operation operation
     ) {
@@ -25,7 +26,7 @@ final class UiThreadRunner {
                     operation.run();
                 } catch (Throwable error) {
                     if (promise != null) {
-                        promise.reject(operationName + " failed", error);
+                        promise.reject(errorCode, operationName + " failed", error);
                     } else {
                         Log.e(UpdateContext.TAG, operationName + " failed", error);
                     }

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

@@ -207,14 +207,16 @@ public class UpdateContext {
     }
 
     private void persistEditor(SharedPreferences.Editor editor, String reason) {
-        if (!editor.commit() && DEBUG) {
-            Log.w(TAG, "Failed to persist update state for " + reason);
+        // A lost state write can mean a missed rollback or a version switch
+        // that silently never happens, so this must be visible in release too.
+        if (!editor.commit()) {
+            Log.e(TAG, "Failed to persist update state for " + reason);
         }
     }
 
     public void switchVersion(String hash) {
         if (!new File(rootDir, hash+"/index.bundlejs").exists()) {
-            throw new Error("Bundle version " + hash + " not found.");
+            throw new IllegalStateException("Bundle version " + hash + " not found.");
         }
         StateCoreResult currentState = getStateSnapshot();
         StateCoreResult nextState = runStateCore(
@@ -367,6 +369,13 @@ public class UpdateContext {
             ignoreRollback,
             true
         );
+        if (launchState.didRollback) {
+            // The crash-protection rollback: the new version never called
+            // markSuccess. Keep this visible in release logs.
+            Log.e(TAG, "Version " + currentState.currentVersion
+                + " was not marked as successful, rolling back to "
+                + launchState.currentVersion);
+        }
         if (launchState.didRollback || launchState.consumedFirstTime) {
             SharedPreferences.Editor editor = sp.edit();
             applyState(editor, launchState);
@@ -385,7 +394,11 @@ public class UpdateContext {
             return defaultAssetsUrl;
         }
 
-        while (currentVersion != null) {
+        // Guard the rollback chain against cycles: a corrupted state returning
+        // an already-visited version would otherwise spin this loop forever on
+        // the main thread.
+        java.util.HashSet<String> visitedVersions = new java.util.HashSet<>();
+        while (currentVersion != null && visitedVersions.add(currentVersion)) {
             File bundleFile = new File(rootDir, currentVersion+"/index.bundlejs");
             if (!bundleFile.exists()) {
                 Log.e(TAG, "Bundle version " + currentVersion + " not found.");
@@ -407,6 +420,8 @@ public class UpdateContext {
             false,
             false
         );
+        Log.e(TAG, "Rolling back version " + currentState.currentVersion
+            + " to " + nextState.currentVersion);
         SharedPreferences.Editor editor = sp.edit();
         applyState(editor, nextState);
         persistEditor(editor, "rollback");

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

@@ -24,7 +24,7 @@ final class UpdateEventEmitter {
 
     static void sendEvent(String eventName, WritableMap params) {
         ReactApplicationContext reactContext = getReactContext();
-        if (reactContext == null || !reactContext.hasActiveCatalystInstance()) {
+        if (reactContext == null || !hasActiveInstance(reactContext)) {
             return;
         }
 
@@ -32,4 +32,16 @@ final class UpdateEventEmitter {
             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
             .emit(eventName, params);
     }
+
+    @SuppressWarnings("deprecation")
+    private static boolean hasActiveInstance(ReactApplicationContext reactContext) {
+        try {
+            // hasActiveCatalystInstance() is always false in bridgeless mode, which
+            // silently drops every progress event on the new architecture.
+            return reactContext.hasActiveReactInstance();
+        } catch (NoSuchMethodError e) {
+            // RN < 0.68 has no hasActiveReactInstance(); fall back for old peers.
+            return reactContext.hasActiveCatalystInstance();
+        }
+    }
 }

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

@@ -41,7 +41,7 @@ public class UpdateModuleImpl {
 
             @Override
             public void onDownloadFailed(Throwable error) {
-                promise.reject(error);
+                promise.reject(ErrorCodes.DOWNLOAD_FAILED, error);
             }
         });
     }
@@ -64,7 +64,7 @@ public class UpdateModuleImpl {
 
             @Override
             public void onDownloadFailed(Throwable error) {
-                promise.reject(error);
+                promise.reject(ErrorCodes.DOWNLOAD_FAILED, error);
             }
         });
     }
@@ -84,7 +84,7 @@ public class UpdateModuleImpl {
 
             @Override
             public void onDownloadFailed(Throwable error) {
-                promise.reject(error);
+                promise.reject(ErrorCodes.DOWNLOAD_FAILED, error);
             }
         });
     }
@@ -107,11 +107,11 @@ public class UpdateModuleImpl {
 
                 @Override
                 public void onDownloadFailed(Throwable error) {
-                    promise.reject(error);
+                    promise.reject(ErrorCodes.DOWNLOAD_FAILED, error);
                 }
             });
         } catch (Exception e) {
-            promise.reject("downloadPatchFromPpk failed: " + e.getMessage());
+            promise.reject(ErrorCodes.INVALID_OPTIONS, "downloadPatchFromPpk failed: " + e.getMessage(), e);
         }
     }
 
@@ -130,7 +130,7 @@ public class UpdateModuleImpl {
         @Nullable final String hash,
         final Promise promise
     ) {
-        UiThreadRunner.run(promise, "restartApp", new UiThreadRunner.Operation() {
+        UiThreadRunner.run(promise, ErrorCodes.RESTART_FAILED, "restartApp", new UiThreadRunner.Operation() {
             @Override
             public void run() throws Throwable {
                 ReactReloadManager.restartApp(updateContext, reactContext, hash);
@@ -149,7 +149,7 @@ public class UpdateModuleImpl {
         final Promise promise
     ) {
         final String hash = options.getString("hash");
-        StateSerialRunner.run(promise, "switchVersionLater", new StateSerialRunner.Operation() {
+        StateSerialRunner.run(promise, ErrorCodes.SWITCH_VERSION_FAILED, "switchVersionLater", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setNeedUpdateInternal(updateContext, hash);
@@ -160,7 +160,7 @@ public class UpdateModuleImpl {
 
     public static void setNeedUpdate(final UpdateContext updateContext, final ReadableMap options) {
         final String hash = options.getString("hash");
-        StateSerialRunner.run(null, "switchVersionLater", new StateSerialRunner.Operation() {
+        StateSerialRunner.run(null, ErrorCodes.SWITCH_VERSION_FAILED, "switchVersionLater", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setNeedUpdateInternal(updateContext, hash);
@@ -173,7 +173,7 @@ public class UpdateModuleImpl {
     }
 
     public static void markSuccess(final UpdateContext updateContext, final Promise promise) {
-        StateSerialRunner.run(promise, "markSuccess", new StateSerialRunner.Operation() {
+        StateSerialRunner.run(promise, ErrorCodes.MARK_SUCCESS_FAILED, "markSuccess", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 markSuccessInternal(updateContext);
@@ -183,7 +183,7 @@ public class UpdateModuleImpl {
     }
 
     public static void markSuccess(final UpdateContext updateContext) {
-        StateSerialRunner.run(null, "markSuccess", new StateSerialRunner.Operation() {
+        StateSerialRunner.run(null, ErrorCodes.MARK_SUCCESS_FAILED, "markSuccess", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 markSuccessInternal(updateContext);
@@ -200,7 +200,7 @@ public class UpdateModuleImpl {
         final String uuid,
         final Promise promise
     ) {
-        StateSerialRunner.run(promise, "setUuid", new StateSerialRunner.Operation() {
+        StateSerialRunner.run(promise, ErrorCodes.FILE_OPERATION_FAILED, "setUuid", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setUuidInternal(updateContext, uuid);
@@ -210,7 +210,7 @@ public class UpdateModuleImpl {
     }
 
     public static void setUuid(final UpdateContext updateContext, final String uuid) {
-        StateSerialRunner.run(null, "setUuid", new StateSerialRunner.Operation() {
+        StateSerialRunner.run(null, ErrorCodes.FILE_OPERATION_FAILED, "setUuid", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setUuidInternal(updateContext, uuid);
@@ -235,7 +235,7 @@ public class UpdateModuleImpl {
         final String info,
         final Promise promise
     ) {
-        StateSerialRunner.run(promise, "setLocalHashInfo", new StateSerialRunner.Operation() {
+        StateSerialRunner.run(promise, ErrorCodes.INVALID_HASH_INFO, "setLocalHashInfo", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setLocalHashInfoInternal(updateContext, hash, info);
@@ -249,7 +249,7 @@ public class UpdateModuleImpl {
         final String hash,
         final String info
     ) {
-        StateSerialRunner.run(null, "setLocalHashInfo", new StateSerialRunner.Operation() {
+        StateSerialRunner.run(null, ErrorCodes.INVALID_HASH_INFO, "setLocalHashInfo", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setLocalHashInfoInternal(updateContext, hash, info);
@@ -264,7 +264,7 @@ public class UpdateModuleImpl {
     ) {
         String value = updateContext.getKv("hash_" + hash);
         if (!isValidHashInfo(value)) {
-            promise.reject("getLocalHashInfo failed: invalid json string");
+            promise.reject(ErrorCodes.INVALID_HASH_INFO, "getLocalHashInfo failed: invalid json string");
             return;
         }
 

package/cpp/patch_core/error_codes.h

@@ -0,0 +1,43 @@
+#ifndef PUSHY_PATCH_CORE_ERROR_CODES_H_
+#define PUSHY_PATCH_CORE_ERROR_CODES_H_
+
+// Single source of truth for the stable, machine-readable error codes shared
+// by every platform. Native modules reject promises with one of these codes
+// so the JS layer (src/error.ts UpdateErrorCode) and user loggers can
+// aggregate errors across platforms and locales.
+//
+// Mirrors that cannot include this header MUST stay in sync by hand:
+//   - src/error.ts                      (UpdateErrorCode union, JS layer)
+//   - android/.../ErrorCodes.java      (Java constants)
+// iOS (RCTPushy.mm) includes this header directly.
+//
+// Human-readable messages are NOT part of this contract: they may differ per
+// platform and locale. Only the codes are stable.
+
+namespace pushy {
+namespace error_codes {
+
+// Method options missing or malformed (blank hash/url, wrong types).
+constexpr const char* kInvalidOptions = "INVALID_OPTIONS";
+// Native download failed (network error, bad HTTP status, truncated body).
+constexpr const char* kDownloadFailed = "DOWNLOAD_FAILED";
+// Unzip or hdiff patch application failed.
+constexpr const char* kPatchFailed = "PATCH_FAILED";
+// Local file or state persistence operation failed.
+constexpr const char* kFileOperationFailed = "FILE_OPERATION_FAILED";
+// switchVersion / setNeedUpdate state transition failed.
+constexpr const char* kSwitchVersionFailed = "SWITCH_VERSION_FAILED";
+// markSuccess state transition failed.
+constexpr const char* kMarkSuccessFailed = "MARK_SUCCESS_FAILED";
+// reloadUpdate / restartApp failed.
+constexpr const char* kRestartFailed = "RESTART_FAILED";
+// Stored or provided hash info is not a valid JSON object.
+constexpr const char* kInvalidHashInfo = "INVALID_HASH_INFO";
+// The method is not supported on this platform (e.g. downloadAndInstallApk
+// outside Android).
+constexpr const char* kUnsupportedPlatform = "UNSUPPORTED_PLATFORM";
+
+}  // namespace error_codes
+}  // namespace pushy
+
+#endif  // PUSHY_PATCH_CORE_ERROR_CODES_H_

package/cpp/patch_core/patch_core.cpp

@@ -8,7 +8,6 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include <set>
 #include <vector>
 
 extern "C" {
@@ -17,6 +16,11 @@ extern "C" {
 
 namespace pushy {
 namespace patch {
+
+namespace internal {
+bool g_disable_hard_links = false;
+}  // namespace internal
+
 namespace {
 
 constexpr size_t kCopyBufferSize = 16 * 1024;
@@ -202,6 +206,17 @@ Status CopyFile(const std::string& from, const std::string& to, bool overwrite)
     }
   }
 
+  // Prefer a hard link over copying bytes: unchanged files between versions
+  // are identical, so linking is O(1) per file, writes nothing to flash, and
+  // shares disk blocks. Version directories are immutable once created (patch
+  // outputs are always written as new files), so sharing the inode with the
+  // source is safe. Fall back to a byte copy whenever linking is not possible
+  // (cross-device source such as the installed app bundle, EPERM, EMLINK, or
+  // filesystems without hard-link support).
+  if (!internal::g_disable_hard_links && link(from.c_str(), to.c_str()) == 0) {
+    return Status::Ok();
+  }
+
   FILE* source = std::fopen(from.c_str(), "rb");
   if (!source) {
     return MakeErrnoStatus("Failed to open source file " + from);

package/cpp/patch_core/patch_core.h

@@ -64,5 +64,11 @@ Status CleanupOldEntries(
 
 bool IsSafeRelativePath(const std::string& path);
 
+namespace internal {
+// Test-only escape hatch: forces file copies to take the byte-copy fallback
+// instead of hard-linking, so tests can cover both paths on one filesystem.
+extern bool g_disable_hard_links;
+}  // namespace internal
+
 }  // namespace patch
 }  // namespace pushy

package/cpp/patch_core/tests/patch_core_test.cpp

@@ -175,6 +175,81 @@ void TestApplyPatchFromFileSourceMergesAndCopies() {
   Expect(!Exists(JoinPath(target, "assets/delete.txt")), "deleted asset should not be copied");
 }
 
+void TestApplyPatchMergeHardLinksUnchangedFiles() {
+  TempDir temp;
+  const std::string source = JoinPath(temp.path, "origin");
+  const std::string target = JoinPath(temp.path, "target");
+  const std::string patch = JoinPath(temp.path, "bundle.patch");
+
+  WriteFile(JoinPath(source, "index.bundlejs"), "old bundle");
+  WriteFile(JoinPath(source, "assets/keep.txt"), "keep");
+  WriteFile(patch, "unused patch");
+
+  FakeBundlePatcher patcher("patched bundle");
+  FileSourcePatchOptions options;
+  options.source_root = source;
+  options.target_root = target;
+  options.origin_bundle_path = JoinPath(source, "index.bundlejs");
+  options.bundle_patch_path = patch;
+  options.bundle_output_path = JoinPath(target, "index.bundlejs");
+  options.manifest.copies.push_back(CopyOperation{"assets/keep.txt", "assets/copied.txt"});
+
+  Status status = ApplyPatchFromFileSource(options, patcher);
+  Expect(status.ok, status.message);
+
+  // Unchanged files must share the source inode (hard link) instead of being
+  // byte-copied: same filesystem, so the fast path has to kick in.
+  struct stat source_stat;
+  struct stat merged_stat;
+  struct stat copied_stat;
+  Expect(stat(JoinPath(source, "assets/keep.txt").c_str(), &source_stat) == 0, "stat source");
+  Expect(stat(JoinPath(target, "assets/keep.txt").c_str(), &merged_stat) == 0, "stat merged");
+  Expect(stat(JoinPath(target, "assets/copied.txt").c_str(), &copied_stat) == 0, "stat copied");
+  Expect(merged_stat.st_ino == source_stat.st_ino, "merged file should hard-link the source");
+  Expect(copied_stat.st_ino == source_stat.st_ino, "manifest copy should hard-link the source");
+  Expect(source_stat.st_nlink >= 3, "source should have three names");
+  ExpectEq(ReadFile(JoinPath(target, "assets/keep.txt")), "keep", "merged content mismatch");
+
+  // The patched bundle must be a fresh file, never a link into the source dir.
+  struct stat bundle_stat;
+  struct stat origin_stat;
+  Expect(stat(JoinPath(target, "index.bundlejs").c_str(), &bundle_stat) == 0, "stat bundle");
+  Expect(stat(JoinPath(source, "index.bundlejs").c_str(), &origin_stat) == 0, "stat origin bundle");
+  Expect(bundle_stat.st_ino != origin_stat.st_ino, "patched bundle must not link the origin");
+}
+
+void TestApplyPatchMergeFallsBackToByteCopy() {
+  TempDir temp;
+  const std::string source = JoinPath(temp.path, "origin");
+  const std::string target = JoinPath(temp.path, "target");
+  const std::string patch = JoinPath(temp.path, "bundle.patch");
+
+  WriteFile(JoinPath(source, "index.bundlejs"), "old bundle");
+  WriteFile(JoinPath(source, "assets/keep.txt"), "keep");
+  WriteFile(patch, "unused patch");
+
+  FakeBundlePatcher patcher("patched bundle");
+  FileSourcePatchOptions options;
+  options.source_root = source;
+  options.target_root = target;
+  options.origin_bundle_path = JoinPath(source, "index.bundlejs");
+  options.bundle_patch_path = patch;
+  options.bundle_output_path = JoinPath(target, "index.bundlejs");
+
+  pushy::patch::internal::g_disable_hard_links = true;
+  Status status = ApplyPatchFromFileSource(options, patcher);
+  pushy::patch::internal::g_disable_hard_links = false;
+  Expect(status.ok, status.message);
+
+  struct stat source_stat;
+  struct stat merged_stat;
+  Expect(stat(JoinPath(source, "assets/keep.txt").c_str(), &source_stat) == 0, "stat source");
+  Expect(stat(JoinPath(target, "assets/keep.txt").c_str(), &merged_stat) == 0, "stat merged");
+  Expect(merged_stat.st_ino != source_stat.st_ino, "fallback should produce an independent copy");
+  Expect(merged_stat.st_nlink == 1, "fallback copy should have a single name");
+  ExpectEq(ReadFile(JoinPath(target, "assets/keep.txt")), "keep", "fallback content mismatch");
+}
+
 void TestApplyPatchFromFileSourceCanLimitMergeSubdir() {
   TempDir temp;
   const std::string source = JoinPath(temp.path, "origin");
@@ -537,6 +612,8 @@ void TestStateCoreSwitchToSameVersion() {
 int main() {
   const std::vector<std::pair<std::string, void (*)()>> tests = {
       {"ApplyPatchFromFileSourceMergesAndCopies", TestApplyPatchFromFileSourceMergesAndCopies},
+      {"ApplyPatchMergeHardLinksUnchangedFiles", TestApplyPatchMergeHardLinksUnchangedFiles},
+      {"ApplyPatchMergeFallsBackToByteCopy", TestApplyPatchMergeFallsBackToByteCopy},
       {"ApplyPatchFromFileSourceCanLimitMergeSubdir", TestApplyPatchFromFileSourceCanLimitMergeSubdir},
       {"ApplyPatchFromFileSourceRejectsUnsafePaths", TestApplyPatchFromFileSourceRejectsUnsafePaths},
       {"CleanupOldEntriesRemovesOnlyExpiredPaths", TestCleanupOldEntriesRemovesOnlyExpiredPaths},

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

@@ -11,7 +11,6 @@
 #include "state_ops.h"
 
 extern "C" {
-#include "hpatch.h"
 }
 
 namespace {
@@ -407,96 +406,6 @@ pushy::patch::PatchManifest BuildManifest(
   return manifest;
 }
 
-napi_value HdiffPatch(napi_env env, napi_callback_info info) {
-  napi_value args[2] = {nullptr, nullptr};
-  size_t argc = 2;
-  if (!GetArgCount(env, info, &argc, args) || argc < 2) {
-    ThrowError(env, "Wrong number of arguments");
-    return nullptr;
-  }
-
-  bool is_typed_array = false;
-  if (napi_is_typedarray(env, args[0], &is_typed_array) != napi_ok || !is_typed_array) {
-    ThrowError(env, "First argument must be a TypedArray");
-    return nullptr;
-  }
-
-  uint8_t* origin_ptr = nullptr;
-  size_t origin_length = 0;
-  if (napi_get_typedarray_info(
-          env,
-          args[0],
-          nullptr,
-          &origin_length,
-          reinterpret_cast<void**>(&origin_ptr),
-          nullptr,
-          nullptr) != napi_ok) {
-    ThrowError(env, "Failed to get origin buffer");
-    return nullptr;
-  }
-
-  if (napi_is_typedarray(env, args[1], &is_typed_array) != napi_ok || !is_typed_array) {
-    ThrowError(env, "Second argument must be a TypedArray");
-    return nullptr;
-  }
-
-  uint8_t* patch_ptr = nullptr;
-  size_t patch_length = 0;
-  if (napi_get_typedarray_info(
-          env,
-          args[1],
-          nullptr,
-          &patch_length,
-          reinterpret_cast<void**>(&patch_ptr),
-          nullptr,
-          nullptr) != napi_ok) {
-    ThrowError(env, "Failed to get patch buffer");
-    return nullptr;
-  }
-
-  hpatch_singleCompressedDiffInfo patch_info;
-  if (!((origin_length == 0) || origin_ptr) || !patch_ptr || patch_length == 0) {
-    ThrowError(env, "Corrupt patch");
-    return nullptr;
-  }
-  if (kHPatch_ok != hpatch_getInfo_by_mem(&patch_info, patch_ptr, patch_length)) {
-    ThrowError(env, "Error info in hpatch");
-    return nullptr;
-  }
-  if (origin_length != patch_info.oldDataSize) {
-    ThrowError(env, "Error oldDataSize in hpatch");
-    return nullptr;
-  }
-
-  size_t new_size = static_cast<size_t>(patch_info.newDataSize);
-  if (sizeof(size_t) != sizeof(hpatch_StreamPos_t) &&
-      new_size != patch_info.newDataSize) {
-    ThrowError(env, "Error newDataSize in hpatch");
-    return nullptr;
-  }
-
-  void* output_data = nullptr;
-  napi_value result = nullptr;
-  if (napi_create_arraybuffer(env, new_size, &output_data, &result) != napi_ok) {
-    ThrowError(env, "Failed to create result buffer");
-    return nullptr;
-  }
-
-  if (kHPatch_ok != hpatch_by_mem(
-                       origin_ptr,
-                       origin_length,
-                       static_cast<uint8_t*>(output_data),
-                       new_size,
-                       patch_ptr,
-                       patch_length,
-                       &patch_info)) {
-    ThrowError(env, "hpatch");
-    return nullptr;
-  }
-
-  return result;
-}
-
 napi_value SyncStateWithBinaryVersion(napi_env env, napi_callback_info info) {
   napi_value args[3] = {nullptr, nullptr, nullptr};
   size_t argc = 3;
@@ -968,8 +877,7 @@ bool ExportFunction(
 }  // namespace
 
 napi_value Init(napi_env env, napi_value exports) {
-  if (!ExportFunction(env, exports, "hdiffPatch", HdiffPatch) ||
-      !ExportFunction(env, exports, "syncStateWithBinaryVersion", SyncStateWithBinaryVersion) ||
+  if (!ExportFunction(env, exports, "syncStateWithBinaryVersion", SyncStateWithBinaryVersion) ||
       !ExportFunction(env, exports, "runStateCore", RunStateCore) ||
       !ExportFunction(env, exports, "buildArchivePatchPlan", BuildArchivePatchPlan) ||
       !ExportFunction(env, exports, "buildCopyGroups", BuildCopyGroups) ||