@capgo/capacitor-updater 8.45.3 → 8.45.9

package/Package.swift

@@ -11,7 +11,7 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0"),
-        .package(url: "https://github.com/Alamofire/Alamofire.git", .upToNextMajor(from: "5.11.1")),
+        .package(url: "https://github.com/Alamofire/Alamofire.git", .upToNextMajor(from: "5.11.2")),
         .package(url: "https://github.com/weichsel/ZIPFoundation.git", from: "0.9.20"),
         .package(url: "https://github.com/mrackwitz/Version.git", exact: "0.8.0"),
         .package(url: "https://github.com/attaswift/BigInt.git", from: "5.7.0")

package/README.md

@@ -2063,9 +2063,10 @@ If you don't use backend, you need to provide the URL and version of the bundle.
 
 ##### ResetOptions
 
-| Prop                   | Type                 |
-| ---------------------- | -------------------- |
-| **`toLastSuccessful`** | <code>boolean</code> |
+| Prop                   | Type                 | Description                                                                                                                                                                                                        | Default            |
+| ---------------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------ |
+| **`toLastSuccessful`** | <code>boolean</code> | Reset to the last successfully loaded bundle instead of the builtin one.                                                                                                                                           | <code>false</code> |
+| **`usePendingBundle`** | <code>boolean</code> | Apply the pending bundle set via {@link next} while resetting. When `true`, the plugin will switch to the pending bundle immediately and clear the pending flag. If no pending bundle exists, the reset will fail. | <code>false</code> |
 
 
 ##### CurrentBundleResult

package/android/src/main/java/ee/forgr/capacitor_updater/CapacitorUpdaterPlugin.java

@@ -22,6 +22,7 @@ import android.view.View;
 import android.view.ViewGroup;
 import android.widget.FrameLayout;
 import android.widget.ProgressBar;
+import androidx.core.content.pm.PackageInfoCompat;
 import com.getcapacitor.Bridge;
 import com.getcapacitor.CapConfig;
 import com.getcapacitor.JSArray;
@@ -87,8 +88,9 @@ public class CapacitorUpdaterPlugin extends Plugin {
     private static final String SPLASH_SCREEN_PLUGIN_ID = "SplashScreen";
     private static final int SPLASH_SCREEN_RETRY_DELAY_MS = 100;
     private static final int SPLASH_SCREEN_MAX_RETRIES = 20;
+    private static final long PENDING_BUNDLE_APP_READY_MIN_TIMEOUT_MS = 30000L;
 
-    private final String pluginVersion = "8.45.3";
+    private final String pluginVersion = "8.45.9";
     private static final String DELAY_CONDITION_PREFERENCES = "";
 
     private SharedPreferences.Editor editor;
@@ -133,8 +135,12 @@ public class CapacitorUpdaterPlugin extends Plugin {
     private volatile long downloadStartTimeMs = 0;
     private static final long DOWNLOAD_TIMEOUT_MS = 3600000; // 1 hour timeout
 
-    //  private static final CountDownLatch semaphoreReady = new CountDownLatch(1);
-    private static final Phaser semaphoreReady = new Phaser(1);
+    private final Phaser semaphoreReady = new Phaser(0) {
+        @Override
+        protected boolean onAdvance(final int phase, final int registeredParties) {
+            return false;
+        }
+    };
 
     // Lock to ensure cleanup completes before downloads start
     private final Object cleanupLock = new Object();
@@ -191,7 +197,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
     }
 
     private String getVersionCode(final PackageInfo packageInfo) {
-        return Long.toString(packageInfo.getLongVersionCode());
+        return Long.toString(PackageInfoCompat.getLongVersionCode(packageInfo));
     }
 
     private void notifyBreakingEvents(final String version) {
@@ -283,13 +289,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
 
                 @Override
                 public void directUpdateFinish(final BundleInfo latest) {
-                    if (activity != null) {
-                        activity.runOnUiThread(() -> {
-                            CapacitorUpdaterPlugin.this.directUpdateFinish(latest);
-                        });
-                    } else {
-                        logger.warn("directUpdateFinish: Activity is null, skipping notification");
-                    }
+                    CapacitorUpdaterPlugin.this.scheduleDirectUpdateFinish(latest);
                 }
 
                 @Override
@@ -520,30 +520,69 @@ public class CapacitorUpdaterPlugin extends Plugin {
         }
     }
 
-    private void semaphoreWait(Number waitTime) {
+    private boolean semaphoreWait(final int phase, Number waitTime) {
         try {
-            semaphoreReady.awaitAdvanceInterruptibly(semaphoreReady.getPhase(), waitTime.longValue(), TimeUnit.SECONDS);
+            semaphoreReady.awaitAdvanceInterruptibly(phase, waitTime.longValue(), TimeUnit.MILLISECONDS);
             logger.info("semaphoreReady count " + semaphoreReady.getPhase());
+            return true;
         } catch (InterruptedException e) {
             logger.info("semaphoreWait InterruptedException");
+            cleanupTimedOutSemaphoreWait(phase);
             Thread.currentThread().interrupt(); // Restore interrupted status
+            return false;
         } catch (TimeoutException e) {
             logger.error("Semaphore timeout: " + e.getMessage());
-            // Don't throw runtime exception, just log and continue
+            cleanupTimedOutSemaphoreWait(phase);
+            return false;
         }
     }
 
-    private void semaphoreUp() {
+    private int semaphoreUp() {
         logger.info("semaphoreUp");
-        semaphoreReady.register();
+        return semaphoreReady.register();
     }
 
     private void semaphoreDown() {
+        if (semaphoreReady.getRegisteredParties() == 0) {
+            logger.info("semaphoreDown skipped, no pending app ready wait");
+            return;
+        }
         logger.info("semaphoreDown");
         logger.info("semaphoreDown count " + semaphoreReady.getPhase());
         semaphoreReady.arriveAndDeregister();
     }
 
+    private void cleanupTimedOutSemaphoreWait(final int phase) {
+        if (semaphoreReady.getPhase() != phase || semaphoreReady.getRegisteredParties() == 0) {
+            return;
+        }
+        logger.info("Cleaning up stale app ready wait for phase " + phase);
+        semaphoreReady.arriveAndDeregister();
+    }
+
+    protected long getMinimumPendingBundleAppReadyTimeoutMs() {
+        return PENDING_BUNDLE_APP_READY_MIN_TIMEOUT_MS;
+    }
+
+    private long resolveAppReadyCheckTimeoutMs() {
+        long configuredTimeoutMs = this.appReadyTimeout.longValue();
+        try {
+            if (this.implementation == null) {
+                return configuredTimeoutMs;
+            }
+
+            final BundleInfo current = this.implementation.getCurrentBundle();
+            if (current == null || BundleStatus.SUCCESS == current.getStatus()) {
+                return configuredTimeoutMs;
+            }
+
+            return Math.max(configuredTimeoutMs, this.getMinimumPendingBundleAppReadyTimeoutMs());
+        } catch (final Exception e) {
+            logger.warn("Falling back to configured appReadyTimeout: " + e.getMessage());
+            return configuredTimeoutMs;
+        }
+    }
+
     private void sendReadyToJs(final BundleInfo current, final String msg) {
         sendReadyToJs(current, msg, false);
     }
@@ -863,6 +902,22 @@ public class CapacitorUpdaterPlugin extends Plugin {
         this.endBackGroundTaskWithNotif("test", current.getVersionName(), current, false, plannedDirectUpdate);
     }
 
+    void scheduleDirectUpdateFinish(final BundleInfo latest) {
+        startNewThread(() -> {
+            try {
+                Activity currentActivity = this.getActivity();
+                if (currentActivity != null) {
+                    this.implementation.activity = currentActivity;
+                } else {
+                    logger.warn("directUpdateFinish: Activity is null, proceeding without refreshing the activity reference");
+                }
+                this.directUpdateFinish(latest);
+            } catch (final Exception e) {
+                logger.error("directUpdateFinish failed: " + e.getMessage());
+            }
+        });
+    }
+
     private void directUpdateFinish(final BundleInfo latest) {
         if ("onLaunch".equals(this.directUpdateMode)) {
             this.onLaunchDirectUpdateUsed = true;
@@ -1333,12 +1388,12 @@ public class CapacitorUpdaterPlugin extends Plugin {
         this.bridge.getWebView().post(() -> this.bridge.getWebView().evaluateJavascript(script, null));
     }
 
-    protected boolean _reload() {
+    private void applyCurrentBundleToBridge() {
         final String path = this.implementation.getCurrentBundlePath();
+        final boolean usingBuiltin = this.implementation.isUsingBuiltin();
         if (this.keepUrlPathAfterReload) {
             this.syncKeepUrlPathFlag(true);
         }
-        this.semaphoreUp();
         logger.info("Reloading: " + path);
 
         AtomicReference<URL> url = new AtomicReference<>();
@@ -1383,7 +1438,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
         }
 
         if (url.get() != null) {
-            if (this.implementation.isUsingBuiltin()) {
+            if (usingBuiltin) {
                 this.bridge.getLocalServer().hostAssets(path);
             } else {
                 this.bridge.getLocalServer().hostFiles(path);
@@ -1403,14 +1458,14 @@ public class CapacitorUpdaterPlugin extends Plugin {
             } catch (MalformedURLException e) {
                 logger.error("Cannot get finalUrl from capacitor bridge " + e.getMessage());
 
-                if (this.implementation.isUsingBuiltin()) {
+                if (usingBuiltin) {
                     this.bridge.setServerAssetPath(path);
                 } else {
                     this.bridge.setServerBasePath(path);
                 }
             }
         } else {
-            if (this.implementation.isUsingBuiltin()) {
+            if (usingBuiltin) {
                 this.bridge.setServerAssetPath(path);
             } else {
                 this.bridge.setServerBasePath(path);
@@ -1426,24 +1481,63 @@ public class CapacitorUpdaterPlugin extends Plugin {
                 });
             }
         }
+    }
 
-        this.checkAppReady();
-        this.notifyListeners("appReloaded", new JSObject());
-
-        // Wait for the reload to complete (until notifyAppReady is called)
+    protected void restoreLiveBundleStateAfterFailedReload() {
         try {
-            this.semaphoreWait(this.appReadyTimeout);
-        } catch (Exception e) {
-            logger.error("Error waiting for app ready: " + e.getMessage());
-            return false;
+            this.applyCurrentBundleToBridge();
+        } catch (final Exception e) {
+            logger.warn("Failed to restore live bundle after rejected reload: " + e.getMessage());
         }
+    }
 
-        return true;
+    protected boolean _reload() {
+        final int phase = this.semaphoreUp();
+        this.applyCurrentBundleToBridge();
+
+        final long waitTimeMs = this.resolveAppReadyCheckTimeoutMs();
+        this.checkAppReady(waitTimeMs);
+        this.notifyListeners("appReloaded", new JSObject());
+
+        // Wait for the reload to complete (until notifyAppReady is called)
+        return this.semaphoreWait(phase, waitTimeMs);
     }
 
     @PluginMethod
     public void reload(final PluginCall call) {
         try {
+            final BundleInfo current = this.implementation.getCurrentBundle();
+            final BundleInfo next = this.implementation.getNextBundle();
+
+            if (next != null && !next.isErrorStatus() && !next.getId().equals(current.getId())) {
+                final CapgoUpdater.ResetState previousState = this.implementation.captureResetState();
+                final String previousBundleName = this.implementation.getCurrentBundle().getVersionName();
+                logger.info("Applying pending bundle before reload: " + next.getVersionName());
+                final boolean didApplyPendingBundle;
+                if (next.isBuiltin()) {
+                    this.implementation.prepareResetStateForTransition();
+                    didApplyPendingBundle = true;
+                } else {
+                    didApplyPendingBundle = this.implementation.stagePendingReload(next);
+                }
+                if (didApplyPendingBundle && this._reload()) {
+                    if (next.isBuiltin()) {
+                        this.implementation.finalizeResetTransition(previousBundleName, false);
+                    } else {
+                        this.implementation.finalizePendingReload(next, previousBundleName);
+                    }
+                    this.notifyBundleSet(next);
+                    this.implementation.setNextBundle(null);
+                    call.resolve();
+                    return;
+                }
+                this.implementation.restoreResetState(previousState);
+                this.restoreLiveBundleStateAfterFailedReload();
+                logger.error("Reload failed after applying pending bundle: " + next.getVersionName());
+                call.reject("Reload failed after applying pending bundle: " + next.getVersionName());
+                return;
+            }
+
             if (this._reload()) {
                 call.resolve();
             } else {
@@ -1605,28 +1699,83 @@ public class CapacitorUpdaterPlugin extends Plugin {
         );
     }
 
-    private boolean _reset(final Boolean toLastSuccessful) {
+    private boolean _reset(final Boolean toLastSuccessful, final Boolean usePendingBundle) {
+        return this.performReset(toLastSuccessful, usePendingBundle, false);
+    }
+
+    private boolean performReset(final Boolean toLastSuccessful, final Boolean usePendingBundle, final boolean internal) {
         final BundleInfo fallback = this.implementation.getFallbackBundle();
-        this.implementation.reset();
+        final BundleInfo pending = this.implementation.getNextBundle();
+        final CapgoUpdater.ResetState previousState = this.implementation.captureResetState();
+        final String previousBundleName = this.implementation.getCurrentBundle().getVersionName();
 
-        if (toLastSuccessful && !fallback.isBuiltin()) {
-            logger.info("Resetting to: " + fallback);
-            if (this.implementation.set(fallback) && this._reload()) {
-                this.notifyBundleSet(fallback);
+        if (Boolean.TRUE.equals(usePendingBundle)) {
+            if (pending == null || pending.isErrorStatus()) {
+                logger.error("No pending bundle available to reset to");
+                return false;
+            }
+            if (!this.implementation.canSet(pending)) {
+                logger.error("Pending bundle is not installable");
+                return false;
+            }
+            this.implementation.prepareResetStateForTransition();
+            logger.info("Resetting to pending bundle: " + pending.getVersionName());
+            final boolean didApplyPendingBundle;
+            if (pending.isBuiltin()) {
+                didApplyPendingBundle = true;
+            } else {
+                didApplyPendingBundle = this.implementation.set(pending);
+            }
+            if (didApplyPendingBundle && this._reload()) {
+                this.implementation.finalizeResetTransition(previousBundleName, internal);
+                this.notifyBundleSet(pending);
+                this.implementation.setNextBundle(null);
                 return true;
             }
+            this.implementation.restoreResetState(previousState);
+            this.restoreLiveBundleStateAfterFailedReload();
             return false;
         }
 
+        if (Boolean.TRUE.equals(toLastSuccessful) && !fallback.isBuiltin()) {
+            if (this.implementation.canSet(fallback)) {
+                this.implementation.prepareResetStateForTransition();
+                logger.info("Resetting to: " + fallback);
+                if (this.implementation.set(fallback) && this._reload()) {
+                    this.implementation.finalizeResetTransition(previousBundleName, internal);
+                    this.notifyBundleSet(fallback);
+                    return true;
+                }
+                if (!internal) {
+                    this.implementation.restoreResetState(previousState);
+                    this.restoreLiveBundleStateAfterFailedReload();
+                    return false;
+                }
+                logger.warn("Fallback reload failed during internal reset, resetting to native instead");
+            } else {
+                logger.warn("Fallback bundle is not installable, resetting to native instead");
+            }
+        }
+
+        this.implementation.prepareResetStateForTransition();
         logger.info("Resetting to native.");
-        return this._reload();
+        if (this._reload()) {
+            this.implementation.finalizeResetTransition(previousBundleName, internal);
+            return true;
+        }
+        if (!internal) {
+            this.implementation.restoreResetState(previousState);
+            this.restoreLiveBundleStateAfterFailedReload();
+        }
+        return false;
     }
 
     @PluginMethod
     public void reset(final PluginCall call) {
         try {
             final Boolean toLastSuccessful = call.getBoolean("toLastSuccessful", false);
-            if (this._reset(toLastSuccessful)) {
+            final Boolean usePendingBundle = call.getBoolean("usePendingBundle", false);
+            if (this._reset(toLastSuccessful, usePendingBundle)) {
                 call.resolve();
                 return;
             }
@@ -1828,11 +1977,15 @@ public class CapacitorUpdaterPlugin extends Plugin {
     }
 
     private void checkAppReady() {
+        this.checkAppReady(this.resolveAppReadyCheckTimeoutMs());
+    }
+
+    private void checkAppReady(final long waitTimeMs) {
         try {
             if (this.appReadyCheck != null) {
                 this.appReadyCheck.interrupt();
             }
-            this.appReadyCheck = startNewThread(new DeferredNotifyAppReadyCheck());
+            this.appReadyCheck = startNewThread(new DeferredNotifyAppReadyCheck(waitTimeMs));
         } catch (final Exception e) {
             logger.error("Failed to start " + DeferredNotifyAppReadyCheck.class.getName() + " " + e.getMessage());
         }
@@ -1990,7 +2143,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
                             );
                             if (directUpdateAllowedNow) {
                                 logger.info("Direct update to builtin version");
-                                this._reset(false);
+                                this._reset(false, false);
                                 CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
                                     "Updated to builtin version",
                                     latestVersionName,
@@ -2224,16 +2377,18 @@ public class CapacitorUpdaterPlugin extends Plugin {
             if (next != null && !next.isErrorStatus() && !next.getId().equals(current.getId())) {
                 // There is a next bundle waiting for activation
                 logger.debug("Next bundle is: " + next.getVersionName());
-                if (this.implementation.set(next) && this._reload()) {
-                    logger.info("Updated to bundle: " + next.getVersionName());
-                    this.notifyBundleSet(next);
-                    this.implementation.setNextBundle(null);
-                } else {
-                    logger.error("Update to bundle: " + next.getVersionName() + " Failed!");
-                }
+                startNewThread(() -> {
+                    if (this.implementation.set(next) && this._reload()) {
+                        logger.info("Updated to bundle: " + next.getVersionName());
+                        this.notifyBundleSet(next);
+                        this.implementation.setNextBundle(null);
+                    } else {
+                        logger.error("Update to bundle: " + next.getVersionName() + " Failed!");
+                    }
+                });
             }
         } catch (final Exception e) {
-            logger.error("Error during onActivityStopped " + e.getMessage());
+            logger.error("Error during installNext " + e);
         }
     }
 
@@ -2256,7 +2411,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
             this.notifyListeners("updateFailed", ret);
             this.implementation.sendStats("update_fail", current.getVersionName());
             this.implementation.setError(current);
-            this._reset(true);
+            this.performReset(true, false, true);
             if (CapacitorUpdaterPlugin.this.autoDeleteFailed && !current.isBuiltin()) {
                 logger.info("Deleting failing bundle: " + current.getVersionName());
                 try {
@@ -2275,11 +2430,17 @@ public class CapacitorUpdaterPlugin extends Plugin {
 
     private class DeferredNotifyAppReadyCheck implements Runnable {
 
+        private final long waitTimeMs;
+
+        DeferredNotifyAppReadyCheck(final long waitTimeMs) {
+            this.waitTimeMs = waitTimeMs;
+        }
+
         @Override
         public void run() {
             try {
-                logger.info("Wait for " + CapacitorUpdaterPlugin.this.appReadyTimeout + "ms, then check for notifyAppReady");
-                Thread.sleep(CapacitorUpdaterPlugin.this.appReadyTimeout);
+                logger.info("Wait for " + this.waitTimeMs + "ms, then check for notifyAppReady");
+                Thread.sleep(this.waitTimeMs);
                 CapacitorUpdaterPlugin.this.checkRevert();
                 CapacitorUpdaterPlugin.this.appReadyCheck = null;
             } catch (final InterruptedException e) {

package/android/src/main/java/ee/forgr/capacitor_updater/CapgoUpdater.java

@@ -991,6 +991,64 @@ public class CapgoUpdater {
         return (bundle.isDirectory() && bundle.exists() && new File(bundle.getPath(), "/index.html").exists() && !bundleInfo.isDeleted());
     }
 
+    static final class ResetState {
+
+        final String currentBundlePath;
+        final String fallbackBundleId;
+        final String nextBundleId;
+
+        ResetState(final String currentBundlePath, final String fallbackBundleId, final String nextBundleId) {
+            this.currentBundlePath = currentBundlePath;
+            this.fallbackBundleId = fallbackBundleId;
+            this.nextBundleId = nextBundleId;
+        }
+    }
+
+    ResetState captureResetState() {
+        return new ResetState(
+            this.getCurrentBundlePath(),
+            this.prefs.getString(FALLBACK_VERSION, BundleInfo.ID_BUILTIN),
+            this.prefs.getString(NEXT_VERSION, null)
+        );
+    }
+
+    void restoreResetState(final ResetState state) {
+        final String currentBundlePath = state.currentBundlePath == null || state.currentBundlePath.trim().isEmpty()
+            ? "public"
+            : state.currentBundlePath;
+        final String fallbackBundleId = state.fallbackBundleId == null || state.fallbackBundleId.isEmpty()
+            ? BundleInfo.ID_BUILTIN
+            : state.fallbackBundleId;
+
+        this.editor.putString(this.CAP_SERVER_PATH, currentBundlePath);
+        this.editor.putString(FALLBACK_VERSION, fallbackBundleId);
+        if (state.nextBundleId == null || state.nextBundleId.isEmpty()) {
+            this.editor.remove(NEXT_VERSION);
+        } else {
+            this.editor.putString(NEXT_VERSION, state.nextBundleId);
+        }
+        this.editor.commit();
+    }
+
+    void prepareResetStateForTransition() {
+        this.setCurrentBundle(new File("public"));
+        this.setFallbackBundle(null);
+        this.setNextBundle(null);
+    }
+
+    void finalizeResetTransition(final String previousBundleName, final boolean internal) {
+        if (this.activity != null) {
+            DownloadWorkerManager.cancelAllDownloads(this.activity);
+        }
+        if (!internal) {
+            this.sendStats("reset", this.getCurrentBundle().getVersionName(), previousBundleName);
+        }
+    }
+
+    boolean canSet(final BundleInfo bundle) {
+        return bundle != null && (bundle.isBuiltin() || this.bundleExists(bundle.getId()));
+    }
+
     public Boolean set(final BundleInfo bundle) {
         return this.set(bundle.getId());
     }
@@ -1015,6 +1073,21 @@ public class CapgoUpdater {
         return false;
     }
 
+    boolean stagePendingReload(final BundleInfo bundle) {
+        if (bundle == null || bundle.isBuiltin() || !this.bundleExists(bundle.getId())) {
+            return false;
+        }
+        this.setCurrentBundle(this.getBundleDirectory(bundle.getId()));
+        return true;
+    }
+
+    void finalizePendingReload(final BundleInfo bundle, final String previousBundleName) {
+        if (bundle == null || bundle.isBuiltin()) {
+            return;
+        }
+        this.sendStats("set", bundle.getVersionName(), previousBundleName);
+    }
+
     public void autoReset() {
         final BundleInfo currentBundle = this.getCurrentBundle();
         if (!currentBundle.isBuiltin() && !this.bundleExists(currentBundle.getId())) {
@@ -1058,17 +1131,9 @@ public class CapgoUpdater {
 
     public void reset(final boolean internal) {
         logger.debug("reset: " + internal);
-        var currentBundleName = this.getCurrentBundle().getVersionName();
-        this.setCurrentBundle(new File("public"));
-        this.setFallbackBundle(null);
-        this.setNextBundle(null);
-        // Cancel any ongoing downloads
-        if (this.activity != null) {
-            DownloadWorkerManager.cancelAllDownloads(this.activity);
-        }
-        if (!internal) {
-            this.sendStats("reset", this.getCurrentBundle().getVersionName(), currentBundleName);
-        }
+        final String currentBundleName = this.getCurrentBundle().getVersionName();
+        this.prepareResetStateForTransition();
+        this.finalizeResetTransition(currentBundleName, internal);
     }
 
     private JSONObject createInfoObject() throws JSONException {

package/android/src/main/java/ee/forgr/capacitor_updater/DownloadService.java

@@ -110,7 +110,23 @@ public class DownloadService extends Worker {
     }
 
     private static String sanitizeUserAgentValue(String value) {
-        return value == null || value.isEmpty() ? "unknown" : value;
+        if (value == null || value.isEmpty()) {
+            return "unknown";
+        }
+
+        StringBuilder sanitized = new StringBuilder();
+        value
+            .codePoints()
+            .forEach((cp) -> {
+                boolean isVisibleAscii = cp >= 0x20 && cp <= 0x7E;
+                boolean isIso88591 = cp >= 0xA0 && cp <= 0xFF;
+                if (isVisibleAscii || isIso88591) {
+                    sanitized.appendCodePoint(cp);
+                }
+            });
+
+        String result = sanitized.toString().trim();
+        return result.isEmpty() ? "unknown" : result;
     }
 
     // Method to update User-Agent values

package/dist/docs.json

@@ -343,7 +343,7 @@
           },
           {
             "name": "link",
-            "text": "ResetOptions} to control reset behavior. If `toLastSuccessful` is `false` (or omitted), resets to builtin. If `true`, resets to last successful bundle."
+            "text": "ResetOptions} to control reset behavior.\nIf `toLastSuccessful` is `false` (or omitted), resets to builtin.\nIf `true`, resets to last successful bundle.\nIf `usePendingBundle` is `true`, applies the pending bundle set via {@link next} and clears it."
           },
           {
             "name": "returns",
@@ -1872,10 +1872,27 @@
       "properties": [
         {
           "name": "toLastSuccessful",
-          "tags": [],
-          "docs": "",
+          "tags": [
+            {
+              "text": "false",
+              "name": "default"
+            }
+          ],
+          "docs": "Reset to the last successfully loaded bundle instead of the builtin one.",
           "complexTypes": [],
-          "type": "boolean"
+          "type": "boolean | undefined"
+        },
+        {
+          "name": "usePendingBundle",
+          "tags": [
+            {
+              "text": "false",
+              "name": "default"
+            }
+          ],
+          "docs": "Apply the pending bundle set via {@link next} while resetting.\n\nWhen `true`, the plugin will switch to the pending bundle immediately and clear the pending flag.\nIf no pending bundle exists, the reset will fail.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
         }
       ]
     },

package/dist/esm/definitions.d.ts

@@ -568,7 +568,10 @@ export interface CapacitorUpdaterPlugin {
      * - Testing rollback functionality
      * - Providing users a "reset to factory" option
      *
-     * @param options {@link ResetOptions} to control reset behavior. If `toLastSuccessful` is `false` (or omitted), resets to builtin. If `true`, resets to last successful bundle.
+     * @param options {@link ResetOptions} to control reset behavior.
+     * If `toLastSuccessful` is `false` (or omitted), resets to builtin.
+     * If `true`, resets to last successful bundle.
+     * If `usePendingBundle` is `true`, applies the pending bundle set via {@link next} and clears it.
      * @returns {Promise<void>} A promise that may never resolve because the app will be reloaded.
      * @throws {Error} If the reset operation fails.
      */
@@ -1680,7 +1683,19 @@ export interface BundleListResult {
     bundles: BundleInfo[];
 }
 export interface ResetOptions {
-    toLastSuccessful: boolean;
+    /**
+     * Reset to the last successfully loaded bundle instead of the builtin one.
+     * @default false
+     */
+    toLastSuccessful?: boolean;
+    /**
+     * Apply the pending bundle set via {@link next} while resetting.
+     *
+     * When `true`, the plugin will switch to the pending bundle immediately and clear the pending flag.
+     * If no pending bundle exists, the reset will fail.
+     * @default false
+     */
+    usePendingBundle?: boolean;
 }
 export interface ListOptions {
     /**