@onekeyfe/hd-core 1.2.0-alpha.147 → 1.2.0-alpha.148

package/dist/index.js

@@ -466,10 +466,13 @@ const getDeviceTypeByBleName = (name) => {
         return hdShared.EDeviceType.Touch;
     if (/^Touch/i.test(name))
         return hdShared.EDeviceType.Touch;
-    if (/\bPro\s*2\b/i.test(name) || /^Pro2/i.test(name))
+    const compactName = name.replace(/[\s-]/g, '');
+    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))
+    }
+    if (/\bNeo\b/i.test(name) || /^Neo/i.test(name) || /^(?:OneKey)?Neo/i.test(compactName)) {
         return hdShared.EDeviceType.Neo;
+    }
     if (/\bPro\b/i.test(name) || /^Pro/i.test(name))
         return hdShared.EDeviceType.Pro;
     return hdShared.EDeviceType.Unknown;
@@ -40675,18 +40678,16 @@ const findLatestRelease = (releases) => {
     return leastRelease;
 };
 
-const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH$1 = 'vol0:/loaders/bootloader/boot_resource.okpkg';
-const SHA256_HEX_LENGTH = 64;
-function normalizeHex$1(value, expectedLength, field) {
-    if (typeof value !== 'string') {
-        throw new Error(`Invalid Pro2 resource ${field}: expected a hexadecimal string`);
-    }
-    const normalized = value.replace(/^0x/i, '').toLowerCase();
-    if (normalized.length !== expectedLength || !/^[0-9a-f]+$/.test(normalized)) {
-        throw new Error(`Invalid Pro2 resource ${field}: expected ${expectedLength} hexadecimal characters`);
-    }
-    return normalized;
-}
+const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH = 'vol0:/loaders/bootloader/boot_resource.okpkg';
+const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH = `${PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH}.staging`;
+const PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE = 0x5f90;
+const PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_VERSION = 1;
+const PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_OFFSET = 0x6c;
+const PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_SIZE = 64;
+const PROTOCOL_V2_RESOURCE_PACKAGE_PAYLOAD_HASH_OFFSET = 0x200;
+const PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_HASH_OFFSET = 0x240;
+const PROTOCOL_V2_RESOURCE_PACKAGE_HASH_SIZE = 64;
+const PROTOCOL_V2_RESOURCE_PACKAGE_TYPE = 'RESC';
 function parseProtocolV2Resources(value) {
     if (value === undefined)
         return undefined;
@@ -40715,86 +40716,75 @@ function parseProtocolV2Resources(value) {
         },
     };
 }
-const PROTOCOL_V2_RESOURCE_MANIFEST_DEVICE_ROOTS = [
-    'vol0:/bundles/',
-    'vol0:/loaders/rom/',
-];
-function isAllowedManifestDevicePath(path) {
-    if (!path.endsWith('.okpkg') ||
-        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 === '..')) {
         return false;
     }
-    if (path === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH$1) {
+    if (path === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH) {
         return true;
     }
-    return PROTOCOL_V2_RESOURCE_MANIFEST_DEVICE_ROOTS.some(root => path.startsWith(root));
+    return (path.endsWith('.okpkg') && PROTOCOL_V2_RESOURCE_DEVICE_ROOTS.some(root => path.startsWith(root)));
 }
-function assertManifestString(value, field) {
-    if (typeof value !== 'string' || value.length === 0) {
-        throw new Error(`Invalid Pro2 resource manifest ${field}`);
-    }
-    return value;
+function readAscii(bytes, offset, length) {
+    return Array.from(bytes.slice(offset, offset + length))
+        .map(byte => String.fromCharCode(byte))
+        .join('');
 }
-function assertManifestRelativePath(value, field) {
-    const path = assertManifestString(value, field);
-    if (path.startsWith('/') ||
-        path.includes('\\') ||
-        path.includes(':') ||
-        path.split('/').some(part => !part || part === '.' || part === '..')) {
-        throw new Error(`Invalid Pro2 resource manifest ${field}`);
+function readResourceDevicePath(bytes) {
+    const metadata = bytes.slice(PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_OFFSET, PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_OFFSET + PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_SIZE);
+    const terminator = metadata.indexOf(0);
+    const pathBytes = terminator === -1 ? metadata : metadata.slice(0, terminator);
+    const padding = terminator === -1 ? new Uint8Array(0) : metadata.slice(terminator);
+    if (pathBytes.byteLength === 0 ||
+        Array.from(pathBytes).some(byte => byte < 0x20 || byte > 0x7e) ||
+        Array.from(padding).some(byte => byte !== 0)) {
+        throw new Error('Invalid Pro2 RESOURCE package device path metadata');
+    }
+    const path = readAscii(pathBytes, 0, pathBytes.byteLength);
+    if (!isAllowedResourceDevicePath(path)) {
+        throw new Error(`Invalid Pro2 RESOURCE package device path: ${path}`);
     }
     return path;
 }
-function parseProtocolV2ResourceManifestFile(value, index) {
-    var _a;
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}]`);
-    }
-    const file = value;
-    const archivePath = assertManifestRelativePath(file.archive_path, `files[${index}].archive_path`);
-    const originalName = file.original_name === undefined
-        ? (_a = archivePath.split('/').pop()) !== null && _a !== void 0 ? _a : archivePath
-        : assertManifestRelativePath(file.original_name, `files[${index}].original_name`);
-    if (originalName.includes('/')) {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}].original_name`);
-    }
-    const devicePath = assertManifestString(file.device_path, `files[${index}].device_path`);
-    if (!isAllowedManifestDevicePath(devicePath)) {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}].device_path`);
-    }
-    if (!Number.isSafeInteger(file.size) || Number(file.size) <= 0) {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}].size`);
-    }
-    const digest = normalizeHex$1(file.sha256, SHA256_HEX_LENGTH, `files[${index}].sha256`);
-    if (!archivePath.endsWith('.okpkg') || !originalName.endsWith('.okpkg')) {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}] package extension`);
-    }
-    return Object.assign(Object.assign(Object.assign({ archive_path: archivePath, original_name: originalName, device_path: devicePath, size: Number(file.size), sha256: digest }, (file.signed === undefined ? {} : { signed: file.signed })), (file.sig_algo === undefined ? {} : { sig_algo: file.sig_algo })), (file.payload_version === undefined ? {} : { payload_version: file.payload_version }));
-}
-function parseProtocolV2ResourceManifest(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('Invalid Pro2 resource manifest');
-    }
-    const manifest = value;
-    if (!Array.isArray(manifest.files)) {
-        throw new Error('Invalid Pro2 resource manifest files');
+function parseProtocolV2ResourcePackageHeader(bytes, packageSize) {
+    if (bytes.byteLength < PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE) {
+        throw new Error('Pro2 RESOURCE package is shorter than its header');
     }
-    const files = manifest.files.map(parseProtocolV2ResourceManifestFile);
-    const devicePaths = new Set(files.map(file => file.device_path));
-    const archivePaths = new Set(files.map(file => file.archive_path));
-    if (files.length === 0 ||
-        devicePaths.size !== files.length ||
-        archivePaths.size !== files.length) {
-        throw new Error('Invalid Pro2 resource manifest file set');
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const headerVersion = view.getUint32(0x04, true);
+    const headerLength = view.getUint32(0x0c, true);
+    const payloadLength = view.getUint32(0x14, true);
+    if (readAscii(bytes, 0, 4) !== 'OKPP' ||
+        readAscii(bytes, 0x08, 4) !== PROTOCOL_V2_RESOURCE_PACKAGE_TYPE ||
+        headerVersion !== PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_VERSION ||
+        headerLength !== PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE ||
+        payloadLength <= 0 ||
+        headerLength + payloadLength !== packageSize) {
+        throw new Error('Invalid Pro2 RESOURCE package header');
     }
+    const packedVersion = view.getUint32(0x10, true);
     return {
-        files,
+        version: [
+            Math.floor(packedVersion / 0x10000) % 0x100,
+            Math.floor(packedVersion / 0x100) % 0x100,
+            packedVersion % 0x100,
+        ],
+        payloadLength,
+        devicePath: readResourceDevicePath(bytes),
+        payloadHash: utils.bytesToHex(bytes.slice(PROTOCOL_V2_RESOURCE_PACKAGE_PAYLOAD_HASH_OFFSET, PROTOCOL_V2_RESOURCE_PACKAGE_PAYLOAD_HASH_OFFSET + PROTOCOL_V2_RESOURCE_PACKAGE_HASH_SIZE)),
+        headerHash: utils.bytesToHex(bytes.slice(PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_HASH_OFFSET, PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_HASH_OFFSET + PROTOCOL_V2_RESOURCE_PACKAGE_HASH_SIZE)),
     };
 }
-function selectProtocolV2ResourceManifestFiles({ manifest, targetsToUpdate, }) {
-    return targetsToUpdate.includes('resource') ? [...manifest.files] : [];
+function parseProtocolV2ResourcePackage(binary) {
+    const bytes = binary instanceof Uint8Array ? binary : new Uint8Array(binary);
+    return parseProtocolV2ResourcePackageHeader(bytes, bytes.byteLength);
 }
 
 var _a$1;
@@ -45140,6 +45130,7 @@ class Device extends events.exports {
         super();
         this.deviceConnector = null;
         this.deviceAcquired = false;
+        this.interruptedByUser = false;
         this.stateStore = new DeviceStateStore();
         this.protocolV2StateNeedsReload = false;
         this.protocolV2UiInteractionCounter = 0;
@@ -45232,8 +45223,9 @@ class Device extends events.exports {
         }));
     }
     acquire(expectedProtocol, options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         return __awaiter(this, void 0, void 0, function* () {
+            this.throwIfInterruptedByUser();
             const env = DataManager.getSettings('env');
             const mainIdKey = DataManager.isBleConnect(env) ? 'id' : 'session';
             const previousProtocol = this.originalDescriptor.protocolType;
@@ -45259,12 +45251,21 @@ class Device extends events.exports {
                 if (detectedProtocol) {
                     this.originalDescriptor.protocolType = detectedProtocol;
                 }
+                if (this.interruptedByUser) {
+                    const session = this.mainId;
+                    if (session && ((_g = this.deviceConnector) === null || _g === void 0 ? void 0 : _g.disconnect)) {
+                        yield this.deviceConnector.disconnect(session).catch(disconnectError => {
+                            Log$h.debug('Ignored disconnect after user cancel during acquire', disconnectError);
+                        });
+                    }
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromUser);
+                }
                 this.deviceAcquired = true;
                 this.updateDescriptor({ [mainIdKey]: this.mainId });
                 if (this.commands) {
                     yield this.commands.dispose(false);
                 }
-                this.commands = new DeviceCommands(this, (_g = this.mainId) !== null && _g !== void 0 ? _g : '');
+                this.commands = new DeviceCommands(this, (_h = this.mainId) !== null && _h !== void 0 ? _h : '');
                 this.invalidateProtocolV2RuntimeState();
             }
             catch (error) {
@@ -45274,7 +45275,7 @@ class Device extends events.exports {
                     this.deviceAcquired = false;
                     if (failedSession) {
                         try {
-                            yield ((_j = (_h = this.deviceConnector) === null || _h === void 0 ? void 0 : _h.release) === null || _j === void 0 ? void 0 : _j.call(_h, failedSession, false));
+                            yield ((_k = (_j = this.deviceConnector) === null || _j === void 0 ? void 0 : _j.release) === null || _k === void 0 ? void 0 : _k.call(_j, failedSession, false));
                         }
                         catch (releaseError) {
                             Log$h.debug('Failed to release an unsuccessful protocol probe', releaseError);
@@ -45596,6 +45597,7 @@ class Device extends events.exports {
     }
     initialize(options) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.throwIfInterruptedByUser();
             if (this.isProtocolV2()) {
                 this.passphraseState = options === null || options === void 0 ? void 0 : options.passphraseState;
                 if (this.state && !(options === null || options === void 0 ? void 0 : options.initSession) && !this.protocolV2StateNeedsReload) {
@@ -46017,6 +46019,7 @@ class Device extends events.exports {
                 yield this.interruptionFromOutside();
                 Log$h.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
             }
+            this.interruptedByUser = false;
             options = parseRunOptions(options);
             const runPromise = hdShared.createDeferred();
             this.runPromise = runPromise;
@@ -46127,25 +46130,29 @@ class Device extends events.exports {
         });
     }
     interruptionFromUser() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromUser);
+            this.interruptedByUser = true;
             const cleanupPromise = this.runCleanupPromise;
             const { cancelableAction } = this;
-            const env = DataManager.getSettings('env');
             if (cancelableAction) {
                 yield cancelableAction(error);
             }
-            else if (this.isProtocolV2() &&
-                (DataManager.isBleConnect(env) ||
-                    DataManager.isBrowserWebUsb(env) ||
-                    DataManager.isDesktopWebUsb(env)) &&
-                this.hasDeviceAcquire()) {
+            else if (this.shouldSendFallbackProtocolCancel()) {
                 yield ((_b = (_a = this.commands) === null || _a === void 0 ? void 0 : _a.cancelDevice) === null || _b === void 0 ? void 0 : _b.call(_a).catch(cancelError => {
                     Log$h.debug('Protocol V2 fallback cancel error', cancelError);
                 }));
             }
-            yield ((_c = this.commands) === null || _c === void 0 ? void 0 : _c.cancel());
+            else if (!this.hasDeviceAcquire()) {
+                if (this.mainId && ((_c = this.deviceConnector) === null || _c === void 0 ? void 0 : _c.disconnect)) {
+                    yield this.deviceConnector.disconnect(this.mainId).catch(disconnectError => {
+                        Log$h.debug('Ignored disconnect during user cancel without acquire', disconnectError);
+                    });
+                }
+                this.markTransportDisconnected();
+            }
+            yield ((_d = this.commands) === null || _d === void 0 ? void 0 : _d.cancel());
             if (this.runPromise) {
                 this.runPromise.reject(error);
                 this.runPromise = null;
@@ -46200,6 +46207,26 @@ class Device extends events.exports {
     isUsed() {
         return typeof this.originalDescriptor.session === 'string';
     }
+    wasInterruptedByUser() {
+        return this.interruptedByUser;
+    }
+    throwIfInterruptedByUser() {
+        if (this.interruptedByUser) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromUser);
+        }
+    }
+    shouldSendFallbackProtocolCancel() {
+        if (!this.hasDeviceAcquire() || !this.isProtocolV2()) {
+            return false;
+        }
+        if (!this.hasOpenProtocolV2UiInteraction()) {
+            return false;
+        }
+        const env = DataManager.getSettings('env');
+        return (DataManager.isBleConnect(env) ||
+            DataManager.isBrowserWebUsb(env) ||
+            DataManager.isDesktopWebUsb(env));
+    }
     hasDeviceAcquire() {
         const env = DataManager.getSettings('env');
         if (DataManager.isBleConnect(env)) {
@@ -48253,6 +48280,8 @@ class DeviceRebootToBootloader extends BaseMethod {
     init() {
         this.useDevicePassphraseState = false;
         this.skipForceUpdateCheck = true;
+        this.unlockPolicy = 'unlock-before-run';
+        this.protocolV2PreUnlockPinType = hdTransport.DeviceSessionPinType.Any;
     }
     getVersionRange() {
         return {
@@ -48286,6 +48315,8 @@ class DeviceRebootToBoardloader extends BaseMethod {
     init() {
         this.useDevicePassphraseState = false;
         this.skipForceUpdateCheck = true;
+        this.unlockPolicy = 'unlock-before-run';
+        this.protocolV2PreUnlockPinType = hdTransport.DeviceSessionPinType.Any;
     }
     getVersionRange() {
         return {
@@ -51771,17 +51802,8 @@ const PROTOCOL_V2_TRANSFER_PROGRESS_HEARTBEAT_MS = 1000;
 const PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE = 'FirmwareInstallStatusConflict';
 const PROTOCOL_V2_INSTALL_FAILED_CODE = 'FirmwareInstallFailed';
 const PROTOCOL_V2_INSTALL_TIMEOUT_CODE = 'FirmwareInstallTimeout';
-const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
-const PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET = 0x200;
-const PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET = 0x240;
-const PROTOCOL_V2_OKPP_HASH_SIZE = 64;
-const PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES = 1024 * 1024;
 const PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT = 512;
 const PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES = 256 * 1024 * 1024;
-const getProtocolV2LocalResourceArchivePath = (entryName) => {
-    const match = entryName.match(/(?:^|\/)((?:bundles\/|loaders\/(?:bootloader|rom)\/).+\.okpkg)$/iu);
-    return match === null || match === void 0 ? void 0 : match[1];
-};
 const PROTOCOL_V2_NEO_UNSUPPORTED_TARGETS = new Set(['se03', 'se04']);
 const getProtocolV2ZipEntrySizes = (entry) => {
     var _a;
@@ -51875,14 +51897,8 @@ const PROTOCOL_V2_REMOTE_COMPONENT_TARGETS = {
     },
 };
 const PROTOCOL_V2_FIRMWARE_STAGING_PATHS = new Set(Object.values(PROTOCOL_V2_REMOTE_COMPONENT_TARGETS).map(target => `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}${target.fileName}`));
-const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH = 'vol0:/loaders/bootloader/boot_resource.okpkg';
-const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH = `${PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH}.staging`;
 const isProtocolV2BootResourcePackagePath = (devicePath) => typeof devicePath === 'string' &&
-    devicePath.replace(/^vol0:(?!\/)/i, 'vol0:/').toLowerCase() ===
-        PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH;
-const resolveProtocolV2ResourceWritePath = (devicePath) => isProtocolV2BootResourcePackagePath(devicePath)
-    ? PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH
-    : devicePath;
+    devicePath.toLowerCase() === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH;
 const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map([
     [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER, 'boot'],
     [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1, 'app_v1'],
@@ -52008,30 +52024,6 @@ const toProtocolV2FiniteNumber = (value) => {
     }
     return undefined;
 };
-const readProtocolV2Ascii = (bytes, offset, length) => Array.from(bytes.slice(offset, offset + length))
-    .map(byte => String.fromCharCode(byte))
-    .join('');
-const parseProtocolV2OkppHeader = (bytes) => {
-    if (bytes.byteLength < PROTOCOL_V2_OKPP_HEADER_SIZE)
-        return null;
-    if (readProtocolV2Ascii(bytes, 0, 4) !== 'OKPP')
-        return null;
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const headerLen = view.getUint32(0x0c, true);
-    if (headerLen !== PROTOCOL_V2_OKPP_HEADER_SIZE)
-        return null;
-    const packedVersion = view.getUint32(0x10, true);
-    return {
-        type: readProtocolV2Ascii(bytes, 0x08, 4),
-        version: [
-            Math.floor(packedVersion / 0x10000) % 0x100,
-            Math.floor(packedVersion / 0x100) % 0x100,
-            packedVersion % 0x100,
-        ],
-        payloadHash: bytesToHex(bytes.slice(PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET, PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET + PROTOCOL_V2_OKPP_HASH_SIZE)),
-        headerHash: bytesToHex(bytes.slice(PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET, PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET + PROTOCOL_V2_OKPP_HASH_SIZE)),
-    };
-};
 const isProtocolV2FirmwareFingerprintValid = (binary, fingerprint) => {
     const expectedFingerprint = normalizeProtocolV2Hex(fingerprint);
     if (!expectedFingerprint)
@@ -52539,7 +52531,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     prepareProtocolV2LocalResourceArchive(binary) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (binary.byteLength <= 0 || binary.byteLength > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource ZIP archive size is invalid', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
@@ -52548,91 +52539,47 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             try {
                 zip = yield JSZip__default["default"].loadAsync(binary);
             }
-            catch (_b) {
+            catch (_a) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 resource ZIP cannot be parsed', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
             }
             const zipEntries = Object.values(zip.files);
-            if (zipEntries.some(entry => entry.unsafeOriginalName && entry.unsafeOriginalName !== entry.name)) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource ZIP contains an unsafe entry path', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            const entries = zipEntries.filter(entry => !entry.dir);
-            if (entries.length === 0) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource ZIP entry set is invalid', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            const manifestEntry = entries.find(entry => entry.name.split('/').pop() === 'manifest.json');
-            let manifestBinary;
-            let manifestDirectory = '';
-            let selectedFiles;
-            if (manifestEntry) {
-                if (getProtocolV2ZipEntrySizes(manifestEntry).uncompressedSize >
-                    PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource manifest size is invalid', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-                }
-                manifestBinary = yield manifestEntry.async('arraybuffer');
-                if (manifestBinary.byteLength <= 0 ||
-                    manifestBinary.byteLength > PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource manifest size is invalid', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-                }
-                let manifestValue;
-                try {
-                    manifestValue = JSON.parse(new TextDecoder().decode(manifestBinary));
-                }
-                catch (error) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local resource manifest is invalid: ${String(error)}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-                }
-                selectedFiles = selectProtocolV2ResourceManifestFiles({
-                    manifest: parseProtocolV2ResourceManifest(manifestValue),
-                    targetsToUpdate: (_a = this.params.targetsToUpdate) !== null && _a !== void 0 ? _a : [],
-                });
-                manifestDirectory = manifestEntry.name.slice(0, -'manifest.json'.length);
-            }
-            else {
-                selectedFiles = entries.flatMap(entry => {
-                    var _a;
-                    const archivePath = getProtocolV2LocalResourceArchivePath(entry.name);
-                    if (!archivePath)
-                        return [];
-                    return [
-                        {
-                            archive_path: archivePath,
-                            original_name: (_a = archivePath.split('/').pop()) !== null && _a !== void 0 ? _a : archivePath,
-                            device_path: `vol0:/${archivePath}`,
-                            size: getProtocolV2ZipEntrySizes(entry).uncompressedSize,
-                            sha256: '',
-                        },
-                    ];
-                });
-            }
-            if (selectedFiles.length === 0 || selectedFiles.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource ZIP has no resource packages', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
+            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 normalizedFiles = [];
-            for (const file of selectedFiles) {
-                const entry = manifestEntry
-                    ? zip.file(`${manifestDirectory}${file.archive_path}`)
-                    : entries.find(candidate => getProtocolV2LocalResourceArchivePath(candidate.name) === file.archive_path);
-                if (!entry) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local resource ZIP is missing ${file.archive_path}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-                }
-                const { uncompressedSize } = getProtocolV2ZipEntrySizes(entry);
+            const resources = [];
+            const devicePaths = new Set();
+            for (const entry of resourceEntries) {
+                const { compressedSize, uncompressedSize } = getProtocolV2ZipEntrySizes(entry);
                 totalSize += uncompressedSize;
-                if (uncompressedSize !== file.size || totalSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local resource file declared size is invalid: ${file.archive_path}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
+                if (compressedSize > binary.byteLength ||
+                    uncompressedSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES ||
+                    totalSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 resource package size is invalid: ${entry.name}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
                 }
                 const fileBinary = yield entry.async('arraybuffer');
-                const digest = bytesToHex(sha256.sha256(new Uint8Array(fileBinary)));
-                if (fileBinary.byteLength !== file.size ||
-                    (file.sha256 && digest !== file.sha256.toLowerCase())) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local resource file does not match manifest: ${file.archive_path}`, { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' });
+                if (fileBinary.byteLength !== uncompressedSize) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 resource package is incomplete: ${entry.name}`, { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' });
+                }
+                let header;
+                try {
+                    header = parseProtocolV2ResourcePackage(fileBinary);
+                }
+                catch (error) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 resource package is invalid: ${entry.name}: ${String(error)}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
                 }
-                normalizedFiles.push(Object.assign(Object.assign({}, file), { sha256: digest }));
-                materializedEntries.push({ entryName: file.archive_path, binary: fileBinary });
+                const canonicalDevicePath = header.devicePath.toLowerCase();
+                if (devicePaths.has(canonicalDevicePath)) {
+                    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 });
             }
-            manifestBinary !== null && manifestBinary !== void 0 ? manifestBinary : (manifestBinary = new TextEncoder().encode(JSON.stringify({ files: normalizedFiles })).buffer);
-            materializedEntries.unshift({ entryName: 'manifest.json', binary: manifestBinary });
-            return { binary, materializedEntries };
+            return { binary, materializedEntries, resources };
         });
     }
     prepareProtocolV2ResourceSources() {
@@ -52678,48 +52625,17 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared resource archive does not match its approved receipt', { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' });
             }
             const verifiedArchive = yield this.prepareProtocolV2LocalResourceArchive(archiveBinary);
-            const verifiedEntriesByName = new Map(verifiedArchive.materializedEntries.map(entry => [entry.entryName, entry.binary]));
-            const manifestBinary = verifiedEntriesByName.get('manifest.json');
-            if (!manifestBinary) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared resource archive has no valid manifest.json', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            let manifestValue;
-            try {
-                manifestValue = JSON.parse(new TextDecoder().decode(manifestBinary));
-            }
-            catch (error) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 prepared resource manifest is invalid: ${String(error)}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            const manifest = parseProtocolV2ResourceManifest(manifestValue);
-            const selectedFiles = selectProtocolV2ResourceManifestFiles({
-                manifest,
-                targetsToUpdate: (_c = this.params.targetsToUpdate) !== null && _c !== void 0 ? _c : [],
-            });
-            if (selectedFiles.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared resource archive contains too many files', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            let totalSize = 0;
             const sources = [];
-            for (const [index, file] of selectedFiles.entries()) {
-                const binary = verifiedEntriesByName.get(file.archive_path);
-                if (!binary || binary.byteLength !== file.size) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 prepared resource file does not match manifest: ${file.archive_path}`, { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' });
-                }
-                totalSize += binary.byteLength;
-                if (totalSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared resource archive exceeds the total size limit', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-                }
-                const source = yield this.openProtocolV2MemorySource(binary);
-                const header = source.size >= PROTOCOL_V2_OKPP_HEADER_SIZE
-                    ? parseProtocolV2OkppHeader(new Uint8Array(yield source.readAt(0, PROTOCOL_V2_OKPP_HEADER_SIZE)))
-                    : null;
-                sources.push(Object.assign({ name: file.original_name || `resource-${index}`, source, devicePath: file.device_path }, (header
-                    ? {
-                        version: header.version,
-                        payloadHash: header.payloadHash,
-                        headerHash: header.headerHash,
-                    }
-                    : {})));
+            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;
         });
@@ -53101,15 +53017,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             if (!((_b = pathInfoRes.message) === null || _b === void 0 ? void 0 : _b.exist) ||
                 ((_c = pathInfoRes.message) === null || _c === void 0 ? void 0 : _c.directory) ||
                 fileSize === undefined ||
-                fileSize < PROTOCOL_V2_OKPP_HEADER_SIZE ||
+                fileSize < PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE ||
                 (expectedSize !== undefined && fileSize !== expectedSize)) {
                 return null;
             }
             const chunkSize = this.getProtocolV2FirmwareChunkSize('read');
             const chunks = [];
             let offset = 0;
-            while (offset < PROTOCOL_V2_OKPP_HEADER_SIZE) {
-                const readLen = Math.min(chunkSize, PROTOCOL_V2_OKPP_HEADER_SIZE - offset);
+            while (offset < PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE) {
+                const readLen = Math.min(chunkSize, PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE - offset);
                 const res = yield typedCall('FilesystemFileRead', 'FilesystemFile', {
                     file: {
                         path: filePath,
@@ -53131,7 +53047,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 headerBytes.set(chunk, cursor);
                 cursor += chunk.byteLength;
             });
-            return parseProtocolV2OkppHeader(headerBytes);
+            try {
+                return parseProtocolV2ResourcePackageHeader(headerBytes, fileSize);
+            }
+            catch (_e) {
+                return null;
+            }
         });
     }
     isProtocolV2ResourceBundleUpToDate(bundle) {
@@ -53357,7 +53278,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             this.protocolV2LastTransferProgressAt = 0;
             let processedSize = 0;
             for (const resource of resourcesToSync) {
-                const writePath = resolveProtocolV2ResourceWritePath(resource.devicePath);
+                const writePath = resource.devicePath;
                 processedSize = yield this.protocolV2SourceUpdateProcess({
                     source: resource.source,
                     filePath: writePath,
@@ -54008,7 +53929,7 @@ class PromptWebDeviceAccess extends BaseMethod {
                     }
                     if (isWebUsbEnv) {
                         const usbDevice = device;
-                        const path = usbDevice.serialNumber;
+                        const path = hdShared.resolveOneKeyUsbDevicePath(usbDevice);
                         if (!path) {
                             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.WebDevicePromptAccessError);
                         }
@@ -54042,6 +53963,8 @@ class DeviceReboot extends BaseMethod {
     init() {
         this.skipForceUpdateCheck = true;
         this.useDevicePassphraseState = false;
+        this.unlockPolicy = 'unlock-before-run';
+        this.protocolV2PreUnlockPinType = hdTransport.DeviceSessionPinType.Any;
         this.params = {
             rebootType: this.payload.rebootType,
             reboot_type: this.payload.reboot_type,
@@ -54446,7 +54369,8 @@ class DeviceUploadWallpaper extends BaseMethod {
         });
         this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
         this.params = { jpegBase64, fileName, chunkSize };
-        this.unlockPolicy = 'none';
+        this.unlockPolicy = 'unlock-before-run';
+        this.protocolV2PreUnlockPinType = hdTransport.DeviceSessionPinType.Any;
         this.skipForceUpdateCheck = true;
         this.useDevicePassphraseState = false;
     }
@@ -54602,7 +54526,8 @@ class DeviceUploadNft extends BaseMethod {
             paceMs,
             timeoutMs,
         };
-        this.unlockPolicy = 'none';
+        this.unlockPolicy = 'unlock-before-run';
+        this.protocolV2PreUnlockPinType = hdTransport.DeviceSessionPinType.Any;
         this.skipForceUpdateCheck = true;
         this.useDevicePassphraseState = false;
     }
@@ -65282,7 +65207,6 @@ 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);
@@ -65632,12 +65556,25 @@ function canSkipInitialize(method, device) {
     return true;
 }
 function isRetryableBleProtocolV2ProbeError(method, error) {
-    const message = error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : '');
+    const typedError = error;
+    const message = typeof (typedError === null || typedError === void 0 ? void 0 : typedError.message) === 'string' ? typedError.message : String(error !== null && error !== void 0 ? error : '');
     return (method.payload.connectProtocol === 'V2' &&
+        (typedError === null || typedError === void 0 ? void 0 : typedError.errorCode) === hdShared.HardwareErrorCode.RuntimeError &&
         message.includes('Device protocol mismatch') &&
         message.includes('expected V2') &&
         message.includes('did not respond to expected protocol'));
 }
+function isRetryableBleConnectionError(method, error) {
+    var _a;
+    if ((_a = method.device) === null || _a === void 0 ? void 0 : _a.wasInterruptedByUser()) {
+        return false;
+    }
+    const typedError = error;
+    return ((typedError === null || typedError === void 0 ? void 0 : typedError.errorCode) === hdShared.HardwareErrorCode.BleTimeoutError ||
+        (typedError === null || typedError === void 0 ? void 0 : typedError.errorCode) === hdShared.HardwareErrorCode.BleConnectedError ||
+        isRetryableBleProtocolV2ProbeError(method, error) ||
+        isMissingDetectedProtocolV2Error(method, error));
+}
 function isMissingDetectedProtocolV2Error(method, error) {
     const typedError = error;
     return (method.payload.connectProtocol === 'V2' &&
@@ -65645,34 +65582,13 @@ function isMissingDetectedProtocolV2Error(method, error) {
         typeof typedError.message === 'string' &&
         typedError.message.includes('Device protocol has not been detected'));
 }
-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) {
+function connectDeviceForBle(method, device, retryCount = 0) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
         try {
+            if (device.wasInterruptedByUser()) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromUser);
+            }
             if (method.payload.forceProtocolDetection && device.hasDeviceAcquire()) {
                 yield device.release();
             }
@@ -65681,31 +65597,9 @@ function connectDeviceForBle(method, device, abortSignal, retryCount = 0) {
                 !device.commands ||
                 device.commands.disposed;
             if (shouldAcquire) {
-                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;
-                    }
-                }
+                yield device.acquire(method.payload.connectProtocol, {
+                    forceProtocolDetection: method.payload.forceProtocolDetection,
+                });
             }
             if ((_a = method.payload) === null || _a === void 0 ? void 0 : _a.onlyConnectBleDevice) {
                 if (shouldAcquire) {
@@ -65732,15 +65626,11 @@ function connectDeviceForBle(method, device, abortSignal, retryCount = 0) {
                 yield device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
                 device.markTransportDisconnected();
             }
-            if ((err.errorCode === hdShared.HardwareErrorCode.BleTimeoutError ||
-                err.errorCode === hdShared.HardwareErrorCode.BleConnectedError ||
-                isRetryableBleProtocolV2ProbeError(method, err) ||
-                requiresColdReconnect) &&
-                retryCount < 6) {
+            if (isRetryableBleConnectionError(method, err) && retryCount < 6) {
                 const nextRetry = retryCount + 1;
                 Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
                 yield wait(3000);
-                yield connectDeviceForBle(method, device, abortSignal, nextRetry);
+                yield connectDeviceForBle(method, device, nextRetry);
             }
             else {
                 throw err;
@@ -65822,7 +65712,7 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                         if (abort()) {
                             return;
                         }
-                        yield connectDeviceForBle(method, device, abortSignal);
+                        yield connectDeviceForBle(method, device);
                     }
                     resolve(device);
                     return;
@@ -66418,14 +66308,12 @@ exports.normalizeSafetyCheckLevel = normalizeSafetyCheckLevel;
 exports.normalizeVersionArray = normalizeVersionArray;
 exports.parseConnectSettings = parseConnectSettings;
 exports.parseMessage = parseMessage;
-exports.parseProtocolV2ResourceManifest = parseProtocolV2ResourceManifest;
 exports.patchFeatures = patchFeatures;
 exports.preloadSessionCache = preloadSessionCache;
 exports.prepareFirmwareUpdateV4MemoryHost = prepareFirmwareUpdateV4MemoryHost;
 exports.projectDeviceStateFeatures = projectFeatures;
 exports.registerFirmwareUpdateHostBinding = registerFirmwareUpdateHostBinding;
 exports.safeThrowError = safeThrowError;
-exports.selectProtocolV2ResourceManifestFiles = selectProtocolV2ResourceManifestFiles;
 exports.setLoggerPostMessage = setLoggerPostMessage;
 exports.supportInputPinOnSoftware = supportInputPinOnSoftware;
 exports.switchTransport = switchTransport;