@onekeyfe/hd-core 1.2.0-alpha.160 → 1.2.0-alpha.161

package/dist/index.js

@@ -419,8 +419,7 @@ const resolveDeviceBleName = (features) => {
     if (!features)
         return null;
     const compatible = asCompatibleFeatures(features);
-    const bleName = (_a = firstNonEmptyString(compatible.bleName, compatible.onekey_ble_name, compatible.ble_name)) !== null && _a !== void 0 ? _a : null;
-    return bleName ? hdShared.canonicalizePro2BleAdvertisementName(bleName) : null;
+    return ((_a = firstNonEmptyString(compatible.bleName, compatible.onekey_ble_name, compatible.ble_name)) !== null && _a !== void 0 ? _a : null);
 };
 const resolveDeviceFirmwareVersion = (features) => {
     var _a;
@@ -468,7 +467,7 @@ const getDeviceTypeByBleName = (name) => {
     if (/^Touch/i.test(name))
         return hdShared.EDeviceType.Touch;
     const compactName = name.replace(/[\s-]/g, '');
-    if (/\bPro\s*2\b/i.test(name) || /^(?:OneKey)?Pro2[a-f0-9]{4}$/i.test(compactName)) {
+    if (/\bPro\s*2\b/i.test(name) || /^Pro2/i.test(name) || /^(?:OneKey)?Pro2/i.test(compactName)) {
         return hdShared.EDeviceType.Pro2;
     }
     if (/\bNeo\b/i.test(name) || /^Neo/i.test(name) || /^(?:OneKey)?Neo/i.test(compactName)) {
@@ -930,6 +929,22 @@ const finalizeFirmwareUpdatePlan = ({ features, firmwareType, platform, artifact
     };
     return assertFirmwareUpdatePlan(Object.assign(Object.assign({}, planWithoutDigest), { planDigest: digestFirmwareUpdatePlan(planWithoutDigest) }));
 };
+const buildProtocolV2LocalFirmwareUpdatePlan = ({ features, firmwareType, platform, artifacts, }) => {
+    if (artifacts.length === 0) {
+        return planError('Protocol V2 local firmware plan has no artifacts');
+    }
+    const plan = finalizeFirmwareUpdatePlan({
+        features,
+        firmwareType,
+        platform,
+        artifacts: artifacts.map(artifact => (Object.assign(Object.assign({}, 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;
+};
 const buildProtocolV2FirmwareUpdatePlan = ({ features, firmwareType, platform, release, targetsToUpdate, forceUpdateTargets, resourceArchive, }) => {
     const validatedForceTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
     if (validatedForceTargets.some(target => target === 'ble' || target === 'bootloader')) {
@@ -1120,10 +1135,6 @@ const getFirmwareUpdateResourceName = (value) => {
     }
     return resourceName;
 };
-const getPreparedEntryIdentity = (entryName) => {
-    getFirmwareUpdateResourceName(entryName);
-    return entryName.toLowerCase();
-};
 const assertPreparedEntry = (value) => {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return preparedPlanError('Firmware prepared plan entry must be an object');
@@ -1176,8 +1187,7 @@ const assertPreparedArtifacts = ({ plan, artifacts, }) => {
             return preparedPlanError('Firmware prepared plan materialization is incomplete');
         }
         if (materializedEntries &&
-            new Set(materializedEntries.map(entry => getPreparedEntryIdentity(entry.entryName))).size !==
-                materializedEntries.length) {
+            new Set(materializedEntries.map(entry => getFirmwareUpdateResourceName(entry.entryName).toLowerCase())).size !== materializedEntries.length) {
             return preparedPlanError('Firmware prepared plan contains duplicate entry names');
         }
         return Object.assign(Object.assign(Object.assign(Object.assign({ artifactId: planArtifact.artifactId, role: planArtifact.role, target: planArtifact.target, container: planArtifact.container }, (planArtifact.logicalName ? { logicalName: planArtifact.logicalName } : {})), (planArtifact.targetVersion ? { targetVersion: planArtifact.targetVersion } : {})), { artifact: Object.assign(Object.assign({}, artifact), { sha256: artifact.sha256.toLowerCase() }) }), ((materializedEntries === null || materializedEntries === void 0 ? void 0 : materializedEntries.length) ? { materializedEntries } : {}));
@@ -1283,7 +1293,7 @@ const validateFirmwareUpdatePreparedPlan = (value) => {
         assertFirmwareArtifactReference(artifact.artifact);
         const materializedEntryNames = (_d = (_c = artifact.materializedEntries) === null || _c === void 0 ? void 0 : _c.map(entry => {
             assertPreparedEntry(entry);
-            return getPreparedEntryIdentity(entry.entryName);
+            return getFirmwareUpdateResourceName(entry.entryName).toLowerCase();
         })) !== null && _d !== void 0 ? _d : [];
         if (new Set(materializedEntryNames).size !== materializedEntryNames.length) {
             return preparedPlanError('Firmware prepared plan contains duplicate entry names');
@@ -40706,26 +40716,21 @@ function parseProtocolV2Resources(value) {
         },
     };
 }
-function isProtocolV2ResourceArchiveEntryName(entryName) {
-    var _a;
-    const normalized = entryName.replace(/\\/g, '/');
-    if (!normalized.toLowerCase().endsWith('.okpkg')) {
-        return false;
-    }
-    const parts = normalized.split('/');
-    const fileName = (_a = parts[parts.length - 1]) !== null && _a !== void 0 ? _a : '';
-    return (fileName.length > 0 &&
-        !fileName.startsWith('.') &&
-        !parts.some(part => part === '__MACOSX' || part === '.' || part === '..' || part === ''));
-}
-function isSafeResourceDevicePath(path) {
-    return !(path.includes('\\') ||
+const PROTOCOL_V2_RESOURCE_DEVICE_ROOTS = ['vol0:/bundles/', 'vol0:/loaders/rom/'];
+function isAllowedResourceDevicePath(path) {
+    if (path.includes('\\') ||
         path.includes('//') ||
         [...path].some(char => {
             const code = char.charCodeAt(0);
             return code <= 0x1f || code === 0x7f;
         }) ||
-        path.split('/').some(part => part === '.' || part === '..'));
+        path.split('/').some(part => part === '.' || part === '..')) {
+        return false;
+    }
+    if (path === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH) {
+        return true;
+    }
+    return (path.endsWith('.okpkg') && PROTOCOL_V2_RESOURCE_DEVICE_ROOTS.some(root => path.startsWith(root)));
 }
 function readAscii(bytes, offset, length) {
     return Array.from(bytes.slice(offset, offset + length))
@@ -40743,7 +40748,7 @@ function readResourceDevicePath(bytes) {
         throw new Error('Invalid Pro2 RESOURCE package device path metadata');
     }
     const path = readAscii(pathBytes, 0, pathBytes.byteLength);
-    if (!isSafeResourceDevicePath(path)) {
+    if (!isAllowedResourceDevicePath(path)) {
         throw new Error(`Invalid Pro2 RESOURCE package device path: ${path}`);
     }
     return path;
@@ -43718,8 +43723,7 @@ class DeviceCommands {
                     errorCode: error === null || error === void 0 ? void 0 : error.errorCode,
                     response: hdTransport.getSafeTransportLogPayload((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data, type),
                 });
-                if (error.errorCode === hdShared.HardwareErrorCode.BleDeviceBondError ||
-                    error.errorCode === hdShared.HardwareErrorCode.BlePeerRemovedPairingInformation) {
+                if (error.errorCode === hdShared.HardwareErrorCode.BleDeviceBondError) {
                     return {
                         type: 'BleDeviceBondError',
                         message: {
@@ -43778,9 +43782,6 @@ class DeviceCommands {
                         if (error.message.indexOf('BleDeviceBondError') > -1) {
                             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondError);
                         }
-                        if (error.message.indexOf('BlePeerRemovedPairingInformation') > -1) {
-                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePeerRemovedPairingInformation);
-                        }
                         if (error.message.indexOf('BridgeDeviceDisconnected') > -1) {
                             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeDeviceDisconnected);
                         }
@@ -44530,7 +44531,7 @@ const mapProtocolV2DeviceInfoToState = (info, mode = 'unknown') => {
             vendor: 'onekey.so',
             serialNo: (_b = info.hw) === null || _b === void 0 ? void 0 : _b.serial_no,
             bleName: ((_c = info.coprocessor) === null || _c === void 0 ? void 0 : _c.bt_adv_name)
-                ? hdShared.canonicalizePro2BleAdvertisementName(info.coprocessor.bt_adv_name)
+                ? hdShared.normalizePro2FindMyAdvertisementName(info.coprocessor.bt_adv_name)
                 : undefined,
             deviceId: loader ? null : undefined,
         }),
@@ -45411,8 +45412,7 @@ class Device extends events.exports {
     }
     getCurrentBleName() {
         var _a, _b;
-        const bleName = (_b = (_a = this.state) === null || _a === void 0 ? void 0 : _a.identity.bleName) !== null && _b !== void 0 ? _b : null;
-        return bleName ? hdShared.canonicalizePro2BleAdvertisementName(bleName) : null;
+        return (_b = (_a = this.state) === null || _a === void 0 ? void 0 : _a.identity.bleName) !== null && _b !== void 0 ? _b : null;
     }
     getCurrentLabel() {
         var _a, _b;
@@ -46923,7 +46923,7 @@ class SearchDevices extends BaseMethod {
                     if (!seenIds.has(lowerId)) {
                         seenIds.add(lowerId);
                         const rawBleName = (_e = (_d = device.name) !== null && _d !== void 0 ? _d : device.localName) !== null && _e !== void 0 ? _e : '';
-                        const bleName = hdShared.canonicalizePro2BleAdvertisementName(rawBleName);
+                        const bleName = hdShared.normalizePro2FindMyAdvertisementName(rawBleName);
                         devices.push(Object.assign(Object.assign({}, device), { connectId: device.id, serialNo: null, uuid: '', deviceId: null, name: bleName || device.name, deviceType: getDeviceTypeByBleName(bleName) }));
                     }
                 }
@@ -51407,7 +51407,6 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                         hdShared.HardwareErrorCode.BlePermissionError,
                         hdShared.HardwareErrorCode.BleLocationError,
                         hdShared.HardwareErrorCode.BleDeviceBondError,
-                        hdShared.HardwareErrorCode.BlePeerRemovedPairingInformation,
                         hdShared.HardwareErrorCode.BleCharacteristicNotifyError,
                         hdShared.HardwareErrorCode.BleTimeoutError,
                         hdShared.HardwareErrorCode.BleWriteCharacteristicError,
@@ -51708,6 +51707,86 @@ const INSTALLABLE_FIRMWARE_TARGET_IDS = new Set([
 ]);
 new Map(Object.entries(ProtocolV2FirmwareTargetType).flatMap(([key, value]) => INSTALLABLE_FIRMWARE_TARGET_IDS.has(value) ? [[key, value]] : []));
 
+let memoryHostSequence = 0;
+const createReference = (binary, prefix) => {
+    const digest = utils.bytesToHex(sha256.sha256(new Uint8Array(binary)));
+    return {
+        artifactRef: `fwmem:${prefix}:${digest.slice(0, 32)}`,
+        size: binary.byteLength,
+        sha256: digest,
+    };
+};
+function prepareFirmwareUpdateV4MemoryHost({ sdk, plan, artifacts, }) {
+    if (plan.executor !== 'v4') {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware memory host only supports V4 plans');
+    }
+    memoryHostSequence += 1;
+    const hostId = `${Date.now()}:${memoryHostSequence}`;
+    const binaries = new Map();
+    const inputs = artifacts.map((input, artifactIndex) => {
+        var _a;
+        const artifactBinary = new Uint8Array(input.binary).slice();
+        const artifact = createReference(artifactBinary.buffer, `${hostId}:artifact:${artifactIndex}`);
+        binaries.set(artifact.artifactRef, artifactBinary);
+        const materializedEntries = (_a = input.materializedEntries) === null || _a === void 0 ? void 0 : _a.map((entry, entryIndex) => {
+            const entryArtifact = createReference(entry.binary, `${hostId}:entry:${artifactIndex}:${entryIndex}`);
+            return {
+                entryName: entry.entryName,
+                artifact: entryArtifact,
+            };
+        });
+        return Object.assign({ artifactId: input.artifactId, artifact }, ((materializedEntries === null || materializedEntries === void 0 ? void 0 : materializedEntries.length) ? { materializedEntries } : {}));
+    });
+    const preparedPlan = sdk.prepareFirmwareUpdatePlan({
+        plan,
+        leaseRef: `fwmemlease:${hostId}`,
+        artifacts: inputs,
+    });
+    const readers = new Map();
+    let readerSequence = 0;
+    const artifactReader = {
+        open({ artifactRef }) {
+            const binary = binaries.get(artifactRef);
+            if (!binary) {
+                throw hdShared.ERRORS.TypedError(hdShared.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 hdShared.ERRORS.TypedError(hdShared.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,
+    });
+    return {
+        preparedPlan,
+        hostBindingGeneration,
+        release: () => {
+            sdk.unregisterFirmwareUpdateHostBinding(hostBindingGeneration);
+            readers.clear();
+            binaries.clear();
+        },
+    };
+}
+
 const Log$7 = getLogger(exports.LoggerNames.Method);
 const SESSION_ERROR$1 = 'session not found';
 const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
@@ -52176,7 +52255,16 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             if (!this.params.preparedPlan &&
                 this.params.resourceArchiveBinary &&
                 ((_c = this.params.targetsToUpdate) === null || _c === void 0 ? void 0 : _c.includes('resource'))) {
-                return this.runProtocolV2DirectArtifacts({});
+                const localMemoryHost = yield this.prepareProtocolV2LocalMemoryHost({
+                    features: deviceFeatures,
+                    firmwareType,
+                });
+                try {
+                    return yield this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
+                }
+                finally {
+                    localMemoryHost.release();
+                }
             }
             const hasPreparedComponentArtifacts = Object.values((_d = this.params.componentArtifacts) !== null && _d !== void 0 ? _d : {}).some(Boolean);
             if (this.params.preparedPlan || hasPreparedComponentArtifacts) {
@@ -52185,12 +52273,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             let fwBinaryMap = [];
             let bootloaderBinary = null;
             let installItems;
-            let explicitInstallItems;
+            let resourceMemoryHost;
             try {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.StartDownloadFirmware);
                 fwBinaryMap = this.collectExplicitTargetBinaries();
                 bootloaderBinary = this.prepareBootloaderBinary();
-                explicitInstallItems = this.buildProtocolV2InstallItems({
+                const explicitInstallItems = this.buildProtocolV2InstallItems({
                     bootloaderBinary,
                     fwBinaryMap,
                 });
@@ -52232,10 +52320,16 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 }
                 if (wantsResources) {
                     this.params.resourceArchiveBinary = yield this.downloadRemoteProtocolV2ResourceArchive(deviceFeatures, firmwareType);
+                    resourceMemoryHost = yield this.prepareProtocolV2LocalMemoryHost({
+                        features: deviceFeatures,
+                        firmwareType,
+                        availableInstallItems: installItems !== null && installItems !== void 0 ? installItems : explicitInstallItems,
+                    });
                 }
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.FinishDownloadFirmware);
             }
             catch (err) {
+                resourceMemoryHost === null || resourceMemoryHost === void 0 ? void 0 : resourceMemoryHost.release();
                 if (typeof err === 'object' &&
                     err !== null &&
                     'params' in err &&
@@ -52247,11 +52341,13 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 }
                 throw normalizeFirmwarePreparationError(err);
             }
-            if (wantsResources && this.params.resourceArchiveBinary) {
-                return this.runProtocolV2DirectArtifacts({
-                    availableInstallItems: installItems !== null && installItems !== void 0 ? installItems : explicitInstallItems,
-                    announceDownload: false,
-                });
+            if (resourceMemoryHost) {
+                try {
+                    return yield this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType, false);
+                }
+                finally {
+                    resourceMemoryHost.release();
+                }
             }
             if (!bootloaderBinary && fwBinaryMap.length === 0 && !(installItems === null || installItems === void 0 ? void 0 : installItems.length)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
@@ -52352,59 +52448,95 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return installSources;
         });
     }
-    runProtocolV2DirectArtifacts({ availableInstallItems, announceDownload = true, }) {
+    prepareProtocolV2LocalMemoryHost({ features, firmwareType, availableInstallItems = this.buildProtocolV2InstallItems({
+        bootloaderBinary: this.prepareBootloaderBinary(),
+        fwBinaryMap: this.collectExplicitTargetBinaries(),
+    }), }) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (announceDownload) {
-                    this.postTipMessage(exports.FirmwareUpdateTipMessage.StartDownloadFirmware);
-                }
-                const installItems = this.filterProtocolV2LocalInstallItems(availableInstallItems !== null && availableInstallItems !== void 0 ? availableInstallItems : this.buildProtocolV2InstallItems({
-                    bootloaderBinary: this.prepareBootloaderBinary(),
-                    fwBinaryMap: this.collectExplicitTargetBinaries(),
-                }));
-                const installSources = yield Promise.all(installItems.map((item) => __awaiter(this, void 0, void 0, function* () {
-                    return ({
-                        fileName: item.fileName,
-                        source: yield this.openProtocolV2MemorySource(item.binary),
-                        targetId: item.targetId,
-                        kind: item.kind,
-                    });
-                })));
-                const resourceSources = this.params.resourceArchiveBinary
-                    ? yield this.createProtocolV2ResourceSourcesFromArchive(this.params.resourceArchiveBinary)
-                    : [];
-                if (installSources.length === 0 && resourceSources.length === 0) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
-                }
-                if (announceDownload) {
-                    this.postTipMessage(exports.FirmwareUpdateTipMessage.FinishDownloadFirmware);
-                }
-                return yield this.executeProtocolV2SourceUpdate({
-                    installSources,
-                    resourceSources,
+            const requestedComponentTargets = new Set(((_a = this.params.targetsToUpdate) !== null && _a !== void 0 ? _a : []).filter((target) => 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 hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local update has no binary for requested target ${missingTarget}`, {
+                    firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+                    artifactName: missingTarget,
                 });
             }
-            finally {
-                yield this.closeProtocolV2PreparedSources();
+            const installItems = this.filterProtocolV2LocalInstallItems(availableInstallItems);
+            const planArtifacts = [];
+            const memoryArtifacts = [];
+            for (const item of installItems) {
+                const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
+                if (!target || item.binary.byteLength <= 0) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local firmware artifact is invalid: ${item.fileName}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
+                }
+                const artifactId = `component:${target}`;
+                planArtifacts.push(Object.assign({ artifactId,
+                    target, container: 'raw', logicalName: item.fileName, expectedSize: item.binary.byteLength, expectedSha256: bytesToHex(sha256.sha256(new Uint8Array(item.binary))) }, (((_b = this.params.expectedTargetVersions) === null || _b === void 0 ? void 0 : _b[target])
+                    ? { targetVersion: this.params.expectedTargetVersions[target] }
+                    : {})));
+                memoryArtifacts.push({ artifactId, binary: item.binary });
             }
-        });
-    }
-    createProtocolV2ResourceSourcesFromArchive(binary) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const archive = yield this.prepareProtocolV2LocalResourceArchive(binary);
-            const sources = [];
-            for (const resource of archive.resources) {
-                sources.push({
-                    name: (_a = resource.entryName.split('/').pop()) !== null && _a !== void 0 ? _a : resource.entryName,
-                    source: yield this.openProtocolV2MemorySource(resource.binary),
-                    devicePath: resource.header.devicePath,
-                    version: resource.header.version,
-                    payloadHash: resource.header.payloadHash,
-                    headerHash: resource.header.headerHash,
+            const resourceArchive = yield this.prepareProtocolV2LocalResourceArchive(this.params.resourceArchiveBinary);
+            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.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;
+            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),
                 });
+                const hostBinding = resolveFirmwareUpdateHostBinding(memoryHost.hostBindingGeneration, preparedPlan.preparedPlanDigest);
+                this.params.preparedPlan = preparedPlan;
+                this.params.targetsToUpdate = [...preparedPlan.targetsToUpdate];
+                this.params.artifactReader = hostBinding.artifactReader;
+                this.params.componentArtifacts = undefined;
+                return memoryHost;
+            }
+            catch (error) {
+                memoryHost === null || memoryHost === void 0 ? void 0 : memoryHost.release();
+                throw error;
             }
-            return sources;
         });
     }
     prepareProtocolV2LocalResourceArchive(binary) {
@@ -52420,12 +52552,13 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 resource ZIP cannot be parsed', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
             }
             const zipEntries = Object.values(zip.files);
-            const resourceEntries = zipEntries.filter(entry => !entry.dir && isProtocolV2ResourceArchiveEntryName(entry.name));
+            const resourceEntries = zipEntries.filter(entry => !entry.dir && entry.name.toLowerCase().endsWith('.okpkg'));
             if (resourceEntries.length === 0 ||
                 resourceEntries.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 resource ZIP has no valid resource package set', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
             }
             let totalSize = 0;
+            const materializedEntries = [];
             const resources = [];
             const devicePaths = new Set();
             for (const entry of resourceEntries) {
@@ -52452,9 +52585,10 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 resource ZIP contains duplicate device path: ${header.devicePath}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
                 }
                 devicePaths.add(canonicalDevicePath);
+                materializedEntries.push({ entryName: entry.name, binary: fileBinary });
                 resources.push({ entryName: entry.name, binary: fileBinary, header });
             }
-            return { binary, resources };
+            return { binary, materializedEntries, resources };
         });
     }
     prepareProtocolV2ResourceSources() {
@@ -52472,7 +52606,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     prepareProtocolV2ResourceArchiveSources() {
-        var _a, _b;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const archiveArtifacts = (_b = (_a = this.params.preparedPlan) === null || _a === void 0 ? void 0 : _a.artifacts.filter(artifact => artifact.role === 'resourceBundle' &&
                 artifact.target === 'resource' &&
@@ -52499,7 +52633,20 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             if (archiveDigest !== archiveArtifact.artifact.sha256.toLowerCase()) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared resource archive does not match its approved receipt', { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' });
             }
-            return this.createProtocolV2ResourceSourcesFromArchive(archiveBinary);
+            const verifiedArchive = yield this.prepareProtocolV2LocalResourceArchive(archiveBinary);
+            const sources = [];
+            for (const resource of verifiedArchive.resources) {
+                const source = yield this.openProtocolV2MemorySource(resource.binary);
+                sources.push({
+                    name: (_c = resource.entryName.split('/').pop()) !== null && _c !== void 0 ? _c : resource.entryName,
+                    source,
+                    devicePath: resource.header.devicePath,
+                    version: resource.header.version,
+                    payloadHash: resource.header.payloadHash,
+                    headerHash: resource.header.headerHash,
+                });
+            }
+            return sources;
         });
     }
     runProtocolV2PreparedArtifacts(features, firmwareType, announceDownload = true) {
@@ -52867,11 +53014,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return `vol0:${path}`;
         return `vol0:/${path}`;
     }
-    getProtocolV2ResourceComparePath(devicePath) {
-        return isProtocolV2BootResourcePackagePath(devicePath)
-            ? PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH
-            : devicePath;
-    }
     readProtocolV2DeviceFileHeader(path, expectedSize) {
         var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
@@ -52930,7 +53072,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             if (!bundle.payloadHash || !bundle.headerHash)
                 return false;
             try {
-                const header = yield this.readProtocolV2DeviceFileHeader(this.getProtocolV2ResourceComparePath(bundle.devicePath), bundle.source.size);
+                const header = yield this.readProtocolV2DeviceFileHeader(bundle.devicePath, bundle.source.size);
                 if (!header)
                     return false;
                 if (bundle.version) {
@@ -53131,7 +53273,8 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             let totalSize = installSources.reduce((total, item) => total + item.source.size, 0);
             const resourcesToSync = [];
             for (const resource of resourceSources) {
-                if (yield this.isProtocolV2ResourceBundleUpToDate(resource)) {
+                const requiresFreshStaging = isProtocolV2BootResourcePackagePath(resource.devicePath);
+                if (!requiresFreshStaging && (yield this.isProtocolV2ResourceBundleUpToDate(resource))) {
                     Log$7.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
                 }
                 else {
@@ -65073,6 +65216,7 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
     if ((_g = method.payload) === null || _g === void 0 ? void 0 : _g.onlyConnectBleDevice) {
         preWarmCallbackTask === null || preWarmCallbackTask === void 0 ? void 0 : preWarmCallbackTask.resolve();
         Log.debug('Call API - only connect ble device: ', device === null || device === void 0 ? void 0 : device.mainId);
+        requestQueue.releaseTask(method.responseID);
         return createResponseMessage(method.responseID, true, null);
     }
     Log.debug('Call API - setDevice: ', device.mainId);
@@ -65448,7 +65592,31 @@ function isMissingDetectedProtocolV2Error(method, error) {
         typeof typedError.message === 'string' &&
         typedError.message.includes('Device protocol has not been detected'));
 }
-function connectDeviceForBle(method, device, retryCount = 0) {
+const BLE_ACQUIRE_DEADLINE_MS = 60 * 1000;
+function raceBleAcquire(acquirePromise, abortSignal) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(deadline);
+            abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener('abort', onAbort);
+            fn();
+        };
+        const onAbort = () => settle(() => reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled)));
+        const deadline = setTimeout(() => settle(() => reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`))), BLE_ACQUIRE_DEADLINE_MS);
+        acquirePromise.then(value => settle(() => resolve(value)), error => settle(() => reject(error)));
+        if (abortSignal) {
+            if (abortSignal.aborted) {
+                onAbort();
+                return;
+            }
+            abortSignal.addEventListener('abort', onAbort);
+        }
+    });
+}
+function connectDeviceForBle(method, device, abortSignal, retryCount = 0) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
         try {
@@ -65463,9 +65631,31 @@ function connectDeviceForBle(method, device, retryCount = 0) {
                 !device.commands ||
                 device.commands.disposed;
             if (shouldAcquire) {
-                yield device.acquire(method.payload.connectProtocol, {
-                    forceProtocolDetection: method.payload.forceProtocolDetection,
-                });
+                const useAcquireGuards = DataManager.getSettings('env') === 'desktop-web-ble';
+                if (useAcquireGuards && (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled);
+                }
+                if (!useAcquireGuards) {
+                    yield device.acquire(method.payload.connectProtocol, {
+                        forceProtocolDetection: method.payload.forceProtocolDetection,
+                    });
+                }
+                else {
+                    try {
+                        yield raceBleAcquire(device.acquire(method.payload.connectProtocol, {
+                            forceProtocolDetection: method.payload.forceProtocolDetection,
+                        }), abortSignal);
+                    }
+                    catch (err) {
+                        if (err.errorCode === hdShared.HardwareErrorCode.BleTimeoutError &&
+                            device.mainId &&
+                            device.deviceConnector) {
+                            yield device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
+                            device.markTransportDisconnected();
+                        }
+                        throw err;
+                    }
+                }
             }
             if ((_a = method.payload) === null || _a === void 0 ? void 0 : _a.onlyConnectBleDevice) {
                 if (shouldAcquire) {
@@ -65496,7 +65686,7 @@ function connectDeviceForBle(method, device, retryCount = 0) {
                 const nextRetry = retryCount + 1;
                 Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
                 yield wait(3000);
-                yield connectDeviceForBle(method, device, nextRetry);
+                yield connectDeviceForBle(method, device, abortSignal, nextRetry);
             }
             else {
                 throw err;
@@ -65581,7 +65771,7 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                         if (tryCount === 1) {
                             device.beginConnectionAttempt();
                         }
-                        yield connectDeviceForBle(method, device);
+                        yield connectDeviceForBle(method, device, abortSignal);
                     }
                     resolve(device);
                     return;
@@ -65611,7 +65801,6 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                     hdShared.HardwareErrorCode.BleLocationServicesDisabled,
                     hdShared.HardwareErrorCode.BleDeviceNotBonded,
                     hdShared.HardwareErrorCode.BleDeviceBondError,
-                    hdShared.HardwareErrorCode.BlePeerRemovedPairingInformation,
                     hdShared.HardwareErrorCode.BleDeviceBondedCanceled,
                     hdShared.HardwareErrorCode.BleCharacteristicNotifyError,
                     hdShared.HardwareErrorCode.BleTimeoutError,
@@ -66198,6 +66387,7 @@ exports.parseConnectSettings = parseConnectSettings;
 exports.parseMessage = parseMessage;
 exports.patchFeatures = patchFeatures;
 exports.preloadSessionCache = preloadSessionCache;
+exports.prepareFirmwareUpdateV4MemoryHost = prepareFirmwareUpdateV4MemoryHost;
 exports.projectDeviceStateFeatures = projectFeatures;
 exports.registerFirmwareUpdateHostBinding = registerFirmwareUpdateHostBinding;
 exports.safeThrowError = safeThrowError;