@onekeyfe/hd-core 1.2.0-alpha.98 → 1.2.0-alpha.99

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

@@ -328,15 +328,16 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       status: 'required',
       resourceStatus: 'unknown',
       resourceArchive: resourceSource,
-      targetsToUpdate: ['boot', 'app_v1'],
+      targetsToUpdate: ['boot', 'app_v1', 'resource'],
       firmwareUpdatePlan: {
         executor: 'v4',
         platform: 'web',
         artifacts: [
           { artifactId: 'component:boot', target: 'boot' },
           { artifactId: 'component:app_v1', target: 'app_v1' },
+          { artifactId: 'resource:archive', target: 'resource' },
         ],
-        targetsToUpdate: ['boot', 'app_v1'],
+        targetsToUpdate: ['boot', 'app_v1', 'resource'],
       },
       firmware: {
         status: 'required',
@@ -377,7 +378,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
 
     await expect(method.run()).resolves.toMatchObject({
-      targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03'],
+      targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03', 'resource'],
       firmwareUpdatePlan: {
         executor: 'v4',
         deviceIdentity: 'pro2-device-id',
@@ -387,8 +388,9 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
           { artifactId: 'component:app_v1', target: 'app_v1' },
           { artifactId: 'component:se02', target: 'se02' },
           { artifactId: 'component:se03', target: 'se03' },
+          { artifactId: 'resource:archive', target: 'resource' },
         ],
-        targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03'],
+        targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03', 'resource'],
       },
     });
   });
@@ -582,12 +584,12 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
 
     await expect(method.run()).resolves.toMatchObject({
-      targetsToUpdate: ['se01', 'se02'],
+      targetsToUpdate: ['se01', 'se02', 'resource'],
       firmwareUpdatePlan: {
         executor: 'v4',
         deviceModel: 'neo',
         platform: 'native',
-        targetsToUpdate: ['se01', 'se02'],
+        targetsToUpdate: ['se01', 'se02', 'resource'],
       },
     });
   });
@@ -618,63 +620,66 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     });
   });
 
-  test('adds a Protocol V2 resource target only when explicitly forced', async () => {
-    const currentRelease: IFirmwareReleaseInfo = {
-      ...release,
-      required: false,
-      installOrder: ['applicationP1'],
-      components: {
-        applicationP1: {
-          target: 'APPLICATION_P1',
-          url: 'https://example.com/application-p1.okpkg',
-          version: [1, 0, 0],
+  test.each(['resource', 'boot_resources'] as const)(
+    'allows an explicitly forced Protocol V2 resource-only target through %s',
+    async forceTarget => {
+      const currentRelease: IFirmwareReleaseInfo = {
+        ...release,
+        required: false,
+        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: ['resource'],
-      },
-    });
-    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);
+      };
+      const method = new CheckAllFirmwareRelease({
+        id: 1,
+        payload: {
+          method: 'checkAllFirmwareRelease',
+          platform: 'desktop',
+          protocolV2ForceUpdateTargets: [forceTarget],
+        },
+      });
+      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({
-      status: 'valid',
-      hasUpgrade: true,
-      targetsToUpdate: ['resource'],
-      firmwareUpdatePlan: {
-        executor: 'v4',
-        platform: 'desktop',
-        artifacts: [
-          {
-            artifactId: 'resource:archive',
-            target: 'resource',
-            role: 'resourceBundle',
-            container: 'zip',
-          },
-        ],
+      await expect(method.run()).resolves.toMatchObject({
+        status: 'valid',
+        hasUpgrade: true,
         targetsToUpdate: ['resource'],
-      },
-    });
-  });
+        firmwareUpdatePlan: {
+          executor: 'v4',
+          platform: 'desktop',
+          artifacts: [
+            {
+              artifactId: 'resource:archive',
+              target: 'resource',
+              role: 'resourceBundle',
+              container: 'zip',
+            },
+          ],
+          targetsToUpdate: ['resource'],
+        },
+      });
+    }
+  );
 
   test('requests and compares firmware hashes only when explicitly enabled', async () => {
     const packageSet: IFirmwareReleaseInfo = {
@@ -752,7 +757,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
         protocol: 'V2',
         resourceStatus: 'unknown',
         resourceArchive: resourceSource,
-        targetsToUpdate: ['boot', 'app_v1'],
+        targetsToUpdate: ['boot', 'app_v1', 'resource'],
       });
       expect(typedCall).not.toHaveBeenCalled();
     }

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

@@ -147,7 +147,7 @@ describe.each(['pro2', 'neo'] as const)('Protocol V2 release checks for %s', dev
       deviceType,
       status: 'outdated',
       hasUpgrade: true,
-      targetsToUpdate: ['boot', 'app_v1', 'coprocessor'],
+      targetsToUpdate: ['boot', 'app_v1', 'coprocessor', 'resource'],
       firmware: { status: 'outdated', shouldUpdate: true },
       ble: {
         status: 'outdated',

package/__tests__/firmware-memory-host.test.ts

@@ -93,18 +93,32 @@ describe('prepareFirmwareUpdateV4MemoryHost', () => {
     const componentArtifact = host.preparedPlan.artifacts.find(
       artifact => artifact.target === 'boot'
     )?.artifact;
+    const resourceEntryArtifact = host.preparedPlan.artifacts.find(
+      artifact => artifact.target === 'resource'
+    )?.materializedEntries?.[0]?.artifact;
     expect(componentArtifact?.size).toBe(componentBinary.byteLength);
+    expect(resourceEntryArtifact?.size).toBe(manifestBinary.byteLength);
+    if (!artifactReader || !componentArtifact || !resourceEntryArtifact) {
+      throw new Error('Firmware memory host test setup is incomplete');
+    }
     new Uint8Array(componentBinary).fill(9);
-    const opened = await artifactReader!.open({
-      artifactRef: componentArtifact!.artifactRef,
+    const opened = await artifactReader.open({
+      artifactRef: componentArtifact.artifactRef,
     });
-    const chunk = await artifactReader!.read({
+    const chunk = await artifactReader.read({
       readerId: opened.readerId,
       offset: 1,
       length: 2,
     });
     expect(Array.from(new Uint8Array(chunk.data))).toEqual([2, 3]);
-    await artifactReader!.close({ readerId: opened.readerId });
+    await artifactReader.close({ readerId: opened.readerId });
+
+    // Materialized ZIP entries are receipts only. Execution opens the approved
+    // archive and re-derives these bytes, so the memory host must not retain a
+    // second readable copy of every expanded resource file.
+    expect(() => artifactReader.open({ artifactRef: resourceEntryArtifact.artifactRef })).toThrow(
+      'Firmware memory artifact is unavailable'
+    );
 
     host.release();
     expect(unregisterFirmwareUpdateHostBinding).toHaveBeenCalledWith(7);

package/__tests__/firmware-update/device-update-bootloader.test.ts

@@ -9,6 +9,7 @@ import {
 jest.mock('../../src/api/firmware/FirmwareUpdatePreparedPlan', () => ({
   assertFirmwareUpdatePreparedPlanBinding: jest.fn(),
   assertFirmwareUpdatePreparedPlanDeviceIdentity: jest.fn(),
+  clearFirmwareUpdatePreparedPlanDeviceIdentityPin: jest.fn(),
   getFirmwareUpdatePreparedRawArtifact: jest.fn(
     ({ preparedPlan }: { preparedPlan: { artifacts: unknown[] } }) => preparedPlan.artifacts[0]
   ),

package/__tests__/firmware-update/firmware-update-bootloader-poll.test.ts

@@ -231,7 +231,7 @@ describe.each([
     jest.restoreAllMocks();
   });
 
-  test('pauses the reboot deadline while waiting for browser authorization', async () => {
+  test('resumes bounded polling after browser authorization returns an empty enumeration', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
     jest.spyOn(DataManager, 'isBleConnect').mockReturnValue(false);
     jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(true);
@@ -300,13 +300,76 @@ describe.each([
     }
     expect(rejected).not.toHaveBeenCalled();
 
-    permissionGranted = true;
     resolvePrompt('bootloader-device');
     await flush();
     await flush();
 
+    // The chooser may resolve before the newly authorized device appears in the
+    // next WebUSB enumeration. That transient empty result must not strand the
+    // deferred check after its original interval and timeout were cleared.
+    expect(resolved).not.toHaveBeenCalled();
+    expect(rejected).not.toHaveBeenCalled();
+
+    permissionGranted = true;
+    for (let elapsed = 0; elapsed < 5000; elapsed += 500) {
+      jest.advanceTimersByTime(500);
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      if (resolved.mock.calls.length) break;
+    }
+
     expect(resolved).toHaveBeenCalledWith(true);
     expect(updateFromCache).toHaveBeenCalledWith(bootloaderDevice);
     expect(commands.disposed).toBe(false);
   });
+
+  test('rejects after the fresh deadline when the authorized device never appears', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    jest.spyOn(DataManager, 'isBleConnect').mockReturnValue(false);
+    jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(true);
+    jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({ devices: {}, deviceList: [] });
+
+    const method = buildMethod();
+    method.device = {
+      originalDescriptor: {
+        id: WEBUSB_ID,
+        path: WEBUSB_ID,
+        protocolType: 'V1',
+      },
+      deviceConnector: {
+        enumerate: jest.fn().mockResolvedValue({ descriptors: [] }),
+      },
+      commands: { disposed: true },
+      updateFromCache: jest.fn(),
+      getCurrentDeviceType: jest.fn(() => EDeviceType.Pro),
+    } as unknown as Device;
+    method.postTipMessage = jest.fn();
+    const prompt = jest
+      .spyOn(method as any, '_promptDeviceInBootloaderForWebDevice')
+      .mockResolvedValue('bootloader-device');
+
+    method.checkDeviceToBootloader(WEBUSB_ID);
+    const resolved = jest.fn();
+    const rejected = jest.fn();
+    method.checkPromise?.promise.then(resolved, rejected);
+
+    for (let elapsed = 0; elapsed < 15000; elapsed += 500) {
+      jest.advanceTimersByTime(500);
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      if (prompt.mock.calls.length) break;
+    }
+    expect(prompt).toHaveBeenCalledTimes(1);
+
+    for (let elapsed = 0; elapsed < 31000; elapsed += 500) {
+      jest.advanceTimersByTime(500);
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      if (rejected.mock.calls.length) break;
+    }
+
+    expect(resolved).not.toHaveBeenCalled();
+    expect(rejected).toHaveBeenCalledTimes(1);
+    expect(prompt).toHaveBeenCalledTimes(1);
+  });
 });

package/__tests__/firmware-update/firmware-update-plan-bootloader-identity.test.ts

@@ -1,6 +1,10 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
 import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+import {
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from '../../src/api/firmware/FirmwareHostBinding';
 import {
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
   prepareFirmwareUpdatePlan,
@@ -179,6 +183,19 @@ describe('firmware update plan identity in bootloader mode', () => {
         ],
       });
     };
+    const createBinding = (preparedPlanDigest: string) => ({
+      preparedPlanDigest,
+      artifactReader: {
+        open: () => Promise.resolve({ readerId: 'unused', size: 0 }),
+        read: () =>
+          Promise.resolve({
+            data: new ArrayBuffer(0),
+            bytesRead: 0,
+            eof: true,
+          }),
+        close: () => Promise.resolve(),
+      },
+    });
 
     test('accepts the phase that runs after the device reboots and reports a serial', () => {
       const preparedPlan = prepareRecoveryPlan();
@@ -250,6 +267,69 @@ describe('firmware update plan identity in bootloader mode', () => {
         })
       ).not.toThrow();
     });
+
+    test('releases the identity pin when the digest-bound host workflow ends', () => {
+      const preparedPlan = prepareRecoveryPlan();
+      const firstGeneration = registerFirmwareUpdateHostBinding(
+        createBinding(preparedPlan.preparedPlanDigest)
+      );
+      try {
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: 'CLA45F0023',
+          bootloaderMode: false,
+          deviceModel: String(EDeviceType.Classic1s),
+        });
+      } finally {
+        expect(unregisterFirmwareUpdateHostBinding(firstGeneration)).toBe(true);
+      }
+
+      const secondGeneration = registerFirmwareUpdateHostBinding(
+        createBinding(preparedPlan.preparedPlanDigest)
+      );
+      try {
+        expect(() =>
+          assertFirmwareUpdatePreparedPlanDeviceIdentity({
+            preparedPlan,
+            deviceIdentity: 'CLA99Z9999',
+            bootloaderMode: false,
+            deviceModel: String(EDeviceType.Classic1s),
+          })
+        ).not.toThrow();
+      } finally {
+        expect(unregisterFirmwareUpdateHostBinding(secondGeneration)).toBe(true);
+      }
+    });
+
+    test('a stale unregister cannot release the active workflow identity pin', () => {
+      const stalePlan = prepareRecoveryPlan();
+      const staleGeneration = registerFirmwareUpdateHostBinding(
+        createBinding(stalePlan.preparedPlanDigest)
+      );
+      const activePlan = prepareRecoveryPlan();
+      const activeGeneration = registerFirmwareUpdateHostBinding(
+        createBinding(activePlan.preparedPlanDigest)
+      );
+      try {
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan: activePlan,
+          deviceIdentity: 'CLA45F0023',
+          bootloaderMode: false,
+          deviceModel: String(EDeviceType.Classic1s),
+        });
+        expect(unregisterFirmwareUpdateHostBinding(staleGeneration)).toBe(false);
+        expect(() =>
+          assertFirmwareUpdatePreparedPlanDeviceIdentity({
+            preparedPlan: activePlan,
+            deviceIdentity: 'CLA99Z9999',
+            bootloaderMode: false,
+            deviceModel: String(EDeviceType.Classic1s),
+          })
+        ).toThrow();
+      } finally {
+        expect(unregisterFirmwareUpdateHostBinding(activeGeneration)).toBe(true);
+      }
+    });
   });
 
   describe('prepared plan device identity assertion', () => {

package/__tests__/firmware-update/firmware-update-plan.test.ts

@@ -1,6 +1,9 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
-import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+import {
+  buildFirmwareUpdatePlan,
+  validateProtocolV2FirmwareUpdateTargets,
+} from '../../src/api/firmware/FirmwareUpdatePlan';
 import {
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
   prepareFirmwareUpdatePlan,
@@ -88,6 +91,18 @@ const createProtocolV2ForceInput = (
   forceUpdateTargets: forceUpdateTargets as BuildPlanInput['forceUpdateTargets'],
 });
 
+describe('validateProtocolV2FirmwareUpdateTargets', () => {
+  test('normalizes the deprecated boot_resources alias to resource', () => {
+    expect(validateProtocolV2FirmwareUpdateTargets(['boot_resources'])).toEqual(['resource']);
+  });
+
+  test('rejects duplicate semantic targets after alias normalization', () => {
+    expectFirmwarePlanInvalid(() =>
+      validateProtocolV2FirmwareUpdateTargets(['boot_resources', 'resource'])
+    );
+  });
+});
+
 describe('buildFirmwareUpdatePlan', () => {
   test('selects all legacy artifacts before execution and chooses the desktop full resource', () => {
     const plan = buildFirmwareUpdatePlan({
@@ -316,6 +331,51 @@ describe('buildFirmwareUpdatePlan', () => {
     expectFirmwarePlanInvalid(() => buildFirmwareUpdatePlan(createLegacyForceInput(['resource'])));
   });
 
+  test.each([
+    {
+      executor: 'V2',
+      deviceType: EDeviceType.Classic1s,
+      bootloaderVersion: '2.1.2',
+    },
+    {
+      executor: 'V3',
+      deviceType: EDeviceType.Pro,
+      bootloaderVersion: '2.8.4',
+    },
+  ])(
+    'rejects a resource-only prepared plan that the $executor executor cannot run',
+    ({ deviceType, bootloaderVersion }) => {
+      expectFirmwarePlanInvalid(
+        () =>
+          buildFirmwareUpdatePlan({
+            features: createFeatures({
+              deviceType,
+              firmwareVersion: '4.21.0',
+              bootloaderVersion,
+            }),
+            firmwareType: EFirmwareType.Universal,
+            platform: 'desktop',
+            firmware: {
+              status: 'valid',
+              release: {
+                url: 'https://firmware.onekey.so/legacy/firmware.bin',
+                version: [4, 21, 0],
+                expectedSize: 1024,
+                fingerprint: '1'.repeat(64),
+                resource: 'https://firmware.onekey.so/legacy/resource.zip',
+                resourceExpectedSize: 4096,
+                resourceFingerprint: '2'.repeat(64),
+              },
+            },
+            ble: noUpdate,
+            bootloader: noUpdate,
+            forceUpdateTargets: ['resource'],
+          }),
+        'Legacy resource updates require a firmware target'
+      );
+    }
+  );
+
   test('rejects a legacy resource archive without complete integrity metadata', () => {
     expectFirmwarePlanInvalid(
       () =>

package/__tests__/protocol-v2-firmware-targets.test.ts

@@ -57,6 +57,22 @@ describe('Protocol V2 firmware target contract', () => {
     ).toThrow('Neo only supports SE01 and SE02; unsupported firmware targets: se03, se04');
   });
 
+  test('ignores unselected SE binaries when the caller supplied a target subset', () => {
+    const params = {
+      platform: 'web' as const,
+      targetsToUpdate: ['app_v1'] as Array<'app_v1'>,
+      se03Binary: new ArrayBuffer(1),
+      se04Binary: new ArrayBuffer(1),
+    };
+
+    expect(() =>
+      assertProtocolV2FirmwareTargetsSupported(EDeviceType.Neo, params, true)
+    ).not.toThrow();
+    expect(() => assertProtocolV2FirmwareTargetsSupported(EDeviceType.Neo, params)).toThrow(
+      'Neo only supports SE01 and SE02; unsupported firmware targets: se03, se04'
+    );
+  });
+
   test('keeps all four SE firmware targets available on Pro2', () => {
     expect(() =>
       assertProtocolV2FirmwareTargetsSupported(EDeviceType.Pro2, {

package/__tests__/protocol-v2.test.ts

@@ -4033,6 +4033,71 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
+  test('filters unrequested binaries from a direct local Protocol V2 update', async () => {
+    const applicationP1Binary = new Uint8Array([1, 2, 3]).buffer;
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        targetsToUpdate: ['app_v1'],
+        applicationP1Binary,
+        bootloaderBinary: new Uint8Array([4, 5, 6]).buffer,
+      },
+    });
+    method.init();
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+    (method as any).device = stubDevice({
+      originalDescriptor: { protocolType: 'V2' },
+      features: {
+        deviceType: 'pro2',
+        firmwareVersion: '1.0.0',
+        capabilities: [],
+      },
+      getCurrentDeviceType: () => 'pro2',
+    });
+    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue('local-result');
+    method.postTipMessage = jest.fn();
+
+    await expect(method.run()).resolves.toBe('local-result');
+    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
+      bootloaderBinary: null,
+      fwBinaryMap: [
+        {
+          fileName: 'application_p1.bin',
+          binary: applicationP1Binary,
+          targetId: 4,
+        },
+      ],
+    });
+  });
+
+  test('keeps all local binaries when no target list was supplied', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        applicationP1Binary: new Uint8Array([1]).buffer,
+        bootloaderBinary: new Uint8Array([2]).buffer,
+        resourceArchiveBinary: new Uint8Array([3]).buffer,
+      },
+    });
+    method.init();
+
+    const availableInstallItems = (method as any).buildProtocolV2InstallItems({
+      bootloaderBinary: (method as any).prepareBootloaderBinary(),
+      fwBinaryMap: (method as any).collectExplicitTargetBinaries(),
+    });
+
+    expect((method as any).params.targetsToUpdate).toEqual(['resource']);
+    expect(
+      (method as any)
+        .filterProtocolV2LocalInstallItems(availableInstallItems)
+        .map((item: { targetId: number }) => item.targetId)
+    ).toEqual([3, 4]);
+  });
+
   test('requires the external host to prepare manifest resources before bootloader entry', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -6702,6 +6767,7 @@ describe('Protocol V2 firmware update targets', () => {
     zip.file('loaders/bootloader/boot_resource.okpkg', bootResourceBinary);
     const resourceArchiveBinary = await zip.generateAsync({ type: 'arraybuffer' });
     const applicationP1Binary = new Uint8Array([7, 8, 9]).buffer;
+    const bootloaderBinary = new Uint8Array([10, 11, 12]).buffer;
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -6709,6 +6775,7 @@ describe('Protocol V2 firmware update targets', () => {
         platform: 'web',
         targetsToUpdate: ['app_v1'],
         applicationP1Binary,
+        bootloaderBinary,
         resourceArchiveBinary,
       },
     });
@@ -6742,6 +6809,11 @@ describe('Protocol V2 firmware update targets', () => {
         executor: 'v4',
         targetsToUpdate: ['app_v1', 'resource'],
       });
+      expect(
+        (method as any).params.preparedPlan.artifacts.some(
+          (artifact: { target: string }) => artifact.target === 'boot'
+        )
+      ).toBe(false);
       expect((method as any).executeProtocolV2SourceUpdate).toHaveBeenCalledWith(
         expect.objectContaining({
           installSources: [
@@ -6832,6 +6904,30 @@ describe('Protocol V2 firmware update targets', () => {
     );
   });
 
+  test('maps malformed resource ZIPs to a typed firmware preparation error', async () => {
+    const loadSpy = jest.spyOn(JSZip, 'loadAsync').mockRejectedValue(new Error('corrupt ZIP'));
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        targetsToUpdate: ['resource'],
+      },
+    });
+    method.init();
+
+    try {
+      await expect(
+        (method as any).prepareProtocolV2LocalResourceArchive(new Uint8Array([1]).buffer)
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.RuntimeError,
+        params: { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' },
+      });
+    } finally {
+      loadSpy.mockRestore();
+    }
+  });
+
   test('rejects an oversized ZIP entry before allocating its decompressed bytes', async () => {
     const extractEntry = jest.fn();
     const loadSpy = jest.spyOn(JSZip, 'loadAsync').mockResolvedValue({

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;AAgC1C,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;CAsH5B"}
+{"version":3,"file":"CheckAllFirmwareRelease.d.ts","sourceRoot":"","sources":["../../src/api/CheckAllFirmwareRelease.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAgC1C,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;CA2H5B"}