@onekeyfe/hd-core 1.2.0-alpha.8 → 1.2.0-alpha.81

package/__tests__/device-state-events.test.ts

@@ -0,0 +1,286 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+
+import { Device } from '../src/device/Device';
+import { DEVICE } from '../src/events';
+import { EOneKeyDeviceMode } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('Device state events', () => {
+  test.each([
+    ['V1', EFirmwareType.BitcoinOnly],
+    ['V2', EFirmwareType.Universal],
+  ] as const)(
+    'reads the current %s firmware type from canonical state',
+    (protocol, firmwareType) => {
+      const device = Device.fromDescriptor({
+        id: `device-${protocol}`,
+        path: `device-${protocol}`,
+        protocolType: protocol,
+      } as never);
+      device.updateState({ protocol, identity: { firmwareType } }, 'initialize');
+      const featuresGetter = jest.spyOn(device, 'features', 'get').mockImplementation(() => {
+        throw new Error('Legacy Features projection should not be read');
+      });
+
+      expect(device.getCurrentFirmwareType()).toBe(firmwareType);
+      featuresGetter.mockRestore();
+    }
+  );
+
+  test('keeps the universal firmware fallback before device state is initialized', () => {
+    const device = Device.fromDescriptor({ id: 'pending', path: 'pending' } as never);
+
+    expect(device.getCurrentFirmwareType()).toBe(EFirmwareType.Universal);
+    expect(device.getCurrentDeviceType()).toBe(EDeviceType.Unknown);
+    expect(device.getCurrentDeviceId()).toBeUndefined();
+    expect(device.getCurrentSerialNo()).toBe('');
+    expect(device.getCurrentBleName()).toBeNull();
+    expect(device.getCurrentLabel()).toBeNull();
+    expect(device.getCurrentFirmwareVersionString()).toBe('0.0.0');
+    expect(device.getCurrentBLEFirmwareVersionString()).toBeUndefined();
+    expect(device.getCurrentBootloaderVersionString()).toBeUndefined();
+    expect(device.getFirmwareVersion()).toBeNull();
+    expect(device.getBLEFirmwareVersion()).toBeNull();
+    expect(device.isUnacquired()).toBe(true);
+  });
+
+  test('reads current device data from canonical state without projecting Features', () => {
+    const device = Device.fromDescriptor({
+      id: 'pro2-state',
+      path: 'pro2-state',
+      protocolType: 'V2',
+    } as never);
+    device.updateState(
+      {
+        protocol: 'V2',
+        identity: {
+          deviceType: EDeviceType.Pro2,
+          deviceId: 'wallet-id',
+          serialNo: 'SERIAL-PRO2',
+          label: null,
+          bleName: 'Pro2 1234',
+        },
+        status: {
+          mode: 'normal',
+          initialized: true,
+          unlocked: false,
+          noBackup: false,
+          passphraseProtection: false,
+        },
+        settings: { safetyChecks: Enum_SafetyCheckLevel.Strict },
+        versions: {
+          firmware: '5.1.2',
+          bootloader: '2.0.0',
+          ble: null,
+        },
+      },
+      'initialize'
+    );
+    const featuresGetter = jest.spyOn(device, 'features', 'get').mockImplementation(() => {
+      throw new Error('Legacy Features projection should not be read');
+    });
+
+    expect(device.getCurrentDeviceType()).toBe(EDeviceType.Pro2);
+    expect(device.getCurrentDeviceId()).toBe('wallet-id');
+    expect(device.getCurrentSerialNo()).toBe('SERIAL-PRO2');
+    expect(device.getCurrentBleName()).toBe('Pro2 1234');
+    expect(device.getCurrentLabel()).toBeNull();
+    expect((device as any).getCurrentDisplayName()).toBe('Pro2 1234');
+    expect(device.getCurrentPassphraseProtection()).toBe(false);
+    expect(device.getCurrentFirmwareVersionString()).toBe('5.1.2');
+    expect(device.getCurrentBLEFirmwareVersionString()).toBe('0.0.0');
+    expect(device.getCurrentBootloaderVersionString()).toBe('2.0.0');
+    expect(device.getCurrentSafetyChecks()).toBe(Enum_SafetyCheckLevel.Strict);
+    expect(device.getFirmwareVersion()).toEqual([5, 1, 2]);
+    expect(device.getBLEFirmwareVersion()).toEqual([0, 0, 0]);
+    expect(device.isBootloader()).toBe(false);
+    expect(device.isInitialized()).toBe(true);
+    expect(device.isSeedless()).toBe(false);
+    expect(device.isUnacquired()).toBe(false);
+    expect(device.hasUsePassphrase()).toBe(true);
+    expect(device.supportInputPinOnSoftware()).toEqual({ support: false });
+    expect(device.supportModifyHomescreen()).toEqual({ support: true });
+    featuresGetter.mockRestore();
+  });
+
+  test('keeps legacy display-name fallbacks separate from the canonical label', () => {
+    const device = Device.fromDescriptor({ id: 'pure', path: 'pure' } as never);
+    device.updateState(
+      {
+        protocol: 'V1',
+        identity: {
+          deviceType: EDeviceType.ClassicPure,
+          label: null,
+          bleName: null,
+        },
+        status: { mode: 'normal', initialized: true },
+      },
+      'initialize'
+    );
+
+    expect(device.getCurrentLabel()).toBeNull();
+    expect(device.getCurrentDisplayName()).toBe('OneKey Classic 1S');
+    expect(device.toMessageObject()).toMatchObject({
+      name: 'OneKey Classic 1S',
+      label: 'OneKey Classic 1S',
+      state: { identity: { label: null } },
+    });
+  });
+
+  test('emits only the canonical state event for Protocol V2', () => {
+    const device = Device.fromDescriptor({
+      id: 'pro2',
+      path: 'pro2',
+      protocolType: 'V2',
+    } as never);
+    const onState = jest.fn();
+    const onFeatures = jest.fn();
+    device.on(DEVICE.STATE, onState);
+    device.on(DEVICE.FEATURES, onFeatures);
+
+    const state = device.updateState(
+      {
+        protocol: 'V2',
+        identity: { label: 'Renamed', bleName: 'Pro2 1234' },
+        raw: {
+          protocolV2DeviceInfo: { protocol_version: 2 },
+        },
+      },
+      'settings-write'
+    );
+
+    expect(state?.identity.label).toBe('Renamed');
+    expect(onState).toHaveBeenCalledWith(
+      device,
+      expect.objectContaining({
+        state: expect.objectContaining({ revision: 1 }),
+        revision: 1,
+        source: 'settings-write',
+      })
+    );
+    expect(onFeatures).not.toHaveBeenCalled();
+    expect(onState.mock.calls[0][1].state).not.toHaveProperty('raw');
+    expect(onState.mock.calls[0][1].state).not.toHaveProperty('session');
+    expect(device.state?.raw?.protocolV2DeviceInfo).toEqual({ protocol_version: 2 });
+  });
+
+  test.each([
+    ['normal', null, EOneKeyDeviceMode.normal],
+    ['notInitialized', false, EOneKeyDeviceMode.notInitialized],
+    ['backupMode', true, EOneKeyDeviceMode.backupMode],
+    ['bootloader', null, EOneKeyDeviceMode.bootloader],
+    ['romloader', null, EOneKeyDeviceMode.bootloader],
+  ] as const)(
+    'uses canonical %s mode even when initialized is %s',
+    (mode, initialized, expected) => {
+      const device = Device.fromDescriptor({
+        id: 'mode',
+        path: 'mode',
+        protocolType: 'V2',
+      } as never);
+      device.updateState({ protocol: 'V2', status: { mode, initialized } }, 'initialize');
+
+      expect(device.getMode()).toBe(expected);
+    }
+  );
+
+  test('commits lock success to canonical state and emits one state event', async () => {
+    const device = Device.fromDescriptor({ id: 'pro2', path: 'pro2', protocolType: 'V2' } as never);
+    (device as any).commands = {
+      typedCall: jest.fn().mockResolvedValue({ message: { message: 'locked' } }),
+    };
+    device.updateState(
+      { protocol: 'V2', status: { mode: 'normal', initialized: true, unlocked: true } },
+      'initialize'
+    );
+    const onState = jest.fn();
+    device.on(DEVICE.STATE, onState);
+
+    await device.lockDevice();
+
+    expect(device.state?.status.unlocked).toBe(false);
+    expect(onState).toHaveBeenCalledWith(
+      device,
+      expect.objectContaining({ source: 'lock', changedKeys: ['status.unlocked'] })
+    );
+  });
+
+  test('continues emitting projected Features events for Protocol V1', () => {
+    const device = Device.fromDescriptor({ id: 'legacy', path: 'legacy' } as never);
+    const onFeatures = jest.fn();
+    device.on(DEVICE.FEATURES, onFeatures);
+
+    device.updateState(
+      {
+        protocol: 'V1',
+        identity: { label: 'Legacy' },
+      },
+      'settings-write'
+    );
+
+    expect(onFeatures).toHaveBeenCalledWith(device, expect.objectContaining({ label: 'Legacy' }));
+  });
+
+  test('keeps Features assignment as an import-only compatibility projection', () => {
+    const device = Device.fromDescriptor({ id: 'legacy', path: 'legacy' } as never);
+
+    (device as any).features = {
+      protocol: 'V1',
+      deviceType: 'pro',
+      firmwareType: 'universal',
+      model: 'pro',
+      vendor: 'onekey.so',
+      deviceId: 'device-1',
+      serialNo: 'SERIAL-1',
+      label: 'Imported',
+      bleName: null,
+      capabilities: [],
+      mode: 'normal',
+      initialized: true,
+      bootloaderMode: false,
+      unlocked: true,
+      firmwarePresent: true,
+      passphraseProtection: false,
+      pinProtection: true,
+      backupRequired: false,
+      noBackup: false,
+      unfinishedBackup: false,
+      recoveryMode: false,
+      language: 'en-US',
+      bleEnabled: true,
+      sdCardPresent: false,
+      sdProtection: false,
+      wipeCodeProtection: false,
+      passphraseAlwaysOnDevice: false,
+      safetyChecks: null,
+      autoLockDelayMs: 10_000,
+      autoShutdownDelayMs: 20_000,
+      displayRotation: 0,
+      experimentalFeatures: false,
+      wallpaperPath: null,
+      brightness: 50,
+      animationEnabled: true,
+      tapToWake: true,
+      hapticFeedback: true,
+      deviceNameDisplayEnabled: true,
+      airgapMode: false,
+      fidoEnabled: true,
+      usbLockEnabled: false,
+      randomKeypad: false,
+      firmwareVersion: '4.0.0',
+      bootloaderVersion: '1.0.0',
+      boardVersion: '1.0.0',
+      bleVersion: '1.0.0',
+      sessionId: null,
+    };
+
+    expect(device.state?.identity.label).toBe('Imported');
+    expect(device.features).not.toBe((device as any).state);
+    expect(device.features?.label).toBe('Imported');
+  });
+});

package/__tests__/device-state-mapper.test.ts

@@ -0,0 +1,288 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import {
+  DeviceSEState,
+  DeviceSeType,
+  DeviceType,
+  Enum_SafetyCheckLevel,
+} from '@onekeyfe/hd-transport';
+
+import {
+  mapApplySettingsToState,
+  mapDeviceSettingsToState,
+  mapProtocolV1FeaturesToState,
+  mapProtocolV2DeviceInfoToState,
+  mapProtocolV2DeviceStatusToState,
+} from '../src/device/DeviceStateMapper';
+
+import type { PROTO } from '../src/constants';
+import type { DeviceSettings, DeviceStatus, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+
+describe('DeviceStateMapper', () => {
+  test('maps Protocol V1 Features into structured state sections', () => {
+    const patch = mapProtocolV1FeaturesToState({
+      onekey_device_type: 'PRO',
+      device_id: 'device-1',
+      label: 'Pro Wallet',
+      initialized: true,
+      unlocked: true,
+      language: 'en-US',
+      major_version: 4,
+      minor_version: 10,
+      patch_version: 1,
+      se_ver: '1.1.0.2',
+    } as PROTO.Features);
+
+    expect(patch).toMatchObject({
+      protocol: 'V1',
+      identity: {
+        deviceType: EDeviceType.Pro,
+        deviceId: 'device-1',
+        label: 'Pro Wallet',
+      },
+      status: { mode: 'normal', initialized: true, unlocked: true },
+      settings: { language: 'en-US' },
+      versions: { firmware: '4.10.1', se: '1.1.0.2', se01: '1.1.0.2' },
+    });
+  });
+
+  test.each([
+    ['CLASSIC1S', EDeviceType.Classic1s],
+    ['TOUCH', EDeviceType.Touch],
+    ['PRO', EDeviceType.Pro],
+  ] as const)(
+    'keeps the real label separate from display fallbacks for Protocol V1 %s',
+    (onekeyDeviceType, expectedDeviceType) => {
+      const patch = mapProtocolV1FeaturesToState({
+        onekey_device_type: onekeyDeviceType,
+        onekey_ble_name: `${onekeyDeviceType} BLE`,
+        initialized: true,
+      } as PROTO.Features);
+
+      expect(patch.identity).toMatchObject({
+        deviceType: expectedDeviceType,
+        label: null,
+        bleName: `${onekeyDeviceType} BLE`,
+      });
+    }
+  );
+
+  test.each([
+    ['CLASSIC1S', EDeviceType.Classic1s],
+    ['TOUCH', EDeviceType.Touch],
+    ['PRO', EDeviceType.Pro],
+  ] as const)(
+    'preserves Protocol V1 backup mode semantics for %s',
+    (onekeyDeviceType, expectedDeviceType) => {
+      const patch = mapProtocolV1FeaturesToState({
+        onekey_device_type: onekeyDeviceType,
+        initialized: true,
+        no_backup: true,
+      } as PROTO.Features);
+
+      expect(patch.identity?.deviceType).toBe(expectedDeviceType);
+      expect(patch.status?.mode).toBe('backupMode');
+    }
+  );
+
+  test('normalizes legacy Bitcoin-only and Attach PIN fields from Protocol V1', () => {
+    const patch = mapProtocolV1FeaturesToState({
+      onekey_device_type: 'PRO',
+      capabilities: [1],
+      attach_to_pin_user: true,
+      unlocked_attach_pin: true,
+      initialized: true,
+    } as PROTO.Features);
+
+    expect(patch.identity?.firmwareType).toBe(EFirmwareType.BitcoinOnly);
+    expect(patch.status).toMatchObject({
+      attachToPinEnabled: true,
+      unlockedAttachPin: true,
+    });
+  });
+
+  test('keeps Protocol V1 universal firmware when the decoded Bitcoin-like capability is present', () => {
+    const patch = mapProtocolV1FeaturesToState({
+      onekey_device_type: 'CLASSIC1S',
+      capabilities: ['Capability_Bitcoin_like'],
+      initialized: true,
+    } as PROTO.Features);
+
+    expect(patch.identity?.firmwareType).toBe(EFirmwareType.Universal);
+  });
+
+  test('maps Protocol V2 DeviceInfo without inventing runtime status', () => {
+    const patch = mapProtocolV2DeviceInfoToState(
+      {
+        protocol_version: 2,
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
+        fw: {
+          application: { version: '5.0.0', build_id: 'p1-build', hash: [0x01, 0x02] },
+          application_data: { version: '5.0.1', build_id: 'p2-build', hash: [0x03, 0x04] },
+          bootloader: { version: '2.0.0' },
+        },
+        coprocessor: {
+          bt_adv_name: 'Pro2 1234',
+          application: { version: '1.2.3' },
+        },
+        se1: {
+          type: DeviceSeType.THD89,
+          state: DeviceSEState.APP,
+          application: { version: '3.0.0', build_id: 'se1-build', hash: [0x05, 0x06] },
+        },
+      } as ProtocolV2DeviceInfo,
+      'normal'
+    );
+
+    expect(patch.identity).toMatchObject({
+      deviceType: EDeviceType.Pro2,
+      serialNo: 'SERIAL-1',
+      bleName: 'Pro2 1234',
+    });
+    expect(patch.versions).toMatchObject({
+      firmware: '5.0.0',
+      applicationP1: '5.0.0',
+      applicationP2: '5.0.1',
+      bootloader: '2.0.0',
+      ble: '1.2.3',
+    });
+    expect(patch.verification).toMatchObject({
+      applicationP1BuildId: 'p1-build',
+      applicationP1Hash: '0102',
+      applicationP2BuildId: 'p2-build',
+      applicationP2Hash: '0304',
+      se01BuildId: 'se1-build',
+      se01Hash: '0506',
+    });
+    expect(patch.securityElements).toMatchObject({
+      se01: { type: 'THD89', state: 'APP' },
+    });
+    expect(patch).toMatchObject({ protocolVersion: 2 });
+    expect(patch.status?.unlocked).toBeUndefined();
+  });
+
+  test('maps the Protocol V2 Neo device type without treating it as Pro2', () => {
+    const patch = mapProtocolV2DeviceInfoToState({
+      hw: { Device_type: DeviceType.NEO, serial_no: 'NEO-SERIAL-1' },
+    });
+
+    expect(patch.identity).toMatchObject({
+      deviceType: EDeviceType.Neo,
+      model: 'neo',
+      serialNo: 'NEO-SERIAL-1',
+    });
+  });
+
+  test('maps the hardware model independently from Protocol V2', () => {
+    const pro = mapProtocolV2DeviceInfoToState({
+      protocol_version: 2,
+      hw: { Device_type: 'PRO' as unknown as DeviceType, serial_no: 'SERIAL-PRO' },
+    });
+    const unknown = mapProtocolV2DeviceInfoToState({ protocol_version: 2, hw: {} });
+
+    expect(pro.identity).toMatchObject({ deviceType: EDeviceType.Pro, model: 'pro' });
+    expect(unknown.identity).toMatchObject({ deviceType: EDeviceType.Unknown, model: null });
+  });
+
+  test('keeps normal mode when Protocol V2 application and SE versions are returned together', () => {
+    const patch = mapProtocolV2DeviceInfoToState(
+      {
+        protocol_version: 2,
+        hw: { serial_no: 'SERIAL-NORMAL' },
+        fw: {
+          application: { version: '5.0.0' },
+          bootloader: { version: '2.0.0' },
+        },
+        se1: {
+          application: { version: '1.0.0', build_id: 'se-app', hash: [0x01, 0x02] },
+          bootloader: { version: '0.1.0', build_id: 'se-boot', hash: [0x03, 0x04] },
+        },
+      } as ProtocolV2DeviceInfo,
+      'normal'
+    );
+
+    expect(patch.status?.mode).toBe('normal');
+    expect(patch.verification).toMatchObject({
+      se01BuildId: 'se-app',
+      se01Hash: '0102',
+      se01BootBuildId: 'se-boot',
+      se01BootHash: '0304',
+    });
+  });
+
+  test.each([
+    [
+      'bootloader',
+      {
+        hw: { serial_no: 'SERIAL-BOOT' },
+        fw: { bootloader: { version: '2.0.0' } },
+        se1: {},
+      },
+    ],
+    [
+      'romloader',
+      {
+        hw: { serial_no: 'SERIAL-ROM' },
+        fw: {
+          romloader: { version: '1.0.0' },
+          bootloader: { version: '2.0.0' },
+        },
+      },
+    ],
+  ] as const)('clears stale device identity in Protocol V2 %s mode', (mode, info) => {
+    const patch = mapProtocolV2DeviceInfoToState(info as ProtocolV2DeviceInfo, mode);
+
+    expect(patch.status?.mode).toBe(mode);
+    expect(patch.identity).toMatchObject({ deviceId: null });
+  });
+
+  test('maps Protocol V2 status separately and ignores locked passphrase value', () => {
+    const locked = mapProtocolV2DeviceStatusToState({
+      device_id: 'device-2',
+      init_states: true,
+      unlocked: false,
+      passphrase_enabled: true,
+      backup_required: true,
+    } as DeviceStatus);
+
+    expect(locked.identity?.deviceId).toBe('device-2');
+    expect(locked.status).toMatchObject({
+      mode: 'normal',
+      initialized: true,
+      unlocked: false,
+      backupRequired: true,
+    });
+    expect(locked.status).not.toHaveProperty('passphraseProtection');
+  });
+
+  test('maps common settings into identity, status and settings sections', () => {
+    expect(
+      mapApplySettingsToState({
+        label: 'Renamed',
+        use_passphrase: true,
+        haptic_feedback: false,
+        use_ble: true,
+        safety_checks: 'Strict',
+      })
+    ).toEqual({
+      identity: { label: 'Renamed' },
+      status: { passphraseProtection: true },
+      settings: {
+        hapticFeedback: false,
+        bleEnabled: true,
+        safetyChecks: Enum_SafetyCheckLevel.Strict,
+      },
+    });
+
+    expect(
+      mapDeviceSettingsToState({
+        label: 'Pro2',
+        language: 'en-Latn-US',
+        brightness: 80,
+        autolock_delay_ms: 30_000,
+      } as DeviceSettings)
+    ).toEqual({
+      identity: { label: 'Pro2' },
+      settings: { language: 'en', brightness: 80, autoLockDelayMs: 30_000 },
+    });
+  });
+});

package/__tests__/device-state-projector.test.ts

@@ -0,0 +1,114 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import { createEmptyDeviceState } from '../src/device/DeviceStateStore';
+import { projectFeatures } from '../src/device/DeviceStateProjector';
+
+describe('DeviceStateProjector', () => {
+  test('projects legacy Features from the canonical snapshot', () => {
+    const state = createEmptyDeviceState({
+      deviceType: EDeviceType.Pro2,
+      firmwareType: EFirmwareType.Universal,
+      deviceId: 'device-1',
+      serialNo: 'SERIAL-1',
+      label: 'My Pro2',
+      bleName: 'Pro2 1234',
+    });
+    state.protocol = 'V2';
+    state.protocolVersion = 7;
+    state.status = {
+      ...state.status,
+      mode: 'normal',
+      initialized: true,
+      unlocked: true,
+      passphraseProtection: false,
+    };
+    state.settings = {
+      ...state.settings,
+      language: 'en-US',
+      brightness: 80,
+      autoLockDelayMs: 30_000,
+    };
+    state.versions = {
+      ...state.versions,
+      firmware: '5.0.0',
+      bootloader: '2.0.0',
+      ble: '1.2.3',
+      se01: '3.1.0',
+      se01Boot: '1.0.2',
+    };
+    state.verification = {
+      firmwareBuildId: 'firmware-build',
+      firmwareHash: 'firmware-hash',
+      se01BuildId: 'se01-build',
+      se01Hash: 'se01-hash',
+    };
+    state.securityElements = {
+      se01: { type: 'THD89', state: 'APP' },
+    };
+
+    const features = projectFeatures(state);
+    expect(features).toMatchObject({
+      protocol: 'V2',
+      protocolVersion: 7,
+      label: 'My Pro2',
+      unlocked: true,
+      brightness: 80,
+      firmwareVersion: '5.0.0',
+      onekey_firmware_version: '5.0.0',
+      onekey_firmware_build_id: 'firmware-build',
+      onekey_firmware_hash: 'firmware-hash',
+      onekey_se_type: 'THD89',
+      onekey_se01_version: '3.1.0',
+      onekey_se01_build_id: 'se01-build',
+      onekey_se01_hash: 'se01-hash',
+      onekey_se01_state: 'APP',
+      onekey_se01_boot_version: '1.0.2',
+    });
+  });
+
+  test.each([
+    [EDeviceType.Classic1s],
+    [EDeviceType.ClassicPure],
+    [EDeviceType.Touch],
+    [EDeviceType.Pro],
+  ] as const)('preserves Protocol V1 compatibility defaults for %s', deviceType => {
+    const state = createEmptyDeviceState({ deviceType });
+    state.protocol = 'V1';
+    state.versions.se = '1.1.0.2';
+    state.raw = {
+      protocolV1Features: {
+        onekey_device_type: deviceType,
+        initialized: true,
+      } as never,
+    };
+
+    const features = projectFeatures(state);
+
+    expect(features).toMatchObject({
+      protocolVersion: 1,
+      label: null,
+      bootloaderMode: null,
+      bootloader_mode: null,
+      seVersion: '1.1.0.2',
+    });
+  });
+
+  test('returns an isolated compatibility snapshot without internal raw state', () => {
+    const state = createEmptyDeviceState({ deviceType: EDeviceType.Pro });
+    state.protocol = 'V1';
+    state.capabilities = [1];
+    state.verification = { firmwareBuildId: 'build-1' };
+    state.raw = {
+      protocolV1Features: { label: 'Original' } as never,
+    };
+
+    const features = projectFeatures(state);
+    features.capabilities.push(2);
+    if (features.verify) features.verify.firmwareBuildId = 'mutated';
+
+    expect(state.capabilities).toEqual([1]);
+    expect(state.verification?.firmwareBuildId).toBe('build-1');
+    expect(state.raw.protocolV1Features?.label).toBe('Original');
+    expect(features).not.toHaveProperty('raw');
+  });
+});