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

package/src/api/firmware/FirmwareMemoryHost.ts

@@ -0,0 +1,174 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import type { CoreApi } from '../../types/api';
+import type {
+  FirmwareArtifactReader,
+  FirmwareArtifactReference,
+  FirmwareUpdateV4Target,
+} from '../../types/api/firmwareUpdate';
+import type { FirmwareUpdatePlan } from '../../types/api/firmwareUpdatePlan';
+
+export type FirmwareMemoryArtifactEntry = {
+  entryName: string;
+  binary: ArrayBuffer;
+};
+
+export type FirmwareMemoryArtifact = {
+  artifactId: string;
+  binary: ArrayBuffer;
+  materializedEntries?: FirmwareMemoryArtifactEntry[];
+};
+
+export type FirmwareUpdateV4MemoryHost = {
+  preparedPlan: ReturnType<CoreApi['prepareFirmwareUpdatePlan']>;
+  hostBindingGeneration: number;
+  targetsToUpdate: FirmwareUpdateV4Target[];
+  expectedDeviceId: string;
+  expectedTargetVersions: Partial<Record<FirmwareUpdateV4Target, string>>;
+  componentArtifacts: Partial<
+    Record<Exclude<FirmwareUpdateV4Target, 'resource'>, FirmwareArtifactReference>
+  >;
+  release: () => void;
+};
+
+let memoryHostSequence = 0;
+
+const FIRMWARE_UPDATE_V4_COMPONENT_TARGETS = new Set<Exclude<FirmwareUpdateV4Target, 'resource'>>([
+  'boot',
+  'app_v1',
+  'app_v2',
+  'coprocessor',
+  'se01',
+  'se02',
+  'se03',
+  'se04',
+]);
+
+const isFirmwareUpdateV4ComponentTarget = (
+  target: string
+): target is Exclude<FirmwareUpdateV4Target, 'resource'> =>
+  FIRMWARE_UPDATE_V4_COMPONENT_TARGETS.has(target as Exclude<FirmwareUpdateV4Target, 'resource'>);
+
+const createReference = (binary: ArrayBuffer, prefix: string): FirmwareArtifactReference => {
+  const digest = bytesToHex(sha256(new Uint8Array(binary)));
+  return {
+    artifactRef: `fwmem:${prefix}:${digest.slice(0, 32)}`,
+    size: binary.byteLength,
+    sha256: digest,
+  };
+};
+
+export function prepareFirmwareUpdateV4MemoryHost({
+  sdk,
+  plan,
+  artifacts,
+}: {
+  sdk: Pick<
+    CoreApi,
+    | 'prepareFirmwareUpdatePlan'
+    | 'registerFirmwareUpdateHostBinding'
+    | 'unregisterFirmwareUpdateHostBinding'
+  >;
+  plan: FirmwareUpdatePlan;
+  artifacts: FirmwareMemoryArtifact[];
+}): FirmwareUpdateV4MemoryHost {
+  if (plan.executor !== 'v4') {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Firmware memory host only supports V4 plans'
+    );
+  }
+  memoryHostSequence += 1;
+  const hostId = `${Date.now()}:${memoryHostSequence}`;
+  const binaries = new Map<string, Uint8Array>();
+  const inputs = artifacts.map((input, artifactIndex) => {
+    const artifact = createReference(input.binary, `${hostId}:artifact:${artifactIndex}`);
+    binaries.set(artifact.artifactRef, new Uint8Array(input.binary));
+    const materializedEntries = input.materializedEntries?.map((entry, entryIndex) => {
+      const entryArtifact = createReference(
+        entry.binary,
+        `${hostId}:entry:${artifactIndex}:${entryIndex}`
+      );
+      binaries.set(entryArtifact.artifactRef, new Uint8Array(entry.binary));
+      return {
+        entryName: entry.entryName,
+        artifact: entryArtifact,
+      };
+    });
+    return {
+      artifactId: input.artifactId,
+      artifact,
+      ...(materializedEntries?.length ? { materializedEntries } : {}),
+    };
+  });
+  const preparedPlan = sdk.prepareFirmwareUpdatePlan({
+    plan,
+    leaseRef: `fwmemlease:${hostId}`,
+    artifacts: inputs,
+  });
+  const readers = new Map<string, Uint8Array>();
+  let readerSequence = 0;
+  const artifactReader: FirmwareArtifactReader = {
+    open({ artifactRef }) {
+      const binary = binaries.get(artifactRef);
+      if (!binary) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Firmware memory artifact is unavailable'
+        );
+      }
+      readerSequence += 1;
+      const readerId = `fwmemreader:${hostId}:${readerSequence}`;
+      readers.set(readerId, binary);
+      return Promise.resolve({ readerId, size: binary.byteLength });
+    },
+    read({ readerId, offset, length }) {
+      const binary = readers.get(readerId);
+      if (!binary || offset < 0 || length <= 0 || offset + length > binary.byteLength) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Firmware memory artifact read is invalid'
+        );
+      }
+      const data = binary.slice(offset, offset + length).buffer;
+      return Promise.resolve({
+        data,
+        bytesRead: data.byteLength,
+        eof: offset + length === binary.byteLength,
+      });
+    },
+    close({ readerId }) {
+      readers.delete(readerId);
+      return Promise.resolve();
+    },
+  };
+  const hostBindingGeneration = sdk.registerFirmwareUpdateHostBinding({
+    artifactReader,
+    preparedPlanDigest: preparedPlan.preparedPlanDigest,
+  });
+  const componentArtifacts: FirmwareUpdateV4MemoryHost['componentArtifacts'] = {};
+  const expectedTargetVersions: FirmwareUpdateV4MemoryHost['expectedTargetVersions'] = {};
+  for (const artifact of preparedPlan.artifacts) {
+    if (artifact.role === 'component' && isFirmwareUpdateV4ComponentTarget(artifact.target)) {
+      componentArtifacts[artifact.target] = artifact.artifact;
+    }
+    if (artifact.targetVersion) {
+      expectedTargetVersions[artifact.target as FirmwareUpdateV4Target] = artifact.targetVersion;
+    }
+  }
+  return {
+    preparedPlan,
+    hostBindingGeneration,
+    targetsToUpdate: [...preparedPlan.targetsToUpdate] as FirmwareUpdateV4Target[],
+    expectedDeviceId: preparedPlan.deviceIdentity,
+    expectedTargetVersions,
+    componentArtifacts,
+    release: () => {
+      sdk.unregisterFirmwareUpdateHostBinding(hostBindingGeneration);
+      readers.clear();
+      binaries.clear();
+    },
+  };
+}

package/src/api/firmware/FirmwareUpdatePlan.ts

@@ -17,7 +17,7 @@ import type {
   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';
 
@@ -31,7 +31,6 @@ type ReleaseRecord = {
   version?: unknown;
   components?: unknown;
   installOrder?: unknown;
-  resourceBundles?: unknown;
   fingerprint?: unknown;
   fingerprintWeb?: unknown;
   expectedSize?: unknown;
@@ -444,11 +443,9 @@ const buildProtocolV2Artifacts = (
   release: ReleaseRecord,
   {
     includeComponents = true,
-    includeResources = true,
     componentTargets: selectedComponentTargets,
   }: {
     includeComponents?: boolean;
-    includeResources?: boolean;
     componentTargets?: ReadonlySet<FirmwareUpdatePlanTarget>;
   } = {}
 ): {
@@ -523,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)] };
 };
 
@@ -679,7 +639,7 @@ export const buildProtocolV2FirmwareUpdatePlan = ({
   release,
   targetsToUpdate,
   forceUpdateTargets,
-  resourceArchiveAvailable,
+  resourceArchive,
 }: {
   features: Features;
   firmwareType: EFirmwareType;
@@ -687,7 +647,7 @@ export const buildProtocolV2FirmwareUpdatePlan = ({
   release: ReleaseRecord | undefined;
   targetsToUpdate: readonly FirmwareUpdateV4Target[];
   forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
-  resourceArchiveAvailable: boolean;
+  resourceArchive: IProtocolV2ResourceSource | undefined;
 }): FirmwareUpdatePlan => {
   const validatedForceTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
   if (validatedForceTargets.some(target => target === 'ble' || target === 'bootloader')) {
@@ -705,9 +665,32 @@ export const buildProtocolV2FirmwareUpdatePlan = ({
   }
   const protocolV2 = buildProtocolV2Artifacts(release ?? {}, {
     includeComponents: requestedComponentTargets.size > 0,
-    includeResources: false,
     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)
@@ -718,12 +701,10 @@ export const buildProtocolV2FirmwareUpdatePlan = ({
   if (validatedForceTargets.includes('firmware') && protocolV2.targets.length === 0) {
     planError('Forced firmware update target firmware is not represented by the plan');
   }
-  if (validatedForceTargets.includes('resource') && !resourceArchiveAvailable) {
+  if (validatedForceTargets.includes('resource') && !resourceArchive) {
     planError('Forced firmware update target resource has no Protocol V2 resource archive');
   }
 
-  // Protocol V2 resource archives are materialized by the host into explicit
-  // resourceFiles. The prepared artifact plan therefore binds firmware components only.
   return finalizeFirmwareUpdatePlan({
     features,
     firmwareType,
@@ -781,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;

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/data-manager/DataManager.ts

@@ -94,12 +94,10 @@ export default class DataManager {
       ble: [],
     },
     [EDeviceType.Pro2]: {
-      firmware: [],
-      ble: [],
+      'firmware-v1': [],
     },
     [EDeviceType.Neo]: {
-      firmware: [],
-      ble: [],
+      'firmware-v1': [],
     },
     [EDeviceType.ClassicPure]: {
       firmware: [],
@@ -121,6 +119,8 @@ export default class DataManager {
 
   static protocolV2ResourcesConfigError: Error | undefined;
 
+  private static protocolV2NeoResourcesConfigError: Error | undefined;
+
   static getFirmwareStatus = (
     features: Features,
     firmwareType: EFirmwareType
@@ -410,6 +410,7 @@ export default class DataManager {
   static async load(settings: ConnectSettings): Promise<boolean> {
     this.settings = settings;
     this.protocolV2ResourcesConfigError = undefined;
+    this.protocolV2NeoResourcesConfigError = undefined;
     const manifestMode =
       settings.firmwareManifestMode ?? (settings.fetchConfig ? 'sdk-managed' : undefined);
     if (settings.preloadedConfig) {
@@ -476,15 +477,21 @@ export default class DataManager {
       pro2Resources = parseProtocolV2Resources(
         (data.pro2 as { resources?: unknown } | undefined)?.resources
       );
-      neoResources = parseProtocolV2Resources(
-        (data.neo as { resources?: unknown } | undefined)?.resources
-      );
     } catch (error) {
       // Firmware resource metadata is not required for base communication. If the
       // remote config is temporarily incomplete, disable this resource update only.
       this.protocolV2ResourcesConfigError =
         error instanceof Error ? error : new Error(String(error));
-      Log.warn('[DataConfig] Ignoring invalid Protocol V2 resources config:', error);
+      Log.warn('[DataConfig] Ignoring invalid Pro2 resources config:', error);
+    }
+    try {
+      neoResources = parseProtocolV2Resources(
+        (data.neo as { resources?: unknown } | undefined)?.resources
+      );
+    } catch (error) {
+      this.protocolV2NeoResourcesConfigError =
+        error instanceof Error ? error : new Error(String(error));
+      Log.warn('[DataConfig] Ignoring invalid Neo resources config:', error);
     }
     const enrichedPro2Config = this.enrichFirmwareReleaseInfo(data.pro2);
     const enrichedNeoConfig = this.enrichFirmwareReleaseInfo(data.neo);
@@ -537,7 +544,12 @@ export default class DataManager {
   /** Force a fresh remote config before an update is allowed to mutate the device. */
   static async forceReloadData({
     requireResources = false,
-  }: { requireResources?: boolean } = {}): Promise<void> {
+    resourceDeviceType = EDeviceType.Pro2,
+  }: {
+    requireResources?: boolean;
+    resourceDeviceType?: EDeviceType.Pro2 | EDeviceType.Neo;
+  } = {}): Promise<void> {
+    const resourceDeviceName = resourceDeviceType === EDeviceType.Pro2 ? 'Pro2' : 'Neo';
     if (!this.settings) {
       throw new Error('Remote config settings are not initialized');
     }
@@ -545,10 +557,14 @@ export default class DataManager {
       this.lastCheckTimestamp > 0 &&
       getTimeStamp() - this.lastCheckTimestamp <= FIRMWARE_UPDATE_CONFIG_FRESHNESS_MS;
     if (hasFreshConfig) {
-      if (requireResources && this.protocolV2ResourcesConfigError) {
+      const resourcesConfigError =
+        resourceDeviceType === EDeviceType.Pro2
+          ? this.protocolV2ResourcesConfigError
+          : this.protocolV2NeoResourcesConfigError;
+      if (requireResources && resourcesConfigError) {
         throw ERRORS.TypedError(
           HardwareErrorCode.FirmwareUpdateDownloadFailed,
-          `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`
+          `Invalid ${resourceDeviceName} resources config: ${resourcesConfigError.message}`
         );
       }
       return;
@@ -560,10 +576,14 @@ export default class DataManager {
         'Unable to refresh the latest remote config'
       );
     }
-    if (requireResources && this.protocolV2ResourcesConfigError) {
+    const resourcesConfigError =
+      resourceDeviceType === EDeviceType.Pro2
+        ? this.protocolV2ResourcesConfigError
+        : this.protocolV2NeoResourcesConfigError;
+    if (requireResources && resourcesConfigError) {
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareUpdateDownloadFailed,
-        `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`
+        `Invalid ${resourceDeviceName} resources config: ${resourcesConfigError.message}`
       );
     }
     this.lastCheckTimestamp = getTimeStamp();

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

@@ -75,7 +75,6 @@ export type AllFirmwareRelease = {
   required?: boolean;
   resourceStatus?: 'valid' | 'outdated' | 'unknown';
   resourceArchive?: IProtocolV2ResourceSource;
-  resourcePreparationRequired?: boolean;
   currentVersions?: DeviceStateVersions;
   components?: ProtocolV2FirmwareComponentRelease[];
   targetsToUpdate?: FirmwareUpdateV4Target[];

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

@@ -26,6 +26,8 @@ export interface FirmwareArtifactReader {
 
 export interface FirmwareUpdateHostBinding {
   artifactReader: FirmwareArtifactReader;
+  /** 将读取器 generation 绑定到包含 ZIP 条目的完整 PreparedPlan。 */
+  preparedPlanDigest: string;
 }
 
 export interface FirmwareUpdateBinaryParams {
@@ -153,25 +155,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;
   };
@@ -179,22 +159,20 @@ export type IBLEFirmwareReleaseInfo = {
 };
 
 type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
-type ILegacyKnownDevice = Exclude<IKnownDevice, 'neo'>;
-
 type IDeviceReleaseInfo = {
-  firmware: IFirmwareReleaseInfo[];
+  firmware?: IFirmwareReleaseInfo[];
   /** Protocol V2 payload package set */
   'firmware-v1'?: IFirmwareReleaseInfo[];
   'firmware-v2'?: IFirmwareReleaseInfo[];
   'firmware-v8'?: IFirmwareReleaseInfo[];
   'firmware-btc-v8'?: IFirmwareReleaseInfo[];
-  ble: IBLEFirmwareReleaseInfo[];
+  ble?: IBLEFirmwareReleaseInfo[];
   /** Independent Protocol V2 resource release configuration. */
   resources?: IProtocolV2Resources;
 };
 
 export type DeviceTypeMap = {
-  [k in ILegacyKnownDevice]: IDeviceReleaseInfo;
+  [k in Exclude<IKnownDevice, 'neo'>]: IDeviceReleaseInfo;
 } & {
   /** Optional until every remote-config producer publishes a Neo entry. */
   neo?: IDeviceReleaseInfo;

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"}