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

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: {
@@ -333,6 +321,21 @@ 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' },
+          {
+            artifactId: 'resource:archive',
+            target: 'resource',
+            role: 'resourceBundle',
+            container: 'zip',
+          },
+        ],
+        targetsToUpdate: ['boot', 'app_v1', 'resource'],
+      },
       firmware: {
         status: 'required',
       },
@@ -344,11 +347,266 @@ 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' },
+          { artifactId: 'resource:archive', target: 'resource', container: 'zip' },
+        ],
+        targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03', 'resource'],
+      },
+    });
+  });
+
+  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' },
+          { artifactId: 'resource:archive', target: 'resource', container: 'zip' },
+        ],
+        targetsToUpdate: ['app_v1', 'coprocessor', 'resource'],
+      },
+    });
+  });
+
+  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', 'resource'],
+      },
+    });
+  });
+
+  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,
       required: false,
-      resourceBundles: undefined,
       installOrder: ['applicationP1'],
       components: {
         applicationP1: {
@@ -467,6 +725,18 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       resourceStatus: 'unknown',
       resourcePreparationRequired: true,
       targetsToUpdate: ['resource'],
+      firmwareUpdatePlan: {
+        executor: 'v4',
+        artifacts: [
+          {
+            artifactId: 'resource:archive',
+            target: 'resource',
+            role: 'resourceBundle',
+            container: 'zip',
+          },
+        ],
+        targetsToUpdate: ['resource'],
+      },
     });
   });
 
@@ -477,6 +747,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     await api.checkAllFirmwareRelease('pro2-connect-id', {
       checkFirmwareHash: true,
       firmwareType: EFirmwareType.Universal,
+      protocolV2ForceUpdateTargets: ['app_v1'],
       retryCount: 0,
     });
 
@@ -484,6 +755,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__/firmware-memory-host.test.ts

@@ -0,0 +1,105 @@
+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(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/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(() =>