@onekeyfe/hd-core 1.2.0-alpha.95 → 1.2.0-alpha.97

package/src/api/FirmwareUpdateV4.ts

@@ -1,5 +1,4 @@
 import { EDeviceType, ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
-import JSZip from 'jszip';
 import {
   DeviceRebootType,
   PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
@@ -10,6 +9,7 @@ import {
 import { sha256 } from '@noble/hashes/sha256';
 
 import { FirmwareUpdateTipMessage, UI_REQUEST } from '../events/ui-request';
+import { validateProtocolV2FilesystemPath } from './helpers/filesystemValidation';
 import { validateParams } from './helpers/paramsValidator';
 import {
   LoggerNames,
@@ -31,31 +31,21 @@ import {
 } from '../protocols/protocol-v2';
 import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
 import {
-  parseProtocolV2ResourceManifest,
-  selectProtocolV2ResourceManifestFiles,
+  PROTOCOL_V2_RESOURCE_DEVICE_PATHS,
+  buildProtocolV2ResourceUpdatePlan,
+  isProtocolV2ResourceFileValid,
+  readProtocolV2ResourceInventory,
 } 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 { openFirmwareByteSource, writeFirmwareByteSource } from './firmware/FirmwareArtifactSource';
+import { resolveFirmwareUpdateHostBinding } from './firmware/FirmwareHostBinding';
 import {
   assertFirmwareUpdatePreparedPlanBinding,
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
-  prepareFirmwareUpdatePlan,
-  validateFirmwareUpdatePreparedPlan,
 } from './firmware/FirmwareUpdatePreparedPlan';
-import { prepareFirmwareUpdateV4MemoryHost } from './firmware/FirmwareMemoryHost';
-import { buildProtocolV2LocalFirmwareUpdatePlan } from './firmware/FirmwareUpdatePlan';
 
 import type {
   FirmwareArtifactReference,
@@ -69,14 +59,11 @@ import type {
   Features,
   IFirmwareReleaseInfo,
   IProtocolV2FirmwareComponent,
+  IProtocolV2Resource,
+  IProtocolV2ResourceFile,
   IVersionArray,
 } from '../types';
 import type { FirmwareByteSource } from './firmware/FirmwareArtifactSource';
-import type {
-  FirmwareMemoryArtifact,
-  FirmwareMemoryArtifactEntry,
-  FirmwareUpdateV4MemoryHost,
-} from './firmware/FirmwareMemoryHost';
 
 const Log = getLogger(LoggerNames.Method);
 
@@ -108,34 +95,9 @@ 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 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
@@ -186,6 +148,12 @@ type ProtocolV2TargetBinary = { fileName: string; binary: ArrayBuffer; targetId:
 type ProtocolV2InstallItem = ProtocolV2TargetBinary & {
   kind: ProtocolV2RemoteComponentTarget['kind'];
 };
+/** Protocol V2 resource file written independently to devicePath through FileWrite. */
+type ProtocolV2ResourceBundleBinary = {
+  name: string;
+  binary: ArrayBuffer;
+  devicePath: string;
+};
 
 type ProtocolV2RemoteComponentBinary = ProtocolV2RemoteComponentTarget & {
   binary: ArrayBuffer;
@@ -213,18 +181,6 @@ type ProtocolV2ResourceBundleSource = {
   headerHash?: string;
 };
 
-type ProtocolV2LocalResourceArchive = {
-  binary: ArrayBuffer;
-  materializedEntries: FirmwareMemoryArtifactEntry[];
-};
-
-type JSZipSizedEntry = JSZip.JSZipObject & {
-  _data?: {
-    compressedSize?: unknown;
-    uncompressedSize?: unknown;
-  };
-};
-
 type ProtocolV2ExecutionPhaseKind =
   | 'resource-sync'
   | 'bootloader-install'
@@ -296,20 +252,7 @@ const PROTOCOL_V2_FIRMWARE_STAGING_PATHS = new Set(
   )
 );
 
-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 resolveProtocolV2ResourceWritePath = (devicePath: string) => {
-  const normalizedPath = devicePath.replace(/^vol0:(?!\/)/i, 'vol0:/').toLowerCase();
-  return normalizedPath === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH
-    ? PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH
-    : devicePath;
-};
-
-const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map<
-  number,
-  Exclude<FirmwareUpdateV4Target, 'boot_resources'>
->([
+const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map<number, FirmwareUpdateV4Target>([
   [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER, 'boot'],
   [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1, 'app_v1'],
   [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2, 'app_v2'],
@@ -320,19 +263,6 @@ const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map<
   [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.';
 
@@ -604,11 +534,11 @@ 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: 'expectedDeviceId', type: 'string' },
+      { name: 'resourceFiles', type: 'array', allowEmpty: true },
     ]);
     if (
       payload.expectedDeviceId !== undefined &&
@@ -619,101 +549,50 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         '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;
-    } else if (payload.hostBindingGeneration !== undefined) {
-      artifactReader = resolveFirmwareUpdateHostBinding(
-        payload.hostBindingGeneration
-      ).artifactReader;
-    }
-    if (preparedPlan) {
+    const hostBinding =
+      payload.preparedPlan || payload.componentArtifacts || payload.resourceBundleArtifacts
+        ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
+        : undefined;
+    if (hostBinding) {
       assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan,
+        preparedPlan: payload.preparedPlan,
         executor: 'v4',
         platform: payload.platform,
-        scopeTargets: [],
-        bindings: [],
+        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,
+            })
+          ),
+        ],
       });
-      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,
+      preparedPlan: payload.preparedPlan,
       chunkSize: payload.chunkSize,
       forcedUpdateRes: payload.forcedUpdateRes,
       bootloaderBinary: payload.bootloaderBinary,
@@ -725,18 +604,15 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       se02Binary: payload.se02Binary,
       se03Binary: payload.se03Binary,
       se04Binary: payload.se04Binary,
-      resourceArchiveBinary: payload.resourceArchiveBinary,
-      firmwareType: preparedPlan?.firmwareType ?? payload.firmwareType,
-      targetsToUpdate: preparedPlan
-        ? ([...preparedPlan.targetsToUpdate] as FirmwareUpdateV4Target[])
-        : resolvedLocalTargetsToUpdate,
-      expectedTargetVersions: preparedPlan
-        ? preparedExpectedTargetVersions
-        : payload.expectedTargetVersions,
+      resourceFiles: payload.resourceFiles,
+      firmwareType: payload.firmwareType,
+      targetsToUpdate: payload.targetsToUpdate,
+      expectedTargetVersions: payload.expectedTargetVersions,
       platform: payload.platform,
       expectedDeviceId: payload.expectedDeviceId,
-      artifactReader,
-      componentArtifacts: preparedPlan ? undefined : payload.componentArtifacts,
+      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
+      componentArtifacts: payload.componentArtifacts,
+      resourceBundleArtifacts: payload.resourceBundleArtifacts,
     };
   }
 
@@ -783,55 +659,30 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     this.validateExpectedTargetVersions();
 
     if (
-      !this.params.preparedPlan &&
-      this.params.resourceArchiveBinary &&
-      this.params.targetsToUpdate?.includes('resource')
+      (this.params.componentArtifacts && Object.keys(this.params.componentArtifacts).length > 0) ||
+      this.params.resourceBundleArtifacts?.length
     ) {
-      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);
     }
-    const wantsResources = !!this.params.targetsToUpdate?.includes('resource');
+    const hasExplicitResourceFiles = !!this.params.resourceFiles?.length;
+    const wantsStableResources = !!this.params.targetsToUpdate?.includes('resource');
+    const wantsBootResources = !!this.params.targetsToUpdate?.includes('boot_resources');
+    const needsRemoteResources = !hasExplicitResourceFiles && wantsStableResources;
+    const needsRemoteBootResources =
+      !hasExplicitResourceFiles && (wantsBootResources || wantsStableResources);
 
     let fwBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
     let installItems: ProtocolV2InstallItem[] | undefined;
+    let resourceBundles: ProtocolV2ResourceBundleBinary[] | undefined;
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
+      resourceBundles = this.prepareExplicitProtocolV2ResourceFiles();
       fwBinaryMap = this.collectExplicitTargetBinaries();
       bootloaderBinary = this.prepareBootloaderBinary();
-      const explicitInstallItems = this.buildProtocolV2InstallItems({
-        bootloaderBinary,
-        fwBinaryMap,
-      });
-      const missingFirmwareTargets = this.getMissingProtocolV2FirmwareTargets(explicitInstallItems);
-      const needsRemoteFirmware = this.params.targetsToUpdate?.length
-        ? missingFirmwareTargets.length > 0
-        : explicitInstallItems.length === 0;
-      if (wantsResources) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Protocol V2 resource archive must be provided through a local or external PreparedPlan',
-          {
-            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-          }
-        );
-      }
+      const needsRemoteFirmware = !this.hasExplicitProtocolV2Payload(fwBinaryMap);
       if (
-        needsRemoteFirmware &&
+        (needsRemoteFirmware || needsRemoteResources || needsRemoteBootResources) &&
         (this.params.artifactReader ||
           DataManager.getSettings('firmwareManifestMode') === 'external-only')
       ) {
@@ -843,47 +694,74 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           }
         );
       }
-      if (needsRemoteFirmware) {
+      if (needsRemoteFirmware || needsRemoteResources || needsRemoteBootResources) {
         // Remote updates must use a freshly fetched config before any reboot or file write.
-        await DataManager.forceReloadData();
+        await DataManager.forceReloadData({
+          requireResources: needsRemoteResources || needsRemoteBootResources,
+        });
       }
       if (needsRemoteFirmware) {
         const remoteBinaries = await this.prepareRemoteProtocolV2Binaries(
           firmwareType,
-          deviceFeatures,
-          explicitInstallItems
+          deviceFeatures
         );
         bootloaderBinary = remoteBinaries.bootloaderBinary;
         fwBinaryMap = remoteBinaries.fwBinaryMap;
         installItems = remoteBinaries.installItems;
       }
-      this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
-    } catch (err) {
-      if (
-        typeof err === 'object' &&
-        err !== null &&
-        'params' in err &&
-        (err as HardwareError).params?.firmwareUpdateCode === 'FirmwareArtifactsNotPrepared'
-      ) {
-        throw err;
+      const bootResourceFiles = await this.prepareProtocolV2BootResources();
+      if (bootResourceFiles?.length) {
+        resourceBundles = this.mergeProtocolV2ResourceBundles(resourceBundles, bootResourceFiles);
+      }
+      if (!needsRemoteResources) {
+        this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
       }
+    } catch (err) {
       if (err instanceof HardwareError && err.errorCode === HardwareErrorCode.NetworkError) {
         throw err;
       }
       throw normalizeFirmwarePreparationError(err);
     }
 
-    if (!bootloaderBinary && fwBinaryMap.length === 0 && !installItems?.length) {
+    if (
+      !bootloaderBinary &&
+      fwBinaryMap.length === 0 &&
+      !installItems?.length &&
+      !resourceBundles?.length &&
+      !needsRemoteResources
+    ) {
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareUpdateDownloadFailed,
         'No firmware to update'
       );
     }
 
+    if (needsRemoteResources) {
+      const enteredBootloader = await this.enterProtocolV2BootloaderMode();
+      try {
+        const stableResources = await this.prepareProtocolV2ResourceBundles();
+        resourceBundles = this.mergeProtocolV2ResourceBundles(resourceBundles, stableResources);
+        this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+      } catch (err) {
+        if (enteredBootloader) {
+          try {
+            await this.exitProtocolV2BootloaderToNormal();
+          } catch (restoreError) {
+            Log.warn(
+              '[FirmwareUpdateV4] failed to restore App mode after resource preparation error:',
+              restoreError
+            );
+          }
+        }
+        throw normalizeFirmwarePreparationError(err);
+      }
+    }
+
     return this.executeProtocolV2Update({
       fwBinaryMap,
       bootloaderBinary,
       ...(installItems ? { installItems } : undefined),
+      ...(resourceBundles?.length ? { resourceBundles } : undefined),
     });
   }
 
@@ -926,54 +804,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     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 release = DataManager.getFirmwareLatestRelease(features, firmwareType);
     if (!release) {
       throw ERRORS.TypedError(
@@ -1023,430 +853,53 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return installSources;
   }
 
-  private async prepareProtocolV2LocalMemoryHost({
-    features,
-    firmwareType,
-  }: {
-    features: Features;
-    firmwareType: EFirmwareType;
-  }): Promise<FirmwareUpdateV4MemoryHost> {
-    const installItems = this.buildProtocolV2InstallItems({
-      bootloaderBinary: this.prepareBootloaderBinary(),
-      fwBinaryMap: this.collectExplicitTargetBinaries(),
-    });
-    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(
-      installItems.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 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' }
-      );
-    }
-    const zip = await JSZip.loadAsync(binary);
-    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 || entries.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT + 1) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 local resource ZIP entry set is invalid',
-        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-      );
-    }
-    let declaredUncompressedSize = 0;
-    let declaredCompressedSize = 0;
-    for (const entry of entries) {
-      const sizes = getProtocolV2ZipEntrySizes(entry);
-      declaredCompressedSize += sizes.compressedSize;
-      declaredUncompressedSize += sizes.uncompressedSize;
-      const entryLimit =
-        entry.name === 'manifest.json'
-          ? PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
-          : PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES;
-      if (
-        sizes.uncompressedSize > entryLimit ||
-        declaredCompressedSize > binary.byteLength ||
-        declaredUncompressedSize >
-          PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES + PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
-      ) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Protocol V2 local resource ZIP declared size exceeds the allowed limit',
-          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-        );
-      }
-    }
-    const manifestEntry = zip.file('manifest.json');
-    if (!manifestEntry) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 local resource ZIP has no manifest.json',
-        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-      );
-    }
-    const 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' }
-      );
-    }
-    const manifest = parseProtocolV2ResourceManifest(manifestValue);
-    const selectedFiles = selectProtocolV2ResourceManifestFiles({
-      manifest,
-      targetsToUpdate: this.params.targetsToUpdate ?? [],
-    });
-    const expectedEntryNames = new Set([
-      'manifest.json',
-      ...selectedFiles.map(file => file.archive_path),
-    ]);
-    if (
-      entries.length !== expectedEntryNames.size ||
-      entries.some(entry => !expectedEntryNames.has(entry.name))
-    ) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 local resource ZIP contains an unexpected entry',
-        { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
-      );
-    }
-
-    let totalSize = 0;
-    const materializedEntries: FirmwareMemoryArtifactEntry[] = [
-      { entryName: 'manifest.json', binary: manifestBinary },
-    ];
-    for (const file of selectedFiles) {
-      const entry = zip.file(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 || digest !== file.sha256.toLowerCase()) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `Protocol V2 local resource file does not match manifest: ${file.archive_path}`,
-          { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
-        );
-      }
-      materializedEntries.push({ entryName: file.archive_path, binary: fileBinary });
-    }
-    return { binary, materializedEntries };
-  }
-
-  private async prepareProtocolV2ResourceSources(): Promise<ProtocolV2ResourceBundleSource[]> {
-    const resourceRequested = this.params.targetsToUpdate?.includes('resource') ?? false;
+  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 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' }
-      );
-    }
-
-    // materializedEntries 由宿主生成，只有与获批 ZIP 的规范字节完全一致后才能使用。
-    const verifiedArchive = await this.prepareProtocolV2LocalResourceArchive(archiveBinary);
-    const entries = archiveArtifact.materializedEntries ?? [];
-    const entriesByName = new Map(entries.map(entry => [entry.entryName, entry] as const));
-    if (
-      entries.length !== verifiedArchive.materializedEntries.length ||
-      verifiedArchive.materializedEntries.some(entry => {
-        const preparedEntry = entriesByName.get(entry.entryName);
-        const digest = bytesToHex(sha256(new Uint8Array(entry.binary)));
-        return (
-          !preparedEntry ||
-          preparedEntry.artifact.size !== entry.binary.byteLength ||
-          preparedEntry.artifact.sha256.toLowerCase() !== digest
-        );
-      })
-    ) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 prepared resource entries do not match the approved archive',
-        { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' }
-      );
-    }
-
-    const verifiedEntriesByName = new Map(
-      verifiedArchive.materializedEntries.map(entry => [entry.entryName, entry.binary] as const)
+    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+    const descriptors = release?.resourceBundles ?? [];
+    const artifactByName = new Map(
+      preparedArtifacts.map(item => [item.name, item.artifact] 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) {
+    for (const descriptor of descriptors) {
+      const artifact = artifactByName.get(descriptor.name);
+      if (!artifact) {
         throw ERRORS.TypedError(
           HardwareErrorCode.RuntimeError,
-          'Protocol V2 prepared resource archive exceeds the total size limit',
-          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+          `Protocol V2 resource bundle ${descriptor.name} is not prepared`,
+          {
+            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+            artifactName: descriptor.name,
+          }
         );
       }
-      // 使用从获批 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;
+      const devicePath = validateProtocolV2FilesystemPath(
+        descriptor.devicePath,
+        'resourceBundles[].devicePath'
+      );
       sources.push({
-        name: file.original_name || `resource-${index}`,
-        source,
-        devicePath: file.device_path,
-        ...(header
-          ? {
-              version: header.version,
-              payloadHash: header.payloadHash,
-              headerHash: header.headerHash,
-            }
-          : {}),
+        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;
   }
@@ -1455,7 +908,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
       const installSources = await this.prepareProtocolV2InstallSources(firmwareType, features);
-      const resourceSources = await this.prepareProtocolV2ResourceSources();
+      const resourceSources = await this.prepareProtocolV2ResourceSources(firmwareType, features);
       if (installSources.length === 0 && resourceSources.length === 0) {
         throw ERRORS.TypedError(
           HardwareErrorCode.FirmwareUpdateDownloadFailed,
@@ -1485,7 +938,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     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'>
+          target as FirmwareUpdateV4Target
         ) ||
         typeof version !== 'string' ||
         !/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/u.test(version) ||
@@ -1571,13 +1024,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     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.resourceBundleArtifacts?.length || this.params.resourceFiles?.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');
@@ -1605,34 +1058,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     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()
+      this.device.originalDescriptor.path
     );
   }
 
@@ -1652,12 +1083,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private async captureProtocolV2PhysicalIdentity() {
     const deviceInfo = await this.requestProtocolV2PhysicalIdentity();
     const serialNumber = this.getProtocolV2SerialNumber(deviceInfo);
-    const path = this.getProtocolV2ConnectionRoute();
+    const path = this.device.originalDescriptor?.path?.trim() || undefined;
     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);
@@ -1678,19 +1108,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     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] : [];
-      })
+  private hasExplicitProtocolV2Payload(fwBinaryMap: ProtocolV2TargetBinary[]) {
+    return (
+      !!this.params.resourceFiles?.length ||
+      !!this.params.bootloaderBinary ||
+      fwBinaryMap.length > 0
     );
-    return (this.params.targetsToUpdate ?? [])
-      .filter(
-        (target): target is Exclude<FirmwareUpdateV4Target, 'resource' | 'boot_resources'> =>
-          target !== 'resource' && target !== 'boot_resources'
-      )
-      .filter(target => !preparedTargets.has(target));
   }
 
   private buildProtocolV2InstallItems({
@@ -1761,28 +1184,8 @@ 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,
@@ -1805,11 +1208,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     };
   }
 
-  private async prepareRemoteProtocolV2Binaries(
-    firmwareType: EFirmwareType,
-    features: Features,
-    explicitInstallItems: ProtocolV2InstallItem[] = []
-  ) {
+  private async prepareRemoteProtocolV2Binaries(firmwareType: EFirmwareType, features: Features) {
     const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
 
     let bootloaderBinary: ArrayBuffer | null = null;
@@ -1817,15 +1216,6 @@ 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,
@@ -1835,10 +1225,6 @@ 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 targetName = component.target?.toUpperCase();
@@ -1847,34 +1233,27 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         ? PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId)
         : undefined;
       if (updateTarget && targetsToUpdate.has(updateTarget)) {
-        const explicitInstallItem = explicitInstallItemByTargetId.get(target.targetId);
-        const installItem =
-          explicitInstallItem ?? (await this.downloadRemoteProtocolV2Component(key, component));
-        if (installItem.kind === 'bootloader') {
-          bootloaderBinary = installItem.binary;
+        const remoteBinary = await this.downloadRemoteProtocolV2Component(key, component);
+        if (remoteBinary.kind === 'bootloader') {
+          bootloaderBinary = remoteBinary.binary;
+          installItems.push({
+            fileName: remoteBinary.fileName,
+            binary: remoteBinary.binary,
+            targetId: remoteBinary.targetId,
+            kind: remoteBinary.kind,
+          });
         } else {
           const binaryEntry = {
-            fileName: installItem.fileName,
-            binary: installItem.binary,
-            targetId: installItem.targetId,
+            fileName: remoteBinary.fileName,
+            binary: remoteBinary.binary,
+            targetId: remoteBinary.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,
@@ -1882,13 +1261,211 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     };
   }
 
+  private getProtocolV2DeviceType(): EDeviceType.Pro2 | EDeviceType.Neo {
+    const deviceType = this.device.getCurrentDeviceType();
+    if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) return deviceType;
+    throw new Error(`Unsupported Protocol V2 device type: ${deviceType}`);
+  }
+
+  private async prepareProtocolV2BootResources(): Promise<
+    ProtocolV2ResourceBundleBinary[] | undefined
+  > {
+    const wantsStableResources = !!this.params.targetsToUpdate?.includes('resource');
+    const wantsBootResources = !!this.params.targetsToUpdate?.includes('boot_resources');
+    if (!wantsStableResources && !wantsBootResources) {
+      return undefined;
+    }
+    if (this.params.resourceFiles?.length) {
+      return undefined;
+    }
+    const resource = DataManager.getProtocolV2BootResources(this.getProtocolV2DeviceType());
+    if (!resource) {
+      if (wantsBootResources) {
+        throw new Error('Missing Protocol V2 boot resources configuration');
+      }
+      Log.debug('[FirmwareUpdateV4] no boot resources configured; continue with stable resources');
+      return undefined;
+    }
+
+    const files: ProtocolV2ResourceBundleBinary[] = [];
+    for (const file of resource.files) {
+      const isCurrent =
+        !this.params.forcedUpdateRes && (await this.isProtocolV2BootResourceCurrent(file));
+      if (isCurrent) {
+        Log.log(`[FirmwareUpdateV4] boot resource unchanged, skipping ${file.devicePath}`);
+      } else {
+        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 async isProtocolV2BootResourceCurrent(file: IProtocolV2ResourceFile) {
+    try {
+      const commands = this.device.getCommands();
+      const pathInfo = await commands.typedCall(
+        'FilesystemPathInfoQuery',
+        'FilesystemPathInfo',
+        { path: file.devicePath },
+        { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT }
+      );
+      const size = toProtocolV2FiniteNumber(pathInfo.message?.size);
+      if (
+        !pathInfo.message?.exist ||
+        pathInfo.message?.directory ||
+        !Number.isSafeInteger(size) ||
+        size !== file.size
+      ) {
+        return false;
+      }
+
+      const digest = sha256.create();
+      const chunkSize = this.getProtocolV2FirmwareChunkSize('write');
+      let offset = 0;
+      while (offset < file.size) {
+        const response = await commands.typedCall(
+          'FilesystemFileRead',
+          'FilesystemFile',
+          {
+            file: { path: file.devicePath, offset, total_size: 0 },
+            chunk_len: Math.min(chunkSize, file.size - offset),
+          },
+          { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT }
+        );
+        const data = toProtocolV2Bytes(response.message?.data);
+        if (data.byteLength === 0) return false;
+        const consumed = data.subarray(0, Math.min(data.byteLength, file.size - offset));
+        digest.update(consumed);
+        offset += consumed.byteLength;
+      }
+      return bytesToHex(digest.digest()) === normalizeProtocolV2Hex(file.fileHash);
+    } catch (error) {
+      Log.debug(
+        `[FirmwareUpdateV4] unable to compare boot resource ${file.devicePath}; scheduling rewrite`,
+        error
+      );
+      return false;
+    }
+  }
+
+  private mergeProtocolV2ResourceBundles(
+    ...groups: Array<ProtocolV2ResourceBundleBinary[] | undefined>
+  ): ProtocolV2ResourceBundleBinary[] | undefined {
+    const merged = groups.flatMap(group => group ?? []);
+    if (!merged.length) return undefined;
+    const seenPaths = new Set<string>();
+    for (const bundle of merged) {
+      if (seenPaths.has(bundle.devicePath)) {
+        throw new Error(`Duplicate Protocol V2 resource devicePath: ${bundle.devicePath}`);
+      }
+      seenPaths.add(bundle.devicePath);
+    }
+    return merged;
+  }
+
+  private prepareExplicitProtocolV2ResourceFiles(): ProtocolV2ResourceBundleBinary[] | undefined {
+    const files = this.params.resourceFiles ?? [];
+    if (!files?.length) return undefined;
+
+    const prepared = files.map((file, index) => {
+      const devicePath = validateProtocolV2FilesystemPath(
+        file.devicePath,
+        `resourceFiles[${index}].devicePath`
+      );
+      const descriptor = file as typeof file &
+        Pick<Partial<IProtocolV2ResourceFile>, 'size' | 'fileHash'>;
+      if (descriptor.size !== undefined && descriptor.size !== file.binary.byteLength) {
+        throw new Error(`resourceFiles[${index}] size mismatch`);
+      }
+      if (
+        descriptor.fileHash &&
+        !isProtocolV2ResourceFileValid(file.binary, {
+          size: file.binary.byteLength,
+          fileHash: descriptor.fileHash,
+        })
+      ) {
+        throw new Error(`resourceFiles[${index}] SHA-256 mismatch`);
+      }
+      return {
+        name: devicePath.split('/').pop() ?? devicePath,
+        binary: file.binary,
+        devicePath,
+      };
+    });
+    if (new Set(prepared.map(file => file.devicePath)).size !== prepared.length) {
+      throw new Error('resourceFiles contain duplicate devicePath values');
+    }
+    return prepared;
+  }
+
+  private async prepareProtocolV2ResourceBundles(): Promise<
+    ProtocolV2ResourceBundleBinary[] | undefined
+  > {
+    if (!this.params.targetsToUpdate?.includes('resource')) {
+      return undefined;
+    }
+
+    const resources = DataManager.getProtocolV2Resources(this.getProtocolV2DeviceType());
+    if (!resources?.length) {
+      throw new Error('Missing Pro2 stable resource configuration');
+    }
+
+    const inventory = this.params.forcedUpdateRes
+      ? undefined
+      : await readProtocolV2ResourceInventory({
+          commands: this.device.getCommands(),
+          resources,
+          chunkSize: this.getProtocolV2FirmwareChunkSize('write'),
+          timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+        });
+    const plan = buildProtocolV2ResourceUpdatePlan({
+      resources,
+      inventory,
+      mode: 'bootloader-recovery',
+      forced: this.params.forcedUpdateRes,
+    });
+    Log.log(
+      `[FirmwareUpdateV4] Protocol V2 resource plan mode=bootloader-recovery status=${plan.status} count=${plan.resources.length}`
+    );
+
+    const bundles: ProtocolV2ResourceBundleBinary[] = [];
+    for (const resource of plan.resources) {
+      bundles.push(await this.downloadProtocolV2Resource(resource));
+    }
+    return bundles;
+  }
+
+  private async downloadProtocolV2Resource(
+    resource: IProtocolV2Resource
+  ): Promise<ProtocolV2ResourceBundleBinary> {
+    Log.log(`[FirmwareUpdateV4] downloading Pro2 resource ${resource.type}`);
+    const { binary } = await getSysResourceBinary(resource.url);
+    if (!isProtocolV2ResourceFileValid(binary, resource)) {
+      throw new Error(`Pro2 resource file verification failed: ${resource.type}`);
+    }
+    return {
+      name: `${resource.type}.okpkg`,
+      binary,
+      devicePath: PROTOCOL_V2_RESOURCE_DEVICE_PATHS[resource.type],
+    };
+  }
+
   private getProtocolV2ResourceFilePath(path: string) {
     if (path.startsWith('vol')) return path;
     if (path.startsWith('/')) return `vol0:${path}`;
     return `vol0:/${path}`;
   }
 
-  private async readProtocolV2DeviceFileHeader(path: string, expectedSize?: number) {
+  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', {
@@ -1899,8 +1476,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       !pathInfoRes.message?.exist ||
       pathInfoRes.message?.directory ||
       fileSize === undefined ||
-      fileSize < PROTOCOL_V2_OKPP_HEADER_SIZE ||
-      (expectedSize !== undefined && fileSize !== expectedSize)
+      fileSize < PROTOCOL_V2_OKPP_HEADER_SIZE
     ) {
       return null;
     }
@@ -1934,31 +1510,32 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return parseProtocolV2OkppHeader(headerBytes);
   }
 
-  /** Compare the downloaded and installed okpkg headers before transferring a resource. */
+  /** Compare a prepared okpkg header when its manifest supplies version or hash metadata. */
   private async isProtocolV2ResourceBundleUpToDate(
     bundle: Pick<
       ProtocolV2ResourceBundleSource,
-      'name' | 'source' | 'devicePath' | 'version' | 'payloadHash' | 'headerHash'
+      'name' | 'devicePath' | 'version' | 'payloadHash' | 'headerHash'
     >
   ): Promise<boolean> {
     if (this.params?.forcedUpdateRes) return false;
-    if (!bundle.payloadHash || !bundle.headerHash) return false;
+    if (!bundle.version && !bundle.payloadHash) return false;
 
     try {
-      const header = await this.readProtocolV2DeviceFileHeader(
-        bundle.devicePath,
-        bundle.source.size
-      );
+      const header = await this.readProtocolV2DeviceFileHeader(bundle.devicePath);
       if (!header) return false;
 
       if (bundle.version) {
         const cmp = compareProtocolV2Versions(header.version, bundle.version);
         if (cmp === undefined || cmp !== 0) 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;
+      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);
@@ -2114,6 +1691,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     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(
@@ -2129,13 +1713,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         }
       );
     }
-    if (resourceSources.length > 0) {
-      phases.push({
-        kind: 'resource-sync',
-        installSources: [],
-        resourceSources,
-      });
-    }
     const componentSources = installSources.filter(source => source.kind !== 'bootloader');
     if (componentSources.length > 0) {
       phases.push({
@@ -2202,10 +1779,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     fwBinaryMap,
     bootloaderBinary,
     installItems,
+    resourceBundles,
   }: {
     fwBinaryMap?: ProtocolV2TargetBinary[];
     bootloaderBinary?: ArrayBuffer | null;
     installItems?: ProtocolV2InstallItem[];
+    resourceBundles?: ProtocolV2ResourceBundleBinary[];
   }) {
     const memoryInstallItems =
       installItems ??
@@ -2222,9 +1801,16 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           kind: item.kind,
         }))
       );
+      const resourceSources = await Promise.all(
+        (resourceBundles ?? []).map(async bundle => ({
+          name: bundle.name,
+          source: await this.openProtocolV2MemorySource(bundle.binary),
+          devicePath: bundle.devicePath,
+        }))
+      );
       return await this.executeProtocolV2Phases({
         installSources,
-        resourceSources: [],
+        resourceSources,
       });
     } finally {
       await this.closeProtocolV2PreparedSources();
@@ -2249,16 +1835,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
     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,
+        filePath: resource.devicePath,
         processedSize,
         totalSize,
       });
-      await this.verifyProtocolV2StagedFile(writePath, resource.source.size);
+      await this.verifyProtocolV2StagedFile(resource.devicePath, resource.source.size);
     }
 
     const stagedInstallTargets: Array<{ targetId: number; path: string }> = [];