@onekeyfe/hd-core 1.2.0-alpha.157 → 1.2.0-alpha.159

package/src/api/FirmwareUpdateV4.ts

@@ -32,12 +32,13 @@ import {
 } from '../protocols/protocol-v2';
 import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
 import {
+  PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH,
   PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH,
   PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE,
+  type ProtocolV2ResourcePackageHeader,
   isProtocolV2ResourceArchiveEntryName,
   parseProtocolV2ResourcePackage,
   parseProtocolV2ResourcePackageHeader,
-  type ProtocolV2ResourcePackageHeader,
 } from '../protocols/protocol-v2/resources';
 import {
   getProtocolV2UnknownErrorText,
@@ -48,20 +49,12 @@ import {
   readFirmwareByteSourceFully,
   writeFirmwareByteSource,
 } from './firmware/FirmwareArtifactSource';
-import {
-  registerFirmwareUpdateHostBinding,
-  resolveFirmwareUpdateHostBinding,
-  unregisterFirmwareUpdateHostBinding,
-} from './firmware/FirmwareHostBinding';
+import { resolveFirmwareUpdateHostBinding } from './firmware/FirmwareHostBinding';
 import {
   assertFirmwareUpdatePreparedPlanBinding,
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
-  prepareFirmwareUpdatePlan,
   validateFirmwareUpdatePreparedPlan,
 } from './firmware/FirmwareUpdatePreparedPlan';
-import { prepareFirmwareUpdateV4MemoryHost } from './firmware/FirmwareMemoryHost';
-import { buildProtocolV2LocalFirmwareUpdatePlan } from './firmware/FirmwareUpdatePlan';
-
 import type {
   FirmwareArtifactReference,
   FirmwareUpdateV4Params,
@@ -78,11 +71,6 @@ import type {
   KnownDevice,
 } from '../types';
 import type { FirmwareByteSource } from './firmware/FirmwareArtifactSource';
-import type {
-  FirmwareMemoryArtifact,
-  FirmwareMemoryArtifactEntry,
-  FirmwareUpdateV4MemoryHost,
-} from './firmware/FirmwareMemoryHost';
 
 const Log = getLogger(LoggerNames.Method);
 
@@ -231,7 +219,6 @@ type ProtocolV2ResourceBundleSource = {
 
 type ProtocolV2LocalResourceArchive = {
   binary: ArrayBuffer;
-  materializedEntries: FirmwareMemoryArtifactEntry[];
   resources: Array<{
     entryName: string;
     binary: ArrayBuffer;
@@ -302,13 +289,9 @@ const PROTOCOL_V2_FIRMWARE_STAGING_PATHS = new Set(
   )
 );
 
-const isProtocolV2BootResourcePackagePath = (devicePath: string) => {
-  if (typeof devicePath !== 'string') return false;
-  const normalized = devicePath.toLowerCase();
-  return (
-    normalized.startsWith('vol0:/loaders/bootloader/') && normalized.endsWith('.okpkg.staging')
-  );
-};
+const isProtocolV2BootResourcePackagePath = (devicePath: string) =>
+  typeof devicePath === 'string' &&
+  devicePath.toLowerCase() === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH;
 
 const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map<
   number,
@@ -797,15 +780,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       this.params.resourceArchiveBinary &&
       this.params.targetsToUpdate?.includes('resource')
     ) {
-      const localMemoryHost = await this.prepareProtocolV2LocalMemoryHost({
-        features: deviceFeatures,
-        firmwareType,
-      });
-      try {
-        return await this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
-      } finally {
-        localMemoryHost.release();
-      }
+      return this.runProtocolV2DirectArtifacts({});
     }
 
     const hasPreparedComponentArtifacts = Object.values(this.params.componentArtifacts ?? {}).some(
@@ -818,12 +793,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     let fwBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
     let installItems: ProtocolV2InstallItem[] | undefined;
-    let resourceMemoryHost: FirmwareUpdateV4MemoryHost | undefined;
+    let explicitInstallItems: ProtocolV2InstallItem[] | undefined;
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
       fwBinaryMap = this.collectExplicitTargetBinaries();
       bootloaderBinary = this.prepareBootloaderBinary();
-      const explicitInstallItems = this.buildProtocolV2InstallItems({
+      explicitInstallItems = this.buildProtocolV2InstallItems({
         bootloaderBinary,
         fwBinaryMap,
       });
@@ -879,15 +854,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           deviceFeatures,
           firmwareType
         );
-        resourceMemoryHost = await this.prepareProtocolV2LocalMemoryHost({
-          features: deviceFeatures,
-          firmwareType,
-          availableInstallItems: installItems ?? explicitInstallItems,
-        });
       }
       this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
     } catch (err) {
-      resourceMemoryHost?.release();
       if (
         typeof err === 'object' &&
         err !== null &&
@@ -902,12 +871,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       throw normalizeFirmwarePreparationError(err);
     }
 
-    if (resourceMemoryHost) {
-      try {
-        return await this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType, false);
-      } finally {
-        resourceMemoryHost.release();
-      }
+    if (wantsResources && this.params.resourceArchiveBinary) {
+      return this.runProtocolV2DirectArtifacts({
+        availableInstallItems: installItems ?? explicitInstallItems,
+        announceDownload: false,
+      });
     }
 
     if (!bootloaderBinary && fwBinaryMap.length === 0 && !installItems?.length) {
@@ -1060,133 +1028,69 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return installSources;
   }
 
-  private async prepareProtocolV2LocalMemoryHost({
-    features,
-    firmwareType,
-    availableInstallItems = this.buildProtocolV2InstallItems({
-      bootloaderBinary: this.prepareBootloaderBinary(),
-      fwBinaryMap: this.collectExplicitTargetBinaries(),
-    }),
+  private async runProtocolV2DirectArtifacts({
+    availableInstallItems,
+    announceDownload = true,
   }: {
-    features: Features;
-    firmwareType: EFirmwareType;
     availableInstallItems?: ProtocolV2InstallItem[];
-  }): Promise<FirmwareUpdateV4MemoryHost> {
-    const requestedComponentTargets = new Set(
-      (this.params.targetsToUpdate ?? []).filter(
-        (target): target is Exclude<FirmwareUpdateV4Target, 'resource' | 'boot_resources'> =>
-          target !== 'resource' && target !== 'boot_resources'
-      )
-    );
-    const localComponentTargets = new Set(
-      availableInstallItems.flatMap(item => {
-        const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
-        return target ? [target] : [];
-      })
-    );
-    const missingTarget = Array.from(requestedComponentTargets).find(
-      target => !localComponentTargets.has(target)
-    );
-    if (missingTarget) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `Protocol V2 local update has no binary for requested target ${missingTarget}`,
-        {
-          firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-          artifactName: missingTarget,
-        }
+    announceDownload?: boolean;
+  }) {
+    try {
+      if (announceDownload) {
+        this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
+      }
+      const installItems = this.filterProtocolV2LocalInstallItems(
+        availableInstallItems ??
+          this.buildProtocolV2InstallItems({
+            bootloaderBinary: this.prepareBootloaderBinary(),
+            fwBinaryMap: this.collectExplicitTargetBinaries(),
+          })
       );
-    }
-    const installItems = this.filterProtocolV2LocalInstallItems(availableInstallItems);
-
-    const planArtifacts: Parameters<typeof buildProtocolV2LocalFirmwareUpdatePlan>[0]['artifacts'] =
-      [];
-    const memoryArtifacts: FirmwareMemoryArtifact[] = [];
-    for (const item of installItems) {
-      const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
-      if (!target || item.binary.byteLength <= 0) {
+      const installSources = await Promise.all(
+        installItems.map(async item => ({
+          fileName: item.fileName,
+          source: await this.openProtocolV2MemorySource(item.binary),
+          targetId: item.targetId,
+          kind: item.kind,
+        }))
+      );
+      const resourceSources = this.params.resourceArchiveBinary
+        ? await this.createProtocolV2ResourceSourcesFromArchive(this.params.resourceArchiveBinary)
+        : [];
+      if (installSources.length === 0 && resourceSources.length === 0) {
         throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          `Protocol V2 local firmware artifact is invalid: ${item.fileName}`,
-          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' }
+          HardwareErrorCode.FirmwareUpdateDownloadFailed,
+          'No firmware to update'
         );
       }
-      const artifactId = `component:${target}`;
-      planArtifacts.push({
-        artifactId,
-        target,
-        container: 'raw',
-        logicalName: item.fileName,
-        expectedSize: item.binary.byteLength,
-        expectedSha256: bytesToHex(sha256(new Uint8Array(item.binary))),
-        ...(this.params.expectedTargetVersions?.[target]
-          ? { targetVersion: this.params.expectedTargetVersions[target] }
-          : {}),
+      if (announceDownload) {
+        this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
+      }
+      return await this.executeProtocolV2SourceUpdate({
+        installSources,
+        resourceSources,
       });
-      memoryArtifacts.push({ artifactId, binary: item.binary });
+    } finally {
+      await this.closeProtocolV2PreparedSources();
     }
+  }
 
-    const resourceArchive = await this.prepareProtocolV2LocalResourceArchive(
-      this.params.resourceArchiveBinary as ArrayBuffer
-    );
-    const resourceArtifactId = 'resource:archive';
-    planArtifacts.push({
-      artifactId: resourceArtifactId,
-      target: 'resource',
-      container: 'zip',
-      logicalName: 'protocol-v2-local-resource-archive',
-      expectedSize: resourceArchive.binary.byteLength,
-      expectedSha256: bytesToHex(sha256(new Uint8Array(resourceArchive.binary))),
-    });
-    memoryArtifacts.push({
-      artifactId: resourceArtifactId,
-      binary: resourceArchive.binary,
-      materializedEntries: resourceArchive.materializedEntries,
-    });
-
-    const plan = buildProtocolV2LocalFirmwareUpdatePlan({
-      features,
-      firmwareType,
-      platform: this.params.platform,
-      artifacts: planArtifacts,
-    });
-    let memoryHost: FirmwareUpdateV4MemoryHost | undefined;
-    try {
-      memoryHost = prepareFirmwareUpdateV4MemoryHost({
-        sdk: {
-          prepareFirmwareUpdatePlan,
-          registerFirmwareUpdateHostBinding,
-          unregisterFirmwareUpdateHostBinding,
-        },
-        plan,
-        artifacts: memoryArtifacts,
-      });
-      const preparedPlan = validateFirmwareUpdatePreparedPlan(memoryHost.preparedPlan);
-      assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan,
-        executor: 'v4',
-        platform: this.params.platform,
-        scopeTargets: [],
-        bindings: [],
-      });
-      assertFirmwareUpdatePreparedPlanDeviceIdentity({
-        preparedPlan,
-        deviceIdentity: this.protocolV2ExpectedSerialNumber,
-        deviceModel: this.getProtocolV2PreparedPlanDeviceModel(features),
+  private async createProtocolV2ResourceSourcesFromArchive(
+    binary: ArrayBuffer
+  ): Promise<ProtocolV2ResourceBundleSource[]> {
+    const archive = await this.prepareProtocolV2LocalResourceArchive(binary);
+    const sources: ProtocolV2ResourceBundleSource[] = [];
+    for (const resource of archive.resources) {
+      sources.push({
+        name: resource.entryName.split('/').pop() ?? resource.entryName,
+        source: await this.openProtocolV2MemorySource(resource.binary),
+        devicePath: resource.header.devicePath,
+        version: resource.header.version,
+        payloadHash: resource.header.payloadHash,
+        headerHash: resource.header.headerHash,
       });
-      const hostBinding = resolveFirmwareUpdateHostBinding(
-        memoryHost.hostBindingGeneration,
-        preparedPlan.preparedPlanDigest
-      );
-      this.params.preparedPlan = preparedPlan;
-      this.params.targetsToUpdate = [...preparedPlan.targetsToUpdate] as FirmwareUpdateV4Target[];
-      this.params.artifactReader = hostBinding.artifactReader;
-      this.params.componentArtifacts = undefined;
-      return memoryHost;
-    } catch (error) {
-      memoryHost?.release();
-      throw error;
     }
+    return sources;
   }
 
   private async prepareProtocolV2LocalResourceArchive(
@@ -1225,7 +1129,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     let totalSize = 0;
-    const materializedEntries: FirmwareMemoryArtifactEntry[] = [];
     const resources: ProtocolV2LocalResourceArchive['resources'] = [];
     const devicePaths = new Set<string>();
     for (const entry of resourceEntries) {
@@ -1269,10 +1172,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         );
       }
       devicePaths.add(canonicalDevicePath);
-      materializedEntries.push({ entryName: entry.name, binary: fileBinary });
       resources.push({ entryName: entry.name, binary: fileBinary, header });
     }
-    return { binary, materializedEntries, resources };
+    return { binary, resources };
   }
 
   private async prepareProtocolV2ResourceSources(): Promise<ProtocolV2ResourceBundleSource[]> {
@@ -1339,20 +1241,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     // The verified ZIP bytes are authoritative. Non-okpkg entries are release
     // metadata only; each RESOURCE package carries its own device path.
-    const verifiedArchive = await this.prepareProtocolV2LocalResourceArchive(archiveBinary);
-    const sources: ProtocolV2ResourceBundleSource[] = [];
-    for (const resource of verifiedArchive.resources) {
-      const source = await this.openProtocolV2MemorySource(resource.binary);
-      sources.push({
-        name: resource.entryName.split('/').pop() ?? resource.entryName,
-        source,
-        devicePath: resource.header.devicePath,
-        version: resource.header.version,
-        payloadHash: resource.header.payloadHash,
-        headerHash: resource.header.headerHash,
-      });
-    }
-    return sources;
+    return this.createProtocolV2ResourceSourcesFromArchive(archiveBinary);
   }
 
   private async runProtocolV2PreparedArtifacts(
@@ -1836,6 +1725,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return `vol0:/${path}`;
   }
 
+  private getProtocolV2ResourceComparePath(devicePath: string) {
+    return isProtocolV2BootResourcePackagePath(devicePath)
+      ? PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH
+      : devicePath;
+  }
+
   private async readProtocolV2DeviceFileHeader(path: string, expectedSize?: number) {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
     const filePath = this.getProtocolV2ResourceFilePath(path);
@@ -1898,7 +1793,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
     try {
       const header = await this.readProtocolV2DeviceFileHeader(
-        bundle.devicePath,
+        this.getProtocolV2ResourceComparePath(bundle.devicePath),
         bundle.source.size
       );
       if (!header) return false;
@@ -2157,11 +2052,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     let totalSize = installSources.reduce((total, item) => total + item.source.size, 0);
     const resourcesToSync: ProtocolV2ResourceBundleSource[] = [];
     for (const resource of resourceSources) {
-      // Early boot promotes this mounted package's staging file. Always replace any
-      // stale staging bytes with the artifact approved by the current PreparedPlan,
-      // even when the mounted final file itself is already current.
-      const requiresFreshStaging = isProtocolV2BootResourcePackagePath(resource.devicePath);
-      if (!requiresFreshStaging && (await this.isProtocolV2ResourceBundleUpToDate(resource))) {
+      if (await this.isProtocolV2ResourceBundleUpToDate(resource)) {
         Log.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
       } else {
         resourcesToSync.push(resource);

package/src/api/firmware/FirmwareUpdatePlan.ts

@@ -654,47 +654,6 @@ const finalizeFirmwareUpdatePlan = ({
   });
 };
 
-export type ProtocolV2LocalFirmwareUpdatePlanArtifact = {
-  artifactId: string;
-  target: Exclude<FirmwareUpdateV4Target, 'boot_resources'>;
-  container: 'raw' | 'zip';
-  logicalName: string;
-  expectedSize: number;
-  expectedSha256: string;
-  targetVersion?: string;
-};
-
-export const buildProtocolV2LocalFirmwareUpdatePlan = ({
-  features,
-  firmwareType,
-  platform,
-  artifacts,
-}: {
-  features: Features;
-  firmwareType: EFirmwareType;
-  platform: FirmwareUpdatePlatform;
-  artifacts: ProtocolV2LocalFirmwareUpdatePlanArtifact[];
-}): FirmwareUpdatePlan => {
-  if (artifacts.length === 0) {
-    return planError('Protocol V2 local firmware plan has no artifacts');
-  }
-  const plan = finalizeFirmwareUpdatePlan({
-    features,
-    firmwareType,
-    platform,
-    artifacts: artifacts.map(artifact => ({
-      ...artifact,
-      role: artifact.target === 'resource' ? 'resourceBundle' : 'component',
-      url: `https://local-firmware.invalid/${encodeURIComponent(artifact.artifactId)}`,
-    })),
-    targetsToUpdate: artifacts.map(artifact => artifact.target),
-  });
-  if (plan.executor !== 'v4') {
-    return planError('Protocol V2 local firmware plan requires executor v4');
-  }
-  return plan;
-};
-
 export const buildProtocolV2FirmwareUpdatePlan = ({
   features,
   firmwareType,

package/src/api/firmware/FirmwareUpdatePreparedPlan.ts

@@ -73,6 +73,8 @@ export const getFirmwareUpdateResourceName = (value: unknown): string => {
 
 const getPreparedEntryIdentity = (entryName: unknown): string => {
   getFirmwareUpdateResourceName(entryName);
+  // Protocol V2 resource ZIPs can ship the same basename from different
+  // directories, such as rom/params.okpkg and bootloader/params.okpkg.
   return (entryName as string).toLowerCase();
 };
 

package/src/data-manager/TransportManager.ts

@@ -69,7 +69,9 @@ export default class TransportManager {
       } else if (env === 'desktop-web-ble') {
         await this.transport.init(WebBleLogger, DevicePool.emitter);
       } else if (env === 'webusb' || env === 'desktop-webusb') {
-        await this.transport.init(WebUsbLogger);
+        // The emitter is what turns a navigator.usb 'disconnect' into a
+        // DEVICE.DISCONNECT; without it WebUSB never reports device removal.
+        await this.transport.init(WebUsbLogger, DevicePool.emitter);
       } else {
         await this.transport.init(HttpLogger);
       }

package/src/index.ts

@@ -21,12 +21,6 @@ export { executeCallback, cleanupCallback };
 export { preloadSessionCache } from './device/Device';
 export { projectFeatures as projectDeviceStateFeatures } from './device/DeviceStateProjector';
 export { getMethodSupportedProtocols } from './api/utils';
-export { prepareFirmwareUpdateV4MemoryHost } from './api/firmware/FirmwareMemoryHost';
-export type {
-  FirmwareMemoryArtifact,
-  FirmwareMemoryArtifactEntry,
-  FirmwareUpdateV4MemoryHost,
-} from './api/firmware/FirmwareMemoryHost';
 export {
   getFirmwareUpdateHostBindingGeneration,
   registerFirmwareUpdateHostBinding,

package/src/types/api/firmwareUpdate.ts

@@ -158,7 +158,7 @@ export interface FirmwareUpdateV4Params {
   se02Binary?: ArrayBuffer;
   se03Binary?: ArrayBuffer;
   se04Binary?: ArrayBuffer;
-  /** Complete Protocol V2 resource ZIP for local development; Core converts it to a local PreparedPlan. */
+  /** Complete Protocol V2 resource ZIP. Core parses RESC packages and writes only changed files. */
   resourceArchiveBinary?: ArrayBuffer;
   forcedUpdateRes?: boolean;
   artifactReader?: FirmwareArtifactReader;

package/src/utils/deviceInfoUtils.ts

@@ -31,7 +31,9 @@ export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
   if (/^Touch/i.test(name)) return EDeviceType.Touch;
 
   const compactName = name.replace(/[\s-]/g, '');
-  if (/\bPro\s*2\b/i.test(name) || /^Pro2/i.test(name) || /^(?:OneKey)?Pro2/i.test(compactName)) {
+  // Require a 4-hex Pro2 suffix in the compact form. A bare `^Pro2` prefix
+  // would also match OneKey Pro names such as "Pro 22D8" / "Pro 2D8F".
+  if (/\bPro\s*2\b/i.test(name) || /^(?:OneKey)?Pro2[a-f0-9]{4}$/i.test(compactName)) {
     return EDeviceType.Pro2;
   }
   if (/\bNeo\b/i.test(name) || /^Neo/i.test(name) || /^(?:OneKey)?Neo/i.test(compactName)) {

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

@@ -1,126 +0,0 @@
-import { prepareFirmwareUpdateV4MemoryHost } from '../src/api/firmware/FirmwareMemoryHost';
-
-import type { CoreApi } from '../src/types/api';
-import type { FirmwareUpdatePlan } from '../src/types/api/firmwareUpdatePlan';
-
-describe('prepareFirmwareUpdateV4MemoryHost', () => {
-  test('registers artifact-backed component and resource readers', async () => {
-    const componentBinary = new Uint8Array([1, 2, 3, 4]).buffer;
-    const archiveBinary = new Uint8Array([5, 6]).buffer;
-    const manifestBinary = new TextEncoder().encode('{"schema":1}').buffer;
-    let artifactReader: Parameters<
-      CoreApi['registerFirmwareUpdateHostBinding']
-    >[0]['artifactReader'];
-    const unregisterFirmwareUpdateHostBinding = jest.fn();
-    const sdk = {
-      prepareFirmwareUpdatePlan: jest.fn(({ plan, artifacts }) => ({
-        schemaVersion: 2,
-        preparedPlanDigest: 'b'.repeat(64),
-        planDigest: plan.planDigest,
-        networkPolicy: 'forbid',
-        executor: plan.executor,
-        deviceIdentity: plan.deviceIdentity,
-        deviceModel: plan.deviceModel,
-        firmwareType: plan.firmwareType,
-        platform: plan.platform,
-        leaseRef: 'test-lease',
-        targetsToUpdate: plan.targetsToUpdate,
-        artifacts: plan.artifacts.map(planArtifact => {
-          const input = artifacts.find(item => item.artifactId === planArtifact.artifactId);
-          return {
-            ...planArtifact,
-            artifact: input?.artifact,
-            materializedEntries: input?.materializedEntries,
-          };
-        }),
-      })),
-      registerFirmwareUpdateHostBinding: jest.fn(binding => {
-        artifactReader = binding.artifactReader;
-        return 7;
-      }),
-      unregisterFirmwareUpdateHostBinding,
-    } as unknown as Pick<
-      CoreApi,
-      | 'prepareFirmwareUpdatePlan'
-      | 'registerFirmwareUpdateHostBinding'
-      | 'unregisterFirmwareUpdateHostBinding'
-    >;
-    const plan = {
-      schemaVersion: 2,
-      planDigest: 'a'.repeat(64),
-      executor: 'v4',
-      deviceIdentity: 'device-id',
-      deviceModel: 'pro2',
-      firmwareType: 0,
-      platform: 'web',
-      targetsToUpdate: ['boot', 'resource'],
-      artifacts: [
-        {
-          artifactId: 'component:boot',
-          role: 'component',
-          target: 'boot',
-          url: 'https://example.com/boot.okpkg',
-          container: 'raw',
-        },
-        {
-          artifactId: 'resource:archive',
-          role: 'resourceBundle',
-          target: 'resource',
-          url: 'https://example.com/resource.zip',
-          container: 'zip',
-          logicalName: 'resource-archive',
-        },
-      ],
-    } as FirmwareUpdatePlan;
-
-    const host = prepareFirmwareUpdateV4MemoryHost({
-      sdk,
-      plan,
-      artifacts: [
-        { artifactId: 'component:boot', binary: componentBinary },
-        {
-          artifactId: 'resource:archive',
-          binary: archiveBinary,
-          materializedEntries: [{ entryName: 'manifest.json', binary: manifestBinary }],
-        },
-      ],
-    });
-
-    expect(host.hostBindingGeneration).toBe(7);
-    expect(sdk.registerFirmwareUpdateHostBinding).toHaveBeenCalledWith(
-      expect.objectContaining({ preparedPlanDigest: host.preparedPlan.preparedPlanDigest })
-    );
-    const componentArtifact = host.preparedPlan.artifacts.find(
-      artifact => artifact.target === 'boot'
-    )?.artifact;
-    const resourceEntryArtifact = host.preparedPlan.artifacts.find(
-      artifact => artifact.target === 'resource'
-    )?.materializedEntries?.[0]?.artifact;
-    expect(componentArtifact?.size).toBe(componentBinary.byteLength);
-    expect(resourceEntryArtifact?.size).toBe(manifestBinary.byteLength);
-    if (!artifactReader || !componentArtifact || !resourceEntryArtifact) {
-      throw new Error('Firmware memory host test setup is incomplete');
-    }
-    new Uint8Array(componentBinary).fill(9);
-    const opened = await artifactReader.open({
-      artifactRef: componentArtifact.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 });
-
-    // Materialized ZIP entries are receipts only. Execution opens the approved
-    // archive and re-derives these bytes, so the memory host must not retain a
-    // second readable copy of every expanded resource file.
-    expect(() => artifactReader.open({ artifactRef: resourceEntryArtifact.artifactRef })).toThrow(
-      'Firmware memory artifact is unavailable'
-    );
-
-    host.release();
-    expect(unregisterFirmwareUpdateHostBinding).toHaveBeenCalledWith(7);
-  });
-});

package/dist/api/firmware/FirmwareMemoryHost.d.ts

@@ -1,22 +0,0 @@
-import type { CoreApi } from '../../types/api';
-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;
-    release: () => void;
-};
-export declare function prepareFirmwareUpdateV4MemoryHost({ sdk, plan, artifacts, }: {
-    sdk: Pick<CoreApi, 'prepareFirmwareUpdatePlan' | 'registerFirmwareUpdateHostBinding' | 'unregisterFirmwareUpdateHostBinding'>;
-    plan: FirmwareUpdatePlan;
-    artifacts: FirmwareMemoryArtifact[];
-}): FirmwareUpdateV4MemoryHost;
-//# sourceMappingURL=FirmwareMemoryHost.d.ts.map

package/dist/api/firmware/FirmwareMemoryHost.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FirmwareMemoryHost.d.ts","sourceRoot":"","sources":["../../../src/api/firmware/FirmwareMemoryHost.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAK/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAE7E,MAAM,MAAM,2BAA2B,GAAG;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,WAAW,CAAC;IACpB,mBAAmB,CAAC,EAAE,2BAA2B,EAAE,CAAC;CACrD,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,YAAY,EAAE,UAAU,CAAC,OAAO,CAAC,2BAA2B,CAAC,CAAC,CAAC;IAC/D,qBAAqB,EAAE,MAAM,CAAC;IAC9B,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAaF,wBAAgB,iCAAiC,CAAC,EAChD,GAAG,EACH,IAAI,EACJ,SAAS,GACV,EAAE;IACD,GAAG,EAAE,IAAI,CACP,OAAO,EACL,2BAA2B,GAC3B,mCAAmC,GACnC,qCAAqC,CACxC,CAAC;IACF,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,sBAAsB,EAAE,CAAC;CACrC,GAAG,0BAA0B,CA0F7B"}