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

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

@@ -62,14 +62,6 @@ const release: IFirmwareReleaseInfo = {
       version: [2, 0, 0],
     },
   },
-  resourceBundles: [
-    {
-      name: 'images',
-      url: 'https://example.com/images.okpkg',
-      devicePath: 'vol0:/bundles/images/images.okpkg',
-      version: [1, 0, 0],
-    },
-  ],
 };
 
 const resourceSource = {
@@ -152,7 +144,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
   test('detects same-version package hotfixes by P1 and P2 payload hash', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
-      resourceBundles: undefined,
       installOrder: ['applicationP1', 'applicationP2'],
       components: {
         applicationP1: {
@@ -203,7 +194,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
       required: false,
-      resourceBundles: undefined,
       installOrder: ['applicationP1'],
       components: {
         applicationP1: {
@@ -234,7 +224,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
       required: false,
-      resourceBundles: undefined,
       installOrder: ['applicationP1'],
       components: {
         applicationP1: {
@@ -265,7 +254,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
   test('updates both application packages when normal mode only reports P1', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
-      resourceBundles: undefined,
       installOrder: ['applicationP1', 'applicationP2'],
       components: {
         applicationP1: {
@@ -331,8 +319,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       status: 'required',
       resourceStatus: 'unknown',
       resourceArchive: resourceSource,
-      resourcePreparationRequired: true,
-      targetsToUpdate: ['boot', 'app_v1', 'resource'],
+      targetsToUpdate: ['boot', 'app_v1'],
       firmwareUpdatePlan: {
         executor: 'v4',
         platform: 'web',
@@ -381,7 +368,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
 
     await expect(method.run()).resolves.toMatchObject({
-      targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03', 'resource'],
+      targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03'],
       firmwareUpdatePlan: {
         executor: 'v4',
         deviceIdentity: 'pro2-device-id',
@@ -442,7 +429,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
 
     await expect(method.run()).resolves.toMatchObject({
-      targetsToUpdate: ['app_v1', 'coprocessor', 'resource'],
+      targetsToUpdate: ['app_v1', 'coprocessor'],
       firmwareUpdatePlan: {
         executor: 'v4',
         platform: 'desktop',
@@ -491,7 +478,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
 
     await expect(method.run()).resolves.toMatchObject({
-      targetsToUpdate: ['app_v1', 'resource'],
+      targetsToUpdate: ['app_v1'],
       firmwareUpdatePlan: undefined,
     });
   });
@@ -571,7 +558,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
 
     await expect(method.run()).resolves.toMatchObject({
-      targetsToUpdate: ['se01', 'se02', 'resource'],
+      targetsToUpdate: ['se01', 'se02'],
       firmwareUpdatePlan: {
         executor: 'v4',
         deviceModel: 'neo',
@@ -607,11 +594,68 @@ 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],
+        },
+      },
+    };
+    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);
+
+    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 = {
       ...release,
       required: false,
-      resourceBundles: undefined,
       installOrder: ['applicationP1'],
       components: {
         applicationP1: {
@@ -684,14 +728,13 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
         protocol: 'V2',
         resourceStatus: 'unknown',
         resourceArchive: resourceSource,
-        resourcePreparationRequired: true,
-        targetsToUpdate: ['boot', 'app_v1', 'resource'],
+        targetsToUpdate: ['boot', 'app_v1'],
       });
       expect(typedCall).not.toHaveBeenCalled();
     }
   );
 
-  test('requires manifest preparation when only Protocol V2 resources may have changed', async () => {
+  test('exposes resource archive availability without reporting an unconfirmed update', async () => {
     const currentRelease: IFirmwareReleaseInfo = {
       ...release,
       required: false,
@@ -725,11 +768,11 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
 
     await expect(method.run()).resolves.toMatchObject({
-      status: 'unknown',
-      hasUpgrade: true,
+      status: 'valid',
+      hasUpgrade: false,
       resourceStatus: 'unknown',
-      resourcePreparationRequired: true,
-      targetsToUpdate: ['resource'],
+      resourceArchive: resourceSource,
+      targetsToUpdate: [],
       firmwareUpdatePlan: undefined,
     });
   });

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

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

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

@@ -0,0 +1,108 @@
+import { prepareFirmwareUpdateV4MemoryHost } from '../src/api/firmware/FirmwareMemoryHost';
+
+import type { CoreApi } from '../src/types/api';
+import type { FirmwareUpdatePlan } from '../src/types/api/firmwareUpdatePlan';
+
+describe('prepareFirmwareUpdateV4MemoryHost', () => {
+  test('registers artifact-backed component and resource readers', async () => {
+    const componentBinary = new Uint8Array([1, 2, 3, 4]).buffer;
+    const archiveBinary = new Uint8Array([5, 6]).buffer;
+    const manifestBinary = new TextEncoder().encode('{"schema":1}').buffer;
+    let artifactReader: Parameters<
+      CoreApi['registerFirmwareUpdateHostBinding']
+    >[0]['artifactReader'];
+    const unregisterFirmwareUpdateHostBinding = jest.fn();
+    const sdk = {
+      prepareFirmwareUpdatePlan: jest.fn(({ plan, artifacts }) => ({
+        schemaVersion: 2,
+        preparedPlanDigest: 'b'.repeat(64),
+        planDigest: plan.planDigest,
+        networkPolicy: 'forbid',
+        executor: plan.executor,
+        deviceIdentity: plan.deviceIdentity,
+        deviceModel: plan.deviceModel,
+        firmwareType: plan.firmwareType,
+        platform: plan.platform,
+        leaseRef: 'test-lease',
+        targetsToUpdate: plan.targetsToUpdate,
+        artifacts: plan.artifacts.map(planArtifact => {
+          const input = artifacts.find(item => item.artifactId === planArtifact.artifactId);
+          return {
+            ...planArtifact,
+            artifact: input?.artifact,
+            materializedEntries: input?.materializedEntries,
+          };
+        }),
+      })),
+      registerFirmwareUpdateHostBinding: jest.fn(binding => {
+        artifactReader = binding.artifactReader;
+        return 7;
+      }),
+      unregisterFirmwareUpdateHostBinding,
+    } as unknown as Pick<
+      CoreApi,
+      | 'prepareFirmwareUpdatePlan'
+      | 'registerFirmwareUpdateHostBinding'
+      | 'unregisterFirmwareUpdateHostBinding'
+    >;
+    const plan = {
+      schemaVersion: 2,
+      planDigest: 'a'.repeat(64),
+      executor: 'v4',
+      deviceIdentity: 'device-id',
+      deviceModel: 'pro2',
+      firmwareType: 0,
+      platform: 'web',
+      targetsToUpdate: ['boot', 'resource'],
+      artifacts: [
+        {
+          artifactId: 'component:boot',
+          role: 'component',
+          target: 'boot',
+          url: 'https://example.com/boot.okpkg',
+          container: 'raw',
+        },
+        {
+          artifactId: 'resource:archive',
+          role: 'resourceBundle',
+          target: 'resource',
+          url: 'https://example.com/resource.zip',
+          container: 'zip',
+          logicalName: 'resource-archive',
+        },
+      ],
+    } as FirmwareUpdatePlan;
+
+    const host = prepareFirmwareUpdateV4MemoryHost({
+      sdk,
+      plan,
+      artifacts: [
+        { artifactId: 'component:boot', binary: componentBinary },
+        {
+          artifactId: 'resource:archive',
+          binary: archiveBinary,
+          materializedEntries: [{ entryName: 'manifest.json', binary: manifestBinary }],
+        },
+      ],
+    });
+
+    expect(host.hostBindingGeneration).toBe(7);
+    expect(sdk.registerFirmwareUpdateHostBinding).toHaveBeenCalledWith(
+      expect.objectContaining({ preparedPlanDigest: host.preparedPlan.preparedPlanDigest })
+    );
+    expect(host.componentArtifacts.boot?.size).toBe(componentBinary.byteLength);
+    const opened = await artifactReader!.open({
+      artifactRef: host.componentArtifacts.boot!.artifactRef,
+    });
+    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 });
+
+    host.release();
+    expect(unregisterFirmwareUpdateHostBinding).toHaveBeenCalledWith(7);
+  });
+});

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

@@ -36,7 +36,10 @@ const createMethod = () => {
     read: jest.fn(),
     close,
   };
-  const hostBindingGeneration = registerFirmwareUpdateHostBinding({ artifactReader });
+  const hostBindingGeneration = registerFirmwareUpdateHostBinding({
+    artifactReader,
+    preparedPlanDigest: 'a'.repeat(64),
+  });
   const method = new DeviceUpdateBootloader({
     id: 1,
     payload: {

package/__tests__/firmware-update/firmware-host-binding.test.ts

@@ -6,6 +6,7 @@ import {
 } from '../../src/api/firmware/FirmwareHostBinding';
 
 const createBinding = () => ({
+  preparedPlanDigest: 'a'.repeat(64),
   artifactReader: {
     open: jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: 4 })),
     read: jest.fn(() =>
@@ -67,4 +68,12 @@ describe('firmware host binding generation', () => {
       readerId: 'stale-reader',
     });
   });
+
+  test('rejects a prepared plan from another host generation before opening artifacts', () => {
+    const generation = registerFirmwareUpdateHostBinding(createBinding());
+
+    expect(() => resolveFirmwareUpdateHostBinding(generation, 'b'.repeat(64))).toThrow(
+      'does not match the prepared plan'
+    );
+  });
 });

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

@@ -297,12 +297,6 @@ describe('buildFirmwareUpdatePlan', () => {
       forceTarget: 'firmware' as const,
       release: {
         components: {},
-        resourceBundles: [
-          {
-            name: 'images',
-            url: 'https://firmware.onekey.so/pro2/images.okpkg',
-          },
-        ],
       },
     },
     {
@@ -325,41 +319,21 @@ describe('buildFirmwareUpdatePlan', () => {
     }
   );
 
-  test.each([
-    {
-      forceTarget: 'firmware' as const,
-      expectedArtifactIds: ['component:app_v1'],
-      expectedTargets: ['app_v1'],
-    },
-    {
-      forceTarget: 'resource' as const,
-      expectedArtifactIds: ['resourceBundle:images'],
-      expectedTargets: ['resource'],
-    },
-  ])(
-    'limits a Pro2 $forceTarget force to the selected artifact role',
-    ({ forceTarget, expectedArtifactIds, expectedTargets }) => {
-      const plan = buildFirmwareUpdatePlan(
-        createProtocolV2ForceInput([forceTarget], {
-          components: {
-            applicationP1: {
-              target: 'APPLICATION_P1',
-              url: 'https://firmware.onekey.so/pro2/application-p1.bin',
-            },
+  test('limits a Pro2 firmware force to component artifacts', () => {
+    const plan = buildFirmwareUpdatePlan(
+      createProtocolV2ForceInput(['firmware'], {
+        components: {
+          applicationP1: {
+            target: 'APPLICATION_P1',
+            url: 'https://firmware.onekey.so/pro2/application-p1.bin',
           },
-          resourceBundles: [
-            {
-              name: 'images',
-              url: 'https://firmware.onekey.so/pro2/images.okpkg',
-            },
-          ],
-        })
-      );
+        },
+      })
+    );
 
-      expect(plan.artifacts.map(artifact => artifact.artifactId)).toEqual(expectedArtifactIds);
-      expect(plan.targetsToUpdate).toEqual(expectedTargets);
-    }
-  );
+    expect(plan.artifacts.map(artifact => artifact.artifactId)).toEqual(['component:app_v1']);
+    expect(plan.targetsToUpdate).toEqual(['app_v1']);
+  });
 
   test('rejects a prepared native plan without a stable device identity', () => {
     const features = createFeatures({
@@ -384,7 +358,7 @@ describe('buildFirmwareUpdatePlan', () => {
     ).toThrow('requires a stable device identity');
   });
 
-  test('maps the Pro2 component order and resource bundles without downloading them', () => {
+  test('maps the Pro2 component order without downloading artifacts', () => {
     const plan = buildFirmwareUpdatePlan({
       features: createFeatures({ deviceType: EDeviceType.Pro2 }),
       firmwareType: EFirmwareType.Universal,
@@ -409,12 +383,6 @@ describe('buildFirmwareUpdatePlan', () => {
               url: 'https://firmware.onekey.so/pro2/se01.bin',
             },
           },
-          resourceBundles: [
-            {
-              name: 'images',
-              url: 'https://firmware.onekey.so/pro2/images.okpkg',
-            },
-          ],
         },
       },
       ble: noUpdate,
@@ -426,9 +394,8 @@ describe('buildFirmwareUpdatePlan', () => {
       'component:boot',
       'component:app_v1',
       'component:se01',
-      'resourceBundle:images',
     ]);
-    expect(plan.targetsToUpdate).toEqual(['boot', 'app_v1', 'se01', 'resource']);
+    expect(plan.targetsToUpdate).toEqual(['boot', 'app_v1', 'se01']);
     expect(plan.artifacts[1]).toEqual(
       expect.objectContaining({
         expectedSize: 1024,
@@ -477,28 +444,6 @@ describe('buildFirmwareUpdatePlan', () => {
       },
       expectedError: 'duplicates target app_v1',
     },
-    {
-      label: 'resource bundle name',
-      release: {
-        components: {
-          application: {
-            target: 'APPLICATION_P1',
-            url: 'https://firmware.onekey.so/pro2/application.bin',
-          },
-        },
-        resourceBundles: [
-          {
-            name: 'images',
-            url: 'https://firmware.onekey.so/pro2/images.okpkg',
-          },
-          {
-            name: 'images',
-            url: 'https://firmware.onekey.so/pro2/images-duplicate.okpkg',
-          },
-        ],
-      },
-      expectedError: 'duplicates name images',
-    },
   ])('rejects a duplicate Pro2 $label', ({ release, expectedError }) => {
     expect(() =>
       buildFirmwareUpdatePlan({

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

@@ -1,6 +1,9 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
-import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+import {
+  buildFirmwareUpdatePlan,
+  digestFirmwareUpdateContract,
+} from '../../src/api/firmware/FirmwareUpdatePlan';
 import {
   assertFirmwareUpdatePreparedPlanBinding,
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
@@ -209,6 +212,55 @@ describe('FirmwareUpdatePreparedPlan', () => {
     ).toThrow('entry name is invalid');
   });
 
+  test('rejects duplicate materialized entry names during standalone validation', () => {
+    const plan = buildPlan();
+    const prepared = prepareFirmwareUpdatePlan({
+      plan,
+      leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
+      artifacts: [
+        {
+          artifactId: 'firmware',
+          artifact: artifact('a'.repeat(64), 4),
+        },
+        {
+          artifactId: 'resource',
+          artifact: artifact('b'.repeat(64), 8),
+          materializedEntries: [
+            {
+              entryName: 'resource/index.bin',
+              artifact: artifact('c'.repeat(64), 2),
+            },
+          ],
+        },
+      ],
+    });
+    const resourceArtifact = prepared.artifacts.find(item => item.target === 'resource')!;
+    const tamperedWithoutDigest = {
+      ...prepared,
+      artifacts: prepared.artifacts.map(item =>
+        item === resourceArtifact
+          ? {
+              ...item,
+              materializedEntries: [
+                ...resourceArtifact.materializedEntries!,
+                {
+                  entryName: 'other/index.bin',
+                  artifact: artifact('d'.repeat(64), 2),
+                },
+              ],
+            }
+          : item
+      ),
+    };
+    const { preparedPlanDigest: _preparedPlanDigest, ...digestInput } = tamperedWithoutDigest;
+    const tampered = {
+      ...tamperedWithoutDigest,
+      preparedPlanDigest: digestFirmwareUpdateContract(digestInput),
+    };
+
+    expect(() => validateFirmwareUpdatePreparedPlan(tampered)).toThrow('duplicate entry names');
+  });
+
   test('rejects unknown fields even when a caller presents a plan-shaped object', () => {
     const plan = buildPlan();
     expect(() =>

package/__tests__/protocol-v2-resources.test.ts

@@ -1,13 +1,11 @@
 import axios from 'axios';
 import { sha256 } from '@noble/hashes/sha256';
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { DataManager } from '../src/data-manager';
 import {
-  isProtocolV2ResourceFileValid,
   parseProtocolV2ResourceManifest,
   parseProtocolV2Resources,
-  prepareProtocolV2ResourceFiles,
 } from '../src/protocols/protocol-v2/resources';
 
 import type { ConnectSettings, RemoteConfigResponse } from '../src/types';
@@ -27,6 +25,12 @@ const resourceSource = {
   archiveSize: 16_815_479,
 };
 
+const neoResourceSource = {
+  archiveUrl: 'https://example.com/resource/neo-resource.zip',
+  archiveSha256: 'b'.repeat(64),
+  archiveSize: 12_345_678,
+};
+
 const manifestFiles = [
   ['bundles/firmware_logo-build.okpkg', 'firmware_logo.okpkg', 'vol0:/bundles/firmware_logo.okpkg'],
   ['bundles/font/noto-build.okpkg', 'noto.okpkg', 'vol0:/bundles/font/noto.okpkg'],
@@ -105,6 +109,7 @@ const createRemoteConfig = (): RemoteConfigResponse =>
     touch: { firmware: [], ble: [] },
     pro: { firmware: [], ble: [] },
     pro2: { firmware: [], ble: [], resources: { source: resourceSource } },
+    neo: { firmware: [], ble: [], resources: { source: neoResourceSource } },
     bridge: {},
   } as unknown as RemoteConfigResponse);
 
@@ -151,42 +156,6 @@ describe('Pro2 resource configuration', () => {
     ).toThrow('archive_path');
   });
 
-  test('verifies selected manifest files and preserves manifest device paths', () => {
-    const prepared = prepareProtocolV2ResourceFiles({
-      manifest: resourceManifest,
-      files: manifestFiles.map(file => ({
-        archivePath: file.archive_path,
-        binary: file.binary,
-      })),
-      targetsToUpdate: ['resource'],
-    });
-    expect(prepared.map(file => file.devicePath)).toEqual(
-      manifestFiles.map(file => file.device_path)
-    );
-    expect(() =>
-      prepareProtocolV2ResourceFiles({
-        manifest: resourceManifest,
-        files: manifestFiles.map((file, index) => ({
-          archivePath: file.archive_path,
-          binary: index === 0 ? new Uint8Array([0]).buffer : file.binary,
-        })),
-        targetsToUpdate: ['resource'],
-      })
-    ).toThrow('verification failed');
-  });
-
-  test('verifies both full file size and SHA-256 before transfer', () => {
-    const bytes = new Uint8Array([1, 2, 3]);
-    const binary = bytes.buffer;
-    const identity = { size: bytes.byteLength, fileHash: bytesToHex(sha256(bytes)) };
-
-    expect(isProtocolV2ResourceFileValid(binary, identity)).toBe(true);
-    expect(isProtocolV2ResourceFileValid(binary, { ...identity, size: 4 })).toBe(false);
-    expect(isProtocolV2ResourceFileValid(binary, { ...identity, fileHash: '0'.repeat(64) })).toBe(
-      false
-    );
-  });
-
   test('applies a validated pre-release config and exposes its archive source', async () => {
     const configFetcher = jest.fn().mockResolvedValue(createRemoteConfig());
 
@@ -217,6 +186,34 @@ describe('Pro2 resource configuration', () => {
     await expect(DataManager.load(createSettings(configFetcher))).resolves.toBe(true);
 
     expect(DataManager.getProtocolV2ResourceSource()).toBeUndefined();
+    expect(DataManager.protocolV2ResourcesConfigError).toBeInstanceOf(Error);
+    expect(DataManager.getProtocolV2ResourceSource(EDeviceType.Neo)).toEqual(neoResourceSource);
+  });
+
+  test('keeps Pro2 resources available when remote Neo resources are invalid', async () => {
+    const remoteConfig = createRemoteConfig();
+    (remoteConfig.neo as { resources?: unknown }).resources = { source: {} };
+    const configFetcher = jest.fn().mockResolvedValue(remoteConfig);
+
+    await expect(DataManager.load(createSettings(configFetcher))).resolves.toBe(true);
+
+    expect(DataManager.getProtocolV2ResourceSource(EDeviceType.Pro2)).toEqual(resourceSource);
+    expect(DataManager.getProtocolV2ResourceSource(EDeviceType.Neo)).toBeUndefined();
+    await expect(
+      DataManager.forceReloadData({
+        requireResources: true,
+        resourceDeviceType: EDeviceType.Pro2,
+      })
+    ).resolves.toBeUndefined();
+    await expect(
+      DataManager.forceReloadData({
+        requireResources: true,
+        resourceDeviceType: EDeviceType.Neo,
+      })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
+      message: expect.stringContaining('Invalid Neo resources config'),
+    });
   });
 
   test('only blocks resource mutation when the refreshed Pro2 resources are invalid', async () => {
@@ -233,6 +230,29 @@ describe('Pro2 resource configuration', () => {
     expect(DataManager.lastCheckTimestamp).toBeGreaterThan(0);
   });
 
+  test('checks resource configuration errors for the requested device only', async () => {
+    const remoteConfig = createRemoteConfig();
+    (remoteConfig.pro2 as { resources?: unknown }).resources = { source: {} };
+    const settings = createSettings(jest.fn().mockResolvedValue(remoteConfig));
+    DataManager.settings = settings;
+
+    await expect(
+      DataManager.forceReloadData({
+        requireResources: true,
+        resourceDeviceType: EDeviceType.Neo,
+      })
+    ).resolves.toBeUndefined();
+    await expect(
+      DataManager.forceReloadData({
+        requireResources: true,
+        resourceDeviceType: EDeviceType.Pro2,
+      })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
+      message: expect.stringContaining('Invalid Pro2 resources config'),
+    });
+  });
+
   test('does not advance the cache timestamp when refresh fails', async () => {
     jest.spyOn(axios, 'get').mockRejectedValue(new Error('offline'));
     const settings = createSettings(jest.fn().mockResolvedValue(null));