@onekeyfe/hd-core 1.2.0-alpha.65 → 1.2.0-alpha.66

package/src/api/FirmwareUpdateV4.ts

@@ -2,13 +2,13 @@ import { EDeviceType, ERRORS, HardwareError, HardwareErrorCode, wait } from '@on
 import {
   DeviceRebootType,
   PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
-  PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE,
   PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
 } from '@onekeyfe/hd-transport';
 import { sha256 } from '@noble/hashes/sha256';
 
 import { FirmwareUpdateTipMessage, UI_REQUEST } from '../events/ui-request';
 import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
+import { writeProtocolV2File } from './helpers/protocolV2FileWrite';
 import { validateParams } from './helpers/paramsValidator';
 import {
   LoggerNames,
@@ -19,7 +19,6 @@ import {
   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';
@@ -28,41 +27,40 @@ import {
   ProtocolV2FirmwareTargetType,
 } from '../protocols/protocol-v2';
 import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
+import {
+  PROTOCOL_V2_RESOURCE_DEVICE_PATHS,
+  buildProtocolV2ResourceUpdatePlan,
+  isProtocolV2ResourceFileValid,
+  readProtocolV2ResourceInventory,
+} from '../protocols/protocol-v2/resources';
 import {
   getProtocolV2UnknownErrorText,
   isProtocolV2DeviceDisconnectedError,
 } from './protocol-v2/helpers';
-import { openFirmwareByteSource, writeFirmwareByteSource } from './firmware/FirmwareArtifactSource';
-import { resolveFirmwareUpdateHostBinding } from './firmware/FirmwareHostBinding';
-import {
-  assertFirmwareUpdatePreparedPlanBinding,
-  assertFirmwareUpdatePreparedPlanDeviceIdentity,
-} from './firmware/FirmwareUpdatePreparedPlan';
 
-import type {
-  FirmwareArtifactReference,
-  FirmwareUpdateV4Params,
-  FirmwareUpdateV4Target,
-} from '../types/api/firmwareUpdate';
+import type { FirmwareUpdateV4Params, FirmwareUpdateV4Target } from '../types/api/firmwareUpdate';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+import type { PROTO } from '../constants';
 import type { TypedResponseMessage } from '../device/DeviceCommands';
 import type {
   Features,
   IFirmwareReleaseInfo,
   IProtocolV2FirmwareComponent,
+  IProtocolV2Resource,
+  IProtocolV2ResourceFile,
   IVersionArray,
 } from '../types';
-import type { FirmwareByteSource } from './firmware/FirmwareArtifactSource';
 
 const Log = getLogger(LoggerNames.Method);
 
-const SESSION_ERROR = 'session not found';
-const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 60 * 1000;
-const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 2 * 60 * 1000;
+const PROTOCOL_V2_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_FIRMWARE_STATUS_RESPONSE_TIMEOUT = 15 * 1000;
 const PROTOCOL_V2_START_UPDATE_TIMEOUT = 3 * 60 * 1000;
-const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
+const PROTOCOL_V2_INSTALL_TIMEOUT = 8 * 60 * 1000;
+const PROTOCOL_V2_MISSING_TARGET_STATUS_GRACE_TIMEOUT = 30 * 1000;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
 const PROTOCOL_V2_TARGET_STATUS_FINISHED = 2;
@@ -73,7 +71,7 @@ const PROTOCOL_V2_MIN_FILE_CHUNK_SIZE = 64;
 const PROTOCOL_V2_CONNECT_RETRY_COUNT = 10;
 const PROTOCOL_V2_CONNECT_POLL_INTERVAL = 500;
 const PROTOCOL_V2_CONNECT_SINGLE_TIMEOUT = 75 * 1000;
-const PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT = 60 * 1000;
+const PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT = 30 * 1000;
 const PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT = 3;
 const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
 const PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET = 0x200;
@@ -97,6 +95,11 @@ const getProtocolV2DeviceTransferProgress = (
   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;
@@ -110,16 +113,22 @@ type ProtocolV2TargetBinary = { fileName: string; binary: ArrayBuffer; targetId:
 type ProtocolV2InstallItem = ProtocolV2TargetBinary & {
   kind: ProtocolV2RemoteComponentTarget['kind'];
 };
-/** RESC bundle okpkg written independently to devicePath through FileWrite. */
+type ProtocolV2InstallTarget = ProtocolV2InstallItem & {
+  path: string;
+};
+
+type ProtocolV2FileTransferParams = PROTO.FirmwareUpload & {
+  filePath: string;
+  processedSize?: number;
+  totalSize?: number;
+  onTransferredBytes?: (transferredBytes: number) => void;
+};
+
+/** Protocol V2 resource file written independently to devicePath through FileWrite. */
 type ProtocolV2ResourceBundleBinary = {
   name: string;
   binary: ArrayBuffer;
   devicePath: string;
-  /** Download URL for remote-config mode; omitted in manual mode. */
-  url?: string;
-  version?: IVersionArray;
-  payloadHash?: string;
-  headerHash?: string;
 };
 
 type ProtocolV2RemoteComponentBinary = ProtocolV2RemoteComponentTarget & {
@@ -132,35 +141,6 @@ type ProtocolV2RemoteComponentTarget = {
   kind: 'bootloader' | 'firmware';
 };
 
-type ProtocolV2InstallSource = {
-  fileName: string;
-  source: FirmwareByteSource;
-  targetId: number;
-  kind: ProtocolV2RemoteComponentTarget['kind'];
-};
-
-type ProtocolV2ResourceBundleSource = {
-  name: string;
-  source: FirmwareByteSource;
-  devicePath: string;
-  version?: IVersionArray;
-  payloadHash?: string;
-  headerHash?: string;
-};
-
-type ProtocolV2ExecutionPhaseKind =
-  | 'resource-sync'
-  | 'bootloader-install'
-  | 'bootloader-verify'
-  | 'component-install'
-  | 'final-verify';
-
-type ProtocolV2ExecutionPhase = {
-  kind: ProtocolV2ExecutionPhaseKind;
-  installSources: ProtocolV2InstallSource[];
-  resourceSources: ProtocolV2ResourceBundleSource[];
-};
-
 type ProtocolV2OkppHeader = {
   type: string;
   version: IVersionArray;
@@ -300,18 +280,6 @@ const normalizeProtocolV2TargetStatus = (
 
 const normalizeProtocolV2Hex = (value?: string) => value?.replace(/^0x/i, '').toLowerCase();
 
-const versionArrayToNumber = (version?: IVersionArray) => {
-  if (!version) return undefined;
-  return version[0] * 0x10000 + version[1] * 0x100 + version[2];
-};
-
-const compareProtocolV2Versions = (current?: IVersionArray, target?: IVersionArray) => {
-  const currentNumber = versionArrayToNumber(current);
-  const targetNumber = versionArrayToNumber(target);
-  if (currentNumber === undefined || targetNumber === undefined) return undefined;
-  return currentNumber - targetNumber;
-};
-
 const bytesToHex = (bytes: Uint8Array) =>
   Array.from(bytes)
     .map(byte => byte.toString(16).padStart(2, '0'))
@@ -402,20 +370,30 @@ export const isProtocolV2FirmwareFingerprintValid = (
 
 export const assertProtocolV2ReconnectIdentity = (
   expectedSerialNumber?: string,
-  actualSerialNumber?: string
+  actualSerialNumber?: string,
+  expectedPath?: string,
+  actualPath?: string
 ) => {
-  if (!expectedSerialNumber || !actualSerialNumber) {
-    throw ERRORS.TypedError(
-      HardwareErrorCode.DeviceNotFound,
-      'Protocol V2 reconnect physical identity is unavailable'
-    );
+  if (expectedSerialNumber && actualSerialNumber) {
+    if (actualSerialNumber !== expectedSerialNumber) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceNotFound,
+        `Protocol V2 reconnect physical identity mismatch: expected ${expectedSerialNumber}, received ${actualSerialNumber}`
+      );
+    }
+    return;
   }
-  if (actualSerialNumber !== expectedSerialNumber) {
-    throw ERRORS.TypedError(
-      HardwareErrorCode.DeviceNotFound,
-      `Protocol V2 reconnect physical identity mismatch: expected ${expectedSerialNumber}, received ${actualSerialNumber}`
-    );
+
+  if (expectedPath && actualPath && expectedPath === actualPath) {
+    return;
   }
+
+  throw ERRORS.TypedError(
+    HardwareErrorCode.DeviceNotFound,
+    `Protocol V2 reconnect physical identity unavailable: expected path ${
+      expectedPath ?? 'unknown'
+    }, received ${actualPath ?? 'unknown'}`
+  );
 };
 
 /**
@@ -429,20 +407,12 @@ export const assertProtocolV2ReconnectIdentity = (
 export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareUpdateV4Params> {
   private protocolV2ExpectedSerialNumber?: string;
 
+  private protocolV2ExpectedPath?: string;
+
   getSupportedProtocols() {
     return ['V2'] as const;
   }
 
-  private protocolV2PreparedSources: FirmwareByteSource[] = [];
-
-  private protocolV2ExecutionInLoader = false;
-
-  private protocolV2CompletedTargetVersions = new Map<number, number>();
-
-  private protocolV2LatestFinalFeatures?: Features;
-
-  private protocolV2FinalStatusVerified = false;
-
   init() {
     this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
     this.requireDeviceMode = [];
@@ -480,62 +450,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       { name: 'firmwareType', type: 'string' },
       { name: 'targetsToUpdate', type: 'array', allowEmpty: true },
       { name: 'platform', type: 'string' },
-      { name: 'expectedDeviceId', type: 'string' },
-      { name: 'resourceBundleFiles', type: 'array', allowEmpty: true },
+      { name: 'resourceFiles', type: 'array', allowEmpty: true },
     ]);
-    if (
-      payload.expectedDeviceId !== undefined &&
-      (payload.expectedDeviceId.length === 0 || payload.expectedDeviceId.length > 160)
-    ) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.CallMethodInvalidParameter,
-        'Protocol V2 expected device identity is invalid'
-      );
-    }
-    const hostBinding =
-      payload.preparedPlan || payload.componentArtifacts || payload.resourceBundleArtifacts
-        ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
-        : undefined;
-    if (hostBinding) {
-      assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan: payload.preparedPlan,
-        executor: 'v4',
-        platform: payload.platform,
-        scopeTargets: [
-          'boot',
-          'app_v1',
-          'app_v2',
-          'coprocessor',
-          'resource',
-          'se01',
-          'se02',
-          'se03',
-          'se04',
-        ],
-        bindings: [
-          ...Object.entries(payload.componentArtifacts ?? {}).flatMap(([target, artifact]) =>
-            artifact
-              ? [
-                  {
-                    target: target as Exclude<FirmwareUpdateV4Target, 'resource'>,
-                    artifact,
-                  },
-                ]
-              : []
-          ),
-          ...(payload.resourceBundleArtifacts ?? []).map(
-            (entry: { name: string; artifact: FirmwareArtifactReference }) => ({
-              target: 'resource' as const,
-              logicalName: entry.name,
-              artifact: entry.artifact,
-            })
-          ),
-        ],
-      });
-    }
 
     this.params = {
-      preparedPlan: payload.preparedPlan,
       chunkSize: payload.chunkSize,
       forcedUpdateRes: payload.forcedUpdateRes,
       bootloaderBinary: payload.bootloaderBinary,
@@ -547,28 +465,20 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       se02Binary: payload.se02Binary,
       se03Binary: payload.se03Binary,
       se04Binary: payload.se04Binary,
-      resourceBundleFiles: payload.resourceBundleFiles,
+      resourceFiles: payload.resourceFiles,
       firmwareType: payload.firmwareType,
       targetsToUpdate: payload.targetsToUpdate,
-      expectedTargetVersions: payload.expectedTargetVersions,
       platform: payload.platform,
-      expectedDeviceId: payload.expectedDeviceId,
-      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
-      componentArtifacts: payload.componentArtifacts,
-      resourceBundleArtifacts: payload.resourceBundleArtifacts,
     };
   }
 
-  private getProtocolV2FirmwareChunkSize(direction: 'read' | 'write' = 'write') {
+  private getProtocolV2FirmwareChunkSize() {
     const payloadChunkSize = Number(this.params?.chunkSize);
     const env = DataManager.getSettings('env');
     const isBle = this.params?.platform === 'native' || (env && DataManager.isBleConnect(env));
     let maxChunkSize = PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
     if (isBle) {
-      maxChunkSize =
-        direction === 'read'
-          ? PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE
-          : PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+      maxChunkSize = PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
     }
     if (!Number.isFinite(payloadChunkSize) || payloadChunkSize <= 0) {
       return maxChunkSize;
@@ -589,14 +499,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const deviceFeatures = await this.getProtocolV2DeviceFeatures();
     const deviceFirmwareType = getFirmwareType(deviceFeatures);
     const firmwareType = this.params.firmwareType ?? deviceFirmwareType;
-    this.validateExpectedTargetVersions();
-
-    if (
-      (this.params.componentArtifacts && Object.keys(this.params.componentArtifacts).length > 0) ||
-      this.params.resourceBundleArtifacts?.length
-    ) {
-      return this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
-    }
+    const needsRemoteResources =
+      !this.params.resourceFiles?.length && !!this.params.targetsToUpdate?.includes('resource');
 
     let fwBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
@@ -604,21 +508,18 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     let resourceBundles: ProtocolV2ResourceBundleBinary[] | undefined;
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
+      resourceBundles = this.prepareExplicitProtocolV2ResourceFiles();
       fwBinaryMap = this.collectExplicitTargetBinaries();
       bootloaderBinary = this.prepareBootloaderBinary();
-      if (!this.hasExplicitProtocolV2Payload(fwBinaryMap)) {
-        if (
-          this.params.artifactReader ||
-          DataManager.getSettings('firmwareManifestMode') === 'external-only'
-        ) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.RuntimeError,
-            'Protocol V2 firmware artifacts must be prepared by the external firmware host',
-            {
-              firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-            }
-          );
-        }
+      const needsRemoteFirmware = !this.hasExplicitProtocolV2Payload(fwBinaryMap);
+      const needsRemoteBootResources = !!this.params.targetsToUpdate?.includes('boot_resources');
+      if (needsRemoteFirmware || needsRemoteResources || needsRemoteBootResources) {
+        // Remote updates must use a freshly fetched config before any reboot or file write.
+        await DataManager.forceReloadData({
+          requireResources: needsRemoteResources || needsRemoteBootResources,
+        });
+      }
+      if (needsRemoteFirmware) {
         const remoteBinaries = await this.prepareRemoteProtocolV2Binaries(
           firmwareType,
           deviceFeatures
@@ -627,308 +528,70 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         fwBinaryMap = remoteBinaries.fwBinaryMap;
         installItems = remoteBinaries.installItems;
       }
-      const resourceDescriptors = this.prepareProtocolV2ResourceBundles(
-        firmwareType,
-        deviceFeatures
-      );
-      resourceBundles = resourceDescriptors?.length
-        ? await this.materializeProtocolV2ResourceBundles(resourceDescriptors)
-        : undefined;
-      this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+      const bootResourceFiles = await this.prepareProtocolV2BootResources();
+      if (bootResourceFiles?.length) {
+        resourceBundles = [...(resourceBundles ?? []), ...bootResourceFiles];
+      }
+      if (!needsRemoteResources) {
+        this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+      }
     } catch (err) {
-      throw normalizeFirmwarePreparationError(err);
+      if (err instanceof HardwareError && err.errorCode === HardwareErrorCode.NetworkError) {
+        throw err;
+      }
+      throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
     }
 
-    if (!bootloaderBinary && fwBinaryMap.length === 0 && !resourceBundles?.length) {
+    if (
+      !bootloaderBinary &&
+      fwBinaryMap.length === 0 &&
+      !installItems?.length &&
+      !resourceBundles?.length &&
+      !needsRemoteResources
+    ) {
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareUpdateDownloadFailed,
         'No firmware to update'
       );
     }
 
-    return this.executeProtocolV2Update({
-      fwBinaryMap,
-      bootloaderBinary,
-      ...(installItems ? { installItems } : undefined),
-      ...(resourceBundles?.length ? { resourceBundles } : undefined),
-    });
-  }
-
-  private async openProtocolV2PreparedSource(artifact: FirmwareArtifactReference) {
-    const source = await openFirmwareByteSource({
-      artifact,
-      reader: this.params.artifactReader,
-    });
-    if (!source) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `Firmware artifact ${artifact.artifactRef} is not prepared`,
-        {
-          firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-        }
-      );
-    }
-    this.protocolV2PreparedSources.push(source);
-    return source;
-  }
-
-  private async openProtocolV2MemorySource(binary: ArrayBuffer) {
-    const source = await openFirmwareByteSource({ binary });
-    if (!source) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 firmware binary is empty'
-      );
-    }
-    this.protocolV2PreparedSources.push(source);
-    return source;
-  }
-
-  private async closeProtocolV2PreparedSources() {
-    const sources = this.protocolV2PreparedSources.splice(0);
-    await Promise.all(sources.map(source => source.close().catch(() => undefined)));
-  }
+    const enteredBootloader = await this.enterProtocolV2BootloaderMode();
 
-  private async prepareProtocolV2InstallSources(
-    firmwareType: EFirmwareType,
-    features: Features
-  ): Promise<ProtocolV2InstallSource[]> {
-    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
-    if (!release) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 firmware release is unavailable'
-      );
-    }
-    const componentArtifacts = this.params.componentArtifacts ?? {};
-    const requestedTargets = new Set(
-      this.params.targetsToUpdate ?? (Object.keys(componentArtifacts) as FirmwareUpdateV4Target[])
-    );
-    const installSources: ProtocolV2InstallSource[] = [];
-    const preparedTargets = new Set<FirmwareUpdateV4Target>();
-
-    for (const [key, component] of this.getRemoteComponentEntries(release)) {
-      const target = this.getRemoteComponentTarget(key, component);
-      const updateTarget = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId);
-      if (updateTarget && updateTarget !== 'resource' && requestedTargets.has(updateTarget)) {
-        const artifact = componentArtifacts[updateTarget];
-        if (!artifact) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.RuntimeError,
-            `Protocol V2 ${updateTarget} artifact is not prepared`,
-            {
-              firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-              artifactName: updateTarget,
-            }
-          );
-        }
-        installSources.push({
-          ...target,
-          source: await this.openProtocolV2PreparedSource(artifact),
-        });
-        preparedTargets.add(updateTarget);
-      }
-    }
-
-    const unknownTarget = Array.from(requestedTargets).find(
-      target => target !== 'resource' && !preparedTargets.has(target)
-    );
-    if (unknownTarget) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `Protocol V2 release does not contain requested target ${unknownTarget}`
-      );
-    }
-    return installSources;
-  }
-
-  private async prepareProtocolV2ResourceSources(
-    firmwareType: EFirmwareType,
-    features: Features
-  ): Promise<ProtocolV2ResourceBundleSource[]> {
-    const preparedArtifacts = this.params.resourceBundleArtifacts ?? [];
-    const resourceRequested =
-      this.params.targetsToUpdate?.includes('resource') || preparedArtifacts.length > 0;
-    if (!resourceRequested) {
-      return [];
-    }
-    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
-    const descriptors = release?.resourceBundles ?? [];
-    const artifactByName = new Map(
-      preparedArtifacts.map(item => [item.name, item.artifact] as const)
-    );
-    const sources: ProtocolV2ResourceBundleSource[] = [];
-    for (const descriptor of descriptors) {
-      const artifact = artifactByName.get(descriptor.name);
-      if (!artifact) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `Protocol V2 resource bundle ${descriptor.name} is not prepared`,
-          {
-            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-            artifactName: descriptor.name,
+    if (needsRemoteResources) {
+      try {
+        const stableResources = await this.prepareProtocolV2ResourceBundles();
+        resourceBundles = [...(resourceBundles ?? []), ...(stableResources ?? [])];
+        this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+      } catch (err) {
+        if (enteredBootloader) {
+          try {
+            await this.exitProtocolV2BootloaderToNormal();
+          } catch (restoreError) {
+            Log.warn(
+              '[FirmwareUpdateV4] failed to restore App mode after resource preparation error:',
+              restoreError
+            );
           }
-        );
-      }
-      const devicePath = validateProtocolV2FilesystemPath(
-        descriptor.devicePath,
-        'resourceBundles[].devicePath'
-      );
-      sources.push({
-        name: descriptor.name,
-        source: await this.openProtocolV2PreparedSource(artifact),
-        devicePath,
-        version: descriptor.version,
-        payloadHash: descriptor.payloadHash,
-        headerHash: descriptor.headerHash,
-      });
-      artifactByName.delete(descriptor.name);
-    }
-    if (artifactByName.size > 0) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `Protocol V2 release does not contain resource bundle ${artifactByName.keys().next().value}`
-      );
-    }
-    return sources;
-  }
-
-  private async runProtocolV2PreparedArtifacts(features: Features, firmwareType: EFirmwareType) {
-    try {
-      this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
-      const installSources = await this.prepareProtocolV2InstallSources(firmwareType, features);
-      const resourceSources = await this.prepareProtocolV2ResourceSources(firmwareType, features);
-      if (installSources.length === 0 && resourceSources.length === 0) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.FirmwareUpdateDownloadFailed,
-          'No firmware to update'
-        );
+        }
+        throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
       }
-      this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
-
-      return await this.executeProtocolV2SourceUpdate({
-        installSources,
-        resourceSources,
-      });
-    } finally {
-      await this.closeProtocolV2PreparedSources();
     }
-  }
 
-  private validateExpectedTargetVersions() {
-    const expected = this.params.expectedTargetVersions;
-    if (expected === undefined) return;
-    if (typeof expected !== 'object' || expected === null || Array.isArray(expected)) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 expected target versions are invalid'
-      );
-    }
-    for (const [target, version] of Object.entries(expected)) {
-      if (
-        !Array.from(PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.values()).includes(
-          target as FirmwareUpdateV4Target
-        ) ||
-        typeof version !== 'string' ||
-        !/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/u.test(version) ||
-        version.length > 64
-      ) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Protocol V2 expected target version is invalid'
-        );
-      }
-    }
-  }
+    await this.executeProtocolV2Update({
+      fwBinaryMap,
+      bootloaderBinary,
+      ...(installItems ? { installItems } : undefined),
+      ...(resourceBundles?.length ? { resourceBundles } : undefined),
+    });
 
-  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];
-  }
+    this.postTipMessage(FirmwareUpdateTipMessage.SwitchFirmwareReconnectDevice);
+    await this.exitProtocolV2BootloaderToNormal();
 
-  private assertExpectedProtocolV2Versions(targets?: readonly FirmwareUpdateV4Target[]) {
-    const expected = this.params?.expectedTargetVersions;
-    if (!expected) return;
-    const features = this.protocolV2LatestFinalFeatures;
-    const requestedTargets = this.getProtocolV2RequestedTargets();
-    const applicationTargets = requestedTargets.filter(
-      target => target === 'app_v1' || target === 'app_v2'
-    );
-    const visibleVersions: Partial<Record<FirmwareUpdateV4Target, string>> = {
-      boot: features ? getDeviceBootloaderVersion(features).join('.') : undefined,
-      coprocessor: features ? getDeviceBLEFirmwareVersion(features).join('.') : undefined,
-      se01: features?.se01Version ?? undefined,
-      se02: features?.se02Version ?? undefined,
-      se03: features?.se03Version ?? undefined,
-      se04: features?.se04Version ?? undefined,
-    };
-    if (features && applicationTargets.length === 1) {
-      visibleVersions[applicationTargets[0]] = getDeviceFirmwareVersion(features).join('.');
-    }
-    const expectedEntries = (
-      Object.entries(expected) as Array<[FirmwareUpdateV4Target, string]>
-    ).filter(([target]) => !targets || targets.includes(target));
-    for (const [target, expectedVersion] of expectedEntries) {
-      const targetId = Array.from(PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.entries()).find(
-        ([, mappedTarget]) => mappedTarget === target
-      )?.[0];
-      const statusVersion =
-        targetId === undefined ? undefined : this.protocolV2CompletedTargetVersions.get(targetId);
-      const observedVersion =
-        statusVersion === undefined
-          ? visibleVersions[target]
-          : `${Math.floor(statusVersion / 0x10000) % 0x100}.${
-              Math.floor(statusVersion / 0x100) % 0x100
-            }.${statusVersion % 0x100}`;
-      if (!observedVersion) {
-        if (this.protocolV2FinalStatusVerified) {
-          Log.warn(
-            `Protocol V2 target ${target} has no observable final version; completed target status is authoritative`
-          );
-        } else {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.FirmwareVerificationFailed,
-            `Protocol V2 target ${target} has no observable final version after status fallback`
-          );
-        }
-      } else if (observedVersion !== expectedVersion) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.FirmwareVerificationFailed,
-          `Protocol V2 target ${target} reached ${observedVersion}, expected ${expectedVersion}`
-        );
-      }
-    }
-  }
+    const versions = await this.waitForProtocolV2FinalFeatures();
+    this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
+    DevicePool.resetState();
 
-  private getProtocolV2RequestedTargets(): FirmwareUpdateV4Target[] {
-    if (this.params.targetsToUpdate?.length) {
-      return [...new Set(this.params.targetsToUpdate)];
-    }
-    const targets = new Set<FirmwareUpdateV4Target>();
-    Object.keys(this.params.componentArtifacts ?? {}).forEach(target =>
-      targets.add(target as FirmwareUpdateV4Target)
-    );
-    if (this.params.resourceBundleArtifacts?.length || this.params.resourceBundleFiles?.length) {
-      targets.add('resource');
-    }
-    if (this.params.bootloaderBinary) targets.add('boot');
-    if (this.params.applicationP1Binary) targets.add('app_v1');
-    if (this.params.applicationP2Binary) targets.add('app_v2');
-    if (this.params.coprocessorBinary) targets.add('coprocessor');
-    if (this.params.se01Binary) targets.add('se01');
-    if (this.params.se02Binary) targets.add('se02');
-    if (this.params.se03Binary) targets.add('se03');
-    if (this.params.se04Binary) targets.add('se04');
-    return Array.from(targets);
+    return versions;
   }
 
   private async getProtocolV2DeviceFeatures(): Promise<Features> {
@@ -950,31 +613,32 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private assertProtocolV2DeviceInfoIdentity(deviceInfo: ProtocolV2DeviceInfo) {
     assertProtocolV2ReconnectIdentity(
       this.protocolV2ExpectedSerialNumber,
-      this.getProtocolV2SerialNumber(deviceInfo)
+      this.getProtocolV2SerialNumber(deviceInfo),
+      this.protocolV2ExpectedPath,
+      this.device.originalDescriptor.path
     );
   }
 
+  private getProtocolV2DeviceInfoTimeout() {
+    return this.isBleReconnect()
+      ? this.payload.protocolV2DeviceInfoTimeoutMs ?? PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT
+      : PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT;
+  }
+
   private async requestProtocolV2PhysicalIdentity() {
     return requestProtocolV2DeviceInfo({
       commands: this.device.getCommands(),
-      timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+      timeoutMs: this.getProtocolV2DeviceInfoTimeout(),
     });
   }
 
   private async captureProtocolV2PhysicalIdentity() {
     const deviceInfo = await this.requestProtocolV2PhysicalIdentity();
     const serialNumber = this.getProtocolV2SerialNumber(deviceInfo);
-    if (this.params?.preparedPlan) {
-      assertFirmwareUpdatePreparedPlanDeviceIdentity({
-        preparedPlan: this.params.preparedPlan,
-        deviceIdentity: serialNumber,
-      });
-    } else if (this.params?.expectedDeviceId) {
-      assertProtocolV2ReconnectIdentity(this.params?.expectedDeviceId, serialNumber);
-    } else {
-      assertProtocolV2ReconnectIdentity(serialNumber, serialNumber);
-    }
+    const path = this.device.originalDescriptor.path?.trim() || undefined;
+    assertProtocolV2ReconnectIdentity(serialNumber, serialNumber, path, path);
     this.protocolV2ExpectedSerialNumber = serialNumber;
+    this.protocolV2ExpectedPath = path;
   }
 
   private async verifyProtocolV2ReconnectIdentity() {
@@ -989,7 +653,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private hasExplicitProtocolV2Payload(fwBinaryMap: ProtocolV2TargetBinary[]) {
     return (
-      !!this.params.resourceBundleFiles?.length ||
+      !!this.params.resourceFiles?.length ||
       !!this.params.bootloaderBinary ||
       fwBinaryMap.length > 0
     );
@@ -1052,57 +716,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return target;
   }
 
-  private getProtocolV2ResourceFilePath(path: string) {
-    if (path.startsWith('vol')) return path;
-    if (path.startsWith('/')) return `vol0:${path}`;
-    return `vol0:/${path}`;
-  }
-
-  private async readProtocolV2DeviceFileHeader(path: string) {
-    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    const filePath = this.getProtocolV2ResourceFilePath(path);
-    const pathInfoRes = await typedCall('FilesystemPathInfoQuery', 'FilesystemPathInfo', {
-      path: filePath,
-    });
-    const fileSize = toProtocolV2FiniteNumber(pathInfoRes.message?.size);
-    if (
-      !pathInfoRes.message?.exist ||
-      pathInfoRes.message?.directory ||
-      fileSize === undefined ||
-      fileSize < PROTOCOL_V2_OKPP_HEADER_SIZE
-    ) {
-      return null;
-    }
-
-    const chunkSize = this.getProtocolV2FirmwareChunkSize('read');
-    const chunks: Uint8Array[] = [];
-    let offset = 0;
-    while (offset < PROTOCOL_V2_OKPP_HEADER_SIZE) {
-      const readLen = Math.min(chunkSize, PROTOCOL_V2_OKPP_HEADER_SIZE - offset);
-      const res = await typedCall('FilesystemFileRead', 'FilesystemFile', {
-        file: {
-          path: filePath,
-          offset,
-          total_size: 0,
-        },
-        chunk_len: readLen,
-        ui_percentage: undefined,
-      });
-      const data = toProtocolV2Bytes(res.message?.data);
-      if (data.byteLength === 0) return null;
-      chunks.push(data);
-      offset += data.byteLength;
-    }
-
-    const headerBytes = new Uint8Array(offset);
-    let cursor = 0;
-    chunks.forEach(chunk => {
-      headerBytes.set(chunk, cursor);
-      cursor += chunk.byteLength;
-    });
-    return parseProtocolV2OkppHeader(headerBytes);
-  }
-
   private async downloadRemoteProtocolV2Component(
     key: string,
     component: IProtocolV2FirmwareComponent
@@ -1191,155 +804,159 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     };
   }
 
-  // ============================================================
-  // Incremental RESC bundle sync through FileRead and FilesystemFileWrite
-  // ============================================================
+  private getProtocolV2DeviceType(): EDeviceType.Pro2 | EDeviceType.Neo {
+    const deviceType = this.device.getCurrentDeviceType();
+    if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) return deviceType;
+    throw new Error(`Unsupported Protocol V2 device type: ${deviceType}`);
+  }
 
-  /**
-   * Prepare the RESC bundle list.
-   *
-   * Two modes, matching FirmwareUpdateV3 binary-versus-version behavior:
-   * - resourceBundleFiles supplied: use binaries directly without version checks.
-   * - Otherwise load release.resourceBundles from remote config.json; the binaries
-   *   are prefetched before reboot and synchronization skips matching device headers.
-   */
-  private prepareProtocolV2ResourceBundles(
-    firmwareType: EFirmwareType,
-    features: Features
-  ): ProtocolV2ResourceBundleBinary[] | undefined {
-    // Manual binaries are installed directly without comparison.
-    if (this.params.resourceBundleFiles?.length) {
-      return this.params.resourceBundleFiles.map((file, index) => {
-        const devicePath = validateProtocolV2FilesystemPath(
-          file.devicePath,
-          `resourceBundleFiles[${index}].devicePath`
-        );
-        return {
-          name: devicePath.split('/').pop() ?? devicePath,
-          binary: file.binary,
-          devicePath,
-        };
+  private async prepareProtocolV2BootResources(): Promise<
+    ProtocolV2ResourceBundleBinary[] | undefined
+  > {
+    if (!this.params.targetsToUpdate?.includes('boot_resources')) return undefined;
+    const resource = DataManager.getProtocolV2BootResources(this.getProtocolV2DeviceType());
+    if (!resource) throw new Error('Missing Protocol V2 boot resources configuration');
+
+    const files: ProtocolV2ResourceBundleBinary[] = [];
+    for (const file of resource.files) {
+      Log.log(`[FirmwareUpdateV4] downloading boot resource ${file.devicePath}`);
+      const { binary } = await getSysResourceBinary(file.url);
+      if (!isProtocolV2ResourceFileValid(binary, file)) {
+        throw new Error(`Boot resource file verification failed: ${file.devicePath}`);
+      }
+      files.push({
+        name: file.name ?? file.devicePath.split('/').pop() ?? file.devicePath,
+        binary,
+        devicePath: file.devicePath,
       });
     }
+    return files;
+  }
+
+  private prepareExplicitProtocolV2ResourceFiles(): ProtocolV2ResourceBundleBinary[] | undefined {
+    const files = this.params.resourceFiles ?? [];
+    if (!files?.length) return undefined;
 
+    const prepared = files.map((file, index) => {
+      const devicePath = validateProtocolV2FilesystemPath(
+        file.devicePath,
+        `resourceFiles[${index}].devicePath`
+      );
+      const descriptor = file as typeof file &
+        Pick<Partial<IProtocolV2ResourceFile>, 'size' | 'fileHash'>;
+      if (descriptor.size !== undefined && descriptor.size !== file.binary.byteLength) {
+        throw new Error(`resourceFiles[${index}] size mismatch`);
+      }
+      if (
+        descriptor.fileHash &&
+        !isProtocolV2ResourceFileValid(file.binary, {
+          size: file.binary.byteLength,
+          fileHash: descriptor.fileHash,
+        })
+      ) {
+        throw new Error(`resourceFiles[${index}] SHA-256 mismatch`);
+      }
+      return {
+        name: devicePath.split('/').pop() ?? devicePath,
+        binary: file.binary,
+        devicePath,
+      };
+    });
+    if (new Set(prepared.map(file => file.devicePath)).size !== prepared.length) {
+      throw new Error('resourceFiles contain duplicate devicePath values');
+    }
+    return prepared;
+  }
+
+  private async prepareProtocolV2ResourceBundles(): Promise<
+    ProtocolV2ResourceBundleBinary[] | undefined
+  > {
     if (!this.params.targetsToUpdate?.includes('resource')) {
       return undefined;
     }
 
-    // Remote-config bundles are downloaded and compared later.
-    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
-    if (!release?.resourceBundles?.length) return undefined;
-
-    return release.resourceBundles.map((bundle, index) => ({
-      name: bundle.name,
-      binary: new ArrayBuffer(0),
-      devicePath: validateProtocolV2FilesystemPath(
-        bundle.devicePath,
-        `resourceBundles[${index}].devicePath`
-      ),
-      url: bundle.url,
-      version: bundle.version,
-      payloadHash: bundle.payloadHash,
-      headerHash: bundle.headerHash,
-    })) as ProtocolV2ResourceBundleBinary[];
-  }
-
-  private async materializeProtocolV2ResourceBundles(
-    bundles: ProtocolV2ResourceBundleBinary[]
-  ): Promise<ProtocolV2ResourceBundleBinary[]> {
-    for (const bundle of bundles) {
-      let { binary } = bundle;
-      let downloadedFromRemote = false;
-      if (binary.byteLength === 0) {
-        if (!bundle.url) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.FirmwareUpdateDownloadFailed,
-            `Missing Protocol V2 RESC bundle binary: ${bundle.name}`
-          );
-        }
-        if (
-          this.params.artifactReader ||
-          DataManager.getSettings('firmwareManifestMode') === 'external-only'
-        ) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.RuntimeError,
-            `Firmware resource bundle ${bundle.name} is not prepared`,
-            {
-              firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-              artifactName: bundle.name,
-            }
-          );
-        }
-        Log.log(`[FirmwareUpdateV4] downloading remote RESC bundle ${bundle.name}`);
-        ({ binary } = await getSysResourceBinary(bundle.url));
-        bundle.binary = binary;
-        downloadedFromRemote = true;
-      }
-      if (bundle.binary.byteLength === 0) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.FirmwareUpdateDownloadFailed,
-          `Protocol V2 RESC bundle is empty: ${bundle.name}`
-        );
-      }
-      if (downloadedFromRemote) {
-        const header = parseProtocolV2OkppHeader(toProtocolV2Bytes(binary));
-        if (!header || header.type !== 'RESC') {
-          throw new Error(`Invalid Protocol V2 RESC bundle header: ${bundle.name}`);
-        }
-        if (bundle.version && compareProtocolV2Versions(header.version, bundle.version) !== 0) {
-          throw new Error(`Protocol V2 RESC bundle version mismatch: ${bundle.name}`);
-        }
-        const expectedPayloadHash = normalizeProtocolV2Hex(bundle.payloadHash);
-        if (expectedPayloadHash && header.payloadHash !== expectedPayloadHash) {
-          throw new Error(`Protocol V2 RESC bundle payload hash mismatch: ${bundle.name}`);
-        }
-        const expectedHeaderHash = normalizeProtocolV2Hex(bundle.headerHash);
-        if (expectedHeaderHash && header.headerHash !== expectedHeaderHash) {
-          throw new Error(`Protocol V2 RESC bundle header hash mismatch: ${bundle.name}`);
-        }
-      }
+    const resources = DataManager.getProtocolV2Resources(this.getProtocolV2DeviceType());
+    if (!resources?.length) {
+      throw new Error('Missing Pro2 stable resource configuration');
+    }
+
+    const inventory = this.params.forcedUpdateRes
+      ? undefined
+      : await readProtocolV2ResourceInventory({
+          commands: this.device.getCommands(),
+          resources,
+          chunkSize: this.getProtocolV2FirmwareChunkSize(),
+          timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+        });
+    const plan = buildProtocolV2ResourceUpdatePlan({
+      resources,
+      inventory,
+      mode: 'bootloader-recovery',
+      forced: this.params.forcedUpdateRes,
+    });
+    Log.log(
+      `[FirmwareUpdateV4] Protocol V2 resource plan mode=bootloader-recovery status=${plan.status} count=${plan.resources.length}`
+    );
+
+    const bundles: ProtocolV2ResourceBundleBinary[] = [];
+    for (const resource of plan.resources) {
+      bundles.push(await this.downloadProtocolV2Resource(resource));
     }
     return bundles;
   }
 
-  /**
-   * Compare the existing okpkg OKPP header in remote-config mode.
-   */
-  private async isProtocolV2ResourceBundleUpToDate(
-    bundle: Pick<
-      ProtocolV2ResourceBundleBinary,
-      'name' | 'devicePath' | 'version' | 'payloadHash' | 'headerHash'
-    >
-  ): Promise<boolean> {
-    if (this.params?.forcedUpdateRes) return false;
-    if (!bundle.version && !bundle.payloadHash) return false;
+  private async downloadProtocolV2Resource(
+    resource: IProtocolV2Resource
+  ): Promise<ProtocolV2ResourceBundleBinary> {
+    Log.log(`[FirmwareUpdateV4] downloading Pro2 resource ${resource.type}`);
+    const { binary } = await getSysResourceBinary(resource.url);
+    if (!isProtocolV2ResourceFileValid(binary, resource)) {
+      throw new Error(`Pro2 resource file verification failed: ${resource.type}`);
+    }
+    return {
+      name: `${resource.type}.okpkg`,
+      binary,
+      devicePath: PROTOCOL_V2_RESOURCE_DEVICE_PATHS[resource.type],
+    };
+  }
 
-    try {
-      const header = await this.readProtocolV2DeviceFileHeader(bundle.devicePath);
-      if (!header) return false;
+  private async syncProtocolV2ResourceBundles(
+    bundles: ProtocolV2ResourceBundleBinary[],
+    firmwareSize: number
+  ): Promise<{ processedSize: number; totalSize: number }> {
+    const transferStartTime = Date.now();
+    const transferTransport = this.getProtocolV2FirmwareTransferTransport();
 
-      if (bundle.version) {
-        const cmp = compareProtocolV2Versions(header.version, bundle.version);
-        if (cmp === undefined || cmp !== 0) return false;
-      }
-      if (bundle.payloadHash) {
-        const expected = normalizeProtocolV2Hex(bundle.payloadHash);
-        if (expected && header.payloadHash !== expected) return false;
-      }
-      if (bundle.headerHash) {
-        const expected = normalizeProtocolV2Hex(bundle.headerHash);
-        if (expected && header.headerHash !== expected) return false;
-      }
-      return true;
-    } catch (error) {
-      Log.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
-      return false;
+    // Write directly to the device through FileWrite.
+    let totalSize = 0;
+    for (const b of bundles) totalSize += b.binary.byteLength;
+
+    const transferTotalSize = totalSize + firmwareSize;
+    let processedSize = 0;
+    for (const bundle of bundles) {
+      Log.log(
+        `[FirmwareUpdateV4] syncing resource ${bundle.name} -> ${bundle.devicePath} bytes=${bundle.binary.byteLength}`
+      );
+      processedSize = await this.protocolV2CommonUpdateProcess({
+        payload: bundle.binary,
+        filePath: bundle.devicePath,
+        processedSize,
+        totalSize: transferTotalSize,
+      });
     }
+
+    const elapsedMs = Date.now() - transferStartTime;
+    Log.log(
+      `[FirmwareUpdateV4] resource sync finished transport=${transferTransport} bytes=${totalSize} elapsed=${(
+        elapsedMs / 1000
+      ).toFixed(2)}s speed=${formatProtocolV2TransferSpeed(totalSize, elapsedMs)} KB/s`
+    );
+    return { processedSize, totalSize: transferTotalSize };
   }
 
   private isProtocolV2BootloaderMode() {
     if (typeof this.device.isBootloader === 'function') {
-      return this.device.isBootloader();
+      return !!this.device.isBootloader();
     }
     return (
       this.device.features?.mode === 'bootloader' ||
@@ -1348,7 +965,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   private isProtocolV2RomloaderMode() {
-    if (!this.device.isProtocolV2() || this.device.getCurrentDeviceType() !== EDeviceType.Pro2) {
+    const deviceType = this.device.getCurrentDeviceType();
+    if (
+      !this.device.isProtocolV2() ||
+      (deviceType !== EDeviceType.Pro2 && deviceType !== EDeviceType.Neo)
+    ) {
       return false;
     }
     if (typeof this.device.isRomloader === 'function') {
@@ -1362,22 +983,20 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     // 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;
     }
 
     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) {
@@ -1394,13 +1013,17 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   ) {
     const startTime = Date.now();
     let lastError: unknown;
+    let shouldReconnect = true;
 
     while (Date.now() - startTime < timeout) {
       try {
-        await this.reconnectProtocolV2Device();
+        if (shouldReconnect) {
+          await this.reconnectProtocolV2Device();
+          shouldReconnect = false;
+        }
         const deviceInfo = await requestProtocolV2DeviceInfo({
           commands: this.device.getCommands(),
-          timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+          timeoutMs: this.getProtocolV2DeviceInfoTimeout(),
         });
         this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
         const features = await this.device.probeProtocolV2RuntimeState(
@@ -1415,6 +1038,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         if (this.isProtocolV2ReconnectIdentityError(error)) {
           throw error;
         }
+        shouldReconnect = true;
         lastError = error;
         Log.log('Protocol V2 bootloader mode not ready, polling reconnect: ', error);
       }
@@ -1467,98 +1091,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return entries;
   }
 
-  private buildProtocolV2ExecutionPhases({
-    installSources,
-    resourceSources,
-  }: {
-    installSources: ProtocolV2InstallSource[];
-    resourceSources: ProtocolV2ResourceBundleSource[];
-  }): ProtocolV2ExecutionPhase[] {
-    const phases: ProtocolV2ExecutionPhase[] = [];
-    if (resourceSources.length > 0) {
-      phases.push({
-        kind: 'resource-sync',
-        installSources: [],
-        resourceSources,
-      });
-    }
-    const bootloaderSources = installSources.filter(source => source.kind === 'bootloader');
-    if (bootloaderSources.length > 0) {
-      phases.push(
-        {
-          kind: 'bootloader-install',
-          installSources: bootloaderSources,
-          resourceSources: [],
-        },
-        {
-          kind: 'bootloader-verify',
-          installSources: [],
-          resourceSources: [],
-        }
-      );
-    }
-    const componentSources = installSources.filter(source => source.kind !== 'bootloader');
-    if (componentSources.length > 0) {
-      phases.push({
-        kind: 'component-install',
-        installSources: componentSources,
-        resourceSources: [],
-      });
-    }
-    phases.push({
-      kind: 'final-verify',
-      installSources: [],
-      resourceSources: [],
-    });
-    return phases;
-  }
-
-  private async executeProtocolV2Phases({
-    installSources,
-    resourceSources,
-  }: {
-    installSources: ProtocolV2InstallSource[];
-    resourceSources: ProtocolV2ResourceBundleSource[];
-  }) {
-    const phases = this.buildProtocolV2ExecutionPhases({
-      installSources,
-      resourceSources,
-    });
-    for (const phase of phases) {
-      if (phase.kind === 'final-verify') {
-        return this.completeProtocolV2FinalVerification();
-      }
-      if (phase.kind === 'resource-sync') {
-        await this.enterProtocolV2BootloaderMode();
-        await this.executeProtocolV2TransferPhase(phase);
-      } else if (phase.kind === 'bootloader-install' || phase.kind === 'component-install') {
-        await this.enterProtocolV2BootloaderMode();
-        await this.executeProtocolV2TransferPhase(phase);
-        await this.exitProtocolV2BootloaderToNormal();
-      } else if (phase.kind === 'bootloader-verify') {
-        await this.waitForProtocolV2FinalFeatures();
-        this.assertExpectedProtocolV2Versions(['boot']);
-      }
-    }
-    throw ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      'Protocol V2 execution has no final verification phase'
-    );
-  }
-
-  private async executeProtocolV2SourceUpdate({
-    installSources,
-    resourceSources,
-  }: {
-    installSources: ProtocolV2InstallSource[];
-    resourceSources: ProtocolV2ResourceBundleSource[];
-  }) {
-    return this.executeProtocolV2Phases({
-      installSources,
-      resourceSources,
-    });
-  }
-
   private async executeProtocolV2Update({
     fwBinaryMap,
     bootloaderBinary,
@@ -1570,158 +1102,104 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     installItems?: ProtocolV2InstallItem[];
     resourceBundles?: ProtocolV2ResourceBundleBinary[];
   }) {
-    const memoryInstallItems =
+    const orderedInstallItems =
       installItems ??
       this.buildProtocolV2InstallItems({
-        fwBinaryMap: fwBinaryMap ?? [],
         bootloaderBinary: bootloaderBinary ?? null,
+        fwBinaryMap: fwBinaryMap ?? [],
       });
-    try {
-      const installSources = await Promise.all(
-        memoryInstallItems.map(async item => ({
-          fileName: item.fileName,
-          source: await this.openProtocolV2MemorySource(item.binary),
-          targetId: item.targetId,
-          kind: item.kind,
-        }))
-      );
-      const resourceSources = await Promise.all(
-        (resourceBundles ?? []).map(async bundle => ({
-          name: bundle.name,
-          source: await this.openProtocolV2MemorySource(bundle.binary),
-          devicePath: bundle.devicePath,
-          version: bundle.version,
-          payloadHash: bundle.payloadHash,
-          headerHash: bundle.headerHash,
-        }))
-      );
-      return await this.executeProtocolV2Phases({
-        installSources,
-        resourceSources,
-      });
-    } finally {
-      await this.closeProtocolV2PreparedSources();
-    }
-  }
 
-  private async executeProtocolV2TransferPhase({
-    installSources,
-    resourceSources,
-  }: ProtocolV2ExecutionPhase) {
-    let totalSize = installSources.reduce((total, item) => total + item.source.size, 0);
-    const resourcesToSync: ProtocolV2ResourceBundleSource[] = [];
-    for (const resource of resourceSources) {
-      if (await this.isProtocolV2ResourceBundleUpToDate(resource)) {
-        Log.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
-      } else {
-        resourcesToSync.push(resource);
-        totalSize += resource.source.size;
-      }
-    }
+    let firmwareSize = 0;
+    for (const item of orderedInstallItems) firmwareSize += item.binary.byteLength;
 
     this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
+
     let processedSize = 0;
-    for (const resource of resourcesToSync) {
-      processedSize = await this.protocolV2SourceUpdateProcess({
-        source: resource.source,
-        filePath: resource.devicePath,
-        processedSize,
-        totalSize,
-      });
-      await this.verifyProtocolV2StagedFile(resource.devicePath, resource.source.size);
+    let totalSize = firmwareSize;
+    if (resourceBundles?.length) {
+      const resourceTransfer = await this.syncProtocolV2ResourceBundles(
+        resourceBundles,
+        firmwareSize
+      );
+      processedSize = resourceTransfer.processedSize;
+      totalSize = resourceTransfer.totalSize;
     }
 
-    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,
-      });
+    // Skip staging and installation when the update contains resource files only.
+    if (orderedInstallItems.length === 0) {
+      Log.log('[FirmwareUpdateV4] no firmware targets to install (resource files only)');
+      if (totalSize > 0) {
+        this.postProgressMessage(100, 'transferData');
+      }
+      return;
     }
+    let transferredSize = processedSize;
+    const transferStartTime = Date.now();
+    const transferTransport = this.getProtocolV2FirmwareTransferTransport();
+    const chunkSize = this.getProtocolV2FirmwareChunkSize();
+    const onTransferredBytes = (bytes: number) => {
+      transferredSize = bytes;
+    };
+    Log.log(
+      `[FirmwareUpdateV4] transfer started transport=${transferTransport} total=${totalSize} bytes chunk=${chunkSize} bytes`
+    );
 
-    if (totalSize > 0) {
-      this.postProgressMessage(100, 'transferData');
-    }
-    if (stagedInstallTargets.length === 0) {
-      return;
+    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');
+      }
+
+      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;
     }
 
     this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
-    const targets = stagedInstallTargets.map(item => ({
+
+    const allTargets = stagedInstallTargets.map(item => ({
       target_id: item.targetId,
       path: item.path,
     }));
-    await this.protocolV2StartFirmwareUpdate({ targets });
-    await this.waitForProtocolV2FirmwareUpdateComplete(targets);
-  }
-
-  private async protocolV2SourceUpdateProcess({
-    source,
-    filePath,
-    processedSize,
-    totalSize,
-  }: {
-    source: FirmwareByteSource;
-    filePath: string;
-    processedSize: number;
-    totalSize: number;
-  }) {
-    let lastError: unknown;
-    for (let attempt = 1; attempt <= PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT; attempt += 1) {
-      try {
-        await writeFirmwareByteSource({
-          source,
-          chunkSize: this.getProtocolV2FirmwareChunkSize(),
-          write: async ({ data, sourceOffset, length, first }) => {
-            const chunkEnd = sourceOffset + length;
-            const progress = getProtocolV2DeviceTransferProgress(
-              processedSize + sourceOffset,
-              processedSize + chunkEnd,
-              totalSize
-            );
-            const response = await this.fileWriteChunk(
-              filePath,
-              source.size,
-              sourceOffset,
-              data,
-              first,
-              progress
-            );
-            const rawProcessedByte = response.message.processed_byte;
-            const nextOffset = rawProcessedByte === undefined ? chunkEnd : Number(rawProcessedByte);
-            if (!Number.isFinite(nextOffset) || nextOffset !== chunkEnd) {
-              throw ERRORS.TypedError(
-                HardwareErrorCode.EmmcFileWriteFirmwareError,
-                `invalid processed_byte ${rawProcessedByte} for offset ${sourceOffset}`
-              );
-            }
-            this.postProgressMessage(progress, 'transferData');
-            return length;
-          },
-        });
-        return processedSize + source.size;
-      } catch (error) {
-        lastError = error;
-        if (attempt < PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
-          await this.recoverProtocolV2FileTransfer();
-        }
-      }
-    }
-    throw ERRORS.TypedError(
-      HardwareErrorCode.EmmcFileWriteFirmwareError,
-      `transfer data error: ${getProtocolV2UnknownErrorText(lastError)}`
-    );
+    Log.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateRequest targets=${JSON.stringify(allTargets)}`);
+    await this.protocolV2StartFirmwareUpdate({ targets: allTargets });
+    await this.waitForProtocolV2FirmwareUpdateComplete(allTargets);
   }
 
-  private getProtocolV2InstallItemStagingPath(item: Pick<ProtocolV2InstallItem, 'fileName'>) {
+  private getProtocolV2InstallItemStagingPath(item: ProtocolV2InstallItem) {
     return `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}${item.fileName}`;
   }
 
@@ -1740,8 +1218,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private assertProtocolV2TargetStatus(
     statusTargets: ProtocolV2FirmwareUpdateStatusTarget[],
-    expectedTargetIds: Set<number>,
-    expectedPaths = new Map<number, string>()
+    expectedTargetIds: Set<number>
   ) {
     Log.log(
       `[FirmwareUpdateV4] DeviceFirmwareUpdateStatus records=${JSON.stringify(statusTargets)}`
@@ -1772,54 +1249,17 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const matchingTargets = statusTargets.filter(target =>
       expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1)
     );
-    const seenTargetIds = new Set<number>();
-    for (const target of matchingTargets) {
-      const targetId = normalizeProtocolV2TargetId(target.target_id);
-      if (
-        targetId === undefined ||
-        seenTargetIds.has(targetId) ||
-        (target.path && expectedPaths.get(targetId) && target.path !== expectedPaths.get(targetId))
-      ) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `Protocol V2 install status conflicts with target ${target.target_id}`
-        );
-      }
-      seenTargetIds.add(targetId);
-    }
-    const completedTargets = matchingTargets.filter(target =>
-      isProtocolV2TargetStatusFinished(target.status)
-    );
     const completedTargetIds = new Set<number>();
-    completedTargets.forEach(target => {
+    matchingTargets.forEach(target => {
       const targetId = normalizeProtocolV2TargetId(target.target_id);
-      if (targetId !== undefined) {
+      if (targetId !== undefined && isProtocolV2TargetStatusFinished(target.status)) {
         completedTargetIds.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);
-        }
-      }
+    const allExpectedTargetsCompleted =
+      expectedTargetIds.size > 0 &&
+      Array.from(expectedTargetIds).every(targetId => completedTargetIds.has(targetId));
+    if (allExpectedTargetsCompleted) {
       this.postProgressMessage(100, 'installingFirmware');
       return true;
     }
@@ -1840,19 +1280,43 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     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 async waitForProtocolV2FirmwareUpdateComplete(
     targets: Array<{ target_id: number; path: string }>
   ) {
-    this.protocolV2FinalStatusVerified = false;
     const expectedTargetIds = new Set(targets.map(target => target.target_id));
-    const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
     const startTime = Date.now();
     let lastError: unknown;
+    let shouldReconnect = true;
+    let deviceInfo: ProtocolV2DeviceInfo | undefined;
+    let missingTargetStatusSince: number | undefined;
+    let missingTargetStatusKey: string | undefined;
+    const resetMissingTargetStatusGrace = () => {
+      missingTargetStatusSince = undefined;
+      missingTargetStatusKey = undefined;
+    };
 
     while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
       try {
-        await this.reconnectProtocolV2Device();
-        const deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+        if (shouldReconnect) {
+          await this.reconnectProtocolV2Device();
+          deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+          shouldReconnect = false;
+        }
+        const currentDeviceInfo = deviceInfo;
         try {
           const statusResponse = await this.device.getCommands().typedCall(
             'DeviceFirmwareUpdateStatusGet',
@@ -1864,19 +1328,57 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
                 path: true,
               },
             },
-            { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT }
+            { timeoutMs: PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT }
           );
+          const statusTargets = (statusResponse.message.records ??
+            []) as ProtocolV2FirmwareUpdateStatusTarget[];
+          if (this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds)) {
+            return;
+          }
+
           if (
-            this.assertProtocolV2TargetStatus(
-              (statusResponse.message.records ?? []) as ProtocolV2FirmwareUpdateStatusTarget[],
-              expectedTargetIds,
-              expectedPaths
-            )
+            statusTargets.length === 0 &&
+            currentDeviceInfo &&
+            (await this.probeProtocolV2NormalMode(currentDeviceInfo))
           ) {
-            this.protocolV2FinalStatusVerified = true;
+            Log.log(
+              '[FirmwareUpdateV4] empty firmware status after confirmed App reboot; update complete'
+            );
+            this.postProgressMessage(100, 'installingFirmware');
             return;
           }
-          lastError = new Error('Protocol V2 firmware targets are still installing');
+
+          const missingTargetIds = this.getProtocolV2MissingTargetIds(
+            statusTargets,
+            expectedTargetIds
+          );
+          if (missingTargetIds.length > 0) {
+            const now = Date.now();
+            const missingKey = missingTargetIds.join(',');
+            if (missingTargetStatusSince === undefined || missingTargetStatusKey !== missingKey) {
+              missingTargetStatusSince = now;
+              missingTargetStatusKey = missingKey;
+            } else if (
+              now - missingTargetStatusSince >=
+              PROTOCOL_V2_MISSING_TARGET_STATUS_GRACE_TIMEOUT
+            ) {
+              const reportedTargetIds = statusTargets
+                .map(target => normalizeProtocolV2TargetId(target.target_id))
+                .filter((targetId): targetId is number => targetId !== undefined);
+              throw ERRORS.TypedError(
+                HardwareErrorCode.FirmwareError,
+                `Protocol V2 firmware status is missing requested records: targetIds=${missingKey} reportedTargetIds=${reportedTargetIds.join(
+                  ','
+                )}`
+              );
+            }
+            lastError = new Error(
+              `Protocol V2 firmware status is temporarily missing targetIds=${missingKey}`
+            );
+          } else {
+            resetMissingTargetStatusGrace();
+            lastError = new Error('Protocol V2 firmware targets are still installing');
+          }
         } catch (error) {
           if (
             error instanceof HardwareError &&
@@ -1884,19 +1386,31 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           ) {
             throw error;
           }
+          // Only consecutive full status dumps can prove that a record is absent.
+          // A reboot or transport interruption starts a fresh grace window.
+          resetMissingTargetStatusGrace();
           // App firmware does not register DeviceFirmwareUpdateStatusGet. Treat the
           // missing endpoint as completion only after the runtime probe confirms App mode.
           if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
-            if (await this.probeProtocolV2NormalMode(deviceInfo)) {
+            if (!currentDeviceInfo) {
+              throw ERRORS.TypedError(
+                HardwareErrorCode.RuntimeError,
+                'Protocol V2 device identity is unavailable during install polling'
+              );
+            }
+            if (await this.probeProtocolV2NormalMode(currentDeviceInfo)) {
               Log.log(
                 '[FirmwareUpdateV4] firmware status endpoint unavailable after confirmed App reboot'
               );
+              this.postProgressMessage(100, 'installingFirmware');
               return;
             }
             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: ',
@@ -1912,12 +1426,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         if (error instanceof HardwareError && error.errorCode === HardwareErrorCode.FirmwareError) {
           throw error;
         }
-        if (
-          error instanceof HardwareError &&
-          error.params?.firmwareUpdateCode === 'FirmwareInstallStatusUnavailable'
-        ) {
-          throw error;
-        }
+        shouldReconnect = true;
+        deviceInfo = undefined;
+        resetMissingTargetStatusGrace();
         Log.log('Protocol V2 firmware install device readiness probe failed: ', error);
       }
       await wait(1000);
@@ -1925,17 +1436,24 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     throw ERRORS.TypedError(
       HardwareErrorCode.RuntimeError,
-      `Protocol V2 firmware update status timeout: ${this.normalizeErrorMessage(lastError)}`
+      `Protocol V2 firmware update status not complete within ${
+        PROTOCOL_V2_INSTALL_TIMEOUT / 1000
+      }s: ${this.normalizeErrorMessage(lastError)}`
     );
   }
 
   private async exitProtocolV2BootloaderToNormal() {
     await this.reconnectProtocolV2Device();
-    await this.verifyProtocolV2ReconnectIdentity();
-    // The connection may still be in bootloader. Request a Normal reboot directly;
-    // repeating it after an automatic App reboot is idempotent.
+    const deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+    try {
+      if (await this.probeProtocolV2NormalMode(deviceInfo)) {
+        Log.log('[FirmwareUpdateV4] device already returned to App mode; skip Normal reboot');
+        return;
+      }
+    } catch (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) {
@@ -1951,10 +1469,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       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.'
@@ -1968,27 +1489,20 @@ 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;
 
     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(),
           // Completion needs target versions only; keep scope aligned with the request.
           request: PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
         });
@@ -1997,21 +1511,22 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           deviceInfo,
           PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
         );
-        if (features.mode !== 'normal' || features.bootloaderMode) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.DeviceNotFound,
-            'Protocol V2 device is still in bootloader mode'
-          );
+        if (features.mode === 'normal' && !features.bootloaderMode) {
+          return features;
         }
-        return features;
+        lastError = ERRORS.TypedError(
+          HardwareErrorCode.DeviceNotFound,
+          'Protocol V2 device is still in bootloader mode'
+        );
       } catch (error) {
         if (this.isProtocolV2ReconnectIdentityError(error)) {
           throw error;
         }
+        shouldReconnect = true;
         lastError = error;
         Log.log('Protocol V2 normal mode not ready, polling Ping: ', error);
-        await wait(1000);
       }
+      await wait(1000);
     }
 
     throw ERRORS.TypedError(
@@ -2035,9 +1550,13 @@ 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
@@ -2048,20 +1567,29 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       return;
     }
 
-    // App and bootloader serials may differ temporarily. During V4 reconnect, accept
-    // only a uniquely enumerated device instead of repeatedly using the old App path.
+    // 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]);
+    this.device.updateFromCache(reconnectDevice);
     await this.ensureProtocolV2DeviceAcquired();
     this.device.commands.disposed = false;
     this.device.getCommands().mainId = this.device.mainId ?? '';
@@ -2085,35 +1613,99 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return this.normalizeErrorMessage(error).includes('Protocol V2 reconnect physical identity');
   }
 
-  private async fileWriteChunk(
-    filePath: string,
-    totalFileSize: number,
-    offset: number,
-    chunk: ArrayBuffer | Buffer,
-    overwrite: boolean,
-    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,
-      },
-      overwrite,
-      append: false,
-      ui_percentage: progress ?? undefined,
-    });
-    if (writeRes.type !== 'FilesystemFile') {
-      if ((writeRes as any).type === 'CallMethodError') {
-        if (((writeRes as any).message.error ?? '').indexOf(SESSION_ERROR) > -1) {
-          throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, SESSION_ERROR);
+  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');
     }
-    return writeRes;
+
+    throw ERRORS.TypedError(
+      HardwareErrorCode.EmmcFileWriteFirmwareError,
+      `transfer data error: ${getProtocolV2UnknownErrorText(lastError)}`
+    );
+  }
+
+  private async protocolV2WriteWholeFile({
+    payload,
+    filePath,
+    processedSize,
+    totalSize,
+    onTransferredBytes,
+  }: ProtocolV2FileTransferParams) {
+    const chunkSize = this.getProtocolV2FirmwareChunkSize();
+    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);
+    };
+
+    try {
+      await writeProtocolV2File({
+        commands: this.device.getCommands(),
+        path: filePath,
+        data: payload,
+        totalSize: payload.byteLength,
+        chunkSize,
+        overwrite: true,
+        append: false,
+        writeWithResponse: true,
+        maxChunkRetries: 0,
+        getUiPercentage: ({ offset, chunkLength }) =>
+          getProtocolV2DeviceTransferProgress(
+            (processedSize ?? 0) + offset,
+            (processedSize ?? 0) + offset + chunkLength,
+            totalSize ?? payload.byteLength
+          ),
+        onProgress: progress => {
+          const transferredBytes = (processedSize ?? 0) + progress.transferredBytes;
+          onTransferredBytes?.(transferredBytes);
+          this.postProgressMessage(getUploadProgress(progress.transferredBytes), 'transferData', {
+            transferredBytes,
+            totalBytes: totalSize ?? payload.byteLength,
+            rateBytesPerSecond: progress.rateBytesPerSecond,
+            elapsedMs: progress.elapsedMs,
+          });
+        },
+      });
+    } catch (error) {
+      if (
+        error instanceof HardwareError &&
+        error.errorCode === HardwareErrorCode.RuntimeError &&
+        error.message.includes('FilesystemFileWrite')
+      ) {
+        throw ERRORS.TypedError(HardwareErrorCode.EmmcFileWriteFirmwareError, error.message);
+      }
+      throw error;
+    }
+
+    return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
+  }
+
+  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 async recoverProtocolV2FileTransfer() {