@onekeyfe/hd-core 1.2.0-alpha.14 → 1.2.0-alpha.141

package/src/api/FirmwareUpdateV4.ts

@@ -1,21 +1,28 @@
-import { ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
+import { EDeviceType, ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
+import JSZip from 'jszip';
 import {
   DeviceRebootType,
+  DeviceSessionPinType,
   PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
+  PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE,
+  PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE,
   PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
 } from '@onekeyfe/hd-transport';
+import { sha256 } from '@noble/hashes/sha256';
 
-import { FirmwareUpdateTipMessage, UI_REQUEST } from '../events/ui-request';
+import { FirmwareUpdateTipMessage, UI_REQUEST, createUiMessage } from '../events/ui-request';
 import { validateParams } from './helpers/paramsValidator';
 import {
   LoggerNames,
   getDeviceBLEFirmwareVersion,
   getDeviceBootloaderVersion,
   getDeviceFirmwareVersion,
+  getDeviceType,
   getFirmwareType,
   getLogger,
 } from '../utils';
 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';
@@ -25,29 +32,67 @@ import {
 } from '../protocols/protocol-v2';
 import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
 import {
-  PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
+  parseProtocolV2ResourceManifest,
+  selectProtocolV2ResourceManifestFiles,
+} from '../protocols/protocol-v2/resources';
+import {
   getProtocolV2UnknownErrorText,
   isProtocolV2DeviceDisconnectedError,
 } from './protocol-v2/helpers';
+import {
+  openFirmwareByteSource,
+  readFirmwareByteSourceFully,
+  writeFirmwareByteSource,
+} from './firmware/FirmwareArtifactSource';
+import {
+  registerFirmwareUpdateHostBinding,
+  resolveFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from './firmware/FirmwareHostBinding';
+import {
+  assertFirmwareUpdatePreparedPlanBinding,
+  assertFirmwareUpdatePreparedPlanDeviceIdentity,
+  prepareFirmwareUpdatePlan,
+  validateFirmwareUpdatePreparedPlan,
+} from './firmware/FirmwareUpdatePreparedPlan';
+import { prepareFirmwareUpdateV4MemoryHost } from './firmware/FirmwareMemoryHost';
+import { buildProtocolV2LocalFirmwareUpdatePlan } from './firmware/FirmwareUpdatePlan';
 
-import type { FirmwareUpdateV4Params, FirmwareUpdateV4Target } from '../types/api/firmwareUpdate';
+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,
   IFirmwareReleaseInfo,
   IProtocolV2FirmwareComponent,
+  IProtocolV2ResourceManifestFile,
   IVersionArray,
+  KnownDevice,
 } from '../types';
+import type { FirmwareByteSource } from './firmware/FirmwareArtifactSource';
+import type {
+  FirmwareMemoryArtifact,
+  FirmwareMemoryArtifactEntry,
+  FirmwareUpdateV4MemoryHost,
+} from './firmware/FirmwareMemoryHost';
 
 const Log = getLogger(LoggerNames.Method);
 
+// Restored after a rebase dropped the declaration while keeping its use in
+// fileWriteChunk; without it that error branch throws ReferenceError instead of
+// the intended typed session error.
 const SESSION_ERROR = 'session not found';
-const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 60 * 1000;
+const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
+const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
-const PROTOCOL_V2_START_UPDATE_TIMEOUT = 3 * 60 * 1000;
+const PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT = 15 * 1000;
 const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
+const PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY = 1000;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
 const PROTOCOL_V2_TARGET_STATUS_FINISHED = 2;
@@ -58,12 +103,88 @@ const PROTOCOL_V2_MIN_FILE_CHUNK_SIZE = 64;
 const PROTOCOL_V2_CONNECT_RETRY_COUNT = 10;
 const PROTOCOL_V2_CONNECT_POLL_INTERVAL = 500;
 const PROTOCOL_V2_CONNECT_SINGLE_TIMEOUT = 75 * 1000;
-const PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT = 60 * 1000;
+const PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT = 30 * 1000;
 const PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT = 3;
+const PROTOCOL_V2_TRANSFER_PROGRESS_HEARTBEAT_MS = 1000;
+const PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE = 'FirmwareInstallStatusConflict';
+const PROTOCOL_V2_INSTALL_FAILED_CODE = 'FirmwareInstallFailed';
+const PROTOCOL_V2_INSTALL_TIMEOUT_CODE = 'FirmwareInstallTimeout';
 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 PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES = 1024 * 1024;
+const PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT = 512;
+const PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES = 256 * 1024 * 1024;
+
+const getProtocolV2LocalResourceArchivePath = (entryName: string) => {
+  const match = entryName.match(
+    /(?:^|\/)((?:bundles\/|loaders\/(?:bootloader|rom)\/).+\.okpkg)$/iu
+  );
+  return match?.[1];
+};
+
+const PROTOCOL_V2_NEO_UNSUPPORTED_TARGETS = new Set<FirmwareUpdateV4Target>(['se03', 'se04']);
+
+const getProtocolV2ZipEntrySizes = (entry: JSZip.JSZipObject) => {
+  // loadAsync records central-directory sizes on JSZip's documented private data object.
+  // Validate those bounds before calling async(), which allocates the decompressed entry.
+  const { compressedSize, uncompressedSize } = (entry as JSZipSizedEntry)._data ?? {};
+  if (
+    !Number.isSafeInteger(compressedSize) ||
+    Number(compressedSize) < 0 ||
+    !Number.isSafeInteger(uncompressedSize) ||
+    Number(uncompressedSize) <= 0
+  ) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `Protocol V2 local resource ZIP entry size is invalid: ${entry.name}`,
+      { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+    );
+  }
+  return {
+    compressedSize: Number(compressedSize),
+    uncompressedSize: Number(uncompressedSize),
+  };
+};
+
+export function assertProtocolV2FirmwareTargetsSupported(
+  deviceType: EDeviceType | string | undefined,
+  params: FirmwareUpdateV4Params,
+  hasExplicitTargetSelection = false
+) {
+  const requestedTargets = new Set(params.targetsToUpdate ?? []);
+  const unsupportedTargets = new Set(
+    Array.from(requestedTargets).filter(target => PROTOCOL_V2_NEO_UNSUPPORTED_TARGETS.has(target))
+  );
+  if (params.se03Binary && (!hasExplicitTargetSelection || requestedTargets.has('se03'))) {
+    unsupportedTargets.add('se03');
+  }
+  if (params.se04Binary && (!hasExplicitTargetSelection || requestedTargets.has('se04'))) {
+    unsupportedTargets.add('se04');
+  }
+  if (
+    params.componentArtifacts?.se03 &&
+    (!hasExplicitTargetSelection || requestedTargets.has('se03'))
+  ) {
+    unsupportedTargets.add('se03');
+  }
+  if (
+    params.componentArtifacts?.se04 &&
+    (!hasExplicitTargetSelection || requestedTargets.has('se04'))
+  ) {
+    unsupportedTargets.add('se04');
+  }
+
+  if (!unsupportedTargets.size || deviceType === EDeviceType.Pro2) return;
+
+  const targetList = Array.from(unsupportedTargets).join(', ');
+  const message =
+    deviceType === EDeviceType.Neo
+      ? `Neo only supports SE01 and SE02; unsupported firmware targets: ${targetList}`
+      : `Cannot safely update ${targetList} without a confirmed Pro2 device type`;
+  throw ERRORS.TypedError(HardwareErrorCode.DeviceNotSupportMethod, message);
+}
 
 const getProtocolV2DeviceTransferProgress = (
   bytesBeforeChunk: number,
@@ -71,22 +192,14 @@ const getProtocolV2DeviceTransferProgress = (
   totalBytes: number
 ) => {
   if (!Number.isFinite(totalBytes) || totalBytes <= 0) {
-    return 100;
+    return 0;
   }
   if (bytesBeforeChunk <= 0 && bytesAfterChunk < totalBytes) {
     return 0;
   }
-  if (bytesAfterChunk >= totalBytes) {
-    return 100;
-  }
   return Math.min(Math.max(Math.ceil((bytesAfterChunk / totalBytes) * 100), 1), 99);
 };
 
-const formatProtocolV2TransferSpeed = (bytes: number, elapsedMs: number) => {
-  const safeElapsedMs = Math.max(elapsedMs, 1);
-  return (bytes / 1024 / (safeElapsedMs / 1000)).toFixed(2);
-};
-
 type ProtocolV2FirmwareUpdateStatusTarget = {
   target_id: number | string;
   status?: number | string;
@@ -94,46 +207,52 @@ type ProtocolV2FirmwareUpdateStatusTarget = {
   path?: string;
 };
 
-type ProtocolV2FirmwareUpdateStartResponse =
-  | TypedResponseMessage<'Success'>
-  | TypedResponseMessage<'DeviceFirmwareUpdateStatus'>
-  | undefined;
-
 type ProtocolV2TargetBinary = { fileName: string; binary: ArrayBuffer; targetId: number };
 type ProtocolV2InstallItem = ProtocolV2TargetBinary & {
   kind: ProtocolV2RemoteComponentTarget['kind'];
 };
-type ProtocolV2InstallTarget = ProtocolV2InstallItem & {
-  path: string;
+
+type ProtocolV2RemoteComponentBinary = ProtocolV2RemoteComponentTarget & {
+  binary: ArrayBuffer;
+};
+
+type ProtocolV2RemoteComponentTarget = {
+  fileName: string;
+  targetId: number;
+  kind: 'bootloader' | 'firmware';
 };
 
-type ProtocolV2FileTransferParams = PROTO.FirmwareUpload & {
-  filePath: string;
-  processedSize?: number;
-  totalSize?: number;
-  onTransferredBytes?: (transferredBytes: number) => void;
+type ProtocolV2InstallSource = {
+  fileName: string;
+  source: FirmwareByteSource;
+  targetId: number;
+  kind: ProtocolV2RemoteComponentTarget['kind'];
 };
 
-/** RESC bundle okpkg（FileWrite 直写模式），每个独立同步到 devicePath */
-type ProtocolV2ResourceBundleBinary = {
+type ProtocolV2ResourceBundleSource = {
   name: string;
-  binary: ArrayBuffer;
+  source: FirmwareByteSource;
   devicePath: string;
-  /** 远端配置模式下的下载 URL（手动模式不填） */
-  url?: string;
   version?: IVersionArray;
   payloadHash?: string;
   headerHash?: string;
 };
 
-type ProtocolV2RemoteComponentBinary = ProtocolV2RemoteComponentTarget & {
+type ProtocolV2LocalResourceArchive = {
   binary: ArrayBuffer;
+  materializedEntries: FirmwareMemoryArtifactEntry[];
 };
 
-type ProtocolV2RemoteComponentTarget = {
-  fileName: string;
-  targetId: number;
-  kind: 'bootloader' | 'firmware';
+type JSZipSizedEntry = JSZip.JSZipObject & {
+  _data?: {
+    compressedSize?: unknown;
+    uncompressedSize?: unknown;
+  };
+};
+
+type ProtocolV2TransferBatch = {
+  installSources: ProtocolV2InstallSource[];
+  resourceSources: ProtocolV2ResourceBundleSource[];
 };
 
 type ProtocolV2OkppHeader = {
@@ -188,7 +307,29 @@ const PROTOCOL_V2_REMOTE_COMPONENT_TARGETS: Readonly<
   },
 };
 
-const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map<number, FirmwareUpdateV4Target>([
+const PROTOCOL_V2_FIRMWARE_STAGING_PATHS = new Set(
+  Object.values(PROTOCOL_V2_REMOTE_COMPONENT_TARGETS).map(
+    target => `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}${target.fileName}`
+  )
+);
+
+const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH = 'vol0:/loaders/bootloader/boot_resource.okpkg';
+const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH = `${PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH}.staging`;
+
+const isProtocolV2BootResourcePackagePath = (devicePath: string) =>
+  typeof devicePath === 'string' &&
+  devicePath.replace(/^vol0:(?!\/)/i, 'vol0:/').toLowerCase() ===
+    PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH;
+
+const resolveProtocolV2ResourceWritePath = (devicePath: string) =>
+  isProtocolV2BootResourcePackagePath(devicePath)
+    ? PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH
+    : devicePath;
+
+const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map<
+  number,
+  Exclude<FirmwareUpdateV4Target, 'boot_resources'>
+>([
   [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER, 'boot'],
   [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1, 'app_v1'],
   [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2, 'app_v2'],
@@ -199,11 +340,24 @@ const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map<number, FirmwareUpdateV4T
   [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04, 'se04'],
 ]);
 
+const PROTOCOL_V2_INSTALL_TARGET_BY_UPDATE_TARGET = new Map<
+  Exclude<FirmwareUpdateV4Target, 'resource'>,
+  ProtocolV2RemoteComponentTarget
+>(
+  Object.values(PROTOCOL_V2_REMOTE_COMPONENT_TARGETS).map(target => [
+    PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId) as Exclude<
+      FirmwareUpdateV4Target,
+      'resource'
+    >,
+    target,
+  ])
+);
+
 const PROTOCOL_V2_ROMLOADER_UNSUPPORTED_MESSAGE =
   'FW_MGMT_TARGET_ROMLOADER is not accepted by the current Pro2 bootloader update request. Flash romloader with the loader-specific flow instead of firmwareUpdateV4.';
 
-// hd-transport 的历史 decode 行为会把单值 enum 输出为枚举名字符串；
-// Protocol V2 沿用这个 SDK 语义，内部比较前再映射回固件协议数值。
+// hd-transport historically decodes scalar enums as enum-name strings.
+// Map them back to firmware protocol values before internal comparisons.
 const PROTOCOL_V2_TARGET_ID_BY_DECODED_NAME = new Map<string, number>(
   Object.entries(ProtocolV2FirmwareTargetType).map(([key, value]) => [key, value])
 );
@@ -229,27 +383,21 @@ const isProtocolV2ReconnectProbeError = (error: unknown) => {
   );
 };
 
-const isProtocolV2PollingTransientError = (error: unknown) => {
+const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
   const message = getProtocolV2UnknownErrorText(error).toLowerCase();
   return (
-    isProtocolV2DeviceDisconnectedError(error) ||
-    isProtocolV2ReconnectProbeError(error) ||
-    message.includes('libusb_transfer_timed_out') ||
-    (message.includes('response timeout') && message.includes('devicefirmwareupdatestatusget')) ||
-    message.includes('device not found') ||
-    message.includes('transportnotfound')
+    message.includes('handler not registered') ||
+    message.includes('message handler not found') ||
+    message.includes('unsupported message')
   );
 };
 
-const isProtocolV2StartUpdateTransientError = (error: unknown) => {
-  const message = getProtocolV2UnknownErrorText(error).toLowerCase();
-  return (
-    isProtocolV2DeviceDisconnectedError(error) ||
-    isProtocolV2ReconnectProbeError(error) ||
-    message.includes('libusb_transfer_timed_out') ||
-    (message.includes('response timeout') && message.includes('devicefirmwareupdaterequest'))
-  );
-};
+const isProtocolV2TerminalInstallStatusError = (error: unknown) =>
+  error instanceof HardwareError &&
+  (error.errorCode === HardwareErrorCode.ActionCancelled ||
+    error.errorCode === HardwareErrorCode.FirmwareError ||
+    error.errorCode === HardwareErrorCode.FirmwareVerificationFailed ||
+    error.params?.firmwareUpdateCode === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE);
 
 const isProtocolV2TargetStatusFinished = (status: ProtocolV2FirmwareUpdateStatusTarget['status']) =>
   normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_FINISHED;
@@ -379,23 +527,41 @@ const parseProtocolV2OkppHeader = (bytes: Uint8Array): ProtocolV2OkppHeader | nu
   };
 };
 
+export const isProtocolV2FirmwareFingerprintValid = (
+  binary: ArrayBuffer | Uint8Array,
+  fingerprint: string | undefined
+) => {
+  const expectedFingerprint = normalizeProtocolV2Hex(fingerprint);
+  if (!expectedFingerprint) return true;
+  return bytesToHex(sha256(toProtocolV2Bytes(binary))) === expectedFingerprint;
+};
+
 export const assertProtocolV2ReconnectIdentity = (
-  expectedDeviceId?: string,
-  actualDeviceId?: string
+  expectedSerialNumber?: string,
+  actualSerialNumber?: string,
+  expectedPath?: string,
+  actualPath?: string
 ) => {
-  if (!expectedDeviceId) return;
-  if (!actualDeviceId) {
-    throw ERRORS.TypedError(
-      HardwareErrorCode.DeviceNotFound,
-      'Protocol V2 reconnect identity unavailable'
-    );
+  if (expectedSerialNumber && actualSerialNumber) {
+    if (actualSerialNumber !== expectedSerialNumber) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceNotFound,
+        `Protocol V2 reconnect physical identity mismatch: expected ${expectedSerialNumber}, received ${actualSerialNumber}`
+      );
+    }
+    return;
   }
-  if (actualDeviceId !== expectedDeviceId) {
-    throw ERRORS.TypedError(
-      HardwareErrorCode.DeviceNotFound,
-      `Protocol V2 reconnect identity mismatch: expected ${expectedDeviceId}, received ${actualDeviceId}`
-    );
+
+  if (expectedPath && actualPath && expectedPath === actualPath) {
+    return;
   }
+
+  throw ERRORS.TypedError(
+    HardwareErrorCode.DeviceNotFound,
+    `Protocol V2 reconnect physical identity unavailable: expected path ${
+      expectedPath ?? 'unknown'
+    }, received ${actualPath ?? 'unknown'}`
+  );
 };
 
 /**
@@ -403,20 +569,74 @@ export const assertProtocolV2ReconnectIdentity = (
  *
  * It intentionally does not fall back to FirmwareUpdateV3/V1 behavior:
  * - upload uses FilesystemFileWrite
- * - install uses DeviceFirmwareUpdateRequest
+ * - install uses DeviceFirmwareUpdateStage followed by an empty DeviceFirmwareUpdateRequest
  * - completion waits for target status to finish, reboots to normal, then polls DeviceInfo
  */
 export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareUpdateV4Params> {
-  private protocolV2ExpectedDeviceId?: string;
+  private protocolV2ExpectedSerialNumber?: string;
+
+  private protocolV2ExpectedPath?: string;
+
+  private protocolV2HasExplicitTargetSelection = false;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  private protocolV2PreparedSources: FirmwareByteSource[] = [];
+
+  private protocolV2ExecutionInLoader = false;
+
+  private protocolV2BootResourceStagingSafe = false;
+
+  private protocolV2CompletedTargetVersions = new Map<number, number>();
+
+  private protocolV2CompletedTargetIds = new Set<number>();
+
+  private protocolV2LatestFinalFeatures?: Features;
+
+  private protocolV2LatestFinalDeviceInfo?: ProtocolV2DeviceInfo;
+
+  private protocolV2InstallBaselineVersions = new Map<number, string>();
+
+  private protocolV2LastRuntimeProbeFeatures?: Features;
+
+  private protocolV2LastTransferProgress?: number;
+
+  private protocolV2LastTransferProgressAt = 0;
 
   init() {
     this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
     this.requireDeviceMode = [];
+    this.unlockPolicy = 'unlock-before-run';
+    // Protocol V2 device-management actions are not wallet-scoped, so either
+    // the main PIN or an Attach PIN may authorize them.
+    this.protocolV2PreUnlockPinType = DeviceSessionPinType.Any;
     this.useDevicePassphraseState = false;
     this.skipForceUpdateCheck = true;
 
     const { payload } = this;
 
+    const removedResourceInputs = ['resourceFiles', 'resourceBundleArtifacts'].filter(input =>
+      Object.prototype.hasOwnProperty.call(payload, input)
+    );
+    if (removedResourceInputs.length > 0) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        `Protocol V2 ${removedResourceInputs.join(
+          ' and '
+        )} inputs are no longer supported; use resourceArchiveBinary for local updates or preparedPlan with hostBindingGeneration for remote updates`
+      );
+    }
+    if (payload.hostBindingGeneration !== undefined && !payload.preparedPlan) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Protocol V2 hostBindingGeneration requires preparedPlan for remote updates; use direct binaries or resourceArchiveBinary for local updates'
+      );
+    }
+
+    this.protocolV2HasExplicitTargetSelection = payload.targetsToUpdate !== undefined;
+
     if (typeof payload.retryCount !== 'number') {
       payload.retryCount = PROTOCOL_V2_CONNECT_RETRY_COUNT;
     }
@@ -442,13 +662,112 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       { name: 'se02Binary', type: 'buffer' },
       { name: 'se03Binary', type: 'buffer' },
       { name: 'se04Binary', type: 'buffer' },
+      { name: 'resourceArchiveBinary', type: 'buffer' },
       { name: 'firmwareType', type: 'string' },
       { name: 'targetsToUpdate', type: 'array', allowEmpty: true },
       { name: 'platform', type: 'string' },
-      { name: 'resourceBundleFiles', type: 'array', allowEmpty: true },
+      { name: 'expectedDeviceId', type: 'string' },
     ]);
+    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 preparedPlan = payload.preparedPlan
+      ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
+      : undefined;
+    const hasLocalArtifacts = [
+      payload.bootloaderBinary,
+      payload.romloaderBinary,
+      payload.applicationP1Binary,
+      payload.applicationP2Binary,
+      payload.coprocessorBinary,
+      payload.se01Binary,
+      payload.se02Binary,
+      payload.se03Binary,
+      payload.se04Binary,
+      payload.resourceArchiveBinary,
+    ].some(Boolean);
+    if (preparedPlan && hasLocalArtifacts) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Prepared firmware plans cannot be combined with legacy or local firmware inputs'
+      );
+    }
+    let { artifactReader } = payload;
+    if (preparedPlan) {
+      artifactReader = resolveFirmwareUpdateHostBinding(
+        payload.hostBindingGeneration,
+        preparedPlan.preparedPlanDigest
+      ).artifactReader;
+    }
+    if (preparedPlan) {
+      assertFirmwareUpdatePreparedPlanBinding({
+        preparedPlan,
+        executor: 'v4',
+        platform: payload.platform,
+        scopeTargets: [],
+        bindings: [],
+      });
+      if (payload.componentArtifacts) {
+        const componentBindings: Array<{
+          target: Exclude<FirmwareUpdateV4Target, 'resource'>;
+          artifact: FirmwareArtifactReference;
+        }> = Object.entries(payload.componentArtifacts).flatMap(([target, artifact]) =>
+          artifact
+            ? [
+                {
+                  target: target as Exclude<FirmwareUpdateV4Target, 'resource'>,
+                  artifact: artifact as FirmwareArtifactReference,
+                },
+              ]
+            : []
+        );
+        assertFirmwareUpdatePreparedPlanBinding({
+          preparedPlan,
+          executor: 'v4',
+          platform: payload.platform,
+          scopeTargets: componentBindings.map(binding => binding.target),
+          bindings: componentBindings,
+        });
+      }
+    }
+
+    const preparedExpectedTargetVersions = preparedPlan?.artifacts.reduce<
+      NonNullable<FirmwareUpdateV4Params['expectedTargetVersions']>
+    >((result, artifact) => {
+      if (
+        artifact.role === 'component' &&
+        artifact.target !== 'resource' &&
+        artifact.targetVersion &&
+        PROTOCOL_V2_INSTALL_TARGET_BY_UPDATE_TARGET.has(
+          artifact.target as Exclude<FirmwareUpdateV4Target, 'resource'>
+        )
+      ) {
+        result[artifact.target as FirmwareUpdateV4Target] = artifact.targetVersion;
+      }
+      return result;
+    }, {});
+    const localTargetsToUpdate = payload.targetsToUpdate?.map((target: FirmwareUpdateV4Target) =>
+      target === 'boot_resources' ? 'resource' : target
+    );
+    if (
+      payload.resourceArchiveBinary &&
+      localTargetsToUpdate &&
+      !localTargetsToUpdate.includes('resource')
+    ) {
+      localTargetsToUpdate.push('resource');
+    }
+    // 本地 ZIP 本身就是明确的资源升级请求，不要求调用方重复声明 target。
+    const resolvedLocalTargetsToUpdate =
+      localTargetsToUpdate ?? (payload.resourceArchiveBinary ? ['resource'] : undefined);
 
     this.params = {
+      preparedPlan,
       chunkSize: payload.chunkSize,
       forcedUpdateRes: payload.forcedUpdateRes,
       bootloaderBinary: payload.bootloaderBinary,
@@ -460,20 +779,36 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       se02Binary: payload.se02Binary,
       se03Binary: payload.se03Binary,
       se04Binary: payload.se04Binary,
-      resourceBundleFiles: payload.resourceBundleFiles,
-      firmwareType: payload.firmwareType,
-      targetsToUpdate: payload.targetsToUpdate,
+      resourceArchiveBinary: payload.resourceArchiveBinary,
+      firmwareType: preparedPlan?.firmwareType ?? payload.firmwareType,
+      targetsToUpdate: preparedPlan
+        ? ([...preparedPlan.targetsToUpdate] as FirmwareUpdateV4Target[])
+        : resolvedLocalTargetsToUpdate,
+      expectedTargetVersions: preparedPlan
+        ? preparedExpectedTargetVersions
+        : payload.expectedTargetVersions,
       platform: payload.platform,
+      expectedDeviceId: payload.expectedDeviceId,
+      artifactReader,
+      componentArtifacts: preparedPlan ? undefined : payload.componentArtifacts,
     };
   }
 
-  private getProtocolV2FirmwareChunkSize() {
+  private getProtocolV2FirmwareChunkSize(direction: 'read' | 'write', filePath?: string) {
     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) {
+      if (direction === 'read') {
+        maxChunkSize = PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE;
+      } else {
+        // Firmware staging writes tolerate a larger BLE chunk than generic filesystem writes.
+        maxChunkSize = PROTOCOL_V2_FIRMWARE_STAGING_PATHS.has(filePath ?? '')
+          ? PROTOCOL_V2_BLE_FIRMWARE_FILE_CHUNK_SIZE
+          : PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+      }
+    }
     if (!Number.isFinite(payloadChunkSize) || payloadChunkSize <= 0) {
       return maxChunkSize;
     }
@@ -484,200 +819,1053 @@ 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();
-    this.protocolV2ExpectedDeviceId = deviceFeatures.deviceId ?? undefined;
+    this.protocolV2InstallBaselineVersions =
+      this.getProtocolV2ObservableTargetVersions(deviceFeatures);
+    this.protocolV2LastRuntimeProbeFeatures = undefined;
+    const currentDeviceType = this.device.getCurrentDeviceType();
+    const capabilityDeviceType =
+      currentDeviceType === EDeviceType.Pro2 || currentDeviceType === EDeviceType.Neo
+        ? currentDeviceType
+        : getDeviceType(deviceFeatures);
+    assertProtocolV2FirmwareTargetsSupported(
+      capabilityDeviceType,
+      this.params,
+      this.protocolV2HasExplicitTargetSelection
+    );
     const deviceFirmwareType = getFirmwareType(deviceFeatures);
     const firmwareType = this.params.firmwareType ?? deviceFirmwareType;
+    this.validateExpectedTargetVersions();
+    const wantsResources = !!this.params.targetsToUpdate?.includes('resource');
+
+    if (
+      !this.params.preparedPlan &&
+      this.params.resourceArchiveBinary &&
+      this.params.targetsToUpdate?.includes('resource')
+    ) {
+      const localMemoryHost = await this.prepareProtocolV2LocalMemoryHost({
+        features: deviceFeatures,
+        firmwareType,
+      });
+      try {
+        return await this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
+      } finally {
+        localMemoryHost.release();
+      }
+    }
+
+    const hasPreparedComponentArtifacts = Object.values(this.params.componentArtifacts ?? {}).some(
+      Boolean
+    );
+    if (this.params.preparedPlan || hasPreparedComponentArtifacts) {
+      return this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
+    }
 
     let fwBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
     let installItems: ProtocolV2InstallItem[] | undefined;
+    let resourceMemoryHost: FirmwareUpdateV4MemoryHost | undefined;
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
       fwBinaryMap = this.collectExplicitTargetBinaries();
       bootloaderBinary = this.prepareBootloaderBinary();
-      if (!this.hasExplicitProtocolV2Payload(fwBinaryMap)) {
+      const explicitInstallItems = this.buildProtocolV2InstallItems({
+        bootloaderBinary,
+        fwBinaryMap,
+      });
+      const missingFirmwareTargets = this.getMissingProtocolV2FirmwareTargets(explicitInstallItems);
+      const needsRemoteFirmware = this.params.targetsToUpdate?.length
+        ? missingFirmwareTargets.length > 0
+        : explicitInstallItems.length === 0;
+      const needsSdkManagedArtifacts = needsRemoteFirmware || wantsResources;
+      if (
+        needsSdkManagedArtifacts &&
+        (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',
+          }
+        );
+      }
+      if (needsSdkManagedArtifacts) {
+        // Remote updates must use a freshly fetched config before any reboot or file write.
+        await DataManager.forceReloadData({
+          requireResources: wantsResources,
+          resourceDeviceType:
+            capabilityDeviceType === EDeviceType.Neo ? EDeviceType.Neo : EDeviceType.Pro2,
+        });
+      }
+      if (needsRemoteFirmware) {
         const remoteBinaries = await this.prepareRemoteProtocolV2Binaries(
           firmwareType,
-          deviceFeatures
+          deviceFeatures,
+          explicitInstallItems
         );
         bootloaderBinary = remoteBinaries.bootloaderBinary;
         fwBinaryMap = remoteBinaries.fwBinaryMap;
         installItems = remoteBinaries.installItems;
+      } else {
+        const selectedInstallItems = this.filterProtocolV2LocalInstallItems(explicitInstallItems);
+        bootloaderBinary =
+          selectedInstallItems.find(item => item.kind === 'bootloader')?.binary ?? null;
+        fwBinaryMap = selectedInstallItems
+          .filter(item => item.kind === 'firmware')
+          .map(item => ({
+            fileName: item.fileName,
+            binary: item.binary,
+            targetId: item.targetId,
+          }));
+      }
+      if (wantsResources) {
+        this.params.resourceArchiveBinary = await this.downloadRemoteProtocolV2ResourceArchive(
+          deviceFeatures,
+          firmwareType
+        );
+        resourceMemoryHost = await this.prepareProtocolV2LocalMemoryHost({
+          features: deviceFeatures,
+          firmwareType,
+          availableInstallItems: installItems ?? explicitInstallItems,
+        });
       }
       this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
     } catch (err) {
-      throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
+      resourceMemoryHost?.release();
+      if (
+        typeof err === 'object' &&
+        err !== null &&
+        'params' in err &&
+        (err as HardwareError).params?.firmwareUpdateCode === 'FirmwareArtifactsNotPrepared'
+      ) {
+        throw err;
+      }
+      if (err instanceof HardwareError && err.errorCode === HardwareErrorCode.NetworkError) {
+        throw err;
+      }
+      throw normalizeFirmwarePreparationError(err);
     }
 
-    const resourceBundles = this.prepareProtocolV2ResourceBundles(firmwareType, deviceFeatures);
+    if (resourceMemoryHost) {
+      try {
+        return await this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType, false);
+      } finally {
+        resourceMemoryHost.release();
+      }
+    }
 
-    if (!bootloaderBinary && fwBinaryMap.length === 0 && !resourceBundles?.length) {
+    if (!bootloaderBinary && fwBinaryMap.length === 0 && !installItems?.length) {
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareUpdateDownloadFailed,
         'No firmware to update'
       );
     }
 
-    await this.enterProtocolV2BootloaderMode();
-
-    await this.executeProtocolV2Update({
+    return this.executeProtocolV2Update({
       fwBinaryMap,
       bootloaderBinary,
       ...(installItems ? { installItems } : undefined),
-      ...(resourceBundles?.length ? { resourceBundles } : undefined),
     });
-
-    await this.exitProtocolV2BootloaderToNormal();
-
-    const versions = await this.waitForProtocolV2FinalFeatures();
-    this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
-    DevicePool.resetState();
-
-    return versions;
   }
 
-  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;
+  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',
+        }
+      );
     }
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device features not available');
-  }
-
-  private prepareBootloaderBinary(): ArrayBuffer | null {
-    return this.params.bootloaderBinary ?? null;
+    this.protocolV2PreparedSources.push(source);
+    return source;
   }
 
-  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',
-      });
+  private async openProtocolV2MemorySource(binary: ArrayBuffer) {
+    const source = await openFirmwareByteSource({ binary });
+    if (!source) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 firmware binary is empty'
+      );
     }
-
-    installItems.push(...fwBinaryMap.map(item => ({ ...item, kind: 'firmware' as const })));
-    return installItems;
+    this.protocolV2PreparedSources.push(source);
+    return source;
   }
 
-  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 async closeProtocolV2PreparedSources() {
+    const sources = this.protocolV2PreparedSources.splice(0);
+    await Promise.all(sources.map(source => source.close().catch(() => undefined)));
   }
 
-  private getRemoteComponentTarget(key: string, component: IProtocolV2FirmwareComponent) {
-    const targetName = component.target?.toUpperCase();
-    if (targetName === 'ROMLOADER') {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        PROTOCOL_V2_ROMLOADER_UNSUPPORTED_MESSAGE
+  private async prepareProtocolV2InstallSources(
+    firmwareType: EFirmwareType,
+    features: Features
+  ): Promise<ProtocolV2InstallSource[]> {
+    if (this.params.preparedPlan) {
+      const requestedTargets = new Set(
+        this.params.preparedPlan.targetsToUpdate.filter(
+          (target): target is Exclude<FirmwareUpdateV4Target, 'resource'> => target !== 'resource'
+        )
+      );
+      const installSources: ProtocolV2InstallSource[] = [];
+      const preparedTargets = new Set<Exclude<FirmwareUpdateV4Target, 'resource'>>();
+      for (const artifact of this.params.preparedPlan.artifacts) {
+        if (artifact.target !== 'resource') {
+          const target = artifact.target as Exclude<FirmwareUpdateV4Target, 'resource'>;
+          const installTarget = PROTOCOL_V2_INSTALL_TARGET_BY_UPDATE_TARGET.get(target);
+          if (
+            !requestedTargets.has(target) ||
+            artifact.role !== 'component' ||
+            artifact.container !== 'raw' ||
+            !installTarget ||
+            preparedTargets.has(target)
+          ) {
+            throw ERRORS.TypedError(
+              HardwareErrorCode.RuntimeError,
+              `Protocol V2 prepared component artifact is invalid: ${artifact.artifactId}`,
+              { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+            );
+          }
+          installSources.push({
+            ...installTarget,
+            source: await this.openProtocolV2PreparedSource(artifact.artifact),
+          });
+          preparedTargets.add(target);
+        }
+      }
+      const missingTarget = Array.from(requestedTargets).find(
+        target => !preparedTargets.has(target)
       );
+      if (missingTarget) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Protocol V2 ${missingTarget} artifact is not prepared`,
+          {
+            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+            artifactName: missingTarget,
+          }
+        );
+      }
+      return installSources;
     }
-    const target = PROTOCOL_V2_REMOTE_COMPONENT_TARGETS[targetName];
-    if (!target) {
+
+    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+    if (!release) {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
-        `Unsupported Protocol V2 firmware component target: ${key}/${component.target}`
+        'Protocol V2 firmware release is unavailable'
       );
     }
-    return target;
-  }
+    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>();
 
-  private getProtocolV2ResourceFilePath(path: string) {
-    if (path.startsWith('vol')) return path;
-    if (path.startsWith('/')) return `vol0:${path}`;
-    return `vol0:/${path}`;
+    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 prepareProtocolV2LocalMemoryHost({
+    features,
+    firmwareType,
+    availableInstallItems = this.buildProtocolV2InstallItems({
+      bootloaderBinary: this.prepareBootloaderBinary(),
+      fwBinaryMap: this.collectExplicitTargetBinaries(),
+    }),
+  }: {
+    features: Features;
+    firmwareType: EFirmwareType;
+    availableInstallItems?: ProtocolV2InstallItem[];
+  }): Promise<FirmwareUpdateV4MemoryHost> {
+    const requestedComponentTargets = new Set(
+      (this.params.targetsToUpdate ?? []).filter(
+        (target): target is Exclude<FirmwareUpdateV4Target, 'resource' | 'boot_resources'> =>
+          target !== 'resource' && target !== 'boot_resources'
+      )
+    );
+    const localComponentTargets = new Set(
+      availableInstallItems.flatMap(item => {
+        const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
+        return target ? [target] : [];
+      })
+    );
+    const missingTarget = Array.from(requestedComponentTargets).find(
+      target => !localComponentTargets.has(target)
+    );
+    if (missingTarget) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 local update has no binary for requested target ${missingTarget}`,
+        {
+          firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+          artifactName: missingTarget,
+        }
+      );
+    }
+    const installItems = this.filterProtocolV2LocalInstallItems(availableInstallItems);
+
+    const planArtifacts: Parameters<typeof buildProtocolV2LocalFirmwareUpdatePlan>[0]['artifacts'] =
+      [];
+    const memoryArtifacts: FirmwareMemoryArtifact[] = [];
+    for (const item of installItems) {
+      const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
+      if (!target || item.binary.byteLength <= 0) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Protocol V2 local firmware artifact is invalid: ${item.fileName}`,
+          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+        );
+      }
+      const artifactId = `component:${target}`;
+      planArtifacts.push({
+        artifactId,
+        target,
+        container: 'raw',
+        logicalName: item.fileName,
+        expectedSize: item.binary.byteLength,
+        expectedSha256: bytesToHex(sha256(new Uint8Array(item.binary))),
+        ...(this.params.expectedTargetVersions?.[target]
+          ? { targetVersion: this.params.expectedTargetVersions[target] }
+          : {}),
+      });
+      memoryArtifacts.push({ artifactId, binary: item.binary });
+    }
+
+    const resourceArchive = await this.prepareProtocolV2LocalResourceArchive(
+      this.params.resourceArchiveBinary as ArrayBuffer
+    );
+    const resourceArtifactId = 'resource:archive';
+    planArtifacts.push({
+      artifactId: resourceArtifactId,
+      target: 'resource',
+      container: 'zip',
+      logicalName: 'protocol-v2-local-resource-archive',
+      expectedSize: resourceArchive.binary.byteLength,
+      expectedSha256: bytesToHex(sha256(new Uint8Array(resourceArchive.binary))),
+    });
+    memoryArtifacts.push({
+      artifactId: resourceArtifactId,
+      binary: resourceArchive.binary,
+      materializedEntries: resourceArchive.materializedEntries,
+    });
+
+    const plan = buildProtocolV2LocalFirmwareUpdatePlan({
+      features,
+      firmwareType,
+      platform: this.params.platform,
+      artifacts: planArtifacts,
+    });
+    let memoryHost: FirmwareUpdateV4MemoryHost | undefined;
+    try {
+      memoryHost = prepareFirmwareUpdateV4MemoryHost({
+        sdk: {
+          prepareFirmwareUpdatePlan,
+          registerFirmwareUpdateHostBinding,
+          unregisterFirmwareUpdateHostBinding,
+        },
+        plan,
+        artifacts: memoryArtifacts,
+      });
+      const preparedPlan = validateFirmwareUpdatePreparedPlan(memoryHost.preparedPlan);
+      assertFirmwareUpdatePreparedPlanBinding({
+        preparedPlan,
+        executor: 'v4',
+        platform: this.params.platform,
+        scopeTargets: [],
+        bindings: [],
+      });
+      assertFirmwareUpdatePreparedPlanDeviceIdentity({
+        preparedPlan,
+        deviceIdentity: this.protocolV2ExpectedSerialNumber,
+        deviceModel: this.getProtocolV2PreparedPlanDeviceModel(features),
+      });
+      const hostBinding = resolveFirmwareUpdateHostBinding(
+        memoryHost.hostBindingGeneration,
+        preparedPlan.preparedPlanDigest
+      );
+      this.params.preparedPlan = preparedPlan;
+      this.params.targetsToUpdate = [...preparedPlan.targetsToUpdate] as FirmwareUpdateV4Target[];
+      this.params.artifactReader = hostBinding.artifactReader;
+      this.params.componentArtifacts = undefined;
+      return memoryHost;
+    } catch (error) {
+      memoryHost?.release();
+      throw error;
+    }
+  }
+
+  private async prepareProtocolV2LocalResourceArchive(
+    binary: ArrayBuffer
+  ): Promise<ProtocolV2LocalResourceArchive> {
+    if (binary.byteLength <= 0 || binary.byteLength > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 local resource ZIP archive size is invalid',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+    let zip: JSZip;
+    try {
+      zip = await JSZip.loadAsync(binary);
+    } catch {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 resource ZIP cannot be parsed',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+    const zipEntries = Object.values(zip.files);
+    if (
+      zipEntries.some(entry => entry.unsafeOriginalName && entry.unsafeOriginalName !== entry.name)
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 local resource ZIP contains an unsafe entry path',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+    const entries = zipEntries.filter(entry => !entry.dir);
+    if (entries.length === 0) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 local resource ZIP entry set is invalid',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+    const manifestEntry = entries.find(entry => entry.name.split('/').pop() === 'manifest.json');
+    let manifestBinary: ArrayBuffer | undefined;
+    let manifestDirectory = '';
+    let selectedFiles: IProtocolV2ResourceManifestFile[];
+    if (manifestEntry) {
+      if (
+        getProtocolV2ZipEntrySizes(manifestEntry).uncompressedSize >
+        PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
+      ) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Protocol V2 local resource manifest size is invalid',
+          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+        );
+      }
+      manifestBinary = await manifestEntry.async('arraybuffer');
+      if (
+        manifestBinary.byteLength <= 0 ||
+        manifestBinary.byteLength > PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
+      ) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Protocol V2 local resource manifest size is invalid',
+          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+        );
+      }
+      let manifestValue: unknown;
+      try {
+        manifestValue = JSON.parse(new TextDecoder().decode(manifestBinary));
+      } catch (error) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Protocol V2 local resource manifest is invalid: ${String(error)}`,
+          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+        );
+      }
+      selectedFiles = selectProtocolV2ResourceManifestFiles({
+        manifest: parseProtocolV2ResourceManifest(manifestValue),
+        targetsToUpdate: this.params.targetsToUpdate ?? [],
+      });
+      manifestDirectory = manifestEntry.name.slice(0, -'manifest.json'.length);
+    } else {
+      selectedFiles = entries.flatMap(entry => {
+        const archivePath = getProtocolV2LocalResourceArchivePath(entry.name);
+        if (!archivePath) return [];
+        return [
+          {
+            archive_path: archivePath,
+            original_name: archivePath.split('/').pop() ?? archivePath,
+            device_path: `vol0:/${archivePath}`,
+            size: getProtocolV2ZipEntrySizes(entry).uncompressedSize,
+            sha256: '',
+          },
+        ];
+      });
+    }
+    if (selectedFiles.length === 0 || selectedFiles.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 local resource ZIP has no resource packages',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+
+    let totalSize = 0;
+    const materializedEntries: FirmwareMemoryArtifactEntry[] = [];
+    const normalizedFiles: IProtocolV2ResourceManifestFile[] = [];
+    for (const file of selectedFiles) {
+      const entry = manifestEntry
+        ? zip.file(`${manifestDirectory}${file.archive_path}`)
+        : entries.find(
+            candidate => getProtocolV2LocalResourceArchivePath(candidate.name) === file.archive_path
+          );
+      if (!entry) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Protocol V2 local resource ZIP is missing ${file.archive_path}`,
+          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+        );
+      }
+      const { uncompressedSize } = getProtocolV2ZipEntrySizes(entry);
+      totalSize += uncompressedSize;
+      if (uncompressedSize !== file.size || totalSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Protocol V2 local resource file declared size is invalid: ${file.archive_path}`,
+          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+        );
+      }
+      const fileBinary = await entry.async('arraybuffer');
+      const digest = bytesToHex(sha256(new Uint8Array(fileBinary)));
+      if (
+        fileBinary.byteLength !== file.size ||
+        (file.sha256 && digest !== file.sha256.toLowerCase())
+      ) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Protocol V2 local resource file does not match manifest: ${file.archive_path}`,
+          { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
+        );
+      }
+      normalizedFiles.push({ ...file, sha256: digest });
+      materializedEntries.push({ entryName: file.archive_path, binary: fileBinary });
+    }
+    manifestBinary ??= new TextEncoder().encode(JSON.stringify({ files: normalizedFiles })).buffer;
+    materializedEntries.unshift({ entryName: 'manifest.json', binary: manifestBinary });
+    return { binary, materializedEntries };
+  }
+
+  private async prepareProtocolV2ResourceSources(): Promise<ProtocolV2ResourceBundleSource[]> {
+    const resourceRequested = this.params.targetsToUpdate?.includes('resource') ?? false;
+    if (!resourceRequested) {
+      return [];
+    }
+    const archiveSources = await this.prepareProtocolV2ResourceArchiveSources();
+    if (archiveSources) {
+      return archiveSources;
+    }
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Protocol V2 resource archive is not prepared',
+      { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+    );
+  }
+
+  private async prepareProtocolV2ResourceArchiveSources(): Promise<
+    ProtocolV2ResourceBundleSource[] | undefined
+  > {
+    const archiveArtifacts =
+      this.params.preparedPlan?.artifacts.filter(
+        artifact =>
+          artifact.role === 'resourceBundle' &&
+          artifact.target === 'resource' &&
+          artifact.container === 'zip'
+      ) ?? [];
+    if (archiveArtifacts.length === 0) {
+      return undefined;
+    }
+    if (archiveArtifacts.length !== 1) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 prepared plan must contain exactly one resource archive',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+
+    const archiveArtifact = archiveArtifacts[0];
+    const archiveSource = await this.openProtocolV2PreparedSource(archiveArtifact.artifact);
+    if (archiveSource.size > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 prepared resource archive exceeds the total size limit',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+
+    let archiveBinary: ArrayBuffer;
+    try {
+      archiveBinary = await readFirmwareByteSourceFully(archiveSource);
+    } finally {
+      await archiveSource.close();
+    }
+    const archiveDigest = bytesToHex(sha256(new Uint8Array(archiveBinary)));
+    if (archiveDigest !== archiveArtifact.artifact.sha256.toLowerCase()) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 prepared resource archive does not match its approved receipt',
+        { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
+      );
+    }
+
+    // The verified archive bytes are authoritative. Host materialization is an
+    // implementation detail and may preserve wrapper paths or extra metadata files.
+    const verifiedArchive = await this.prepareProtocolV2LocalResourceArchive(archiveBinary);
+    const verifiedEntriesByName = new Map(
+      verifiedArchive.materializedEntries.map(entry => [entry.entryName, entry.binary] as const)
+    );
+    const manifestBinary = verifiedEntriesByName.get('manifest.json');
+    if (!manifestBinary) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 prepared resource archive has no valid manifest.json',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+
+    let manifestValue: unknown;
+    try {
+      manifestValue = JSON.parse(new TextDecoder().decode(manifestBinary));
+    } catch (error) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 prepared resource manifest is invalid: ${String(error)}`,
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+    const manifest = parseProtocolV2ResourceManifest(manifestValue);
+    const selectedFiles = selectProtocolV2ResourceManifestFiles({
+      manifest,
+      targetsToUpdate: this.params.targetsToUpdate ?? [],
+    });
+    if (selectedFiles.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 prepared resource archive contains too many files',
+        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+      );
+    }
+
+    let totalSize = 0;
+    const sources: ProtocolV2ResourceBundleSource[] = [];
+    for (const [index, file] of selectedFiles.entries()) {
+      const binary = verifiedEntriesByName.get(file.archive_path);
+      if (!binary || binary.byteLength !== file.size) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Protocol V2 prepared resource file does not match manifest: ${file.archive_path}`,
+          { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
+        );
+      }
+      totalSize += binary.byteLength;
+      if (totalSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Protocol V2 prepared resource archive exceeds the total size limit',
+          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+        );
+      }
+      // 使用从获批 ZIP 中提取的规范字节，避免宿主在校验后替换 entry reader 内容。
+      const source = await this.openProtocolV2MemorySource(binary);
+      const header =
+        source.size >= PROTOCOL_V2_OKPP_HEADER_SIZE
+          ? parseProtocolV2OkppHeader(
+              new Uint8Array(await source.readAt(0, PROTOCOL_V2_OKPP_HEADER_SIZE))
+            )
+          : null;
+      sources.push({
+        name: file.original_name || `resource-${index}`,
+        source,
+        devicePath: file.device_path,
+        ...(header
+          ? {
+              version: header.version,
+              payloadHash: header.payloadHash,
+              headerHash: header.headerHash,
+            }
+          : {}),
+      });
+    }
+    return sources;
+  }
+
+  private async runProtocolV2PreparedArtifacts(
+    features: Features,
+    firmwareType: EFirmwareType,
+    announceDownload = true
+  ) {
+    try {
+      if (announceDownload) {
+        this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
+      }
+      const installSources = await this.prepareProtocolV2InstallSources(firmwareType, features);
+      const resourceSources = await this.prepareProtocolV2ResourceSources();
+      if (installSources.length === 0 && resourceSources.length === 0) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.FirmwareUpdateDownloadFailed,
+          'No firmware to update'
+        );
+      }
+      if (announceDownload) {
+        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 Exclude<FirmwareUpdateV4Target, 'boot_resources'>
+        ) ||
+        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 deviceInfo = this.protocolV2LatestFinalDeviceInfo;
+    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,
+      app_v1: deviceInfo?.main_mcu?.application?.version,
+      app_v2: deviceInfo?.main_mcu?.application_data?.version,
+      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]]) {
+      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) {
+        const requestedTargetIds = requestedTargets.flatMap(requestedTarget => {
+          if (requestedTarget === 'resource' || requestedTarget === 'boot_resources') return [];
+          const installTarget = PROTOCOL_V2_INSTALL_TARGET_BY_UPDATE_TARGET.get(requestedTarget);
+          return installTarget ? [installTarget.targetId] : [];
+        });
+        const hasCompleteTargetEvidence =
+          requestedTargetIds.length > 0 &&
+          requestedTargetIds.every(targetId => this.protocolV2CompletedTargetIds.has(targetId));
+        if (hasCompleteTargetEvidence) {
+          Log.warn(
+            `Protocol V2 target ${target} has no observable final version; install completion 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)];
+    }
+    if (this.params.preparedPlan?.targetsToUpdate.length) {
+      return [...new Set(this.params.preparedPlan.targetsToUpdate)] as FirmwareUpdateV4Target[];
+    }
+    const targets = new Set<FirmwareUpdateV4Target>();
+    Object.keys(this.params.componentArtifacts ?? {}).forEach(target =>
+      targets.add(target as FirmwareUpdateV4Target)
+    );
+    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> {
+    let { features } = this.device;
+    if (typeof this.device.getFeatures === 'function') {
+      features ??= await this.device.getFeatures();
+    }
+    if (!features) {
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device features not available');
+    }
+    const deviceType = this.device.getCurrentDeviceType();
+    if (deviceType !== EDeviceType.Pro2 && deviceType !== EDeviceType.Neo) {
+      return features;
+    }
+    return {
+      ...features,
+      deviceType,
+      firmwareType: this.device.getCurrentFirmwareType(),
+    };
+  }
+
+  private getProtocolV2SerialNumber(deviceInfo: ProtocolV2DeviceInfo) {
+    const serialNumber = deviceInfo.hw?.serial_no?.trim();
+    return serialNumber || undefined;
+  }
+
+  private getProtocolV2PreparedPlanDeviceModel(features?: Features) {
+    const currentDeviceType = this.device.getCurrentDeviceType();
+    const featureDeviceType = features ? getDeviceType(features) : undefined;
+    const deviceType =
+      currentDeviceType === EDeviceType.Pro2 || currentDeviceType === EDeviceType.Neo
+        ? currentDeviceType
+        : featureDeviceType;
+    return deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo
+      ? String(deviceType)
+      : undefined;
+  }
+
+  private getProtocolV2ConnectionRoute() {
+    const descriptor = this.device.originalDescriptor;
+    return (
+      descriptor?.path?.trim() ||
+      this.device.getConnectId?.()?.trim() ||
+      descriptor?.id?.trim() ||
+      undefined
+    );
+  }
+
+  private assertProtocolV2DeviceInfoIdentity(deviceInfo: ProtocolV2DeviceInfo) {
+    assertProtocolV2ReconnectIdentity(
+      this.protocolV2ExpectedSerialNumber,
+      this.getProtocolV2SerialNumber(deviceInfo),
+      this.protocolV2ExpectedPath,
+      this.getProtocolV2ConnectionRoute()
+    );
+  }
+
+  private getProtocolV2DeviceInfoTimeout() {
+    return this.isBleReconnect()
+      ? this.payload.protocolV2DeviceInfoTimeoutMs ?? PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT
+      : PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT;
+  }
+
+  private async requestProtocolV2PhysicalIdentity() {
+    return requestProtocolV2DeviceInfo({
+      commands: this.device.getCommands(),
+      timeoutMs: this.getProtocolV2DeviceInfoTimeout(),
+    });
+  }
+
+  private async captureProtocolV2PhysicalIdentity() {
+    const deviceInfo = await this.requestProtocolV2PhysicalIdentity();
+    const serialNumber = this.getProtocolV2SerialNumber(deviceInfo);
+    const path = this.getProtocolV2ConnectionRoute();
+    if (this.params?.preparedPlan) {
+      assertFirmwareUpdatePreparedPlanDeviceIdentity({
+        preparedPlan: this.params.preparedPlan,
+        deviceIdentity: serialNumber,
+        deviceModel: this.getProtocolV2PreparedPlanDeviceModel(this.device.features),
+      });
+    } else if (this.params?.expectedDeviceId) {
+      assertProtocolV2ReconnectIdentity(this.params?.expectedDeviceId, serialNumber);
+    } else {
+      assertProtocolV2ReconnectIdentity(serialNumber, serialNumber, path, path);
+    }
+    this.protocolV2ExpectedSerialNumber = serialNumber;
+    this.protocolV2ExpectedPath = path;
+  }
+
+  private async verifyProtocolV2ReconnectIdentity() {
+    const deviceInfo = await this.requestProtocolV2PhysicalIdentity();
+    this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
+    return deviceInfo;
+  }
+
+  private prepareBootloaderBinary(): ArrayBuffer | null {
+    return this.params.bootloaderBinary ?? null;
+  }
+
+  private getMissingProtocolV2FirmwareTargets(installItems: ProtocolV2InstallItem[]) {
+    const preparedTargets = new Set(
+      installItems.flatMap(item => {
+        const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
+        return target ? [target] : [];
+      })
+    );
+    return (this.params.targetsToUpdate ?? [])
+      .filter(
+        (target): target is Exclude<FirmwareUpdateV4Target, 'resource' | 'boot_resources'> =>
+          target !== 'resource' && target !== 'boot_resources'
+      )
+      .filter(target => !preparedTargets.has(target));
+  }
+
+  private filterProtocolV2LocalInstallItems(installItems: ProtocolV2InstallItem[]) {
+    if (!this.protocolV2HasExplicitTargetSelection) {
+      return installItems;
+    }
+    const requestedTargets = new Set(this.params.targetsToUpdate ?? []);
+    return installItems.filter(item => {
+      const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
+      return target !== undefined && requestedTargets.has(target);
+    });
+  }
+
+  private buildProtocolV2InstallItems({
+    bootloaderBinary,
+    fwBinaryMap,
+  }: {
+    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 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;
+  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 chunkSize = this.getProtocolV2FirmwareChunkSize();
-    const chunks: Uint8Array[] = [];
-    let offset = 0;
-    while (offset < PROTOCOL_V2_OKPP_HEADER_SIZE) {
-      const readLen = Math.min(chunkSize, PROTOCOL_V2_OKPP_HEADER_SIZE - offset);
-      const res = await typedCall('FilesystemFileRead', 'FilesystemFile', {
-        file: {
-          path: filePath,
-          offset,
-          total_size: 0,
-        },
-        chunk_len: readLen,
-        ui_percentage: undefined,
-      });
-      const data = toProtocolV2Bytes(res.message?.data);
-      if (data.byteLength === 0) return null;
-      chunks.push(data);
-      offset += data.byteLength;
+    const target = PROTOCOL_V2_REMOTE_COMPONENT_TARGETS[targetName];
+    if (!target) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Unsupported Protocol V2 firmware component target: ${key}/${component.target}`
+      );
     }
-
-    const headerBytes = new Uint8Array(offset);
-    let cursor = 0;
-    chunks.forEach(chunk => {
-      headerBytes.set(chunk, cursor);
-      cursor += chunk.byteLength;
-    });
-    return parseProtocolV2OkppHeader(headerBytes);
+    return target;
   }
 
   private async downloadRemoteProtocolV2Component(
@@ -691,15 +1879,87 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         `Missing Protocol V2 firmware component url: ${key}/${component.target}`
       );
     }
+    const expectedFingerprint = normalizeProtocolV2Hex(component.fingerprint);
+    if (
+      !Number.isSafeInteger(component.expectedSize) ||
+      Number(component.expectedSize) <= 0 ||
+      !expectedFingerprint ||
+      !/^[0-9a-f]{64}$/u.test(expectedFingerprint)
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 firmware component integrity metadata is invalid: ${key}/${component.target}`,
+        { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+      );
+    }
 
     const { binary } = await getSysResourceBinary(component.url);
+    if (binary.byteLength !== component.expectedSize) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 firmware size mismatch: ${key}/${component.target}`,
+        { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
+      );
+    }
+    if (!isProtocolV2FirmwareFingerprintValid(binary, component.fingerprint)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 firmware fingerprint mismatch: ${key}/${component.target}`
+      );
+    }
     return {
       ...target,
       binary,
     };
   }
 
-  private async prepareRemoteProtocolV2Binaries(firmwareType: EFirmwareType, features: Features) {
+  private async downloadRemoteProtocolV2ResourceArchive(
+    features: Features,
+    firmwareType: EFirmwareType
+  ): Promise<ArrayBuffer> {
+    const deviceType = getDeviceType(features);
+    if (deviceType !== EDeviceType.Pro2 && deviceType !== EDeviceType.Neo) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 resource archive requires a Pro2 or Neo device'
+      );
+    }
+    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+    const source = DataManager.getProtocolV2ResourceSource(release);
+    const expectedSha256 = normalizeProtocolV2Hex(source?.archiveSha256);
+    if (
+      !source?.archiveUrl ||
+      !Number.isSafeInteger(source.archiveSize) ||
+      source.archiveSize <= 0 ||
+      source.archiveSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES ||
+      !expectedSha256 ||
+      !/^[0-9a-f]{64}$/u.test(expectedSha256)
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 resource archive integrity metadata is invalid',
+        { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+      );
+    }
+    const { binary } = await getSysResourceBinary(source.archiveUrl);
+    if (
+      binary.byteLength !== source.archiveSize ||
+      bytesToHex(sha256(new Uint8Array(binary))) !== expectedSha256
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 resource archive does not match the remote config',
+        { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
+      );
+    }
+    return binary;
+  }
+
+  private async prepareRemoteProtocolV2Binaries(
+    firmwareType: EFirmwareType,
+    features: Features,
+    explicitInstallItems: ProtocolV2InstallItem[] = []
+  ) {
     const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
 
     let bootloaderBinary: ArrayBuffer | null = null;
@@ -707,6 +1967,15 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const installItems: ProtocolV2InstallItem[] = [];
 
     if (!release) {
+      const missingFirmwareTargets = this.getMissingProtocolV2FirmwareTargets(explicitInstallItems);
+      if (missingFirmwareTargets.length > 0) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Protocol V2 firmware release is unavailable for requested targets: ${missingFirmwareTargets.join(
+            ', '
+          )}`
+        );
+      }
       return {
         bootloaderBinary,
         fwBinaryMap,
@@ -716,33 +1985,52 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     const entries = this.getRemoteComponentEntries(release);
     const targetsToUpdate = new Set(this.params.targetsToUpdate ?? []);
+    const explicitInstallItemByTargetId = new Map(
+      explicitInstallItems.map(item => [item.targetId, item] as const)
+    );
+    const preparedTargets = new Set<FirmwareUpdateV4Target>();
 
     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,
-          });
+      const targetName = component.target?.toUpperCase();
+      const target = PROTOCOL_V2_REMOTE_COMPONENT_TARGETS[targetName];
+      const updateTarget = target
+        ? PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId)
+        : undefined;
+      if (updateTarget && targetsToUpdate.has(updateTarget)) {
+        const explicitInstallItem = explicitInstallItemByTargetId.get(target.targetId);
+        let installItem = explicitInstallItem;
+        if (!installItem) {
+          installItem = await this.downloadRemoteProtocolV2Component(key, component);
+          if (component.version) {
+            this.params.expectedTargetVersions ??= {};
+            this.params.expectedTargetVersions[updateTarget] = component.version.join('.');
+          }
+        }
+        if (installItem.kind === 'bootloader') {
+          bootloaderBinary = installItem.binary;
         } else {
           const binaryEntry = {
-            fileName: remoteBinary.fileName,
-            binary: remoteBinary.binary,
-            targetId: remoteBinary.targetId,
+            fileName: installItem.fileName,
+            binary: installItem.binary,
+            targetId: installItem.targetId,
           };
           fwBinaryMap.push(binaryEntry);
-          installItems.push({ ...binaryEntry, kind: remoteBinary.kind });
         }
+        installItems.push({ ...installItem });
+        preparedTargets.add(updateTarget);
       }
     }
 
+    const missingTarget = Array.from(targetsToUpdate).find(
+      target => target !== 'resource' && !preparedTargets.has(target)
+    );
+    if (missingTarget) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 release does not contain requested target ${missingTarget}`
+      );
+    }
+
     return {
       bootloaderBinary,
       fwBinaryMap,
@@ -750,144 +2038,83 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     };
   }
 
-  // ============================================================
-  // RESC bundle 直写增量同步（FileRead 比对 + FilesystemFileWrite 直写）
-  // ============================================================
-
-  /**
-   * 准备 RESC bundle 列表。
-   *
-   * 两种模式（同 FirmwareUpdateV3 的 binary vs version 模式）：
-   * - 用户传了 resourceBundleFiles（binary 数组）：直接用，不做版本比对。
-   * - 用户没传：从远端 config.json 的 release.resourceBundles 拉取，
-   *   此时 syncProtocolV2ResourceBundles 会按需下载 + 比对设备已有 header 跳过。
-   */
-  private prepareProtocolV2ResourceBundles(
-    firmwareType: EFirmwareType,
-    features: Features
-  ): ProtocolV2ResourceBundleBinary[] | undefined {
-    // 模式1：用户手动传入 binary，直接安装，不比对
-    if (this.params.resourceBundleFiles?.length) {
-      return this.params.resourceBundleFiles.map(file => ({
-        name: file.devicePath.split('/').pop() ?? file.devicePath,
-        binary: file.binary,
-        devicePath: file.devicePath,
-      }));
-    }
-
-    if (!this.params.targetsToUpdate?.includes('resource')) {
-      return undefined;
-    }
-
-    // 模式2：远端配置模式，后续按需下载 + 比对
-    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
-    if (!release?.resourceBundles?.length) return undefined;
-
-    return release.resourceBundles.map(bundle => ({
-      name: bundle.name,
-      binary: new ArrayBuffer(0),
-      devicePath: bundle.devicePath,
-      url: bundle.url,
-      version: bundle.version,
-      payloadHash: bundle.payloadHash,
-      headerHash: bundle.headerHash,
-    })) as ProtocolV2ResourceBundleBinary[];
+  private getProtocolV2ResourceFilePath(path: string) {
+    if (path.startsWith('vol')) return path;
+    if (path.startsWith('/')) return `vol0:${path}`;
+    return `vol0:/${path}`;
   }
 
-  /**
-   * 同步 RESC bundles 到设备。
-   *
-   * 手动传入模式（有 binary）：直接 FileWrite 直写，不比对。
-   * 远端配置模式（无 binary，有 url）：按需下载 + FileRead 比对跳过已更新的。
-   */
-  private async syncProtocolV2ResourceBundles(
-    bundles: ProtocolV2ResourceBundleBinary[],
-    firmwareSize: number
-  ): Promise<{ processedSize: number; totalSize: number }> {
-    const transferStartTime = Date.now();
-    const transferTransport = this.getProtocolV2FirmwareTransferTransport();
-
-    const isManualMode = bundles.every(b => b.binary.byteLength > 0);
-    let bundlesToSync = bundles;
-
-    // 远端配置模式：按需下载 + 比对跳过
-    if (!isManualMode) {
-      const filtered: ProtocolV2ResourceBundleBinary[] = [];
-      for (const bundle of bundles) {
-        // 下载 binary
-        if (bundle.binary.byteLength === 0 && bundle.url) {
-          Log.log(`[FirmwareUpdateV4] downloading RESC bundle ${bundle.name} from ${bundle.url}`);
-          const { binary } = await getSysResourceBinary(bundle.url);
-          bundle.binary = binary;
-        }
-        // 比对设备上已有 header
-        const upToDate = await this.isProtocolV2ResourceBundleUpToDate(bundle);
-        if (upToDate) {
-          Log.log(`[FirmwareUpdateV4] skip RESC bundle ${bundle.name}; already up to date`);
-        } else {
-          filtered.push(bundle);
-        }
-      }
-      bundlesToSync = filtered;
-    }
-
-    if (bundlesToSync.length === 0) {
-      Log.log('[FirmwareUpdateV4] all RESC bundles up to date, nothing to sync');
-      return { processedSize: 0, totalSize: firmwareSize };
+  private async readProtocolV2DeviceFileHeader(path: string, expectedSize?: number) {
+    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 ||
+      (expectedSize !== undefined && fileSize !== expectedSize)
+    ) {
+      return null;
     }
 
-    // FileWrite 直写到设备
-    let totalSize = 0;
-    for (const b of bundlesToSync) totalSize += b.binary.byteLength;
-
-    const transferTotalSize = totalSize + firmwareSize;
-    let processedSize = 0;
-    for (const bundle of bundlesToSync) {
-      Log.log(
-        `[FirmwareUpdateV4] syncing RESC bundle ${bundle.name} -> ${bundle.devicePath} bytes=${bundle.binary.byteLength}`
-      );
-      processedSize = await this.protocolV2CommonUpdateProcess({
-        payload: bundle.binary,
-        filePath: bundle.devicePath,
-        processedSize,
-        totalSize: transferTotalSize,
+    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 elapsedMs = Date.now() - transferStartTime;
-    Log.log(
-      `[FirmwareUpdateV4] RESC bundle sync finished transport=${transferTransport} bytes=${totalSize} elapsed=${(
-        elapsedMs / 1000
-      ).toFixed(2)}s speed=${formatProtocolV2TransferSpeed(totalSize, elapsedMs)} KB/s`
-    );
-    return { processedSize, totalSize: transferTotalSize };
+    const headerBytes = new Uint8Array(offset);
+    let cursor = 0;
+    chunks.forEach(chunk => {
+      headerBytes.set(chunk, cursor);
+      cursor += chunk.byteLength;
+    });
+    return parseProtocolV2OkppHeader(headerBytes);
   }
 
-  /**
-   * 比对设备上已有 okpkg 的 OKPP header（仅远端配置模式使用）。
-   */
+  /** Compare the downloaded and installed okpkg headers before transferring a resource. */
   private async isProtocolV2ResourceBundleUpToDate(
-    bundle: ProtocolV2ResourceBundleBinary
+    bundle: Pick<
+      ProtocolV2ResourceBundleSource,
+      'name' | 'source' | 'devicePath' | 'version' | 'payloadHash' | 'headerHash'
+    >
   ): Promise<boolean> {
-    if (this.params.forcedUpdateRes) return false;
-    if (!bundle.version && !bundle.payloadHash) return false;
+    if (this.params?.forcedUpdateRes) return false;
+    if (!bundle.payloadHash || !bundle.headerHash) return false;
 
     try {
-      const header = await this.readProtocolV2DeviceFileHeader(bundle.devicePath);
+      const header = await this.readProtocolV2DeviceFileHeader(
+        bundle.devicePath,
+        bundle.source.size
+      );
       if (!header) return false;
 
       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;
-      }
+      const expectedPayloadHash = normalizeProtocolV2Hex(bundle.payloadHash);
+      const expectedHeaderHash = normalizeProtocolV2Hex(bundle.headerHash);
+      if (!expectedPayloadHash || header.payloadHash !== expectedPayloadHash) return false;
+      if (!expectedHeaderHash || header.headerHash !== expectedHeaderHash) return false;
       return true;
     } catch (error) {
       Log.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
@@ -897,23 +2124,36 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private isProtocolV2BootloaderMode() {
     if (typeof this.device.isBootloader === 'function') {
-      return this.device.isBootloader();
+      return !!this.device.isBootloader();
     }
-    return !!this.device.features?.bootloaderMode;
+    return (
+      this.device.features?.mode === 'bootloader' ||
+      (this.device.features?.mode == null && !!this.device.features?.bootloaderMode)
+    );
   }
 
-  async enterProtocolV2BootloaderMode() {
-    if (this.isProtocolV2BootloaderMode()) {
-      Log.debug('Protocol V2 device is already in bootloader mode, skip reboot to bootloader');
+  private isProtocolV2RomloaderMode() {
+    const deviceType = this.device.getCurrentDeviceType();
+    if (
+      !this.device.isProtocolV2() ||
+      (deviceType !== EDeviceType.Pro2 && deviceType !== EDeviceType.Neo)
+    ) {
       return false;
     }
+    if (typeof this.device.isRomloader === 'function') {
+      return this.device.isRomloader();
+    }
+    return this.device.features?.mode === 'romloader';
+  }
 
+  private async rebootProtocolV2ToBootloader() {
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.AutoRebootToBootloader);
       await this.protocolV2Reboot(DeviceRebootType.Bootloader);
-      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
       await wait(1000);
       await this.waitForProtocolV2BootloaderMode();
+      this.protocolV2ExecutionInLoader = true;
+      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
       return true;
     } catch (error) {
       if (error instanceof HardwareError) {
@@ -924,30 +2164,56 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
   }
 
+  async enterProtocolV2BootloaderMode() {
+    // romloader is the first update environment and forwards targets to bootloader.
+    // It rejects DeviceRebootType.Bootloader, so reuse the current connection.
+    if (this.isProtocolV2RomloaderMode()) {
+      Log.debug('Protocol V2 device is in romloader mode; start firmware update directly');
+      this.protocolV2ExecutionInLoader = true;
+      return false;
+    }
+    if (this.isProtocolV2BootloaderMode()) {
+      Log.debug('Protocol V2 device is already in bootloader mode, skip reboot');
+      this.protocolV2ExecutionInLoader = true;
+      this.postTipMessage(FirmwareUpdateTipMessage.GoToBootloaderSuccess);
+      return false;
+    }
+
+    return this.rebootProtocolV2ToBootloader();
+  }
+
   private async waitForProtocolV2BootloaderMode(
     timeout = PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT,
     retryInterval = 1000
   ) {
     const startTime = Date.now();
     let lastError: unknown;
+    let shouldReconnect = true;
 
     while (Date.now() - startTime < timeout) {
       try {
-        await this.reconnectProtocolV2Device();
+        if (shouldReconnect) {
+          await this.reconnectProtocolV2Device();
+          shouldReconnect = false;
+        }
         const deviceInfo = await requestProtocolV2DeviceInfo({
           commands: this.device.getCommands(),
-          timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+          timeoutMs: this.getProtocolV2DeviceInfoTimeout(),
         });
-        const features = this.device.updateProtocolV2Features(deviceInfo);
-        assertProtocolV2ReconnectIdentity(
-          this.protocolV2ExpectedDeviceId,
-          features.deviceId ?? undefined
+        this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
+        const features = await this.device.probeProtocolV2RuntimeState(
+          deviceInfo,
+          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
         );
-        if (features?.bootloaderMode) {
+        if (features?.mode === 'bootloader') {
           return features;
         }
         lastError = new Error('Protocol V2 device is reachable but is not in bootloader mode');
       } catch (error) {
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
+          throw error;
+        }
+        shouldReconnect = true;
         lastError = error;
         Log.log('Protocol V2 bootloader mode not ready, polling reconnect: ', error);
       }
@@ -963,8 +2229,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   /**
-   * 收集按 DeviceFirmwareTargetType 拆分的显式目标二进制。
-   * 文件名仅用于 staging 路径展示，target_id 已显式给定。
+   * Collect explicit target binaries grouped by DeviceFirmwareTargetType.
+   * Filenames are display-only staging paths because target_id is explicit.
    */
   private collectExplicitTargetBinaries() {
     const entries: ProtocolV2TargetBinary[] = [];
@@ -1000,115 +2266,249 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return entries;
   }
 
+  private async executeProtocolV2SourceUpdate({
+    installSources,
+    resourceSources,
+  }: {
+    installSources: ProtocolV2InstallSource[];
+    resourceSources: ProtocolV2ResourceBundleSource[];
+  }) {
+    this.protocolV2BootResourceStagingSafe = false;
+    if (installSources.length > 0 || resourceSources.length > 0) {
+      await this.enterProtocolV2BootloaderMode();
+      // Clear stale boot-resource staging before writing any artifacts. The new
+      // boot resource, resources and firmware then share one transfer session,
+      // one global progress range and one multi-target install request.
+      // Preserve the approved source order instead of synthesizing a boot-first
+      // phase. Loader firmware owns the cross-stage handoff: bootloader runs its
+      // component targets and leaves boot pending for romloader, while pending
+      // runner-backed records always resume before the application boots.
+      await this.ensureProtocolV2BootResourceStagingIsEmpty();
+      await this.executeProtocolV2TransferPhase({
+        installSources,
+        resourceSources,
+      });
+    }
+    return this.completeProtocolV2FinalVerification();
+  }
+
+  private async ensureProtocolV2BootResourceStagingIsEmpty() {
+    if (this.protocolV2BootResourceStagingSafe) return;
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+    const query = () =>
+      typedCall('FilesystemPathInfoQuery', 'FilesystemPathInfo', {
+        path: PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH,
+      });
+    const current = await query();
+    if (current.message?.exist) {
+      if (current.message.directory) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.EmmcFileWriteFirmwareError,
+          'Protocol V2 boot resource staging path is not a file'
+        );
+      }
+      await typedCall('FilesystemFileDelete', 'Success', {
+        path: PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH,
+      });
+      const remaining = await query();
+      if (remaining.message?.exist) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.EmmcFileWriteFirmwareError,
+          'Protocol V2 stale boot resource staging file could not be removed'
+        );
+      }
+    }
+    this.protocolV2BootResourceStagingSafe = true;
+  }
+
   private async executeProtocolV2Update({
     fwBinaryMap,
     bootloaderBinary,
     installItems,
-    resourceBundles,
   }: {
     fwBinaryMap?: ProtocolV2TargetBinary[];
     bootloaderBinary?: ArrayBuffer | null;
     installItems?: ProtocolV2InstallItem[];
-    resourceBundles?: ProtocolV2ResourceBundleBinary[];
   }) {
-    const orderedInstallItems =
+    const memoryInstallItems =
       installItems ??
       this.buildProtocolV2InstallItems({
-        bootloaderBinary: bootloaderBinary ?? null,
         fwBinaryMap: fwBinaryMap ?? [],
+        bootloaderBinary: bootloaderBinary ?? null,
       });
-
-    let firmwareSize = 0;
-    for (const item of orderedInstallItems) firmwareSize += item.binary.byteLength;
-
-    this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
-
-    let processedSize = 0;
-    let totalSize = firmwareSize;
-    if (resourceBundles?.length) {
-      const resourceTransfer = await this.syncProtocolV2ResourceBundles(
-        resourceBundles,
-        firmwareSize
+    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,
+        }))
       );
-      processedSize = resourceTransfer.processedSize;
-      totalSize = resourceTransfer.totalSize;
+      return await this.executeProtocolV2SourceUpdate({
+        installSources,
+        resourceSources: [],
+      });
+    } finally {
+      await this.closeProtocolV2PreparedSources();
     }
+  }
 
-    // 只有 RESC bundle、没有固件 target 时跳过 staging/install 阶段
-    if (orderedInstallItems.length === 0) {
-      Log.log('[FirmwareUpdateV4] no firmware targets to install (RESC bundles only)');
-      if (totalSize > 0) {
-        this.postProgressMessage(100, 'transferData');
+  private async executeProtocolV2TransferPhase({
+    installSources,
+    resourceSources,
+  }: ProtocolV2TransferBatch) {
+    let totalSize = installSources.reduce((total, item) => total + item.source.size, 0);
+    const resourcesToSync: ProtocolV2ResourceBundleSource[] = [];
+    for (const resource of resourceSources) {
+      // Early boot promotes this mounted package's staging file. Always replace any
+      // stale staging bytes with the artifact approved by the current PreparedPlan,
+      // even when the mounted final file itself is already current.
+      const requiresFreshStaging = isProtocolV2BootResourcePackagePath(resource.devicePath);
+      if (!requiresFreshStaging && (await this.isProtocolV2ResourceBundleUpToDate(resource))) {
+        Log.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
+      } else {
+        resourcesToSync.push(resource);
+        totalSize += resource.source.size;
       }
-      return;
     }
-    let transferredSize = processedSize;
-    const transferStartTime = Date.now();
-    const transferTransport = this.getProtocolV2FirmwareTransferTransport();
-    const chunkSize = this.getProtocolV2FirmwareChunkSize();
-    const onTransferredBytes = (bytes: number) => {
-      transferredSize = bytes;
-    };
-    Log.log(
-      `[FirmwareUpdateV4] transfer started transport=${transferTransport} total=${totalSize} bytes chunk=${chunkSize} bytes`
-    );
-
-    const stagedInstallTargets: ProtocolV2InstallTarget[] = [];
-
-    try {
-      for (const item of orderedInstallItems) {
-        const filePath = this.getProtocolV2InstallItemStagingPath(item);
-        Log.log(
-          `[FirmwareUpdateV4] staging ${item.kind} via FilesystemFileWrite target=${item.targetId} path=${filePath} source=${item.fileName} bytes=${item.binary.byteLength}`
-        );
-        processedSize = await this.protocolV2CommonUpdateProcess({
-          payload: item.binary,
-          filePath,
-          processedSize,
-          totalSize,
-          onTransferredBytes,
-        });
-        transferredSize = processedSize;
-        await this.verifyProtocolV2StagedFile(filePath, item.binary.byteLength);
-
-        stagedInstallTargets.push({
-          ...item,
-          path: filePath,
-        });
-      }
 
-      if (totalSize > 0) {
-        this.postProgressMessage(100, 'transferData');
+    this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
+    this.protocolV2LastTransferProgress = undefined;
+    this.protocolV2LastTransferProgressAt = 0;
+    let processedSize = 0;
+    for (const resource of resourcesToSync) {
+      // The bootloader keeps its live resource package mounted. FatFs rejects
+      // replacing an open file, so early boot promotes this staging file before mounting it.
+      const writePath = resolveProtocolV2ResourceWritePath(resource.devicePath);
+      processedSize = await this.protocolV2SourceUpdateProcess({
+        source: resource.source,
+        filePath: writePath,
+        processedSize,
+        totalSize,
+      });
+      await this.verifyProtocolV2StagedFile(writePath, resource.source.size);
+      if (isProtocolV2BootResourcePackagePath(resource.devicePath)) {
+        this.protocolV2BootResourceStagingSafe = true;
       }
+    }
 
-      const elapsedMs = Date.now() - transferStartTime;
-      Log.log(
-        `[FirmwareUpdateV4] transfer finished transport=${transferTransport} bytes=${totalSize} elapsed=${(
-          elapsedMs / 1000
-        ).toFixed(2)}s speed=${formatProtocolV2TransferSpeed(totalSize, elapsedMs)} KB/s`
-      );
-    } catch (error) {
-      const elapsedMs = Date.now() - transferStartTime;
-      Log.warn(
-        `[FirmwareUpdateV4] transfer failed transport=${transferTransport} bytes=${transferredSize}/${totalSize} elapsed=${(
-          elapsedMs / 1000
-        ).toFixed(2)}s speed=${formatProtocolV2TransferSpeed(transferredSize, elapsedMs)} KB/s`
-      );
-      throw error;
+    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,
+      });
+      await this.verifyProtocolV2StagedFile(filePath, item.source.size);
+      stagedInstallTargets.push({
+        targetId: item.targetId,
+        path: filePath,
+      });
     }
 
-    this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
+    if (totalSize > 0) {
+      this.postProgressMessage(100, 'transferData');
+    }
+    if (stagedInstallTargets.length === 0) {
+      return;
+    }
 
-    const allTargets = stagedInstallTargets.map(item => ({
+    this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
+    const targets = stagedInstallTargets.map(item => ({
       target_id: item.targetId,
       path: item.path,
     }));
-    Log.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateRequest targets=${JSON.stringify(allTargets)}`);
-    const startResponse = await this.protocolV2StartFirmwareUpdate({ targets: allTargets });
-    await this.waitForProtocolV2FirmwareUpdateComplete(allTargets, startResponse);
+    try {
+      await this.protocolV2StartFirmwareUpdate({ targets });
+      await wait(PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY);
+      await this.waitForProtocolV2FirmwareUpdateComplete(targets, true);
+    } finally {
+      this.device?.clearCancelableAction();
+    }
+  }
+
+  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 {
+        const transferStartedAt = Date.now();
+        await writeFirmwareByteSource({
+          source,
+          chunkSize: this.getProtocolV2FirmwareChunkSize('write', filePath),
+          write: async ({ data, sourceOffset, length, first }) => {
+            const chunkEnd = sourceOffset + length;
+            const deviceProgress = getProtocolV2DeviceTransferProgress(
+              processedSize + sourceOffset,
+              processedSize + chunkEnd,
+              totalSize
+            );
+            const response = await this.fileWriteChunk(
+              filePath,
+              source.size,
+              sourceOffset,
+              data,
+              first,
+              deviceProgress
+            );
+            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}`
+              );
+            }
+            const transferredBytes = processedSize + chunkEnd;
+            const now = Date.now();
+            const elapsedMs = Math.max(now - transferStartedAt, 0);
+            const progress = Math.min(Math.ceil((transferredBytes / totalSize) * 100), 99);
+            const shouldPostProgress =
+              progress !== this.protocolV2LastTransferProgress ||
+              now - this.protocolV2LastTransferProgressAt >=
+                PROTOCOL_V2_TRANSFER_PROGRESS_HEARTBEAT_MS ||
+              chunkEnd === source.size;
+            if (shouldPostProgress) {
+              this.protocolV2LastTransferProgress = progress;
+              this.protocolV2LastTransferProgressAt = now;
+              this.postProgressMessage(progress, 'transferData', {
+                transferredBytes,
+                totalBytes: totalSize,
+                rateBytesPerSecond:
+                  elapsedMs > 0 ? Math.round((chunkEnd / elapsedMs) * 1000) : undefined,
+                elapsedMs,
+              });
+            }
+            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 getProtocolV2InstallItemStagingPath(item: ProtocolV2InstallItem) {
+  private getProtocolV2InstallItemStagingPath(item: Pick<ProtocolV2InstallItem, 'fileName'>) {
     return `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}${item.fileName}`;
   }
 
@@ -1125,172 +2525,423 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
   }
 
-  private async queryProtocolV2FirmwareUpdateStatus() {
-    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    return typedCall(
-      'DeviceFirmwareUpdateStatusGet',
-      'DeviceFirmwareUpdateStatus',
-      {},
-      {
-        timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
-      }
-    );
-  }
-
-  private async pingProtocolV2Device() {
-    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    await typedCall(
-      'Ping',
-      'Success',
-      { message: 'firmware-update' },
-      {
-        timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
-      }
-    );
-  }
-
-  private isProtocolV2NormalModeFeatures(features?: Features | null) {
-    return !!features && !features.bootloaderMode && features.mode !== 'bootloader';
-  }
-
-  private async probeProtocolV2NormalMode() {
-    const deviceInfo = await requestProtocolV2DeviceInfo({
-      commands: this.device.getCommands(),
-      timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
-      request: PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
-    });
-    const features = this.device.updateProtocolV2Features(deviceInfo);
-    assertProtocolV2ReconnectIdentity(
-      this.protocolV2ExpectedDeviceId,
-      features.deviceId ?? undefined
-    );
-    if (this.isProtocolV2NormalModeFeatures(features)) {
-      Log.log('Protocol V2 firmware install finished; device is back in normal mode');
-      return true;
-    }
-    return false;
-  }
-
   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(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 install failed',
+        {
+          firmwareUpdateCode: PROTOCOL_V2_INSTALL_FAILED_CODE,
+        }
       );
     }
 
-    const completedTargets = statusTargets.filter(
-      target =>
-        expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1) &&
-        isProtocolV2TargetStatusFinished(target.status)
+    const matchingTargets = statusTargets.filter(target =>
+      expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1)
     );
-    if (completedTargets.length === expectedTargetIds.size && expectedTargetIds.size > 0) {
+    const 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))
+      ) {
+        Log.error(`[FirmwareUpdateV4] install status conflicts with target=${target.target_id}`);
+        throw ERRORS.TypedError(
+          HardwareErrorCode.FirmwareError,
+          'Protocol V2 firmware install status conflict',
+          {
+            firmwareUpdateCode: PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE,
+          }
+        );
+      }
+      seenTargetIds.add(targetId);
+    }
+    const completedTargets = matchingTargets.filter(target =>
+      isProtocolV2TargetStatusFinished(target.status)
+    );
+    const completedTargetIds = new Set<number>();
+    completedTargets.forEach(target => {
+      const targetId = normalizeProtocolV2TargetId(target.target_id);
+      if (targetId !== undefined) {
+        completedTargetIds.add(targetId);
+        this.protocolV2CompletedTargetIds.add(targetId);
+      }
+    });
+    if (completedTargetIds.size === 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(normalizeProtocolV2TargetId(target.target_id) ?? -1) &&
+    if (expectedTargetIds.size > 0 && matchingTargets.length > 0) {
+      const hasInProgressTarget = matchingTargets.some(target =>
         isProtocolV2TargetStatusInProgress(target.status)
-    );
-    if (inProgressTarget) {
-      this.postProgressMessage(99, 'installingFirmware');
+      );
+      const completedProgress = Math.floor(
+        (completedTargetIds.size / expectedTargetIds.size) * 100
+      );
+      // The protocol exposes no per-target percentage, so report coarse progress by
+      // completed targets and use 1% once work starts to keep the UI responsive.
+      const progress = Math.min(99, Math.max(completedProgress, hasInProgressTarget ? 1 : 0));
+      this.postProgressMessage(progress, 'installingFirmware');
     }
 
     return false;
   }
 
+  private getProtocolV2MissingTargetIds(
+    statusTargets: ProtocolV2FirmwareUpdateStatusTarget[],
+    expectedTargetIds: Set<number>
+  ) {
+    const reportedTargetIds = new Set<number>();
+    statusTargets.forEach(target => {
+      const targetId = normalizeProtocolV2TargetId(target.target_id);
+      if (targetId !== undefined) {
+        reportedTargetIds.add(targetId);
+      }
+    });
+    return Array.from(expectedTargetIds).filter(targetId => !reportedTargetIds.has(targetId));
+  }
+
+  private getProtocolV2ObservableTargetVersions(features: Features) {
+    const versions = new Map<number, string>();
+    versions.set(
+      ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER,
+      getDeviceBootloaderVersion(features).join('.')
+    );
+    const applicationVersion = getDeviceFirmwareVersion(features).join('.');
+    versions.set(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1, applicationVersion);
+    versions.set(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2, applicationVersion);
+    versions.set(
+      ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR,
+      getDeviceBLEFirmwareVersion(features).join('.')
+    );
+    const secureElementVersions: Array<[number, string | null | undefined]> = [
+      [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01, features.se01Version],
+      [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02, features.se02Version],
+      [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03, features.se03Version],
+      [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04, features.se04Version],
+    ];
+    secureElementVersions.forEach(([targetId, version]) => {
+      if (version) versions.set(targetId, version);
+    });
+    return versions;
+  }
+
+  private hasProtocolV2InstallVersionChanged(expectedTargetIds: Set<number>) {
+    if (!this.protocolV2LastRuntimeProbeFeatures) return false;
+    const currentVersions = this.getProtocolV2ObservableTargetVersions(
+      this.protocolV2LastRuntimeProbeFeatures
+    );
+    return Array.from(expectedTargetIds).some(targetId => {
+      const previousVersion = this.protocolV2InstallBaselineVersions.get(targetId);
+      const currentVersion = currentVersions.get(targetId);
+      return (
+        previousVersion !== undefined &&
+        currentVersion !== undefined &&
+        previousVersion !== currentVersion
+      );
+    });
+  }
+
+  private recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds: Set<number>) {
+    expectedTargetIds.forEach(targetId => this.protocolV2CompletedTargetIds.add(targetId));
+  }
+
   private async waitForProtocolV2FirmwareUpdateComplete(
     targets: Array<{ target_id: number; path: string }>,
-    startResponse?: ProtocolV2FirmwareUpdateStartResponse
+    requireCurrentInstallStatus = false
   ) {
     const expectedTargetIds = new Set(targets.map(target => target.target_id));
-    if (startResponse?.type === 'DeviceFirmwareUpdateStatus') {
-      const statusTargets = (startResponse.message.records ??
-        []) as ProtocolV2FirmwareUpdateStatusTarget[];
-      if (this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds)) {
-        return;
-      }
-    }
-
+    const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
     const startTime = Date.now();
     let lastError: unknown;
+    // DeviceFirmwareUpdateRequest leaves the current loader link usable for status polling.
+    // Reconnecting here probes DeviceInfo, which loaders reject while installation is active.
+    let shouldReconnect = false;
+    let deviceInfo: ProtocolV2DeviceInfo | undefined;
+    let installEvidenceObserved = false;
+    let currentInstallStatusObserved = false;
 
     while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
+      // A transport release caused by an explicit workflow cancellation must not
+      // be mistaken for the expected device reboot during installation.
+      this.throwIfAborted();
       try {
-        const statusRes = await this.queryProtocolV2FirmwareUpdateStatus();
-        const statusTargets = (statusRes.message.records ??
-          []) as ProtocolV2FirmwareUpdateStatusTarget[];
-        if (this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds)) {
-          return;
-        }
-      } catch (error) {
-        lastError = error;
-        if (error instanceof HardwareError && error.errorCode === HardwareErrorCode.FirmwareError) {
-          throw error;
+        if (shouldReconnect) {
+          await this.reconnectProtocolV2Device();
+          deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+          shouldReconnect = false;
         }
-        Log.log('Protocol V2 firmware install status polling failed: ', error);
-        if (isProtocolV2PollingTransientError(error)) {
-          try {
-            await this.reconnectProtocolV2Device();
-            if (await this.probeProtocolV2NormalMode()) {
+        const currentDeviceInfo = deviceInfo;
+        try {
+          const statusResponse = await this.device.getCommands().typedCall(
+            'DeviceFirmwareUpdateStatusGet',
+            ['DeviceFirmwareUpdateStatus', 'Success'],
+            {
+              fields: {
+                status: true,
+                payload_version: true,
+                path: true,
+              },
+            },
+            { timeoutMs: PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT }
+          );
+          if (statusResponse.type === 'Success') {
+            installEvidenceObserved = true;
+            lastError = new Error(
+              'Protocol V2 firmware install acknowledged; waiting for target status'
+            );
+          }
+          const statusTargets =
+            statusResponse.type === 'DeviceFirmwareUpdateStatus'
+              ? ((statusResponse.message.records ?? []) as ProtocolV2FirmwareUpdateStatusTarget[])
+              : [];
+          const hasInProgressTarget = statusTargets.some(target => {
+            const targetId = normalizeProtocolV2TargetId(target.target_id);
+            return (
+              targetId !== undefined &&
+              expectedTargetIds.has(targetId) &&
+              isProtocolV2TargetStatusInProgress(target.status)
+            );
+          });
+          if (hasInProgressTarget) {
+            currentInstallStatusObserved = true;
+          }
+          const hasMatchingTargetStatus = statusTargets.some(target => {
+            const targetId = normalizeProtocolV2TargetId(target.target_id);
+            return targetId !== undefined && expectedTargetIds.has(targetId);
+          });
+          if (
+            hasMatchingTargetStatus &&
+            (!requireCurrentInstallStatus || currentInstallStatusObserved)
+          ) {
+            installEvidenceObserved = true;
+          }
+          const matchingStatusTargets = statusTargets.filter(target => {
+            const targetId = normalizeProtocolV2TargetId(target.target_id);
+            return targetId !== undefined && expectedTargetIds.has(targetId);
+          });
+          const shouldVerifyTargetCompletion =
+            !requireCurrentInstallStatus || currentInstallStatusObserved;
+          if (
+            shouldVerifyTargetCompletion &&
+            this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths)
+          ) {
+            return;
+          }
+
+          if (
+            requireCurrentInstallStatus &&
+            !currentInstallStatusObserved &&
+            matchingStatusTargets.length > 0
+          ) {
+            lastError = new Error(
+              'Protocol V2 firmware status is stale; waiting for the current install to start'
+            );
+          }
+
+          if (statusTargets.length === 0 && currentDeviceInfo) {
+            const isNormalMode = await this.probeProtocolV2NormalMode(currentDeviceInfo);
+            if (
+              isNormalMode &&
+              (installEvidenceObserved ||
+                this.hasProtocolV2InstallVersionChanged(expectedTargetIds))
+            ) {
+              Log.log(
+                '[FirmwareUpdateV4] empty firmware status after confirmed App reboot; update complete'
+              );
+              this.recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds);
+              this.postProgressMessage(100, 'installingFirmware');
               return;
             }
-          } catch (reconnectError) {
-            lastError = reconnectError;
-            Log.log(
-              'Protocol V2 firmware install reconnect/normal-mode probe failed: ',
-              reconnectError
+          }
+
+          if (statusTargets.length === 0) {
+            if (statusResponse.type !== 'Success') {
+              lastError = new Error(
+                'Protocol V2 firmware update is waiting for user confirmation or target status'
+              );
+            }
+          } else {
+            const missingTargetIds = this.getProtocolV2MissingTargetIds(
+              statusTargets,
+              expectedTargetIds
             );
+            if (missingTargetIds.length > 0) {
+              const missingKey = missingTargetIds.join(',');
+              lastError = new Error(
+                `Protocol V2 firmware status is temporarily missing targetIds=${missingKey}`
+              );
+            } else {
+              lastError = new Error('Protocol V2 firmware targets are still installing');
+            }
+          }
+        } catch (error) {
+          if (isProtocolV2TerminalInstallStatusError(error)) {
+            throw error;
           }
-          try {
-            await this.pingProtocolV2Device();
-            Log.log('Protocol V2 firmware status unavailable, Ping is ready');
-          } catch (pingError) {
-            lastError = pingError;
-            Log.log('Protocol V2 firmware install Ping polling failed: ', pingError);
+          // App firmware does not register DeviceFirmwareUpdateStatusGet. Treat the
+          // missing endpoint as completion only after the runtime probe confirms App mode.
+          if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
+            if (!currentDeviceInfo) {
+              throw ERRORS.TypedError(
+                HardwareErrorCode.RuntimeError,
+                'Protocol V2 device identity is unavailable during install polling'
+              );
+            }
+            const isNormalMode = await this.probeProtocolV2NormalMode(currentDeviceInfo);
+            if (
+              isNormalMode &&
+              (installEvidenceObserved ||
+                this.hasProtocolV2InstallVersionChanged(expectedTargetIds))
+            ) {
+              Log.log(
+                '[FirmwareUpdateV4] firmware status endpoint unavailable after confirmed App reboot'
+              );
+              this.recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds);
+              this.postProgressMessage(100, 'installingFirmware');
+              return;
+            }
+            if (isNormalMode) {
+              lastError = new Error(
+                'Protocol V2 device is in normal mode but installation is not yet confirmed'
+              );
+            } else {
+              lastError = new Error(
+                'Protocol V2 firmware status endpoint is unavailable while the device remains in loader mode'
+              );
+            }
+          } else {
+            shouldReconnect = true;
+            deviceInfo = undefined;
+            lastError = error;
+            Log.log(
+              '[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ',
+              error
+            );
           }
         }
+      } catch (error) {
+        lastError = error;
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
+          throw error;
+        }
+        if (isProtocolV2TerminalInstallStatusError(error)) {
+          throw error;
+        }
+        if (
+          error instanceof HardwareError &&
+          error.params?.firmwareUpdateCode === 'FirmwareInstallStatusUnavailable'
+        ) {
+          throw error;
+        }
+        shouldReconnect = true;
+        deviceInfo = undefined;
+        Log.log('Protocol V2 firmware install device readiness probe failed: ', error);
       }
       await wait(1000);
     }
 
+    Log.error(
+      `[FirmwareUpdateV4] install timed out after ${
+        PROTOCOL_V2_INSTALL_TIMEOUT / 1000
+      }s: ${this.normalizeErrorMessage(lastError)}`
+    );
     throw ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      `Protocol V2 firmware update status timeout: ${this.normalizeErrorMessage(lastError)}`
+      HardwareErrorCode.FirmwareError,
+      'Protocol V2 firmware install timed out',
+      {
+        firmwareUpdateCode: PROTOCOL_V2_INSTALL_TIMEOUT_CODE,
+      }
     );
   }
 
   private async exitProtocolV2BootloaderToNormal() {
-    this.postTipMessage(FirmwareUpdateTipMessage.SwitchFirmwareReconnectDevice);
+    await this.reconnectProtocolV2Device();
+    const deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
     try {
-      await this.reconnectProtocolV2Device();
-      if (await this.probeProtocolV2NormalMode()) {
-        Log.log('Protocol V2 device is already in normal mode, skip normal reboot');
+      if (await this.probeProtocolV2NormalMode(deviceInfo)) {
+        Log.log('[FirmwareUpdateV4] device already returned to App mode; skip Normal reboot');
         return;
       }
     } catch (error) {
-      Log.log('Protocol V2 normal-mode probe before reboot failed: ', error);
+      Log.log('[FirmwareUpdateV4] unable to confirm App mode before Normal reboot: ', error);
     }
     await this.protocolV2Reboot(DeviceRebootType.Normal);
+    this.protocolV2ExecutionInLoader = false;
+  }
+
+  private async probeProtocolV2NormalMode(deviceInfo: ProtocolV2DeviceInfo) {
+    const features = await this.device.probeProtocolV2RuntimeState(
+      deviceInfo,
+      PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+    );
+    this.protocolV2LastRuntimeProbeFeatures = features;
+    return this.isProtocolV2ApplicationMode(features);
+  }
+
+  private isProtocolV2ApplicationMode(features: Features) {
+    return (
+      (features.mode === 'normal' || features.mode === 'notInitialized') && !features.bootloaderMode
+    );
   }
 
   private async waitForProtocolV2FinalFeatures() {
     const features = await this.waitForProtocolV2ReconnectAndFeatures(
-      PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT
+      PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT
     );
 
+    return this.getProtocolV2VersionResult(features);
+  }
+
+  private getProtocolV2VersionResult(features: Features) {
     const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
     const bleVersion = getDeviceBLEFirmwareVersion(features).join('.');
     const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
+    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.'
@@ -1304,36 +2955,58 @@ 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;
+    let shouldReconnect = true;
+    this.protocolV2LatestFinalDeviceInfo = undefined;
 
     while (Date.now() - startTime < timeout) {
       try {
-        await this.reconnectProtocolV2Device();
+        if (shouldReconnect) {
+          await this.reconnectProtocolV2Device();
+          shouldReconnect = false;
+        }
         const deviceInfo = await requestProtocolV2DeviceInfo({
           commands: this.device.getCommands(),
-          timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
-          // 更新完成判定只需要各 target 版本号；scope 与请求内容保持一致
+          timeoutMs: this.getProtocolV2DeviceInfoTimeout(),
+          // Completion needs target versions only; keep scope aligned with the request.
           request: PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
         });
-        const features = this.device.updateProtocolV2Features(deviceInfo);
-        assertProtocolV2ReconnectIdentity(
-          this.protocolV2ExpectedDeviceId,
-          features.deviceId ?? undefined
+        this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
+        const features = await this.device.probeProtocolV2RuntimeState(
+          deviceInfo,
+          PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+          { forceRuntimeContextRefresh: true }
         );
-        if (features.bootloaderMode || features.mode === 'bootloader') {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.DeviceNotFound,
-            'Protocol V2 device is still in bootloader mode'
-          );
+        if (this.isProtocolV2ApplicationMode(features)) {
+          this.protocolV2LatestFinalDeviceInfo = deviceInfo;
+          return features;
         }
-        return features;
+        lastError = ERRORS.TypedError(
+          HardwareErrorCode.DeviceNotFound,
+          'Protocol V2 device is still in bootloader mode'
+        );
       } catch (error) {
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
+          throw error;
+        }
+        shouldReconnect = true;
         lastError = error;
         Log.log('Protocol V2 normal mode not ready, polling Ping: ', error);
-        await wait(1000);
       }
+      await wait(1000);
     }
 
     throw ERRORS.TypedError(
@@ -1357,136 +3030,71 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
       devicesDescriptor.length === 1
     ) {
+      const descriptor = devicesDescriptor[0];
+      if (!this.protocolV2ExpectedSerialNumber && descriptor.path !== this.protocolV2ExpectedPath) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
+      }
       this.device.updateDescriptor(
         {
-          ...devicesDescriptor[0],
+          ...descriptor,
           protocolType: PROTOCOL_V2_CONNECT_PROTOCOL,
         },
         true
       );
-      await this.device.acquire(PROTOCOL_V2_CONNECT_PROTOCOL, { throwOnRunPromiseError: true });
+      await this.ensureProtocolV2DeviceAcquired();
       this.device.commands.disposed = false;
       this.device.getCommands().mainId = this.device.mainId ?? '';
-      await this.device.initialize();
-      assertProtocolV2ReconnectIdentity(
-        this.protocolV2ExpectedDeviceId,
-        this.device.getCurrentDeviceId()
-      );
       return;
     }
 
-    // App 与 bootloader 序列号暂时可能不一致。V4 升级重连阶段只接受唯一枚举设备，
-    // 避免继续按旧 app connectId 查缓存导致反复输出 path mismatch 日志。
+    // Reinitialize every USB descriptor so DeviceInfo can provide the physical serial.
+    // Enumeration order is not stable and must never decide the reconnect target.
     const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined, {
       connectProtocol: PROTOCOL_V2_CONNECT_PROTOCOL,
     });
-    if (deviceList.length !== 1) {
+    const expectedSerialNumber = this.protocolV2ExpectedSerialNumber?.trim();
+    const expectedPath = this.protocolV2ExpectedPath?.trim();
+    const reconnectDevice = deviceList.find(candidate => {
+      const candidateSerialNumber = candidate.getCurrentSerialNo?.().trim();
+      if (expectedSerialNumber && candidateSerialNumber) {
+        return candidateSerialNumber === expectedSerialNumber;
+      }
+      return !!expectedPath && candidate.getConnectId() === expectedPath;
+    });
+    if (!reconnectDevice) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
     }
 
     Log.debug(
-      'Protocol V2 firmware reconnect using single enumerated device:',
-      deviceList[0].getConnectId()
+      'Protocol V2 firmware reconnect using matched device:',
+      reconnectDevice.getConnectId()
     );
-    this.device.updateFromCache(deviceList[0]);
-    await this.device.acquire(PROTOCOL_V2_CONNECT_PROTOCOL, { throwOnRunPromiseError: true });
+    this.device.updateFromCache(reconnectDevice);
+    await this.ensureProtocolV2DeviceAcquired();
     this.device.commands.disposed = false;
     this.device.getCommands().mainId = this.device.mainId ?? '';
-    await this.device.initialize();
-    assertProtocolV2ReconnectIdentity(
-      this.protocolV2ExpectedDeviceId,
-      this.device.getCurrentDeviceId()
-    );
-  }
-
-  private async protocolV2CommonUpdateProcess(params: ProtocolV2FileTransferParams) {
-    let lastError: unknown;
-    for (let attempt = 1; attempt <= PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT; attempt += 1) {
-      try {
-        return await this.protocolV2WriteWholeFile(params);
-      } catch (error) {
-        lastError = error;
-        Log.error(
-          `Protocol V2 file transfer failed path=${params.filePath} attempt=${attempt}/${PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT}; restarting from offset 0`,
-          error
-        );
-        if (attempt === PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
-          break;
-        }
-        await this.recoverProtocolV2FileTransfer();
-      }
-    }
-
-    throw ERRORS.TypedError(
-      HardwareErrorCode.EmmcFileWriteFirmwareError,
-      `transfer data error: ${getProtocolV2UnknownErrorText(lastError)}`
-    );
   }
 
-  private async protocolV2WriteWholeFile({
-    payload,
-    filePath,
-    processedSize,
-    totalSize,
-    onTransferredBytes,
-  }: ProtocolV2FileTransferParams) {
-    const chunkSize = this.getProtocolV2FirmwareChunkSize();
-    let offset = 0;
-    const getUploadProgress = (fileOffset: number) => {
-      if (totalSize !== undefined && processedSize !== undefined) {
-        return Math.min(Math.ceil(((processedSize + fileOffset) / totalSize) * 100), 99);
-      }
-      return Math.min(Math.ceil((fileOffset / payload.byteLength) * 100), 99);
-    };
-
-    while (offset < payload.byteLength) {
-      const chunkEnd = Math.min(offset + chunkSize, payload.byteLength);
-      const chunkLength = chunkEnd - offset;
-      const chunk = payload.slice(offset, chunkEnd);
-      const overwrite = offset === 0;
-      const progress = getProtocolV2DeviceTransferProgress(
-        (processedSize ?? 0) + offset,
-        (processedSize ?? 0) + chunkEnd,
-        totalSize ?? payload.byteLength
-      );
-
-      const writeRes = await this.fileWriteChunk(
-        filePath,
-        payload.byteLength,
-        offset,
-        chunk,
-        overwrite,
-        progress
-      );
-      const rawProcessedByte = writeRes.message.processed_byte;
-      const processedByte = Number(rawProcessedByte);
-      const nextOffset = rawProcessedByte === undefined ? offset + chunkLength : processedByte;
-      if (!Number.isFinite(nextOffset) || nextOffset <= offset || nextOffset > chunkEnd) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.EmmcFileWriteFirmwareError,
-          `invalid processed_byte ${writeRes.message.processed_byte} for offset ${offset}`
-        );
-      }
-      offset = nextOffset;
-      onTransferredBytes?.((processedSize ?? 0) + offset);
-      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;
     }
-
-    return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
+    await this.device.acquire(PROTOCOL_V2_CONNECT_PROTOCOL, {
+      throwOnRunPromiseError: true,
+    });
   }
 
-  private getProtocolV2FirmwareTransferTransport() {
-    const env = DataManager.getSettings('env');
-    if (env && DataManager.isBleConnect(env)) {
-      return 'BLE';
-    }
-    if (
-      env &&
-      (DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env) || env === 'web')
-    ) {
-      return 'WebUSB';
-    }
-    return env ?? 'unknown';
+  private isProtocolV2ReconnectIdentityError(error: unknown) {
+    // A serial can be temporarily unavailable while Loader starts, and BLE has no stable path.
+    // Keep polling unless the device explicitly reports a different serial.
+    return this.normalizeErrorMessage(error).includes(
+      'Protocol V2 reconnect physical identity mismatch'
+    );
   }
 
   private async fileWriteChunk(
@@ -1498,17 +3106,25 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     progress: number | null
   ): Promise<TypedResponseMessage<'FilesystemFile'>> {
     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,
+    const writeRes = await typedCall(
+      'FilesystemFileWrite',
+      'FilesystemFile',
+      {
+        file: {
+          path: filePath,
+          offset,
+          total_size: totalFileSize,
+          data: chunk,
+        },
+        overwrite,
+        append: false,
+        ui_percentage: progress ?? undefined,
       },
-      overwrite,
-      append: false,
-      ui_percentage: progress ?? undefined,
-    });
+      {
+        writeWithResponse: false,
+        onWriteCompleted: () => undefined,
+      }
+    );
     if (writeRes.type !== 'FilesystemFile') {
       if ((writeRes as any).type === 'CallMethodError') {
         if (((writeRes as any).message.error ?? '').indexOf(SESSION_ERROR) > -1) {
@@ -1524,9 +3140,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const env = DataManager.getSettings('env');
     if (DataManager.isBleConnect(env)) {
       await wait(3000);
-      await this.acquireProtocolV2BleDevice();
-      await this.device.initialize();
     }
+    await this.reconnectProtocolV2Device();
+    await this.verifyProtocolV2ReconnectIdentity();
+    await this.device.initialize();
     await wait(2000);
   }
 
@@ -1544,37 +3161,23 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }: {
     targets: Array<{ target_id: number; path: string }>;
   }) {
+    this.protocolV2LastRuntimeProbeFeatures = undefined;
     const commands = this.device.getCommands();
-    let response: ProtocolV2FirmwareUpdateStartResponse;
-    try {
-      response = await commands.typedCall(
-        'DeviceFirmwareUpdateRequest',
-        PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
-        {
-          targets,
-        },
-        {
-          intermediateTypes: ['DeviceFirmwareUpdateStatus'],
-          timeoutMs: PROTOCOL_V2_START_UPDATE_TIMEOUT,
-          onIntermediateResponse: (response: { type?: string }) => {
-            if (response.type === 'DeviceFirmwareUpdateStatus') {
-              this.postProgressMessage(99, 'installingFirmware');
-            }
-          },
-        }
-      );
-    } catch (error) {
-      if (isProtocolV2StartUpdateTransientError(error)) {
-        Log.log(
-          'Protocol V2 firmware update request did not return; continue status polling',
-          error
-        );
-      } else {
-        throw error;
-      }
-    }
-    this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdating);
-    return response;
+    await commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
+    this.device.setCancelableAction(() => commands.cancelDevice());
+    const interaction = this.device.createProtocolV2UiPhaseMetadata('button', 'start');
+    this.postMessage(
+      createUiMessage(UI_REQUEST.REQUEST_BUTTON, {
+        device: this.device.toMessageObject() as KnownDevice,
+        source: 'method-lifecycle',
+        reason: 'firmware-update',
+        completion: 'operation-completed',
+        deviceOnly: true,
+        operation: this.name,
+        ...(interaction ? { interaction } : {}),
+      })
+    );
+    await commands.call('DeviceFirmwareUpdateRequest', {}, { returnAfterWrite: true });
   }
 
   private async protocolV2Reboot(rebootType: DeviceRebootType) {
@@ -1583,9 +3186,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       const res = await typedCall('DeviceReboot', 'Success', {
         reboot_type: rebootType,
       });
+      this.device.markProtocolV2Reboot(rebootType);
       return res.message;
     } catch (error) {
       if (isProtocolV2DeviceDisconnectedError(error) || isProtocolV2ReconnectProbeError(error)) {
+        this.device.markProtocolV2Reboot(rebootType);
         return { message: 'Device rebooted successfully' };
       }
       throw error;