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

package/src/api/firmware/FirmwareUpdatePlan.ts

@@ -10,13 +10,14 @@ import {
   getDeviceFirmwareVersion,
 } from '../../utils/deviceVersionUtils';
 
+import type { FirmwareUpdateV4Target } from '../../types/api/firmwareUpdate';
 import type {
   FirmwareUpdatePlan,
   FirmwareUpdatePlanArtifact,
   FirmwareUpdatePlanForceTarget,
   FirmwareUpdatePlanTarget,
 } from '../../types/api/firmwareUpdatePlan';
-import type { Features } from '../../types';
+import type { Features, IProtocolV2ResourceSource } from '../../types';
 
 type FirmwareUpdatePlatform = 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
 
@@ -30,7 +31,6 @@ type ReleaseRecord = {
   version?: unknown;
   components?: unknown;
   installOrder?: unknown;
-  resourceBundles?: unknown;
   fingerprint?: unknown;
   fingerprintWeb?: unknown;
   expectedSize?: unknown;
@@ -62,6 +62,11 @@ const PROTOCOL_V2_TARGETS: Readonly<
   SE04: 'se04',
 };
 
+const PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS = new Set<FirmwareUpdateV4Target>([
+  ...Object.values(PROTOCOL_V2_TARGETS),
+  'resource',
+]);
+
 const asRecord = (value: unknown): Record<string, unknown> | undefined =>
   value && typeof value === 'object' && !Array.isArray(value)
     ? (value as Record<string, unknown>)
@@ -191,6 +196,23 @@ export const validateFirmwareUpdatePlanForceTargets = (
   return [...value] as FirmwareUpdatePlanForceTarget[];
 };
 
+export const validateProtocolV2FirmwareUpdateTargets = (
+  value: unknown
+): FirmwareUpdateV4Target[] => {
+  if (value === undefined) {
+    return [];
+  }
+  if (
+    !Array.isArray(value) ||
+    value.length > PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.size ||
+    value.some(target => !PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.has(target)) ||
+    new Set(value).size !== value.length
+  ) {
+    return planError('Protocol V2 firmware update targets are invalid');
+  }
+  return [...value] as FirmwareUpdateV4Target[];
+};
+
 const assertExactKeys = (
   value: Record<string, unknown>,
   required: readonly string[],
@@ -405,7 +427,7 @@ const selectResourceUrl = ({
 
 const getExecutor = (features: Features): FirmwareUpdatePlan['executor'] => {
   const deviceType = getDeviceType(features);
-  if (deviceType === EDeviceType.Pro2) {
+  if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) {
     return 'v4';
   }
   if (
@@ -421,10 +443,10 @@ const buildProtocolV2Artifacts = (
   release: ReleaseRecord,
   {
     includeComponents = true,
-    includeResources = true,
+    componentTargets: selectedComponentTargets,
   }: {
     includeComponents?: boolean;
-    includeResources?: boolean;
+    componentTargets?: ReadonlySet<FirmwareUpdatePlanTarget>;
   } = {}
 ): {
   artifacts: FirmwareUpdatePlanArtifact[];
@@ -445,12 +467,21 @@ const buildProtocolV2Artifacts = (
     includeComponents && components
       ? [...installOrder, ...Object.keys(components).filter(key => !installOrder.includes(key))]
       : [];
+  const selectedComponentKeys = selectedComponentTargets
+    ? componentKeys.filter(key => {
+        const component = asRecord(components?.[key]);
+        const targetName = asString(component?.target)?.toUpperCase();
+        const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
+        return !!target && selectedComponentTargets.has(target);
+      })
+    : componentKeys;
   const artifacts: FirmwareUpdatePlanArtifact[] = [];
   const targets: FirmwareUpdatePlanTarget[] = [];
-  const componentTargets = new Set<FirmwareUpdatePlanTarget>();
-  for (const key of componentKeys) {
+  const componentTargetSet = new Set<FirmwareUpdatePlanTarget>();
+  for (const key of selectedComponentKeys) {
     const component = asRecord(components?.[key]);
     const targetName = asString(component?.target)?.toUpperCase();
+    const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
     if (targetName === 'ROMLOADER') {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
@@ -458,7 +489,6 @@ const buildProtocolV2Artifacts = (
         { firmwareUpdateCode: 'FirmwarePlanInvalid' }
       );
     }
-    const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
     if (!component || !target) {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
@@ -466,14 +496,14 @@ const buildProtocolV2Artifacts = (
         { firmwareUpdateCode: 'FirmwarePlanInvalid' }
       );
     }
-    if (componentTargets.has(target)) {
+    if (componentTargetSet.has(target)) {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
         `Protocol V2 component ${key} duplicates target ${target}`,
         { firmwareUpdateCode: 'FirmwarePlanInvalid' }
       );
     }
-    componentTargets.add(target);
+    componentTargetSet.add(target);
     artifacts.push({
       artifactId: `component:${target}`,
       role: 'component',
@@ -490,43 +520,6 @@ const buildProtocolV2Artifacts = (
     targets.push(target);
   }
 
-  const bundles =
-    includeResources && Array.isArray(release.resourceBundles) ? release.resourceBundles : [];
-  const resourceBundleNames = new Set<string>();
-  for (const value of bundles) {
-    const bundle = asRecord(value);
-    const name = asString(bundle?.name);
-    if (!bundle || !name) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 resource bundle is invalid',
-        { firmwareUpdateCode: 'FirmwarePlanInvalid' }
-      );
-    }
-    if (resourceBundleNames.has(name)) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `Protocol V2 resource bundle duplicates name ${name}`,
-        { firmwareUpdateCode: 'FirmwarePlanInvalid' }
-      );
-    }
-    resourceBundleNames.add(name);
-    artifacts.push({
-      artifactId: `resourceBundle:${name}`,
-      role: 'resourceBundle',
-      target: 'resource',
-      url: assertArtifactUrl(bundle.url, `Protocol V2 resource bundle ${name}`),
-      container: 'raw',
-      logicalName: name,
-      ...asIntegrity({
-        size: bundle.expectedSize,
-        sha256: bundle.fingerprint,
-      }),
-    });
-  }
-  if (bundles.length > 0) {
-    targets.push('resource');
-  }
   return { artifacts, targets: [...new Set(targets)] };
 };
 
@@ -587,6 +580,140 @@ const assertForcedTargetsRepresented = ({
   }
 };
 
+const finalizeFirmwareUpdatePlan = ({
+  features,
+  firmwareType,
+  platform,
+  artifacts,
+  targetsToUpdate,
+}: {
+  features: Features;
+  firmwareType: EFirmwareType;
+  platform: FirmwareUpdatePlatform;
+  artifacts: FirmwareUpdatePlanArtifact[];
+  targetsToUpdate: FirmwareUpdatePlanTarget[];
+}): FirmwareUpdatePlan => {
+  const executor = getExecutor(features);
+  const bootloaderMode = resolveDeviceBootloaderMode(features);
+  // 'unavailable' is the reserved degraded-identity sentinel; a device-reported
+  // serial must never be able to collide with it.
+  const reportedIdentity = getDeviceUUID(features);
+  const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
+  // Bootloader-mode classic-family devices (executor v2, e.g. classic1s) cannot report
+  // a serial number, so their recovery plans fall back to the degraded 'unavailable'
+  // identity. Binding is then enforced against the live device at install time instead
+  // (assertFirmwareUpdatePreparedPlanDeviceIdentity), and plan integrity by the digest.
+  // Pro (v3), Pro2, and Neo (v4) report a serial even in loader mode and stay strict.
+  if (
+    artifacts.length > 0 &&
+    (platform === 'native' || platform === 'desktop') &&
+    !deviceIdentity &&
+    !(bootloaderMode && executor === 'v2')
+  ) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Prepared firmware update requires a stable device identity',
+      { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+    );
+  }
+  const planWithoutDigest: Omit<FirmwareUpdatePlan, 'planDigest'> = {
+    schemaVersion: 2,
+    executor,
+    deviceIdentity: deviceIdentity || 'unavailable',
+    deviceModel: String(getDeviceType(features)),
+    firmwareType,
+    platform,
+    artifacts,
+    targetsToUpdate,
+  };
+  return assertFirmwareUpdatePlan({
+    ...planWithoutDigest,
+    planDigest: digestFirmwareUpdatePlan(planWithoutDigest),
+  });
+};
+
+export const buildProtocolV2FirmwareUpdatePlan = ({
+  features,
+  firmwareType,
+  platform,
+  release,
+  targetsToUpdate,
+  forceUpdateTargets,
+  resourceArchive,
+}: {
+  features: Features;
+  firmwareType: EFirmwareType;
+  platform: FirmwareUpdatePlatform;
+  release: ReleaseRecord | undefined;
+  targetsToUpdate: readonly FirmwareUpdateV4Target[];
+  forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
+  resourceArchive: IProtocolV2ResourceSource | undefined;
+}): FirmwareUpdatePlan => {
+  const validatedForceTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
+  if (validatedForceTargets.some(target => target === 'ble' || target === 'bootloader')) {
+    planError('Protocol V2 does not support forced BLE or legacy bootloader targets');
+  }
+
+  const requestedComponentTargets = new Set<FirmwareUpdatePlanTarget>(
+    targetsToUpdate.filter(target => target !== 'resource')
+  );
+  if (
+    getDeviceType(features) === EDeviceType.Neo &&
+    (requestedComponentTargets.has('se03') || requestedComponentTargets.has('se04'))
+  ) {
+    planError('Neo does not support Protocol V2 targets se03 or se04');
+  }
+  const protocolV2 = buildProtocolV2Artifacts(release ?? {}, {
+    includeComponents: requestedComponentTargets.size > 0,
+    componentTargets: requestedComponentTargets,
+  });
+  const resourceRequested = targetsToUpdate.includes('resource');
+  if (resourceRequested) {
+    const archive = resourceArchive;
+    if (!archive) {
+      return planError('Protocol V2 resource target has no resource archive');
+    }
+    const integrity = asIntegrity({
+      size: archive.archiveSize,
+      sha256: archive.archiveSha256,
+    });
+    if (integrity.expectedSize === undefined || integrity.expectedSha256 === undefined) {
+      planError('Protocol V2 resource archive integrity metadata is invalid');
+    }
+    protocolV2.artifacts.push({
+      artifactId: 'resource:archive',
+      role: 'resourceBundle',
+      target: 'resource',
+      url: assertArtifactUrl(archive.archiveUrl, 'Protocol V2 resource archive'),
+      container: 'zip',
+      logicalName: 'protocol-v2-resource-archive',
+      ...integrity,
+    });
+    protocolV2.targets.push('resource');
+  }
+  const representedTargets = new Set(protocolV2.targets);
+  const missingTarget = Array.from(requestedComponentTargets).find(
+    target => !representedTargets.has(target)
+  );
+  if (missingTarget) {
+    planError(`Protocol V2 release does not contain requested target ${missingTarget}`);
+  }
+  if (validatedForceTargets.includes('firmware') && protocolV2.targets.length === 0) {
+    planError('Forced firmware update target firmware is not represented by the plan');
+  }
+  if (validatedForceTargets.includes('resource') && !resourceArchive) {
+    planError('Forced firmware update target resource has no Protocol V2 resource archive');
+  }
+
+  return finalizeFirmwareUpdatePlan({
+    features,
+    firmwareType,
+    platform,
+    artifacts: protocolV2.artifacts,
+    targetsToUpdate: protocolV2.targets,
+  });
+};
+
 export const buildFirmwareUpdatePlan = ({
   features,
   firmwareType,
@@ -635,7 +762,6 @@ export const buildFirmwareUpdatePlan = ({
   if (executor === 'v4' && (shouldUpdateFirmware || shouldUpdateResource)) {
     const protocolV2 = buildProtocolV2Artifacts(firmwareRelease ?? {}, {
       includeComponents: shouldUpdateFirmware,
-      includeResources: shouldUpdateResource,
     });
     artifacts = protocolV2.artifacts;
     targetsToUpdate = protocolV2.targets;
@@ -733,40 +859,11 @@ export const buildFirmwareUpdatePlan = ({
     artifacts,
     targetsToUpdate,
   });
-
-  // 'unavailable' is the reserved degraded-identity sentinel; a device-reported
-  // serial must never be able to collide with it.
-  const reportedIdentity = getDeviceUUID(features);
-  const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
-  // Bootloader-mode classic-family devices (executor v2, e.g. classic1s) cannot report
-  // a serial number, so their recovery plans fall back to the degraded 'unavailable'
-  // identity. Binding is then enforced against the live device at install time instead
-  // (assertFirmwareUpdatePreparedPlanDeviceIdentity), and plan integrity by the digest.
-  // Pro (v3) and Pro2 (v4) report a serial even in bootloader mode and stay strict.
-  if (
-    artifacts.length > 0 &&
-    (platform === 'native' || platform === 'desktop') &&
-    !deviceIdentity &&
-    !(bootloaderMode && executor === 'v2')
-  ) {
-    throw ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      'Prepared firmware update requires a stable device identity',
-      { firmwareUpdateCode: 'FirmwarePlanInvalid' }
-    );
-  }
-  const planWithoutDigest: Omit<FirmwareUpdatePlan, 'planDigest'> = {
-    schemaVersion: 2,
-    executor,
-    deviceIdentity: deviceIdentity || 'unavailable',
-    deviceModel: String(getDeviceType(features)),
+  return finalizeFirmwareUpdatePlan({
+    features,
     firmwareType,
     platform,
     artifacts,
     targetsToUpdate,
-  };
-  return assertFirmwareUpdatePlan({
-    ...planWithoutDigest,
-    planDigest: digestFirmwareUpdatePlan(planWithoutDigest),
   });
 };

package/src/api/firmware/FirmwareUpdatePreparedPlan.ts

@@ -278,7 +278,14 @@ export const validateFirmwareUpdatePreparedPlan = (value: unknown): FirmwareUpda
     artifactIds.add(artifact.artifactId);
     artifactTargets.add(artifact.target);
     assertFirmwareArtifactReference(artifact.artifact);
-    artifact.materializedEntries?.forEach(assertPreparedEntry);
+    const materializedEntryNames =
+      artifact.materializedEntries?.map(entry => {
+        assertPreparedEntry(entry);
+        return getFirmwareUpdateResourceName(entry.entryName).toLowerCase();
+      }) ?? [];
+    if (new Set(materializedEntryNames).size !== materializedEntryNames.length) {
+      return preparedPlanError('Firmware prepared plan contains duplicate entry names');
+    }
   }
   if (
     preparedPlan.targetsToUpdate.some(target => !FIRMWARE_UPDATE_PLAN_TARGETS.has(target)) ||

package/src/api/firmware/protocolV2Release.ts

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

package/src/index.ts

@@ -23,9 +23,14 @@ export { projectFeatures as projectDeviceStateFeatures } from './device/DeviceSt
 export { getMethodSupportedProtocols } from './api/utils';
 export {
   parseProtocolV2ResourceManifest,
-  prepareProtocolV2ResourceFiles,
   selectProtocolV2ResourceManifestFiles,
 } from './protocols/protocol-v2/resources';
+export { prepareFirmwareUpdateV4MemoryHost } from './api/firmware/FirmwareMemoryHost';
+export type {
+  FirmwareMemoryArtifact,
+  FirmwareMemoryArtifactEntry,
+  FirmwareUpdateV4MemoryHost,
+} from './api/firmware/FirmwareMemoryHost';
 export {
   getFirmwareUpdateHostBindingGeneration,
   registerFirmwareUpdateHostBinding,

package/src/inject.ts

@@ -3,7 +3,6 @@ import {
   prepareFirmwareUpdatePlan,
   validateFirmwareUpdatePreparedPlan,
 } from './api/firmware/FirmwareUpdatePreparedPlan';
-import { prepareProtocolV2ResourceFiles } from './protocols/protocol-v2/resources';
 import {
   getFirmwareUpdateHostBindingGeneration,
   registerFirmwareUpdateHostBinding,
@@ -169,7 +168,6 @@ export const createCoreApi = (
   getFirmwareUpdateHostBindingGeneration,
   prepareFirmwareUpdatePlan,
   validateFirmwareUpdatePreparedPlan,
-  prepareProtocolV2ResourceFiles,
   getLogs: () => call({ method: 'getLogs' }),
   clearSessionCache: params => call({ ...params, method: 'clearSessionCache' }),
   /**

package/src/protocols/protocol-v2/resources.ts

@@ -1,5 +1,3 @@
-import { sha256 } from '@noble/hashes/sha256';
-
 import type {
   IProtocolV2ResourceManifest,
   IProtocolV2ResourceManifestFile,
@@ -210,48 +208,3 @@ export function selectProtocolV2ResourceManifestFiles({
 }): IProtocolV2ResourceManifestFile[] {
   return targetsToUpdate.includes('resource') ? [...manifest.files] : [];
 }
-
-export function prepareProtocolV2ResourceFiles({
-  manifest: value,
-  files,
-  targetsToUpdate,
-}: {
-  manifest: unknown;
-  files: Array<{ archivePath: string; binary: ArrayBuffer }>;
-  targetsToUpdate: readonly FirmwareUpdateV4Target[];
-}): Array<{ binary: ArrayBuffer; devicePath: string; size: number; fileHash: string }> {
-  const manifest = parseProtocolV2ResourceManifest(value);
-  const selected = selectProtocolV2ResourceManifestFiles({ manifest, targetsToUpdate });
-  const binaries = new Map(files.map(file => [file.archivePath, file.binary] as const));
-  return selected.map(file => {
-    const binary = binaries.get(file.archive_path);
-    if (
-      !binary ||
-      !isProtocolV2ResourceFileValid(binary, {
-        size: file.size,
-        fileHash: file.sha256,
-      })
-    ) {
-      throw new Error(`Pro2 resource manifest file verification failed: ${file.archive_path}`);
-    }
-    return {
-      binary,
-      devicePath: file.device_path,
-      size: file.size,
-      fileHash: file.sha256,
-    };
-  });
-}
-
-function bytesToHex(bytes: Uint8Array): string {
-  return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
-}
-
-/** Verify the complete downloaded file before any device mutation. */
-export function isProtocolV2ResourceFileValid(
-  binary: ArrayBuffer,
-  resource: { size: number; fileHash: string }
-): boolean {
-  if (binary.byteLength !== resource.size) return false;
-  return bytesToHex(sha256(new Uint8Array(binary))) === resource.fileHash.toLowerCase();
-}

package/src/types/api/checkAllFirmwareRelease.ts

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

package/src/types/api/export.ts

@@ -49,10 +49,6 @@ export type {
   FirmwareUpdatePreparedEntry,
   FirmwareUpdatePreparedPlan,
 } from './firmwareUpdatePreparedPlan';
-export type {
-  ProtocolV2PreparedResourceFile,
-  ProtocolV2ResourceManifestBinary,
-} from './protocolV2ResourceManifest';
 export type { FirmwareUpdateCapabilities } from './firmwareUpdateCapabilities';
 export type {
   AllFirmwareRelease,

package/src/types/api/firmwareUpdate.ts

@@ -153,25 +153,10 @@ export interface FirmwareUpdateV4Params {
   se03Binary?: ArrayBuffer;
   se04Binary?: ArrayBuffer;
   forcedUpdateRes?: boolean;
-  /**
-   * Arbitrary Protocol V2 resource files written directly with FilesystemFileWrite.
-   * Use this for every file selected from the manifest-driven resource archive.
-   * When provided, these files are authoritative for the resource target.
-   */
-  resourceFiles?: Array<{
-    binary: ArrayBuffer;
-    devicePath: string;
-    size?: number;
-    fileHash?: string;
-  }>;
   artifactReader?: FirmwareArtifactReader;
   componentArtifacts?: Partial<
     Record<Exclude<FirmwareUpdateV4Target, 'resource'>, FirmwareArtifactReference>
   >;
-  resourceBundleArtifacts?: Array<{
-    name: string;
-    artifact: FirmwareArtifactReference;
-  }>;
 }
 
 export declare function registerFirmwareUpdateHostBinding(

package/src/types/api/index.ts

@@ -41,7 +41,6 @@ import type {
   prepareFirmwareUpdatePlan,
   validateFirmwareUpdatePreparedPlan,
 } from './firmwareUpdatePreparedPlan';
-import type { prepareProtocolV2ResourceFiles } from './protocolV2ResourceManifest';
 import type { promptWebDeviceAccess } from './promptWebDeviceAccess';
 import type { deviceReset } from './deviceReset';
 import type { deviceRecovery } from './deviceRecovery';
@@ -254,7 +253,6 @@ export type CoreApi = {
   getFirmwareUpdateCapabilities: typeof getFirmwareUpdateCapabilities;
   prepareFirmwareUpdatePlan: typeof prepareFirmwareUpdatePlan;
   validateFirmwareUpdatePreparedPlan: typeof validateFirmwareUpdatePreparedPlan;
-  prepareProtocolV2ResourceFiles: typeof prepareProtocolV2ResourceFiles;
   cipherKeyValue: typeof cipherKeyValue;
 
   /**

package/src/types/settings.ts

@@ -104,24 +104,6 @@ export type IProtocolV2ResourceManifest = {
   files: IProtocolV2ResourceManifestFile[];
 };
 
-/** Pro2 RESC bundle okpkg descriptor for incremental FileWrite synchronization. */
-export type IProtocolV2ResourceBundle = {
-  /** Bundle name, such as images, animation, translations, or fonts_roobert. */
-  name: string;
-  /** Download URL. */
-  url: string;
-  fingerprint?: string;
-  expectedSize?: number;
-  /** Device target path, such as vol0:/bundles/images/images.okpkg. */
-  devicePath: string;
-  /** okpkg payload_version used to skip matching content after FileRead. */
-  version?: IVersionArray;
-  /** okpkg payload_hash used for SHA3-512 comparison after FileRead. */
-  payloadHash?: string;
-  /** okpkg header_hash used for SHA3-512 comparison after FileRead. */
-  headerHash?: string;
-};
-
 /** STM32 firmware config */
 export type IFirmwareReleaseInfo = {
   required: boolean;
@@ -149,8 +131,6 @@ export type IFirmwareReleaseInfo = {
   upgradeType?: 'payload-package-set' | string;
   components?: Record<string, IProtocolV2FirmwareComponent>;
   installOrder?: string[];
-  /** Pro2 RESC bundles for incremental direct FileWrite synchronization. */
-  resourceBundles?: IProtocolV2ResourceBundle[];
   bootloaderChangelog?: {
     [k in ILocale]: string;
   };

package/src/utils/deviceFeaturesUtils.ts

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

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

@@ -1,17 +0,0 @@
-import type { FirmwareUpdateV4Target } from './firmwareUpdate';
-export type ProtocolV2ResourceManifestBinary = {
-    archivePath: string;
-    binary: ArrayBuffer;
-};
-export type ProtocolV2PreparedResourceFile = {
-    binary: ArrayBuffer;
-    devicePath: string;
-    size: number;
-    fileHash: string;
-};
-export declare function prepareProtocolV2ResourceFiles(input: {
-    manifest: unknown;
-    files: ProtocolV2ResourceManifestBinary[];
-    targetsToUpdate: readonly FirmwareUpdateV4Target[];
-}): ProtocolV2PreparedResourceFile[];
-//# sourceMappingURL=protocolV2ResourceManifest.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"protocolV2ResourceManifest.d.ts","sourceRoot":"","sources":["../../../src/types/api/protocolV2ResourceManifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE/D,MAAM,MAAM,gCAAgC,GAAG;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG;IAC3C,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,8BAA8B,CAAC,KAAK,EAAE;IAC5D,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,gCAAgC,EAAE,CAAC;IAC1C,eAAe,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACpD,GAAG,8BAA8B,EAAE,CAAC"}

package/src/types/api/protocolV2ResourceManifest.ts

@@ -1,19 +0,0 @@
-import type { FirmwareUpdateV4Target } from './firmwareUpdate';
-
-export type ProtocolV2ResourceManifestBinary = {
-  archivePath: string;
-  binary: ArrayBuffer;
-};
-
-export type ProtocolV2PreparedResourceFile = {
-  binary: ArrayBuffer;
-  devicePath: string;
-  size: number;
-  fileHash: string;
-};
-
-export declare function prepareProtocolV2ResourceFiles(input: {
-  manifest: unknown;
-  files: ProtocolV2ResourceManifestBinary[];
-  targetsToUpdate: readonly FirmwareUpdateV4Target[];
-}): ProtocolV2PreparedResourceFile[];