@onekeyfe/hd-core 1.2.0-alpha.3 → 1.2.0-alpha.31

package/src/api/FirmwareUpdateV4.ts

@@ -1,11 +1,13 @@
 import { ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
 import {
-  DevRebootType,
+  DeviceRebootType,
   PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
+  PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE,
   PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
 } from '@onekeyfe/hd-transport';
 
 import { FirmwareUpdateTipMessage, UI_REQUEST } from '../events/ui-request';
+import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
 import { validateParams } from './helpers/paramsValidator';
 import {
   LoggerNames,
@@ -15,50 +17,233 @@ import {
   getFirmwareType,
   getLogger,
 } from '../utils';
-import { getBinary, getSysResourceBinary } from './firmware/getBinary';
+import { getSysResourceBinary } from './firmware/getBinary';
+import { normalizeFirmwarePreparationError } from './firmware/FirmwarePreparationError';
 import { DataManager } from '../data-manager';
 import { FirmwareUpdateBaseMethod } from './firmware/FirmwareUpdateBaseMethod';
 import { DevicePool } from '../device/DevicePool';
 import {
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
   ProtocolV2FirmwareTargetType,
-  protocolV2FileNameToTargetId,
 } from '../protocols/protocol-v2';
 import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
 import {
-  PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
   getProtocolV2UnknownErrorText,
   isProtocolV2DeviceDisconnectedError,
 } from './protocol-v2/helpers';
-
-import type { FirmwareUpdateV4Params } from '../types/api/firmwareUpdate';
+import { openFirmwareByteSource, writeFirmwareByteSource } from './firmware/FirmwareArtifactSource';
+import { resolveFirmwareUpdateHostBinding } from './firmware/FirmwareHostBinding';
+import {
+  assertFirmwareUpdatePreparedPlanBinding,
+  assertFirmwareUpdatePreparedPlanDeviceIdentity,
+} from './firmware/FirmwareUpdatePreparedPlan';
+
+import type {
+  FirmwareArtifactReference,
+  FirmwareUpdateV4Params,
+  FirmwareUpdateV4Target,
+} from '../types/api/firmwareUpdate';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
-import type { PROTO } from '../constants';
+import type { ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
 import type { TypedResponseMessage } from '../device/DeviceCommands';
-import type { Features } from '../types';
+import type {
+  Features,
+  IFirmwareReleaseInfo,
+  IProtocolV2FirmwareComponent,
+  IVersionArray,
+} from '../types';
+import type { FirmwareByteSource } from './firmware/FirmwareArtifactSource';
 
 const Log = getLogger(LoggerNames.Method);
 
 const SESSION_ERROR = 'session not found';
 const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 60 * 1000;
+const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 2 * 60 * 1000;
 const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
+const PROTOCOL_V2_START_UPDATE_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
-const PROTOCOL_V2_TARGET_STATUS_FINISHED = 0;
+const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
-const PROTOCOL_V2_TARGET_STATUS_FAILED = 2;
+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_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;
+const PROTOCOL_V2_OKPP_HASH_SIZE = 64;
+
+const getProtocolV2DeviceTransferProgress = (
+  bytesBeforeChunk: number,
+  bytesAfterChunk: number,
+  totalBytes: number
+) => {
+  if (!Number.isFinite(totalBytes) || totalBytes <= 0) {
+    return 100;
+  }
+  if (bytesBeforeChunk <= 0 && bytesAfterChunk < totalBytes) {
+    return 0;
+  }
+  if (bytesAfterChunk >= totalBytes) {
+    return 100;
+  }
+  return Math.min(Math.max(Math.ceil((bytesAfterChunk / totalBytes) * 100), 1), 99);
+};
 
 type ProtocolV2FirmwareUpdateStatusTarget = {
-  target_id: number;
-  status: number;
+  target_id: number | string;
+  status?: number | string;
+  payload_version?: number;
+  path?: string;
+};
+
+type ProtocolV2FirmwareUpdateStartResponse = TypedResponseMessage<'Success'>;
+
+type ProtocolV2TargetBinary = { fileName: string; binary: ArrayBuffer; targetId: number };
+type ProtocolV2InstallItem = ProtocolV2TargetBinary & {
+  kind: ProtocolV2RemoteComponentTarget['kind'];
+};
+/** RESC bundle okpkg written independently to devicePath through FileWrite. */
+type ProtocolV2ResourceBundleBinary = {
+  name: string;
+  binary: ArrayBuffer;
+  devicePath: string;
+  /** Download URL for remote-config mode; omitted in manual mode. */
+  url?: string;
+  version?: IVersionArray;
+  payloadHash?: string;
+  headerHash?: string;
 };
 
-type ProtocolV2FirmwareUpdateStartResponse =
-  | TypedResponseMessage<'Success'>
-  | TypedResponseMessage<'DevFirmwareUpdateStatus'>
-  | undefined;
+type ProtocolV2RemoteComponentBinary = ProtocolV2RemoteComponentTarget & {
+  binary: ArrayBuffer;
+};
+
+type ProtocolV2RemoteComponentTarget = {
+  fileName: string;
+  targetId: number;
+  kind: 'bootloader' | 'firmware';
+};
+
+type ProtocolV2InstallSource = {
+  fileName: string;
+  source: FirmwareByteSource;
+  targetId: number;
+  kind: ProtocolV2RemoteComponentTarget['kind'];
+};
+
+type ProtocolV2ResourceBundleSource = {
+  name: string;
+  source: FirmwareByteSource;
+  devicePath: string;
+  version?: IVersionArray;
+  payloadHash?: string;
+  headerHash?: string;
+};
+
+type ProtocolV2ExecutionPhaseKind =
+  | 'resource-sync'
+  | 'bootloader-install'
+  | 'bootloader-verify'
+  | 'component-install'
+  | 'final-verify';
+
+type ProtocolV2ExecutionPhase = {
+  kind: ProtocolV2ExecutionPhaseKind;
+  installSources: ProtocolV2InstallSource[];
+  resourceSources: ProtocolV2ResourceBundleSource[];
+};
+
+type ProtocolV2OkppHeader = {
+  type: string;
+  version: IVersionArray;
+  payloadHash: string;
+  headerHash: string;
+};
+
+const PROTOCOL_V2_REMOTE_COMPONENT_TARGETS: Readonly<
+  Record<string, ProtocolV2RemoteComponentTarget>
+> = {
+  BOOTLOADER: {
+    fileName: 'bootloader.bin',
+    targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER,
+    kind: 'bootloader',
+  },
+  APPLICATION_P1: {
+    fileName: 'application_p1.bin',
+    targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1,
+    kind: 'firmware',
+  },
+  APPLICATION_P2: {
+    fileName: 'application_p2.bin',
+    targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2,
+    kind: 'firmware',
+  },
+  COPROCESSOR: {
+    fileName: 'coprocessor.bin',
+    targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR,
+    kind: 'firmware',
+  },
+  SE01: {
+    fileName: 'se01.bin',
+    targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01,
+    kind: 'firmware',
+  },
+  SE02: {
+    fileName: 'se02.bin',
+    targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02,
+    kind: 'firmware',
+  },
+  SE03: {
+    fileName: 'se03.bin',
+    targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03,
+    kind: 'firmware',
+  },
+  SE04: {
+    fileName: 'se04.bin',
+    targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04,
+    kind: 'firmware',
+  },
+};
+
+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 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])
+);
+const PROTOCOL_V2_TARGET_STATUS_BY_DECODED_NAME = new Map<string, number>([
+  ['FW_MGMT_UPDATER_TASK_STATUS_PENDING', PROTOCOL_V2_TARGET_STATUS_PENDING],
+  ['FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS', PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS],
+  ['FW_MGMT_UPDATER_TASK_STATUS_FINISHED', PROTOCOL_V2_TARGET_STATUS_FINISHED],
+  ['FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_NOT_FOUND', 3],
+  ['FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_READ', 4],
+  ['FW_MGMT_UPDATER_TASK_STATUS_FAILED_FILE_WRITE', 5],
+  ['FW_MGMT_UPDATER_TASK_STATUS_FAILED_VERIFY', 6],
+  ['FW_MGMT_UPDATER_TASK_STATUS_FAILED_INSTALL', 7],
+  ['FW_MGMT_UPDATER_TASK_STATUS_FAILED_ABORT', 8],
+  ['FW_MGMT_UPDATER_TASK_STATUS_FAILED_BUSY', 9],
+  ['FW_MGMT_UPDATER_TASK_STATUS_FAILED_ENTRY_OUT_OF_BOUNDS', 10],
+]);
 
 const isProtocolV2ReconnectProbeError = (error: unknown) => {
   const message = getProtocolV2UnknownErrorText(error).toLowerCase();
@@ -68,43 +253,211 @@ const isProtocolV2ReconnectProbeError = (error: unknown) => {
   );
 };
 
-const isProtocolV2PollingTransientError = (error: unknown) => {
+const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
   const message = getProtocolV2UnknownErrorText(error).toLowerCase();
   return (
-    isProtocolV2DeviceDisconnectedError(error) ||
-    isProtocolV2ReconnectProbeError(error) ||
-    (message.includes('response timeout') && message.includes('devicegetfirmwareupdatestatus')) ||
-    message.includes('device not found') ||
-    message.includes('transportnotfound')
+    message.includes('handler not registered') ||
+    message.includes('message handler not found') ||
+    message.includes('unsupported message')
+  );
+};
+
+const isProtocolV2TargetStatusFinished = (status: ProtocolV2FirmwareUpdateStatusTarget['status']) =>
+  normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_FINISHED;
+
+const isProtocolV2TargetStatusInProgress = (
+  status: ProtocolV2FirmwareUpdateStatusTarget['status']
+) =>
+  normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_PENDING ||
+  normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS;
+
+const isProtocolV2TargetStatusFailed = (status: ProtocolV2FirmwareUpdateStatusTarget['status']) => {
+  const normalizedStatus = normalizeProtocolV2TargetStatus(status);
+  return (
+    typeof normalizedStatus === 'number' && normalizedStatus >= PROTOCOL_V2_TARGET_STATUS_FAILED_MIN
   );
 };
 
+const normalizeProtocolV2TargetId = (targetId: number | string) => {
+  if (typeof targetId === 'number') {
+    return targetId;
+  }
+  return PROTOCOL_V2_TARGET_ID_BY_DECODED_NAME.get(targetId);
+};
+
+const normalizeProtocolV2TargetStatus = (
+  status: ProtocolV2FirmwareUpdateStatusTarget['status']
+) => {
+  if (typeof status === 'number') {
+    return status;
+  }
+  if (typeof status === 'string') {
+    return PROTOCOL_V2_TARGET_STATUS_BY_DECODED_NAME.get(status);
+  }
+  return undefined;
+};
+
+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 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'))
+    .join('');
+
+const hexToProtocolV2Bytes = (hex: string) => {
+  const normalized = hex.replace(/^0x/i, '');
+  if (!normalized || normalized.length % 2 !== 0 || /[^0-9a-f]/i.test(normalized)) {
+    return new Uint8Array(0);
+  }
+  const bytes = new Uint8Array(normalized.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Number.parseInt(normalized.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+};
+
+const toProtocolV2Bytes = (value: unknown): Uint8Array => {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (typeof value === 'string') return hexToProtocolV2Bytes(value);
+  return new Uint8Array(0);
+};
+
+const toProtocolV2FiniteNumber = (value: unknown) => {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string') {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : undefined;
+  }
+  if (value && typeof value === 'object') {
+    const longLike = value as { toNumber?: () => number };
+    if (typeof longLike.toNumber === 'function') {
+      const numeric = longLike.toNumber();
+      return Number.isFinite(numeric) ? numeric : undefined;
+    }
+  }
+  return undefined;
+};
+
+const readProtocolV2Ascii = (bytes: Uint8Array, offset: number, length: number) =>
+  Array.from(bytes.slice(offset, offset + length))
+    .map(byte => String.fromCharCode(byte))
+    .join('');
+
+const parseProtocolV2OkppHeader = (bytes: Uint8Array): ProtocolV2OkppHeader | null => {
+  if (bytes.byteLength < PROTOCOL_V2_OKPP_HEADER_SIZE) return null;
+  if (readProtocolV2Ascii(bytes, 0, 4) !== 'OKPP') return null;
+
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const headerLen = view.getUint32(0x0c, true);
+  if (headerLen !== PROTOCOL_V2_OKPP_HEADER_SIZE) return null;
+
+  const packedVersion = view.getUint32(0x10, true);
+  return {
+    type: readProtocolV2Ascii(bytes, 0x08, 4),
+    version: [
+      Math.floor(packedVersion / 0x10000) % 0x100,
+      Math.floor(packedVersion / 0x100) % 0x100,
+      packedVersion % 0x100,
+    ],
+    payloadHash: bytesToHex(
+      bytes.slice(
+        PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET,
+        PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET + PROTOCOL_V2_OKPP_HASH_SIZE
+      )
+    ),
+    headerHash: bytesToHex(
+      bytes.slice(
+        PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET,
+        PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET + PROTOCOL_V2_OKPP_HASH_SIZE
+      )
+    ),
+  };
+};
+
+export const assertProtocolV2ReconnectIdentity = (
+  expectedSerialNumber?: string,
+  actualSerialNumber?: string
+) => {
+  if (!expectedSerialNumber || !actualSerialNumber) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.DeviceNotFound,
+      'Protocol V2 reconnect physical identity is unavailable'
+    );
+  }
+  if (actualSerialNumber !== expectedSerialNumber) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.DeviceNotFound,
+      `Protocol V2 reconnect physical identity mismatch: expected ${expectedSerialNumber}, received ${actualSerialNumber}`
+    );
+  }
+};
+
 /**
  * FirmwareUpdateV4 is the complete Protocol V2 firmware update flow.
  *
  * It intentionally does not fall back to FirmwareUpdateV3/V1 behavior:
  * - upload uses FilesystemFileWrite
- * - install uses DevFirmwareUpdate
- * - completion reboots to normal, then polls Ping
+ * - install uses DeviceFirmwareUpdateRequest
+ * - completion waits for target status to finish, reboots to normal, then polls DeviceInfo
  */
 export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareUpdateV4Params> {
+  private protocolV2ExpectedSerialNumber?: string;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  private protocolV2PreparedSources: FirmwareByteSource[] = [];
+
+  private protocolV2ExecutionInLoader = false;
+
+  private protocolV2CompletedTargetVersions = new Map<number, number>();
+
+  private protocolV2LatestFinalFeatures?: Features;
+
+  private protocolV2FinalStatusVerified = false;
+
   init() {
     this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
     this.requireDeviceMode = [];
+    this.unlockPolicy = 'unlock-before-run';
     this.useDevicePassphraseState = false;
     this.skipForceUpdateCheck = true;
 
     const { payload } = this;
 
+    if (typeof payload.retryCount !== 'number') {
+      payload.retryCount = PROTOCOL_V2_CONNECT_RETRY_COUNT;
+    }
+    if (typeof payload.pollIntervalTime !== 'number') {
+      payload.pollIntervalTime = PROTOCOL_V2_CONNECT_POLL_INTERVAL;
+    }
+    if (typeof payload.timeout !== 'number') {
+      payload.timeout = PROTOCOL_V2_CONNECT_SINGLE_TIMEOUT;
+    }
+    if (typeof payload.protocolV2DeviceInfoTimeoutMs !== 'number') {
+      payload.protocolV2DeviceInfoTimeoutMs = PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT;
+    }
+
     validateParams(payload, [
-      { name: 'bleVersion', type: 'array' },
-      { name: 'bleBinary', type: 'buffer' },
       { name: 'chunkSize', type: 'number' },
-      { name: 'firmwareVersion', type: 'array' },
-      { name: 'firmwareBinary', type: 'buffer' },
-      { name: 'resourceBinary', type: 'buffer' },
       { name: 'forcedUpdateRes', type: 'boolean' },
-      { name: 'bootloaderVersion', type: 'array' },
       { name: 'bootloaderBinary', type: 'buffer' },
       { name: 'romloaderBinary', type: 'buffer' },
       { name: 'applicationP1Binary', type: 'buffer' },
@@ -115,16 +468,66 @@ 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: 'expectedDeviceId', type: 'string' },
+      { name: 'resourceBundleFiles', type: 'array', allowEmpty: true },
     ]);
+    if (
+      payload.expectedDeviceId !== undefined &&
+      (payload.expectedDeviceId.length === 0 || payload.expectedDeviceId.length > 160)
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Protocol V2 expected device identity is invalid'
+      );
+    }
+    const hostBinding =
+      payload.preparedPlan || payload.componentArtifacts || payload.resourceBundleArtifacts
+        ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
+        : undefined;
+    if (hostBinding) {
+      assertFirmwareUpdatePreparedPlanBinding({
+        preparedPlan: payload.preparedPlan,
+        executor: 'v4',
+        platform: payload.platform,
+        scopeTargets: [
+          'boot',
+          'app_v1',
+          'app_v2',
+          'coprocessor',
+          'resource',
+          'se01',
+          'se02',
+          'se03',
+          'se04',
+        ],
+        bindings: [
+          ...Object.entries(payload.componentArtifacts ?? {}).flatMap(([target, artifact]) =>
+            artifact
+              ? [
+                  {
+                    target: target as Exclude<FirmwareUpdateV4Target, 'resource'>,
+                    artifact,
+                  },
+                ]
+              : []
+          ),
+          ...(payload.resourceBundleArtifacts ?? []).map(
+            (entry: { name: string; artifact: FirmwareArtifactReference }) => ({
+              target: 'resource' as const,
+              logicalName: entry.name,
+              artifact: entry.artifact,
+            })
+          ),
+        ],
+      });
+    }
 
     this.params = {
-      bleBinary: payload.bleBinary,
+      preparedPlan: payload.preparedPlan,
       chunkSize: payload.chunkSize,
-      firmwareBinary: payload.firmwareBinary,
       forcedUpdateRes: payload.forcedUpdateRes,
-      bleVersion: payload.bleVersion,
-      bootloaderVersion: payload.bootloaderVersion,
       bootloaderBinary: payload.bootloaderBinary,
       romloaderBinary: payload.romloaderBinary,
       applicationP1Binary: payload.applicationP1Binary,
@@ -134,20 +537,29 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       se02Binary: payload.se02Binary,
       se03Binary: payload.se03Binary,
       se04Binary: payload.se04Binary,
-      firmwareVersion: payload.firmwareVersion,
-      resourceBinary: payload.resourceBinary,
+      resourceBundleFiles: payload.resourceBundleFiles,
       firmwareType: payload.firmwareType,
+      targetsToUpdate: payload.targetsToUpdate,
+      expectedTargetVersions: payload.expectedTargetVersions,
       platform: payload.platform,
+      expectedDeviceId: payload.expectedDeviceId,
+      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
+      componentArtifacts: payload.componentArtifacts,
+      resourceBundleArtifacts: payload.resourceBundleArtifacts,
     };
   }
 
-  private getProtocolV2FirmwareChunkSize() {
+  private getProtocolV2FirmwareChunkSize(direction: 'read' | 'write' = 'write') {
     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 =
+        direction === 'read'
+          ? PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE
+          : PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+    }
     if (!Number.isFinite(payloadChunkSize) || payloadChunkSize <= 0) {
       return maxChunkSize;
     }
@@ -158,107 +570,716 @@ 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;
+    this.validateExpectedTargetVersions();
+
+    if (
+      (this.params.componentArtifacts && Object.keys(this.params.componentArtifacts).length > 0) ||
+      this.params.resourceBundleArtifacts?.length
+    ) {
+      return this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
+    }
 
-    let resourceBinary: ArrayBuffer | null = null;
-    let fwBinaryMap: { fileName: string; binary: ArrayBuffer; targetId?: number }[] = [];
+    let fwBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
+    let installItems: ProtocolV2InstallItem[] | undefined;
+    let resourceBundles: ProtocolV2ResourceBundleBinary[] | undefined;
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
-      resourceBinary = await this.prepareResourceBinary(firmwareType, deviceFeatures);
-      fwBinaryMap = await this.prepareFirmwareAndBleBinary(firmwareType, deviceFeatures);
-      bootloaderBinary = await this.prepareBootloaderBinary(firmwareType, deviceFeatures);
-      // 按 DevFirmwareTargetType 拆分的目标二进制（显式 target_id，不走文件名推断）
-      fwBinaryMap.push(...this.collectExplicitTargetBinaries());
+      fwBinaryMap = this.collectExplicitTargetBinaries();
+      bootloaderBinary = this.prepareBootloaderBinary();
+      if (!this.hasExplicitProtocolV2Payload(fwBinaryMap)) {
+        if (
+          this.params.artifactReader ||
+          DataManager.getSettings('firmwareManifestMode') === 'external-only'
+        ) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            'Protocol V2 firmware artifacts must be prepared by the external firmware host',
+            {
+              firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+            }
+          );
+        }
+        const remoteBinaries = await this.prepareRemoteProtocolV2Binaries(
+          firmwareType,
+          deviceFeatures
+        );
+        bootloaderBinary = remoteBinaries.bootloaderBinary;
+        fwBinaryMap = remoteBinaries.fwBinaryMap;
+        installItems = remoteBinaries.installItems;
+      }
+      const resourceDescriptors = this.prepareProtocolV2ResourceBundles(
+        firmwareType,
+        deviceFeatures
+      );
+      resourceBundles = resourceDescriptors?.length
+        ? await this.materializeProtocolV2ResourceBundles(resourceDescriptors)
+        : undefined;
       this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
     } catch (err) {
-      throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
+      throw normalizeFirmwarePreparationError(err);
     }
 
-    if (!resourceBinary && !bootloaderBinary && fwBinaryMap.length === 0) {
+    if (!bootloaderBinary && fwBinaryMap.length === 0 && !resourceBundles?.length) {
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareUpdateDownloadFailed,
         'No firmware to update'
       );
     }
 
-    // TODO: 当前 firmware-pro2 子模块的 reboot/bootloader 流程还未稳定，先暂停自动进 bootloader。
-    // await this.enterProtocolV2BootloaderMode();
-
-    await this.executeProtocolV2Update({
-      resourceBinary,
+    return this.executeProtocolV2Update({
       fwBinaryMap,
       bootloaderBinary,
+      ...(installItems ? { installItems } : undefined),
+      ...(resourceBundles?.length ? { resourceBundles } : undefined),
     });
+  }
+
+  private async openProtocolV2PreparedSource(artifact: FirmwareArtifactReference) {
+    const source = await openFirmwareByteSource({
+      artifact,
+      reader: this.params.artifactReader,
+    });
+    if (!source) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Firmware artifact ${artifact.artifactRef} is not prepared`,
+        {
+          firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+        }
+      );
+    }
+    this.protocolV2PreparedSources.push(source);
+    return source;
+  }
 
-    await this.exitProtocolV2BootloaderToNormal();
+  private async openProtocolV2MemorySource(binary: ArrayBuffer) {
+    const source = await openFirmwareByteSource({ binary });
+    if (!source) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 firmware binary is empty'
+      );
+    }
+    this.protocolV2PreparedSources.push(source);
+    return source;
+  }
 
-    const versions = await this.waitForProtocolV2FinalFeatures();
-    this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
-    DevicePool.resetState();
+  private async closeProtocolV2PreparedSources() {
+    const sources = this.protocolV2PreparedSources.splice(0);
+    await Promise.all(sources.map(source => source.close().catch(() => undefined)));
+  }
 
-    return versions;
+  private async prepareProtocolV2InstallSources(
+    firmwareType: EFirmwareType,
+    features: Features
+  ): Promise<ProtocolV2InstallSource[]> {
+    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+    if (!release) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 firmware release is unavailable'
+      );
+    }
+    const componentArtifacts = this.params.componentArtifacts ?? {};
+    const requestedTargets = new Set(
+      this.params.targetsToUpdate ?? (Object.keys(componentArtifacts) as FirmwareUpdateV4Target[])
+    );
+    const installSources: ProtocolV2InstallSource[] = [];
+    const preparedTargets = new Set<FirmwareUpdateV4Target>();
+
+    for (const [key, component] of this.getRemoteComponentEntries(release)) {
+      const target = this.getRemoteComponentTarget(key, component);
+      const updateTarget = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId);
+      if (updateTarget && updateTarget !== 'resource' && requestedTargets.has(updateTarget)) {
+        const artifact = componentArtifacts[updateTarget];
+        if (!artifact) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            `Protocol V2 ${updateTarget} artifact is not prepared`,
+            {
+              firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+              artifactName: updateTarget,
+            }
+          );
+        }
+        installSources.push({
+          ...target,
+          source: await this.openProtocolV2PreparedSource(artifact),
+        });
+        preparedTargets.add(updateTarget);
+      }
+    }
+
+    const unknownTarget = Array.from(requestedTargets).find(
+      target => target !== 'resource' && !preparedTargets.has(target)
+    );
+    if (unknownTarget) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 release does not contain requested target ${unknownTarget}`
+      );
+    }
+    return installSources;
+  }
+
+  private async prepareProtocolV2ResourceSources(
+    firmwareType: EFirmwareType,
+    features: Features
+  ): Promise<ProtocolV2ResourceBundleSource[]> {
+    const preparedArtifacts = this.params.resourceBundleArtifacts ?? [];
+    const resourceRequested =
+      this.params.targetsToUpdate?.includes('resource') || preparedArtifacts.length > 0;
+    if (!resourceRequested) {
+      return [];
+    }
+    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+    const descriptors = release?.resourceBundles ?? [];
+    const artifactByName = new Map(
+      preparedArtifacts.map(item => [item.name, item.artifact] as const)
+    );
+    const sources: ProtocolV2ResourceBundleSource[] = [];
+    for (const descriptor of descriptors) {
+      const artifact = artifactByName.get(descriptor.name);
+      if (!artifact) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Protocol V2 resource bundle ${descriptor.name} is not prepared`,
+          {
+            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+            artifactName: descriptor.name,
+          }
+        );
+      }
+      const devicePath = validateProtocolV2FilesystemPath(
+        descriptor.devicePath,
+        'resourceBundles[].devicePath'
+      );
+      sources.push({
+        name: descriptor.name,
+        source: await this.openProtocolV2PreparedSource(artifact),
+        devicePath,
+        version: descriptor.version,
+        payloadHash: descriptor.payloadHash,
+        headerHash: descriptor.headerHash,
+      });
+      artifactByName.delete(descriptor.name);
+    }
+    if (artifactByName.size > 0) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 release does not contain resource bundle ${artifactByName.keys().next().value}`
+      );
+    }
+    return sources;
+  }
+
+  private async runProtocolV2PreparedArtifacts(features: Features, firmwareType: EFirmwareType) {
+    try {
+      this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
+      const installSources = await this.prepareProtocolV2InstallSources(firmwareType, features);
+      const resourceSources = await this.prepareProtocolV2ResourceSources(firmwareType, features);
+      if (installSources.length === 0 && resourceSources.length === 0) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.FirmwareUpdateDownloadFailed,
+          'No firmware to update'
+        );
+      }
+      this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+
+      return await this.executeProtocolV2SourceUpdate({
+        installSources,
+        resourceSources,
+      });
+    } finally {
+      await this.closeProtocolV2PreparedSources();
+    }
+  }
+
+  private validateExpectedTargetVersions() {
+    const expected = this.params.expectedTargetVersions;
+    if (expected === undefined) return;
+    if (typeof expected !== 'object' || expected === null || Array.isArray(expected)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 expected target versions are invalid'
+      );
+    }
+    for (const [target, version] of Object.entries(expected)) {
+      if (
+        !Array.from(PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.values()).includes(
+          target as FirmwareUpdateV4Target
+        ) ||
+        typeof version !== 'string' ||
+        !/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/u.test(version) ||
+        version.length > 64
+      ) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Protocol V2 expected target version is invalid'
+        );
+      }
+    }
+  }
+
+  private getExpectedProtocolV2TargetVersion(targetId: number) {
+    const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(targetId);
+    const version = target ? this.params?.expectedTargetVersions?.[target] : undefined;
+    if (!version) return undefined;
+    const parts = version.split(/[+-]/u, 1)[0].split('.').map(Number);
+    if (
+      parts.length !== 3 ||
+      parts.some(part => !Number.isSafeInteger(part) || part < 0 || part > 0xff)
+    ) {
+      return undefined;
+    }
+    return parts[0] * 0x10000 + parts[1] * 0x100 + parts[2];
+  }
+
+  private assertExpectedProtocolV2Versions(targets?: readonly FirmwareUpdateV4Target[]) {
+    const expected = this.params?.expectedTargetVersions;
+    if (!expected) return;
+    const features = this.protocolV2LatestFinalFeatures;
+    const requestedTargets = this.getProtocolV2RequestedTargets();
+    const applicationTargets = requestedTargets.filter(
+      target => target === 'app_v1' || target === 'app_v2'
+    );
+    const visibleVersions: Partial<Record<FirmwareUpdateV4Target, string>> = {
+      boot: features ? getDeviceBootloaderVersion(features).join('.') : undefined,
+      coprocessor: features ? getDeviceBLEFirmwareVersion(features).join('.') : undefined,
+      se01: features?.se01Version ?? undefined,
+      se02: features?.se02Version ?? undefined,
+      se03: features?.se03Version ?? undefined,
+      se04: features?.se04Version ?? undefined,
+    };
+    if (features && applicationTargets.length === 1) {
+      visibleVersions[applicationTargets[0]] = getDeviceFirmwareVersion(features).join('.');
+    }
+    const expectedEntries = (
+      Object.entries(expected) as Array<[FirmwareUpdateV4Target, string]>
+    ).filter(([target]) => !targets || targets.includes(target));
+    for (const [target, expectedVersion] of expectedEntries) {
+      const targetId = Array.from(PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.entries()).find(
+        ([, mappedTarget]) => mappedTarget === target
+      )?.[0];
+      const statusVersion =
+        targetId === undefined ? undefined : this.protocolV2CompletedTargetVersions.get(targetId);
+      const observedVersion =
+        statusVersion === undefined
+          ? visibleVersions[target]
+          : `${Math.floor(statusVersion / 0x10000) % 0x100}.${
+              Math.floor(statusVersion / 0x100) % 0x100
+            }.${statusVersion % 0x100}`;
+      if (!observedVersion) {
+        if (this.protocolV2FinalStatusVerified) {
+          Log.warn(
+            `Protocol V2 target ${target} has no observable final version; completed target status is authoritative`
+          );
+        } else {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.FirmwareVerificationFailed,
+            `Protocol V2 target ${target} has no observable final version after status fallback`
+          );
+        }
+      } else if (observedVersion !== expectedVersion) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.FirmwareVerificationFailed,
+          `Protocol V2 target ${target} reached ${observedVersion}, expected ${expectedVersion}`
+        );
+      }
+    }
+  }
+
+  private getProtocolV2RequestedTargets(): FirmwareUpdateV4Target[] {
+    if (this.params.targetsToUpdate?.length) {
+      return [...new Set(this.params.targetsToUpdate)];
+    }
+    const targets = new Set<FirmwareUpdateV4Target>();
+    Object.keys(this.params.componentArtifacts ?? {}).forEach(target =>
+      targets.add(target as FirmwareUpdateV4Target)
+    );
+    if (this.params.resourceBundleArtifacts?.length || this.params.resourceBundleFiles?.length) {
+      targets.add('resource');
+    }
+    if (this.params.bootloaderBinary) targets.add('boot');
+    if (this.params.applicationP1Binary) targets.add('app_v1');
+    if (this.params.applicationP2Binary) targets.add('app_v2');
+    if (this.params.coprocessorBinary) targets.add('coprocessor');
+    if (this.params.se01Binary) targets.add('se01');
+    if (this.params.se02Binary) targets.add('se02');
+    if (this.params.se03Binary) targets.add('se03');
+    if (this.params.se04Binary) targets.add('se04');
+    return Array.from(targets);
   }
 
   private async getProtocolV2DeviceFeatures(): Promise<Features> {
+    if (this.device.features) {
+      return this.device.features;
+    }
     if (typeof this.device.getFeatures === 'function') {
       const features = await this.device.getFeatures();
       if (features) return features;
     }
-    if (this.device.features) {
-      return this.device.features;
-    }
     throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device features not available');
   }
 
-  private async prepareResourceBinary(firmwareType: EFirmwareType, features: Features) {
-    if (this.params.resourceBinary) {
-      return this.params.resourceBinary;
+  private getProtocolV2SerialNumber(deviceInfo: ProtocolV2DeviceInfo) {
+    const serialNumber = deviceInfo.hw?.serial_no?.trim();
+    return serialNumber || undefined;
+  }
+
+  private assertProtocolV2DeviceInfoIdentity(deviceInfo: ProtocolV2DeviceInfo) {
+    assertProtocolV2ReconnectIdentity(
+      this.protocolV2ExpectedSerialNumber,
+      this.getProtocolV2SerialNumber(deviceInfo)
+    );
+  }
+
+  private async requestProtocolV2PhysicalIdentity() {
+    return requestProtocolV2DeviceInfo({
+      commands: this.device.getCommands(),
+      timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+    });
+  }
+
+  private async captureProtocolV2PhysicalIdentity() {
+    const deviceInfo = await this.requestProtocolV2PhysicalIdentity();
+    const serialNumber = this.getProtocolV2SerialNumber(deviceInfo);
+    if (this.params?.preparedPlan) {
+      assertFirmwareUpdatePreparedPlanDeviceIdentity({
+        preparedPlan: this.params.preparedPlan,
+        deviceIdentity: serialNumber,
+      });
+    } else if (this.params?.expectedDeviceId) {
+      assertProtocolV2ReconnectIdentity(this.params?.expectedDeviceId, serialNumber);
+    } else {
+      assertProtocolV2ReconnectIdentity(serialNumber, serialNumber);
+    }
+    this.protocolV2ExpectedSerialNumber = serialNumber;
+  }
+
+  private async verifyProtocolV2ReconnectIdentity() {
+    const deviceInfo = await this.requestProtocolV2PhysicalIdentity();
+    this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
+    return deviceInfo;
+  }
+
+  private prepareBootloaderBinary(): ArrayBuffer | null {
+    return this.params.bootloaderBinary ?? null;
+  }
+
+  private hasExplicitProtocolV2Payload(fwBinaryMap: ProtocolV2TargetBinary[]) {
+    return (
+      !!this.params.resourceBundleFiles?.length ||
+      !!this.params.bootloaderBinary ||
+      fwBinaryMap.length > 0
+    );
+  }
+
+  private buildProtocolV2InstallItems({
+    bootloaderBinary,
+    fwBinaryMap,
+  }: {
+    bootloaderBinary: ArrayBuffer | null;
+    fwBinaryMap: ProtocolV2TargetBinary[];
+  }): ProtocolV2InstallItem[] {
+    const installItems: ProtocolV2InstallItem[] = [];
+
+    if (bootloaderBinary) {
+      installItems.push({
+        fileName: 'bootloader.bin',
+        binary: bootloaderBinary,
+        targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER,
+        kind: 'bootloader',
+      });
+    }
+
+    installItems.push(...fwBinaryMap.map(item => ({ ...item, kind: 'firmware' as const })));
+    return installItems;
+  }
+
+  private getRemoteComponentEntries(release: IFirmwareReleaseInfo) {
+    const { components } = release;
+    if (!components) return [];
+
+    const orderedKeys = [
+      ...(release.installOrder ?? []),
+      ...Object.keys(components).filter(key => !release.installOrder?.includes(key)),
+    ];
+
+    return orderedKeys
+      .map(key => {
+        const component = components[key];
+        return component ? ([key, component] as const) : undefined;
+      })
+      .filter((entry): entry is readonly [string, IProtocolV2FirmwareComponent] => !!entry);
+  }
+
+  private getRemoteComponentTarget(key: string, component: IProtocolV2FirmwareComponent) {
+    const targetName = component.target?.toUpperCase();
+    if (targetName === 'ROMLOADER') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        PROTOCOL_V2_ROMLOADER_UNSUPPORTED_MESSAGE
+      );
+    }
+    const target = PROTOCOL_V2_REMOTE_COMPONENT_TARGETS[targetName];
+    if (!target) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Unsupported Protocol V2 firmware component target: ${key}/${component.target}`
+      );
+    }
+    return target;
+  }
+
+  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('read');
+    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 resourceUrl = DataManager.getSysResourcesLatestRelease({
-      features,
-      forcedUpdateRes: this.params.forcedUpdateRes,
-      firmwareType,
+
+    const headerBytes = new Uint8Array(offset);
+    let cursor = 0;
+    chunks.forEach(chunk => {
+      headerBytes.set(chunk, cursor);
+      cursor += chunk.byteLength;
     });
+    return parseProtocolV2OkppHeader(headerBytes);
+  }
+
+  private async downloadRemoteProtocolV2Component(
+    key: string,
+    component: IProtocolV2FirmwareComponent
+  ): Promise<ProtocolV2RemoteComponentBinary> {
+    const target = this.getRemoteComponentTarget(key, component);
+    if (!component.url) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Missing Protocol V2 firmware component url: ${key}/${component.target}`
+      );
+    }
+
+    const { binary } = await getSysResourceBinary(component.url);
+    return {
+      ...target,
+      binary,
+    };
+  }
+
+  private async prepareRemoteProtocolV2Binaries(firmwareType: EFirmwareType, features: Features) {
+    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+
+    let bootloaderBinary: ArrayBuffer | null = null;
+    const fwBinaryMap: ProtocolV2TargetBinary[] = [];
+    const installItems: ProtocolV2InstallItem[] = [];
+
+    if (!release) {
+      return {
+        bootloaderBinary,
+        fwBinaryMap,
+        installItems,
+      };
+    }
+
+    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 updateTarget = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId);
+      const shouldInstall = updateTarget ? targetsToUpdate.has(updateTarget) : false;
+      if (shouldInstall) {
+        const remoteBinary = await this.downloadRemoteProtocolV2Component(key, component);
+        if (remoteBinary.kind === 'bootloader') {
+          bootloaderBinary = remoteBinary.binary;
+          installItems.push({
+            fileName: remoteBinary.fileName,
+            binary: remoteBinary.binary,
+            targetId: remoteBinary.targetId,
+            kind: remoteBinary.kind,
+          });
+        } else {
+          const binaryEntry = {
+            fileName: remoteBinary.fileName,
+            binary: remoteBinary.binary,
+            targetId: remoteBinary.targetId,
+          };
+          fwBinaryMap.push(binaryEntry);
+          installItems.push({ ...binaryEntry, kind: remoteBinary.kind });
+        }
+      }
+    }
+
+    return {
+      bootloaderBinary,
+      fwBinaryMap,
+      installItems,
+    };
+  }
+
+  // ============================================================
+  // Incremental RESC bundle sync through FileRead and FilesystemFileWrite
+  // ============================================================
+
+  /**
+   * Prepare the RESC bundle list.
+   *
+   * Two modes, matching FirmwareUpdateV3 binary-versus-version behavior:
+   * - resourceBundleFiles supplied: use binaries directly without version checks.
+   * - Otherwise load release.resourceBundles from remote config.json; the binaries
+   *   are prefetched before reboot and synchronization skips matching device headers.
+   */
+  private prepareProtocolV2ResourceBundles(
+    firmwareType: EFirmwareType,
+    features: Features
+  ): ProtocolV2ResourceBundleBinary[] | undefined {
+    // Manual binaries are installed directly without comparison.
+    if (this.params.resourceBundleFiles?.length) {
+      return this.params.resourceBundleFiles.map((file, index) => {
+        const devicePath = validateProtocolV2FilesystemPath(
+          file.devicePath,
+          `resourceBundleFiles[${index}].devicePath`
+        );
+        return {
+          name: devicePath.split('/').pop() ?? devicePath,
+          binary: file.binary,
+          devicePath,
+        };
+      });
+    }
 
-    if (resourceUrl) {
-      const resource = (await getSysResourceBinary(resourceUrl)).binary;
-      return resource;
+    if (!this.params.targetsToUpdate?.includes('resource')) {
+      return undefined;
     }
-    Log.warn('No resource url found');
-    return null;
+
+    // Remote-config bundles are downloaded and compared later.
+    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+    if (!release?.resourceBundles?.length) return undefined;
+
+    return release.resourceBundles.map((bundle, index) => ({
+      name: bundle.name,
+      binary: new ArrayBuffer(0),
+      devicePath: validateProtocolV2FilesystemPath(
+        bundle.devicePath,
+        `resourceBundles[${index}].devicePath`
+      ),
+      url: bundle.url,
+      version: bundle.version,
+      payloadHash: bundle.payloadHash,
+      headerHash: bundle.headerHash,
+    })) as ProtocolV2ResourceBundleBinary[];
   }
 
-  private async prepareBootloaderBinary(
-    firmwareType: EFirmwareType,
-    features: Features
-  ): Promise<ArrayBuffer | null> {
-    if (this.params.bootloaderBinary) {
-      return this.params.bootloaderBinary;
+  private async materializeProtocolV2ResourceBundles(
+    bundles: ProtocolV2ResourceBundleBinary[]
+  ): Promise<ProtocolV2ResourceBundleBinary[]> {
+    for (const bundle of bundles) {
+      if (bundle.binary.byteLength === 0 && bundle.url) {
+        if (
+          this.params.artifactReader ||
+          DataManager.getSettings('firmwareManifestMode') === 'external-only'
+        ) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            `Firmware resource bundle ${bundle.name} is not prepared`,
+            {
+              firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+              artifactName: bundle.name,
+            }
+          );
+        }
+        Log.log(`[FirmwareUpdateV4] preloading RESC bundle ${bundle.name}`);
+        bundle.binary = (await getSysResourceBinary(bundle.url)).binary;
+      }
+      if (bundle.binary.byteLength === 0) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.FirmwareUpdateDownloadFailed,
+          `Protocol V2 RESC bundle is empty: ${bundle.name}`
+        );
+      }
     }
+    return bundles;
+  }
+
+  /**
+   * Compare the existing okpkg OKPP header in remote-config mode.
+   */
+  private async isProtocolV2ResourceBundleUpToDate(
+    bundle: Pick<
+      ProtocolV2ResourceBundleBinary,
+      'name' | 'devicePath' | 'version' | 'payloadHash' | 'headerHash'
+    >
+  ): Promise<boolean> {
+    if (this.params?.forcedUpdateRes) return false;
+    if (!bundle.version && !bundle.payloadHash) return false;
+
+    try {
+      const header = await this.readProtocolV2DeviceFileHeader(bundle.devicePath);
+      if (!header) return false;
 
-    if (this.params.bootloaderVersion) {
-      const bootResourceUrl = DataManager.getBootloaderResource(features, firmwareType);
-      if (bootResourceUrl) {
-        const bootBinary = (await getSysResourceBinary(bootResourceUrl)).binary;
-        return bootBinary;
+      if (bundle.version) {
+        const cmp = compareProtocolV2Versions(header.version, bundle.version);
+        if (cmp === undefined || cmp !== 0) return false;
+      }
+      if (bundle.payloadHash) {
+        const expected = normalizeProtocolV2Hex(bundle.payloadHash);
+        if (expected && header.payloadHash !== expected) return false;
       }
+      if (bundle.headerHash) {
+        const expected = normalizeProtocolV2Hex(bundle.headerHash);
+        if (expected && header.headerHash !== expected) return false;
+      }
+      return true;
+    } catch (error) {
+      Log.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
+      return false;
     }
-    return null;
   }
 
   private isProtocolV2BootloaderMode() {
@@ -269,19 +1290,21 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   async enterProtocolV2BootloaderMode() {
-    if (this.isProtocolV2BootloaderMode()) {
+    // romloader is the first update environment and forwards targets to bootloader.
+    // It rejects DeviceRebootType.Bootloader, so reuse the current connection.
+    if (this.isProtocolV2BootloaderMode() || this.device.features?.mode === 'romloader') {
+      Log.debug('Protocol V2 device is already in loader mode, skip reboot to bootloader');
+      this.protocolV2ExecutionInLoader = true;
       return false;
     }
 
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.AutoRebootToBootloader);
-      await this.protocolV2Reboot(DevRebootType.Bootloader);
+      await this.protocolV2Reboot(DeviceRebootType.Bootloader);
       this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
-      this.checkDeviceToBootloader(this.payload.connectId);
-      await this.checkPromise?.promise;
-      this.checkPromise = null;
-      await wait(1500);
-      await this.device.acquire?.();
+      await wait(1000);
+      await this.waitForProtocolV2BootloaderMode();
+      this.protocolV2ExecutionInLoader = true;
       return true;
     } catch (error) {
       if (error instanceof HardwareError) {
@@ -292,268 +1315,548 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
   }
 
+  private async waitForProtocolV2BootloaderMode(
+    timeout = PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT,
+    retryInterval = 1000
+  ) {
+    const startTime = Date.now();
+    let lastError: unknown;
+
+    while (Date.now() - startTime < timeout) {
+      try {
+        await this.reconnectProtocolV2Device();
+        const deviceInfo = await requestProtocolV2DeviceInfo({
+          commands: this.device.getCommands(),
+          timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+        });
+        this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
+        // This is a reconnect probe after a Bootloader reboot. Bootloader does not
+        // support DeviceStatusGet, so the generic runtime-mode probe is invalid here.
+        const features = this.device.updateProtocolV2Features(deviceInfo, null, 'bootloader');
+        if (features?.bootloaderMode) {
+          return features;
+        }
+        lastError = new Error('Protocol V2 device is reachable but is not in bootloader mode');
+      } catch (error) {
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
+          throw error;
+        }
+        lastError = error;
+        Log.log('Protocol V2 bootloader mode not ready, polling reconnect: ', error);
+      }
+      await wait(retryInterval);
+    }
+
+    throw ERRORS.TypedError(
+      HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure,
+      `Protocol V2 bootloader not ready within ${timeout / 1000}s: ${this.normalizeErrorMessage(
+        lastError
+      )}`
+    );
+  }
+
   /**
-   * 收集按 DevFirmwareTargetType 拆分的显式目标二进制。
-   * 文件名仅用于 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: { fileName: string; binary: ArrayBuffer; targetId: number }[] = [];
+    const entries: ProtocolV2TargetBinary[] = [];
     const push = (binary: ArrayBuffer | undefined, fileName: string, targetId: number) => {
       if (binary) entries.push({ fileName, binary, targetId });
     };
 
-    push(
-      this.params.romloaderBinary,
-      'romloader.bin',
-      ProtocolV2FirmwareTargetType.TARGET_MAIN_BOOT
-    );
+    if (this.params.romloaderBinary) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        PROTOCOL_V2_ROMLOADER_UNSUPPORTED_MESSAGE
+      );
+    }
     push(
       this.params.applicationP1Binary,
       'application_p1.bin',
-      ProtocolV2FirmwareTargetType.TARGET_MAIN_APP
+      ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1
     );
     push(
       this.params.applicationP2Binary,
       'application_p2.bin',
-      ProtocolV2FirmwareTargetType.TARGET_MAIN_APP
+      ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2
+    );
+    push(
+      this.params.coprocessorBinary,
+      'coprocessor.bin',
+      ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR
     );
-    push(this.params.coprocessorBinary, 'coprocessor.bin', ProtocolV2FirmwareTargetType.TARGET_BT);
-    push(this.params.se01Binary, 'se01.bin', ProtocolV2FirmwareTargetType.TARGET_SE1);
-    push(this.params.se02Binary, 'se02.bin', ProtocolV2FirmwareTargetType.TARGET_SE2);
-    push(this.params.se03Binary, 'se03.bin', ProtocolV2FirmwareTargetType.TARGET_SE3);
-    push(this.params.se04Binary, 'se04.bin', ProtocolV2FirmwareTargetType.TARGET_SE4);
+    push(this.params.se01Binary, 'se01.bin', ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01);
+    push(this.params.se02Binary, 'se02.bin', ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02);
+    push(this.params.se03Binary, 'se03.bin', ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03);
+    push(this.params.se04Binary, 'se04.bin', ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04);
     return entries;
   }
 
-  private async prepareFirmwareAndBleBinary(firmwareType: EFirmwareType, features: Features) {
-    const fwBinaryMap: { fileName: string; binary: ArrayBuffer; targetId?: number }[] = [];
-    if (this.params.firmwareBinary) {
-      fwBinaryMap.push({
-        fileName: 'firmware.bin',
-        binary: this.params.firmwareBinary,
+  private buildProtocolV2ExecutionPhases({
+    installSources,
+    resourceSources,
+  }: {
+    installSources: ProtocolV2InstallSource[];
+    resourceSources: ProtocolV2ResourceBundleSource[];
+  }): ProtocolV2ExecutionPhase[] {
+    const phases: ProtocolV2ExecutionPhase[] = [];
+    if (resourceSources.length > 0) {
+      phases.push({
+        kind: 'resource-sync',
+        installSources: [],
+        resourceSources,
       });
-    } else if (this.params.firmwareVersion) {
-      const firmwareBinary = (
-        await getBinary({
-          features,
-          version: this.params.firmwareVersion,
-          updateType: 'firmware',
-          isUpdateBootloader: false,
-          firmwareType,
-        })
-      ).binary;
-      fwBinaryMap.push({
-        fileName: 'firmware.bin',
-        binary: firmwareBinary,
+    }
+    const bootloaderSources = installSources.filter(source => source.kind === 'bootloader');
+    if (bootloaderSources.length > 0) {
+      phases.push(
+        {
+          kind: 'bootloader-install',
+          installSources: bootloaderSources,
+          resourceSources: [],
+        },
+        {
+          kind: 'bootloader-verify',
+          installSources: [],
+          resourceSources: [],
+        }
+      );
+    }
+    const componentSources = installSources.filter(source => source.kind !== 'bootloader');
+    if (componentSources.length > 0) {
+      phases.push({
+        kind: 'component-install',
+        installSources: componentSources,
+        resourceSources: [],
       });
     }
+    phases.push({
+      kind: 'final-verify',
+      installSources: [],
+      resourceSources: [],
+    });
+    return phases;
+  }
 
-    if (this.params.bleBinary) {
-      fwBinaryMap.push({
-        fileName: 'ble-firmware.bin',
-        binary: this.params.bleBinary,
-      });
-    } else if (this.params.bleVersion) {
-      const bleBinary = await getBinary({
-        features,
-        version: this.params.bleVersion,
-        updateType: 'ble',
-        firmwareType,
-      });
-      fwBinaryMap.push({
-        fileName: 'ble-firmware.bin',
-        binary: bleBinary.binary,
-      });
+  private async executeProtocolV2Phases({
+    installSources,
+    resourceSources,
+  }: {
+    installSources: ProtocolV2InstallSource[];
+    resourceSources: ProtocolV2ResourceBundleSource[];
+  }) {
+    const phases = this.buildProtocolV2ExecutionPhases({
+      installSources,
+      resourceSources,
+    });
+    for (const phase of phases) {
+      if (phase.kind === 'final-verify') {
+        return this.completeProtocolV2FinalVerification();
+      }
+      if (phase.kind === 'resource-sync') {
+        await this.enterProtocolV2BootloaderMode();
+        await this.executeProtocolV2TransferPhase(phase);
+      } else if (phase.kind === 'bootloader-install' || phase.kind === 'component-install') {
+        await this.enterProtocolV2BootloaderMode();
+        await this.executeProtocolV2TransferPhase(phase);
+        await this.exitProtocolV2BootloaderToNormal();
+      } else if (phase.kind === 'bootloader-verify') {
+        await this.waitForProtocolV2FinalFeatures();
+        this.assertExpectedProtocolV2Versions(['boot']);
+      }
     }
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Protocol V2 execution has no final verification phase'
+    );
+  }
 
-    return fwBinaryMap;
+  private async executeProtocolV2SourceUpdate({
+    installSources,
+    resourceSources,
+  }: {
+    installSources: ProtocolV2InstallSource[];
+    resourceSources: ProtocolV2ResourceBundleSource[];
+  }) {
+    return this.executeProtocolV2Phases({
+      installSources,
+      resourceSources,
+    });
   }
 
   private async executeProtocolV2Update({
-    resourceBinary,
     fwBinaryMap,
     bootloaderBinary,
+    installItems,
+    resourceBundles,
   }: {
-    resourceBinary: ArrayBuffer | null;
-    fwBinaryMap: { fileName: string; binary: ArrayBuffer; targetId?: number }[];
-    bootloaderBinary: ArrayBuffer | null;
+    fwBinaryMap?: ProtocolV2TargetBinary[];
+    bootloaderBinary?: ArrayBuffer | null;
+    installItems?: ProtocolV2InstallItem[];
+    resourceBundles?: ProtocolV2ResourceBundleBinary[];
   }) {
-    let totalSize = 0;
-    let processedSize = 0;
-
-    if (resourceBinary) totalSize += resourceBinary.byteLength;
-    for (const fwbinary of fwBinaryMap) totalSize += fwbinary.binary.byteLength;
-    if (bootloaderBinary) totalSize += bootloaderBinary.byteLength;
-
-    this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
-
-    const targets: Array<{ target_id: number; path: string }> = [];
-
-    if (resourceBinary) {
-      // resource 仅支持单文件 .bin：整文件一次上传，target path 指向该文件
-      const resourceFilePath = `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}resource.bin`;
-      processedSize = await this.protocolV2CommonUpdateProcess({
-        payload: resourceBinary,
-        filePath: resourceFilePath,
-        processedSize,
-        totalSize,
+    const memoryInstallItems =
+      installItems ??
+      this.buildProtocolV2InstallItems({
+        fwBinaryMap: fwBinaryMap ?? [],
+        bootloaderBinary: bootloaderBinary ?? null,
       });
-      targets.push({
-        target_id: ProtocolV2FirmwareTargetType.TARGET_RESOURCE,
-        path: resourceFilePath,
+    try {
+      const installSources = await Promise.all(
+        memoryInstallItems.map(async item => ({
+          fileName: item.fileName,
+          source: await this.openProtocolV2MemorySource(item.binary),
+          targetId: item.targetId,
+          kind: item.kind,
+        }))
+      );
+      const resourceSources = await Promise.all(
+        (resourceBundles ?? []).map(async bundle => ({
+          name: bundle.name,
+          source: await this.openProtocolV2MemorySource(bundle.binary),
+          devicePath: bundle.devicePath,
+          version: bundle.version,
+          payloadHash: bundle.payloadHash,
+          headerHash: bundle.headerHash,
+        }))
+      );
+      return await this.executeProtocolV2Phases({
+        installSources,
+        resourceSources,
       });
+    } finally {
+      await this.closeProtocolV2PreparedSources();
+    }
+  }
+
+  private async executeProtocolV2TransferPhase({
+    installSources,
+    resourceSources,
+  }: ProtocolV2ExecutionPhase) {
+    let totalSize = installSources.reduce((total, item) => total + item.source.size, 0);
+    const resourcesToSync: ProtocolV2ResourceBundleSource[] = [];
+    for (const resource of resourceSources) {
+      if (await this.isProtocolV2ResourceBundleUpToDate(resource)) {
+        Log.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
+      } else {
+        resourcesToSync.push(resource);
+        totalSize += resource.source.size;
+      }
     }
 
-    if (bootloaderBinary) {
-      const bootloaderPath = `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}bootloader.bin`;
-      processedSize = await this.protocolV2CommonUpdateProcess({
-        payload: bootloaderBinary,
-        filePath: bootloaderPath,
+    this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
+    let processedSize = 0;
+    for (const resource of resourcesToSync) {
+      processedSize = await this.protocolV2SourceUpdateProcess({
+        source: resource.source,
+        filePath: resource.devicePath,
         processedSize,
         totalSize,
       });
-      targets.push({
-        target_id: ProtocolV2FirmwareTargetType.TARGET_MAIN_BOOT,
-        path: bootloaderPath,
-      });
+      await this.verifyProtocolV2StagedFile(resource.devicePath, resource.source.size);
     }
 
-    for (const fwbinary of fwBinaryMap) {
-      const firmwarePath = `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}${fwbinary.fileName}`;
-      processedSize = await this.protocolV2CommonUpdateProcess({
-        payload: fwbinary.binary,
-        filePath: firmwarePath,
+    const stagedInstallTargets: Array<{ targetId: number; path: string }> = [];
+    for (const item of installSources) {
+      const filePath = this.getProtocolV2InstallItemStagingPath(item);
+      processedSize = await this.protocolV2SourceUpdateProcess({
+        source: item.source,
+        filePath,
         processedSize,
         totalSize,
       });
-      targets.push({
-        target_id: fwbinary.targetId ?? protocolV2FileNameToTargetId(fwbinary.fileName),
-        path: firmwarePath,
+      await this.verifyProtocolV2StagedFile(filePath, item.source.size);
+      stagedInstallTargets.push({
+        targetId: item.targetId,
+        path: filePath,
       });
     }
 
     if (totalSize > 0) {
       this.postProgressMessage(100, 'transferData');
     }
+    if (stagedInstallTargets.length === 0) {
+      return;
+    }
 
     this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
-    const startResponse = await this.protocolV2StartFirmwareUpdate({ targets });
-    await this.waitForProtocolV2FirmwareUpdateComplete(targets, startResponse);
+    const targets = stagedInstallTargets.map(item => ({
+      target_id: item.targetId,
+      path: item.path,
+    }));
+    await this.protocolV2StartFirmwareUpdate({ targets });
+    await this.waitForProtocolV2FirmwareUpdateComplete(targets);
   }
 
-  private async queryProtocolV2FirmwareUpdateStatus() {
-    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    return typedCall(
-      'DevGetFirmwareUpdateStatus',
-      'DevFirmwareUpdateStatus',
-      {},
-      {
-        timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+  private async protocolV2SourceUpdateProcess({
+    source,
+    filePath,
+    processedSize,
+    totalSize,
+  }: {
+    source: FirmwareByteSource;
+    filePath: string;
+    processedSize: number;
+    totalSize: number;
+  }) {
+    let lastError: unknown;
+    for (let attempt = 1; attempt <= PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT; attempt += 1) {
+      try {
+        await writeFirmwareByteSource({
+          source,
+          chunkSize: this.getProtocolV2FirmwareChunkSize(),
+          write: async ({ data, sourceOffset, length, first }) => {
+            const chunkEnd = sourceOffset + length;
+            const progress = getProtocolV2DeviceTransferProgress(
+              processedSize + sourceOffset,
+              processedSize + chunkEnd,
+              totalSize
+            );
+            const response = await this.fileWriteChunk(
+              filePath,
+              source.size,
+              sourceOffset,
+              data,
+              first,
+              progress
+            );
+            const rawProcessedByte = response.message.processed_byte;
+            const nextOffset = rawProcessedByte === undefined ? chunkEnd : Number(rawProcessedByte);
+            if (!Number.isFinite(nextOffset) || nextOffset !== chunkEnd) {
+              throw ERRORS.TypedError(
+                HardwareErrorCode.EmmcFileWriteFirmwareError,
+                `invalid processed_byte ${rawProcessedByte} for offset ${sourceOffset}`
+              );
+            }
+            this.postProgressMessage(progress, 'transferData');
+            return length;
+          },
+        });
+        return processedSize + source.size;
+      } catch (error) {
+        lastError = error;
+        if (attempt < PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
+          await this.recoverProtocolV2FileTransfer();
+        }
       }
+    }
+    throw ERRORS.TypedError(
+      HardwareErrorCode.EmmcFileWriteFirmwareError,
+      `transfer data error: ${getProtocolV2UnknownErrorText(lastError)}`
     );
   }
 
-  private async pingProtocolV2Device() {
+  private getProtocolV2InstallItemStagingPath(item: Pick<ProtocolV2InstallItem, 'fileName'>) {
+    return `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}${item.fileName}`;
+  }
+
+  private async verifyProtocolV2StagedFile(path: string, expectedSize: number) {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    await typedCall(
-      'Ping',
-      'Success',
-      { message: 'firmware-update' },
-      {
-        timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
-      }
-    );
+    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'}`
+      );
+    }
   }
 
   private assertProtocolV2TargetStatus(
     statusTargets: ProtocolV2FirmwareUpdateStatusTarget[],
-    expectedTargetIds: Set<number>
+    expectedTargetIds: Set<number>,
+    expectedPaths = new Map<number, string>()
   ) {
+    Log.log(
+      `[FirmwareUpdateV4] DeviceFirmwareUpdateStatus records=${JSON.stringify(statusTargets)}`
+    );
     const failedTarget = statusTargets.find(
       target =>
-        expectedTargetIds.has(target.target_id) &&
-        target.status === PROTOCOL_V2_TARGET_STATUS_FAILED
+        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(target.target_id) &&
-        target.status === PROTOCOL_V2_TARGET_STATUS_FINISHED
+    const matchingTargets = statusTargets.filter(target =>
+      expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1)
+    );
+    const seenTargetIds = new Set<number>();
+    for (const target of matchingTargets) {
+      const targetId = normalizeProtocolV2TargetId(target.target_id);
+      if (
+        targetId === undefined ||
+        seenTargetIds.has(targetId) ||
+        (target.path && expectedPaths.get(targetId) && target.path !== expectedPaths.get(targetId))
+      ) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Protocol V2 install status conflicts with target ${target.target_id}`
+        );
+      }
+      seenTargetIds.add(targetId);
+    }
+    const completedTargets = matchingTargets.filter(target =>
+      isProtocolV2TargetStatusFinished(target.status)
     );
     if (completedTargets.length === expectedTargetIds.size && expectedTargetIds.size > 0) {
+      for (const target of completedTargets) {
+        const targetId = normalizeProtocolV2TargetId(target.target_id);
+        const payloadVersion = toProtocolV2FiniteNumber(target.payload_version);
+        if (targetId === undefined) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            'Protocol V2 completed target identity is invalid'
+          );
+        }
+        const expectedVersion = this.getExpectedProtocolV2TargetVersion(targetId);
+        if (expectedVersion !== undefined && payloadVersion !== undefined) {
+          if (payloadVersion !== expectedVersion) {
+            throw ERRORS.TypedError(
+              HardwareErrorCode.FirmwareVerificationFailed,
+              `Protocol V2 target ${targetId} reached payload version ${payloadVersion}, expected ${expectedVersion}`
+            );
+          }
+        }
+        if (payloadVersion !== undefined) {
+          this.protocolV2CompletedTargetVersions.set(targetId, payloadVersion);
+        }
+      }
+      this.postProgressMessage(100, 'installingFirmware');
       return true;
     }
 
-    const inProgressTarget = statusTargets.find(
-      target =>
-        expectedTargetIds.has(target.target_id) &&
-        target.status === PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS
-    );
-    if (inProgressTarget) {
-      this.postProgressMessage(99, 'installingFirmware');
+    if (expectedTargetIds.size > 0 && matchingTargets.length > 0) {
+      const hasInProgressTarget = matchingTargets.some(target =>
+        isProtocolV2TargetStatusInProgress(target.status)
+      );
+      const completedProgress = Math.floor(
+        (completedTargets.length / 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
+    targets: Array<{ target_id: number; path: string }>
   ) {
+    this.protocolV2FinalStatusVerified = false;
     const expectedTargetIds = new Set(targets.map(target => target.target_id));
-    if (startResponse?.type === 'Success') {
-      return;
-    }
-    if (startResponse?.type === 'DevFirmwareUpdateStatus') {
-      const statusTargets = (startResponse.message.targets ??
-        []) as ProtocolV2FirmwareUpdateStatusTarget[];
-      if (this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds)) {
-        return;
-      }
-    }
-
+    const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
     const startTime = Date.now();
     let lastError: unknown;
 
     while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
       try {
-        const statusRes = await this.queryProtocolV2FirmwareUpdateStatus();
-        const statusTargets = (statusRes.message.targets ??
-          []) as ProtocolV2FirmwareUpdateStatusTarget[];
-        if (this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds)) {
-          return;
+        await this.reconnectProtocolV2Device();
+        await this.verifyProtocolV2ReconnectIdentity();
+        try {
+          const statusResponse = await this.device.getCommands().typedCall(
+            'DeviceFirmwareUpdateStatusGet',
+            'DeviceFirmwareUpdateStatus',
+            {
+              fields: {
+                status: true,
+                payload_version: true,
+                path: true,
+              },
+            },
+            { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT }
+          );
+          if (
+            this.assertProtocolV2TargetStatus(
+              (statusResponse.message.records ?? []) as ProtocolV2FirmwareUpdateStatusTarget[],
+              expectedTargetIds,
+              expectedPaths
+            )
+          ) {
+            this.protocolV2FinalStatusVerified = true;
+            return;
+          }
+          lastError = new Error('Protocol V2 firmware targets are still installing');
+        } catch (error) {
+          if (
+            error instanceof HardwareError &&
+            error.errorCode === HardwareErrorCode.FirmwareError
+          ) {
+            throw error;
+          }
+          // App firmware does not register DeviceFirmwareUpdateStatusGet. If the
+          // device already rebooted into App, this endpoint error signals that the
+          // install phase ended; the later phase performs the final readiness check.
+          if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
+            try {
+              const deviceInfo = await requestProtocolV2DeviceInfo({
+                commands: this.device.getCommands(),
+                timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+              });
+              this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
+              const observed = await this.device.probeProtocolV2RuntimeState(
+                deviceInfo,
+                PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+              );
+              if (observed.mode === 'normal' && !observed.bootloaderMode) {
+                return;
+              }
+              lastError = new Error(
+                'Protocol V2 status endpoint is unavailable outside normal mode'
+              );
+            } catch (probeError) {
+              lastError = probeError;
+            }
+            throw ERRORS.TypedError(
+              HardwareErrorCode.RuntimeError,
+              `Protocol V2 firmware install status is unavailable: ${this.normalizeErrorMessage(
+                lastError
+              )}`,
+              {
+                firmwareUpdateCode: 'FirmwareInstallStatusUnavailable',
+              }
+            );
+          }
+          lastError = error;
+          Log.log(
+            '[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ',
+            error
+          );
         }
       } catch (error) {
         lastError = error;
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
+          throw error;
+        }
         if (error instanceof HardwareError && error.errorCode === HardwareErrorCode.FirmwareError) {
           throw error;
         }
-        Log.log('Protocol V2 firmware install status polling failed: ', error);
-        if (isProtocolV2PollingTransientError(error)) {
-          try {
-            await this.reconnectProtocolV2Device();
-          } catch (reconnectError) {
-            lastError = reconnectError;
-            Log.log(
-              'Protocol V2 firmware install reconnect/status polling failed: ',
-              reconnectError
-            );
-          }
-          try {
-            await this.pingProtocolV2Device();
-            Log.log('Protocol V2 firmware status unavailable, Ping is ready');
-            return;
-          } catch (pingError) {
-            lastError = pingError;
-            Log.log('Protocol V2 firmware install Ping polling failed: ', pingError);
-          }
+        if (
+          error instanceof HardwareError &&
+          error.params?.firmwareUpdateCode === 'FirmwareInstallStatusUnavailable'
+        ) {
+          throw error;
         }
+        Log.log('Protocol V2 firmware install device readiness probe failed: ', error);
       }
       await wait(1000);
     }
@@ -565,18 +1868,23 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   private async exitProtocolV2BootloaderToNormal() {
-    this.postTipMessage(FirmwareUpdateTipMessage.SwitchFirmwareReconnectDevice);
-    await this.protocolV2Reboot(DevRebootType.Normal);
+    await this.reconnectProtocolV2Device();
+    await this.verifyProtocolV2ReconnectIdentity();
+    // The connection may still be in bootloader. Request a Normal reboot directly;
+    // repeating it after an automatic App reboot is idempotent.
+    await this.protocolV2Reboot(DeviceRebootType.Normal);
+    this.protocolV2ExecutionInLoader = false;
   }
 
   private async waitForProtocolV2FinalFeatures() {
     const features = await this.waitForProtocolV2ReconnectAndFeatures(
-      PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT
+      PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT
     );
 
     const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
     const bleVersion = getDeviceBLEFirmwareVersion(features).join('.');
     const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
+    this.protocolV2LatestFinalFeatures = features;
     if (firmwareVersion === '0.0.0') {
       Log.warn(
         'Protocol V2 firmware update finished but app firmware version is still 0.0.0. This is allowed for Pro2 debug BLE-only update flows.'
@@ -590,6 +1898,17 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     };
   }
 
+  private async completeProtocolV2FinalVerification() {
+    if (this.protocolV2ExecutionInLoader || this.isProtocolV2BootloaderMode()) {
+      await this.exitProtocolV2BootloaderToNormal();
+    }
+    const versions = await this.waitForProtocolV2FinalFeatures();
+    this.assertExpectedProtocolV2Versions();
+    this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
+    DevicePool.resetState();
+    return versions;
+  }
+
   private async waitForProtocolV2ReconnectAndFeatures(timeout: number) {
     const startTime = Date.now();
     let lastError: unknown;
@@ -600,11 +1919,25 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         const deviceInfo = await requestProtocolV2DeviceInfo({
           commands: this.device.getCommands(),
           timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
-          // 更新完成判定只需要各 target 版本号；scope 与请求内容保持一致
+          // Completion needs target versions only; keep scope aligned with the request.
           request: PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
         });
-        return this.device.updateProtocolV2Features(deviceInfo);
+        this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
+        const features = await this.device.probeProtocolV2RuntimeState(
+          deviceInfo,
+          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+        );
+        if (features.mode !== 'normal' || features.bootloaderMode) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.DeviceNotFound,
+            'Protocol V2 device is still in bootloader mode'
+          );
+        }
+        return features;
       } catch (error) {
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
+          throw error;
+        }
         lastError = error;
         Log.log('Protocol V2 normal mode not ready, polling Ping: ', error);
         await wait(1000);
@@ -628,70 +1961,61 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const deviceDiff = await this.device.deviceConnector?.enumerate();
     const devicesDescriptor = deviceDiff?.descriptors ?? [];
 
-    const { deviceList } = await DevicePool.getDevices(devicesDescriptor, this.connectId);
+    if (
+      DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
+      devicesDescriptor.length === 1
+    ) {
+      this.device.updateDescriptor(
+        {
+          ...devicesDescriptor[0],
+          protocolType: PROTOCOL_V2_CONNECT_PROTOCOL,
+        },
+        true
+      );
+      await this.ensureProtocolV2DeviceAcquired();
+      this.device.commands.disposed = false;
+      this.device.getCommands().mainId = this.device.mainId ?? '';
+      return;
+    }
+
+    // App and bootloader serials may differ temporarily. During V4 reconnect, accept
+    // only a uniquely enumerated device instead of repeatedly using the old App path.
+    const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined, {
+      connectProtocol: PROTOCOL_V2_CONNECT_PROTOCOL,
+    });
     if (deviceList.length !== 1) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
     }
 
+    Log.debug(
+      'Protocol V2 firmware reconnect using single enumerated device:',
+      deviceList[0].getConnectId()
+    );
     this.device.updateFromCache(deviceList[0]);
-    await this.device.acquire();
+    await this.ensureProtocolV2DeviceAcquired();
     this.device.commands.disposed = false;
     this.device.getCommands().mainId = this.device.mainId ?? '';
   }
 
-  private async protocolV2CommonUpdateProcess({
-    payload,
-    filePath,
-    processedSize,
-    totalSize,
-  }: PROTO.FirmwareUpload & {
-    filePath: string;
-    processedSize?: number;
-    totalSize?: number;
-  }) {
-    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);
-      }
-      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 = getUploadProgress(chunkEnd);
-
-      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}`
-        );
-      }
-      offset = nextOffset;
-      this.postProgressMessage(getUploadProgress(offset), 'transferData');
+  /**
+   * 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,
+    });
+  }
 
-    return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
+  private isProtocolV2ReconnectIdentityError(error: unknown) {
+    return this.normalizeErrorMessage(error).includes('Protocol V2 reconnect physical identity');
   }
 
-  private async fileWriteWithRetry(
+  private async fileWriteChunk(
     filePath: string,
     totalFileSize: number,
     offset: number,
@@ -699,57 +2023,37 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     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);
-          }
+    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;
-    };
+      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);
+      await this.acquireProtocolV2BleDevice();
+      await this.device.initialize();
     }
-    throw ERRORS.TypedError(HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
+    await wait(2000);
   }
 
   private async acquireProtocolV2BleDevice() {
@@ -767,44 +2071,30 @@ 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(
-        'DevFirmwareUpdate',
-        PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
-        {
-          targets,
-        },
-        {
-          intermediateTypes: ['DevFirmwareInstallProgress'],
-          onIntermediateResponse: (response: { message?: { progress?: number } }) => {
-            const progress = Number(response.message?.progress);
-            if (Number.isFinite(progress)) {
-              this.postProgressMessage(Math.min(progress, 99), 'installingFirmware');
-            }
-          },
-        }
-      );
-    } catch (error) {
-      if (isProtocolV2DeviceDisconnectedError(error)) {
-        Log.log('Rebooting device');
-      } 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;
   }
 
-  private async protocolV2Reboot(rebootType: DevRebootType) {
+  private async protocolV2Reboot(rebootType: DeviceRebootType) {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
     try {
-      const res = await typedCall('DevReboot', 'Success', {
+      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;