@onekeyfe/hd-core 1.2.0-alpha.82 → 1.2.0-alpha.84

package/__tests__/check-all-firmware-release-protocol-v2.test.ts

@@ -333,6 +333,15 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       resourceArchive: resourceSource,
       resourcePreparationRequired: true,
       targetsToUpdate: ['boot', 'app_v1', 'resource'],
+      firmwareUpdatePlan: {
+        executor: 'v4',
+        platform: 'web',
+        artifacts: [
+          { artifactId: 'component:boot', target: 'boot' },
+          { artifactId: 'component:app_v1', target: 'app_v1' },
+        ],
+        targetsToUpdate: ['boot', 'app_v1'],
+      },
       firmware: {
         status: 'required',
       },
@@ -344,6 +353,260 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
   });
 
+  test('preserves platform and forced firmware targets in the Protocol V2 prepared plan', async () => {
+    const method = new CheckAllFirmwareRelease({
+      id: 1,
+      payload: {
+        method: 'checkAllFirmwareRelease',
+        firmwareType: EFirmwareType.Universal,
+        platform: 'native',
+        forceUpdateTargets: ['firmware'],
+      },
+    });
+    method.init();
+    method.device = {
+      isProtocolV2: () => true,
+      features: {
+        deviceType: 'pro2',
+        serialNo: 'pro2-device-id',
+        firmwareVersion: '1.0.0',
+      },
+      getDeviceState: jest.fn().mockResolvedValue({
+        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
+        status: { mode: 'normal' },
+        versions: currentVersions,
+      }),
+    } as unknown as CheckAllFirmwareRelease['device'];
+    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
+    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
+
+    await expect(method.run()).resolves.toMatchObject({
+      targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03', 'resource'],
+      firmwareUpdatePlan: {
+        executor: 'v4',
+        deviceIdentity: 'pro2-device-id',
+        platform: 'native',
+        artifacts: [
+          { artifactId: 'component:boot', target: 'boot' },
+          { artifactId: 'component:app_v1', target: 'app_v1' },
+          { artifactId: 'component:se02', target: 'se02' },
+          { artifactId: 'component:se03', target: 'se03' },
+        ],
+        targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03'],
+      },
+    });
+  });
+
+  test('includes exact Protocol V2 developer force targets in the prepared plan', async () => {
+    const currentRelease: IFirmwareReleaseInfo = {
+      ...release,
+      required: false,
+      version: [1, 0, 0],
+      installOrder: ['applicationP1', 'coprocessor'],
+      components: {
+        applicationP1: {
+          target: 'APPLICATION_P1',
+          url: 'https://example.com/application-p1.okpkg',
+          version: [1, 0, 0],
+        },
+        coprocessor: {
+          target: 'COPROCESSOR',
+          url: 'https://example.com/coprocessor.okpkg',
+          version: [1, 0, 0],
+        },
+      },
+    };
+    const method = new CheckAllFirmwareRelease({
+      id: 1,
+      payload: {
+        method: 'checkAllFirmwareRelease',
+        platform: 'desktop',
+        protocolV2ForceUpdateTargets: ['app_v1', 'coprocessor'],
+      },
+    });
+    method.init();
+    method.device = {
+      isProtocolV2: () => true,
+      features: {
+        deviceType: 'pro2',
+        serialNo: 'pro2-device-id',
+        firmwareVersion: '1.0.0',
+      },
+      getDeviceState: jest.fn().mockResolvedValue({
+        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
+        status: { mode: 'normal' },
+        versions: { ...currentVersions, applicationP1: '1.0.0' },
+      }),
+    } as unknown as CheckAllFirmwareRelease['device'];
+    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(currentRelease);
+    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
+
+    await expect(method.run()).resolves.toMatchObject({
+      targetsToUpdate: ['app_v1', 'coprocessor', 'resource'],
+      firmwareUpdatePlan: {
+        executor: 'v4',
+        platform: 'desktop',
+        artifacts: [
+          { artifactId: 'component:app_v1', target: 'app_v1' },
+          { artifactId: 'component:coprocessor', target: 'coprocessor' },
+        ],
+        targetsToUpdate: ['app_v1', 'coprocessor'],
+      },
+    });
+  });
+
+  test('keeps exact force targets but omits a Desktop Plan without device identity', async () => {
+    const currentRelease: IFirmwareReleaseInfo = {
+      ...release,
+      required: false,
+      version: [1, 0, 0],
+      installOrder: ['applicationP1'],
+      components: {
+        applicationP1: {
+          target: 'APPLICATION_P1',
+          url: 'https://example.com/application-p1.okpkg',
+          version: [1, 0, 0],
+        },
+      },
+    };
+    const method = new CheckAllFirmwareRelease({
+      id: 1,
+      payload: {
+        method: 'checkAllFirmwareRelease',
+        platform: 'desktop',
+        protocolV2ForceUpdateTargets: ['app_v1'],
+      },
+    });
+    method.init();
+    method.device = {
+      isProtocolV2: () => true,
+      features: { deviceType: 'pro2', firmwareVersion: '1.0.0' },
+      getDeviceState: jest.fn().mockResolvedValue({
+        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
+        status: { mode: 'normal' },
+        versions: { ...currentVersions, applicationP1: '1.0.0' },
+      }),
+    } as unknown as CheckAllFirmwareRelease['device'];
+    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(currentRelease);
+    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
+
+    await expect(method.run()).resolves.toMatchObject({
+      targetsToUpdate: ['app_v1', 'resource'],
+      firmwareUpdatePlan: undefined,
+    });
+  });
+
+  test('rejects Neo-only unsupported exact secure-element targets', async () => {
+    const neoRelease: IFirmwareReleaseInfo = {
+      ...release,
+      required: false,
+      installOrder: ['se03'],
+      components: {
+        se03: {
+          target: 'SE03',
+          url: 'https://example.com/se03.okpkg',
+          version: [1, 0, 0],
+        },
+      },
+    };
+    const method = new CheckAllFirmwareRelease({
+      id: 1,
+      payload: {
+        method: 'checkAllFirmwareRelease',
+        protocolV2ForceUpdateTargets: ['se03'],
+      },
+    });
+    method.init();
+    method.device = {
+      isProtocolV2: () => true,
+      features: { deviceType: 'neo', firmwareVersion: '1.0.0' },
+      getDeviceState: jest.fn().mockResolvedValue({
+        identity: { deviceType: 'neo', firmwareType: EFirmwareType.Universal },
+        status: { mode: 'normal' },
+        versions: currentVersions,
+      }),
+    } as unknown as CheckAllFirmwareRelease['device'];
+    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(neoRelease);
+    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
+
+    await expect(method.run()).rejects.toMatchObject({
+      params: { firmwareUpdateCode: 'FirmwarePlanInvalid' },
+    });
+  });
+
+  test('builds a V4 plan for Neo and excludes unsupported secure elements when forced', async () => {
+    const neoRelease: IFirmwareReleaseInfo = {
+      ...release,
+      installOrder: ['se01', 'se02', 'se03', 'se04'],
+      components: {
+        se01: { target: 'SE01', url: 'https://example.com/se01.bin', version: [1, 0, 0] },
+        se02: { target: 'SE02', url: 'https://example.com/se02.bin', version: [2, 0, 0] },
+        se03: { target: 'SE03', url: 'https://example.com/se03.bin', version: [1, 0, 0] },
+        se04: { target: 'SE04', url: 'https://example.com/se04.bin', version: [1, 0, 0] },
+      },
+    };
+    const method = new CheckAllFirmwareRelease({
+      id: 1,
+      payload: {
+        method: 'checkAllFirmwareRelease',
+        platform: 'native',
+        forceUpdateTargets: ['firmware'],
+      },
+    });
+    method.init();
+    method.device = {
+      isProtocolV2: () => true,
+      features: {
+        deviceType: 'neo',
+        serialNo: 'neo-device-id',
+        firmwareVersion: '1.0.0',
+      },
+      getDeviceState: jest.fn().mockResolvedValue({
+        identity: { deviceType: 'neo', firmwareType: EFirmwareType.Universal },
+        status: { mode: 'normal' },
+        versions: currentVersions,
+      }),
+    } as unknown as CheckAllFirmwareRelease['device'];
+    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(neoRelease);
+    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
+
+    await expect(method.run()).resolves.toMatchObject({
+      targetsToUpdate: ['se01', 'se02', 'resource'],
+      firmwareUpdatePlan: {
+        executor: 'v4',
+        deviceModel: 'neo',
+        platform: 'native',
+        targetsToUpdate: ['se01', 'se02'],
+      },
+    });
+  });
+
+  test('rejects a forced Protocol V2 resource target without a configured archive', async () => {
+    const method = new CheckAllFirmwareRelease({
+      id: 1,
+      payload: {
+        method: 'checkAllFirmwareRelease',
+        forceUpdateTargets: ['resource'],
+      },
+    });
+    method.init();
+    method.device = {
+      isProtocolV2: () => true,
+      features: { deviceType: 'pro2', firmwareVersion: '1.0.0' },
+      getDeviceState: jest.fn().mockResolvedValue({
+        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
+        status: { mode: 'normal' },
+        versions: currentVersions,
+      }),
+    } as unknown as CheckAllFirmwareRelease['device'];
+    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
+    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(undefined);
+
+    await expect(method.run()).rejects.toMatchObject({
+      params: { firmwareUpdateCode: 'FirmwarePlanInvalid' },
+    });
+  });
+
   test('requests and compares firmware hashes only when explicitly enabled', async () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
@@ -467,6 +730,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       resourceStatus: 'unknown',
       resourcePreparationRequired: true,
       targetsToUpdate: ['resource'],
+      firmwareUpdatePlan: undefined,
     });
   });
 
@@ -477,6 +741,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     await api.checkAllFirmwareRelease('pro2-connect-id', {
       checkFirmwareHash: true,
       firmwareType: EFirmwareType.Universal,
+      protocolV2ForceUpdateTargets: ['app_v1'],
       retryCount: 0,
     });
 
@@ -484,6 +749,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       connectId: 'pro2-connect-id',
       checkFirmwareHash: true,
       firmwareType: EFirmwareType.Universal,
+      protocolV2ForceUpdateTargets: ['app_v1'],
       retryCount: 0,
       method: 'checkAllFirmwareRelease',
     });

package/__tests__/check-firmware-release-protocol-v2.test.ts

@@ -22,6 +22,10 @@ const release: IFirmwareReleaseInfo = {
     'zh-CN': '更新',
     'en-US': 'Update',
   },
+  bootloaderChangelog: {
+    'zh-CN': '旧版 Bootloader 更新',
+    'en-US': 'Legacy bootloader update',
+  },
   installOrder: ['bootloader', 'applicationP1', 'coprocessor'],
   components: {
     bootloader: {
@@ -127,6 +131,7 @@ describe.each(['pro2', 'neo'] as const)('Protocol V2 release checks for %s', dev
     await expect(bootloaderMethod.run()).resolves.toMatchObject({
       status: 'outdated',
       shouldUpdate: true,
+      changelog: [release.changelog],
       release: {
         protocol: 'V2',
         configKey: 'bootloader',
@@ -134,6 +139,7 @@ describe.each(['pro2', 'neo'] as const)('Protocol V2 release checks for %s', dev
         target: 'BOOTLOADER',
         url: 'https://example.com/bootloader.okpkg',
         version: [2, 0, 0],
+        changelog: release.changelog,
       },
     });
     await expect(allMethod.run()).resolves.toMatchObject({

package/__tests__/protocol-v2.test.ts

@@ -2778,9 +2778,12 @@ describe('Protocol V2 feature adapter', () => {
     expect(checkedTypes).toEqual(['pro2', 'model_pro2']);
   });
 
-  test('uses firmware-v1 as the Pro2 remote firmware config field', () => {
+  test.each([
+    ['Pro2', DeviceType.PRO2],
+    ['Neo', DeviceType.NEO],
+  ] as const)('uses firmware-v1 as the %s remote firmware config field', (_name, deviceType) => {
     const features = normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
-      hw: { Device_type: DeviceType.PRO2 },
+      hw: { Device_type: deviceType },
     });
 
     expect(

package/dist/api/CheckAllFirmwareRelease.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AA8B1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EACV,kBAAkB,EAElB,kCAAkC,EAClC,+BAA+B,EAChC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EAGrB,MAAM,UAAU,CAAC;AAgIlB,MAAM,MAAM,6BAA6B,GAAG;IAC1C,YAAY,EAAE,aAAa,CAAC;IAC5B,MAAM,EAAE,+BAA+B,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,mBAAmB,CAAC;IACrC,UAAU,EAAE,kCAAkC,EAAE,CAAC;IACjD,eAAe,EAAE,sBAAsB,EAAE,CAAC;IAC1C,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,EAC7C,eAAe,EACf,mBAAwB,EACxB,iBAAyB,EACzB,mBAAwB,EACxB,YAAY,EACZ,OAAO,EACP,UAAU,GACX,EAAE;IACD,eAAe,EAAE,mBAAmB,CAAC;IACrC,mBAAmB,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACpD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IAC9D,YAAY,EAAE,aAAa,CAAC;IAC5B,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC1C,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAC7B,GAAG,6BAA6B,CAiFhC;AAID,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,qBAAqB;IAIrB,IAAI;IAME,GAAG;YAuFK,aAAa;CA+D5B"}
+{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAiC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EACV,kBAAkB,EAElB,kCAAkC,EAClC,+BAA+B,EAChC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EAGrB,MAAM,UAAU,CAAC;AAgIlB,MAAM,MAAM,6BAA6B,GAAG;IAC1C,YAAY,EAAE,aAAa,CAAC;IAC5B,MAAM,EAAE,+BAA+B,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,mBAAmB,CAAC;IACrC,UAAU,EAAE,kCAAkC,EAAE,CAAC;IACjD,eAAe,EAAE,sBAAsB,EAAE,CAAC;IAC1C,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,EAC7C,eAAe,EACf,mBAAwB,EACxB,iBAAyB,EACzB,mBAAwB,EACxB,YAAY,EACZ,OAAO,EACP,UAAU,GACX,EAAE;IACD,eAAe,EAAE,mBAAmB,CAAC;IACrC,mBAAmB,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACpD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IAC9D,YAAY,EAAE,aAAa,CAAC;IAC5B,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC1C,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAC7B,GAAG,6BAA6B,CAiFhC;AAID,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,UAAU;IAC7D,qBAAqB;IAIrB,IAAI;IAME,GAAG;YAuFK,aAAa;CAmI5B"}

package/dist/api/firmware/FirmwareUpdatePlan.d.ts

@@ -1,7 +1,30 @@
 import { EFirmwareType } from '@onekeyfe/hd-shared';
+import type { FirmwareUpdateV4Target } from '../../types/api/firmwareUpdate';
 import type { FirmwareUpdatePlan, FirmwareUpdatePlanForceTarget, FirmwareUpdatePlanTarget } from '../../types/api/firmwareUpdatePlan';
 import type { Features } from '../../types';
 type FirmwareUpdatePlatform = 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
+type ReleaseRecord = {
+    url?: unknown;
+    webUpdate?: unknown;
+    resource?: unknown;
+    fullResource?: unknown;
+    fullResourceRange?: unknown;
+    bootloaderResource?: unknown;
+    version?: unknown;
+    components?: unknown;
+    installOrder?: unknown;
+    resourceBundles?: unknown;
+    fingerprint?: unknown;
+    fingerprintWeb?: unknown;
+    expectedSize?: unknown;
+    resourceFingerprint?: unknown;
+    resourceExpectedSize?: unknown;
+    fullResourceFingerprint?: unknown;
+    fullResourceExpectedSize?: unknown;
+    bootloaderFingerprint?: unknown;
+    bootloaderExpectedSize?: unknown;
+    bootloaderVersion?: unknown;
+};
 type ReleaseSelection = {
     shouldUpdate?: boolean;
     status?: unknown;
@@ -9,9 +32,19 @@ type ReleaseSelection = {
 };
 export declare const digestFirmwareUpdateContract: (value: unknown) => string;
 export declare const validateFirmwareUpdatePlanForceTargets: (value: unknown) => FirmwareUpdatePlanForceTarget[];
+export declare const validateProtocolV2FirmwareUpdateTargets: (value: unknown) => FirmwareUpdateV4Target[];
 export declare const FIRMWARE_UPDATE_PLAN_TARGETS: Set<FirmwareUpdatePlanTarget>;
 export declare const FIRMWARE_UPDATE_PLAN_ROLES: Set<string>;
 export declare const assertFirmwareUpdatePlan: (value: unknown) => FirmwareUpdatePlan;
+export declare const buildProtocolV2FirmwareUpdatePlan: ({ features, firmwareType, platform, release, targetsToUpdate, forceUpdateTargets, resourceArchiveAvailable, }: {
+    features: Features;
+    firmwareType: EFirmwareType;
+    platform: FirmwareUpdatePlatform;
+    release: ReleaseRecord | undefined;
+    targetsToUpdate: readonly FirmwareUpdateV4Target[];
+    forceUpdateTargets?: FirmwareUpdatePlanForceTarget[] | undefined;
+    resourceArchiveAvailable: boolean;
+}) => FirmwareUpdatePlan;
 export declare const buildFirmwareUpdatePlan: ({ features, firmwareType, platform, firmware, ble, bootloader, forceUpdateTargets, }: {
     features: Features;
     firmwareType: EFirmwareType;

package/dist/api/firmware/FirmwareUpdatePlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdatePlan.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/FirmwareUpdatePlan.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,aAAa,EAA6B,MAAM,qBAAqB,CAAC;AAU5F,OAAO,KAAK,EACV,kBAAkB,EAElB,6BAA6B,EAC7B,wBAAwB,EACzB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,KAAK,sBAAsB,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,WAAW,CAAC;AAyBjF,KAAK,gBAAgB,GAAG;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AA0GF,eAAO,MAAM,4BAA4B,UAAW,OAAO,KAAG,MAG3D,CAAC;AAkBJ,eAAO,MAAM,sCAAsC,UAC1C,OAAO,KACb,6BAA6B,EAa/B,CAAC;AAuBF,eAAO,MAAM,4BAA4B,+BAavC,CAAC;AAEH,eAAO,MAAM,0BAA0B,aAOrC,CAAC;AAYH,eAAO,MAAM,wBAAwB,UAAW,OAAO,KAAG,kBAyHzD,CAAC;AA4NF,eAAO,MAAM,uBAAuB;cASxB,QAAQ;kBACJ,aAAa;cACjB,sBAAsB;cACtB,gBAAgB;SACrB,gBAAgB;;;MAGnB,kBAsKH,CAAC"}
+{"version":3,"file":"FirmwareUpdatePlan.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/FirmwareUpdatePlan.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,aAAa,EAA6B,MAAM,qBAAqB,CAAC;AAU5F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,KAAK,EACV,kBAAkB,EAElB,6BAA6B,EAC7B,wBAAwB,EACzB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,KAAK,sBAAsB,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,WAAW,CAAC;AAEjF,KAAK,aAAa,GAAG;IACnB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AA+GF,eAAO,MAAM,4BAA4B,UAAW,OAAO,KAAG,MAG3D,CAAC;AAkBJ,eAAO,MAAM,sCAAsC,UAC1C,OAAO,KACb,6BAA6B,EAa/B,CAAC;AAEF,eAAO,MAAM,uCAAuC,UAC3C,OAAO,KACb,sBAAsB,EAaxB,CAAC;AAuBF,eAAO,MAAM,4BAA4B,+BAavC,CAAC;AAEH,eAAO,MAAM,0BAA0B,aAOrC,CAAC;AAYH,eAAO,MAAM,wBAAwB,UAAW,OAAO,KAAG,kBAyHzD,CAAC;AA0RF,eAAO,MAAM,iCAAiC;cASlC,QAAQ;kBACJ,aAAa;cACjB,sBAAsB;aACvB,aAAa,GAAG,SAAS;qBACjB,SAAS,sBAAsB,EAAE;;8BAExB,OAAO;MAC/B,kBA2CH,CAAC;AAEF,eAAO,MAAM,uBAAuB;cASxB,QAAQ;kBACJ,aAAa;cACjB,sBAAsB;cACtB,gBAAgB;SACrB,gBAAgB;;;MAGnB,kBAyIH,CAAC"}

package/dist/api/firmware/protocolV2Release.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocolV2Release.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/protocolV2Release.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA6B,MAAM,qBAAqB,CAAC;AAI/E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EACV,WAAW,EACX,QAAQ,EACR,oBAAoB,EACpB,kCAAkC,EACnC,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EACV,0BAA0B,EAC1B,8BAA8B,EAE/B,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAEhF,eAAO,MAAM,iCAAiC,EAAE,SAAS,kCAAkC,EAO1F,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,SAAS,kCAAkC,EAEhF,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,SAAS,kCAAkC,EAEvF,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG;IAC7C,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,GAAG;QACrC,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,GAAG;YACtD,UAAU,EAAE,WAAW,CAAC,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC;SAChD,CAAC;KACH,CAAC;IACF,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,aAAa,CAAC;IAC5B,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF,wBAAsB,oCAAoC,CAAC,EACzD,MAAM,EACN,YAAY,EAAE,iBAAiB,EAC/B,iBAAyB,EACzB,UAAU,GACX,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,aAAa,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,gCAAgC,CAAC,CA4B5C;AAED,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,6BAA6B,EACnC,gBAAgB,EAAE,SAAS,kCAAkC,EAAE,GAC9D,6BAA6B,CAiC/B;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,IAAI,EACJ,KAAK,EACL,OAAO,GACR,EAAE;IACD,IAAI,EAAE,6BAA6B,CAAC;IACpC,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,0BAA0B,CAAC,SAAS,CAAC,CAAC;CAChD,GAAG,0BAA0B,CAQ7B;AAED,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,6BAA6B,EACnC,eAAe,EAAE,kCAAkC,GAClD,8BAA8B,GAAG,SAAS,CAmB5C"}
+{"version":3,"file":"protocolV2Release.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/protocolV2Release.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA6B,MAAM,qBAAqB,CAAC;AAI/E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EACV,WAAW,EACX,QAAQ,EACR,oBAAoB,EACpB,kCAAkC,EACnC,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EACV,0BAA0B,EAC1B,8BAA8B,EAE/B,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAEhF,eAAO,MAAM,iCAAiC,EAAE,SAAS,kCAAkC,EAO1F,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,SAAS,kCAAkC,EAEhF,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,SAAS,kCAAkC,EAEvF,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG;IAC7C,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,GAAG;QACrC,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,GAAG;YACtD,UAAU,EAAE,WAAW,CAAC,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC;SAChD,CAAC;KACH,CAAC;IACF,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,aAAa,CAAC;IAC5B,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAC3C,CAAC;AAEF,wBAAsB,oCAAoC,CAAC,EACzD,MAAM,EACN,YAAY,EAAE,iBAAiB,EAC/B,iBAAyB,EACzB,UAAU,GACX,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,aAAa,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,gCAAgC,CAAC,CA4B5C;AAED,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,6BAA6B,EACnC,gBAAgB,EAAE,SAAS,kCAAkC,EAAE,GAC9D,6BAA6B,CAiC/B;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,IAAI,EACJ,KAAK,EACL,OAAO,GACR,EAAE;IACD,IAAI,EAAE,6BAA6B,CAAC;IACpC,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,0BAA0B,CAAC,SAAS,CAAC,CAAC;CAChD,GAAG,0BAA0B,CAU7B;AAED,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,6BAA6B,EACnC,eAAe,EAAE,kCAAkC,GAClD,8BAA8B,GAAG,SAAS,CAmB5C"}

package/dist/index.d.ts

@@ -1542,6 +1542,7 @@ type CheckAllFirmwareReleaseParams = {
     firmwareType?: EFirmwareType;
     platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
     forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
+    protocolV2ForceUpdateTargets?: FirmwareUpdateV4Target[];
 };
 declare function checkAllFirmwareRelease(connectId?: string, params?: CommonParams & CheckAllFirmwareReleaseParams): Response<AllFirmwareRelease>;
 

package/dist/index.js

@@ -522,6 +522,10 @@ const PROTOCOL_V2_TARGETS = {
     SE03: 'se03',
     SE04: 'se04',
 };
+const PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS = new Set([
+    ...Object.values(PROTOCOL_V2_TARGETS),
+    'resource',
+]);
 const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value)
     ? value
     : undefined;
@@ -609,6 +613,18 @@ const validateFirmwareUpdatePlanForceTargets = (value) => {
     }
     return [...value];
 };
+const validateProtocolV2FirmwareUpdateTargets = (value) => {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value) ||
+        value.length > PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.size ||
+        value.some(target => !PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.has(target)) ||
+        new Set(value).size !== value.length) {
+        return planError('Protocol V2 firmware update targets are invalid');
+    }
+    return [...value];
+};
 const assertExactKeys = (value, required, optional = []) => {
     const allowed = new Set([...required, ...optional]);
     if (required.some(key => !Object.prototype.hasOwnProperty.call(value, key)) ||
@@ -773,7 +789,7 @@ const selectResourceUrl = ({ release, features, platform, }) => {
 };
 const getExecutor = (features) => {
     const deviceType = getDeviceType(features);
-    if (deviceType === hdShared.EDeviceType.Pro2) {
+    if (deviceType === hdShared.EDeviceType.Pro2 || deviceType === hdShared.EDeviceType.Neo) {
         return 'v4';
     }
     if (deviceType === hdShared.EDeviceType.Pro &&
@@ -782,7 +798,7 @@ const getExecutor = (features) => {
     }
     return 'v2';
 };
-const buildProtocolV2Artifacts = (release, { includeComponents = true, includeResources = true, } = {}) => {
+const buildProtocolV2Artifacts = (release, { includeComponents = true, includeResources = true, componentTargets: selectedComponentTargets, } = {}) => {
     var _a;
     const components = asRecord(release.components);
     if (includeComponents && !components) {
@@ -794,23 +810,32 @@ const buildProtocolV2Artifacts = (release, { includeComponents = true, includeRe
     const componentKeys = includeComponents && components
         ? [...installOrder, ...Object.keys(components).filter(key => !installOrder.includes(key))]
         : [];
+    const selectedComponentKeys = selectedComponentTargets
+        ? componentKeys.filter(key => {
+            var _a;
+            const component = asRecord(components === null || components === void 0 ? void 0 : components[key]);
+            const targetName = (_a = asString(component === null || component === void 0 ? void 0 : component.target)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+            const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
+            return !!target && selectedComponentTargets.has(target);
+        })
+        : componentKeys;
     const artifacts = [];
     const targets = [];
-    const componentTargets = new Set();
-    for (const key of componentKeys) {
+    const componentTargetSet = new Set();
+    for (const key of selectedComponentKeys) {
         const component = asRecord(components === null || components === void 0 ? void 0 : components[key]);
         const targetName = (_a = asString(component === null || component === void 0 ? void 0 : component.target)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+        const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
         if (targetName === 'ROMLOADER') {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 ROMLOADER requires its dedicated loader flow', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
         }
-        const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
         if (!component || !target) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 component ${key} has an unsupported target`, { firmwareUpdateCode: 'FirmwarePlanInvalid' });
         }
-        if (componentTargets.has(target)) {
+        if (componentTargetSet.has(target)) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 component ${key} duplicates target ${target}`, { firmwareUpdateCode: 'FirmwarePlanInvalid' });
         }
-        componentTargets.add(target);
+        componentTargetSet.add(target);
         artifacts.push(Object.assign(Object.assign({ artifactId: `component:${target}`, role: 'component', target, url: assertArtifactUrl(component.url, `Protocol V2 component ${key}`), container: 'raw', logicalName: key }, asIntegrity({
             size: component.expectedSize,
             sha256: component.fingerprint,
@@ -865,6 +890,63 @@ const assertForcedTargetsRepresented = ({ executor, forcedTargets, artifacts, ta
         }
     }
 };
+const finalizeFirmwareUpdatePlan = ({ features, firmwareType, platform, artifacts, targetsToUpdate, }) => {
+    const executor = getExecutor(features);
+    const bootloaderMode = resolveDeviceBootloaderMode(features);
+    const reportedIdentity = getDeviceUUID(features);
+    const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
+    if (artifacts.length > 0 &&
+        (platform === 'native' || platform === 'desktop') &&
+        !deviceIdentity &&
+        !(bootloaderMode && executor === 'v2')) {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Prepared firmware update requires a stable device identity', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
+    }
+    const planWithoutDigest = {
+        schemaVersion: 2,
+        executor,
+        deviceIdentity: deviceIdentity || 'unavailable',
+        deviceModel: String(getDeviceType(features)),
+        firmwareType,
+        platform,
+        artifacts,
+        targetsToUpdate,
+    };
+    return assertFirmwareUpdatePlan(Object.assign(Object.assign({}, planWithoutDigest), { planDigest: digestFirmwareUpdatePlan(planWithoutDigest) }));
+};
+const buildProtocolV2FirmwareUpdatePlan = ({ features, firmwareType, platform, release, targetsToUpdate, forceUpdateTargets, resourceArchiveAvailable, }) => {
+    const validatedForceTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
+    if (validatedForceTargets.some(target => target === 'ble' || target === 'bootloader')) {
+        planError('Protocol V2 does not support forced BLE or legacy bootloader targets');
+    }
+    const requestedComponentTargets = new Set(targetsToUpdate.filter(target => target !== 'resource'));
+    if (getDeviceType(features) === hdShared.EDeviceType.Neo &&
+        (requestedComponentTargets.has('se03') || requestedComponentTargets.has('se04'))) {
+        planError('Neo does not support Protocol V2 targets se03 or se04');
+    }
+    const protocolV2 = buildProtocolV2Artifacts(release !== null && release !== void 0 ? release : {}, {
+        includeComponents: requestedComponentTargets.size > 0,
+        includeResources: false,
+        componentTargets: requestedComponentTargets,
+    });
+    const representedTargets = new Set(protocolV2.targets);
+    const missingTarget = Array.from(requestedComponentTargets).find(target => !representedTargets.has(target));
+    if (missingTarget) {
+        planError(`Protocol V2 release does not contain requested target ${missingTarget}`);
+    }
+    if (validatedForceTargets.includes('firmware') && protocolV2.targets.length === 0) {
+        planError('Forced firmware update target firmware is not represented by the plan');
+    }
+    if (validatedForceTargets.includes('resource') && !resourceArchiveAvailable) {
+        planError('Forced firmware update target resource has no Protocol V2 resource archive');
+    }
+    return finalizeFirmwareUpdatePlan({
+        features,
+        firmwareType,
+        platform,
+        artifacts: protocolV2.artifacts,
+        targetsToUpdate: protocolV2.targets,
+    });
+};
 const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, ble, bootloader, forceUpdateTargets, }) => {
     var _a, _b, _c, _d, _e, _f, _g;
     const executor = getExecutor(features);
@@ -951,25 +1033,13 @@ const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, b
         artifacts,
         targetsToUpdate,
     });
-    const reportedIdentity = getDeviceUUID(features);
-    const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
-    if (artifacts.length > 0 &&
-        (platform === 'native' || platform === 'desktop') &&
-        !deviceIdentity &&
-        !(bootloaderMode && executor === 'v2')) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Prepared firmware update requires a stable device identity', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
-    }
-    const planWithoutDigest = {
-        schemaVersion: 2,
-        executor,
-        deviceIdentity: deviceIdentity || 'unavailable',
-        deviceModel: String(getDeviceType(features)),
+    return finalizeFirmwareUpdatePlan({
+        features,
         firmwareType,
         platform,
         artifacts,
         targetsToUpdate,
-    };
-    return assertFirmwareUpdatePlan(Object.assign(Object.assign({}, planWithoutDigest), { planDigest: digestFirmwareUpdatePlan(planWithoutDigest) }));
+    });
 };
 
 const preparedPlanError = (message) => {
@@ -41925,7 +41995,7 @@ const getFirmwareUpdateField = ({ features, updateType, targetVersion, firmwareT
     if (deviceType === hdShared.EDeviceType.Pro) {
         return latestFirmwareField;
     }
-    if (deviceType === hdShared.EDeviceType.Pro2) {
+    if (deviceType === hdShared.EDeviceType.Pro2 || deviceType === hdShared.EDeviceType.Neo) {
         return 'firmware-v1';
     }
     return 'firmware';
@@ -41957,7 +42027,7 @@ const getFirmwareUpdateFieldArray = (features, updateType) => {
     if (deviceType === 'pro') {
         return ['firmware-v8'];
     }
-    if (deviceType === 'pro2') {
+    if (deviceType === 'pro2' || deviceType === 'neo') {
         return ['firmware-v1'];
     }
     return ['firmware'];
@@ -47688,9 +47758,11 @@ class CheckAllFirmwareRelease extends BaseMethod {
         });
     }
     runProtocolV2() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const { checkFirmwareHash = false, firmwareType: firmwareTypeParam } = this
-                .payload;
+            const { checkFirmwareHash = false, firmwareType: firmwareTypeParam, platform, forceUpdateTargets, protocolV2ForceUpdateTargets, } = this.payload;
+            const validatedForceUpdateTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
+            const validatedProtocolV2ForceUpdateTargets = validateProtocolV2FirmwareUpdateTargets(protocolV2ForceUpdateTargets);
             const { state, features, firmwareType, release } = yield loadProtocolV2FirmwareReleaseContext({
                 device: this.device,
                 firmwareType: firmwareTypeParam,
@@ -47709,10 +47781,57 @@ class CheckAllFirmwareRelease extends BaseMethod {
             const resourceSource = DataManager.getProtocolV2ResourceSource(resourceDeviceType);
             const resourceStatus = 'unknown';
             const resourcePreparationRequired = !!resourceSource;
+            const detectedComponentTargets = validatedForceUpdateTargets.includes('firmware')
+                ? plan.components.flatMap(component => component.updateTarget ? [component.updateTarget] : [])
+                : plan.targetsToUpdate;
+            const componentTargetsToUpdate = Array.from(new Set([
+                ...detectedComponentTargets,
+                ...validatedProtocolV2ForceUpdateTargets.filter(target => target !== 'resource'),
+            ]));
+            const forceResourceUpdate = validatedForceUpdateTargets.includes('resource') ||
+                validatedProtocolV2ForceUpdateTargets.includes('resource');
             const targetsToUpdate = Array.from(new Set([
-                ...plan.targetsToUpdate,
-                ...(resourcePreparationRequired ? ['resource'] : []),
+                ...componentTargetsToUpdate,
+                ...(resourcePreparationRequired || forceResourceUpdate ? ['resource'] : []),
             ]));
+            let firmwareUpdatePlan;
+            try {
+                const shouldBuildFirmwareUpdatePlan = componentTargetsToUpdate.length > 0 ||
+                    validatedForceUpdateTargets.some(target => target !== 'resource') ||
+                    validatedProtocolV2ForceUpdateTargets.some(target => target !== 'resource') ||
+                    (forceResourceUpdate && !resourcePreparationRequired);
+                const requestedPlatform = platform !== null && platform !== void 0 ? platform : 'web';
+                const requiresDeviceIdentity = requestedPlatform === 'native' || requestedPlatform === 'desktop';
+                const canBindPreparedPlan = !requiresDeviceIdentity || !!getDeviceSerialNo(features);
+                if (shouldBuildFirmwareUpdatePlan) {
+                    const validatedPlan = buildProtocolV2FirmwareUpdatePlan({
+                        features,
+                        firmwareType,
+                        platform: canBindPreparedPlan ? requestedPlatform : 'web',
+                        release,
+                        targetsToUpdate,
+                        forceUpdateTargets: validatedForceUpdateTargets,
+                        resourceArchiveAvailable: resourcePreparationRequired,
+                    });
+                    firmwareUpdatePlan = canBindPreparedPlan ? validatedPlan : undefined;
+                    if (!canBindPreparedPlan) {
+                        Log$c.warn('[CheckAllFirmwareRelease] Protocol V2 device identity is unavailable; using the release result without a prepared Plan');
+                    }
+                }
+                else {
+                    firmwareUpdatePlan = undefined;
+                }
+            }
+            catch (error) {
+                if (validatedForceUpdateTargets.length > 0 ||
+                    validatedProtocolV2ForceUpdateTargets.length > 0 ||
+                    !(error instanceof hdShared.HardwareError) ||
+                    ((_a = error.params) === null || _a === void 0 ? void 0 : _a.firmwareUpdateCode) !== 'FirmwarePlanInvalid') {
+                    throw error;
+                }
+                Log$c.warn('[CheckAllFirmwareRelease] Optional Protocol V2 firmware Plan is unavailable; using the release result');
+                firmwareUpdatePlan = undefined;
+            }
             const firmwarePlan = summarizeProtocolV2FirmwareRelease(plan, PROTOCOL_V2_MAIN_FIRMWARE_TARGETS);
             const blePlan = summarizeProtocolV2FirmwareRelease(plan, PROTOCOL_V2_BLE_TARGETS);
             const bootloaderPlan = summarizeProtocolV2FirmwareRelease(plan, PROTOCOL_V2_BOOTLOADER_TARGETS);
@@ -47728,7 +47847,8 @@ class CheckAllFirmwareRelease extends BaseMethod {
                     state,
                     release: getProtocolV2ComponentReleaseInfo(plan, 'BOOTLOADER'),
                 }), features, protocol: 'V2', deviceType: state.identity.deviceType }, plan), { status,
-                resourceStatus, resourceArchive: resourceSource, resourcePreparationRequired, hasUpgrade: plan.hasUpgrade || resourcePreparationRequired, targetsToUpdate });
+                resourceStatus, resourceArchive: resourceSource, resourcePreparationRequired, hasUpgrade: targetsToUpdate.length > 0, targetsToUpdate,
+                firmwareUpdatePlan });
         });
     }
 }

package/dist/types/api/checkAllFirmwareRelease.d.ts

@@ -62,6 +62,7 @@ export type CheckAllFirmwareReleaseParams = {
     firmwareType?: EFirmwareType;
     platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
     forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
+    protocolV2ForceUpdateTargets?: FirmwareUpdateV4Target[];
 };
 export declare function checkAllFirmwareRelease(connectId?: string, params?: CommonParams & CheckAllFirmwareReleaseParams): Response<AllFirmwareRelease>;
 //# sourceMappingURL=checkAllFirmwareRelease.d.ts.map

package/dist/types/api/checkAllFirmwareRelease.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../../src/types/api/checkAllFirmwareRelease.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"checkAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../../src/types/api/checkAllFirmwareRelease.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.0-alpha.82",
+  "version": "1.2.0-alpha.84",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.0-alpha.82",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.82",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.84",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.84",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "bytebuffer": "^5.0.1",
@@ -44,5 +44,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "7b2b6f5b2f046f5ff2e35e14735ba3918c258054"
+  "gitHead": "577746142ef64d2c97de487c7a9cc8a5a0422e0b"
 }

package/src/api/CheckAllFirmwareRelease.ts

@@ -11,7 +11,9 @@ import {
 } from './firmware/releaseHelper';
 import {
   buildFirmwareUpdatePlan,
+  buildProtocolV2FirmwareUpdatePlan,
   validateFirmwareUpdatePlanForceTargets,
+  validateProtocolV2FirmwareUpdateTargets,
 } from './firmware/FirmwareUpdatePlan';
 import {
   PROTOCOL_V2_BLE_TARGETS,
@@ -26,6 +28,7 @@ import { getBridgeReleaseInfo } from '../utils/bridgeUpdate';
 import {
   LoggerNames,
   getDeviceFirmwareVersion,
+  getDeviceSerialNo,
   getDeviceType,
   getFirmwareType,
   getLogger,
@@ -384,8 +387,17 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
   }
 
   private async runProtocolV2(): Promise<AllFirmwareRelease> {
-    const { checkFirmwareHash = false, firmwareType: firmwareTypeParam } = this
-      .payload as CheckAllFirmwareReleaseParams;
+    const {
+      checkFirmwareHash = false,
+      firmwareType: firmwareTypeParam,
+      platform,
+      forceUpdateTargets,
+      protocolV2ForceUpdateTargets,
+    } = this.payload as CheckAllFirmwareReleaseParams;
+    const validatedForceUpdateTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
+    const validatedProtocolV2ForceUpdateTargets = validateProtocolV2FirmwareUpdateTargets(
+      protocolV2ForceUpdateTargets
+    );
     const { state, features, firmwareType, release } = await loadProtocolV2FirmwareReleaseContext({
       device: this.device,
       firmwareType: firmwareTypeParam,
@@ -405,12 +417,70 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
     const resourceSource = DataManager.getProtocolV2ResourceSource(resourceDeviceType);
     const resourceStatus = 'unknown' as const;
     const resourcePreparationRequired = !!resourceSource;
+    const detectedComponentTargets = validatedForceUpdateTargets.includes('firmware')
+      ? plan.components.flatMap(component =>
+          component.updateTarget ? [component.updateTarget] : []
+        )
+      : plan.targetsToUpdate;
+    const componentTargetsToUpdate = Array.from(
+      new Set([
+        ...detectedComponentTargets,
+        ...validatedProtocolV2ForceUpdateTargets.filter(target => target !== 'resource'),
+      ])
+    );
+    const forceResourceUpdate =
+      validatedForceUpdateTargets.includes('resource') ||
+      validatedProtocolV2ForceUpdateTargets.includes('resource');
     const targetsToUpdate = Array.from(
       new Set([
-        ...plan.targetsToUpdate,
-        ...(resourcePreparationRequired ? (['resource'] as const) : []),
+        ...componentTargetsToUpdate,
+        ...(resourcePreparationRequired || forceResourceUpdate ? (['resource'] as const) : []),
       ])
     );
+    let firmwareUpdatePlan: FirmwareUpdatePlan | undefined;
+    try {
+      const shouldBuildFirmwareUpdatePlan =
+        componentTargetsToUpdate.length > 0 ||
+        validatedForceUpdateTargets.some(target => target !== 'resource') ||
+        validatedProtocolV2ForceUpdateTargets.some(target => target !== 'resource') ||
+        (forceResourceUpdate && !resourcePreparationRequired);
+      const requestedPlatform = platform ?? 'web';
+      const requiresDeviceIdentity =
+        requestedPlatform === 'native' || requestedPlatform === 'desktop';
+      const canBindPreparedPlan = !requiresDeviceIdentity || !!getDeviceSerialNo(features);
+      if (shouldBuildFirmwareUpdatePlan) {
+        const validatedPlan = buildProtocolV2FirmwareUpdatePlan({
+          features,
+          firmwareType,
+          platform: canBindPreparedPlan ? requestedPlatform : 'web',
+          release,
+          targetsToUpdate,
+          forceUpdateTargets: validatedForceUpdateTargets,
+          resourceArchiveAvailable: resourcePreparationRequired,
+        });
+        firmwareUpdatePlan = canBindPreparedPlan ? validatedPlan : undefined;
+        if (!canBindPreparedPlan) {
+          Log.warn(
+            '[CheckAllFirmwareRelease] Protocol V2 device identity is unavailable; using the release result without a prepared Plan'
+          );
+        }
+      } else {
+        firmwareUpdatePlan = undefined;
+      }
+    } catch (error) {
+      if (
+        validatedForceUpdateTargets.length > 0 ||
+        validatedProtocolV2ForceUpdateTargets.length > 0 ||
+        !(error instanceof HardwareError) ||
+        error.params?.firmwareUpdateCode !== 'FirmwarePlanInvalid'
+      ) {
+        throw error;
+      }
+      Log.warn(
+        '[CheckAllFirmwareRelease] Optional Protocol V2 firmware Plan is unavailable; using the release result'
+      );
+      firmwareUpdatePlan = undefined;
+    }
     const firmwarePlan = summarizeProtocolV2FirmwareRelease(
       plan,
       PROTOCOL_V2_MAIN_FIRMWARE_TARGETS
@@ -442,8 +512,9 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
       resourceStatus,
       resourceArchive: resourceSource,
       resourcePreparationRequired,
-      hasUpgrade: plan.hasUpgrade || resourcePreparationRequired,
+      hasUpgrade: targetsToUpdate.length > 0,
       targetsToUpdate,
+      firmwareUpdatePlan,
     };
   }
 }

package/src/api/firmware/FirmwareUpdatePlan.ts

@@ -10,6 +10,7 @@ import {
   getDeviceFirmwareVersion,
 } from '../../utils/deviceVersionUtils';
 
+import type { FirmwareUpdateV4Target } from '../../types/api/firmwareUpdate';
 import type {
   FirmwareUpdatePlan,
   FirmwareUpdatePlanArtifact,
@@ -62,6 +63,11 @@ const PROTOCOL_V2_TARGETS: Readonly<
   SE04: 'se04',
 };
 
+const PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS = new Set<FirmwareUpdateV4Target>([
+  ...Object.values(PROTOCOL_V2_TARGETS),
+  'resource',
+]);
+
 const asRecord = (value: unknown): Record<string, unknown> | undefined =>
   value && typeof value === 'object' && !Array.isArray(value)
     ? (value as Record<string, unknown>)
@@ -191,6 +197,23 @@ export const validateFirmwareUpdatePlanForceTargets = (
   return [...value] as FirmwareUpdatePlanForceTarget[];
 };
 
+export const validateProtocolV2FirmwareUpdateTargets = (
+  value: unknown
+): FirmwareUpdateV4Target[] => {
+  if (value === undefined) {
+    return [];
+  }
+  if (
+    !Array.isArray(value) ||
+    value.length > PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.size ||
+    value.some(target => !PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.has(target)) ||
+    new Set(value).size !== value.length
+  ) {
+    return planError('Protocol V2 firmware update targets are invalid');
+  }
+  return [...value] as FirmwareUpdateV4Target[];
+};
+
 const assertExactKeys = (
   value: Record<string, unknown>,
   required: readonly string[],
@@ -405,7 +428,7 @@ const selectResourceUrl = ({
 
 const getExecutor = (features: Features): FirmwareUpdatePlan['executor'] => {
   const deviceType = getDeviceType(features);
-  if (deviceType === EDeviceType.Pro2) {
+  if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) {
     return 'v4';
   }
   if (
@@ -422,9 +445,11 @@ const buildProtocolV2Artifacts = (
   {
     includeComponents = true,
     includeResources = true,
+    componentTargets: selectedComponentTargets,
   }: {
     includeComponents?: boolean;
     includeResources?: boolean;
+    componentTargets?: ReadonlySet<FirmwareUpdatePlanTarget>;
   } = {}
 ): {
   artifacts: FirmwareUpdatePlanArtifact[];
@@ -445,12 +470,21 @@ const buildProtocolV2Artifacts = (
     includeComponents && components
       ? [...installOrder, ...Object.keys(components).filter(key => !installOrder.includes(key))]
       : [];
+  const selectedComponentKeys = selectedComponentTargets
+    ? componentKeys.filter(key => {
+        const component = asRecord(components?.[key]);
+        const targetName = asString(component?.target)?.toUpperCase();
+        const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
+        return !!target && selectedComponentTargets.has(target);
+      })
+    : componentKeys;
   const artifacts: FirmwareUpdatePlanArtifact[] = [];
   const targets: FirmwareUpdatePlanTarget[] = [];
-  const componentTargets = new Set<FirmwareUpdatePlanTarget>();
-  for (const key of componentKeys) {
+  const componentTargetSet = new Set<FirmwareUpdatePlanTarget>();
+  for (const key of selectedComponentKeys) {
     const component = asRecord(components?.[key]);
     const targetName = asString(component?.target)?.toUpperCase();
+    const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
     if (targetName === 'ROMLOADER') {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
@@ -458,7 +492,6 @@ const buildProtocolV2Artifacts = (
         { firmwareUpdateCode: 'FirmwarePlanInvalid' }
       );
     }
-    const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
     if (!component || !target) {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
@@ -466,14 +499,14 @@ const buildProtocolV2Artifacts = (
         { firmwareUpdateCode: 'FirmwarePlanInvalid' }
       );
     }
-    if (componentTargets.has(target)) {
+    if (componentTargetSet.has(target)) {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
         `Protocol V2 component ${key} duplicates target ${target}`,
         { firmwareUpdateCode: 'FirmwarePlanInvalid' }
       );
     }
-    componentTargets.add(target);
+    componentTargetSet.add(target);
     artifacts.push({
       artifactId: `component:${target}`,
       role: 'component',
@@ -587,6 +620,119 @@ const assertForcedTargetsRepresented = ({
   }
 };
 
+const finalizeFirmwareUpdatePlan = ({
+  features,
+  firmwareType,
+  platform,
+  artifacts,
+  targetsToUpdate,
+}: {
+  features: Features;
+  firmwareType: EFirmwareType;
+  platform: FirmwareUpdatePlatform;
+  artifacts: FirmwareUpdatePlanArtifact[];
+  targetsToUpdate: FirmwareUpdatePlanTarget[];
+}): FirmwareUpdatePlan => {
+  const executor = getExecutor(features);
+  const bootloaderMode = resolveDeviceBootloaderMode(features);
+  // 'unavailable' is the reserved degraded-identity sentinel; a device-reported
+  // serial must never be able to collide with it.
+  const reportedIdentity = getDeviceUUID(features);
+  const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
+  // Bootloader-mode classic-family devices (executor v2, e.g. classic1s) cannot report
+  // a serial number, so their recovery plans fall back to the degraded 'unavailable'
+  // identity. Binding is then enforced against the live device at install time instead
+  // (assertFirmwareUpdatePreparedPlanDeviceIdentity), and plan integrity by the digest.
+  // Pro (v3), Pro2, and Neo (v4) report a serial even in loader mode and stay strict.
+  if (
+    artifacts.length > 0 &&
+    (platform === 'native' || platform === 'desktop') &&
+    !deviceIdentity &&
+    !(bootloaderMode && executor === 'v2')
+  ) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Prepared firmware update requires a stable device identity',
+      { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+    );
+  }
+  const planWithoutDigest: Omit<FirmwareUpdatePlan, 'planDigest'> = {
+    schemaVersion: 2,
+    executor,
+    deviceIdentity: deviceIdentity || 'unavailable',
+    deviceModel: String(getDeviceType(features)),
+    firmwareType,
+    platform,
+    artifacts,
+    targetsToUpdate,
+  };
+  return assertFirmwareUpdatePlan({
+    ...planWithoutDigest,
+    planDigest: digestFirmwareUpdatePlan(planWithoutDigest),
+  });
+};
+
+export const buildProtocolV2FirmwareUpdatePlan = ({
+  features,
+  firmwareType,
+  platform,
+  release,
+  targetsToUpdate,
+  forceUpdateTargets,
+  resourceArchiveAvailable,
+}: {
+  features: Features;
+  firmwareType: EFirmwareType;
+  platform: FirmwareUpdatePlatform;
+  release: ReleaseRecord | undefined;
+  targetsToUpdate: readonly FirmwareUpdateV4Target[];
+  forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
+  resourceArchiveAvailable: boolean;
+}): FirmwareUpdatePlan => {
+  const validatedForceTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
+  if (validatedForceTargets.some(target => target === 'ble' || target === 'bootloader')) {
+    planError('Protocol V2 does not support forced BLE or legacy bootloader targets');
+  }
+
+  const requestedComponentTargets = new Set<FirmwareUpdatePlanTarget>(
+    targetsToUpdate.filter(target => target !== 'resource')
+  );
+  if (
+    getDeviceType(features) === EDeviceType.Neo &&
+    (requestedComponentTargets.has('se03') || requestedComponentTargets.has('se04'))
+  ) {
+    planError('Neo does not support Protocol V2 targets se03 or se04');
+  }
+  const protocolV2 = buildProtocolV2Artifacts(release ?? {}, {
+    includeComponents: requestedComponentTargets.size > 0,
+    includeResources: false,
+    componentTargets: requestedComponentTargets,
+  });
+  const representedTargets = new Set(protocolV2.targets);
+  const missingTarget = Array.from(requestedComponentTargets).find(
+    target => !representedTargets.has(target)
+  );
+  if (missingTarget) {
+    planError(`Protocol V2 release does not contain requested target ${missingTarget}`);
+  }
+  if (validatedForceTargets.includes('firmware') && protocolV2.targets.length === 0) {
+    planError('Forced firmware update target firmware is not represented by the plan');
+  }
+  if (validatedForceTargets.includes('resource') && !resourceArchiveAvailable) {
+    planError('Forced firmware update target resource has no Protocol V2 resource archive');
+  }
+
+  // Protocol V2 resource archives are materialized by the host into explicit
+  // resourceFiles. The prepared artifact plan therefore binds firmware components only.
+  return finalizeFirmwareUpdatePlan({
+    features,
+    firmwareType,
+    platform,
+    artifacts: protocolV2.artifacts,
+    targetsToUpdate: protocolV2.targets,
+  });
+};
+
 export const buildFirmwareUpdatePlan = ({
   features,
   firmwareType,
@@ -733,40 +879,11 @@ export const buildFirmwareUpdatePlan = ({
     artifacts,
     targetsToUpdate,
   });
-
-  // 'unavailable' is the reserved degraded-identity sentinel; a device-reported
-  // serial must never be able to collide with it.
-  const reportedIdentity = getDeviceUUID(features);
-  const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
-  // Bootloader-mode classic-family devices (executor v2, e.g. classic1s) cannot report
-  // a serial number, so their recovery plans fall back to the degraded 'unavailable'
-  // identity. Binding is then enforced against the live device at install time instead
-  // (assertFirmwareUpdatePreparedPlanDeviceIdentity), and plan integrity by the digest.
-  // Pro (v3) and Pro2 (v4) report a serial even in bootloader mode and stay strict.
-  if (
-    artifacts.length > 0 &&
-    (platform === 'native' || platform === 'desktop') &&
-    !deviceIdentity &&
-    !(bootloaderMode && executor === 'v2')
-  ) {
-    throw ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      'Prepared firmware update requires a stable device identity',
-      { firmwareUpdateCode: 'FirmwarePlanInvalid' }
-    );
-  }
-  const planWithoutDigest: Omit<FirmwareUpdatePlan, 'planDigest'> = {
-    schemaVersion: 2,
-    executor,
-    deviceIdentity: deviceIdentity || 'unavailable',
-    deviceModel: String(getDeviceType(features)),
+  return finalizeFirmwareUpdatePlan({
+    features,
     firmwareType,
     platform,
     artifacts,
     targetsToUpdate,
-  };
-  return assertFirmwareUpdatePlan({
-    ...planWithoutDigest,
-    planDigest: digestFirmwareUpdatePlan(planWithoutDigest),
   });
 };

package/src/api/firmware/protocolV2Release.ts

@@ -135,6 +135,8 @@ export function toProtocolV2FirmwareReleaseInfo({
   return {
     shouldUpdate: plan.hasUpgrade,
     status: plan.status === 'unavailable' ? 'unknown' : plan.status,
+    // Protocol V2 components share package-set release notes. The optional
+    // bootloaderChangelog field belongs to the legacy Protocol V1 release model.
     changelog: plan.release ? [plan.release.changelog] : [],
     release,
     bootloaderMode: state.status.mode === 'bootloader' || state.status.mode === 'romloader',

package/src/types/api/checkAllFirmwareRelease.ts

@@ -89,6 +89,7 @@ export type CheckAllFirmwareReleaseParams = {
   firmwareType?: EFirmwareType;
   platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
   forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
+  protocolV2ForceUpdateTargets?: FirmwareUpdateV4Target[];
 };
 
 export declare function checkAllFirmwareRelease(

package/src/utils/deviceFeaturesUtils.ts

@@ -328,7 +328,7 @@ export const getFirmwareUpdateField = ({
   if (deviceType === EDeviceType.Pro) {
     return latestFirmwareField;
   }
-  if (deviceType === EDeviceType.Pro2) {
+  if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) {
     return 'firmware-v1';
   }
   return 'firmware';
@@ -374,7 +374,7 @@ export const getFirmwareUpdateFieldArray = (
     return ['firmware-v8'];
   }
 
-  if (deviceType === 'pro2') {
+  if (deviceType === 'pro2' || deviceType === 'neo') {
     return ['firmware-v1'];
   }