@onekeyfe/hd-core 1.2.0-alpha.23 → 1.2.0-alpha.24

package/dist/index.js

@@ -2,16 +2,16 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var hdShared = require('@onekeyfe/hd-shared');
-var utils = require('@noble/hashes/utils');
-var sha256 = require('@noble/hashes/sha256');
 var semver = require('semver');
 var hdTransport = require('@onekeyfe/hd-transport');
+var hdShared = require('@onekeyfe/hd-shared');
 var axios = require('axios');
 var lodash = require('lodash');
 var ByteBuffer = require('bytebuffer');
 var BigNumber = require('bignumber.js');
+var utils = require('@noble/hashes/utils');
 var blake2s = require('@noble/hashes/blake2s');
+var sha256 = require('@noble/hashes/sha256');
 var JSZip = require('jszip');
 var sha3 = require('@noble/hashes/sha3');
 var blake2b = require('@noble/hashes/blake2b');
@@ -87,1117 +87,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const getFirmwareUpdateCapabilities = () => ({
-    planSchemaVersion: 2,
-    preparedPlanSchemaVersion: 2,
-    hostBindingProtocolVersion: 2,
-    manifestModes: ['external-only', 'sdk-managed'],
-    supportsArtifactReader: true,
-});
-
-const MAX_FIRMWARE_ARTIFACT_READ_BYTES = 256 * 1024;
-const artifactError = (code, message) => {
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, message, {
-        firmwareUpdateCode: code,
-    });
-};
-const assertSafeSize = (value, name) => {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-        artifactError('FirmwareArtifactReceiptMismatch', `${name} must be a positive safe integer`);
-    }
-};
-const assertFirmwareArtifactReference = (artifact) => {
-    if (!artifact ||
-        typeof artifact.artifactRef !== 'string' ||
-        artifact.artifactRef.length === 0 ||
-        artifact.artifactRef.length > 160 ||
-        artifact.artifactRef.includes('/') ||
-        artifact.artifactRef.includes('\\')) {
-        artifactError('FirmwareArtifactReceiptMismatch', 'Firmware artifactRef must be an opaque identifier');
-    }
-    assertSafeSize(artifact.size, 'Firmware artifact size');
-    if (typeof artifact.sha256 !== 'string' || !/^[a-f0-9]{64}$/i.test(artifact.sha256)) {
-        artifactError('FirmwareArtifactReceiptMismatch', 'Firmware artifact sha256 must be a 32-byte hexadecimal digest');
-    }
-    return artifact;
-};
-const assertFirmwareArtifactRead = (size, offset, length) => {
-    if (!Number.isSafeInteger(offset) ||
-        offset < 0 ||
-        offset >= size ||
-        !Number.isSafeInteger(length) ||
-        length <= 0 ||
-        offset + length > size) {
-        artifactError('FirmwareArtifactReadOutOfBounds', `Firmware artifact read is outside size ${size}: offset=${offset}, length=${length}`);
-    }
-    if (length > MAX_FIRMWARE_ARTIFACT_READ_BYTES) {
-        artifactError('FirmwareArtifactReadTooLarge', `Firmware artifact read length ${length} exceeds ${MAX_FIRMWARE_ARTIFACT_READ_BYTES}`);
-    }
-};
-const createMemoryFirmwareByteSource = (binary) => {
-    let bytes = new Uint8Array(binary);
-    const { byteLength: size } = binary;
-    assertSafeSize(size, 'Firmware binary size');
-    return {
-        size,
-        readAt: (offset, length) => {
-            if (!bytes) {
-                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware byte source is closed', {
-                    firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
-                }));
-            }
-            assertFirmwareArtifactRead(size, offset, length);
-            return Promise.resolve(bytes.slice(offset, offset + length).buffer);
-        },
-        close: () => {
-            bytes = null;
-            return Promise.resolve();
-        },
-    };
-};
-class ReaderFirmwareByteSource {
-    constructor(reader, readerId, size) {
-        this.reader = reader;
-        this.readerId = readerId;
-        this.closed = false;
-        this.reading = false;
-        this.size = size;
-    }
-    static open(artifact, reader) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const opened = yield reader.open({ artifactRef: artifact.artifactRef });
-            if (!opened ||
-                typeof opened.readerId !== 'string' ||
-                opened.readerId.length === 0 ||
-                !Number.isSafeInteger(opened.size) ||
-                opened.size !== artifact.size) {
-                if (opened === null || opened === void 0 ? void 0 : opened.readerId) {
-                    yield reader.close({ readerId: opened.readerId }).catch(() => undefined);
-                }
-                return artifactError('FirmwareArtifactReceiptMismatch', `Firmware artifact opened with size ${(_a = opened === null || opened === void 0 ? void 0 : opened.size) !== null && _a !== void 0 ? _a : 'unknown'}, expected ${artifact.size}`);
-            }
-            return new ReaderFirmwareByteSource(reader, opened.readerId, opened.size);
-        });
-    }
-    readAt(offset, length) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closed) {
-                return artifactError('FirmwareArtifactReaderInvalid', 'Firmware artifact reader is closed');
-            }
-            if (this.reading) {
-                return artifactError('FirmwareArtifactReaderInvalid', 'Firmware artifact reader only permits one in-flight read');
-            }
-            assertFirmwareArtifactRead(this.size, offset, length);
-            this.reading = true;
-            try {
-                const result = yield this.reader.read({
-                    readerId: this.readerId,
-                    offset,
-                    length,
-                });
-                const expectedEof = offset + length === this.size;
-                if (!result ||
-                    !(result.data instanceof ArrayBuffer) ||
-                    result.data.byteLength !== length ||
-                    result.bytesRead !== length ||
-                    result.eof !== expectedEof) {
-                    return artifactError('FirmwareArtifactReaderInvalid', 'Firmware artifact reader returned an invalid read result');
-                }
-                return result.data;
-            }
-            finally {
-                this.reading = false;
-            }
-        });
-    }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closed) {
-                return;
-            }
-            this.closed = true;
-            yield this.reader.close({ readerId: this.readerId });
-        });
-    }
-}
-const openFirmwareByteSource = ({ binary, artifact, reader, }) => __awaiter(void 0, void 0, void 0, function* () {
-    if (binary && artifact) {
-        return artifactError('FirmwareArtifactReceiptMismatch', 'Firmware input must not contain both binary and artifactRef');
-    }
-    if (binary) {
-        return createMemoryFirmwareByteSource(binary);
-    }
-    if (!artifact) {
-        return null;
-    }
-    assertFirmwareArtifactReference(artifact);
-    if (!reader) {
-        return artifactError('FirmwareArtifactReaderInvalid', 'Firmware artifact reader is required for artifactRef input');
-    }
-    return ReaderFirmwareByteSource.open(artifact, reader);
-});
-const readFirmwareByteSourceFully = (source) => __awaiter(void 0, void 0, void 0, function* () {
-    const output = new Uint8Array(source.size);
-    let offset = 0;
-    while (offset < source.size) {
-        const length = Math.min(MAX_FIRMWARE_ARTIFACT_READ_BYTES, source.size - offset);
-        output.set(new Uint8Array(yield source.readAt(offset, length)), offset);
-        offset += length;
-    }
-    return output.buffer;
-});
-const writeFirmwareByteSource = ({ source, chunkSize, write, }) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!Number.isSafeInteger(chunkSize) ||
-        chunkSize <= 0 ||
-        chunkSize > MAX_FIRMWARE_ARTIFACT_READ_BYTES) {
-        return artifactError('FirmwareArtifactReadTooLarge', `Firmware artifact chunk size must be between 1 and ${MAX_FIRMWARE_ARTIFACT_READ_BYTES}`);
-    }
-    let offset = 0;
-    while (offset < source.size) {
-        const length = Math.min(chunkSize, source.size - offset);
-        const data = yield source.readAt(offset, length);
-        const processed = yield write({
-            data,
-            sourceOffset: offset,
-            length,
-            first: offset === 0,
-        });
-        if (processed !== length) {
-            return artifactError('FirmwareArtifactReaderInvalid', `Firmware artifact writer processed ${processed} bytes, expected ${length}`);
-        }
-        offset += length;
-    }
-    return offset;
-});
-
-exports.EOneKeyDeviceMode = void 0;
-(function (EOneKeyDeviceMode) {
-    EOneKeyDeviceMode["bootloader"] = "bootloader";
-    EOneKeyDeviceMode["normal"] = "normal";
-    EOneKeyDeviceMode["notInitialized"] = "notInitialized";
-    EOneKeyDeviceMode["backupMode"] = "backupMode";
-})(exports.EOneKeyDeviceMode || (exports.EOneKeyDeviceMode = {}));
-const DeviceModelToTypes = {
-    model_mini: [
-        hdShared.EDeviceType.Classic,
-        hdShared.EDeviceType.Classic1s,
-        hdShared.EDeviceType.ClassicPure,
-        hdShared.EDeviceType.Mini,
-    ],
-    model_touch: [hdShared.EDeviceType.Touch, hdShared.EDeviceType.Pro],
-    model_classic: [hdShared.EDeviceType.Classic, hdShared.EDeviceType.Classic1s, hdShared.EDeviceType.ClassicPure],
-    model_classic1s: [hdShared.EDeviceType.Classic1s, hdShared.EDeviceType.ClassicPure],
-};
-const DeviceTypeToModels = {
-    [hdShared.EDeviceType.Classic]: ['model_classic', 'model_mini'],
-    [hdShared.EDeviceType.Classic1s]: ['model_classic', 'model_mini', 'model_classic1s'],
-    [hdShared.EDeviceType.ClassicPure]: ['model_classic', 'model_mini', 'model_classic1s'],
-    [hdShared.EDeviceType.Mini]: ['model_mini'],
-    [hdShared.EDeviceType.Touch]: ['model_touch'],
-    [hdShared.EDeviceType.Pro]: ['model_touch'],
-    [hdShared.EDeviceType.Pro2]: [],
-    [hdShared.EDeviceType.Unknown]: [],
-};
-
-const asCompatibleFeatures = (features) => features;
-const firstNonEmptyString = (...values) => values.find(value => typeof value === 'string' && value.length > 0);
-const firstMeaningfulVersion$1 = (...versions) => { var _a; return (_a = versions.find(version => Boolean(version && version !== '0.0.0'))) !== null && _a !== void 0 ? _a : null; };
-const versionFromParts = (major, minor, patch) => [major, minor, patch].map(part => Number(part) || 0).join('.');
-const resolveDeviceSerialNo = (features) => {
-    var _a;
-    if (!features)
-        return '';
-    const compatible = asCompatibleFeatures(features);
-    return ((_a = firstNonEmptyString(compatible.serialNo, compatible.onekey_serial_no, compatible.onekey_serial, compatible.serial_no)) !== null && _a !== void 0 ? _a : '');
-};
-const resolveDeviceType = (features) => {
-    var _a, _b, _c, _d;
-    if (!features || typeof features !== 'object') {
-        return hdShared.EDeviceType.Unknown;
-    }
-    const compatible = asCompatibleFeatures(features);
-    if (compatible.deviceType && compatible.deviceType !== hdShared.EDeviceType.Unknown) {
-        return compatible.deviceType;
-    }
-    switch ((_a = compatible.onekey_device_type) === null || _a === void 0 ? void 0 : _a.toString().toUpperCase()) {
-        case 'CLASSIC':
-            return hdShared.EDeviceType.Classic;
-        case 'CLASSIC1S':
-            return hdShared.EDeviceType.Classic1s;
-        case 'MINI':
-            return hdShared.EDeviceType.Mini;
-        case 'TOUCH':
-            return hdShared.EDeviceType.Touch;
-        case 'PRO':
-            return hdShared.EDeviceType.Pro;
-        case 'PRO2':
-            return hdShared.EDeviceType.Pro2;
-        case 'PURE':
-            return hdShared.EDeviceType.ClassicPure;
-    }
-    if (((_b = compatible.model) === null || _b === void 0 ? void 0 : _b.toString().toLowerCase()) === hdShared.EDeviceType.Pro2) {
-        return hdShared.EDeviceType.Pro2;
-    }
-    const serialNo = resolveDeviceSerialNo(features);
-    const prefix = serialNo.slice(0, 2).toLowerCase();
-    if (prefix === 'bi' || prefix === 'cl')
-        return hdShared.EDeviceType.Classic;
-    if (prefix === 'cp')
-        return hdShared.EDeviceType.ClassicPure;
-    if (prefix === 'mi')
-        return hdShared.EDeviceType.Mini;
-    if (prefix === 'tc')
-        return hdShared.EDeviceType.Touch;
-    if (prefix === 'pr')
-        return hdShared.EDeviceType.Pro;
-    if (prefix === 'p2')
-        return hdShared.EDeviceType.Pro2;
-    const bootloaderMode = (_c = compatible.bootloaderMode) !== null && _c !== void 0 ? _c : compatible.bootloader_mode;
-    if (!serialNo && bootloaderMode === true && compatible.model === '1') {
-        return hdShared.EDeviceType.Classic;
-    }
-    return (_d = compatible.deviceType) !== null && _d !== void 0 ? _d : hdShared.EDeviceType.Unknown;
-};
-const resolveDeviceFirmwareType = (features) => {
-    if (!features) {
-        return hdShared.EFirmwareType.Universal;
-    }
-    const compatible = asCompatibleFeatures(features);
-    if (compatible.firmwareType) {
-        return compatible.firmwareType;
-    }
-    if (compatible.fw_vendor === 'OneKey Bitcoin-only') {
-        return hdShared.EFirmwareType.BitcoinOnly;
-    }
-    const capabilities = compatible.capabilities;
-    const supportsBitcoinLike = capabilities === null || capabilities === void 0 ? void 0 : capabilities.some(capability => capability === hdTransport.Enum_Capability.Capability_Bitcoin_like ||
-        capability === 'Capability_Bitcoin_like');
-    return (capabilities === null || capabilities === void 0 ? void 0 : capabilities.length) && !supportsBitcoinLike
-        ? hdShared.EFirmwareType.BitcoinOnly
-        : hdShared.EFirmwareType.Universal;
-};
-const resolveDeviceBleName = (features) => {
-    var _a;
-    if (!features)
-        return null;
-    const compatible = asCompatibleFeatures(features);
-    return ((_a = firstNonEmptyString(compatible.bleName, compatible.onekey_ble_name, compatible.ble_name)) !== null && _a !== void 0 ? _a : null);
-};
-const resolveDeviceFirmwareVersion = (features) => {
-    if (!features)
-        return null;
-    const compatible = asCompatibleFeatures(features);
-    return firstMeaningfulVersion$1(compatible.firmwareVersion, compatible.onekey_firmware_version, compatible.onekey_version, versionFromParts(compatible.major_version, compatible.minor_version, compatible.patch_version));
-};
-const resolveDeviceBootloaderVersion = (features) => {
-    var _a;
-    if (!features)
-        return null;
-    const compatible = asCompatibleFeatures(features);
-    const bootloaderMode = (_a = compatible.bootloaderMode) !== null && _a !== void 0 ? _a : compatible.bootloader_mode;
-    return firstMeaningfulVersion$1(compatible.bootloaderVersion, compatible.onekey_boot_version, compatible.bootloader_version, compatible.onekey_bootloader_version, bootloaderMode
-        ? versionFromParts(compatible.major_version, compatible.minor_version, compatible.patch_version)
-        : null);
-};
-const resolveDeviceBoardVersion = (features) => {
-    if (!features)
-        return null;
-    const compatible = asCompatibleFeatures(features);
-    return firstMeaningfulVersion$1(compatible.boardVersion, compatible.onekey_board_version, compatible.boardloader_version, compatible.onekey_romloader_version, compatible.romloader_version);
-};
-const resolveDeviceBleFirmwareVersion = (features) => {
-    if (!features)
-        return null;
-    const compatible = asCompatibleFeatures(features);
-    return firstMeaningfulVersion$1(compatible.bleVersion, compatible.onekey_ble_version, compatible.ble_ver, compatible.onekey_coprocessor_version);
-};
-
-const getDeviceType = (features) => resolveDeviceType(features);
-const getDeviceTypeByBleName = (name) => {
-    if (!name)
-        return hdShared.EDeviceType.Unknown;
-    if (/^BixinKey/i.test(name))
-        return hdShared.EDeviceType.Classic;
-    if (/^K/i.test(name))
-        return hdShared.EDeviceType.Classic;
-    if (/^T/i.test(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))
-        return hdShared.EDeviceType.Pro2;
-    if (/\bPro\b/i.test(name) || /^Pro/i.test(name))
-        return hdShared.EDeviceType.Pro;
-    return hdShared.EDeviceType.Unknown;
-};
-const getDeviceBleName = (features) => resolveDeviceBleName(features);
-const getDeviceSerialNo = (features) => resolveDeviceSerialNo(features);
-const getDeviceUUID = getDeviceSerialNo;
-const getDeviceLabel = (features) => {
-    if (!features)
-        return null;
-    return 'label' in features && typeof features.label === 'string' && features.label.length > 0
-        ? features.label
-        : null;
-};
-const getMethodVersionRange = (features, getVersionRange) => {
-    const deviceType = getDeviceType(features);
-    const versionRange = getVersionRange(deviceType);
-    if (versionRange) {
-        return versionRange;
-    }
-    const modelFallbacks = [
-        'model_classic1s',
-        'model_classic',
-        'model_mini',
-        'model_touch',
-    ];
-    for (const model of modelFallbacks) {
-        if (DeviceModelToTypes[model].includes(deviceType)) {
-            const versionRange = getVersionRange(model);
-            if (versionRange) {
-                return versionRange;
-            }
-        }
-    }
-    return undefined;
-};
-const isMethodVersionRangeUnsupported = (versionRange) => (versionRange === null || versionRange === void 0 ? void 0 : versionRange.unsupported) === true;
-const getFirmwareType = (features) => resolveDeviceFirmwareType(features);
-
-const EMPTY_VERSION = [0, 0, 0];
-const parseDeviceVersion = (version) => {
-    const parsed = version ? semver__default["default"].parse(version) : null;
-    return parsed ? [parsed.major, parsed.minor, parsed.patch] : [...EMPTY_VERSION];
-};
-const getDeviceFirmwareVersion = (features) => parseDeviceVersion(resolveDeviceFirmwareVersion(features));
-const getDeviceBootloaderVersion = (features) => parseDeviceVersion(resolveDeviceBootloaderVersion(features));
-const getDeviceBoardloaderVersion = (features) => parseDeviceVersion(resolveDeviceBoardVersion(features));
-const getDeviceBLEFirmwareVersion = (features) => parseDeviceVersion(resolveDeviceBleFirmwareVersion(features));
-
-const PROTOCOL_V2_TARGETS = {
-    BOOTLOADER: 'boot',
-    APPLICATION_P1: 'app_v1',
-    APPLICATION_P2: 'app_v2',
-    COPROCESSOR: 'coprocessor',
-    SE01: 'se01',
-    SE02: 'se02',
-    SE03: 'se03',
-    SE04: 'se04',
-};
-const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value)
-    ? value
-    : undefined;
-const asRelease = (release) => asRecord(release === null || release === void 0 ? void 0 : release.release);
-const asString = (value) => typeof value === 'string' && value.length > 0 ? value : undefined;
-const asVersion = (value) => {
-    if (!Array.isArray(value) ||
-        value.length !== 3 ||
-        value.some(part => typeof part !== 'number' || !Number.isSafeInteger(part) || part < 0)) {
-        return undefined;
-    }
-    return value.join('.');
-};
-const asIntegrity = ({ size, sha256: value, }) => {
-    const sha256Value = typeof value === 'string' && /^[a-f0-9]{64}$/iu.test(value) ? value.toLowerCase() : undefined;
-    return Object.assign(Object.assign({}, (Number.isSafeInteger(size) && size > 0 ? { expectedSize: size } : {})), (sha256Value ? { expectedSha256: sha256Value } : {}));
-};
-const isUpgrade = (release) => (release === null || release === void 0 ? void 0 : release.status) === 'required' ||
-    (release === null || release === void 0 ? void 0 : release.status) === 'outdated' ||
-    (release === null || release === void 0 ? void 0 : release.shouldUpdate) === true;
-const assertArtifactUrl = (value, label) => {
-    const raw = asString(value);
-    if (!raw) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `${label} has no downloadable artifact`, { firmwareUpdateCode: 'FirmwarePlanInvalid' });
-    }
-    const parsed = new URL(raw);
-    if (parsed.protocol !== 'https:' ||
-        parsed.port !== '' ||
-        parsed.username ||
-        parsed.password ||
-        parsed.hash) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `${label} URL is not canonical HTTPS`, {
-            firmwareUpdateCode: 'FirmwarePlanInvalid',
-        });
-    }
-    return raw;
-};
-const canonicalizeFirmwareUpdateContract = (value) => {
-    if (Array.isArray(value)) {
-        return value.map(canonicalizeFirmwareUpdateContract);
-    }
-    if (value && typeof value === 'object') {
-        return Object.keys(value)
-            .sort()
-            .reduce((result, key) => {
-            const item = value[key];
-            if (item !== undefined) {
-                result[key] = canonicalizeFirmwareUpdateContract(item);
-            }
-            return result;
-        }, {});
-    }
-    return value;
-};
-const digestFirmwareUpdateContract = (value) => utils.bytesToHex(sha256.sha256(new TextEncoder().encode(JSON.stringify(canonicalizeFirmwareUpdateContract(value)))));
-const digestFirmwareUpdatePlan = (plan) => digestFirmwareUpdateContract(plan);
-const planError = (message) => {
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, message, {
-        firmwareUpdateCode: 'FirmwarePlanInvalid',
-    });
-};
-const assertExactKeys = (value, required, optional = []) => {
-    const allowed = new Set([...required, ...optional]);
-    if (required.some(key => !Object.prototype.hasOwnProperty.call(value, key)) ||
-        Object.keys(value).some(key => !allowed.has(key))) {
-        planError('Firmware update plan contains an invalid field set');
-    }
-};
-const assertBoundedString = (value, label, maxLength = 256) => {
-    if (typeof value !== 'string' || value.length === 0 || value.length > maxLength) {
-        return planError(`Firmware update plan ${label} is invalid`);
-    }
-    return value;
-};
-const FIRMWARE_UPDATE_PLAN_TARGETS = new Set([
-    'firmware',
-    'ble',
-    'bootloader',
-    'resource',
-    'boot',
-    'app_v1',
-    'app_v2',
-    'coprocessor',
-    'se01',
-    'se02',
-    'se03',
-    'se04',
-]);
-const FIRMWARE_UPDATE_PLAN_ROLES = new Set([
-    'firmware',
-    'ble',
-    'bootloader',
-    'resource',
-    'component',
-    'resourceBundle',
-]);
-const PLAN_CONTAINERS = new Set(['raw', 'zip']);
-const PLAN_PLATFORMS = new Set([
-    'native',
-    'desktop',
-    'ext',
-    'web',
-    'web-embed',
-]);
-const assertFirmwareUpdatePlan = (value) => {
-    const plan = asRecord(value);
-    if (!plan) {
-        return planError('Firmware update plan must be an object');
-    }
-    assertExactKeys(plan, [
-        'schemaVersion',
-        'planDigest',
-        'executor',
-        'deviceIdentity',
-        'deviceModel',
-        'firmwareType',
-        'platform',
-        'artifacts',
-        'targetsToUpdate',
-    ]);
-    if (plan.schemaVersion !== 2 ||
-        typeof plan.planDigest !== 'string' ||
-        !/^[a-f0-9]{64}$/u.test(plan.planDigest) ||
-        (plan.executor !== 'v2' && plan.executor !== 'v3' && plan.executor !== 'v4') ||
-        !PLAN_PLATFORMS.has(plan.platform) ||
-        (plan.firmwareType !== hdShared.EFirmwareType.Universal &&
-            plan.firmwareType !== hdShared.EFirmwareType.BitcoinOnly)) {
-        return planError('Firmware update plan header is invalid');
-    }
-    assertBoundedString(plan.deviceIdentity, 'device identity');
-    assertBoundedString(plan.deviceModel, 'device model', 64);
-    if (!Array.isArray(plan.artifacts) || plan.artifacts.length > 128) {
-        return planError('Firmware update plan artifact set is invalid');
-    }
-    const artifactIds = new Set();
-    const artifactTargets = new Set();
-    for (const item of plan.artifacts) {
-        const artifact = asRecord(item);
-        if (!artifact) {
-            return planError('Firmware update plan artifact is invalid');
-        }
-        assertExactKeys(artifact, ['artifactId', 'role', 'target', 'url', 'container'], ['logicalName', 'expectedSize', 'expectedSha256', 'targetVersion']);
-        const artifactId = assertBoundedString(artifact.artifactId, 'artifact id', 160);
-        if (artifactIds.has(artifactId)) {
-            return planError('Firmware update plan contains duplicate artifact ids');
-        }
-        artifactIds.add(artifactId);
-        if (!FIRMWARE_UPDATE_PLAN_ROLES.has(artifact.role) ||
-            !FIRMWARE_UPDATE_PLAN_TARGETS.has(artifact.target) ||
-            !PLAN_CONTAINERS.has(artifact.container)) {
-            return planError('Firmware update plan artifact contract is invalid');
-        }
-        artifactTargets.add(artifact.target);
-        assertArtifactUrl(artifact.url, `Firmware artifact ${artifactId}`);
-        if (artifact.logicalName !== undefined) {
-            assertBoundedString(artifact.logicalName, 'logical name', 256);
-        }
-        if (artifact.expectedSize !== undefined &&
-            (!Number.isSafeInteger(artifact.expectedSize) || artifact.expectedSize <= 0)) {
-            return planError('Firmware update plan artifact size is invalid');
-        }
-        if (artifact.expectedSha256 !== undefined &&
-            (typeof artifact.expectedSha256 !== 'string' ||
-                !/^[a-f0-9]{64}$/u.test(artifact.expectedSha256))) {
-            return planError('Firmware update plan artifact digest is invalid');
-        }
-        if (artifact.targetVersion !== undefined) {
-            assertBoundedString(artifact.targetVersion, 'target version', 64);
-        }
-    }
-    if (!Array.isArray(plan.targetsToUpdate) ||
-        plan.targetsToUpdate.some(target => !FIRMWARE_UPDATE_PLAN_TARGETS.has(target)) ||
-        new Set(plan.targetsToUpdate).size !== plan.targetsToUpdate.length ||
-        plan.targetsToUpdate.length !== artifactTargets.size ||
-        plan.targetsToUpdate.some(target => !artifactTargets.has(target))) {
-        return planError('Firmware update plan targets are invalid');
-    }
-    const legacyTargets = new Set([
-        'firmware',
-        'ble',
-        'bootloader',
-        'resource',
-    ]);
-    const legacyOnlyTargets = new Set(['firmware', 'ble', 'bootloader']);
-    if (((plan.executor === 'v2' || plan.executor === 'v3') &&
-        plan.targetsToUpdate.some(target => !legacyTargets.has(target))) ||
-        (plan.executor === 'v4' &&
-            plan.targetsToUpdate.some(target => legacyOnlyTargets.has(target))) ||
-        (plan.artifacts.length > 0 &&
-            (plan.platform === 'native' || plan.platform === 'desktop') &&
-            plan.deviceIdentity === 'unavailable')) {
-        return planError('Firmware update plan executor contract is invalid');
-    }
-    const _a = plan, { planDigest } = _a, withoutDigest = __rest(_a, ["planDigest"]);
-    if (digestFirmwareUpdatePlan(withoutDigest) !== planDigest) {
-        return planError('Firmware update plan digest is invalid');
-    }
-    return plan;
-};
-const selectResourceUrl = ({ release, features, platform, }) => {
-    const resource = asString(release.resource);
-    const fullResource = asString(release.fullResource);
-    const range = release.fullResourceRange;
-    const currentVersion = getDeviceFirmwareVersion(features).join('.');
-    const targetVersion = asVersion(release.version);
-    if (platform === 'desktop' &&
-        fullResource &&
-        targetVersion &&
-        Array.isArray(range) &&
-        range.length === 2 &&
-        typeof range[0] === 'string' &&
-        typeof range[1] === 'string' &&
-        semver__default["default"].valid(currentVersion) &&
-        semver__default["default"].valid(targetVersion) &&
-        semver__default["default"].valid(range[0]) &&
-        semver__default["default"].valid(range[1]) &&
-        semver__default["default"].lt(currentVersion, range[0]) &&
-        semver__default["default"].gte(targetVersion, range[1])) {
-        return fullResource;
-    }
-    return resource;
-};
-const getExecutor = (features) => {
-    const deviceType = getDeviceType(features);
-    if (deviceType === hdShared.EDeviceType.Pro2) {
-        return 'v4';
-    }
-    if (deviceType === hdShared.EDeviceType.Pro &&
-        semver__default["default"].gte(getDeviceBootloaderVersion(features).join('.'), '2.8.0')) {
-        return 'v3';
-    }
-    return 'v2';
-};
-const buildProtocolV2Artifacts = (release) => {
-    var _a;
-    const components = asRecord(release.components);
-    if (!components) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 release has no component set', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
-    }
-    const installOrder = Array.isArray(release.installOrder)
-        ? release.installOrder.filter((key) => typeof key === 'string')
-        : [];
-    const componentKeys = [
-        ...installOrder,
-        ...Object.keys(components).filter(key => !installOrder.includes(key)),
-    ];
-    const artifacts = [];
-    const targets = [];
-    const componentTargets = new Set();
-    for (const key of componentKeys) {
-        const component = asRecord(components[key]);
-        const targetName = (_a = asString(component === null || component === void 0 ? void 0 : component.target)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-        if (targetName === 'ROMLOADER') {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 ROMLOADER requires its dedicated loader flow', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
-        }
-        const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
-        if (!component || !target) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 component ${key} has an unsupported target`, { firmwareUpdateCode: 'FirmwarePlanInvalid' });
-        }
-        if (componentTargets.has(target)) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 component ${key} duplicates target ${target}`, { firmwareUpdateCode: 'FirmwarePlanInvalid' });
-        }
-        componentTargets.add(target);
-        artifacts.push(Object.assign(Object.assign({ artifactId: `component:${target}`, role: 'component', target, url: assertArtifactUrl(component.url, `Protocol V2 component ${key}`), container: 'raw', logicalName: key }, asIntegrity({
-            size: component.expectedSize,
-            sha256: component.fingerprint,
-        })), (asVersion(component.version) ? { targetVersion: asVersion(component.version) } : {})));
-        targets.push(target);
-    }
-    const bundles = Array.isArray(release.resourceBundles) ? release.resourceBundles : [];
-    const resourceBundleNames = new Set();
-    for (const value of bundles) {
-        const bundle = asRecord(value);
-        const name = asString(bundle === null || bundle === void 0 ? void 0 : bundle.name);
-        if (!bundle || !name) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 resource bundle is invalid', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
-        }
-        if (resourceBundleNames.has(name)) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 resource bundle duplicates name ${name}`, { firmwareUpdateCode: 'FirmwarePlanInvalid' });
-        }
-        resourceBundleNames.add(name);
-        artifacts.push(Object.assign({ artifactId: `resourceBundle:${name}`, role: 'resourceBundle', target: 'resource', url: assertArtifactUrl(bundle.url, `Protocol V2 resource bundle ${name}`), container: 'raw', logicalName: name }, asIntegrity({
-            size: bundle.expectedSize,
-            sha256: bundle.fingerprint,
-        })));
-    }
-    if (bundles.length > 0) {
-        targets.push('resource');
-    }
-    return { artifacts, targets: [...new Set(targets)] };
-};
-const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, ble, bootloader, }) => {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const executor = getExecutor(features);
-    let artifacts = [];
-    let targetsToUpdate = [];
-    const firmwareRelease = asRelease(firmware);
-    if (executor === 'v4' && isUpgrade(firmware)) {
-        const protocolV2 = buildProtocolV2Artifacts(firmwareRelease !== null && firmwareRelease !== void 0 ? firmwareRelease : {});
-        artifacts = protocolV2.artifacts;
-        targetsToUpdate = protocolV2.targets;
-    }
-    else {
-        if (isUpgrade(bootloader)) {
-            artifacts.push(Object.assign(Object.assign({ artifactId: 'bootloader', role: 'bootloader', target: 'bootloader', url: assertArtifactUrl((_a = asRelease(bootloader)) === null || _a === void 0 ? void 0 : _a.bootloaderResource, 'Bootloader release'), container: 'raw' }, asIntegrity({
-                size: (_b = asRelease(bootloader)) === null || _b === void 0 ? void 0 : _b.bootloaderExpectedSize,
-                sha256: (_c = asRelease(bootloader)) === null || _c === void 0 ? void 0 : _c.bootloaderFingerprint,
-            })), (asVersion((_d = asRelease(bootloader)) === null || _d === void 0 ? void 0 : _d.bootloaderVersion)
-                ? {
-                    targetVersion: asVersion((_e = asRelease(bootloader)) === null || _e === void 0 ? void 0 : _e.bootloaderVersion),
-                }
-                : {})));
-        }
-        if (isUpgrade(firmware)) {
-            if (!firmwareRelease) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware release is invalid', {
-                    firmwareUpdateCode: 'FirmwarePlanInvalid',
-                });
-            }
-            artifacts.push(Object.assign(Object.assign({ artifactId: 'firmware', role: 'firmware', target: 'firmware', url: assertArtifactUrl(firmwareRelease.url, 'Firmware release'), container: 'raw' }, asIntegrity({
-                size: firmwareRelease.expectedSize,
-                sha256: firmwareRelease.fingerprint,
-            })), (asVersion(firmwareRelease.version)
-                ? { targetVersion: asVersion(firmwareRelease.version) }
-                : {})));
-            const resourceUrl = selectResourceUrl({
-                release: firmwareRelease,
-                features,
-                platform,
-            });
-            if (resourceUrl) {
-                artifacts.push(Object.assign({ artifactId: 'resource', role: 'resource', target: 'resource', url: assertArtifactUrl(resourceUrl, 'Firmware resource release'), container: 'zip' }, asIntegrity({
-                    size: resourceUrl === asString(firmwareRelease.fullResource)
-                        ? firmwareRelease.fullResourceExpectedSize
-                        : firmwareRelease.resourceExpectedSize,
-                    sha256: resourceUrl === asString(firmwareRelease.fullResource)
-                        ? firmwareRelease.fullResourceFingerprint
-                        : firmwareRelease.resourceFingerprint,
-                })));
-            }
-        }
-        if (isUpgrade(ble)) {
-            const bleRelease = asRelease(ble);
-            artifacts.push(Object.assign(Object.assign({ artifactId: 'ble', role: 'ble', target: 'ble', url: assertArtifactUrl((_f = bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.webUpdate) !== null && _f !== void 0 ? _f : bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.url, 'BLE release'), container: 'raw' }, asIntegrity({
-                size: bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.expectedSize,
-                sha256: (_g = bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.fingerprintWeb) !== null && _g !== void 0 ? _g : bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.fingerprint,
-            })), (asVersion(bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.version)
-                ? { targetVersion: asVersion(bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.version) }
-                : {})));
-        }
-        targetsToUpdate = [...new Set(artifacts.map(artifact => artifact.target))];
-    }
-    const deviceIdentity = getDeviceUUID(features);
-    if (artifacts.length > 0 &&
-        (platform === 'native' || platform === 'desktop') &&
-        !deviceIdentity) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Prepared firmware update requires a stable device identity', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
-    }
-    const planWithoutDigest = {
-        schemaVersion: 2,
-        executor,
-        deviceIdentity: deviceIdentity || 'unavailable',
-        deviceModel: String(getDeviceType(features)),
-        firmwareType,
-        platform,
-        artifacts,
-        targetsToUpdate,
-    };
-    return Object.assign(Object.assign({}, planWithoutDigest), { planDigest: digestFirmwareUpdatePlan(planWithoutDigest) });
-};
-
-const preparedPlanError = (message) => {
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, message, {
-        firmwareUpdateCode: 'FirmwarePreparedPlanInvalid',
-    });
-};
-const digestPreparedPlan = (plan) => digestFirmwareUpdateContract(plan);
-const assertOpaqueLeaseRef = (value) => {
-    if (typeof value !== 'string' ||
-        value.length === 0 ||
-        value.length > 160 ||
-        value.includes('/') ||
-        value.includes('\\')) {
-        return preparedPlanError('Firmware prepared plan leaseRef must be opaque');
-    }
-    return value;
-};
-const getFirmwareUpdateResourceName = (value) => {
-    const normalized = typeof value === 'string' ? value.normalize('NFC') : undefined;
-    const parts = normalized === null || normalized === void 0 ? void 0 : normalized.split('/');
-    const resourceName = parts === null || parts === void 0 ? void 0 : parts.at(-1);
-    if (typeof value !== 'string' ||
-        value.length === 0 ||
-        value.length > 512 ||
-        value !== normalized ||
-        value.startsWith('/') ||
-        value.includes('\\') ||
-        value.includes(':') ||
-        [...value].some(char => {
-            const code = char.charCodeAt(0);
-            return code <= 0x1f || code === 0x7f;
-        }) ||
-        !(parts === null || parts === void 0 ? void 0 : parts.every(part => part.length > 0 &&
-            part !== '.' &&
-            part !== '..' &&
-            !part.endsWith('.') &&
-            !part.endsWith(' '))) ||
-        !resourceName ||
-        resourceName.length > 128) {
-        return preparedPlanError('Firmware prepared plan entry name is invalid');
-    }
-    return resourceName;
-};
-const assertPreparedEntry = (value) => {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return preparedPlanError('Firmware prepared plan entry must be an object');
-    }
-    const entry = value;
-    if (Object.keys(entry).length !== 2 ||
-        !Object.prototype.hasOwnProperty.call(entry, 'entryName') ||
-        !Object.prototype.hasOwnProperty.call(entry, 'artifact')) {
-        return preparedPlanError('Firmware prepared plan entry fields are invalid');
-    }
-    getFirmwareUpdateResourceName(entry.entryName);
-    assertFirmwareArtifactReference(entry.artifact);
-    return value;
-};
-const assertPreparedArtifacts = ({ plan, artifacts, }) => {
-    if (artifacts.length !== plan.artifacts.length) {
-        return preparedPlanError('Firmware prepared plan does not cover every artifact');
-    }
-    const inputs = new Map();
-    for (const input of artifacts) {
-        if (!input ||
-            typeof input !== 'object' ||
-            typeof input.artifactId !== 'string' ||
-            inputs.has(input.artifactId)) {
-            return preparedPlanError('Firmware prepared plan contains a duplicate artifact receipt');
-        }
-        inputs.set(input.artifactId, input);
-    }
-    return plan.artifacts.map(planArtifact => {
-        var _a;
-        const input = inputs.get(planArtifact.artifactId);
-        if (!input) {
-            return preparedPlanError('Firmware prepared plan artifact receipt is missing');
-        }
-        const artifact = assertFirmwareArtifactReference(input.artifact);
-        if ((planArtifact.expectedSize !== undefined && artifact.size !== planArtifact.expectedSize) ||
-            (planArtifact.expectedSha256 !== undefined &&
-                artifact.sha256.toLowerCase() !== planArtifact.expectedSha256.toLowerCase())) {
-            return preparedPlanError('Firmware prepared plan receipt does not match the update plan');
-        }
-        const materializedEntries = (_a = input.materializedEntries) === null || _a === void 0 ? void 0 : _a.map(value => {
-            const entry = assertPreparedEntry(value);
-            return {
-                entryName: entry.entryName,
-                artifact: Object.assign(Object.assign({}, entry.artifact), { sha256: entry.artifact.sha256.toLowerCase() }),
-            };
-        });
-        if ((planArtifact.container === 'raw' && (materializedEntries === null || materializedEntries === void 0 ? void 0 : materializedEntries.length)) ||
-            (planArtifact.container === 'zip' && !(materializedEntries === null || materializedEntries === void 0 ? void 0 : materializedEntries.length))) {
-            return preparedPlanError('Firmware prepared plan materialization is incomplete');
-        }
-        if (materializedEntries &&
-            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 } : {}));
-    });
-};
-const prepareFirmwareUpdatePlan = ({ plan: value, leaseRef, artifacts, }) => {
-    const plan = assertFirmwareUpdatePlan(value);
-    const planWithoutDigest = {
-        schemaVersion: 2,
-        planDigest: plan.planDigest,
-        networkPolicy: 'forbid',
-        executor: plan.executor,
-        deviceIdentity: plan.deviceIdentity,
-        deviceModel: plan.deviceModel,
-        firmwareType: plan.firmwareType,
-        platform: plan.platform,
-        leaseRef: assertOpaqueLeaseRef(leaseRef),
-        artifacts: assertPreparedArtifacts({ plan, artifacts }),
-        targetsToUpdate: plan.targetsToUpdate,
-    };
-    return Object.assign(Object.assign({}, planWithoutDigest), { preparedPlanDigest: digestPreparedPlan(planWithoutDigest) });
-};
-const validateFirmwareUpdatePreparedPlan = (value) => {
-    var _a, _b, _c;
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return preparedPlanError('Firmware prepared plan must be an object');
-    }
-    const preparedPlan = value;
-    const exactKeys = [
-        'schemaVersion',
-        'preparedPlanDigest',
-        'planDigest',
-        'networkPolicy',
-        'executor',
-        'deviceIdentity',
-        'deviceModel',
-        'firmwareType',
-        'platform',
-        'leaseRef',
-        'artifacts',
-        'targetsToUpdate',
-    ];
-    if (Object.keys(value).length !== exactKeys.length ||
-        exactKeys.some(key => !Object.prototype.hasOwnProperty.call(value, key)) ||
-        preparedPlan.schemaVersion !== 2 ||
-        preparedPlan.networkPolicy !== 'forbid' ||
-        !/^[a-f0-9]{64}$/u.test(preparedPlan.planDigest) ||
-        !/^[a-f0-9]{64}$/u.test(preparedPlan.preparedPlanDigest) ||
-        !Array.isArray(preparedPlan.artifacts) ||
-        !Array.isArray(preparedPlan.targetsToUpdate) ||
-        (preparedPlan.executor !== 'v2' &&
-            preparedPlan.executor !== 'v3' &&
-            preparedPlan.executor !== 'v4') ||
-        (preparedPlan.platform !== 'native' &&
-            preparedPlan.platform !== 'desktop' &&
-            preparedPlan.platform !== 'ext' &&
-            preparedPlan.platform !== 'web' &&
-            preparedPlan.platform !== 'web-embed') ||
-        (preparedPlan.firmwareType !== 'universal' && preparedPlan.firmwareType !== 'bitcoinonly') ||
-        typeof preparedPlan.deviceIdentity !== 'string' ||
-        preparedPlan.deviceIdentity.length === 0 ||
-        typeof preparedPlan.deviceModel !== 'string' ||
-        preparedPlan.deviceModel.length === 0) {
-        return preparedPlanError('Firmware prepared plan header is invalid');
-    }
-    assertOpaqueLeaseRef(preparedPlan.leaseRef);
-    const artifactIds = new Set();
-    const artifactTargets = new Set();
-    for (const artifact of preparedPlan.artifacts) {
-        if (!artifact || typeof artifact !== 'object') {
-            return preparedPlanError('Firmware prepared plan artifact is invalid');
-        }
-        const artifactKeys = [
-            'artifactId',
-            'role',
-            'target',
-            'container',
-            'artifact',
-            ...(artifact.logicalName !== undefined ? ['logicalName'] : []),
-            ...(artifact.targetVersion !== undefined ? ['targetVersion'] : []),
-            ...(artifact.materializedEntries !== undefined ? ['materializedEntries'] : []),
-        ];
-        if (typeof artifact.artifactId !== 'string' ||
-            artifact.artifactId.length === 0 ||
-            artifactIds.has(artifact.artifactId) ||
-            Object.keys(artifact).length !== artifactKeys.length ||
-            artifactKeys.some(key => !Object.prototype.hasOwnProperty.call(artifact, key)) ||
-            !FIRMWARE_UPDATE_PLAN_ROLES.has(artifact.role) ||
-            !FIRMWARE_UPDATE_PLAN_TARGETS.has(artifact.target) ||
-            (artifact.container !== 'raw' && artifact.container !== 'zip') ||
-            (artifact.logicalName !== undefined &&
-                (typeof artifact.logicalName !== 'string' || artifact.logicalName.length === 0)) ||
-            (artifact.targetVersion !== undefined &&
-                (typeof artifact.targetVersion !== 'string' || artifact.targetVersion.length === 0)) ||
-            (artifact.materializedEntries !== undefined &&
-                !Array.isArray(artifact.materializedEntries)) ||
-            (artifact.container === 'raw' && Boolean((_a = artifact.materializedEntries) === null || _a === void 0 ? void 0 : _a.length)) ||
-            (artifact.container === 'zip' && !((_b = artifact.materializedEntries) === null || _b === void 0 ? void 0 : _b.length))) {
-            return preparedPlanError('Firmware prepared plan artifact is invalid');
-        }
-        artifactIds.add(artifact.artifactId);
-        artifactTargets.add(artifact.target);
-        assertFirmwareArtifactReference(artifact.artifact);
-        (_c = artifact.materializedEntries) === null || _c === void 0 ? void 0 : _c.forEach(assertPreparedEntry);
-    }
-    if (preparedPlan.targetsToUpdate.some(target => !FIRMWARE_UPDATE_PLAN_TARGETS.has(target)) ||
-        new Set(preparedPlan.targetsToUpdate).size !== preparedPlan.targetsToUpdate.length ||
-        preparedPlan.targetsToUpdate.length !== artifactTargets.size ||
-        preparedPlan.targetsToUpdate.some(target => !artifactTargets.has(target))) {
-        return preparedPlanError('Firmware prepared plan targets are invalid');
-    }
-    const { preparedPlanDigest } = preparedPlan, withoutDigest = __rest(preparedPlan, ["preparedPlanDigest"]);
-    if (digestPreparedPlan(withoutDigest) !== preparedPlanDigest) {
-        return preparedPlanError('Firmware prepared plan digest is invalid');
-    }
-    return preparedPlan;
-};
-const assertFirmwareUpdatePreparedPlanDeviceIdentity = ({ preparedPlan: value, deviceIdentity, }) => {
-    const preparedPlan = validateFirmwareUpdatePreparedPlan(value);
-    if (!deviceIdentity || preparedPlan.deviceIdentity !== deviceIdentity) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError);
-    }
-    return preparedPlan;
-};
-const sameArtifactReference = (first, second) => first.artifactRef === second.artifactRef &&
-    first.size === second.size &&
-    first.sha256.toLowerCase() === second.sha256.toLowerCase();
-const assertFirmwareUpdatePreparedPlanBinding = ({ preparedPlan: value, executor, platform, deviceIdentity, scopeTargets, bindings, }) => {
-    var _a;
-    const preparedPlan = validateFirmwareUpdatePreparedPlan(value);
-    if (preparedPlan.executor !== executor ||
-        (platform !== undefined && preparedPlan.platform !== platform) ||
-        (deviceIdentity !== undefined && preparedPlan.deviceIdentity !== deviceIdentity)) {
-        return preparedPlanError('Firmware prepared plan executor binding is invalid');
-    }
-    const scope = new Set(scopeTargets);
-    const expectedBindings = [];
-    for (const artifact of preparedPlan.artifacts) {
-        if (scope.has(artifact.target)) {
-            if (artifact.container === 'zip') {
-                for (const entry of (_a = artifact.materializedEntries) !== null && _a !== void 0 ? _a : []) {
-                    expectedBindings.push(Object.assign(Object.assign({ target: artifact.target }, (artifact.target === 'resource' && artifact.logicalName
-                        ? { logicalName: artifact.logicalName }
-                        : {})), { entryName: entry.entryName, artifact: entry.artifact }));
-                }
-            }
-            else {
-                expectedBindings.push(Object.assign(Object.assign({ target: artifact.target }, (artifact.target === 'resource' && artifact.logicalName
-                    ? { logicalName: artifact.logicalName }
-                    : {})), { artifact: artifact.artifact }));
-            }
-        }
-    }
-    if (expectedBindings.length !== bindings.length ||
-        expectedBindings.some(expected => {
-            const matching = bindings.filter(binding => binding.target === expected.target &&
-                binding.logicalName === expected.logicalName &&
-                binding.entryName === expected.entryName &&
-                sameArtifactReference(binding.artifact, expected.artifact));
-            return matching.length !== 1;
-        })) {
-        return preparedPlanError('Firmware prepared plan artifact binding is invalid');
-    }
-    return preparedPlan;
-};
-
-const bindingError = (message) => {
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, message, {
-        firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
-    });
-};
-class FirmwareHostBindingRegistry {
-    constructor() {
-        this.generation = 0;
-    }
-    register(binding) {
-        var _a;
-        if (!binding ||
-            typeof ((_a = binding.artifactReader) === null || _a === void 0 ? void 0 : _a.open) !== 'function' ||
-            typeof binding.artifactReader.read !== 'function' ||
-            typeof binding.artifactReader.close !== 'function') {
-            return bindingError('Firmware host binding is invalid');
-        }
-        this.generation += 1;
-        this.binding = binding;
-        return this.generation;
-    }
-    unregister(generation) {
-        if (generation !== undefined && generation !== this.generation) {
-            return false;
-        }
-        this.generation += 1;
-        this.binding = undefined;
-        return true;
-    }
-    getGeneration() {
-        return this.generation;
-    }
-    resolve(generation) {
-        if (!Number.isSafeInteger(generation) ||
-            generation <= 0 ||
-            generation !== this.generation ||
-            !this.binding) {
-            return bindingError(`Firmware host binding generation ${generation} is stale`);
-        }
-        const { binding } = this;
-        const assertCurrent = () => {
-            if (generation !== this.generation || binding !== this.binding) {
-                bindingError(`Firmware host binding generation ${generation} is stale`);
-            }
-        };
-        return {
-            artifactReader: {
-                open: (input) => __awaiter(this, void 0, void 0, function* () {
-                    assertCurrent();
-                    const opened = yield binding.artifactReader.open(input);
-                    try {
-                        assertCurrent();
-                    }
-                    catch (error) {
-                        if (opened === null || opened === void 0 ? void 0 : opened.readerId) {
-                            yield binding.artifactReader
-                                .close({ readerId: opened.readerId })
-                                .catch(() => undefined);
-                        }
-                        throw error;
-                    }
-                    return opened;
-                }),
-                read: (input) => __awaiter(this, void 0, void 0, function* () {
-                    assertCurrent();
-                    const result = yield binding.artifactReader.read(input);
-                    assertCurrent();
-                    return result;
-                }),
-                close: input => binding.artifactReader.close(input),
-            },
-        };
-    }
-}
-const firmwareHostBindingRegistry = new FirmwareHostBindingRegistry();
-const registerFirmwareUpdateHostBinding = (binding) => firmwareHostBindingRegistry.register(binding);
-const unregisterFirmwareUpdateHostBinding = (generation) => firmwareHostBindingRegistry.unregister(generation);
-const getFirmwareUpdateHostBindingGeneration = () => firmwareHostBindingRegistry.getGeneration();
-const resolveFirmwareUpdateHostBinding = (generation) => firmwareHostBindingRegistry.resolve(generation !== null && generation !== void 0 ? generation : Number.NaN);
-
 const callbackManager = new Map();
 const generateCallbackId = () => `callback_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
 const registerCallback = (id, callback) => {
@@ -1220,22 +109,15 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, updateSettings, swi
         }, removeAllListeners: type => {
             eventEmitter.removeAllListeners(type);
         }, init,
-        call, dispose: () => __awaiter(void 0, void 0, void 0, function* () {
-            unregisterFirmwareUpdateHostBinding();
-            yield dispose();
-        }), uiResponse,
+        call,
+        dispose,
+        uiResponse,
         cancel,
         updateSettings,
         switchTransport }, createCoreApi(call));
     return api;
 };
 const createCoreApi = (call) => ({
-    getFirmwareUpdateCapabilities,
-    registerFirmwareUpdateHostBinding,
-    unregisterFirmwareUpdateHostBinding,
-    getFirmwareUpdateHostBindingGeneration,
-    prepareFirmwareUpdatePlan,
-    validateFirmwareUpdatePreparedPlan,
     getLogs: () => call({ method: 'getLogs' }),
     clearSessionCache: params => call(Object.assign(Object.assign({}, params), { method: 'clearSessionCache' })),
     searchDevices: params => call(Object.assign(Object.assign({}, params), { method: 'searchDevices' })),
@@ -1254,6 +136,7 @@ const createCoreApi = (call) => ({
     checkFirmwareTypeAvailable: params => call(Object.assign(Object.assign({}, params), { method: 'checkFirmwareTypeAvailable' })),
     cipherKeyValue: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'cipherKeyValue' })),
     testInitializeDeviceDuration: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'testInitializeDeviceDuration' })),
+    testProtocolV2Ping: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'testProtocolV2Ping' })),
     preInitialize: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'preInitialize' })),
     deviceBackup: connectId => call({ connectId, method: 'deviceBackup' }),
     deviceChangePin: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceChangePin' })),
@@ -1396,10 +279,9 @@ const lowLevelInject = ({ call, cancel, dispose, eventEmitter, init, uiResponse,
     const api = Object.assign({ addHardwareGlobalEventListener, removeAllListeners: type => {
             eventEmitter.removeAllListeners(type);
         }, init,
-        call, dispose: () => __awaiter(void 0, void 0, void 0, function* () {
-            unregisterFirmwareUpdateHostBinding();
-            yield dispose();
-        }), uiResponse,
+        call,
+        dispose,
+        uiResponse,
         cancel,
         updateSettings,
         switchTransport, emit: () => { } }, createCoreApi(call));
@@ -1903,10 +785,7 @@ const topLevelInject = () => {
         }, call }, createCoreApi(call)), { removeAllListeners: type => {
             eventEmitter.removeAllListeners(type);
             lowLevelApi === null || lowLevelApi === void 0 ? void 0 : lowLevelApi.removeAllListeners(type);
-        }, dispose: () => __awaiter(void 0, void 0, void 0, function* () {
-            unregisterFirmwareUpdateHostBinding();
-            yield (lowLevelApi === null || lowLevelApi === void 0 ? void 0 : lowLevelApi.dispose());
-        }), uiResponse: response => lowLevelApi === null || lowLevelApi === void 0 ? void 0 : lowLevelApi.uiResponse(response), cancel: (connectId) => lowLevelApi === null || lowLevelApi === void 0 ? void 0 : lowLevelApi.cancel(connectId), updateSettings: settings => { var _a; return (_a = lowLevelApi === null || lowLevelApi === void 0 ? void 0 : lowLevelApi.updateSettings(settings)) !== null && _a !== void 0 ? _a : Promise.resolve(false); }, switchTransport: (env) => { var _a; return (_a = lowLevelApi === null || lowLevelApi === void 0 ? void 0 : lowLevelApi.switchTransport(env)) !== null && _a !== void 0 ? _a : Promise.resolve({ success: false }); } });
+        }, dispose: () => lowLevelApi === null || lowLevelApi === void 0 ? void 0 : lowLevelApi.dispose(), uiResponse: response => lowLevelApi === null || lowLevelApi === void 0 ? void 0 : lowLevelApi.uiResponse(response), cancel: (connectId) => lowLevelApi === null || lowLevelApi === void 0 ? void 0 : lowLevelApi.cancel(connectId), updateSettings: settings => { var _a; return (_a = lowLevelApi === null || lowLevelApi === void 0 ? void 0 : lowLevelApi.updateSettings(settings)) !== null && _a !== void 0 ? _a : Promise.resolve(false); }, switchTransport: (env) => { var _a; return (_a = lowLevelApi === null || lowLevelApi === void 0 ? void 0 : lowLevelApi.switchTransport(env)) !== null && _a !== void 0 ? _a : Promise.resolve({ success: false }); } });
     return api;
 };
 
@@ -2474,6 +1353,221 @@ function cleanupSdkInstance(sdkInstanceId) {
     }
 }
 
+exports.EOneKeyDeviceMode = void 0;
+(function (EOneKeyDeviceMode) {
+    EOneKeyDeviceMode["bootloader"] = "bootloader";
+    EOneKeyDeviceMode["normal"] = "normal";
+    EOneKeyDeviceMode["notInitialized"] = "notInitialized";
+    EOneKeyDeviceMode["backupMode"] = "backupMode";
+})(exports.EOneKeyDeviceMode || (exports.EOneKeyDeviceMode = {}));
+const DeviceModelToTypes = {
+    model_mini: [
+        hdShared.EDeviceType.Classic,
+        hdShared.EDeviceType.Classic1s,
+        hdShared.EDeviceType.ClassicPure,
+        hdShared.EDeviceType.Mini,
+    ],
+    model_touch: [hdShared.EDeviceType.Touch, hdShared.EDeviceType.Pro],
+    model_classic: [hdShared.EDeviceType.Classic, hdShared.EDeviceType.Classic1s, hdShared.EDeviceType.ClassicPure],
+    model_classic1s: [hdShared.EDeviceType.Classic1s, hdShared.EDeviceType.ClassicPure],
+};
+const DeviceTypeToModels = {
+    [hdShared.EDeviceType.Classic]: ['model_classic', 'model_mini'],
+    [hdShared.EDeviceType.Classic1s]: ['model_classic', 'model_mini', 'model_classic1s'],
+    [hdShared.EDeviceType.ClassicPure]: ['model_classic', 'model_mini', 'model_classic1s'],
+    [hdShared.EDeviceType.Mini]: ['model_mini'],
+    [hdShared.EDeviceType.Touch]: ['model_touch'],
+    [hdShared.EDeviceType.Pro]: ['model_touch'],
+    [hdShared.EDeviceType.Pro2]: [],
+    [hdShared.EDeviceType.Unknown]: [],
+};
+
+const asCompatibleFeatures = (features) => features;
+const firstNonEmptyString = (...values) => values.find(value => typeof value === 'string' && value.length > 0);
+const firstMeaningfulVersion$1 = (...versions) => { var _a; return (_a = versions.find(version => Boolean(version && version !== '0.0.0'))) !== null && _a !== void 0 ? _a : null; };
+const versionFromParts = (major, minor, patch) => [major, minor, patch].map(part => Number(part) || 0).join('.');
+const resolveDeviceSerialNo = (features) => {
+    var _a;
+    if (!features)
+        return '';
+    const compatible = asCompatibleFeatures(features);
+    return ((_a = firstNonEmptyString(compatible.serialNo, compatible.onekey_serial_no, compatible.onekey_serial, compatible.serial_no)) !== null && _a !== void 0 ? _a : '');
+};
+const resolveDeviceType = (features) => {
+    var _a, _b, _c, _d;
+    if (!features || typeof features !== 'object') {
+        return hdShared.EDeviceType.Unknown;
+    }
+    const compatible = asCompatibleFeatures(features);
+    if (compatible.deviceType && compatible.deviceType !== hdShared.EDeviceType.Unknown) {
+        return compatible.deviceType;
+    }
+    switch ((_a = compatible.onekey_device_type) === null || _a === void 0 ? void 0 : _a.toString().toUpperCase()) {
+        case 'CLASSIC':
+            return hdShared.EDeviceType.Classic;
+        case 'CLASSIC1S':
+            return hdShared.EDeviceType.Classic1s;
+        case 'MINI':
+            return hdShared.EDeviceType.Mini;
+        case 'TOUCH':
+            return hdShared.EDeviceType.Touch;
+        case 'PRO':
+            return hdShared.EDeviceType.Pro;
+        case 'PRO2':
+            return hdShared.EDeviceType.Pro2;
+        case 'PURE':
+            return hdShared.EDeviceType.ClassicPure;
+    }
+    if (((_b = compatible.model) === null || _b === void 0 ? void 0 : _b.toString().toLowerCase()) === hdShared.EDeviceType.Pro2) {
+        return hdShared.EDeviceType.Pro2;
+    }
+    const serialNo = resolveDeviceSerialNo(features);
+    const prefix = serialNo.slice(0, 2).toLowerCase();
+    if (prefix === 'bi' || prefix === 'cl')
+        return hdShared.EDeviceType.Classic;
+    if (prefix === 'cp')
+        return hdShared.EDeviceType.ClassicPure;
+    if (prefix === 'mi')
+        return hdShared.EDeviceType.Mini;
+    if (prefix === 'tc')
+        return hdShared.EDeviceType.Touch;
+    if (prefix === 'pr')
+        return hdShared.EDeviceType.Pro;
+    if (prefix === 'p2')
+        return hdShared.EDeviceType.Pro2;
+    const bootloaderMode = (_c = compatible.bootloaderMode) !== null && _c !== void 0 ? _c : compatible.bootloader_mode;
+    if (!serialNo && bootloaderMode === true && compatible.model === '1') {
+        return hdShared.EDeviceType.Classic;
+    }
+    return (_d = compatible.deviceType) !== null && _d !== void 0 ? _d : hdShared.EDeviceType.Unknown;
+};
+const resolveDeviceFirmwareType = (features) => {
+    if (!features) {
+        return hdShared.EFirmwareType.Universal;
+    }
+    const compatible = asCompatibleFeatures(features);
+    if (compatible.firmwareType) {
+        return compatible.firmwareType;
+    }
+    if (compatible.fw_vendor === 'OneKey Bitcoin-only') {
+        return hdShared.EFirmwareType.BitcoinOnly;
+    }
+    const capabilities = compatible.capabilities;
+    const supportsBitcoinLike = capabilities === null || capabilities === void 0 ? void 0 : capabilities.some(capability => capability === hdTransport.Enum_Capability.Capability_Bitcoin_like ||
+        capability === 'Capability_Bitcoin_like');
+    return (capabilities === null || capabilities === void 0 ? void 0 : capabilities.length) && !supportsBitcoinLike
+        ? hdShared.EFirmwareType.BitcoinOnly
+        : hdShared.EFirmwareType.Universal;
+};
+const resolveDeviceBleName = (features) => {
+    var _a;
+    if (!features)
+        return null;
+    const compatible = asCompatibleFeatures(features);
+    return ((_a = firstNonEmptyString(compatible.bleName, compatible.onekey_ble_name, compatible.ble_name)) !== null && _a !== void 0 ? _a : null);
+};
+const resolveDeviceFirmwareVersion = (features) => {
+    if (!features)
+        return null;
+    const compatible = asCompatibleFeatures(features);
+    return firstMeaningfulVersion$1(compatible.firmwareVersion, compatible.onekey_firmware_version, compatible.onekey_version, versionFromParts(compatible.major_version, compatible.minor_version, compatible.patch_version));
+};
+const resolveDeviceBootloaderVersion = (features) => {
+    var _a;
+    if (!features)
+        return null;
+    const compatible = asCompatibleFeatures(features);
+    const bootloaderMode = (_a = compatible.bootloaderMode) !== null && _a !== void 0 ? _a : compatible.bootloader_mode;
+    return firstMeaningfulVersion$1(compatible.bootloaderVersion, compatible.onekey_boot_version, compatible.bootloader_version, compatible.onekey_bootloader_version, bootloaderMode
+        ? versionFromParts(compatible.major_version, compatible.minor_version, compatible.patch_version)
+        : null);
+};
+const resolveDeviceBoardVersion = (features) => {
+    if (!features)
+        return null;
+    const compatible = asCompatibleFeatures(features);
+    return firstMeaningfulVersion$1(compatible.boardVersion, compatible.onekey_board_version, compatible.boardloader_version, compatible.onekey_romloader_version, compatible.romloader_version);
+};
+const resolveDeviceBleFirmwareVersion = (features) => {
+    if (!features)
+        return null;
+    const compatible = asCompatibleFeatures(features);
+    return firstMeaningfulVersion$1(compatible.bleVersion, compatible.onekey_ble_version, compatible.ble_ver, compatible.onekey_coprocessor_version);
+};
+
+const getDeviceType = (features) => resolveDeviceType(features);
+const getDeviceTypeByBleName = (name) => {
+    if (!name)
+        return hdShared.EDeviceType.Unknown;
+    if (/^BixinKey/i.test(name))
+        return hdShared.EDeviceType.Classic;
+    if (/^K/i.test(name))
+        return hdShared.EDeviceType.Classic;
+    if (/^T/i.test(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))
+        return hdShared.EDeviceType.Pro2;
+    if (/\bPro\b/i.test(name) || /^Pro/i.test(name))
+        return hdShared.EDeviceType.Pro;
+    return hdShared.EDeviceType.Unknown;
+};
+const getDeviceBleName = (features) => resolveDeviceBleName(features);
+const getDeviceSerialNo = (features) => resolveDeviceSerialNo(features);
+const getDeviceUUID = getDeviceSerialNo;
+const getDeviceLabel = (features) => {
+    if (!features)
+        return null;
+    const deviceType = getDeviceType(features);
+    if (deviceType == null)
+        return null;
+    if ('label' in features && typeof features.label === 'string' && features.label.length > 0) {
+        return features.label;
+    }
+    const bleName = getDeviceBleName(features);
+    if (bleName)
+        return bleName;
+    if (deviceType === hdShared.EDeviceType.ClassicPure) {
+        return 'OneKey Classic 1S';
+    }
+    return `OneKey ${deviceType.charAt(0).toUpperCase() + deviceType.slice(1)}`;
+};
+const getMethodVersionRange = (features, getVersionRange) => {
+    const deviceType = getDeviceType(features);
+    const versionRange = getVersionRange(deviceType);
+    if (versionRange) {
+        return versionRange;
+    }
+    const modelFallbacks = [
+        'model_classic1s',
+        'model_classic',
+        'model_mini',
+        'model_touch',
+    ];
+    for (const model of modelFallbacks) {
+        if (DeviceModelToTypes[model].includes(deviceType)) {
+            const versionRange = getVersionRange(model);
+            if (versionRange) {
+                return versionRange;
+            }
+        }
+    }
+    return undefined;
+};
+const isMethodVersionRangeUnsupported = (versionRange) => (versionRange === null || versionRange === void 0 ? void 0 : versionRange.unsupported) === true;
+const getFirmwareType = (features) => resolveDeviceFirmwareType(features);
+
+const EMPTY_VERSION = [0, 0, 0];
+const parseDeviceVersion = (version) => {
+    const parsed = version ? semver__default["default"].parse(version) : null;
+    return parsed ? [parsed.major, parsed.minor, parsed.patch] : [...EMPTY_VERSION];
+};
+const getDeviceFirmwareVersion = (features) => parseDeviceVersion(resolveDeviceFirmwareVersion(features));
+const getDeviceBootloaderVersion = (features) => parseDeviceVersion(resolveDeviceBootloaderVersion(features));
+const getDeviceBoardloaderVersion = (features) => parseDeviceVersion(resolveDeviceBoardVersion(features));
+const getDeviceBLEFirmwareVersion = (features) => parseDeviceVersion(resolveDeviceBleFirmwareVersion(features));
+
 const HD_HARDENED = 0x80000000;
 const toHardened = (n) => (n | HD_HARDENED) >>> 0;
 const fromHardened = (n) => (n & ~HD_HARDENED) >>> 0;
@@ -38249,6 +37343,33 @@ var nested = {
 			}
 		}
 	},
+	UiAnimationType: {
+		values: {
+			Unknown: 0,
+			Signing: 1
+		}
+	},
+	UiAnimationCommand: {
+		values: {
+			CommandUnknown: 0,
+			Start: 1,
+			Stop: 2,
+			Refresh: 3
+		}
+	},
+	UiAnimationRequest: {
+		fields: {
+			command: {
+				rule: "required",
+				type: "UiAnimationCommand",
+				id: 1
+			},
+			type: {
+				type: "UiAnimationType",
+				id: 2
+			}
+		}
+	},
 	ViewAmount: {
 		fields: {
 			is_unlimited: {
@@ -39230,6 +38351,10 @@ var nested = {
 	},
 	DeviceSessionAskPassphrase: {
 		fields: {
+			passphrase: {
+				type: "string",
+				id: 1
+			}
 		}
 	},
 	DeviceSessionAskPin_FailureSubCodes: {
@@ -40404,19 +39529,9 @@ class DataManager {
         return enrichedData;
     }
     static load(settings) {
-        var _b;
         return __awaiter(this, void 0, void 0, function* () {
             this.settings = settings;
-            const manifestMode = (_b = settings.firmwareManifestMode) !== null && _b !== void 0 ? _b : (settings.fetchConfig ? 'sdk-managed' : undefined);
-            if (settings.preloadedConfig) {
-                this.applyRemoteConfig(settings.preloadedConfig);
-                Log$i.log('[DataConfig] Preloaded firmware config loaded');
-                return;
-            }
-            if (manifestMode === 'external-only') {
-                throw new Error('External firmware config snapshot is required');
-            }
-            if (manifestMode !== 'sdk-managed') {
+            if (!settings.fetchConfig) {
                 return;
             }
             const url = settings.preRelease
@@ -40424,50 +39539,57 @@ class DataManager {
                 : 'https://data.onekey.so/config.json';
             const urlWithCache = `${url}?noCache=${getTimeStamp()}`;
             let data = null;
+            let fetchMethod = 'none';
             if (settings.configFetcher) {
-                Log$i.debug('[DataConfig] Trying client configFetcher...');
+                Log$i.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
                 try {
                     data = yield settings.configFetcher(urlWithCache);
+                    if (data) {
+                        fetchMethod = 'configFetcher';
+                        Log$i.log('[DataConfig] ConfigFetcher success');
+                    }
+                    else {
+                        Log$i.debug('[DataConfig] ConfigFetcher returned null, will fallback to axios');
+                    }
                 }
                 catch (e) {
-                    Log$i.warn('[DataConfig] Client configFetcher failed:', e);
+                    Log$i.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
                 }
             }
             if (!data) {
-                Log$i.debug('[DataConfig] Trying SDK-managed config request...');
+                Log$i.debug('[DataConfig] Trying axios (SDK default fetcher)...');
                 try {
                     const response = yield axios__default["default"].get(urlWithCache, {
                         timeout: 7000,
                     });
                     data = response.data;
-                    Log$i.log('[DataConfig] SDK-managed config request succeeded');
+                    fetchMethod = 'axios';
+                    Log$i.log('[DataConfig] Axios fetch success');
                 }
                 catch (e) {
-                    Log$i.warn('[DataConfig] SDK-managed config request failed:', e);
+                    Log$i.warn('[DataConfig] Axios fetch error:', e);
                 }
             }
             if (data) {
-                this.applyRemoteConfig(data);
+                Log$i.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
+                this.deviceMap = {
+                    [hdShared.EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
+                    [hdShared.EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
+                    [hdShared.EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
+                    [hdShared.EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
+                    [hdShared.EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
+                    [hdShared.EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
+                    [hdShared.EDeviceType.Pro2]: this.enrichFirmwareReleaseInfo(data.pro2),
+                };
+                this.assets = {
+                    bridge: data.bridge,
+                };
             }
             else {
-                Log$i.warn('[DataConfig] SDK-managed config request failed, using built-in default config');
+                Log$i.warn('[DataConfig] All fetch methods failed, using built-in default config');
             }
         });
     }
-    static applyRemoteConfig(data) {
-        this.deviceMap = {
-            [hdShared.EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
-            [hdShared.EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
-            [hdShared.EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
-            [hdShared.EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
-            [hdShared.EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
-            [hdShared.EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
-            [hdShared.EDeviceType.Pro2]: this.enrichFirmwareReleaseInfo(data.pro2),
-        };
-        this.assets = {
-            bridge: data.bridge,
-        };
-    }
     static updateEnv(newEnv) {
         if (this.settings) {
             const prevEnv = this.settings.env;
@@ -40963,10 +40085,8 @@ const getDeviceSession = (device, request) => __awaiter(void 0, void 0, void 0,
         return device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
     }
 });
-const askDevicePassphrase = (device) => __awaiter(void 0, void 0, void 0, function* () {
-    const request = () => device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', {}, {
-        timeoutMs: 120000,
-    });
+const askDevicePassphrase = (device, passphrase) => __awaiter(void 0, void 0, void 0, function* () {
+    const request = () => device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', passphrase ? { passphrase } : {});
     try {
         return yield request();
     }
@@ -40985,7 +40105,7 @@ const selectDeviceSession = (device) => __awaiter(void 0, void 0, void 0, functi
         source: 'wallet-session-coordinator',
         reason: 'open-wallet',
     };
-    const response = yield device.commands.promptPassphrase(Object.assign({ existsAttachPinUser, deviceOnly: true }, metadata), { cancelDeviceOnReject: false });
+    const response = yield device.commands.promptPassphrase(Object.assign({ existsAttachPinUser }, metadata), { cancelDeviceOnReject: false });
     const hasHostPassphrase = typeof response.passphrase === 'string' && response.passphrase.length > 0;
     const selections = [
         hasHostPassphrase,
@@ -41003,6 +40123,10 @@ const selectDeviceSession = (device) => __awaiter(void 0, void 0, void 0, functi
         yield device.unlockDevice(hdTransport.DeviceSessionPinType.AttachToPin);
         return getDeviceSession(device, {});
     }
+    if (hasHostPassphrase) {
+        yield askDevicePassphrase(device, response.passphrase);
+        return getDeviceSession(device, {});
+    }
     device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
     yield askDevicePassphrase(device);
     return getDeviceSession(device, {});
@@ -41046,6 +40170,10 @@ function getProtocolV2WalletSession(device, options) {
             }
         }
         if (!response) {
+            if (options === null || options === void 0 ? void 0 : options.resumeOnly) {
+                device.clearInternalState();
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.WalletSessionInvalid);
+            }
             response = yield selectDeviceSession(device);
         }
         const { message } = response;
@@ -41069,6 +40197,14 @@ function getProtocolV2WalletSession(device, options) {
         };
     });
 }
+function restoreProtocolV2WalletSession(device, expectedPassphraseState) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return getProtocolV2WalletSession(device, {
+            expectedPassphraseState,
+            resumeOnly: true,
+        });
+    });
+}
 
 const getSupportProtocolV1MessageSchema = (features) => {
     var _a;
@@ -41404,16 +40540,9 @@ const parseConnectSettings = (input = {}) => {
     if (input.fetchConfig) {
         settings.fetchConfig = input.fetchConfig;
     }
-    if (input.firmwareManifestMode === 'sdk-managed' ||
-        input.firmwareManifestMode === 'external-only') {
-        settings.firmwareManifestMode = input.firmwareManifestMode;
-    }
     if (input.configFetcher) {
         settings.configFetcher = input.configFetcher;
     }
-    if (input.preloadedConfig) {
-        settings.preloadedConfig = input.preloadedConfig;
-    }
     return settings;
 };
 
@@ -41476,7 +40605,8 @@ function checkNeedUpdateBootForClassicAndMini({ features, willUpdateFirmware, fi
     });
 }
 const INIT_DATA_CHUNK_SIZE$1 = 16 * 1024;
-const readBootloaderLength = (chunk) => {
+function checkBootloaderLength(data) {
+    const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE$1, data.byteLength)));
     const buffer = ByteBuffer__default["default"].wrap(chunk, undefined, undefined, true);
     buffer.LE();
     buffer.readByte();
@@ -41486,22 +40616,9 @@ const readBootloaderLength = (chunk) => {
     const hdrlen = buffer.readUint32();
     buffer.readUint32();
     const codelen = buffer.readUint32();
-    return hdrlen + codelen;
-};
-function checkBootloaderLength(data) {
-    if (data.byteLength < 16) {
-        return false;
-    }
-    const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE$1, data.byteLength)));
-    return readBootloaderLength(chunk) === data.byteLength;
+    const bootloaderLength = hdrlen + codelen;
+    return bootloaderLength === data.byteLength;
 }
-const checkBootloaderSourceLength = (source) => __awaiter(void 0, void 0, void 0, function* () {
-    if (source.size < 16) {
-        return false;
-    }
-    const chunk = new Uint8Array(yield source.readAt(0, Math.min(INIT_DATA_CHUNK_SIZE$1, source.size)));
-    return readBootloaderLength(chunk) === source.size;
-});
 
 const DEVICE_SETTINGS_SHARED_FIELDS = [
     'language',
@@ -42824,6 +41941,23 @@ class DeviceCommands {
                         firmwareMessage: message,
                     });
                 }
+                else if (DEVICE_SESSION_CALLS.has(callType) &&
+                    (subcode === hdTransport.DeviceSessionErrorCode.DeviceSessionError_Busy ||
+                        /^(?:busy|another flow in progress)$/i.test(normalizedMessage))) {
+                    error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceBusy, message, {
+                        failureCode: code,
+                        subcode,
+                        firmwareMessage: message,
+                    });
+                }
+                else if (callType === 'DeviceSessionAskPin' &&
+                    /^passphrase disabled$/i.test(normalizedMessage)) {
+                    error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotOpenedPassphrase, message, {
+                        failureCode: code,
+                        subcode,
+                        firmwareMessage: message,
+                    });
+                }
                 else if (subcode === hdTransport.DeviceErrorCode.DeviceError_ActionCancelled ||
                     isLegacyProtocolV2ActionCancelledFailure) {
                     error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ActionCancelled, message, {
@@ -43835,6 +42969,10 @@ class Device extends events.exports {
         const env = DataManager.getSettings('env');
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             if (DataManager.isBleConnect(env)) {
+                if (this.hasDeviceAcquire() && this.commands && !this.commands.disposed) {
+                    resolve(true);
+                    return;
+                }
                 try {
                     yield this.acquire(connectProtocol);
                     resolve(true);
@@ -44415,6 +43553,7 @@ class Device extends events.exports {
         return this.updateProtocolV2Features(previousDeviceInfo, Object.assign(Object.assign({}, previousStatus), status));
     }
     markTransportDisconnected() {
+        this.deviceAcquired = false;
         if (!this.isProtocolV2())
             return;
         this.protocolV2StateNeedsReload = true;
@@ -44665,7 +43804,7 @@ class Device extends events.exports {
     isUsedHere() {
         const env = DataManager.getSettings('env');
         if (DataManager.isBleConnect(env)) {
-            return false;
+            return this.deviceAcquired;
         }
         return this.isUsed() && this.originalDescriptor.session === this.mainId;
     }
@@ -44734,9 +43873,7 @@ class Device extends events.exports {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isProtocolV2()) {
                 try {
-                    yield this.commands.typedCall('DeviceSessionAskPin', 'Success', { type: pinType }, {
-                        timeoutMs: 120000,
-                    });
+                    yield this.commands.typedCall('DeviceSessionAskPin', 'Success', { type: pinType });
                 }
                 catch (error) {
                     const errorText = error instanceof Error
@@ -45241,6 +44378,46 @@ class TestInitializeDeviceDuration extends BaseMethod {
     }
 }
 
+const PROTOCOL_V2_PING_MAX_MESSAGE_BYTES = 63;
+const getUtf8ByteLength$1 = (value) => Array.from(value).reduce((length, character) => {
+    var _a;
+    const codePoint = (_a = character.codePointAt(0)) !== null && _a !== void 0 ? _a : 0;
+    if (codePoint <= 0x7f)
+        return length + 1;
+    if (codePoint <= 0x7ff)
+        return length + 2;
+    if (codePoint <= 0xffff)
+        return length + 3;
+    return length + 4;
+}, 0);
+function validateProtocolV2PingMessage(value) {
+    if (value !== undefined && typeof value !== 'string') {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Protocol V2 Ping message must be a string.');
+    }
+    const message = value !== null && value !== void 0 ? value : '';
+    if (getUtf8ByteLength$1(message) > PROTOCOL_V2_PING_MAX_MESSAGE_BYTES) {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Protocol V2 Ping message must not exceed ${PROTOCOL_V2_PING_MAX_MESSAGE_BYTES} UTF-8 bytes.`);
+    }
+    return message;
+}
+class Ping extends BaseMethod {
+    init() {
+        this.requireProtocolV2 = true;
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = { message: validateProtocolV2PingMessage(this.payload.message) };
+    }
+    run() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('Ping', 'Success', {
+                message: (_a = this.params.message) !== null && _a !== void 0 ? _a : '',
+            });
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
 const Log$c = getLogger(exports.LoggerNames.Core);
 const parseInitOptions$1 = (payload) => ({
     initSession: payload === null || payload === void 0 ? void 0 : payload.initSession,
@@ -45629,12 +44806,6 @@ const requiredString = (value, name) => {
     }
     return value.trim();
 };
-const optionalBoolean = (value, name) => {
-    if (value !== undefined && typeof value !== 'boolean') {
-        throw invalidParameter$1(`Parameter [${name}] must be a boolean.`);
-    }
-    return value;
-};
 const wasResumed = (session) => !!session &&
     typeof session === 'object' &&
     'resumed' in session &&
@@ -45647,49 +44818,22 @@ const requireHiddenWalletResponse = (session) => {
     return Object.assign({ passphraseState: session.passphraseState }, forwardSessionId(session));
 };
 const normalizeParams = (payload) => {
-    if (payload.mode !== undefined) {
-        if (payload.mode !== 'standard' &&
-            payload.mode !== 'select-hidden' &&
-            payload.mode !== 'resume-hidden') {
-            throw invalidParameter$1('Parameter [mode] must be one of standard, select-hidden, or resume-hidden.');
-        }
-        if (payload.useEmptyPassphrase !== undefined || payload.initSession !== undefined) {
-            throw invalidParameter$1('Parameters [useEmptyPassphrase] and [initSession] cannot be used with [mode].');
-        }
-        if (payload.mode === 'standard' || payload.mode === 'select-hidden') {
-            if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
-                throw invalidParameter$1('Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].');
-            }
-            return { mode: payload.mode };
-        }
-        return {
-            mode: 'resume-hidden',
-            deviceId: requiredString(payload.deviceId, 'deviceId'),
-            passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
-        };
+    if (payload.mode === undefined) {
+        throw invalidParameter$1('Parameter [mode] is required.');
     }
-    const useEmptyPassphrase = optionalBoolean(payload.useEmptyPassphrase, 'useEmptyPassphrase');
-    const initSession = optionalBoolean(payload.initSession, 'initSession');
-    if (useEmptyPassphrase === true) {
-        return { mode: 'standard' };
+    if (payload.mode !== 'standard' &&
+        payload.mode !== 'select-hidden' &&
+        payload.mode !== 'resume-hidden') {
+        throw invalidParameter$1('Parameter [mode] must be one of standard, select-hidden, or resume-hidden.');
     }
-    if (initSession === true) {
-        const deviceId = payload.deviceId === undefined ? undefined : requiredString(payload.deviceId, 'deviceId');
-        const passphraseState = payload.passphraseState === undefined
-            ? undefined
-            : requiredString(payload.passphraseState, 'passphraseState');
-        return Object.assign({ mode: 'select-hidden' }, (passphraseState
-            ? {
-                legacySessionToClear: {
-                    deviceId,
-                    passphraseState,
-                },
-            }
-            : {}));
+    if (payload.useEmptyPassphrase !== undefined || payload.initSession !== undefined) {
+        throw invalidParameter$1('Legacy parameters [useEmptyPassphrase] and [initSession] are not supported by openWalletSession.');
     }
-    const hasWalletBinding = payload.deviceId !== undefined || payload.passphraseState !== undefined;
-    if (!hasWalletBinding) {
-        return { mode: 'select-hidden' };
+    if (payload.mode === 'standard' || payload.mode === 'select-hidden') {
+        if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
+            throw invalidParameter$1('Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].');
+        }
+        return { mode: payload.mode };
     }
     return {
         mode: 'resume-hidden',
@@ -45710,29 +44854,17 @@ class OpenWalletSession extends BaseMethod {
             const isProtocolV2 = this.device.isProtocolV2();
             const state = yield this.device.getDeviceState({ refreshSections: ['status'] });
             let currentDeviceId = state.identity.deviceId;
-            const { legacySessionToClear } = this.params;
             const requireDeviceId = () => {
                 if (!currentDeviceId) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed);
                 }
                 return currentDeviceId;
             };
-            const clearLegacySession = () => {
-                const deviceId = requireDeviceId();
-                if (legacySessionToClear &&
-                    (!legacySessionToClear.deviceId || legacySessionToClear.deviceId === deviceId)) {
-                    deviceWalletSessionStore.delete(deviceId, legacySessionToClear.passphraseState);
-                }
-            };
             const refreshProtocolV2DeviceId = () => __awaiter(this, void 0, void 0, function* () {
                 const refreshedState = yield this.device.getDeviceState({ refreshSections: ['status'] });
                 currentDeviceId = refreshedState.identity.deviceId;
-                clearLegacySession();
                 return requireDeviceId();
             });
-            if (!isProtocolV2) {
-                clearLegacySession();
-            }
             const protocol = isProtocolV2 ? 'V2' : 'V1';
             if (this.params.mode === 'standard') {
                 this.device.passphraseState = undefined;
@@ -46049,7 +45181,8 @@ class CheckAllFirmwareRelease extends BaseMethod {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const { features } = this.device;
-            const { checkBridgeRelease, firmwareType: firmwareTypeParams, platform, } = this.payload;
+            const { checkBridgeRelease, firmwareType: firmwareTypeParams } = this
+                .payload;
             if (!features) {
                 return Promise.resolve(null);
             }
@@ -46074,20 +45207,6 @@ class CheckAllFirmwareRelease extends BaseMethod {
                 firmwareType,
             });
             const bleFirmwareReleaseInfo = getBleFirmwareReleaseInfo(features);
-            let firmwareUpdatePlan;
-            try {
-                firmwareUpdatePlan = buildFirmwareUpdatePlan({
-                    features,
-                    firmwareType,
-                    platform: platform !== null && platform !== void 0 ? platform : 'web',
-                    firmware: firmwareRelease,
-                    ble: bleFirmwareReleaseInfo,
-                    bootloader: bootloaderRelease,
-                });
-            }
-            catch (_c) {
-                firmwareUpdatePlan = undefined;
-            }
             return {
                 firmware: firmwareRelease,
                 bootloader: bootloaderRelease,
@@ -46101,7 +45220,6 @@ class CheckAllFirmwareRelease extends BaseMethod {
                     }
                     : undefined,
                 features,
-                firmwareUpdatePlan,
             };
         });
     }
@@ -46985,13 +46103,7 @@ const waitBleInstall = (updateType) => __awaiter(void 0, void 0, void 0, functio
         yield wait(10 * 1000);
     }
 });
-const toArrayBuffer$1 = (payload) => {
-    if (payload instanceof ArrayBuffer) {
-        return payload;
-    }
-    return new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength).slice().buffer;
-};
-const uploadFirmwareFromSource = (updateType, typedCall, postMessage, device, source, rebootOnSuccess, isUpdateBootloader) => __awaiter(void 0, void 0, void 0, function* () {
+const uploadFirmware = (updateType, typedCall, postMessage, device, { payload, rebootOnSuccess, }, isUpdateBootloader) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
     const deviceType = device.getCurrentDeviceType();
     if (DeviceModelToTypes.model_mini.includes(deviceType)) {
@@ -47005,15 +46117,15 @@ const uploadFirmwareFromSource = (updateType, typedCall, postMessage, device, so
             Log$a.debug('supportUpgradeFileHeader:', supportUpgradeFileHeader);
             if (supportUpgradeFileHeader) {
                 const HEADER_SIZE = 1024;
-                if (source.size < HEADER_SIZE) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `firmware payload too small: ${source.size} bytes, expected at least ${HEADER_SIZE} bytes`);
+                if (payload.byteLength < HEADER_SIZE) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `firmware payload too small: ${payload.byteLength} bytes, expected at least ${HEADER_SIZE} bytes`);
                 }
                 Log$a.debug('Uploading firmware header:', {
                     size: HEADER_SIZE,
-                    totalSize: source.size,
+                    totalSize: payload.byteLength,
                 });
                 postProgressTip(device, 'UploadingFirmwareHeader', postMessage);
-                const header = new Uint8Array(yield source.readAt(0, HEADER_SIZE));
+                const header = new Uint8Array(payload.slice(0, HEADER_SIZE));
                 try {
                     const headerRes = yield typedCall('UpgradeFileHeader', 'Success', {
                         data: bytesToHex$1(header),
@@ -47043,7 +46155,6 @@ const uploadFirmwareFromSource = (updateType, typedCall, postMessage, device, so
         postProgressMessage(device, 0, 'installingFirmware', postMessage);
         let updateResponse;
         try {
-            const payload = yield readFirmwareByteSourceFully(source);
             updateResponse = yield typedCall('FirmwareUpload', 'Success', {
                 payload,
             });
@@ -47071,19 +46182,21 @@ const uploadFirmwareFromSource = (updateType, typedCall, postMessage, device, so
         if (device.features) {
             const bootloaderVersion = getDeviceBootloaderVersion(device.features);
             if (semver__default["default"].gte(bootloaderVersion.join('.'), NEW_BOOT_UPRATE_FIRMWARE_VERSION)) {
-                const response = yield newTouchUpdateProcess(updateType, postMessage, device, source, rebootOnSuccess);
+                const response = yield newTouchUpdateProcess(updateType, postMessage, device, {
+                    payload,
+                }, rebootOnSuccess);
                 return response.message;
             }
         }
         postConfirmationMessage(device);
         postProgressTip(device, 'ConfirmOnDevice', postMessage);
-        const length = source.size;
+        const length = payload.byteLength;
         let response = yield typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
         postProgressTip(device, 'FirmwareEraseSuccess', postMessage);
         while (response.type !== 'Success') {
             const start = response.message.offset;
             const end = response.message.offset + response.message.length;
-            const chunk = yield source.readAt(start, end - start);
+            const chunk = payload.slice(start, end);
             if (start > 0) {
                 postProgressMessage(device, Math.round((start / length) * 100), 'transferData', postMessage);
             }
@@ -47100,21 +46213,7 @@ const uploadFirmwareFromSource = (updateType, typedCall, postMessage, device, so
     }
     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown device model');
 });
-const uploadFirmware = (updateType, typedCall, postMessage, device, { payload, rebootOnSuccess, }, isUpdateBootloader) => __awaiter(void 0, void 0, void 0, function* () {
-    const source = yield openFirmwareByteSource({
-        binary: toArrayBuffer$1(payload),
-    });
-    if (!source) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'firmware payload is empty');
-    }
-    try {
-        return yield uploadFirmwareFromSource(updateType, typedCall, postMessage, device, source, rebootOnSuccess, isUpdateBootloader);
-    }
-    finally {
-        yield source.close();
-    }
-});
-const newTouchUpdateProcess = (updateType, postMessage, device, source, rebootOnSuccess = true) => __awaiter(void 0, void 0, void 0, function* () {
+const newTouchUpdateProcess = (updateType, postMessage, device, { payload }, rebootOnSuccess = true) => __awaiter(void 0, void 0, void 0, function* () {
     var _c, _d, _e, _f, _g;
     let typedCall = device.getCommands().typedCall.bind(device.getCommands());
     postProgressTip(device, 'StartTransferData', postMessage);
@@ -47122,13 +46221,13 @@ const newTouchUpdateProcess = (updateType, postMessage, device, source, rebootOn
     const env = DataManager.getSettings('env');
     const perPackageSize = DataManager.isBleConnect(env) ? 16 : 128;
     const chunkSize = 1024 * perPackageSize;
-    const totalChunks = Math.ceil(source.size / chunkSize);
+    const totalChunks = Math.ceil(payload.byteLength / chunkSize);
     let offset = 0;
     for (let i = 0; i < totalChunks; i++) {
         const chunkStart = i * chunkSize;
-        const chunkEnd = Math.min(chunkStart + chunkSize, source.size);
+        const chunkEnd = Math.min(chunkStart + chunkSize, payload.byteLength);
         const chunkLength = chunkEnd - chunkStart;
-        const chunk = yield source.readAt(chunkStart, chunkLength);
+        const chunk = payload.slice(chunkStart, chunkEnd);
         const overwrite = i === 0;
         const progress = Math.round(((i + 1) / totalChunks) * 100);
         const writeRes = yield emmcFileWriteWithRetry(device, filePath, chunkLength, offset, chunk, overwrite, progress);
@@ -47296,44 +46395,6 @@ const updateResource = (typedCall, fileName, data, onConfirmAfter) => __awaiter(
     onConfirmAfter === null || onConfirmAfter === void 0 ? void 0 : onConfirmAfter();
     return processResourceRequest(typedCall, res, data);
 });
-const updateResourceFromSource = (typedCall, fileName, source, onConfirmAfter) => __awaiter(void 0, void 0, void 0, function* () {
-    const initialLength = Math.min(INIT_DATA_CHUNK_SIZE, source.size);
-    const initialChunk = new Uint8Array(yield source.readAt(0, initialLength));
-    let response = yield typedCall('ResourceUpdate', ['ResourceRequest', 'Success'], {
-        file_name: fileName,
-        data_length: source.size,
-        initial_data_chunk: bytesToHex$1(initialChunk),
-        hash: bytesToHex$1(blake2s.blake2s(initialChunk)),
-    });
-    onConfirmAfter === null || onConfirmAfter === void 0 ? void 0 : onConfirmAfter();
-    while (response.type !== 'Success') {
-        const { offset, data_length: dataLength } = response.message;
-        if (!Number.isSafeInteger(offset) ||
-            offset === undefined ||
-            offset < 0 ||
-            !Number.isSafeInteger(dataLength) ||
-            dataLength === undefined ||
-            dataLength <= 0 ||
-            offset + dataLength > source.size) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device requested an invalid firmware resource range');
-        }
-        const chunk = new Uint8Array(yield source.readAt(offset, dataLength));
-        response = yield typedCall('ResourceAck', ['ResourceRequest', 'Success'], {
-            data_chunk: bytesToHex$1(chunk),
-            hash: bytesToHex$1(blake2s.blake2s(chunk)),
-        });
-    }
-    return response.message;
-});
-const updateResourcesFromSources = (typedCall, postMessage, device, entries) => __awaiter(void 0, void 0, void 0, function* () {
-    postProgressTip(device, 'UpdateSysResource', postMessage);
-    for (const [index, entry] of entries.entries()) {
-        yield updateResourceFromSource(typedCall, entry.entryName, entry.source);
-        postProgressMessage(device, Math.floor(((index + 1) / entries.length) * 100), 'installingFirmware', postMessage);
-    }
-    postProgressTip(device, 'UpdateSysResourceSuccess', postMessage);
-    return true;
-});
 const updateResources = (typedCall, postMessage, device, source) => __awaiter(void 0, void 0, void 0, function* () {
     postProgressTip(device, 'UpdateSysResource', postMessage);
     const zipData = yield JSZip__default["default"].loadAsync(source);
@@ -47353,22 +46414,10 @@ const updateResources = (typedCall, postMessage, device, source) => __awaiter(vo
     postProgressTip(device, 'UpdateSysResourceSuccess', postMessage);
     return true;
 });
-const updateBootloader = (typedCall, postMessage, device, data) => __awaiter(void 0, void 0, void 0, function* () {
-    const source = yield openFirmwareByteSource({ binary: data });
-    if (!source) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'bootloader payload is empty');
-    }
-    try {
-        return yield updateBootloaderFromSource(typedCall, postMessage, device, source);
-    }
-    finally {
-        yield source.close();
-    }
-});
-const updateBootloaderFromSource = (typedCall, postMessage, device, source) => __awaiter(void 0, void 0, void 0, function* () {
+const updateBootloader = (typedCall, postMessage, device, source) => __awaiter(void 0, void 0, void 0, function* () {
     postProgressTip(device, 'UpdateBootloader', postMessage);
     postProgressMessage(device, Math.floor(0), 'installingFirmware', postMessage);
-    yield updateResourceFromSource(typedCall, 'bootloader.bin', source, () => {
+    yield updateResource(typedCall, 'bootloader.bin', source, () => {
         postProcessingMessage('resource', postMessage);
     });
     postProgressMessage(device, Math.floor(100), 'installingFirmware', postMessage);
@@ -47734,32 +46783,6 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
             return totalSize !== undefined ? (processedSize !== null && processedSize !== void 0 ? processedSize : 0) + payload.byteLength : 0;
         });
     }
-    emmcCommonUpdateProcessFromSource({ source, filePath, processedSize, totalSize, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!filePath.startsWith('0:')) {
-                throw new Error('filePath must start with 0:');
-            }
-            const env = DataManager.getSettings('env');
-            const chunkSize = 1024 * (DataManager.isBleConnect(env) ? 16 : 128);
-            yield writeFirmwareByteSource({
-                source,
-                chunkSize,
-                write: ({ data, sourceOffset, length, first }) => __awaiter(this, void 0, void 0, function* () {
-                    const progress = totalSize !== undefined && processedSize !== undefined
-                        ? Math.min(Math.ceil(((processedSize + sourceOffset + length) / totalSize) * 100), 99)
-                        : Math.min(Math.ceil(((sourceOffset + length) / source.size) * 100), 99);
-                    const writeRes = yield this.emmcFileWriteWithRetry(filePath, length, sourceOffset, data, first, progress);
-                    if (!writeRes) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
-                    }
-                    const processedBytes = Number(writeRes.message.processed_byte);
-                    this.postProgressMessage(progress, 'transferData');
-                    return Number.isFinite(processedBytes) ? processedBytes : length;
-                }),
-            });
-            return totalSize !== undefined ? (processedSize !== null && processedSize !== void 0 ? processedSize : 0) + source.size : 0;
-        });
-    }
     emmcFileWriteWithRetry(filePath, chunkLength, offset, chunk, overwrite, progress) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         return __awaiter(this, void 0, void 0, function* () {
@@ -47864,44 +46887,10 @@ class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod {
             return true;
         });
     }
-    updateBootloaderWithEmmcFileWriteFromSource(_device, source) {
+    updateTouchBootloader({ device, features, firmwareType, }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const filePath = '0:boot/bootloader.bin';
-            this.postTipMessage(exports.FirmwareUpdateTipMessage.StartTransferData);
-            yield this.emmcCommonUpdateProcessFromSource({
-                source,
-                filePath,
-            });
-            this.postTipMessage(exports.FirmwareUpdateTipMessage.ConfirmOnDevice);
-            yield this.reboot(hdTransport.RebootType.Normal);
-            this.postTipMessage(exports.FirmwareUpdateTipMessage.UpdateBootloaderSuccess);
-            return true;
-        });
-    }
-    updateTouchBootloader({ device, features, firmwareType, binary: preparedBinary, source: preparedSource, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (preparedSource) {
-                if (!(yield checkBootloaderSourceLength(preparedSource))) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CheckDownloadFileError);
-                }
-                if (features && device.isBootloader()) {
-                    this.postTipMessage(exports.FirmwareUpdateTipMessage.UpdateBootloader);
-                    const result = yield this.updateBootloaderWithEmmcFileWriteFromSource(device, preparedSource);
-                    return result;
-                }
-                if (features && !device.isBootloader()) {
-                    yield updateBootloaderFromSource(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, preparedSource);
-                    return true;
-                }
-            }
-            let binary = preparedBinary;
+            let { binary } = this.payload;
             if (!binary) {
-                if (DataManager.getSettings('firmwareManifestMode') === 'external-only') {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Bootloader must be prepared by the external firmware host', {
-                        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                        artifactName: 'bootloader',
-                    });
-                }
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.CheckLatestUiResource);
                 const resourceUrl = features
                     ? DataManager.getBootloaderResource(features, firmwareType)
@@ -47915,13 +46904,12 @@ class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod {
                     }
                 }
             }
-            if (!binary || !checkBootloaderLength(binary)) {
+            if (!checkBootloaderLength(binary)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CheckDownloadFileError);
             }
             if (features && device.isBootloader()) {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.UpdateBootloader);
-                const result = yield this.updateBootloaderWithEmmcFileWrite(device, binary);
-                return result;
+                return this.updateBootloaderWithEmmcFileWrite(device, binary);
             }
             if (features && !device.isBootloader()) {
                 yield updateBootloader(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, binary);
@@ -47930,67 +46918,16 @@ class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod {
         });
     }
     run() {
-        var _a, _b, _c;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const { device } = this;
             const { features } = device;
             const payload = this.payload;
-            const hostBinding = payload.artifact
-                ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
-                : undefined;
-            const executionParams = Object.assign(Object.assign({}, payload), { artifactReader: (_a = hostBinding === null || hostBinding === void 0 ? void 0 : hostBinding.artifactReader) !== null && _a !== void 0 ? _a : payload.artifactReader });
-            if (payload.artifact) {
-                assertFirmwareUpdatePreparedPlanDeviceIdentity({
-                    preparedPlan: payload.preparedPlan,
-                    deviceIdentity: getDeviceUUID(features) || undefined,
-                });
-                assertFirmwareUpdatePreparedPlanBinding({
-                    preparedPlan: payload.preparedPlan,
-                    executor: 'v2',
-                    scopeTargets: ['bootloader'],
-                    bindings: [
-                        {
-                            target: 'bootloader',
-                            artifact: payload.artifact,
-                        },
-                    ],
-                });
-                const source = yield openFirmwareByteSource({
-                    artifact: payload.artifact,
-                    reader: executionParams.artifactReader,
-                });
-                if (!source) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Bootloader artifact is not prepared');
-                }
-                try {
-                    const deviceType = device.getCurrentDeviceType();
-                    const deviceFirmwareType = device.getCurrentFirmwareType();
-                    const firmwareType = (_b = payload.firmwareType) !== null && _b !== void 0 ? _b : deviceFirmwareType;
-                    if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-                        return yield this.updateTouchBootloader({
-                            device,
-                            features,
-                            firmwareType,
-                            source,
-                        });
-                    }
-                    return true;
-                }
-                finally {
-                    yield source.close();
-                }
-            }
-            const { binary } = payload;
             const deviceType = device.getCurrentDeviceType();
             const deviceFirmwareType = device.getCurrentFirmwareType();
-            const firmwareType = (_c = payload.firmwareType) !== null && _c !== void 0 ? _c : deviceFirmwareType;
+            const firmwareType = (_a = payload.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
             if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-                return this.updateTouchBootloader({
-                    device,
-                    features,
-                    firmwareType,
-                    binary,
-                });
+                return this.updateTouchBootloader({ device, features, firmwareType });
             }
             return Promise.resolve(true);
         });
@@ -48271,12 +47208,6 @@ const normalizeFirmwareBinary = (binary) => {
     }
     return normalized.buffer;
 };
-const toArrayBuffer = (binary) => {
-    if (binary instanceof ArrayBuffer) {
-        return binary;
-    }
-    return new Uint8Array(binary.buffer, binary.byteOffset, binary.byteLength).slice().buffer;
-};
 class FirmwareUpdateV2 extends BaseMethod {
     constructor() {
         super(...arguments);
@@ -48291,7 +47222,6 @@ class FirmwareUpdateV2 extends BaseMethod {
         };
     }
     init() {
-        var _a;
         this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
         this.requireDeviceMode = [];
         this.useDevicePassphraseState = false;
@@ -48318,28 +47248,6 @@ class FirmwareUpdateV2 extends BaseMethod {
         if ('binary' in payload) {
             this.params = Object.assign(Object.assign({}, this.params), { binary: payload.binary });
         }
-        if ('artifact' in payload) {
-            const hostBinding = resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration);
-            const target = payload.isUpdateBootloader ? 'bootloader' : payload.updateType;
-            const resourceBindings = [
-                ...(payload.resourceArtifact
-                    ? [{ target: 'resource', artifact: payload.resourceArtifact }]
-                    : []),
-                ...((_a = payload.resourceEntries) !== null && _a !== void 0 ? _a : []).map((entry) => ({
-                    target: 'resource',
-                    entryName: entry.entryName,
-                    artifact: entry.artifact,
-                })),
-            ];
-            assertFirmwareUpdatePreparedPlanBinding({
-                preparedPlan: payload.preparedPlan,
-                executor: 'v2',
-                platform: payload.platform,
-                scopeTargets: [target, ...(target === 'firmware' ? ['resource'] : [])],
-                bindings: [{ target, artifact: payload.artifact }, ...resourceBindings],
-            });
-            this.params = Object.assign(Object.assign({}, this.params), { preparedPlan: payload.preparedPlan, artifact: payload.artifact, resourceArtifact: payload.resourceArtifact, resourceEntries: payload.resourceEntries, artifactReader: hostBinding.artifactReader });
-        }
     }
     _promptDeviceInBootloaderForWebDevice() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -48479,7 +47387,7 @@ class FirmwareUpdateV2 extends BaseMethod {
         }
     }
     run() {
-        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* () {
             const { device, params } = this;
             const { features, commands } = device;
@@ -48487,186 +47395,104 @@ class FirmwareUpdateV2 extends BaseMethod {
             if (device.isProtocolV2()) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 firmware update must use firmwareUpdateV4');
             }
-            if (params.preparedPlan) {
-                assertFirmwareUpdatePreparedPlanDeviceIdentity({
-                    preparedPlan: params.preparedPlan,
-                    deviceIdentity: getDeviceUUID(features) || undefined,
-                });
-            }
             const deviceFirmwareType = device.getCurrentFirmwareType();
             const firmwareType = (_a = params.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
             this.checkVersionForCopyTouchResource(features, firmwareType);
-            let preparedSource;
-            try {
-                const acquireFirmwareSource = () => __awaiter(this, void 0, void 0, function* () {
-                    var _k;
-                    try {
-                        if (preparedSource) {
-                            return preparedSource;
-                        }
-                        if (params.binary !== undefined) {
-                            const binary = normalizeFirmwareBinary(params.binary);
-                            if (!binary) {
-                                throw new Error('firmware binary is empty or invalid');
-                            }
-                            const source = yield openFirmwareByteSource({
-                                binary: toArrayBuffer(binary),
-                            });
-                            if (!source) {
-                                throw new Error('firmware binary is empty or invalid');
-                            }
-                            preparedSource = source;
-                            return source;
-                        }
-                        if (params.artifact) {
-                            const source = yield openFirmwareByteSource({
-                                artifact: params.artifact,
-                                reader: params.artifactReader,
-                            });
-                            if (!source) {
-                                throw new Error('firmware artifact is not prepared');
-                            }
-                            preparedSource = source;
-                            return source;
-                        }
-                        if (!device.features) {
-                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'no features found for this device');
-                        }
-                        if (params.artifactReader ||
-                            DataManager.getSettings('firmwareManifestMode') === 'external-only') {
-                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware must be prepared by the external firmware host', {
-                                firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                                artifactName: 'firmware',
-                            });
-                        }
-                        this.postTipMessage('DownloadFirmware');
-                        const firmware = yield getBinary({
-                            features: device.features,
-                            version: params.version,
-                            updateType: params.updateType,
-                            isUpdateBootloader: params.isUpdateBootloader,
-                            firmwareType,
-                            requestOptions: FIRMWARE_DOWNLOAD_REQUEST_OPTIONS,
-                        });
-                        const binary = normalizeFirmwareBinary(firmware.binary);
-                        if (!binary) {
-                            throw new Error('downloaded firmware binary is empty or invalid');
-                        }
-                        const source = yield openFirmwareByteSource({
-                            binary: toArrayBuffer(binary),
-                        });
-                        if (!source) {
-                            throw new Error('downloaded firmware binary is empty or invalid');
+            let preparedBinary;
+            const acquireFirmwareBinary = () => __awaiter(this, void 0, void 0, function* () {
+                var _l;
+                try {
+                    if (preparedBinary) {
+                        return preparedBinary;
+                    }
+                    if (params.binary !== undefined) {
+                        preparedBinary = normalizeFirmwareBinary(params.binary);
+                        if (!preparedBinary) {
+                            throw new Error('firmware binary is empty or invalid');
                         }
-                        preparedSource = source;
-                        this.postTipMessage('DownloadFirmwareSuccess');
-                        return source;
+                        return preparedBinary;
                     }
-                    catch (err) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_k = err.message) !== null && _k !== void 0 ? _k : err);
+                    if (!device.features) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'no features found for this device');
                     }
-                });
-                if (!device.isBootloader() && features) {
-                    const serialNo = device.getCurrentSerialNo();
-                    if (this.isEnteredManuallyBoot()) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateManuallyEnterBoot);
+                    this.postTipMessage('DownloadFirmware');
+                    const firmware = yield getBinary({
+                        features: device.features,
+                        version: params.version,
+                        updateType: params.updateType,
+                        isUpdateBootloader: params.isUpdateBootloader,
+                        firmwareType,
+                        requestOptions: FIRMWARE_DOWNLOAD_REQUEST_OPTIONS,
+                    });
+                    preparedBinary = normalizeFirmwareBinary(firmware.binary);
+                    if (!preparedBinary) {
+                        throw new Error('downloaded firmware binary is empty or invalid');
                     }
-                    yield acquireFirmwareSource();
-                    if (this.isSupportResourceUpdate(params.updateType)) {
-                        this.postTipMessage('CheckLatestUiResource');
-                        const resourceUrl = DataManager.getSysResourcesLatestRelease({
-                            features,
-                            forcedUpdateRes: params.forcedUpdateRes,
-                            firmwareType,
-                        });
-                        if (resourceUrl) {
-                            this.postTipMessage('DownloadLatestUiResource');
-                            if ((_b = params.resourceEntries) === null || _b === void 0 ? void 0 : _b.length) {
-                                const sources = [];
-                                try {
-                                    for (const entry of params.resourceEntries) {
-                                        const resourceName = getFirmwareUpdateResourceName(entry.entryName);
-                                        const source = yield openFirmwareByteSource({
-                                            artifact: entry.artifact,
-                                            reader: params.artifactReader,
-                                        });
-                                        if (!source) {
-                                            throw new Error('Firmware resource entry is not prepared');
-                                        }
-                                        sources.push({ entryName: resourceName, source });
-                                    }
-                                    yield updateResourcesFromSources(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, sources.map(entry => ({
-                                        entryName: entry.entryName,
-                                        source: entry.source,
-                                    })));
-                                }
-                                finally {
-                                    yield Promise.all(sources.map(entry => entry.source.close().catch(() => undefined)));
-                                }
-                                this.postTipMessage('DownloadLatestUiResourceSuccess');
-                            }
-                            else {
-                                let resourceBinary;
-                                if (params.resourceArtifact) {
-                                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware resource archive must be materialized into prepared entries', {
-                                        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                                        artifactName: 'resource',
-                                    });
-                                }
-                                else {
-                                    if (params.artifactReader ||
-                                        DataManager.getSettings('firmwareManifestMode') === 'external-only') {
-                                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware resource must be prepared by the external firmware host', {
-                                            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                                            artifactName: 'resource',
-                                        });
-                                    }
-                                    resourceBinary = (yield getSysResourceBinary(resourceUrl)).binary;
-                                }
-                                this.postTipMessage('DownloadLatestUiResourceSuccess');
-                                yield updateResources(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, resourceBinary);
-                            }
+                    this.postTipMessage('DownloadFirmwareSuccess');
+                    return preparedBinary;
+                }
+                catch (err) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_l = err.message) !== null && _l !== void 0 ? _l : err);
+                }
+            });
+            if (!device.isBootloader() && features) {
+                const serialNo = device.getCurrentSerialNo();
+                if (this.isEnteredManuallyBoot()) {
+                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateManuallyEnterBoot));
+                }
+                if (this.isSupportResourceUpdate(params.updateType)) {
+                    this.postTipMessage('CheckLatestUiResource');
+                    const resourceUrl = DataManager.getSysResourcesLatestRelease({
+                        features,
+                        forcedUpdateRes: params.forcedUpdateRes,
+                        firmwareType,
+                    });
+                    if (resourceUrl) {
+                        this.postTipMessage('DownloadLatestUiResource');
+                        const resource = yield getSysResourceBinary(resourceUrl);
+                        this.postTipMessage('DownloadLatestUiResourceSuccess');
+                        if (resource) {
+                            yield updateResources(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, resource.binary);
                         }
                     }
-                    (_d = (_c = this.device) === null || _c === void 0 ? void 0 : _c.commands) === null || _d === void 0 ? void 0 : _d.checkDisposed();
-                    try {
-                        this.postTipMessage('AutoRebootToBootloader');
-                        const bootRes = yield commands.typedCall('DeviceBackToBoot', 'Success');
-                        if (bootRes.type === 'CallMethodError') {
-                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure);
-                        }
-                        this.postTipMessage('GoToBootloaderSuccess');
-                        this.checkDeviceToBootloader(this.payload.connectId);
-                        if (DeviceModelToTypes.model_classic.includes(deviceType)) {
-                            DevicePool.clearDeviceCache(serialNo);
-                        }
-                        delete DevicePool.devicesCache[''];
-                        yield ((_e = this.checkPromise) === null || _e === void 0 ? void 0 : _e.promise);
-                        this.checkPromise = null;
-                        (_g = (_f = this.device) === null || _f === void 0 ? void 0 : _f.commands) === null || _g === void 0 ? void 0 : _g.checkDisposed();
-                        const isTouch = DeviceModelToTypes.model_touch.includes(deviceType);
-                        yield wait(isTouch ? 3000 : 1500);
+                }
+                (_c = (_b = this.device) === null || _b === void 0 ? void 0 : _b.commands) === null || _c === void 0 ? void 0 : _c.checkDisposed();
+                yield acquireFirmwareBinary();
+                (_e = (_d = this.device) === null || _d === void 0 ? void 0 : _d.commands) === null || _e === void 0 ? void 0 : _e.checkDisposed();
+                try {
+                    this.postTipMessage('AutoRebootToBootloader');
+                    const bootRes = yield commands.typedCall('DeviceBackToBoot', 'Success');
+                    if (bootRes.type === 'CallMethodError') {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure);
                     }
-                    catch (e) {
-                        if (e instanceof hdShared.HardwareError) {
-                            return Promise.reject(e);
-                        }
-                        console.log('auto go to bootloader mode failed: ', e);
-                        return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure));
+                    this.postTipMessage('GoToBootloaderSuccess');
+                    this.checkDeviceToBootloader(this.payload.connectId);
+                    if (DeviceModelToTypes.model_classic.includes(deviceType)) {
+                        DevicePool.clearDeviceCache(serialNo);
                     }
+                    delete DevicePool.devicesCache[''];
+                    yield ((_f = this.checkPromise) === null || _f === void 0 ? void 0 : _f.promise);
+                    this.checkPromise = null;
+                    (_h = (_g = this.device) === null || _g === void 0 ? void 0 : _g.commands) === null || _h === void 0 ? void 0 : _h.checkDisposed();
+                    const isTouch = DeviceModelToTypes.model_touch.includes(deviceType);
+                    yield wait(isTouch ? 3000 : 1500);
                 }
-                const source = yield acquireFirmwareSource();
-                (_j = (_h = this.device) === null || _h === void 0 ? void 0 : _h.commands) === null || _j === void 0 ? void 0 : _j.checkDisposed();
-                yield this.device.acquire();
-                const response = yield uploadFirmwareFromSource(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, source, true, params.isUpdateBootloader);
-                if (this.connectId) {
-                    DevicePool.clearDeviceCache(this.connectId);
+                catch (e) {
+                    if (e instanceof hdShared.HardwareError) {
+                        return Promise.reject(e);
+                    }
+                    console.log('auto go to bootloader mode failed: ', e);
+                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure));
                 }
-                return response;
             }
-            finally {
-                yield (preparedSource === null || preparedSource === void 0 ? void 0 : preparedSource.close().catch(() => undefined));
+            const binary = yield acquireFirmwareBinary();
+            (_k = (_j = this.device) === null || _j === void 0 ? void 0 : _j.commands) === null || _k === void 0 ? void 0 : _k.checkDisposed();
+            yield this.device.acquire();
+            const response = yield uploadFirmware(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, { payload: binary, rebootOnSuccess: true }, params.isUpdateBootloader);
+            if (this.connectId) {
+                DevicePool.clearDeviceCache(this.connectId);
             }
+            return response;
         });
     }
 }
@@ -48678,10 +47504,8 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
         super(...arguments);
         this.checkPromise = null;
         this.isSwitchFirmware = false;
-        this.artifactSources = [];
     }
     init() {
-        var _a, _b, _c, _d, _e, _f;
         this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
         this.requireDeviceMode = [];
         this.useDevicePassphraseState = false;
@@ -48699,50 +47523,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
             { name: 'firmwareType', type: 'string' },
             { name: 'platform', type: 'string' },
         ]);
-        const hostBinding = payload.artifacts || payload.preparedPlan
-            ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
-            : undefined;
-        if (hostBinding) {
-            assertFirmwareUpdatePreparedPlanBinding({
-                preparedPlan: payload.preparedPlan,
-                executor: 'v3',
-                platform: payload.platform,
-                scopeTargets: ['bootloader', 'firmware', 'resource', 'ble'],
-                bindings: [
-                    ...(((_a = payload.artifacts) === null || _a === void 0 ? void 0 : _a.bootloader)
-                        ? [
-                            {
-                                target: 'bootloader',
-                                artifact: payload.artifacts.bootloader,
-                            },
-                        ]
-                        : []),
-                    ...(((_b = payload.artifacts) === null || _b === void 0 ? void 0 : _b.firmware)
-                        ? [
-                            {
-                                target: 'firmware',
-                                artifact: payload.artifacts.firmware,
-                            },
-                        ]
-                        : []),
-                    ...(((_c = payload.artifacts) === null || _c === void 0 ? void 0 : _c.ble)
-                        ? [
-                            {
-                                target: 'ble',
-                                artifact: payload.artifacts.ble,
-                            },
-                        ]
-                        : []),
-                    ...((_e = (_d = payload.artifacts) === null || _d === void 0 ? void 0 : _d.resourceEntries) !== null && _e !== void 0 ? _e : []).map((entry) => ({
-                        target: 'resource',
-                        entryName: entry.entryName,
-                        artifact: entry.artifact,
-                    })),
-                ],
-            });
-        }
         this.params = {
-            preparedPlan: payload.preparedPlan,
             bleBinary: payload.bleBinary,
             firmwareBinary: payload.firmwareBinary,
             forcedUpdateRes: payload.forcedUpdateRes,
@@ -48753,8 +47534,6 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
             resourceBinary: payload.resourceBinary,
             firmwareType: payload.firmwareType,
             platform: payload.platform,
-            artifactReader: (_f = hostBinding === null || hostBinding === void 0 ? void 0 : hostBinding.artifactReader) !== null && _f !== void 0 ? _f : payload.artifactReader,
-            artifacts: payload.artifacts,
         };
     }
     run() {
@@ -48777,48 +47556,32 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
             if (!features) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device features not available');
             }
-            if (this.params.preparedPlan) {
-                assertFirmwareUpdatePreparedPlanDeviceIdentity({
-                    preparedPlan: this.params.preparedPlan,
-                    deviceIdentity: getDeviceUUID(features) || undefined,
-                });
-            }
             const deviceFirmwareType = device.getCurrentFirmwareType();
             const firmwareType = (_b = this.params.firmwareType) !== null && _b !== void 0 ? _b : deviceFirmwareType;
             this.isSwitchFirmware = firmwareType !== deviceFirmwareType;
             let resourceBinary = null;
-            let resourceEntries = [];
-            let fwSources = [];
-            let bootloaderSource = null;
+            let fwBinaryMap = [];
+            let bootloaderBinary = null;
             try {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.StartDownloadFirmware);
-                const resourceInput = yield this.prepareResourceInput(firmwareType);
-                resourceBinary = resourceInput.resourceBinary;
-                resourceEntries = resourceInput.resourceEntries;
-                fwSources = yield this.prepareFirmwareAndBleSources(firmwareType);
-                bootloaderSource = yield this.prepareBootloaderSource(firmwareType);
+                resourceBinary = yield this.prepareResourceBinary(firmwareType);
+                fwBinaryMap = yield this.prepareFirmwareAndBleBinary(firmwareType);
+                bootloaderBinary = yield this.prepareBootloaderBinary(firmwareType);
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.FinishDownloadFirmware);
             }
             catch (err) {
-                yield this.closeArtifactSources();
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_c = err.message) !== null && _c !== void 0 ? _c : err);
             }
-            if (!bootloaderSource && fwSources.length === 0) {
-                yield this.closeArtifactSources();
+            if (!bootloaderBinary && fwBinaryMap.length === 0) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
             }
-            try {
-                yield this.enterBootloaderMode();
-                return yield this.executeUpdate({
-                    resourceBinary,
-                    resourceEntries,
-                    fwSources,
-                    bootloaderSource,
-                });
-            }
-            finally {
-                yield this.closeArtifactSources();
-            }
+            yield this.enterBootloaderMode();
+            const updateResult = yield this.executeUpdate({
+                resourceBinary,
+                fwBinaryMap,
+                bootloaderBinary,
+            });
+            return updateResult;
         });
     }
     validateDeviceAndVersion(deviceType, bootloaderVersion) {
@@ -48832,93 +47595,31 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'bootloader version needs to be updated');
         }
     }
-    openArtifactSource(binary, artifact) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const source = yield openFirmwareByteSource({
-                binary,
-                artifact,
-                reader: this.params.artifactReader,
-            });
-            if (source) {
-                this.artifactSources.push(source);
-            }
-            return source;
-        });
-    }
-    closeArtifactSources() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sources = this.artifactSources.splice(0);
-            yield Promise.all(sources.map(source => source.close().catch(() => undefined)));
-        });
-    }
-    assertSdkDownloadAllowed(artifactName) {
-        if (this.params.artifactReader ||
-            DataManager.getSettings('firmwareManifestMode') === 'external-only') {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `${artifactName} must be prepared by the external firmware host`, {
-                firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                artifactName,
-            });
-        }
-    }
-    prepareResourceInput(firmwareType) {
-        var _a;
+    prepareResourceBinary(firmwareType) {
         return __awaiter(this, void 0, void 0, function* () {
-            const preparedEntries = (_a = this.params.artifacts) === null || _a === void 0 ? void 0 : _a.resourceEntries;
-            if ((preparedEntries === null || preparedEntries === void 0 ? void 0 : preparedEntries.length) && this.params.resourceBinary) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware resource input must not contain both archive binary and prepared entries');
-            }
-            if (preparedEntries === null || preparedEntries === void 0 ? void 0 : preparedEntries.length) {
-                const resourceEntries = [];
-                for (const entry of preparedEntries) {
-                    const resourceName = getFirmwareUpdateResourceName(entry.entryName);
-                    const source = yield this.openArtifactSource(undefined, entry.artifact);
-                    if (!source) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Firmware resource entry ${entry.entryName} is not prepared`);
-                    }
-                    resourceEntries.push({ entryName: resourceName, source });
-                }
-                return {
-                    resourceBinary: null,
-                    resourceEntries,
-                };
-            }
             if (this.params.resourceBinary) {
-                return {
-                    resourceBinary: this.params.resourceBinary,
-                    resourceEntries: [],
-                };
+                return this.params.resourceBinary;
             }
             const { features } = this.device;
-            if (!features) {
-                return {
-                    resourceBinary: null,
-                    resourceEntries: [],
-                };
-            }
+            if (!features)
+                return null;
             const resourceUrl = DataManager.getSysResourcesLatestRelease({
                 features,
                 forcedUpdateRes: this.params.forcedUpdateRes,
                 firmwareType,
             });
             if (resourceUrl) {
-                this.assertSdkDownloadAllowed('resource');
-                return {
-                    resourceBinary: (yield getSysResourceBinary(resourceUrl)).binary,
-                    resourceEntries: [],
-                };
+                const resource = (yield getSysResourceBinary(resourceUrl)).binary;
+                return resource;
             }
             Log$6.warn('No resource url found');
-            return {
-                resourceBinary: null,
-                resourceEntries: [],
-            };
+            return null;
         });
     }
-    prepareBootloaderSource(firmwareType) {
-        var _a, _b;
+    prepareBootloaderBinary(firmwareType) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.params.bootloaderBinary || ((_a = this.params.artifacts) === null || _a === void 0 ? void 0 : _a.bootloader)) {
-                return this.openArtifactSource(this.params.bootloaderBinary, (_b = this.params.artifacts) === null || _b === void 0 ? void 0 : _b.bootloader);
+            if (this.params.bootloaderBinary) {
+                return this.params.bootloaderBinary;
             }
             const { features } = this.device;
             if (!features)
@@ -48926,32 +47627,25 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
             if (this.params.bootloaderVersion) {
                 const bootResourceUrl = DataManager.getBootloaderResource(features, firmwareType);
                 if (bootResourceUrl) {
-                    this.assertSdkDownloadAllowed('bootloader');
                     const bootBinary = (yield getSysResourceBinary(bootResourceUrl)).binary;
-                    return this.openArtifactSource(bootBinary, undefined);
+                    return bootBinary;
                 }
             }
             return null;
         });
     }
-    prepareFirmwareAndBleSources(firmwareType) {
-        var _a, _b, _c, _d;
+    prepareFirmwareAndBleBinary(firmwareType) {
         return __awaiter(this, void 0, void 0, function* () {
-            const fwSources = [];
-            if (this.params.firmwareBinary || ((_a = this.params.artifacts) === null || _a === void 0 ? void 0 : _a.firmware)) {
-                const source = yield this.openArtifactSource(this.params.firmwareBinary, (_b = this.params.artifacts) === null || _b === void 0 ? void 0 : _b.firmware);
-                if (!source) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware artifact is not prepared');
-                }
-                fwSources.push({
+            const fwBinaryMap = [];
+            if (this.params.firmwareBinary) {
+                fwBinaryMap.push({
                     fileName: 'firmware.bin',
-                    source,
+                    binary: this.params.firmwareBinary,
                 });
             }
             else if (this.params.firmwareVersion) {
                 const { features } = this.device;
                 if (features) {
-                    this.assertSdkDownloadAllowed('firmware');
                     const firmwareBinary = (yield getBinary({
                         features,
                         version: this.params.firmwareVersion,
@@ -48959,64 +47653,48 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                         isUpdateBootloader: false,
                         firmwareType,
                     })).binary;
-                    const source = yield this.openArtifactSource(firmwareBinary, undefined);
-                    if (!source) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware binary is not prepared');
-                    }
-                    fwSources.push({
+                    fwBinaryMap.push({
                         fileName: 'firmware.bin',
-                        source,
+                        binary: firmwareBinary,
                     });
                 }
             }
-            if (this.params.bleBinary || ((_c = this.params.artifacts) === null || _c === void 0 ? void 0 : _c.ble)) {
-                const source = yield this.openArtifactSource(this.params.bleBinary, (_d = this.params.artifacts) === null || _d === void 0 ? void 0 : _d.ble);
-                if (!source) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'BLE artifact is not prepared');
-                }
-                fwSources.push({
+            if (this.params.bleBinary) {
+                fwBinaryMap.push({
                     fileName: 'ble-firmware.bin',
-                    source,
+                    binary: this.params.bleBinary,
                 });
             }
             else if (this.params.bleVersion) {
                 const { features } = this.device;
                 if (features) {
-                    this.assertSdkDownloadAllowed('ble');
                     const bleBinary = yield getBinary({
                         features,
                         version: this.params.bleVersion,
                         updateType: 'ble',
                         firmwareType,
                     });
-                    const source = yield this.openArtifactSource(bleBinary.binary, undefined);
-                    if (!source) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'BLE binary is not prepared');
-                    }
-                    fwSources.push({
+                    fwBinaryMap.push({
                         fileName: 'ble-firmware.bin',
-                        source,
+                        binary: bleBinary.binary,
                     });
                 }
             }
-            return fwSources;
+            return fwBinaryMap;
         });
     }
-    executeUpdate({ resourceBinary, resourceEntries, fwSources, bootloaderSource, }) {
+    executeUpdate({ resourceBinary, fwBinaryMap, bootloaderBinary, }) {
         return __awaiter(this, void 0, void 0, function* () {
             let totalSize = 0;
             let processedSize = 0;
             if (resourceBinary) {
                 totalSize += resourceBinary.byteLength;
             }
-            for (const entry of resourceEntries) {
-                totalSize += entry.source.size;
+            for (const fwbinary of fwBinaryMap) {
+                totalSize += fwbinary.binary.byteLength;
             }
-            for (const firmware of fwSources) {
-                totalSize += firmware.source.size;
-            }
-            if (bootloaderSource) {
-                totalSize += bootloaderSource.size;
+            if (bootloaderBinary) {
+                totalSize += bootloaderBinary.byteLength;
             }
             this.postTipMessage(exports.FirmwareUpdateTipMessage.StartTransferData);
             if (resourceBinary) {
@@ -49035,28 +47713,20 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                     }
                 }
             }
-            for (const entry of resourceEntries) {
-                processedSize = yield this.emmcCommonUpdateProcessFromSource({
-                    source: entry.source,
-                    filePath: `0:res/${entry.entryName}`,
-                    processedSize,
-                    totalSize,
-                });
-            }
-            if (bootloaderSource) {
-                processedSize = yield this.emmcCommonUpdateProcessFromSource({
-                    source: bootloaderSource,
+            if (bootloaderBinary) {
+                processedSize = yield this.emmcCommonUpdateProcess({
+                    payload: bootloaderBinary,
                     filePath: `0:boot/bootloader.bin`,
                     processedSize,
                     totalSize,
                 });
             }
             yield this.createUpdatesFolderIfNotExists(`0:updates/`);
-            for (const firmware of fwSources) {
-                if (firmware) {
-                    processedSize = yield this.emmcCommonUpdateProcessFromSource({
-                        source: firmware.source,
-                        filePath: `0:updates/${firmware.fileName}`,
+            for (const fwbinary of fwBinaryMap) {
+                if (fwbinary) {
+                    processedSize = yield this.emmcCommonUpdateProcess({
+                        payload: fwbinary.binary,
+                        filePath: `0:updates/${fwbinary.fileName}`,
                         processedSize,
                         totalSize,
                     });
@@ -49401,6 +48071,10 @@ const getProtocolV2DeviceTransferProgress = (bytesBeforeChunk, bytesAfterChunk,
     }
     return Math.min(Math.max(Math.ceil((bytesAfterChunk / totalBytes) * 100), 1), 99);
 };
+const formatProtocolV2TransferSpeed = (bytes, elapsedMs) => {
+    const safeElapsedMs = Math.max(elapsedMs, 1);
+    return (bytes / 1024 / (safeElapsedMs / 1000)).toFixed(2);
+};
 const PROTOCOL_V2_REMOTE_COMPONENT_TARGETS = {
     BOOTLOADER: {
         fileName: 'bootloader.bin',
@@ -49582,21 +48256,14 @@ const parseProtocolV2OkppHeader = (bytes) => {
 };
 const assertProtocolV2ReconnectIdentity = (expectedSerialNumber, actualSerialNumber) => {
     if (!expectedSerialNumber || !actualSerialNumber) {
-        return;
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'Protocol V2 reconnect physical identity is unavailable');
     }
     if (actualSerialNumber !== expectedSerialNumber) {
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Protocol V2 reconnect physical identity mismatch: expected ${expectedSerialNumber}, received ${actualSerialNumber}`);
     }
 };
 class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
-    constructor() {
-        super(...arguments);
-        this.protocolV2PreparedSources = [];
-        this.protocolV2ExecutionInLoader = false;
-        this.protocolV2CompletedTargetVersions = new Map();
-    }
     init() {
-        var _a, _b, _c;
         this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
         this.requireDeviceMode = [];
         this.unlockPolicy = 'unlock-before-run';
@@ -49630,51 +48297,9 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             { name: 'firmwareType', type: 'string' },
             { name: 'targetsToUpdate', type: 'array', allowEmpty: true },
             { name: 'platform', type: 'string' },
-            { name: 'expectedDeviceId', type: 'string' },
             { name: 'resourceBundleFiles', type: 'array', allowEmpty: true },
         ]);
-        if (payload.expectedDeviceId !== undefined &&
-            (payload.expectedDeviceId.length === 0 || payload.expectedDeviceId.length > 160)) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Protocol V2 expected device identity is invalid');
-        }
-        const hostBinding = payload.preparedPlan || payload.componentArtifacts || payload.resourceBundleArtifacts
-            ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
-            : undefined;
-        if (hostBinding) {
-            assertFirmwareUpdatePreparedPlanBinding({
-                preparedPlan: payload.preparedPlan,
-                executor: 'v4',
-                platform: payload.platform,
-                scopeTargets: [
-                    'boot',
-                    'app_v1',
-                    'app_v2',
-                    'coprocessor',
-                    'resource',
-                    'se01',
-                    'se02',
-                    'se03',
-                    'se04',
-                ],
-                bindings: [
-                    ...Object.entries((_a = payload.componentArtifacts) !== null && _a !== void 0 ? _a : {}).flatMap(([target, artifact]) => artifact
-                        ? [
-                            {
-                                target: target,
-                                artifact,
-                            },
-                        ]
-                        : []),
-                    ...((_b = payload.resourceBundleArtifacts) !== null && _b !== void 0 ? _b : []).map((entry) => ({
-                        target: 'resource',
-                        logicalName: entry.name,
-                        artifact: entry.artifact,
-                    })),
-                ],
-            });
-        }
         this.params = {
-            preparedPlan: payload.preparedPlan,
             chunkSize: payload.chunkSize,
             forcedUpdateRes: payload.forcedUpdateRes,
             bootloaderBinary: payload.bootloaderBinary,
@@ -49689,21 +48314,21 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             resourceBundleFiles: payload.resourceBundleFiles,
             firmwareType: payload.firmwareType,
             targetsToUpdate: payload.targetsToUpdate,
-            expectedTargetVersions: payload.expectedTargetVersions,
             platform: payload.platform,
-            expectedDeviceId: payload.expectedDeviceId,
-            artifactReader: (_c = hostBinding === null || hostBinding === void 0 ? void 0 : hostBinding.artifactReader) !== null && _c !== void 0 ? _c : payload.artifactReader,
-            componentArtifacts: payload.componentArtifacts,
-            resourceBundleArtifacts: payload.resourceBundleArtifacts,
         };
     }
-    getProtocolV2FirmwareChunkSize() {
+    getProtocolV2FirmwareChunkSize(direction = 'write') {
         var _a, _b;
         const payloadChunkSize = Number((_a = this.params) === null || _a === void 0 ? void 0 : _a.chunkSize);
         const env = DataManager.getSettings('env');
-        const maxChunkSize = ((_b = this.params) === null || _b === void 0 ? void 0 : _b.platform) === 'native' || (env && DataManager.isBleConnect(env))
-            ? hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
-            : hdTransport.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+        const isBle = ((_b = this.params) === null || _b === void 0 ? void 0 : _b.platform) === 'native' || (env && DataManager.isBleConnect(env));
+        let maxChunkSize = hdTransport.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+        if (isBle) {
+            maxChunkSize =
+                direction === 'read'
+                    ? hdTransport.PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE
+                    : hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+        }
         if (!Number.isFinite(payloadChunkSize) || payloadChunkSize <= 0) {
             return maxChunkSize;
         }
@@ -49719,17 +48344,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     runProtocolV2() {
-        var _a, _b, _c;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             yield this.captureProtocolV2PhysicalIdentity();
             const deviceFeatures = yield this.getProtocolV2DeviceFeatures();
             const deviceFirmwareType = getFirmwareType(deviceFeatures);
             const firmwareType = (_a = this.params.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
-            this.validateExpectedTargetVersions();
-            if ((this.params.componentArtifacts && Object.keys(this.params.componentArtifacts).length > 0) ||
-                ((_b = this.params.resourceBundleArtifacts) === null || _b === void 0 ? void 0 : _b.length)) {
-                return this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
-            }
             let fwBinaryMap = [];
             let bootloaderBinary = null;
             let installItems;
@@ -49739,245 +48359,33 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 fwBinaryMap = this.collectExplicitTargetBinaries();
                 bootloaderBinary = this.prepareBootloaderBinary();
                 if (!this.hasExplicitProtocolV2Payload(fwBinaryMap)) {
-                    if (this.params.artifactReader ||
-                        DataManager.getSettings('firmwareManifestMode') === 'external-only') {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 firmware artifacts must be prepared by the external firmware host', {
-                            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                        });
-                    }
                     const remoteBinaries = yield this.prepareRemoteProtocolV2Binaries(firmwareType, deviceFeatures);
                     bootloaderBinary = remoteBinaries.bootloaderBinary;
                     fwBinaryMap = remoteBinaries.fwBinaryMap;
                     installItems = remoteBinaries.installItems;
                 }
-                const resourceDescriptors = this.prepareProtocolV2ResourceBundles(firmwareType, deviceFeatures);
-                resourceBundles = (resourceDescriptors === null || resourceDescriptors === void 0 ? void 0 : resourceDescriptors.length)
-                    ? yield this.materializeProtocolV2ResourceBundles(resourceDescriptors)
-                    : undefined;
+                resourceBundles = this.prepareProtocolV2ResourceBundles(firmwareType, deviceFeatures);
+                if (resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length) {
+                    resourceBundles = yield this.prefetchProtocolV2ResourceBundles(resourceBundles);
+                }
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.FinishDownloadFirmware);
             }
             catch (err) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_c = err.message) !== null && _c !== void 0 ? _c : err);
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_b = err.message) !== null && _b !== void 0 ? _b : err);
             }
             if (!bootloaderBinary && fwBinaryMap.length === 0 && !(resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
             }
-            return this.executeProtocolV2Update(Object.assign(Object.assign({ fwBinaryMap,
+            yield this.enterProtocolV2BootloaderMode();
+            yield this.executeProtocolV2Update(Object.assign(Object.assign({ fwBinaryMap,
                 bootloaderBinary }, (installItems ? { installItems } : undefined)), ((resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length) ? { resourceBundles } : undefined)));
+            yield this.exitProtocolV2BootloaderToNormal();
+            const versions = yield this.waitForProtocolV2FinalFeatures();
+            this.postTipMessage(exports.FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
+            DevicePool.resetState();
+            return versions;
         });
     }
-    openProtocolV2PreparedSource(artifact) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const source = yield openFirmwareByteSource({
-                artifact,
-                reader: this.params.artifactReader,
-            });
-            if (!source) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Firmware artifact ${artifact.artifactRef} is not prepared`, {
-                    firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                });
-            }
-            this.protocolV2PreparedSources.push(source);
-            return source;
-        });
-    }
-    openProtocolV2MemorySource(binary) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const source = yield openFirmwareByteSource({ binary });
-            if (!source) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 firmware binary is empty');
-            }
-            this.protocolV2PreparedSources.push(source);
-            return source;
-        });
-    }
-    closeProtocolV2PreparedSources() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sources = this.protocolV2PreparedSources.splice(0);
-            yield Promise.all(sources.map(source => source.close().catch(() => undefined)));
-        });
-    }
-    prepareProtocolV2InstallSources(firmwareType, features) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
-            if (!release) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 firmware release is unavailable');
-            }
-            const componentArtifacts = (_a = this.params.componentArtifacts) !== null && _a !== void 0 ? _a : {};
-            const requestedTargets = new Set((_b = this.params.targetsToUpdate) !== null && _b !== void 0 ? _b : Object.keys(componentArtifacts));
-            const installSources = [];
-            const preparedTargets = new Set();
-            for (const [key, component] of this.getRemoteComponentEntries(release)) {
-                const target = this.getRemoteComponentTarget(key, component);
-                const updateTarget = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId);
-                if (updateTarget && updateTarget !== 'resource' && requestedTargets.has(updateTarget)) {
-                    const artifact = componentArtifacts[updateTarget];
-                    if (!artifact) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 ${updateTarget} artifact is not prepared`, {
-                            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                            artifactName: updateTarget,
-                        });
-                    }
-                    installSources.push(Object.assign(Object.assign({}, target), { source: yield this.openProtocolV2PreparedSource(artifact) }));
-                    preparedTargets.add(updateTarget);
-                }
-            }
-            const unknownTarget = Array.from(requestedTargets).find(target => target !== 'resource' && !preparedTargets.has(target));
-            if (unknownTarget) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 release does not contain requested target ${unknownTarget}`);
-            }
-            return installSources;
-        });
-    }
-    prepareProtocolV2ResourceSources(firmwareType, features) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            const preparedArtifacts = (_a = this.params.resourceBundleArtifacts) !== null && _a !== void 0 ? _a : [];
-            const resourceRequested = ((_b = this.params.targetsToUpdate) === null || _b === void 0 ? void 0 : _b.includes('resource')) || preparedArtifacts.length > 0;
-            if (!resourceRequested) {
-                return [];
-            }
-            const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
-            const descriptors = (_c = release === null || release === void 0 ? void 0 : release.resourceBundles) !== null && _c !== void 0 ? _c : [];
-            const artifactByName = new Map(preparedArtifacts.map(item => [item.name, item.artifact]));
-            const sources = [];
-            for (const descriptor of descriptors) {
-                const artifact = artifactByName.get(descriptor.name);
-                if (!artifact) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 resource bundle ${descriptor.name} is not prepared`, {
-                        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                        artifactName: descriptor.name,
-                    });
-                }
-                const devicePath = validateProtocolV2FilesystemPath(descriptor.devicePath, 'resourceBundles[].devicePath');
-                sources.push({
-                    name: descriptor.name,
-                    source: yield this.openProtocolV2PreparedSource(artifact),
-                    devicePath,
-                    version: descriptor.version,
-                    payloadHash: descriptor.payloadHash,
-                    headerHash: descriptor.headerHash,
-                });
-                artifactByName.delete(descriptor.name);
-            }
-            if (artifactByName.size > 0) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 release does not contain resource bundle ${artifactByName.keys().next().value}`);
-            }
-            return sources;
-        });
-    }
-    runProtocolV2PreparedArtifacts(features, firmwareType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.postTipMessage(exports.FirmwareUpdateTipMessage.StartDownloadFirmware);
-                const installSources = yield this.prepareProtocolV2InstallSources(firmwareType, features);
-                const resourceSources = yield this.prepareProtocolV2ResourceSources(firmwareType, features);
-                if (installSources.length === 0 && resourceSources.length === 0) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
-                }
-                this.postTipMessage(exports.FirmwareUpdateTipMessage.FinishDownloadFirmware);
-                return yield this.executeProtocolV2SourceUpdate({
-                    installSources,
-                    resourceSources,
-                });
-            }
-            finally {
-                yield this.closeProtocolV2PreparedSources();
-            }
-        });
-    }
-    validateExpectedTargetVersions() {
-        const expected = this.params.expectedTargetVersions;
-        if (expected === undefined)
-            return;
-        if (typeof expected !== 'object' || expected === null || Array.isArray(expected)) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 expected target versions are invalid');
-        }
-        for (const [target, version] of Object.entries(expected)) {
-            if (!Array.from(PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.values()).includes(target) ||
-                typeof version !== 'string' ||
-                !/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/u.test(version) ||
-                version.length > 64) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 expected target version is invalid');
-            }
-        }
-    }
-    getExpectedProtocolV2TargetVersion(targetId) {
-        var _a, _b;
-        const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(targetId);
-        const version = target ? (_b = (_a = this.params) === null || _a === void 0 ? void 0 : _a.expectedTargetVersions) === null || _b === void 0 ? void 0 : _b[target] : undefined;
-        if (!version)
-            return undefined;
-        const parts = version.split(/[+-]/u, 1)[0].split('.').map(Number);
-        if (parts.length !== 3 ||
-            parts.some(part => !Number.isSafeInteger(part) || part < 0 || part > 0xff)) {
-            return undefined;
-        }
-        return parts[0] * 0x10000 + parts[1] * 0x100 + parts[2];
-    }
-    assertExpectedProtocolV2Versions(targets) {
-        var _a, _b, _c, _d, _e, _f;
-        const expected = (_a = this.params) === null || _a === void 0 ? void 0 : _a.expectedTargetVersions;
-        if (!expected)
-            return;
-        const features = this.protocolV2LatestFinalFeatures;
-        const requestedTargets = this.getProtocolV2RequestedTargets();
-        const applicationTargets = requestedTargets.filter(target => target === 'app_v1' || target === 'app_v2');
-        const visibleVersions = {
-            boot: features ? getDeviceBootloaderVersion(features).join('.') : undefined,
-            coprocessor: features ? getDeviceBLEFirmwareVersion(features).join('.') : undefined,
-            se01: (_b = features === null || features === void 0 ? void 0 : features.se01Version) !== null && _b !== void 0 ? _b : undefined,
-            se02: (_c = features === null || features === void 0 ? void 0 : features.se02Version) !== null && _c !== void 0 ? _c : undefined,
-            se03: (_d = features === null || features === void 0 ? void 0 : features.se03Version) !== null && _d !== void 0 ? _d : undefined,
-            se04: (_e = features === null || features === void 0 ? void 0 : features.se04Version) !== null && _e !== void 0 ? _e : undefined,
-        };
-        if (features && applicationTargets.length === 1) {
-            visibleVersions[applicationTargets[0]] = getDeviceFirmwareVersion(features).join('.');
-        }
-        const expectedEntries = Object.entries(expected).filter(([target]) => !targets || targets.includes(target));
-        for (const [target, expectedVersion] of expectedEntries) {
-            const targetId = (_f = Array.from(PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.entries()).find(([, mappedTarget]) => mappedTarget === target)) === null || _f === void 0 ? void 0 : _f[0];
-            const statusVersion = targetId === undefined ? undefined : this.protocolV2CompletedTargetVersions.get(targetId);
-            const observedVersion = statusVersion === undefined
-                ? visibleVersions[target]
-                : `${Math.floor(statusVersion / 0x10000) % 0x100}.${Math.floor(statusVersion / 0x100) % 0x100}.${statusVersion % 0x100}`;
-            if (!observedVersion) {
-                Log$5.warn(`Protocol V2 target ${target} has no observable final version; skipping version comparison`);
-            }
-            else if (observedVersion !== expectedVersion) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareVerificationFailed, `Protocol V2 target ${target} reached ${observedVersion}, expected ${expectedVersion}`);
-            }
-        }
-    }
-    getProtocolV2RequestedTargets() {
-        var _a, _b, _c, _d;
-        if ((_a = this.params.targetsToUpdate) === null || _a === void 0 ? void 0 : _a.length) {
-            return [...new Set(this.params.targetsToUpdate)];
-        }
-        const targets = new Set();
-        Object.keys((_b = this.params.componentArtifacts) !== null && _b !== void 0 ? _b : {}).forEach(target => targets.add(target));
-        if (((_c = this.params.resourceBundleArtifacts) === null || _c === void 0 ? void 0 : _c.length) || ((_d = this.params.resourceBundleFiles) === null || _d === void 0 ? void 0 : _d.length)) {
-            targets.add('resource');
-        }
-        if (this.params.bootloaderBinary)
-            targets.add('boot');
-        if (this.params.applicationP1Binary)
-            targets.add('app_v1');
-        if (this.params.applicationP2Binary)
-            targets.add('app_v2');
-        if (this.params.coprocessorBinary)
-            targets.add('coprocessor');
-        if (this.params.se01Binary)
-            targets.add('se01');
-        if (this.params.se02Binary)
-            targets.add('se02');
-        if (this.params.se03Binary)
-            targets.add('se03');
-        if (this.params.se04Binary)
-            targets.add('se04');
-        return Array.from(targets);
-    }
     getProtocolV2DeviceFeatures() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.device.features) {
@@ -50008,19 +48416,10 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     captureProtocolV2PhysicalIdentity() {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const deviceInfo = yield this.requestProtocolV2PhysicalIdentity();
             const serialNumber = this.getProtocolV2SerialNumber(deviceInfo);
-            if ((_a = this.params) === null || _a === void 0 ? void 0 : _a.preparedPlan) {
-                assertFirmwareUpdatePreparedPlanDeviceIdentity({
-                    preparedPlan: this.params.preparedPlan,
-                    deviceIdentity: serialNumber,
-                });
-            }
-            else {
-                assertProtocolV2ReconnectIdentity((_b = this.params) === null || _b === void 0 ? void 0 : _b.expectedDeviceId, serialNumber);
-            }
+            assertProtocolV2ReconnectIdentity(serialNumber, serialNumber);
             this.protocolV2ExpectedSerialNumber = serialNumber;
         });
     }
@@ -50104,7 +48503,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 fileSize < PROTOCOL_V2_OKPP_HEADER_SIZE) {
                 return null;
             }
-            const chunkSize = this.getProtocolV2FirmwareChunkSize();
+            const chunkSize = this.getProtocolV2FirmwareChunkSize('read');
             const chunks = [];
             let offset = 0;
             while (offset < PROTOCOL_V2_OKPP_HEADER_SIZE) {
@@ -50221,31 +48620,71 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             headerHash: bundle.headerHash,
         }));
     }
-    materializeProtocolV2ResourceBundles(bundles) {
+    prefetchProtocolV2ResourceBundles(bundles) {
         return __awaiter(this, void 0, void 0, function* () {
+            const prefetched = [];
             for (const bundle of bundles) {
-                if (bundle.binary.byteLength === 0 && bundle.url) {
-                    if (this.params.artifactReader ||
-                        DataManager.getSettings('firmwareManifestMode') === 'external-only') {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Firmware resource bundle ${bundle.name} is not prepared`, {
-                            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                            artifactName: bundle.name,
-                        });
+                let { binary } = bundle;
+                if (binary.byteLength === 0) {
+                    if (!bundle.url) {
+                        throw new Error(`Missing Protocol V2 RESC bundle binary: ${bundle.name}`);
                     }
-                    Log$5.log(`[FirmwareUpdateV4] preloading RESC bundle ${bundle.name}`);
-                    bundle.binary = (yield getSysResourceBinary(bundle.url)).binary;
+                    Log$5.log(`[FirmwareUpdateV4] downloading remote RESC bundle ${bundle.name}`);
+                    ({ binary } = yield getSysResourceBinary(bundle.url));
                 }
-                if (bundle.binary.byteLength === 0) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, `Protocol V2 RESC bundle is empty: ${bundle.name}`);
+                if (binary.byteLength === 0) {
+                    throw new Error(`Protocol V2 RESC bundle is empty: ${bundle.name}`);
+                }
+                prefetched.push(Object.assign(Object.assign({}, bundle), { binary }));
+            }
+            return prefetched;
+        });
+    }
+    syncProtocolV2ResourceBundles(bundles, firmwareSize) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transferStartTime = Date.now();
+            const transferTransport = this.getProtocolV2FirmwareTransferTransport();
+            const isRemoteMode = bundles.some(bundle => !!bundle.url);
+            let bundlesToSync = bundles;
+            if (isRemoteMode) {
+                const filtered = [];
+                for (const bundle of bundles) {
+                    const upToDate = yield this.isProtocolV2ResourceBundleUpToDate(bundle);
+                    if (upToDate) {
+                        Log$5.log(`[FirmwareUpdateV4] skip RESC bundle ${bundle.name}; already up to date`);
+                    }
+                    else {
+                        filtered.push(bundle);
+                    }
                 }
+                bundlesToSync = filtered;
+            }
+            if (bundlesToSync.length === 0) {
+                Log$5.log('[FirmwareUpdateV4] all RESC bundles up to date, nothing to sync');
+                return { processedSize: 0, totalSize: firmwareSize };
+            }
+            let totalSize = 0;
+            for (const b of bundlesToSync)
+                totalSize += b.binary.byteLength;
+            const transferTotalSize = totalSize + firmwareSize;
+            let processedSize = 0;
+            for (const bundle of bundlesToSync) {
+                Log$5.log(`[FirmwareUpdateV4] syncing RESC bundle ${bundle.name} -> ${bundle.devicePath} bytes=${bundle.binary.byteLength}`);
+                processedSize = yield this.protocolV2CommonUpdateProcess({
+                    payload: bundle.binary,
+                    filePath: bundle.devicePath,
+                    processedSize,
+                    totalSize: transferTotalSize,
+                });
             }
-            return bundles;
+            const elapsedMs = Date.now() - transferStartTime;
+            Log$5.log(`[FirmwareUpdateV4] RESC bundle sync finished transport=${transferTransport} bytes=${totalSize} elapsed=${(elapsedMs / 1000).toFixed(2)}s speed=${formatProtocolV2TransferSpeed(totalSize, elapsedMs)} KB/s`);
+            return { processedSize, totalSize: transferTotalSize };
         });
     }
     isProtocolV2ResourceBundleUpToDate(bundle) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if ((_a = this.params) === null || _a === void 0 ? void 0 : _a.forcedUpdateRes)
+            if (this.params.forcedUpdateRes)
                 return false;
             if (!bundle.version && !bundle.payloadHash)
                 return false;
@@ -50288,7 +48727,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isProtocolV2BootloaderMode() || ((_a = this.device.features) === null || _a === void 0 ? void 0 : _a.mode) === 'romloader') {
                 Log$5.debug('Protocol V2 device is already in loader mode, skip reboot to bootloader');
-                this.protocolV2ExecutionInLoader = true;
                 return false;
             }
             try {
@@ -50297,7 +48735,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.GoToBootloaderSuccess);
                 yield hdShared.wait(1000);
                 yield this.waitForProtocolV2BootloaderMode();
-                this.protocolV2ExecutionInLoader = true;
                 return true;
             }
             catch (error) {
@@ -50357,197 +48794,73 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         push(this.params.se04Binary, 'se04.bin', ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04);
         return entries;
     }
-    buildProtocolV2ExecutionPhases({ installSources, resourceSources, }) {
-        const phases = [];
-        if (resourceSources.length > 0) {
-            phases.push({
-                kind: 'resource-sync',
-                installSources: [],
-                resourceSources,
-            });
-        }
-        const bootloaderSources = installSources.filter(source => source.kind === 'bootloader');
-        if (bootloaderSources.length > 0) {
-            phases.push({
-                kind: 'bootloader-install',
-                installSources: bootloaderSources,
-                resourceSources: [],
-            }, {
-                kind: 'bootloader-verify',
-                installSources: [],
-                resourceSources: [],
-            });
-        }
-        const componentSources = installSources.filter(source => source.kind !== 'bootloader');
-        if (componentSources.length > 0) {
-            phases.push({
-                kind: 'component-install',
-                installSources: componentSources,
-                resourceSources: [],
-            });
-        }
-        phases.push({
-            kind: 'final-verify',
-            installSources: [],
-            resourceSources: [],
-        });
-        return phases;
-    }
-    executeProtocolV2Phases({ installSources, resourceSources, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const phases = this.buildProtocolV2ExecutionPhases({
-                installSources,
-                resourceSources,
-            });
-            for (const phase of phases) {
-                if (phase.kind === 'final-verify') {
-                    return this.completeProtocolV2FinalVerification();
-                }
-                if (phase.kind === 'resource-sync') {
-                    yield this.enterProtocolV2BootloaderMode();
-                    yield this.executeProtocolV2TransferPhase(phase);
-                }
-                else if (phase.kind === 'bootloader-install' || phase.kind === 'component-install') {
-                    yield this.enterProtocolV2BootloaderMode();
-                    yield this.executeProtocolV2TransferPhase(phase);
-                    yield this.exitProtocolV2BootloaderToNormal();
-                }
-                else if (phase.kind === 'bootloader-verify') {
-                    yield this.waitForProtocolV2FinalFeatures();
-                    this.assertExpectedProtocolV2Versions(['boot']);
-                }
-            }
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 execution has no final verification phase');
-        });
-    }
-    executeProtocolV2SourceUpdate({ installSources, resourceSources, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.executeProtocolV2Phases({
-                installSources,
-                resourceSources,
-            });
-        });
-    }
     executeProtocolV2Update({ fwBinaryMap, bootloaderBinary, installItems, resourceBundles, }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const memoryInstallItems = installItems !== null && installItems !== void 0 ? installItems : this.buildProtocolV2InstallItems({
-                fwBinaryMap: fwBinaryMap !== null && fwBinaryMap !== void 0 ? fwBinaryMap : [],
+            const orderedInstallItems = installItems !== null && installItems !== void 0 ? installItems : this.buildProtocolV2InstallItems({
                 bootloaderBinary: bootloaderBinary !== null && bootloaderBinary !== void 0 ? bootloaderBinary : null,
+                fwBinaryMap: fwBinaryMap !== null && fwBinaryMap !== void 0 ? fwBinaryMap : [],
             });
-            try {
-                const installSources = yield Promise.all(memoryInstallItems.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 = yield Promise.all((resourceBundles !== null && resourceBundles !== void 0 ? resourceBundles : []).map((bundle) => __awaiter(this, void 0, void 0, function* () {
-                    return ({
-                        name: bundle.name,
-                        source: yield this.openProtocolV2MemorySource(bundle.binary),
-                        devicePath: bundle.devicePath,
-                        version: bundle.version,
-                        payloadHash: bundle.payloadHash,
-                        headerHash: bundle.headerHash,
-                    });
-                })));
-                return yield this.executeProtocolV2Phases({
-                    installSources,
-                    resourceSources,
-                });
-            }
-            finally {
-                yield this.closeProtocolV2PreparedSources();
-            }
-        });
-    }
-    executeProtocolV2TransferPhase({ installSources, resourceSources, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let totalSize = installSources.reduce((total, item) => total + item.source.size, 0);
-            const resourcesToSync = [];
-            for (const resource of resourceSources) {
-                if (yield this.isProtocolV2ResourceBundleUpToDate(resource)) {
-                    Log$5.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
-                }
-                else {
-                    resourcesToSync.push(resource);
-                    totalSize += resource.source.size;
-                }
-            }
+            let firmwareSize = 0;
+            for (const item of orderedInstallItems)
+                firmwareSize += item.binary.byteLength;
             this.postTipMessage(exports.FirmwareUpdateTipMessage.StartTransferData);
             let processedSize = 0;
-            for (const resource of resourcesToSync) {
-                processedSize = yield this.protocolV2SourceUpdateProcess({
-                    source: resource.source,
-                    filePath: resource.devicePath,
-                    processedSize,
-                    totalSize,
-                });
-                yield this.verifyProtocolV2StagedFile(resource.devicePath, resource.source.size);
+            let totalSize = firmwareSize;
+            if (resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length) {
+                const resourceTransfer = yield this.syncProtocolV2ResourceBundles(resourceBundles, firmwareSize);
+                processedSize = resourceTransfer.processedSize;
+                totalSize = resourceTransfer.totalSize;
             }
-            const stagedInstallTargets = [];
-            for (const item of installSources) {
-                const filePath = this.getProtocolV2InstallItemStagingPath(item);
-                processedSize = yield this.protocolV2SourceUpdateProcess({
-                    source: item.source,
-                    filePath,
-                    processedSize,
-                    totalSize,
-                });
-                yield this.verifyProtocolV2StagedFile(filePath, item.source.size);
-                stagedInstallTargets.push({
-                    targetId: item.targetId,
-                    path: filePath,
-                });
+            if (orderedInstallItems.length === 0) {
+                Log$5.log('[FirmwareUpdateV4] no firmware targets to install (RESC bundles only)');
+                if (totalSize > 0) {
+                    this.postProgressMessage(100, 'transferData');
+                }
+                return;
             }
-            if (totalSize > 0) {
-                this.postProgressMessage(100, 'transferData');
+            let transferredSize = processedSize;
+            const transferStartTime = Date.now();
+            const transferTransport = this.getProtocolV2FirmwareTransferTransport();
+            const chunkSize = this.getProtocolV2FirmwareChunkSize();
+            const onTransferredBytes = (bytes) => {
+                transferredSize = bytes;
+            };
+            Log$5.log(`[FirmwareUpdateV4] transfer started transport=${transferTransport} total=${totalSize} bytes chunk=${chunkSize} bytes`);
+            const stagedInstallTargets = [];
+            try {
+                for (const item of orderedInstallItems) {
+                    const filePath = this.getProtocolV2InstallItemStagingPath(item);
+                    Log$5.log(`[FirmwareUpdateV4] staging ${item.kind} via FilesystemFileWrite target=${item.targetId} path=${filePath} source=${item.fileName} bytes=${item.binary.byteLength}`);
+                    processedSize = yield this.protocolV2CommonUpdateProcess({
+                        payload: item.binary,
+                        filePath,
+                        processedSize,
+                        totalSize,
+                        onTransferredBytes,
+                    });
+                    transferredSize = processedSize;
+                    yield this.verifyProtocolV2StagedFile(filePath, item.binary.byteLength);
+                    stagedInstallTargets.push(Object.assign(Object.assign({}, item), { path: filePath }));
+                }
+                if (totalSize > 0) {
+                    this.postProgressMessage(100, 'transferData');
+                }
+                const elapsedMs = Date.now() - transferStartTime;
+                Log$5.log(`[FirmwareUpdateV4] transfer finished transport=${transferTransport} bytes=${totalSize} elapsed=${(elapsedMs / 1000).toFixed(2)}s speed=${formatProtocolV2TransferSpeed(totalSize, elapsedMs)} KB/s`);
             }
-            if (stagedInstallTargets.length === 0) {
-                return;
+            catch (error) {
+                const elapsedMs = Date.now() - transferStartTime;
+                Log$5.warn(`[FirmwareUpdateV4] transfer failed transport=${transferTransport} bytes=${transferredSize}/${totalSize} elapsed=${(elapsedMs / 1000).toFixed(2)}s speed=${formatProtocolV2TransferSpeed(transferredSize, elapsedMs)} KB/s`);
+                throw error;
             }
             this.postTipMessage(exports.FirmwareUpdateTipMessage.ConfirmOnDevice);
-            const targets = stagedInstallTargets.map(item => ({
+            const allTargets = stagedInstallTargets.map(item => ({
                 target_id: item.targetId,
                 path: item.path,
             }));
-            yield this.protocolV2StartFirmwareUpdate({ targets });
-            yield this.waitForProtocolV2FirmwareUpdateComplete(targets);
-        });
-    }
-    protocolV2SourceUpdateProcess({ source, filePath, processedSize, totalSize, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let lastError;
-            for (let attempt = 1; attempt <= PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT; attempt += 1) {
-                try {
-                    yield writeFirmwareByteSource({
-                        source,
-                        chunkSize: this.getProtocolV2FirmwareChunkSize(),
-                        write: ({ data, sourceOffset, length, first }) => __awaiter(this, void 0, void 0, function* () {
-                            const chunkEnd = sourceOffset + length;
-                            const progress = getProtocolV2DeviceTransferProgress(processedSize + sourceOffset, processedSize + chunkEnd, totalSize);
-                            const response = yield this.fileWriteChunk(filePath, source.size, sourceOffset, data, first, progress);
-                            const rawProcessedByte = response.message.processed_byte;
-                            const nextOffset = rawProcessedByte === undefined ? chunkEnd : Number(rawProcessedByte);
-                            if (!Number.isFinite(nextOffset) || nextOffset !== chunkEnd) {
-                                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `invalid processed_byte ${rawProcessedByte} for offset ${sourceOffset}`);
-                            }
-                            this.postProgressMessage(progress, 'transferData');
-                            return length;
-                        }),
-                    });
-                    return processedSize + source.size;
-                }
-                catch (error) {
-                    lastError = error;
-                    if (attempt < PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
-                        yield this.recoverProtocolV2FileTransfer();
-                    }
-                }
-            }
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `transfer data error: ${getProtocolV2UnknownErrorText(lastError)}`);
+            Log$5.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateRequest targets=${JSON.stringify(allTargets)}`);
+            yield this.protocolV2StartFirmwareUpdate({ targets: allTargets });
+            yield this.waitForProtocolV2FirmwareUpdateComplete(allTargets);
         });
     }
     getProtocolV2InstallItemStagingPath(item) {
@@ -50564,7 +48877,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             }
         });
     }
-    assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths = new Map()) {
+    assertProtocolV2TargetStatus(statusTargets, expectedTargetIds) {
         var _a, _b, _c;
         Log$5.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateStatus records=${JSON.stringify(statusTargets)}`);
         const failedTarget = statusTargets.find(target => {
@@ -50583,34 +48896,8 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareError, `Protocol V2 firmware target failed: target=${failedTarget.target_id} status=${(_a = failedTarget.status) !== null && _a !== void 0 ? _a : 'unknown'} payloadVersion=${(_b = failedTarget.payload_version) !== null && _b !== void 0 ? _b : 'unknown'} path=${(_c = failedTarget.path) !== null && _c !== void 0 ? _c : 'unknown'}`);
         }
         const matchingTargets = statusTargets.filter(target => { var _a; return expectedTargetIds.has((_a = normalizeProtocolV2TargetId(target.target_id)) !== null && _a !== void 0 ? _a : -1); });
-        const seenTargetIds = new Set();
-        for (const target of matchingTargets) {
-            const targetId = normalizeProtocolV2TargetId(target.target_id);
-            if (targetId === undefined ||
-                seenTargetIds.has(targetId) ||
-                (target.path && expectedPaths.get(targetId) && target.path !== expectedPaths.get(targetId))) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 install status conflicts with target ${target.target_id}`);
-            }
-            seenTargetIds.add(targetId);
-        }
         const completedTargets = matchingTargets.filter(target => isProtocolV2TargetStatusFinished(target.status));
         if (completedTargets.length === expectedTargetIds.size && expectedTargetIds.size > 0) {
-            for (const target of completedTargets) {
-                const targetId = normalizeProtocolV2TargetId(target.target_id);
-                const payloadVersion = toProtocolV2FiniteNumber(target.payload_version);
-                if (targetId === undefined) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 completed target identity is invalid');
-                }
-                const expectedVersion = this.getExpectedProtocolV2TargetVersion(targetId);
-                if (expectedVersion !== undefined && payloadVersion !== undefined) {
-                    if (payloadVersion !== expectedVersion) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareVerificationFailed, `Protocol V2 target ${targetId} reached payload version ${payloadVersion}, expected ${expectedVersion}`);
-                    }
-                }
-                if (payloadVersion !== undefined) {
-                    this.protocolV2CompletedTargetVersions.set(targetId, payloadVersion);
-                }
-            }
             this.postProgressMessage(100, 'installingFirmware');
             return true;
         }
@@ -50623,10 +48910,9 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return false;
     }
     waitForProtocolV2FirmwareUpdateComplete(targets) {
-        var _a, _b;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const expectedTargetIds = new Set(targets.map(target => target.target_id));
-            const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
             const startTime = Date.now();
             let lastError;
             while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
@@ -50641,7 +48927,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                                 path: true,
                             },
                         }, { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT });
-                        if (this.assertProtocolV2TargetStatus(((_a = statusResponse.message.records) !== null && _a !== void 0 ? _a : []), expectedTargetIds, expectedPaths)) {
+                        if (this.assertProtocolV2TargetStatus(((_a = statusResponse.message.records) !== null && _a !== void 0 ? _a : []), expectedTargetIds)) {
                             return;
                         }
                         lastError = new Error('Protocol V2 firmware targets are still installing');
@@ -50652,24 +48938,8 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             throw error;
                         }
                         if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
-                            try {
-                                const deviceInfo = yield requestProtocolV2DeviceInfo({
-                                    commands: this.device.getCommands(),
-                                    timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
-                                });
-                                this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
-                                const observed = yield this.device.probeProtocolV2RuntimeState(deviceInfo, PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT);
-                                if (observed.mode === 'normal' && !observed.bootloaderMode) {
-                                    return;
-                                }
-                                lastError = new Error('Protocol V2 status endpoint is unavailable outside normal mode');
-                            }
-                            catch (probeError) {
-                                lastError = probeError;
-                            }
-                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 firmware install status is unavailable: ${this.normalizeErrorMessage(lastError)}`, {
-                                firmwareUpdateCode: 'FirmwareInstallStatusUnavailable',
-                            });
+                            Log$5.log('[FirmwareUpdateV4] firmware status endpoint unavailable after reboot; continue with normal-mode verification');
+                            return;
                         }
                         lastError = error;
                         Log$5.log('[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ', error);
@@ -50683,10 +48953,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     if (error instanceof hdShared.HardwareError && error.errorCode === hdShared.HardwareErrorCode.FirmwareError) {
                         throw error;
                     }
-                    if (error instanceof hdShared.HardwareError &&
-                        ((_b = error.params) === null || _b === void 0 ? void 0 : _b.firmwareUpdateCode) === 'FirmwareInstallStatusUnavailable') {
-                        throw error;
-                    }
                     Log$5.log('Protocol V2 firmware install device readiness probe failed: ', error);
                 }
                 yield hdShared.wait(1000);
@@ -50699,7 +48965,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             yield this.reconnectProtocolV2Device();
             yield this.verifyProtocolV2ReconnectIdentity();
             yield this.protocolV2Reboot(hdTransport.DeviceRebootType.Normal);
-            this.protocolV2ExecutionInLoader = false;
         });
     }
     waitForProtocolV2FinalFeatures() {
@@ -50708,7 +48973,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
             const bleVersion = getDeviceBLEFirmwareVersion(features).join('.');
             const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
-            this.protocolV2LatestFinalFeatures = features;
             if (firmwareVersion === '0.0.0') {
                 Log$5.warn('Protocol V2 firmware update finished but app firmware version is still 0.0.0. This is allowed for Pro2 debug BLE-only update flows.');
             }
@@ -50719,18 +48983,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             };
         });
     }
-    completeProtocolV2FinalVerification() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.protocolV2ExecutionInLoader || this.isProtocolV2BootloaderMode()) {
-                yield this.exitProtocolV2BootloaderToNormal();
-            }
-            const versions = yield this.waitForProtocolV2FinalFeatures();
-            this.assertExpectedProtocolV2Versions();
-            this.postTipMessage(exports.FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
-            DevicePool.resetState();
-            return versions;
-        });
-    }
     waitForProtocolV2ReconnectAndFeatures(timeout) {
         return __awaiter(this, void 0, void 0, function* () {
             const startTime = Date.now();
@@ -50806,6 +49058,66 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     isProtocolV2ReconnectIdentityError(error) {
         return this.normalizeErrorMessage(error).includes('Protocol V2 reconnect physical identity');
     }
+    protocolV2CommonUpdateProcess(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let lastError;
+            for (let attempt = 1; attempt <= PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT; attempt += 1) {
+                try {
+                    return yield this.protocolV2WriteWholeFile(params);
+                }
+                catch (error) {
+                    lastError = error;
+                    Log$5.error(`Protocol V2 file transfer failed path=${params.filePath} attempt=${attempt}/${PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT}; restarting from offset 0`, error);
+                    if (attempt === PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
+                        break;
+                    }
+                    yield this.recoverProtocolV2FileTransfer();
+                }
+            }
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `transfer data error: ${getProtocolV2UnknownErrorText(lastError)}`);
+        });
+    }
+    protocolV2WriteWholeFile({ payload, filePath, processedSize, totalSize, onTransferredBytes, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chunkSize = this.getProtocolV2FirmwareChunkSize();
+            let offset = 0;
+            const getUploadProgress = (fileOffset) => {
+                if (totalSize !== undefined && processedSize !== undefined) {
+                    return Math.min(Math.ceil(((processedSize + fileOffset) / totalSize) * 100), 99);
+                }
+                return Math.min(Math.ceil((fileOffset / payload.byteLength) * 100), 99);
+            };
+            while (offset < payload.byteLength) {
+                const chunkEnd = Math.min(offset + chunkSize, payload.byteLength);
+                const chunkLength = chunkEnd - offset;
+                const chunk = payload.slice(offset, chunkEnd);
+                const overwrite = offset === 0;
+                const progress = getProtocolV2DeviceTransferProgress((processedSize !== null && processedSize !== void 0 ? processedSize : 0) + offset, (processedSize !== null && processedSize !== void 0 ? processedSize : 0) + chunkEnd, totalSize !== null && totalSize !== void 0 ? totalSize : payload.byteLength);
+                const writeRes = yield this.fileWriteChunk(filePath, payload.byteLength, offset, chunk, overwrite, progress);
+                const rawProcessedByte = writeRes.message.processed_byte;
+                const processedByte = Number(rawProcessedByte);
+                const nextOffset = rawProcessedByte === undefined ? offset + chunkLength : processedByte;
+                if (!Number.isFinite(nextOffset) || nextOffset <= offset || nextOffset > chunkEnd) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `invalid processed_byte ${writeRes.message.processed_byte} for offset ${offset}`);
+                }
+                offset = nextOffset;
+                onTransferredBytes === null || onTransferredBytes === void 0 ? void 0 : onTransferredBytes((processedSize !== null && processedSize !== void 0 ? processedSize : 0) + offset);
+                this.postProgressMessage(getUploadProgress(offset), 'transferData');
+            }
+            return totalSize !== undefined ? (processedSize !== null && processedSize !== void 0 ? processedSize : 0) + payload.byteLength : 0;
+        });
+    }
+    getProtocolV2FirmwareTransferTransport() {
+        const env = DataManager.getSettings('env');
+        if (env && DataManager.isBleConnect(env)) {
+            return 'BLE';
+        }
+        if (env &&
+            (DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env) || env === 'web')) {
+            return 'WebUSB';
+        }
+        return env !== null && env !== void 0 ? env : 'unknown';
+    }
     fileWriteChunk(filePath, totalFileSize, offset, chunk, overwrite, progress) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -60685,6 +58997,7 @@ class NeoSignTransaction extends BaseMethod {
 var ApiMethods = /*#__PURE__*/Object.freeze({
     __proto__: null,
     testInitializeDeviceDuration: TestInitializeDeviceDuration,
+    testProtocolV2Ping: Ping,
     preInitialize: PreInitialize,
     searchDevices: SearchDevices,
     getFeatures: GetFeatures,
@@ -61230,7 +59543,7 @@ class ProtocolV2UiInteractionCoordinator {
 
 const Log$1 = getLogger(exports.LoggerNames.Core);
 function runMethodWithUnlockRetry(method, device, uiCoordinator) {
-    var _a;
+    var _a, _b, _c, _d;
     return __awaiter(this, void 0, void 0, function* () {
         const shouldEmitUi = isProtocolV2UiEnabled(method);
         const shouldUnlockBeforeRun = device.isProtocolV2() && method.unlockPolicy !== 'none' && ((_a = device.features) === null || _a === void 0 ? void 0 : _a.unlocked) === false;
@@ -61263,6 +59576,15 @@ function runMethodWithUnlockRetry(method, device, uiCoordinator) {
             }
             yield device.unlockDevice();
             Log$1.debug('Protocol V2 unlock completed', { method: method.name });
+            const expectedPassphraseState = ((_b = method.payload) === null || _b === void 0 ? void 0 : _b.useEmptyPassphrase)
+                ? undefined
+                : (_d = (_c = method.payload) === null || _c === void 0 ? void 0 : _c.passphraseState) !== null && _d !== void 0 ? _d : device.passphraseState;
+            if (method.useDevicePassphraseState &&
+                typeof expectedPassphraseState === 'string' &&
+                expectedPassphraseState.length > 0) {
+                yield restoreProtocolV2WalletSession(device, expectedPassphraseState);
+                Log$1.debug('Protocol V2 wallet session restored after unlock', { method: method.name });
+            }
             if (shouldEmitUi) {
                 uiCoordinator === null || uiCoordinator === void 0 ? void 0 : uiCoordinator.resumeMethodInteraction();
             }
@@ -61360,7 +59682,6 @@ const callAPI = (context, message) => __awaiter(void 0, void 0, void 0, function
         }
         return createResponseMessage((_b = method === null || method === void 0 ? void 0 : method.responseID) !== null && _b !== void 0 ? _b : message.id, false, { error });
     }
-    DevicePool.emitter.on(DEVICE.CONNECT, onDeviceConnectHandler);
     if (!method.useDevice) {
         updateMethodRequestContext(method, { status: 'running' });
         try {
@@ -61394,7 +59715,6 @@ const callAPI = (context, message) => __awaiter(void 0, void 0, void 0, function
 });
 const handlePreWarmSignal = (context, message, method) => __awaiter(void 0, void 0, void 0, function* () {
     const createAckResponse = () => {
-        DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
         completeMethodRequestContext(method);
         method.dispose();
         return createResponseMessage(method.responseID, true, true);
@@ -61821,8 +60141,14 @@ function connectDeviceForBle(method, device, retryCount = 0) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            yield device.acquire(method.payload.connectProtocol);
+            const shouldAcquire = !device.hasDeviceAcquire() || !device.commands || device.commands.disposed;
+            if (shouldAcquire) {
+                yield device.acquire(method.payload.connectProtocol);
+            }
             if ((_a = method.payload) === null || _a === void 0 ? void 0 : _a.onlyConnectBleDevice) {
+                if (shouldAcquire) {
+                    DevicePool.emitter.emit(DEVICE.CONNECT, device);
+                }
                 return;
             }
             if (!canSkipInitialize(method, device)) {
@@ -61832,6 +60158,9 @@ function connectDeviceForBle(method, device, retryCount = 0) {
                     passphraseState: initOptions.passphraseState,
                 });
             }
+            if (shouldAcquire) {
+                DevicePool.emitter.emit(DEVICE.CONNECT, device);
+            }
         }
         catch (err) {
             if ((err.errorCode === hdShared.HardwareErrorCode.BleTimeoutError ||
@@ -62069,7 +60398,6 @@ const cleanup = () => {
 };
 const removeDeviceListener = (device) => {
     device.removeAllListeners();
-    DevicePool.emitter.removeAllListeners(DEVICE.CONNECT);
 };
 const closePopup = () => {
     postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW));
@@ -62087,6 +60415,16 @@ const onDeviceDisconnectHandler = (device) => {
         return;
     postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject }));
 };
+const onTransportDeviceDisconnectHandler = (event) => {
+    var _a, _b;
+    const device = (_b = (_a = deviceCacheMap.get(event.connectId)) !== null && _a !== void 0 ? _a : DevicePool.devicesCache[event.connectId]) !== null && _b !== void 0 ? _b : DevicePool.getDeviceByPath(event.connectId);
+    if (!device) {
+        Log.debug('Ignoring transport disconnect for an unknown device:', event.connectId);
+        return;
+    }
+    device.markTransportDisconnected();
+    DevicePool.emitter.emit(DEVICE.DISCONNECT, device);
+};
 const onDevicePinHandler = (...[device, type, callback]) => __awaiter(void 0, void 0, void 0, function* () {
     Log.log('request Input PIN');
     const uiPromise = createUiPromise(UI_RESPONSE.RECEIVE_PIN, device);
@@ -62314,7 +60652,12 @@ const initCore = () => {
 };
 const initConnector = () => {
     _connector = new DeviceConnector();
+    DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
+    DevicePool.emitter.removeListener(DEVICE.DISCONNECT, onDeviceDisconnectHandler);
+    DevicePool.emitter.removeListener(hdTransport.TRANSPORT_EVENT.DEVICE_DISCONNECT, onTransportDeviceDisconnectHandler);
+    DevicePool.emitter.on(DEVICE.CONNECT, onDeviceConnectHandler);
     DevicePool.emitter.on(DEVICE.DISCONNECT, onDeviceDisconnectHandler);
+    DevicePool.emitter.on(hdTransport.TRANSPORT_EVENT.DEVICE_DISCONNECT, onTransportDeviceDisconnectHandler);
     return _connector;
 };
 const initTransport = (Transport, plugin) => {
@@ -62456,7 +60799,6 @@ exports.getEnv = getEnv;
 exports.getFirmwareType = getFirmwareType;
 exports.getFirmwareUpdateField = getFirmwareUpdateField;
 exports.getFirmwareUpdateFieldArray = getFirmwareUpdateFieldArray;
-exports.getFirmwareUpdateHostBindingGeneration = getFirmwareUpdateHostBindingGeneration;
 exports.getHDPath = getHDPath;
 exports.getHomeScreenDefaultList = getHomeScreenDefaultList;
 exports.getHomeScreenHex = getHomeScreenHex;
@@ -62482,12 +60824,10 @@ exports.parseConnectSettings = parseConnectSettings;
 exports.parseMessage = parseMessage;
 exports.patchFeatures = patchFeatures;
 exports.preloadSessionCache = preloadSessionCache;
-exports.registerFirmwareUpdateHostBinding = registerFirmwareUpdateHostBinding;
 exports.safeThrowError = safeThrowError;
 exports.setLoggerPostMessage = setLoggerPostMessage;
 exports.supportInputPinOnSoftware = supportInputPinOnSoftware;
 exports.switchTransport = switchTransport;
-exports.unregisterFirmwareUpdateHostBinding = unregisterFirmwareUpdateHostBinding;
 exports.updateRequestContext = updateRequestContext;
 exports.versionCompare = versionCompare;
 exports.versionSplit = versionSplit;