@onekeyfe/hd-core 1.2.0-alpha.98 → 1.2.0-alpha.99

package/src/api/CheckAllFirmwareRelease.ts

@@ -429,10 +429,15 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
     const forceResourceUpdate =
       validatedForceUpdateTargets.includes('resource') ||
       validatedProtocolV2ForceUpdateTargets.includes('resource');
+    // A configured resource archive accompanies a real remote component update,
+    // but its mere availability must not turn an otherwise current device into a
+    // resource-only update. Explicit developer resource forcing remains supported.
+    const includeResourceUpdate =
+      forceResourceUpdate || (resourceSource !== undefined && detectedComponentTargets.length > 0);
     const targetsToUpdate = Array.from(
       new Set([
         ...componentTargetsToUpdate,
-        ...(forceResourceUpdate ? (['resource'] as const) : []),
+        ...(includeResourceUpdate ? (['resource'] as const) : []),
       ])
     );
     let firmwareUpdatePlan: FirmwareUpdatePlan | undefined;

package/src/api/FirmwareUpdateV2.ts

@@ -286,84 +286,142 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
     // check device goto bootloader mode
     let isFirstCheck = true;
     let checkCount = 0;
-    // eslint-disable-next-line prefer-const
+    let hasPromptedWebDevice = false;
+    let isPromptingWebDevice = false;
+    let isFinished = false;
+    let intervalTimer: ReturnType<typeof setInterval> | undefined;
     let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
 
     const deviceType = this.device?.getCurrentDeviceType();
     const isTouchOrProDevice = deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro;
 
-    const intervalTimer: ReturnType<typeof setInterval> | undefined = setInterval(
-      async () => {
-        checkCount += 1;
-        Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
-        if (isTouchOrProDevice && isFirstCheck) {
-          isFirstCheck = false;
-          Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] wait 3000ms');
-          await wait(3000);
-        }
+    const clearPollingTimers = () => {
+      if (intervalTimer !== undefined) {
+        clearInterval(intervalTimer);
+        intervalTimer = undefined;
+      }
+      if (timeoutTimer !== undefined) {
+        clearTimeout(timeoutTimer);
+        timeoutTimer = undefined;
+      }
+    };
 
-        if (
-          checkCount > 4 &&
-          DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
-          !this.payload.skipWebDevicePrompt
-        ) {
-          clearInterval(intervalTimer);
-          clearTimeout(timeoutTimer);
+    const checkForBootloader = async (clearActiveTimers: boolean) => {
+      const found = await this._checkDeviceInBootloaderMode(
+        connectId,
+        clearActiveTimers ? intervalTimer : undefined,
+        clearActiveTimers ? timeoutTimer : undefined
+      );
+      if (found) {
+        isFinished = true;
+        clearPollingTimers();
+      }
+      return found;
+    };
 
-          try {
-            this.postTipMessage(FirmwareUpdateTipMessage.SelectDeviceInBootloaderForWebDevice);
-            const confirmed = await this._promptDeviceInBootloaderForWebDevice();
-            if (confirmed) {
-              await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
-            }
-          } catch (e) {
-            Log.log(
-              'FirmwareUpdateV2 [checkDeviceToBootloader] promptDeviceInBootloaderForWebDevice failed: ',
-              e
-            );
-            this.checkPromise?.reject(e);
+    let startPolling: () => void = () => undefined;
+    const pollForBootloader = async () => {
+      if (isFinished || isPromptingWebDevice) return;
+      checkCount += 1;
+      Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
+      if (isTouchOrProDevice && isFirstCheck) {
+        isFirstCheck = false;
+        Log.log('FirmwareUpdateV2 [checkDeviceToBootloader] wait 3000ms');
+        await wait(3000);
+      }
+
+      if (
+        checkCount > 4 &&
+        DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
+        !this.payload.skipWebDevicePrompt &&
+        !hasPromptedWebDevice &&
+        !isPromptingWebDevice
+      ) {
+        clearPollingTimers();
+        isPromptingWebDevice = true;
+        try {
+          this.postTipMessage(FirmwareUpdateTipMessage.SelectDeviceInBootloaderForWebDevice);
+          const confirmed = await this._promptDeviceInBootloaderForWebDevice();
+          hasPromptedWebDevice = true;
+          if (confirmed) {
+            await checkForBootloader(false);
+          }
+          // WebUSB enumeration can still be empty immediately after the chooser
+          // resolves. Resume a fresh bounded polling window instead of leaving the
+          // deferred check pending forever after the original timers were paused.
+          if (!isFinished) {
+            startPolling();
           }
-          return;
+        } catch (e) {
+          isFinished = true;
+          clearPollingTimers();
+          Log.log(
+            'FirmwareUpdateV2 [checkDeviceToBootloader] promptDeviceInBootloaderForWebDevice failed: ',
+            e
+          );
+          this.checkPromise?.reject(e);
+        } finally {
+          isPromptingWebDevice = false;
         }
+        return;
+      }
 
-        if (isBleReconnect) {
-          if (bleProbeInFlight) return;
-          bleProbeInFlight = true;
-          try {
-            await this.device.deviceConnector?.acquire(
-              this.device.originalDescriptor.id,
-              null,
-              true,
-              this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
-            );
-            // Bound each probe so a request the rebooting device never received
-            // frees the slot for the next tick instead of hanging into the
-            // 30s reboot budget.
-            await this.device.initialize({ timeoutMs: BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS });
-            if (this.device.isBootloader()) {
-              clearInterval(intervalTimer);
-              this.checkPromise?.resolve(true);
-            }
-          } catch (e) {
-            // ignore error because of device is not connected
-            Log.log('catch Bluetooth error when device is restarting: ', e);
-          } finally {
-            bleProbeInFlight = false;
+      if (isBleReconnect) {
+        if (bleProbeInFlight) return;
+        bleProbeInFlight = true;
+        try {
+          await this.device.deviceConnector?.acquire(
+            this.device.originalDescriptor.id,
+            null,
+            true,
+            this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
+          );
+          // Bound each probe so a request the rebooting device never received
+          // frees the slot for the next tick instead of hanging into the
+          // 30s reboot budget.
+          await this.device.initialize({ timeoutMs: BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS });
+          if (this.device.isBootloader()) {
+            isFinished = true;
+            clearPollingTimers();
+            this.checkPromise?.resolve(true);
           }
-        } else {
-          await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
+        } catch (e) {
+          // ignore error because of device is not connected
+          Log.log('catch Bluetooth error when device is restarting: ', e);
+        } finally {
+          bleProbeInFlight = false;
         }
-      },
-      isBleReconnect ? 3000 : 2000
-    );
-
-    // check goto bootloader mode timeout and throw error
-    timeoutTimer = setTimeout(() => {
-      if (this.checkPromise) {
-        clearInterval(intervalTimer);
-        this.checkPromise.reject(new Error());
+      } else {
+        await checkForBootloader(true);
       }
-    }, 30000);
+    };
+
+    startPolling = () => {
+      if (isFinished) return;
+      clearPollingTimers();
+      intervalTimer = setInterval(
+        () => {
+          pollForBootloader().catch(error => {
+            if (isFinished) return;
+            isFinished = true;
+            clearPollingTimers();
+            this.checkPromise?.reject(error);
+          });
+        },
+        isBleReconnect ? 3000 : 2000
+      );
+      // Each automatic polling phase is bounded. Time spent in the browser's
+      // permission chooser is intentionally excluded from this deadline.
+      timeoutTimer = setTimeout(() => {
+        if (!isFinished && this.checkPromise) {
+          isFinished = true;
+          clearPollingTimers();
+          this.checkPromise.reject(new Error());
+        }
+      }, 30000);
+    };
+
+    startPolling();
   }
 
   private async _checkDeviceInBootloaderMode(

package/src/api/FirmwareUpdateV4.ts

@@ -138,13 +138,19 @@ const getProtocolV2ZipEntrySizes = (entry: JSZip.JSZipObject) => {
 
 export function assertProtocolV2FirmwareTargetsSupported(
   deviceType: EDeviceType | string | undefined,
-  params: FirmwareUpdateV4Params
+  params: FirmwareUpdateV4Params,
+  hasExplicitTargetSelection = false
 ) {
+  const requestedTargets = new Set(params.targetsToUpdate ?? []);
   const unsupportedTargets = new Set(
-    (params.targetsToUpdate ?? []).filter(target => PROTOCOL_V2_NEO_UNSUPPORTED_TARGETS.has(target))
+    Array.from(requestedTargets).filter(target => PROTOCOL_V2_NEO_UNSUPPORTED_TARGETS.has(target))
   );
-  if (params.se03Binary) unsupportedTargets.add('se03');
-  if (params.se04Binary) unsupportedTargets.add('se04');
+  if (params.se03Binary && (!hasExplicitTargetSelection || requestedTargets.has('se03'))) {
+    unsupportedTargets.add('se03');
+  }
+  if (params.se04Binary && (!hasExplicitTargetSelection || requestedTargets.has('se04'))) {
+    unsupportedTargets.add('se04');
+  }
 
   if (!unsupportedTargets.size || deviceType === EDeviceType.Pro2) return;
 
@@ -559,6 +565,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2ExpectedPath?: string;
 
+  private protocolV2HasExplicitTargetSelection = false;
+
   getSupportedProtocols() {
     return ['V2'] as const;
   }
@@ -584,6 +592,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     const { payload } = this;
 
+    this.protocolV2HasExplicitTargetSelection = payload.targetsToUpdate !== undefined;
+
     if (typeof payload.retryCount !== 'number') {
       payload.retryCount = PROTOCOL_V2_CONNECT_RETRY_COUNT;
     }
@@ -782,7 +792,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       currentDeviceType === EDeviceType.Pro2 || currentDeviceType === EDeviceType.Neo
         ? currentDeviceType
         : getDeviceType(deviceFeatures);
-    assertProtocolV2FirmwareTargetsSupported(capabilityDeviceType, this.params);
+    assertProtocolV2FirmwareTargetsSupported(
+      capabilityDeviceType,
+      this.params,
+      this.protocolV2HasExplicitTargetSelection
+    );
     const deviceFirmwareType = getFirmwareType(deviceFeatures);
     const firmwareType = this.params.firmwareType ?? deviceFirmwareType;
     this.validateExpectedTargetVersions();
@@ -861,6 +875,17 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         bootloaderBinary = remoteBinaries.bootloaderBinary;
         fwBinaryMap = remoteBinaries.fwBinaryMap;
         installItems = remoteBinaries.installItems;
+      } else {
+        const selectedInstallItems = this.filterProtocolV2LocalInstallItems(explicitInstallItems);
+        bootloaderBinary =
+          selectedInstallItems.find(item => item.kind === 'bootloader')?.binary ?? null;
+        fwBinaryMap = selectedInstallItems
+          .filter(item => item.kind === 'firmware')
+          .map(item => ({
+            fileName: item.fileName,
+            binary: item.binary,
+            targetId: item.targetId,
+          }));
       }
       this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
     } catch (err) {
@@ -1035,7 +1060,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     features: Features;
     firmwareType: EFirmwareType;
   }): Promise<FirmwareUpdateV4MemoryHost> {
-    const installItems = this.buildProtocolV2InstallItems({
+    const availableInstallItems = this.buildProtocolV2InstallItems({
       bootloaderBinary: this.prepareBootloaderBinary(),
       fwBinaryMap: this.collectExplicitTargetBinaries(),
     });
@@ -1046,7 +1071,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       )
     );
     const localComponentTargets = new Set(
-      installItems.flatMap(item => {
+      availableInstallItems.flatMap(item => {
         const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
         return target ? [target] : [];
       })
@@ -1064,6 +1089,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         }
       );
     }
+    const installItems = this.filterProtocolV2LocalInstallItems(availableInstallItems);
 
     const planArtifacts: Parameters<typeof buildProtocolV2LocalFirmwareUpdatePlan>[0]['artifacts'] =
       [];
@@ -1165,7 +1191,16 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
       );
     }
-    const zip = await JSZip.loadAsync(binary);
+    let zip: JSZip;
+    try {
+      zip = await JSZip.loadAsync(binary);
+    } catch {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 resource ZIP cannot be parsed',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
     const zipEntries = Object.values(zip.files);
     if (
       zipEntries.some(entry => entry.unsafeOriginalName && entry.unsafeOriginalName !== entry.name)
@@ -1698,6 +1733,17 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       .filter(target => !preparedTargets.has(target));
   }
 
+  private filterProtocolV2LocalInstallItems(installItems: ProtocolV2InstallItem[]) {
+    if (!this.protocolV2HasExplicitTargetSelection) {
+      return installItems;
+    }
+    const requestedTargets = new Set(this.params.targetsToUpdate ?? []);
+    return installItems.filter(item => {
+      const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
+      return target !== undefined && requestedTargets.has(target);
+    });
+  }
+
   private buildProtocolV2InstallItems({
     bootloaderBinary,
     fwBinaryMap,

package/src/api/firmware/FirmwareHostBinding.ts

@@ -1,5 +1,7 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
+import { clearFirmwareUpdatePreparedPlanDeviceIdentityPin } from './FirmwareUpdatePreparedPlan';
+
 import type { FirmwareUpdateHostBinding } from '../../types/api/firmwareUpdate';
 
 const bindingError = (message: string): never => {
@@ -24,8 +26,12 @@ class FirmwareHostBindingRegistry {
     ) {
       return bindingError('Firmware host binding is invalid');
     }
+    const replacedPreparedPlanDigest = this.binding?.preparedPlanDigest;
     this.generation += 1;
     this.binding = binding;
+    if (replacedPreparedPlanDigest) {
+      clearFirmwareUpdatePreparedPlanDeviceIdentityPin(replacedPreparedPlanDigest);
+    }
     return this.generation;
   }
 
@@ -33,8 +39,12 @@ class FirmwareHostBindingRegistry {
     if (generation !== undefined && generation !== this.generation) {
       return false;
     }
+    const releasedPreparedPlanDigest = this.binding?.preparedPlanDigest;
     this.generation += 1;
     this.binding = undefined;
+    if (releasedPreparedPlanDigest) {
+      clearFirmwareUpdatePreparedPlanDeviceIdentityPin(releasedPreparedPlanDigest);
+    }
     return true;
   }
 

package/src/api/firmware/FirmwareMemoryHost.ts

@@ -68,12 +68,13 @@ export function prepareFirmwareUpdateV4MemoryHost({
     );
     binaries.set(artifact.artifactRef, artifactBinary);
     const materializedEntries = input.materializedEntries?.map((entry, entryIndex) => {
-      const entryBinary = new Uint8Array(entry.binary).slice();
       const entryArtifact = createReference(
-        entryBinary.buffer as ArrayBuffer,
+        entry.binary,
         `${hostId}:entry:${artifactIndex}:${entryIndex}`
       );
-      binaries.set(entryArtifact.artifactRef, entryBinary);
+      // Entry references are compact receipts for bytes that will be re-derived
+      // from the verified archive. Retaining another readable copy here doubles
+      // resource memory without adding an execution trust boundary.
       return {
         entryName: entry.entryName,
         artifact: entryArtifact,

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -167,92 +167,141 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     let checkCount = 0;
     let hasPromptedWebDevice = false;
     let isPromptingWebDevice = false;
-    // eslint-disable-next-line prefer-const
+    let isFinished = false;
+    let intervalTimer: ReturnType<typeof setInterval> | undefined;
     let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
 
     const isTouchOrProDevice =
       this?.device?.getCurrentDeviceType() === EDeviceType.Touch ||
       this?.device?.getCurrentDeviceType() === EDeviceType.Pro;
 
-    const intervalTimer: ReturnType<typeof setInterval> | undefined = setInterval(
-      async () => {
-        checkCount += 1;
-        Log.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
-        if (isTouchOrProDevice && isFirstCheck) {
-          isFirstCheck = false;
-          Log.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] wait 3000ms');
-          await wait(3000);
-        }
+    const clearPollingTimers = () => {
+      if (intervalTimer !== undefined) {
+        clearInterval(intervalTimer);
+        intervalTimer = undefined;
+      }
+      if (timeoutTimer !== undefined) {
+        clearTimeout(timeoutTimer);
+        timeoutTimer = undefined;
+      }
+    };
 
-        if (
-          checkCount > 4 &&
-          DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
-          !this.payload.skipWebDevicePrompt &&
-          !hasPromptedWebDevice &&
-          !isPromptingWebDevice
-        ) {
-          clearInterval(intervalTimer);
-          clearTimeout(timeoutTimer);
-          isPromptingWebDevice = true;
-          try {
-            this.postTipMessage(FirmwareUpdateTipMessage.SelectDeviceInBootloaderForWebDevice);
-            const confirmed = await this._promptDeviceInBootloaderForWebDevice();
-            hasPromptedWebDevice = true;
-            if (confirmed) {
-              await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
-            }
-          } catch (e) {
-            clearInterval(intervalTimer);
-            clearTimeout(timeoutTimer);
-            Log.log(
-              'FirmwareUpdateBaseMethod [checkDeviceToBootloader] _promptDeviceInBootloaderForWebDevice failed: ',
-              e
-            );
-            this.checkPromise?.reject(e);
-          } finally {
-            isPromptingWebDevice = false;
+    const checkForBootloader = async (clearActiveTimers: boolean) => {
+      const found = await this._checkDeviceInBootloaderMode(
+        connectId,
+        clearActiveTimers ? intervalTimer : undefined,
+        clearActiveTimers ? timeoutTimer : undefined
+      );
+      if (found) {
+        isFinished = true;
+        clearPollingTimers();
+      }
+      return found;
+    };
+
+    let startPolling: () => void = () => undefined;
+    const pollForBootloader = async () => {
+      if (isFinished || isPromptingWebDevice) return;
+      checkCount += 1;
+      Log.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
+      if (isTouchOrProDevice && isFirstCheck) {
+        isFirstCheck = false;
+        Log.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] wait 3000ms');
+        await wait(3000);
+      }
+
+      if (
+        checkCount > 4 &&
+        DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
+        !this.payload.skipWebDevicePrompt &&
+        !hasPromptedWebDevice &&
+        !isPromptingWebDevice
+      ) {
+        clearPollingTimers();
+        isPromptingWebDevice = true;
+        try {
+          this.postTipMessage(FirmwareUpdateTipMessage.SelectDeviceInBootloaderForWebDevice);
+          const confirmed = await this._promptDeviceInBootloaderForWebDevice();
+          hasPromptedWebDevice = true;
+          if (confirmed) {
+            await checkForBootloader(false);
+          }
+          // WebUSB enumeration can still be empty immediately after the chooser
+          // resolves. Resume a fresh bounded polling window instead of leaving the
+          // deferred check pending forever after the original timers were paused.
+          if (!isFinished) {
+            startPolling();
           }
-          return;
+        } catch (e) {
+          isFinished = true;
+          clearPollingTimers();
+          Log.log(
+            'FirmwareUpdateBaseMethod [checkDeviceToBootloader] _promptDeviceInBootloaderForWebDevice failed: ',
+            e
+          );
+          this.checkPromise?.reject(e);
+        } finally {
+          isPromptingWebDevice = false;
         }
+        return;
+      }
 
-        if (isBleReconnect) {
-          if (bleProbeInFlight) return;
-          bleProbeInFlight = true;
-          try {
-            await this.device.deviceConnector?.acquire(
-              this.device.originalDescriptor.id,
-              null,
-              true,
-              this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
-            );
-            // Bound each probe so a request the rebooting device never received
-            // frees the slot for the next tick instead of hanging into the
-            // 30s reboot budget.
-            await this.device.initialize({ timeoutMs: BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS });
-            if (this.device.isBootloader()) {
-              clearInterval(intervalTimer);
-              this.checkPromise?.resolve(true);
-            }
-          } catch (e) {
-            // ignore error because of device is not connected
-            Log.log('catch Bluetooth error when device is restarting: ', e);
-          } finally {
-            bleProbeInFlight = false;
+      if (isBleReconnect) {
+        if (bleProbeInFlight) return;
+        bleProbeInFlight = true;
+        try {
+          await this.device.deviceConnector?.acquire(
+            this.device.originalDescriptor.id,
+            null,
+            true,
+            this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
+          );
+          // Bound each probe so a request the rebooting device never received
+          // frees the slot for the next tick instead of hanging into the
+          // 30s reboot budget.
+          await this.device.initialize({ timeoutMs: BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS });
+          if (this.device.isBootloader()) {
+            isFinished = true;
+            clearPollingTimers();
+            this.checkPromise?.resolve(true);
           }
-        } else {
-          await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
+        } catch (e) {
+          // ignore error because of device is not connected
+          Log.log('catch Bluetooth error when device is restarting: ', e);
+        } finally {
+          bleProbeInFlight = false;
         }
-      },
-      isBleReconnect ? 3000 : 2000
-    );
-
-    // check goto bootloader mode timeout and throw error
-    timeoutTimer = setTimeout(() => {
-      if (this.checkPromise) {
-        clearInterval(intervalTimer);
-        this.checkPromise.reject(new Error());
+      } else {
+        await checkForBootloader(true);
       }
-    }, 30000);
+    };
+
+    startPolling = () => {
+      if (isFinished) return;
+      clearPollingTimers();
+      intervalTimer = setInterval(
+        () => {
+          pollForBootloader().catch(error => {
+            if (isFinished) return;
+            isFinished = true;
+            clearPollingTimers();
+            this.checkPromise?.reject(error);
+          });
+        },
+        isBleReconnect ? 3000 : 2000
+      );
+      // Each automatic polling phase is bounded. Time spent in the browser's
+      // permission chooser is intentionally excluded from this deadline.
+      timeoutTimer = setTimeout(() => {
+        if (!isFinished && this.checkPromise) {
+          isFinished = true;
+          clearPollingTimers();
+          this.checkPromise.reject(new Error());
+        }
+      }, 30000);
+    };
+
+    startPolling();
   }
 
   private async _checkDeviceInBootloaderMode(

package/src/api/firmware/FirmwareUpdatePlan.ts

@@ -216,15 +216,20 @@ export const validateProtocolV2FirmwareUpdateTargets = (
   if (value === undefined) {
     return [];
   }
+  if (!Array.isArray(value)) {
+    return planError('Protocol V2 firmware update targets are invalid');
+  }
+  const normalizedTargets = value.map(target =>
+    target === 'boot_resources' ? 'resource' : target
+  );
   if (
-    !Array.isArray(value) ||
-    value.length > PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.size ||
-    value.some(target => !PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.has(target)) ||
-    new Set(value).size !== value.length
+    normalizedTargets.length > PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.size ||
+    normalizedTargets.some(target => !PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.has(target)) ||
+    new Set(normalizedTargets).size !== normalizedTargets.length
   ) {
     return planError('Protocol V2 firmware update targets are invalid');
   }
-  return [...value] as FirmwareUpdateV4Target[];
+  return normalizedTargets as FirmwareUpdateV4Target[];
 };
 
 const assertExactKeys = (
@@ -916,6 +921,14 @@ export const buildFirmwareUpdatePlan = ({
     targetsToUpdate = [...new Set(artifacts.map(artifact => artifact.target))];
   }
 
+  if (
+    executor !== 'v4' &&
+    targetsToUpdate.includes('resource') &&
+    !targetsToUpdate.includes('firmware')
+  ) {
+    planError('Legacy resource updates require a firmware target');
+  }
+
   assertForcedTargetsRepresented({
     executor,
     forcedTargets: validatedForceTargets,