@onekeyfe/hd-core 1.2.0-alpha.6 → 1.2.0-alpha.61

package/src/api/FirmwareUpdateV4.ts

@@ -1,11 +1,14 @@
-import { ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
+import { EDeviceType, ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
 import {
   DeviceRebootType,
   PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
   PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
 } from '@onekeyfe/hd-transport';
+import { sha256 } from '@noble/hashes/sha256';
 
 import { FirmwareUpdateTipMessage, UI_REQUEST } from '../events/ui-request';
+import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
+import { writeProtocolV2File } from './helpers/protocolV2FileWrite';
 import { validateParams } from './helpers/paramsValidator';
 import {
   LoggerNames,
@@ -25,41 +28,51 @@ import {
 } from '../protocols/protocol-v2';
 import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
 import {
-  PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
+  PROTOCOL_V2_RESOURCE_DEVICE_PATHS,
+  buildProtocolV2ResourceUpdatePlan,
+  isProtocolV2ResourceFileValid,
+  readProtocolV2ResourceInventory,
+} from '../protocols/protocol-v2/resources';
+import {
   getProtocolV2UnknownErrorText,
   isProtocolV2DeviceDisconnectedError,
 } from './protocol-v2/helpers';
 
-import type { FirmwareUpdateV4Params } from '../types/api/firmwareUpdate';
+import type { FirmwareUpdateV4Params, FirmwareUpdateV4Target } from '../types/api/firmwareUpdate';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
+import type { ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
 import type { PROTO } from '../constants';
 import type { TypedResponseMessage } from '../device/DeviceCommands';
 import type {
   Features,
   IFirmwareReleaseInfo,
   IProtocolV2FirmwareComponent,
-  IProtocolV2ResourceManifestPackage,
+  IProtocolV2Resource,
+  IProtocolV2ResourceFile,
   IVersionArray,
 } from '../types';
 
 const Log = getLogger(LoggerNames.Method);
 
-const SESSION_ERROR = 'session not found';
-const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 60 * 1000;
+const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
+const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
-const PROTOCOL_V2_START_UPDATE_TIMEOUT = 60 * 1000;
-const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
+const PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT = 15 * 1000;
+const PROTOCOL_V2_START_UPDATE_TIMEOUT = 3 * 60 * 1000;
+const PROTOCOL_V2_INSTALL_TIMEOUT = 8 * 60 * 1000;
+const PROTOCOL_V2_MISSING_TARGET_STATUS_GRACE_TIMEOUT = 30 * 1000;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
 const PROTOCOL_V2_TARGET_STATUS_FINISHED = 2;
 const PROTOCOL_V2_TARGET_STATUS_FAILED_MIN = 3;
 const PROTOCOL_V2_CONNECT_PROTOCOL = 'V2';
-const PROTOCOL_V2_FIRMWARE_STAGING_VOLUME = 'vol1:';
+const PROTOCOL_V2_FIRMWARE_STAGING_VOLUME = 'vol0:/';
 const PROTOCOL_V2_MIN_FILE_CHUNK_SIZE = 64;
 const PROTOCOL_V2_CONNECT_RETRY_COUNT = 10;
 const PROTOCOL_V2_CONNECT_POLL_INTERVAL = 500;
 const PROTOCOL_V2_CONNECT_SINGLE_TIMEOUT = 75 * 1000;
-const PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT = 60 * 1000;
+const PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT = 30 * 1000;
+const PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT = 3;
 const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
 const PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET = 0x200;
 const PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET = 0x240;
@@ -94,10 +107,7 @@ type ProtocolV2FirmwareUpdateStatusTarget = {
   path?: string;
 };
 
-type ProtocolV2FirmwareUpdateStartResponse =
-  | TypedResponseMessage<'Success'>
-  | TypedResponseMessage<'DeviceFirmwareUpdateStatus'>
-  | undefined;
+type ProtocolV2FirmwareUpdateStartResponse = TypedResponseMessage<'Success'>;
 
 type ProtocolV2TargetBinary = { fileName: string; binary: ArrayBuffer; targetId: number };
 type ProtocolV2InstallItem = ProtocolV2TargetBinary & {
@@ -107,6 +117,20 @@ type ProtocolV2InstallTarget = ProtocolV2InstallItem & {
   path: string;
 };
 
+type ProtocolV2FileTransferParams = PROTO.FirmwareUpload & {
+  filePath: string;
+  processedSize?: number;
+  totalSize?: number;
+  onTransferredBytes?: (transferredBytes: number) => void;
+};
+
+/** Protocol V2 resource file written independently to devicePath through FileWrite. */
+type ProtocolV2ResourceBundleBinary = {
+  name: string;
+  binary: ArrayBuffer;
+  devicePath: string;
+};
+
 type ProtocolV2RemoteComponentBinary = ProtocolV2RemoteComponentTarget & {
   binary: ArrayBuffer;
 };
@@ -114,7 +138,7 @@ type ProtocolV2RemoteComponentBinary = ProtocolV2RemoteComponentTarget & {
 type ProtocolV2RemoteComponentTarget = {
   fileName: string;
   targetId: number;
-  kind: 'bootloader' | 'firmware' | 'resource';
+  kind: 'bootloader' | 'firmware';
 };
 
 type ProtocolV2OkppHeader = {
@@ -167,18 +191,24 @@ const PROTOCOL_V2_REMOTE_COMPONENT_TARGETS: Readonly<
     targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04,
     kind: 'firmware',
   },
-  CRATE: {
-    fileName: 'resource.bin',
-    targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
-    kind: 'resource',
-  },
 };
 
+const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map<number, FirmwareUpdateV4Target>([
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER, 'boot'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1, 'app_v1'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2, 'app_v2'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR, 'coprocessor'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01, 'se01'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02, 'se02'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03, 'se03'],
+  [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04, 'se04'],
+]);
+
 const PROTOCOL_V2_ROMLOADER_UNSUPPORTED_MESSAGE =
   'FW_MGMT_TARGET_ROMLOADER is not accepted by the current Pro2 bootloader update request. Flash romloader with the loader-specific flow instead of firmwareUpdateV4.';
 
-// hd-transport 的历史 decode 行为会把单值 enum 输出为枚举名字符串；
-// Protocol V2 沿用这个 SDK 语义，内部比较前再映射回固件协议数值。
+// hd-transport historically decodes scalar enums as enum-name strings.
+// Map them back to firmware protocol values before internal comparisons.
 const PROTOCOL_V2_TARGET_ID_BY_DECODED_NAME = new Map<string, number>(
   Object.entries(ProtocolV2FirmwareTargetType).map(([key, value]) => [key, value])
 );
@@ -204,25 +234,12 @@ const isProtocolV2ReconnectProbeError = (error: unknown) => {
   );
 };
 
-const isProtocolV2PollingTransientError = (error: unknown) => {
-  const message = getProtocolV2UnknownErrorText(error).toLowerCase();
-  return (
-    isProtocolV2DeviceDisconnectedError(error) ||
-    isProtocolV2ReconnectProbeError(error) ||
-    message.includes('libusb_transfer_timed_out') ||
-    (message.includes('response timeout') && message.includes('devicefirmwareupdatestatusget')) ||
-    message.includes('device not found') ||
-    message.includes('transportnotfound')
-  );
-};
-
-const isProtocolV2StartUpdateTransientError = (error: unknown) => {
+const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
   const message = getProtocolV2UnknownErrorText(error).toLowerCase();
   return (
-    isProtocolV2DeviceDisconnectedError(error) ||
-    isProtocolV2ReconnectProbeError(error) ||
-    message.includes('libusb_transfer_timed_out') ||
-    (message.includes('response timeout') && message.includes('devicefirmwareupdaterequest'))
+    message.includes('handler not registered') ||
+    message.includes('message handler not found') ||
+    message.includes('unsupported message')
   );
 };
 
@@ -263,25 +280,6 @@ const normalizeProtocolV2TargetStatus = (
 
 const normalizeProtocolV2Hex = (value?: string) => value?.replace(/^0x/i, '').toLowerCase();
 
-const versionArrayToNumber = (version?: IVersionArray) => {
-  if (!version) return undefined;
-  return version[0] * 0x10000 + version[1] * 0x100 + version[2];
-};
-
-const versionStringToArray = (version?: string | null): IVersionArray | undefined => {
-  if (!version) return undefined;
-  const parts = version.split('.').map(part => Number(part));
-  if (parts.length !== 3 || parts.some(part => !Number.isFinite(part))) return undefined;
-  return parts as IVersionArray;
-};
-
-const compareProtocolV2Versions = (current?: IVersionArray, target?: IVersionArray) => {
-  const currentNumber = versionArrayToNumber(current);
-  const targetNumber = versionArrayToNumber(target);
-  if (currentNumber === undefined || targetNumber === undefined) return undefined;
-  return currentNumber - targetNumber;
-};
-
 const bytesToHex = (bytes: Uint8Array) =>
   Array.from(bytes)
     .map(byte => byte.toString(16).padStart(2, '0'))
@@ -361,6 +359,43 @@ const parseProtocolV2OkppHeader = (bytes: Uint8Array): ProtocolV2OkppHeader | nu
   };
 };
 
+export const isProtocolV2FirmwareFingerprintValid = (
+  binary: ArrayBuffer | Uint8Array,
+  fingerprint: string | undefined
+) => {
+  const expectedFingerprint = normalizeProtocolV2Hex(fingerprint);
+  if (!expectedFingerprint) return true;
+  return bytesToHex(sha256(toProtocolV2Bytes(binary))) === expectedFingerprint;
+};
+
+export const assertProtocolV2ReconnectIdentity = (
+  expectedSerialNumber?: string,
+  actualSerialNumber?: string,
+  expectedPath?: string,
+  actualPath?: string
+) => {
+  if (expectedSerialNumber && actualSerialNumber) {
+    if (actualSerialNumber !== expectedSerialNumber) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceNotFound,
+        `Protocol V2 reconnect physical identity mismatch: expected ${expectedSerialNumber}, received ${actualSerialNumber}`
+      );
+    }
+    return;
+  }
+
+  if (expectedPath && actualPath && expectedPath === actualPath) {
+    return;
+  }
+
+  throw ERRORS.TypedError(
+    HardwareErrorCode.DeviceNotFound,
+    `Protocol V2 reconnect physical identity unavailable: expected path ${
+      expectedPath ?? 'unknown'
+    }, received ${actualPath ?? 'unknown'}`
+  );
+};
+
 /**
  * FirmwareUpdateV4 is the complete Protocol V2 firmware update flow.
  *
@@ -370,9 +405,18 @@ const parseProtocolV2OkppHeader = (bytes: Uint8Array): ProtocolV2OkppHeader | nu
  * - completion waits for target status to finish, reboots to normal, then polls DeviceInfo
  */
 export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareUpdateV4Params> {
+  private protocolV2ExpectedSerialNumber?: string;
+
+  private protocolV2ExpectedPath?: string;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
   init() {
     this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
     this.requireDeviceMode = [];
+    this.unlockPolicy = 'unlock-before-run';
     this.useDevicePassphraseState = false;
     this.skipForceUpdateCheck = true;
 
@@ -393,7 +437,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     validateParams(payload, [
       { name: 'chunkSize', type: 'number' },
-      { name: 'resourceBinaries', type: 'array', allowEmpty: true },
       { name: 'forcedUpdateRes', type: 'boolean' },
       { name: 'bootloaderBinary', type: 'buffer' },
       { name: 'romloaderBinary', type: 'buffer' },
@@ -405,7 +448,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       { name: 'se03Binary', type: 'buffer' },
       { name: 'se04Binary', type: 'buffer' },
       { name: 'firmwareType', type: 'string' },
+      { name: 'targetsToUpdate', type: 'array', allowEmpty: true },
       { name: 'platform', type: 'string' },
+      { name: 'resourceFiles', type: 'array', allowEmpty: true },
     ]);
 
     this.params = {
@@ -420,8 +465,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       se02Binary: payload.se02Binary,
       se03Binary: payload.se03Binary,
       se04Binary: payload.se04Binary,
-      resourceBinaries: payload.resourceBinaries,
+      resourceFiles: payload.resourceFiles,
       firmwareType: payload.firmwareType,
+      targetsToUpdate: payload.targetsToUpdate,
       platform: payload.platform,
     };
   }
@@ -429,10 +475,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private getProtocolV2FirmwareChunkSize() {
     const payloadChunkSize = Number(this.params?.chunkSize);
     const env = DataManager.getSettings('env');
-    const maxChunkSize =
-      this.params?.platform === 'native' || (env && DataManager.isBleConnect(env))
-        ? PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
-        : PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+    const isBle = this.params?.platform === 'native' || (env && DataManager.isBleConnect(env));
+    let maxChunkSize = PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+    if (isBle) {
+      maxChunkSize = PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+    }
     if (!Number.isFinite(payloadChunkSize) || payloadChunkSize <= 0) {
       return maxChunkSize;
     }
@@ -443,62 +490,101 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   async run() {
-    if (!this.device.isProtocolV2()) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'firmwareUpdateV4 requires a Protocol V2 device'
-      );
-    }
-
     Log.debug('FirmwareUpdateV4 strategy: Protocol V2');
     return this.runProtocolV2();
   }
 
   private async runProtocolV2() {
+    await this.captureProtocolV2PhysicalIdentity();
     const deviceFeatures = await this.getProtocolV2DeviceFeatures();
     const deviceFirmwareType = getFirmwareType(deviceFeatures);
     const firmwareType = this.params.firmwareType ?? deviceFirmwareType;
+    const needsRemoteResources =
+      !this.params.resourceFiles?.length && !!this.params.targetsToUpdate?.includes('resource');
 
-    let resourceBinaryMap: ProtocolV2TargetBinary[] = [];
     let fwBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
     let installItems: ProtocolV2InstallItem[] | undefined;
+    let resourceBundles: ProtocolV2ResourceBundleBinary[] | undefined;
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
-      resourceBinaryMap = await this.prepareResourceBinaries(firmwareType, deviceFeatures);
+      resourceBundles = this.prepareExplicitProtocolV2ResourceFiles();
       fwBinaryMap = this.collectExplicitTargetBinaries();
       bootloaderBinary = this.prepareBootloaderBinary();
-      if (!this.hasExplicitProtocolV2Payload(fwBinaryMap)) {
+      const needsRemoteFirmware = !this.hasExplicitProtocolV2Payload(fwBinaryMap);
+      const needsRemoteBootResources = !!this.params.targetsToUpdate?.includes('boot_resources');
+      if (needsRemoteFirmware || needsRemoteResources || needsRemoteBootResources) {
+        // Remote updates must use a freshly fetched config before any reboot or file write.
+        await DataManager.forceReloadData({
+          requireResources: needsRemoteResources || needsRemoteBootResources,
+        });
+      }
+      if (needsRemoteFirmware) {
         const remoteBinaries = await this.prepareRemoteProtocolV2Binaries(
           firmwareType,
           deviceFeatures
         );
-        resourceBinaryMap = remoteBinaries.resourceBinaryMap;
         bootloaderBinary = remoteBinaries.bootloaderBinary;
         fwBinaryMap = remoteBinaries.fwBinaryMap;
         installItems = remoteBinaries.installItems;
       }
-      this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+      const bootResourceFiles = await this.prepareProtocolV2BootResources();
+      if (bootResourceFiles?.length) {
+        resourceBundles = [...(resourceBundles ?? []), ...bootResourceFiles];
+      }
+      if (!needsRemoteResources) {
+        this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+      }
     } catch (err) {
+      if (err instanceof HardwareError && err.errorCode === HardwareErrorCode.NetworkError) {
+        throw err;
+      }
       throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
     }
 
-    if (resourceBinaryMap.length === 0 && !bootloaderBinary && fwBinaryMap.length === 0) {
+    if (
+      !bootloaderBinary &&
+      fwBinaryMap.length === 0 &&
+      !installItems?.length &&
+      !resourceBundles?.length &&
+      !needsRemoteResources
+    ) {
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareUpdateDownloadFailed,
         'No firmware to update'
       );
     }
 
-    await this.enterProtocolV2BootloaderMode();
+    const enteredBootloader = await this.enterProtocolV2BootloaderMode();
+
+    if (needsRemoteResources) {
+      try {
+        const stableResources = await this.prepareProtocolV2ResourceBundles();
+        resourceBundles = [...(resourceBundles ?? []), ...(stableResources ?? [])];
+        this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+      } catch (err) {
+        if (enteredBootloader) {
+          try {
+            await this.exitProtocolV2BootloaderToNormal();
+          } catch (restoreError) {
+            Log.warn(
+              '[FirmwareUpdateV4] failed to restore App mode after resource preparation error:',
+              restoreError
+            );
+          }
+        }
+        throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
+      }
+    }
 
     await this.executeProtocolV2Update({
-      resourceBinaryMap,
       fwBinaryMap,
       bootloaderBinary,
       ...(installItems ? { installItems } : undefined),
+      ...(resourceBundles?.length ? { resourceBundles } : undefined),
     });
 
+    this.postTipMessage(FirmwareUpdateTipMessage.SwitchFirmwareReconnectDevice);
     await this.exitProtocolV2BootloaderToNormal();
 
     const versions = await this.waitForProtocolV2FinalFeatures();
@@ -519,41 +605,46 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device features not available');
   }
 
-  private async prepareResourceBinaries(firmwareType: EFirmwareType, features: Features) {
-    if (this.params.resourceBinaries?.length) {
-      this.params.resourceBinaries.forEach((binary, index) => {
-        if (!(binary instanceof ArrayBuffer)) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.CallMethodInvalidParameter,
-            `Parameter [resourceBinaries.${index}] is of type invalid and should be [buffer].`
-          );
-        }
-      });
+  private getProtocolV2SerialNumber(deviceInfo: ProtocolV2DeviceInfo) {
+    const serialNumber = deviceInfo.hw?.serial_no?.trim();
+    return serialNumber || undefined;
+  }
 
-      return this.params.resourceBinaries.map((binary, index) => ({
-        fileName: `resource-${index + 1}.bin`,
-        binary,
-        targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
-      }));
-    }
-    const resourceUrl = DataManager.getSysResourcesLatestRelease({
-      features,
-      forcedUpdateRes: this.params.forcedUpdateRes,
-      firmwareType,
+  private assertProtocolV2DeviceInfoIdentity(deviceInfo: ProtocolV2DeviceInfo) {
+    assertProtocolV2ReconnectIdentity(
+      this.protocolV2ExpectedSerialNumber,
+      this.getProtocolV2SerialNumber(deviceInfo),
+      this.protocolV2ExpectedPath,
+      this.device.originalDescriptor.path
+    );
+  }
+
+  private getProtocolV2DeviceInfoTimeout() {
+    return this.isBleReconnect()
+      ? this.payload.protocolV2DeviceInfoTimeoutMs ?? PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT
+      : PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT;
+  }
+
+  private async requestProtocolV2PhysicalIdentity() {
+    return requestProtocolV2DeviceInfo({
+      commands: this.device.getCommands(),
+      timeoutMs: this.getProtocolV2DeviceInfoTimeout(),
     });
+  }
 
-    if (resourceUrl) {
-      const resource = (await getSysResourceBinary(resourceUrl)).binary;
-      return [
-        {
-          fileName: 'resource.bin',
-          binary: resource,
-          targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
-        },
-      ];
-    }
-    Log.warn('No resource url found');
-    return [];
+  private async captureProtocolV2PhysicalIdentity() {
+    const deviceInfo = await this.requestProtocolV2PhysicalIdentity();
+    const serialNumber = this.getProtocolV2SerialNumber(deviceInfo);
+    const path = this.device.originalDescriptor.path?.trim() || undefined;
+    assertProtocolV2ReconnectIdentity(serialNumber, serialNumber, path, path);
+    this.protocolV2ExpectedSerialNumber = serialNumber;
+    this.protocolV2ExpectedPath = path;
+  }
+
+  private async verifyProtocolV2ReconnectIdentity() {
+    const deviceInfo = await this.requestProtocolV2PhysicalIdentity();
+    this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
+    return deviceInfo;
   }
 
   private prepareBootloaderBinary(): ArrayBuffer | null {
@@ -562,25 +653,20 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private hasExplicitProtocolV2Payload(fwBinaryMap: ProtocolV2TargetBinary[]) {
     return (
-      !!this.params.resourceBinaries?.length ||
+      !!this.params.resourceFiles?.length ||
       !!this.params.bootloaderBinary ||
       fwBinaryMap.length > 0
     );
   }
 
   private buildProtocolV2InstallItems({
-    resourceBinaryMap,
     bootloaderBinary,
     fwBinaryMap,
   }: {
-    resourceBinaryMap: ProtocolV2TargetBinary[];
     bootloaderBinary: ArrayBuffer | null;
     fwBinaryMap: ProtocolV2TargetBinary[];
   }): ProtocolV2InstallItem[] {
-    const installItems: ProtocolV2InstallItem[] = resourceBinaryMap.map(resource => ({
-      ...resource,
-      kind: 'resource',
-    }));
+    const installItems: ProtocolV2InstallItem[] = [];
 
     if (bootloaderBinary) {
       installItems.push({
@@ -630,203 +716,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return target;
   }
 
-  private getProtocolV2ComponentTargetVersion(
-    release: IFirmwareReleaseInfo,
-    component: IProtocolV2FirmwareComponent,
-    target: ProtocolV2RemoteComponentTarget
-  ) {
-    if (component.version) return component.version;
-    if (target.targetId === ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER) {
-      return release.bootloaderVersion;
-    }
-    if (
-      target.targetId === ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1 ||
-      target.targetId === ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2
-    ) {
-      return release.version;
-    }
-    return undefined;
-  }
-
-  private getProtocolV2ComponentCurrentVersion(
-    features: Features,
-    target: ProtocolV2RemoteComponentTarget
-  ) {
-    switch (target.targetId) {
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER:
-        return getDeviceBootloaderVersion(features);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1:
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2:
-        return getDeviceFirmwareVersion(features);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR:
-        return getDeviceBLEFirmwareVersion(features);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01:
-        return versionStringToArray(features.se01Version);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02:
-        return versionStringToArray(features.se02Version);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03:
-        return versionStringToArray(features.se03Version);
-      case ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04:
-        return versionStringToArray(features.se04Version);
-      default:
-        return undefined;
-    }
-  }
-
-  private isProtocolV2ComponentVersionSatisfied(
-    release: IFirmwareReleaseInfo,
-    component: IProtocolV2FirmwareComponent,
-    target: ProtocolV2RemoteComponentTarget,
-    features: Features
-  ) {
-    const targetVersion = this.getProtocolV2ComponentTargetVersion(release, component, target);
-    if (!targetVersion) return false;
-
-    const currentVersion = this.getProtocolV2ComponentCurrentVersion(features, target);
-    const compareResult = compareProtocolV2Versions(currentVersion, targetVersion);
-    return compareResult !== undefined && compareResult >= 0;
-  }
-
-  private getProtocolV2ResourceFilePath(path: string) {
-    if (path.startsWith('vol')) return path;
-    if (path.startsWith('/')) return `vol0:${path}`;
-    return `vol0:/${path}`;
-  }
-
-  private async readProtocolV2DeviceFileHeader(path: string) {
-    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    const filePath = this.getProtocolV2ResourceFilePath(path);
-    const pathInfoRes = await typedCall('FilesystemPathInfoQuery', 'FilesystemPathInfo', {
-      path: filePath,
-    });
-    const fileSize = toProtocolV2FiniteNumber(pathInfoRes.message?.size);
-    if (
-      !pathInfoRes.message?.exist ||
-      pathInfoRes.message?.directory ||
-      fileSize === undefined ||
-      fileSize < PROTOCOL_V2_OKPP_HEADER_SIZE
-    ) {
-      return null;
-    }
-
-    const chunkSize = this.getProtocolV2FirmwareChunkSize();
-    const chunks: Uint8Array[] = [];
-    let offset = 0;
-    while (offset < PROTOCOL_V2_OKPP_HEADER_SIZE) {
-      const readLen = Math.min(chunkSize, PROTOCOL_V2_OKPP_HEADER_SIZE - offset);
-      const res = await typedCall('FilesystemFileRead', 'FilesystemFile', {
-        file: {
-          path: filePath,
-          offset,
-          total_size: 0,
-        },
-        chunk_len: readLen,
-        ui_percentage: undefined,
-      });
-      const data = toProtocolV2Bytes(res.message?.data);
-      if (data.byteLength === 0) return null;
-      chunks.push(data);
-      offset += data.byteLength;
-    }
-
-    const headerBytes = new Uint8Array(offset);
-    let cursor = 0;
-    chunks.forEach(chunk => {
-      headerBytes.set(chunk, cursor);
-      cursor += chunk.byteLength;
-    });
-    return parseProtocolV2OkppHeader(headerBytes);
-  }
-
-  private async isProtocolV2ResourcePackageMatched(
-    pkg: IProtocolV2ResourceManifestPackage,
-    manifestVersion?: IVersionArray
-  ) {
-    try {
-      const header = await this.readProtocolV2DeviceFileHeader(pkg.path);
-      if (!header) return false;
-
-      const expectedType = pkg.type ?? 'RESC';
-      const expectedVersion = pkg.version ?? manifestVersion;
-      if (header.type !== expectedType) return false;
-      if (expectedVersion && compareProtocolV2Versions(header.version, expectedVersion) !== 0) {
-        return false;
-      }
-
-      const expectedPayloadHash = normalizeProtocolV2Hex(pkg.payloadHash);
-      if (expectedPayloadHash && header.payloadHash !== expectedPayloadHash) return false;
-
-      const expectedHeaderHash = normalizeProtocolV2Hex(pkg.headerHash);
-      if (expectedHeaderHash && header.headerHash !== expectedHeaderHash) return false;
-
-      return true;
-    } catch (error) {
-      Log.log(`Protocol V2 resource package check failed for ${pkg.path}: `, error);
-      return false;
-    }
-  }
-
-  private async isProtocolV2ResourceManifestSatisfied(
-    manifest: IFirmwareReleaseInfo['resourceManifest']
-  ) {
-    if (!manifest?.packages?.length) return false;
-
-    for (const pkg of manifest.packages) {
-      if (!(await this.isProtocolV2ResourcePackageMatched(pkg, manifest.version))) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  private getProtocolV2ResourceManifest(
-    release: IFirmwareReleaseInfo,
-    component: IProtocolV2FirmwareComponent
-  ) {
-    return component.resourceManifest ?? release.resourceManifest;
-  }
-
-  private getProtocolV2ResourceComponentFileName(key: string) {
-    const safeKey = key.replace(/[^a-z0-9_-]/gi, '_') || 'resource';
-    return `resource-${safeKey}.bin`;
-  }
-
-  private async shouldInstallRemoteProtocolV2Component(
-    release: IFirmwareReleaseInfo,
-    key: string,
-    component: IProtocolV2FirmwareComponent,
-    target: ProtocolV2RemoteComponentTarget,
-    features: Features
-  ) {
-    if (target.kind === 'resource') {
-      if (
-        this.params.forcedUpdateRes ||
-        features.bootloaderMode ||
-        features.mode === 'bootloader'
-      ) {
-        return true;
-      }
-      const resourceMatched = await this.isProtocolV2ResourceManifestSatisfied(
-        this.getProtocolV2ResourceManifest(release, component)
-      );
-      if (resourceMatched) {
-        Log.log(`[FirmwareUpdateV4] skip Protocol V2 resource component ${key}; manifest matched`);
-      }
-      return !resourceMatched;
-    }
-
-    const versionSatisfied = this.isProtocolV2ComponentVersionSatisfied(
-      release,
-      component,
-      target,
-      features
-    );
-    if (versionSatisfied) {
-      Log.log(`[FirmwareUpdateV4] skip Protocol V2 component ${key}; version is up to date`);
-    }
-    return !versionSatisfied;
-  }
-
   private async downloadRemoteProtocolV2Component(
     key: string,
     component: IProtocolV2FirmwareComponent
@@ -840,6 +729,22 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     const { binary } = await getSysResourceBinary(component.url);
+    if (!isProtocolV2FirmwareFingerprintValid(binary, component.fingerprint)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 firmware fingerprint mismatch: ${key}/${component.target}`
+      );
+    }
+    const expectedPayloadHash = normalizeProtocolV2Hex(component.payloadHash);
+    if (expectedPayloadHash) {
+      const header = parseProtocolV2OkppHeader(toProtocolV2Bytes(binary));
+      if (!header || header.payloadHash !== expectedPayloadHash) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Protocol V2 firmware payload hash mismatch: ${key}/${component.target}`
+        );
+      }
+    }
     return {
       ...target,
       binary,
@@ -849,14 +754,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private async prepareRemoteProtocolV2Binaries(firmwareType: EFirmwareType, features: Features) {
     const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
 
-    const resourceBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
     const fwBinaryMap: ProtocolV2TargetBinary[] = [];
     const installItems: ProtocolV2InstallItem[] = [];
 
     if (!release) {
       return {
-        resourceBinaryMap,
         bootloaderBinary,
         fwBinaryMap,
         installItems,
@@ -864,27 +767,17 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     const entries = this.getRemoteComponentEntries(release);
+    const targetsToUpdate = new Set(this.params.targetsToUpdate ?? []);
 
     for (const [key, component] of entries) {
-      const target = this.getRemoteComponentTarget(key, component);
-      const shouldInstall = await this.shouldInstallRemoteProtocolV2Component(
-        release,
-        key,
-        component,
-        target,
-        features
-      );
-      if (shouldInstall) {
+      const targetName = component.target?.toUpperCase();
+      const target = PROTOCOL_V2_REMOTE_COMPONENT_TARGETS[targetName];
+      const updateTarget = target
+        ? PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId)
+        : undefined;
+      if (updateTarget && targetsToUpdate.has(updateTarget)) {
         const remoteBinary = await this.downloadRemoteProtocolV2Component(key, component);
-        if (remoteBinary.kind === 'resource') {
-          const binaryEntry = {
-            fileName: this.getProtocolV2ResourceComponentFileName(key),
-            binary: remoteBinary.binary,
-            targetId: remoteBinary.targetId,
-          };
-          resourceBinaryMap.push(binaryEntry);
-          installItems.push({ ...binaryEntry, kind: remoteBinary.kind });
-        } else if (remoteBinary.kind === 'bootloader') {
+        if (remoteBinary.kind === 'bootloader') {
           bootloaderBinary = remoteBinary.binary;
           installItems.push({
             fileName: remoteBinary.fileName,
@@ -905,32 +798,205 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     return {
-      resourceBinaryMap,
       bootloaderBinary,
       fwBinaryMap,
       installItems,
     };
   }
 
+  private getProtocolV2DeviceType(): EDeviceType.Pro2 | EDeviceType.Neo {
+    const deviceType = this.device.getCurrentDeviceType();
+    if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) return deviceType;
+    throw new Error(`Unsupported Protocol V2 device type: ${deviceType}`);
+  }
+
+  private async prepareProtocolV2BootResources(): Promise<
+    ProtocolV2ResourceBundleBinary[] | undefined
+  > {
+    if (!this.params.targetsToUpdate?.includes('boot_resources')) return undefined;
+    const resource = DataManager.getProtocolV2BootResources(this.getProtocolV2DeviceType());
+    if (!resource) throw new Error('Missing Protocol V2 boot resources configuration');
+
+    const files: ProtocolV2ResourceBundleBinary[] = [];
+    for (const file of resource.files) {
+      Log.log(`[FirmwareUpdateV4] downloading boot resource ${file.devicePath}`);
+      const { binary } = await getSysResourceBinary(file.url);
+      if (!isProtocolV2ResourceFileValid(binary, file)) {
+        throw new Error(`Boot resource file verification failed: ${file.devicePath}`);
+      }
+      files.push({
+        name: file.name ?? file.devicePath.split('/').pop() ?? file.devicePath,
+        binary,
+        devicePath: file.devicePath,
+      });
+    }
+    return files;
+  }
+
+  private prepareExplicitProtocolV2ResourceFiles(): ProtocolV2ResourceBundleBinary[] | undefined {
+    const files = this.params.resourceFiles ?? [];
+    if (!files?.length) return undefined;
+
+    const prepared = files.map((file, index) => {
+      const devicePath = validateProtocolV2FilesystemPath(
+        file.devicePath,
+        `resourceFiles[${index}].devicePath`
+      );
+      const descriptor = file as typeof file &
+        Pick<Partial<IProtocolV2ResourceFile>, 'size' | 'fileHash'>;
+      if (descriptor.size !== undefined && descriptor.size !== file.binary.byteLength) {
+        throw new Error(`resourceFiles[${index}] size mismatch`);
+      }
+      if (
+        descriptor.fileHash &&
+        !isProtocolV2ResourceFileValid(file.binary, {
+          size: file.binary.byteLength,
+          fileHash: descriptor.fileHash,
+        })
+      ) {
+        throw new Error(`resourceFiles[${index}] SHA-256 mismatch`);
+      }
+      return {
+        name: devicePath.split('/').pop() ?? devicePath,
+        binary: file.binary,
+        devicePath,
+      };
+    });
+    if (new Set(prepared.map(file => file.devicePath)).size !== prepared.length) {
+      throw new Error('resourceFiles contain duplicate devicePath values');
+    }
+    return prepared;
+  }
+
+  private async prepareProtocolV2ResourceBundles(): Promise<
+    ProtocolV2ResourceBundleBinary[] | undefined
+  > {
+    if (!this.params.targetsToUpdate?.includes('resource')) {
+      return undefined;
+    }
+
+    const resources = DataManager.getProtocolV2Resources(this.getProtocolV2DeviceType());
+    if (!resources?.length) {
+      throw new Error('Missing Pro2 stable resource configuration');
+    }
+
+    const inventory = this.params.forcedUpdateRes
+      ? undefined
+      : await readProtocolV2ResourceInventory({
+          commands: this.device.getCommands(),
+          resources,
+          chunkSize: this.getProtocolV2FirmwareChunkSize(),
+          timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+        });
+    const plan = buildProtocolV2ResourceUpdatePlan({
+      resources,
+      inventory,
+      mode: 'bootloader-recovery',
+      forced: this.params.forcedUpdateRes,
+    });
+    Log.log(
+      `[FirmwareUpdateV4] Protocol V2 resource plan mode=bootloader-recovery status=${plan.status} count=${plan.resources.length}`
+    );
+
+    const bundles: ProtocolV2ResourceBundleBinary[] = [];
+    for (const resource of plan.resources) {
+      bundles.push(await this.downloadProtocolV2Resource(resource));
+    }
+    return bundles;
+  }
+
+  private async downloadProtocolV2Resource(
+    resource: IProtocolV2Resource
+  ): Promise<ProtocolV2ResourceBundleBinary> {
+    Log.log(`[FirmwareUpdateV4] downloading Pro2 resource ${resource.type}`);
+    const { binary } = await getSysResourceBinary(resource.url);
+    if (!isProtocolV2ResourceFileValid(binary, resource)) {
+      throw new Error(`Pro2 resource file verification failed: ${resource.type}`);
+    }
+    return {
+      name: `${resource.type}.okpkg`,
+      binary,
+      devicePath: PROTOCOL_V2_RESOURCE_DEVICE_PATHS[resource.type],
+    };
+  }
+
+  private async syncProtocolV2ResourceBundles(
+    bundles: ProtocolV2ResourceBundleBinary[],
+    firmwareSize: number
+  ): Promise<{ processedSize: number; totalSize: number }> {
+    const transferStartTime = Date.now();
+    const transferTransport = this.getProtocolV2FirmwareTransferTransport();
+
+    // Write directly to the device through FileWrite.
+    let totalSize = 0;
+    for (const b of bundles) totalSize += b.binary.byteLength;
+
+    const transferTotalSize = totalSize + firmwareSize;
+    let processedSize = 0;
+    for (const bundle of bundles) {
+      Log.log(
+        `[FirmwareUpdateV4] syncing resource ${bundle.name} -> ${bundle.devicePath} bytes=${bundle.binary.byteLength}`
+      );
+      processedSize = await this.protocolV2CommonUpdateProcess({
+        payload: bundle.binary,
+        filePath: bundle.devicePath,
+        processedSize,
+        totalSize: transferTotalSize,
+      });
+    }
+
+    const elapsedMs = Date.now() - transferStartTime;
+    Log.log(
+      `[FirmwareUpdateV4] resource sync finished transport=${transferTransport} bytes=${totalSize} elapsed=${(
+        elapsedMs / 1000
+      ).toFixed(2)}s speed=${formatProtocolV2TransferSpeed(totalSize, elapsedMs)} KB/s`
+    );
+    return { processedSize, totalSize: transferTotalSize };
+  }
+
   private isProtocolV2BootloaderMode() {
     if (typeof this.device.isBootloader === 'function') {
-      return this.device.isBootloader();
+      return !!this.device.isBootloader();
     }
-    return !!this.device.features?.bootloaderMode;
+    return (
+      this.device.features?.mode === 'bootloader' ||
+      (this.device.features?.mode == null && !!this.device.features?.bootloaderMode)
+    );
+  }
+
+  private isProtocolV2RomloaderMode() {
+    const deviceType = this.device.getCurrentDeviceType();
+    if (
+      !this.device.isProtocolV2() ||
+      (deviceType !== EDeviceType.Pro2 && deviceType !== EDeviceType.Neo)
+    ) {
+      return false;
+    }
+    if (typeof this.device.isRomloader === 'function') {
+      return this.device.isRomloader();
+    }
+    return this.device.features?.mode === 'romloader';
   }
 
   async enterProtocolV2BootloaderMode() {
+    // romloader is the first update environment and forwards targets to bootloader.
+    // It rejects DeviceRebootType.Bootloader, so reuse the current connection.
+    if (this.isProtocolV2RomloaderMode()) {
+      Log.debug('Protocol V2 device is in romloader mode; start firmware update directly');
+      return false;
+    }
     if (this.isProtocolV2BootloaderMode()) {
-      Log.debug('Protocol V2 device is already in bootloader mode, skip reboot to bootloader');
+      Log.debug('Protocol V2 device is already in bootloader mode, skip reboot');
+      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
       return false;
     }
 
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.AutoRebootToBootloader);
       await this.protocolV2Reboot(DeviceRebootType.Bootloader);
-      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
       await wait(1000);
       await this.waitForProtocolV2BootloaderMode();
+      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
       return true;
     } catch (error) {
       if (error instanceof HardwareError) {
@@ -947,20 +1013,32 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   ) {
     const startTime = Date.now();
     let lastError: unknown;
+    let shouldReconnect = true;
 
     while (Date.now() - startTime < timeout) {
       try {
-        await this.reconnectProtocolV2Device();
+        if (shouldReconnect) {
+          await this.reconnectProtocolV2Device();
+          shouldReconnect = false;
+        }
         const deviceInfo = await requestProtocolV2DeviceInfo({
           commands: this.device.getCommands(),
-          timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+          timeoutMs: this.getProtocolV2DeviceInfoTimeout(),
         });
-        const features = this.device.updateProtocolV2Features(deviceInfo);
-        if (features?.bootloaderMode) {
+        this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
+        const features = await this.device.probeProtocolV2RuntimeState(
+          deviceInfo,
+          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+        );
+        if (features?.mode === 'bootloader') {
           return features;
         }
         lastError = new Error('Protocol V2 device is reachable but is not in bootloader mode');
       } catch (error) {
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
+          throw error;
+        }
+        shouldReconnect = true;
         lastError = error;
         Log.log('Protocol V2 bootloader mode not ready, polling reconnect: ', error);
       }
@@ -976,8 +1054,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   /**
-   * 收集按 DeviceFirmwareTargetType 拆分的显式目标二进制。
-   * 文件名仅用于 staging 路径展示，target_id 已显式给定。
+   * Collect explicit target binaries grouped by DeviceFirmwareTargetType.
+   * Filenames are display-only staging paths because target_id is explicit.
    */
   private collectExplicitTargetBinaries() {
     const entries: ProtocolV2TargetBinary[] = [];
@@ -1014,30 +1092,48 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   private async executeProtocolV2Update({
-    resourceBinaryMap,
     fwBinaryMap,
     bootloaderBinary,
     installItems,
+    resourceBundles,
   }: {
-    resourceBinaryMap?: ProtocolV2TargetBinary[];
     fwBinaryMap?: ProtocolV2TargetBinary[];
     bootloaderBinary?: ArrayBuffer | null;
     installItems?: ProtocolV2InstallItem[];
+    resourceBundles?: ProtocolV2ResourceBundleBinary[];
   }) {
     const orderedInstallItems =
       installItems ??
       this.buildProtocolV2InstallItems({
-        resourceBinaryMap: resourceBinaryMap ?? [],
         bootloaderBinary: bootloaderBinary ?? null,
         fwBinaryMap: fwBinaryMap ?? [],
       });
-    let totalSize = 0;
-    let processedSize = 0;
-    let transferredSize = 0;
 
-    for (const item of orderedInstallItems) totalSize += item.binary.byteLength;
+    let firmwareSize = 0;
+    for (const item of orderedInstallItems) firmwareSize += item.binary.byteLength;
 
     this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
+
+    let processedSize = 0;
+    let totalSize = firmwareSize;
+    if (resourceBundles?.length) {
+      const resourceTransfer = await this.syncProtocolV2ResourceBundles(
+        resourceBundles,
+        firmwareSize
+      );
+      processedSize = resourceTransfer.processedSize;
+      totalSize = resourceTransfer.totalSize;
+    }
+
+    // Skip staging and installation when the update contains resource files only.
+    if (orderedInstallItems.length === 0) {
+      Log.log('[FirmwareUpdateV4] no firmware targets to install (resource files only)');
+      if (totalSize > 0) {
+        this.postProgressMessage(100, 'transferData');
+      }
+      return;
+    }
+    let transferredSize = processedSize;
     const transferStartTime = Date.now();
     const transferTransport = this.getProtocolV2FirmwareTransferTransport();
     const chunkSize = this.getProtocolV2FirmwareChunkSize();
@@ -1064,6 +1160,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           onTransferredBytes,
         });
         transferredSize = processedSize;
+        await this.verifyProtocolV2StagedFile(filePath, item.binary.byteLength);
 
         stagedInstallTargets.push({
           ...item,
@@ -1093,203 +1190,289 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
 
-    const firmwareTargets: Array<{ target_id: number; path: string }> = [];
-    const flushFirmwareTargets = async () => {
-      if (firmwareTargets.length === 0) return;
-      const targets = firmwareTargets.splice(0, firmwareTargets.length);
-      Log.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateRequest targets=${JSON.stringify(targets)}`);
-      const startResponse = await this.protocolV2StartFirmwareUpdate({ targets });
-      await this.waitForProtocolV2FirmwareUpdateComplete(targets, startResponse);
-    };
-
-    for (const item of stagedInstallTargets) {
-      const target = {
-        target_id: item.targetId,
-        path: item.path,
-      };
-      if (item.kind === 'resource') {
-        await flushFirmwareTargets();
-        const resourceTargets = [target];
-        Log.log(
-          `[FirmwareUpdateV4] DeviceFirmwareUpdateRequest resources=${JSON.stringify(
-            resourceTargets
-          )}`
-        );
-        const startResponse = await this.protocolV2StartFirmwareUpdate({
-          targets: resourceTargets,
-        });
-        await this.waitForProtocolV2FirmwareUpdateComplete(resourceTargets, startResponse);
-      } else {
-        firmwareTargets.push(target);
-      }
-    }
-
-    await flushFirmwareTargets();
+    const allTargets = stagedInstallTargets.map(item => ({
+      target_id: item.targetId,
+      path: item.path,
+    }));
+    Log.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateRequest targets=${JSON.stringify(allTargets)}`);
+    await this.protocolV2StartFirmwareUpdate({ targets: allTargets });
+    await this.waitForProtocolV2FirmwareUpdateComplete(allTargets);
   }
 
   private getProtocolV2InstallItemStagingPath(item: ProtocolV2InstallItem) {
     return `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}${item.fileName}`;
   }
 
-  private async queryProtocolV2FirmwareUpdateStatus() {
+  private async verifyProtocolV2StagedFile(path: string, expectedSize: number) {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    return typedCall(
-      'DeviceFirmwareUpdateStatusGet',
-      'DeviceFirmwareUpdateStatus',
-      {},
-      {
-        timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
-      }
-    );
-  }
-
-  private async pingProtocolV2Device() {
-    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    await typedCall(
-      'Ping',
-      'Success',
-      { message: 'firmware-update' },
-      {
-        timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
-      }
-    );
-  }
-
-  private isProtocolV2NormalModeFeatures(features?: Features | null) {
-    return !!features && !features.bootloaderMode && features.mode !== 'bootloader';
-  }
-
-  private async probeProtocolV2NormalMode() {
-    const deviceInfo = await requestProtocolV2DeviceInfo({
-      commands: this.device.getCommands(),
-      timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
-      request: PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
-    });
-    const features = this.device.updateProtocolV2Features(deviceInfo);
-    if (this.isProtocolV2NormalModeFeatures(features)) {
-      Log.log('Protocol V2 firmware install finished; device is back in normal mode');
-      return true;
+    const response = await typedCall('FilesystemPathInfoQuery', 'FilesystemPathInfo', { path });
+    const actualSize = toProtocolV2FiniteNumber(response.message?.size);
+    if (!response.message?.exist || response.message?.directory || actualSize !== expectedSize) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.EmmcFileWriteFirmwareError,
+        `staged file verification failed: path=${path} exist=${!!response.message
+          ?.exist} expected=${expectedSize} actual=${actualSize ?? 'unknown'}`
+      );
     }
-    return false;
   }
 
   private assertProtocolV2TargetStatus(
     statusTargets: ProtocolV2FirmwareUpdateStatusTarget[],
     expectedTargetIds: Set<number>
   ) {
+    Log.log(
+      `[FirmwareUpdateV4] DeviceFirmwareUpdateStatus records=${JSON.stringify(statusTargets)}`
+    );
     const failedTarget = statusTargets.find(
       target =>
         expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1) &&
         isProtocolV2TargetStatusFailed(target.status)
     );
     if (failedTarget) {
+      const failedTargetDetails = JSON.stringify({
+        targetId: failedTarget.target_id,
+        status: failedTarget.status,
+        payloadVersion: failedTarget.payload_version,
+        path: failedTarget.path,
+      });
+      Log.error(`[FirmwareUpdateV4] firmware install failed target=${failedTargetDetails}`);
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareError,
-        `Protocol V2 firmware target ${failedTarget.target_id} failed`
+        `Protocol V2 firmware target failed: target=${failedTarget.target_id} status=${
+          failedTarget.status ?? 'unknown'
+        } payloadVersion=${failedTarget.payload_version ?? 'unknown'} path=${
+          failedTarget.path ?? 'unknown'
+        }`
       );
     }
 
-    const completedTargets = statusTargets.filter(
-      target =>
-        expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1) &&
-        isProtocolV2TargetStatusFinished(target.status)
+    const matchingTargets = statusTargets.filter(target =>
+      expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1)
     );
-    if (completedTargets.length === expectedTargetIds.size && expectedTargetIds.size > 0) {
+    const completedTargetIds = new Set<number>();
+    matchingTargets.forEach(target => {
+      const targetId = normalizeProtocolV2TargetId(target.target_id);
+      if (targetId !== undefined && isProtocolV2TargetStatusFinished(target.status)) {
+        completedTargetIds.add(targetId);
+      }
+    });
+    const allExpectedTargetsCompleted =
+      expectedTargetIds.size > 0 &&
+      Array.from(expectedTargetIds).every(targetId => completedTargetIds.has(targetId));
+    if (allExpectedTargetsCompleted) {
+      this.postProgressMessage(100, 'installingFirmware');
       return true;
     }
 
-    const inProgressTarget = statusTargets.find(
-      target =>
-        expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1) &&
+    if (expectedTargetIds.size > 0 && matchingTargets.length > 0) {
+      const hasInProgressTarget = matchingTargets.some(target =>
         isProtocolV2TargetStatusInProgress(target.status)
-    );
-    if (inProgressTarget) {
-      this.postProgressMessage(99, 'installingFirmware');
+      );
+      const completedProgress = Math.floor(
+        (completedTargetIds.size / expectedTargetIds.size) * 100
+      );
+      // The protocol exposes no per-target percentage, so report coarse progress by
+      // completed targets and use 1% once work starts to keep the UI responsive.
+      const progress = Math.min(99, Math.max(completedProgress, hasInProgressTarget ? 1 : 0));
+      this.postProgressMessage(progress, 'installingFirmware');
     }
 
     return false;
   }
 
-  private async waitForProtocolV2FirmwareUpdateComplete(
-    targets: Array<{ target_id: number; path: string }>,
-    startResponse?: ProtocolV2FirmwareUpdateStartResponse
+  private getProtocolV2MissingTargetIds(
+    statusTargets: ProtocolV2FirmwareUpdateStatusTarget[],
+    expectedTargetIds: Set<number>
   ) {
-    const expectedTargetIds = new Set(targets.map(target => target.target_id));
-    if (startResponse?.type === 'DeviceFirmwareUpdateStatus') {
-      const statusTargets = (startResponse.message.records ??
-        []) as ProtocolV2FirmwareUpdateStatusTarget[];
-      if (this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds)) {
-        return;
+    const reportedTargetIds = new Set<number>();
+    statusTargets.forEach(target => {
+      const targetId = normalizeProtocolV2TargetId(target.target_id);
+      if (targetId !== undefined) {
+        reportedTargetIds.add(targetId);
       }
-    }
+    });
+    return Array.from(expectedTargetIds).filter(targetId => !reportedTargetIds.has(targetId));
+  }
 
+  private async waitForProtocolV2FirmwareUpdateComplete(
+    targets: Array<{ target_id: number; path: string }>
+  ) {
+    const expectedTargetIds = new Set(targets.map(target => target.target_id));
     const startTime = Date.now();
     let lastError: unknown;
+    let shouldReconnect = true;
+    let deviceInfo: ProtocolV2DeviceInfo | undefined;
+    let missingTargetStatusSince: number | undefined;
+    let missingTargetStatusKey: string | undefined;
+    const resetMissingTargetStatusGrace = () => {
+      missingTargetStatusSince = undefined;
+      missingTargetStatusKey = undefined;
+    };
 
     while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
       try {
-        const statusRes = await this.queryProtocolV2FirmwareUpdateStatus();
-        const statusTargets = (statusRes.message.records ??
-          []) as ProtocolV2FirmwareUpdateStatusTarget[];
-        if (this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds)) {
-          return;
-        }
-      } catch (error) {
-        lastError = error;
-        if (error instanceof HardwareError && error.errorCode === HardwareErrorCode.FirmwareError) {
-          throw error;
+        if (shouldReconnect) {
+          await this.reconnectProtocolV2Device();
+          deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+          shouldReconnect = false;
         }
-        Log.log('Protocol V2 firmware install status polling failed: ', error);
-        if (isProtocolV2PollingTransientError(error)) {
-          try {
-            await this.reconnectProtocolV2Device();
-            if (await this.probeProtocolV2NormalMode()) {
+        const currentDeviceInfo = deviceInfo;
+        try {
+          const statusResponse = await this.device.getCommands().typedCall(
+            'DeviceFirmwareUpdateStatusGet',
+            'DeviceFirmwareUpdateStatus',
+            {
+              fields: {
+                status: true,
+                payload_version: true,
+                path: true,
+              },
+            },
+            { timeoutMs: PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT }
+          );
+          const statusTargets = (statusResponse.message.records ??
+            []) as ProtocolV2FirmwareUpdateStatusTarget[];
+          if (this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds)) {
+            return;
+          }
+
+          if (
+            statusTargets.length === 0 &&
+            currentDeviceInfo &&
+            (await this.probeProtocolV2NormalMode(currentDeviceInfo))
+          ) {
+            Log.log(
+              '[FirmwareUpdateV4] empty firmware status after confirmed App reboot; update complete'
+            );
+            this.postProgressMessage(100, 'installingFirmware');
+            return;
+          }
+
+          const missingTargetIds = this.getProtocolV2MissingTargetIds(
+            statusTargets,
+            expectedTargetIds
+          );
+          if (missingTargetIds.length > 0) {
+            const now = Date.now();
+            const missingKey = missingTargetIds.join(',');
+            if (missingTargetStatusSince === undefined || missingTargetStatusKey !== missingKey) {
+              missingTargetStatusSince = now;
+              missingTargetStatusKey = missingKey;
+            } else if (
+              now - missingTargetStatusSince >=
+              PROTOCOL_V2_MISSING_TARGET_STATUS_GRACE_TIMEOUT
+            ) {
+              const reportedTargetIds = statusTargets
+                .map(target => normalizeProtocolV2TargetId(target.target_id))
+                .filter((targetId): targetId is number => targetId !== undefined);
+              throw ERRORS.TypedError(
+                HardwareErrorCode.FirmwareError,
+                `Protocol V2 firmware status is missing requested records: targetIds=${missingKey} reportedTargetIds=${reportedTargetIds.join(
+                  ','
+                )}`
+              );
+            }
+            lastError = new Error(
+              `Protocol V2 firmware status is temporarily missing targetIds=${missingKey}`
+            );
+          } else {
+            resetMissingTargetStatusGrace();
+            lastError = new Error('Protocol V2 firmware targets are still installing');
+          }
+        } catch (error) {
+          if (
+            error instanceof HardwareError &&
+            error.errorCode === HardwareErrorCode.FirmwareError
+          ) {
+            throw error;
+          }
+          // Only consecutive full status dumps can prove that a record is absent.
+          // A reboot or transport interruption starts a fresh grace window.
+          resetMissingTargetStatusGrace();
+          // App firmware does not register DeviceFirmwareUpdateStatusGet. Treat the
+          // missing endpoint as completion only after the runtime probe confirms App mode.
+          if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
+            if (!currentDeviceInfo) {
+              throw ERRORS.TypedError(
+                HardwareErrorCode.RuntimeError,
+                'Protocol V2 device identity is unavailable during install polling'
+              );
+            }
+            if (await this.probeProtocolV2NormalMode(currentDeviceInfo)) {
+              Log.log(
+                '[FirmwareUpdateV4] firmware status endpoint unavailable after confirmed App reboot'
+              );
+              this.postProgressMessage(100, 'installingFirmware');
               return;
             }
-          } catch (reconnectError) {
-            lastError = reconnectError;
+            lastError = new Error(
+              'Protocol V2 firmware status endpoint is unavailable while the device remains in loader mode'
+            );
+          } else {
+            shouldReconnect = true;
+            deviceInfo = undefined;
+            lastError = error;
             Log.log(
-              'Protocol V2 firmware install reconnect/normal-mode probe failed: ',
-              reconnectError
+              '[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ',
+              error
             );
           }
-          try {
-            await this.pingProtocolV2Device();
-            Log.log('Protocol V2 firmware status unavailable, Ping is ready');
-          } catch (pingError) {
-            lastError = pingError;
-            Log.log('Protocol V2 firmware install Ping polling failed: ', pingError);
-          }
         }
+      } catch (error) {
+        lastError = error;
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
+          throw error;
+        }
+        if (error instanceof HardwareError && error.errorCode === HardwareErrorCode.FirmwareError) {
+          throw error;
+        }
+        shouldReconnect = true;
+        deviceInfo = undefined;
+        resetMissingTargetStatusGrace();
+        Log.log('Protocol V2 firmware install device readiness probe failed: ', error);
       }
       await wait(1000);
     }
 
     throw ERRORS.TypedError(
       HardwareErrorCode.RuntimeError,
-      `Protocol V2 firmware update status timeout: ${this.normalizeErrorMessage(lastError)}`
+      `Protocol V2 firmware update status not complete within ${
+        PROTOCOL_V2_INSTALL_TIMEOUT / 1000
+      }s: ${this.normalizeErrorMessage(lastError)}`
     );
   }
 
   private async exitProtocolV2BootloaderToNormal() {
-    this.postTipMessage(FirmwareUpdateTipMessage.SwitchFirmwareReconnectDevice);
+    await this.reconnectProtocolV2Device();
+    const deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
     try {
-      await this.reconnectProtocolV2Device();
-      if (await this.probeProtocolV2NormalMode()) {
-        Log.log('Protocol V2 device is already in normal mode, skip normal reboot');
+      if (await this.probeProtocolV2NormalMode(deviceInfo)) {
+        Log.log('[FirmwareUpdateV4] device already returned to App mode; skip Normal reboot');
         return;
       }
     } catch (error) {
-      Log.log('Protocol V2 normal-mode probe before reboot failed: ', error);
+      Log.log('[FirmwareUpdateV4] unable to confirm App mode before Normal reboot: ', error);
     }
     await this.protocolV2Reboot(DeviceRebootType.Normal);
   }
 
+  private async probeProtocolV2NormalMode(deviceInfo: ProtocolV2DeviceInfo) {
+    const features = await this.device.probeProtocolV2RuntimeState(
+      deviceInfo,
+      PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+    );
+    return features.mode === 'normal' && !features.bootloaderMode;
+  }
+
   private async waitForProtocolV2FinalFeatures() {
     const features = await this.waitForProtocolV2ReconnectAndFeatures(
-      PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT
+      PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT
     );
 
+    return this.getProtocolV2VersionResult(features);
+  }
+
+  private getProtocolV2VersionResult(features: Features) {
     const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
     const bleVersion = getDeviceBLEFirmwareVersion(features).join('.');
     const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
@@ -1309,29 +1492,41 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private async waitForProtocolV2ReconnectAndFeatures(timeout: number) {
     const startTime = Date.now();
     let lastError: unknown;
+    let shouldReconnect = true;
 
     while (Date.now() - startTime < timeout) {
       try {
-        await this.reconnectProtocolV2Device();
+        if (shouldReconnect) {
+          await this.reconnectProtocolV2Device();
+          shouldReconnect = false;
+        }
         const deviceInfo = await requestProtocolV2DeviceInfo({
           commands: this.device.getCommands(),
-          timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
-          // 更新完成判定只需要各 target 版本号；scope 与请求内容保持一致
+          timeoutMs: this.getProtocolV2DeviceInfoTimeout(),
+          // Completion needs target versions only; keep scope aligned with the request.
           request: PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
         });
-        const features = this.device.updateProtocolV2Features(deviceInfo);
-        if (features.bootloaderMode || features.mode === 'bootloader') {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.DeviceNotFound,
-            'Protocol V2 device is still in bootloader mode'
-          );
+        this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
+        const features = await this.device.probeProtocolV2RuntimeState(
+          deviceInfo,
+          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+        );
+        if (features.mode === 'normal' && !features.bootloaderMode) {
+          return features;
         }
-        return features;
+        lastError = ERRORS.TypedError(
+          HardwareErrorCode.DeviceNotFound,
+          'Protocol V2 device is still in bootloader mode'
+        );
       } catch (error) {
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
+          throw error;
+        }
+        shouldReconnect = true;
         lastError = error;
         Log.log('Protocol V2 normal mode not ready, polling Ping: ', error);
-        await wait(1000);
       }
+      await wait(1000);
     }
 
     throw ERRORS.TypedError(
@@ -1355,54 +1550,101 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
       devicesDescriptor.length === 1
     ) {
+      const descriptor = devicesDescriptor[0];
+      if (!this.protocolV2ExpectedSerialNumber && descriptor.path !== this.protocolV2ExpectedPath) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
+      }
       this.device.updateDescriptor(
         {
-          ...devicesDescriptor[0],
+          ...descriptor,
           protocolType: PROTOCOL_V2_CONNECT_PROTOCOL,
         },
         true
       );
-      await this.device.acquire(PROTOCOL_V2_CONNECT_PROTOCOL, { throwOnRunPromiseError: true });
+      await this.ensureProtocolV2DeviceAcquired();
       this.device.commands.disposed = false;
       this.device.getCommands().mainId = this.device.mainId ?? '';
-      await this.device.initialize();
       return;
     }
 
-    // App 与 bootloader 序列号暂时可能不一致。V4 升级重连阶段只接受唯一枚举设备，
-    // 避免继续按旧 app connectId 查缓存导致反复输出 path mismatch 日志。
+    // Reinitialize every USB descriptor so DeviceInfo can provide the physical serial.
+    // Enumeration order is not stable and must never decide the reconnect target.
     const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined, {
       connectProtocol: PROTOCOL_V2_CONNECT_PROTOCOL,
     });
-    if (deviceList.length !== 1) {
+    const expectedSerialNumber = this.protocolV2ExpectedSerialNumber?.trim();
+    const expectedPath = this.protocolV2ExpectedPath?.trim();
+    const reconnectDevice = deviceList.find(candidate => {
+      const candidateSerialNumber = candidate.getCurrentSerialNo?.().trim();
+      if (expectedSerialNumber && candidateSerialNumber) {
+        return candidateSerialNumber === expectedSerialNumber;
+      }
+      return !!expectedPath && candidate.getConnectId() === expectedPath;
+    });
+    if (!reconnectDevice) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
     }
 
     Log.debug(
-      'Protocol V2 firmware reconnect using single enumerated device:',
-      deviceList[0].getConnectId()
+      'Protocol V2 firmware reconnect using matched device:',
+      reconnectDevice.getConnectId()
     );
-    this.device.updateFromCache(deviceList[0]);
-    await this.device.acquire(PROTOCOL_V2_CONNECT_PROTOCOL, { throwOnRunPromiseError: true });
+    this.device.updateFromCache(reconnectDevice);
+    await this.ensureProtocolV2DeviceAcquired();
     this.device.commands.disposed = false;
     this.device.getCommands().mainId = this.device.mainId ?? '';
-    await this.device.initialize();
   }
 
-  private async protocolV2CommonUpdateProcess({
+  /**
+   * After acquiring a USB session, polling reuses its command channel. Reacquire only
+   * after reboot or enumeration changes cause hasDeviceAcquire() to become false.
+   */
+  private async ensureProtocolV2DeviceAcquired() {
+    const commands = this.device.getCommands();
+    if (this.device.hasDeviceAcquire() && !commands.disposed) {
+      return;
+    }
+    await this.device.acquire(PROTOCOL_V2_CONNECT_PROTOCOL, {
+      throwOnRunPromiseError: true,
+    });
+  }
+
+  private isProtocolV2ReconnectIdentityError(error: unknown) {
+    return this.normalizeErrorMessage(error).includes('Protocol V2 reconnect physical identity');
+  }
+
+  private async protocolV2CommonUpdateProcess(params: ProtocolV2FileTransferParams) {
+    let lastError: unknown;
+    for (let attempt = 1; attempt <= PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT; attempt += 1) {
+      try {
+        return await this.protocolV2WriteWholeFile(params);
+      } catch (error) {
+        lastError = error;
+        Log.error(
+          `Protocol V2 file transfer failed path=${params.filePath} attempt=${attempt}/${PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT}; restarting from offset 0`,
+          error
+        );
+        if (attempt === PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
+          break;
+        }
+        await this.recoverProtocolV2FileTransfer();
+      }
+    }
+
+    throw ERRORS.TypedError(
+      HardwareErrorCode.EmmcFileWriteFirmwareError,
+      `transfer data error: ${getProtocolV2UnknownErrorText(lastError)}`
+    );
+  }
+
+  private async protocolV2WriteWholeFile({
     payload,
     filePath,
     processedSize,
     totalSize,
     onTransferredBytes,
-  }: PROTO.FirmwareUpload & {
-    filePath: string;
-    processedSize?: number;
-    totalSize?: number;
-    onTransferredBytes?: (transferredBytes: number) => void;
-  }) {
+  }: ProtocolV2FileTransferParams) {
     const chunkSize = this.getProtocolV2FirmwareChunkSize();
-    let offset = 0;
     const getUploadProgress = (fileOffset: number) => {
       if (totalSize !== undefined && processedSize !== undefined) {
         return Math.min(Math.ceil(((processedSize + fileOffset) / totalSize) * 100), 99);
@@ -1410,39 +1652,43 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       return Math.min(Math.ceil((fileOffset / payload.byteLength) * 100), 99);
     };
 
-    while (offset < payload.byteLength) {
-      const chunkEnd = Math.min(offset + chunkSize, payload.byteLength);
-      const chunkLength = chunkEnd - offset;
-      const chunk = payload.slice(offset, chunkEnd);
-      const overwrite = offset === 0;
-      const progress = getProtocolV2DeviceTransferProgress(
-        (processedSize ?? 0) + offset,
-        (processedSize ?? 0) + chunkEnd,
-        totalSize ?? payload.byteLength
-      );
-
-      const writeRes = await this.fileWriteWithRetry(
-        filePath,
-        payload.byteLength,
-        offset,
-        chunk,
-        overwrite,
-        progress
-      );
-      const processedByte = Number(writeRes.message.processed_byte);
-      const nextOffset =
-        Number.isFinite(processedByte) && processedByte > offset
-          ? processedByte
-          : offset + chunkLength;
-      if (nextOffset <= offset || nextOffset > payload.byteLength) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.EmmcFileWriteFirmwareError,
-          `invalid processed_byte ${writeRes.message.processed_byte} for offset ${offset}`
-        );
+    try {
+      await writeProtocolV2File({
+        commands: this.device.getCommands(),
+        path: filePath,
+        data: payload,
+        totalSize: payload.byteLength,
+        chunkSize,
+        overwrite: true,
+        append: false,
+        writeWithResponse: true,
+        maxChunkRetries: 0,
+        getUiPercentage: ({ offset, chunkLength }) =>
+          getProtocolV2DeviceTransferProgress(
+            (processedSize ?? 0) + offset,
+            (processedSize ?? 0) + offset + chunkLength,
+            totalSize ?? payload.byteLength
+          ),
+        onProgress: progress => {
+          const transferredBytes = (processedSize ?? 0) + progress.transferredBytes;
+          onTransferredBytes?.(transferredBytes);
+          this.postProgressMessage(getUploadProgress(progress.transferredBytes), 'transferData', {
+            transferredBytes,
+            totalBytes: totalSize ?? payload.byteLength,
+            rateBytesPerSecond: progress.rateBytesPerSecond,
+            elapsedMs: progress.elapsedMs,
+          });
+        },
+      });
+    } catch (error) {
+      if (
+        error instanceof HardwareError &&
+        error.errorCode === HardwareErrorCode.RuntimeError &&
+        error.message.includes('FilesystemFileWrite')
+      ) {
+        throw ERRORS.TypedError(HardwareErrorCode.EmmcFileWriteFirmwareError, error.message);
       }
-      offset = nextOffset;
-      onTransferredBytes?.((processedSize ?? 0) + offset);
-      this.postProgressMessage(getUploadProgress(offset), 'transferData');
+      throw error;
     }
 
     return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
@@ -1462,65 +1708,15 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return env ?? 'unknown';
   }
 
-  private async fileWriteWithRetry(
-    filePath: string,
-    totalFileSize: number,
-    offset: number,
-    chunk: ArrayBuffer | Buffer,
-    overwrite: boolean,
-    progress: number | null
-  ): Promise<TypedResponseMessage<'FilesystemFile'>> {
-    const writeFunc = async () => {
-      const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-      const writeRes = await typedCall('FilesystemFileWrite', 'FilesystemFile', {
-        file: {
-          path: filePath,
-          offset,
-          total_size: totalFileSize,
-          data: chunk,
-        },
-        overwrite,
-        append: false,
-        ui_percentage: progress ?? undefined,
-      });
-      if (writeRes.type !== 'FilesystemFile') {
-        if ((writeRes as any).type === 'CallMethodError') {
-          if (((writeRes as any).message.error ?? '').indexOf(SESSION_ERROR) > -1) {
-            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, SESSION_ERROR);
-          }
-        }
-        throw ERRORS.TypedError(
-          HardwareErrorCode.EmmcFileWriteFirmwareError,
-          'transfer data error'
-        );
-      }
-      return writeRes;
-    };
-
-    let retryCount = 10;
-    while (retryCount > 0) {
-      try {
-        const result = await writeFunc();
-        return result;
-      } catch (error) {
-        Log.error(`fileWrite error: `, error);
-        retryCount--;
-        if (retryCount === 0) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.EmmcFileWriteFirmwareError,
-            'transfer data error'
-          );
-        }
-        const env = DataManager.getSettings('env');
-        if (DataManager.isBleConnect(env)) {
-          await wait(3000);
-          await this.acquireProtocolV2BleDevice();
-          await this.device.initialize();
-        }
-        await wait(2000);
-      }
+  private async recoverProtocolV2FileTransfer() {
+    const env = DataManager.getSettings('env');
+    if (DataManager.isBleConnect(env)) {
+      await wait(3000);
     }
-    throw ERRORS.TypedError(HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
+    await this.reconnectProtocolV2Device();
+    await this.verifyProtocolV2ReconnectIdentity();
+    await this.device.initialize();
+    await wait(2000);
   }
 
   private async acquireProtocolV2BleDevice() {
@@ -1538,35 +1734,16 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     targets: Array<{ target_id: number; path: string }>;
   }) {
     const commands = this.device.getCommands();
-    let response: ProtocolV2FirmwareUpdateStartResponse;
-    try {
-      response = await commands.typedCall(
-        'DeviceFirmwareUpdateRequest',
-        PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
-        {
-          targets,
-        },
-        {
-          intermediateTypes: ['DeviceFirmwareUpdateStatus'],
-          timeoutMs: PROTOCOL_V2_START_UPDATE_TIMEOUT,
-          onIntermediateResponse: (response: { type?: string }) => {
-            if (response.type === 'DeviceFirmwareUpdateStatus') {
-              this.postProgressMessage(99, 'installingFirmware');
-            }
-          },
-        }
-      );
-    } catch (error) {
-      if (isProtocolV2StartUpdateTransientError(error)) {
-        Log.log(
-          'Protocol V2 firmware update request did not return; continue status polling',
-          error
-        );
-      } else {
-        throw error;
-      }
-    }
+    const response: ProtocolV2FirmwareUpdateStartResponse = await commands.typedCall(
+      'DeviceFirmwareUpdateRequest',
+      'Success',
+      { targets },
+      { timeoutMs: PROTOCOL_V2_START_UPDATE_TIMEOUT }
+    );
+    // Success acknowledges that the device accepted installation. End confirmation
+    // and begin status polling only after receiving this ACK.
     this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdating);
+    this.postProgressMessage(0, 'installingFirmware');
     return response;
   }
 
@@ -1576,9 +1753,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       const res = await typedCall('DeviceReboot', 'Success', {
         reboot_type: rebootType,
       });
+      this.device.markProtocolV2Reboot(rebootType);
       return res.message;
     } catch (error) {
       if (isProtocolV2DeviceDisconnectedError(error) || isProtocolV2ReconnectProbeError(error)) {
+        this.device.markProtocolV2Reboot(rebootType);
         return { message: 'Device rebooted successfully' };
       }
       throw error;