@onekeyfe/hd-core 1.2.8-alpha.128 → 1.2.8-alpha.129

package/dist/index.js

@@ -235,15 +235,24 @@ const readFirmwareByteSourceFully = (source) => __awaiter(void 0, void 0, void 0
 const readVerifiedFirmwareArtifact = ({ artifact, reader, }) => __awaiter(void 0, void 0, void 0, function* () {
     assertFirmwareArtifactReference(artifact);
     const source = yield ReaderFirmwareByteSource.open(artifact, reader);
+    const hasher = sha256.sha256.create();
     try {
-        const binary = yield readFirmwareByteSourceFully(source);
-        const actualSha256 = utils.bytesToHex(sha256.sha256(new Uint8Array(binary)));
+        const bytes = new Uint8Array(source.size);
+        let offset = 0;
+        while (offset < source.size) {
+            const length = Math.min(MAX_FIRMWARE_ARTIFACT_READ_BYTES, source.size - offset);
+            bytes.set(new Uint8Array(yield source.readAt(offset, length)), offset);
+            hasher.update(bytes.subarray(offset, offset + length));
+            offset += length;
+        }
+        const actualSha256 = utils.bytesToHex(hasher.digest());
         if (actualSha256 !== artifact.sha256.toLowerCase()) {
             return artifactError('FirmwareArtifactReceiptMismatch', 'Firmware artifact bytes do not match the approved SHA-256 receipt');
         }
-        return binary;
+        return bytes.buffer;
     }
     finally {
+        hasher.destroy();
         yield source.close().catch(() => undefined);
     }
 });
@@ -43071,6 +43080,7 @@ const findLatestRelease = (releases) => {
 const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH = 'vol0:/loaders/bootloader/boot_resource.okpkg';
 const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH = `${PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH}.staging`;
 const PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE = 0x5f90;
+const PROTOCOL_V2_RESOURCE_PACKAGE_COMPARE_SIZE = 0x280;
 const PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_VERSION = 1;
 const PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_OFFSET = 0x6c;
 const PROTOCOL_V2_RESOURCE_PACKAGE_FLEXIBLE_SIZE = 64;
@@ -43154,7 +43164,7 @@ function readResourceDevicePath(bytes) {
     return path;
 }
 function parseProtocolV2ResourcePackageHeader(bytes, packageSize) {
-    if (bytes.byteLength < PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE) {
+    if (bytes.byteLength < PROTOCOL_V2_RESOURCE_PACKAGE_COMPARE_SIZE) {
         throw new Error('Pro2 RESOURCE package is shorter than its header');
     }
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
@@ -43184,6 +43194,9 @@ function parseProtocolV2ResourcePackageHeader(bytes, packageSize) {
 }
 function parseProtocolV2ResourcePackage(binary) {
     const bytes = binary instanceof Uint8Array ? binary : new Uint8Array(binary);
+    if (bytes.byteLength < PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE) {
+        throw new Error('Pro2 RESOURCE package is shorter than its header');
+    }
     return parseProtocolV2ResourcePackageHeader(bytes, bytes.byteLength);
 }
 
@@ -45546,6 +45559,7 @@ class Device extends events.exports {
         super();
         this.deviceConnector = null;
         this.deviceAcquired = false;
+        this.releasedBleConnection = false;
         this.connectionAttempt = 0;
         this.interruptedAttempt = null;
         this.stateStore = new DeviceStateStore();
@@ -45650,6 +45664,7 @@ class Device extends events.exports {
         return __awaiter(this, void 0, void 0, function* () {
             const attempt = this.connectionAttempt;
             this.throwIfInterruptedByUser();
+            this.releasedBleConnection = false;
             const env = DataManager.getSettings('env');
             const mainIdKey = DataManager.isBleConnect(env) ? 'id' : 'session';
             const previousProtocol = this.originalDescriptor.protocolType;
@@ -45729,6 +45744,7 @@ class Device extends events.exports {
             const env = DataManager.getSettings('env');
             if ((this.isUsedHere() && !this.keepSession && this.mainId) ||
                 (this.mainId && DataManager.isBleConnect(env))) {
+                this.releasedBleConnection = false;
                 if (this.pendingCallbackPromise) {
                     try {
                         Log$i.debug('Waiting for callback tasks to complete before releasing device (in release method)');
@@ -45750,7 +45766,12 @@ class Device extends events.exports {
                     }
                 }
                 try {
-                    yield ((_a = this.deviceConnector) === null || _a === void 0 ? void 0 : _a.release(this.mainId, false, this.keepSession));
+                    const deviceType = this.getCurrentDeviceType();
+                    const keepBleConnection = (env === 'react-native' || env === 'desktop-web-ble') &&
+                        this.isProtocolV2() &&
+                        (deviceType === hdShared.EDeviceType.Pro2 || deviceType === hdShared.EDeviceType.Neo);
+                    yield ((_a = this.deviceConnector) === null || _a === void 0 ? void 0 : _a.release(this.mainId, false, this.keepSession || keepBleConnection));
+                    this.releasedBleConnection = keepBleConnection;
                 }
                 catch (err) {
                     Log$i.error('[Device] release error: ', err);
@@ -46359,6 +46380,7 @@ class Device extends events.exports {
     }
     markTransportDisconnected() {
         this.deviceAcquired = false;
+        this.releasedBleConnection = false;
         this.invalidateProtocolV2RuntimeState();
     }
     invalidateAfterWipe() {
@@ -46583,7 +46605,7 @@ class Device extends events.exports {
                         Log$i.debug('Protocol V2 fallback cancel error', cancelError);
                     }));
                 }
-                else if (!acquired) {
+                else if (!acquired && !this.releasedBleConnection) {
                     if (mainId && (deviceConnector === null || deviceConnector === void 0 ? void 0 : deviceConnector.disconnect)) {
                         Log$i.debug('interruptionFromUser: disconnecting device without acquire, mainId:', mainId);
                         yield deviceConnector.disconnect(mainId);
@@ -52533,11 +52555,276 @@ const INSTALLABLE_FIRMWARE_TARGET_IDS = new Set([
 ]);
 new Map(Object.entries(ProtocolV2FirmwareTargetType).flatMap(([key, value]) => INSTALLABLE_FIRMWARE_TARGET_IDS.has(value) ? [[key, value]] : []));
 
+const isProtocolV2UiEnabled = (method) => method.protocolV2UiMode !== 'none';
+const getDisplayState = (value) => {
+    const visited = new Set();
+    let seen = false;
+    let enabled = false;
+    const visit = (current) => {
+        if (current == null || typeof current !== 'object')
+            return;
+        if (visited.has(current))
+            return;
+        visited.add(current);
+        if (Array.isArray(current)) {
+            current.forEach(visit);
+            return;
+        }
+        Object.entries(current).forEach(([key, item]) => {
+            if ((key === 'show_display' || key === 'showOnOneKey') && typeof item === 'boolean') {
+                seen = true;
+                enabled || (enabled = item);
+                return;
+            }
+            visit(item);
+        });
+    };
+    visit(value);
+    return { seen, enabled };
+};
+const createMethodInteraction = (reason, operation) => ({
+    request: 'button',
+    source: 'method-lifecycle',
+    reason,
+    completion: 'operation-completed',
+    deviceOnly: true,
+    operation,
+});
+const hasCipherConfirmation = (value) => {
+    if (Array.isArray(value))
+        return value.some(hasCipherConfirmation);
+    if (value == null || typeof value !== 'object')
+        return false;
+    const params = value;
+    return params.encrypt === true ? params.ask_on_encrypt === true : params.ask_on_decrypt === true;
+};
+const resolveProtocolV2UiInteraction = (method) => {
+    if (method.protocolV2UiInteraction)
+        return method.protocolV2UiInteraction;
+    const operation = method.name;
+    if (!operation)
+        return undefined;
+    const isAddress = /getAddress(?:ByLoop)?$/i.test(operation);
+    const isPublicKey = /getPublicKey$/i.test(operation);
+    if (isAddress || isPublicKey) {
+        const paramsDisplay = getDisplayState(method.params);
+        const payloadDisplay = getDisplayState(method.payload);
+        const display = paramsDisplay.seen ? paramsDisplay : payloadDisplay;
+        const shouldDisplay = display.seen ? display.enabled : isAddress;
+        if (!shouldDisplay)
+            return undefined;
+        return createMethodInteraction(isAddress ? 'address-confirmation' : 'public-key-confirmation', operation);
+    }
+    if (/sign/i.test(operation) || /verifyMessage$/i.test(operation) || operation === 'lnurlAuth') {
+        return createMethodInteraction('signing-confirmation', operation);
+    }
+    if (operation === 'nostrEncryptMessage' || operation === 'nostrDecryptMessage') {
+        const display = getDisplayState(method.params);
+        if (!display.enabled)
+            return undefined;
+        return createMethodInteraction('signing-confirmation', operation);
+    }
+    if (operation === 'cipherKeyValue' && hasCipherConfirmation(method.params)) {
+        return createMethodInteraction('signing-confirmation', operation);
+    }
+    return undefined;
+};
+class ProtocolV2UiInteractionCoordinator {
+    constructor(device, postMessage) {
+        this.opened = false;
+        this.closed = false;
+        this.device = device;
+        this.postMessage = postMessage;
+    }
+    enterMethodInteraction(interaction) {
+        var _a, _b, _c, _d;
+        this.methodInteraction = interaction;
+        if (!interaction)
+            return;
+        const { request } = interaction, metadata = __rest(interaction, ["request"]);
+        const interactionMeta = (_b = (_a = this.device).createProtocolV2UiPhaseMetadata) === null || _b === void 0 ? void 0 : _b.call(_a, request === 'pin' ? 'pin' : 'button', 'start');
+        this.emit(request === 'pin' ? UI_REQUEST.REQUEST_PIN : UI_REQUEST.REQUEST_BUTTON, Object.assign(Object.assign({ device: this.device.toMessageObject() }, metadata), (interactionMeta ? { interaction: interactionMeta } : {})), `method:${request}:${interaction.reason}:${(_c = interaction.page) !== null && _c !== void 0 ? _c : ''}:${(_d = interaction.operation) !== null && _d !== void 0 ? _d : ''}`);
+    }
+    enterUnlockInteraction(method) {
+        var _a, _b;
+        const interaction = (_b = (_a = this.device).createProtocolV2UiPhaseMetadata) === null || _b === void 0 ? void 0 : _b.call(_a, 'pin', 'start');
+        this.emit(UI_REQUEST.REQUEST_PIN, Object.assign({ device: this.device.toMessageObject(), source: 'unlock-coordinator', reason: 'device-locked', deviceOnly: true, method }, (interaction ? { interaction } : {})), `unlock:${method !== null && method !== void 0 ? method : ''}`);
+        return interaction;
+    }
+    resumeMethodInteraction() {
+        this.enterMethodInteraction(this.methodInteraction);
+    }
+    close(options = {}) {
+        var _a, _b, _c, _d;
+        if ((!options.protocolV2Operation && !this.device.isProtocolV2()) ||
+            (!options.ensureOperationClose &&
+                !this.opened &&
+                !((_b = (_a = this.device).hasOpenProtocolV2UiInteraction) === null || _b === void 0 ? void 0 : _b.call(_a))) ||
+            this.closed)
+            return false;
+        this.closed = true;
+        const interaction = (_d = (_c = this.device).finishProtocolV2UiInteraction) === null || _d === void 0 ? void 0 : _d.call(_c, 'succeeded', {
+            ensureMetadata: options.ensureOperationClose,
+        });
+        const device = this.device.toMessageObject();
+        this.postMessage(interaction
+            ? createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW, Object.assign(Object.assign({}, interaction), (device ? { device } : {})))
+            : createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW));
+        return true;
+    }
+    emit(type, payload, phase) {
+        if (!this.device.isProtocolV2() || this.closed || this.currentPhase === phase)
+            return;
+        this.currentPhase = phase;
+        this.opened = true;
+        const message = type === UI_REQUEST.REQUEST_BUTTON
+            ? createUiMessage(UI_REQUEST.REQUEST_BUTTON, payload)
+            : createUiMessage(UI_REQUEST.REQUEST_PIN, payload);
+        this.postMessage(message);
+    }
+}
+
 const Log$7 = getLogger(exports.LoggerNames.Core);
+const createProtocolV2UnlockContext = () => ({
+    preflightCompleted: false,
+    preflightStatusRefreshed: false,
+    preflightMainPinSelected: false,
+});
+const resolvePreUnlockPinType = (method) => {
+    var _a, _b;
+    if (method.protocolV2PreUnlockPinType !== undefined) {
+        return method.protocolV2PreUnlockPinType;
+    }
+    const targetsKnownHiddenWallet = method.useDevicePassphraseState &&
+        ((_a = method.payload) === null || _a === void 0 ? void 0 : _a.useEmptyPassphrase) !== true &&
+        typeof ((_b = method.payload) === null || _b === void 0 ? void 0 : _b.passphraseState) === 'string' &&
+        method.payload.passphraseState.length > 0;
+    return targetsKnownHiddenWallet ? hdTransport.DeviceSessionPinType.Any : hdTransport.DeviceSessionPinType.Main;
+};
+function runMethodWithUnlockPolicy(method, device, options = {}) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        const { context = createProtocolV2UnlockContext(), uiCoordinator, afterStatusBeforeUnlock, prepare, run: configuredRun, } = options;
+        const run = configuredRun !== null && configuredRun !== void 0 ? configuredRun : (() => method.run());
+        method.protocolV2UnlockContext = context;
+        const shouldEmitUi = isProtocolV2UiEnabled(method);
+        const shouldCoordinateUi = shouldEmitUi && uiCoordinator !== undefined;
+        const requiresPreUnlock = device.isProtocolV2() &&
+            (method.useDevicePassphraseState || method.unlockPolicy === 'unlock-before-run') &&
+            ((_a = device.state) === null || _a === void 0 ? void 0 : _a.status.initialized) !== false &&
+            !((_b = device.isBootloader) === null || _b === void 0 ? void 0 : _b.call(device)) &&
+            !((_c = device.isRomloader) === null || _c === void 0 ? void 0 : _c.call(device));
+        if (requiresPreUnlock && !context.preflightCompleted) {
+            const status = yield refreshProtocolV2DeviceStatus(device);
+            if (typeof (status === null || status === void 0 ? void 0 : status.unlocked) !== 'boolean') {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 DeviceStatus did not report an explicit unlock state.');
+            }
+            yield (afterStatusBeforeUnlock === null || afterStatusBeforeUnlock === void 0 ? void 0 : afterStatusBeforeUnlock());
+            if (!status.unlocked) {
+                const preUnlockPinType = resolvePreUnlockPinType(method);
+                const unlockInteraction = shouldCoordinateUi
+                    ? uiCoordinator.enterUnlockInteraction(method.name)
+                    : undefined;
+                const unlockedStatus = yield device.unlockDevice(preUnlockPinType, shouldCoordinateUi
+                    ? { emitUiEvent: false, interaction: unlockInteraction }
+                    : {
+                        source: 'unlock-coordinator',
+                        reason: 'device-locked',
+                        deviceOnly: true,
+                        method: method.name,
+                    });
+                if ((unlockedStatus === null || unlockedStatus === void 0 ? void 0 : unlockedStatus.unlocked) !== true) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 device remained locked after the unlock flow.');
+                }
+                context.preflightMainPinSelected = preUnlockPinType === hdTransport.DeviceSessionPinType.Main;
+                Log$7.debug('Protocol V2 pre-unlock completed', { method: method.name });
+            }
+            context.preflightStatusRefreshed = true;
+            context.preflightCompleted = true;
+        }
+        yield (prepare === null || prepare === void 0 ? void 0 : prepare());
+        if (shouldCoordinateUi) {
+            uiCoordinator.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
+        }
+        return run();
+    });
+}
+
+const Log$6 = getLogger(exports.LoggerNames.Core);
 const MIN_FILE_CHUNK_SIZE = 64;
 const FILE_TRANSFER_RATE_WINDOW_MS = 1000;
 const FILE_TRANSFER_LOG_INTERVAL_MS = 10000;
 const SESSION_ERROR$1 = 'session not found';
+const ASSET_FILE_WRITE_MIN_APPLICATION_VERSION = '1.0.3';
+const ASSET_FILE_WRITE_RESPONSE_TIMEOUT = 10000;
+function createProtocolV2AssetFileWriteRecovery(method) {
+    var _a, _b, _c, _d;
+    const { device } = method;
+    const expectedSerialNo = (_b = (_a = device.state) === null || _a === void 0 ? void 0 : _a.identity) === null || _b === void 0 ? void 0 : _b.serialNo;
+    const expectedDeviceType = (_d = (_c = device.state) === null || _c === void 0 ? void 0 : _c.identity) === null || _d === void 0 ? void 0 : _d.deviceType;
+    return () => __awaiter(this, void 0, void 0, function* () {
+        var _e, _f, _g, _h, _j, _k, _l, _m;
+        if ((_e = method.abortSignal) === null || _e === void 0 ? void 0 : _e.aborted) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled);
+        }
+        if (!expectedSerialNo) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError);
+        }
+        yield device.acquire('V2', { throwOnRunPromiseError: true });
+        if ((_f = method.abortSignal) === null || _f === void 0 ? void 0 : _f.aborted) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled);
+        }
+        yield device.initialize();
+        if (!device.isProtocolV2() ||
+            ((_g = device.state) === null || _g === void 0 ? void 0 : _g.identity.serialNo) !== expectedSerialNo ||
+            ((_h = device.state) === null || _h === void 0 ? void 0 : _h.identity.deviceType) !== expectedDeviceType ||
+            !['normal', 'notInitialized'].includes((_k = (_j = device.state) === null || _j === void 0 ? void 0 : _j.status.mode) !== null && _k !== void 0 ? _k : '')) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError);
+        }
+        if ((_l = method.abortSignal) === null || _l === void 0 ? void 0 : _l.aborted) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled);
+        }
+        yield runMethodWithUnlockPolicy({
+            name: method.name,
+            unlockPolicy: method.unlockPolicy,
+            useDevicePassphraseState: method.useDevicePassphraseState,
+            protocolV2PreUnlockPinType: method.protocolV2PreUnlockPinType,
+            protocolV2UiMode: method.protocolV2UiMode,
+            payload: method.payload,
+            params: undefined,
+            run: () => Promise.resolve(undefined),
+        }, device, { uiCoordinator: new ProtocolV2UiInteractionCoordinator(device, method.postMessage) });
+        if ((_m = method.abortSignal) === null || _m === void 0 ? void 0 : _m.aborted) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled);
+        }
+        DevicePool.emitter.emit(DEVICE.CONNECT, device);
+        return device.commands;
+    });
+}
+function shouldPipelineAssetFileWrite(options) {
+    var _a, _b, _c, _d;
+    const env = DataManager.getSettings('env');
+    if (env !== 'react-native' && env !== 'desktop-web-ble')
+        return false;
+    if (options.overwrite !== true ||
+        options.append ||
+        ((_a = options.offset) !== null && _a !== void 0 ? _a : 0) !== 0 ||
+        ((_b = options.paceMs) !== null && _b !== void 0 ? _b : 0) > 0 ||
+        options.writeWithResponse === true ||
+        !/^vol1:\/(?:wallpapers\/wallpaper\.okpkg|nft\/nft-[0-9a-f]{8}-[1-9][0-9]*\.okpkg|portfolio\/portfolio\.okpkg\.pending)$/.test(options.path)) {
+        return false;
+    }
+    const { device } = options.commands;
+    const deviceType = device === null || device === void 0 ? void 0 : device.getCurrentDeviceType();
+    const firmwareVersion = (_c = device === null || device === void 0 ? void 0 : device.state) === null || _c === void 0 ? void 0 : _c.versions.firmware;
+    const mode = (_d = device === null || device === void 0 ? void 0 : device.state) === null || _d === void 0 ? void 0 : _d.status.mode;
+    return Boolean((device === null || device === void 0 ? void 0 : device.isProtocolV2()) &&
+        (deviceType === hdShared.EDeviceType.Pro2 || deviceType === hdShared.EDeviceType.Neo) &&
+        (mode === 'normal' || mode === 'notInitialized') &&
+        firmwareVersion &&
+        semver__default["default"].valid(firmwareVersion) &&
+        semver__default["default"].gte(firmwareVersion, ASSET_FILE_WRITE_MIN_APPLICATION_VERSION));
+}
 function formatFileTransferRate(bytesPerSecond) {
     return (Math.max(bytesPerSecond, 0) / 1024).toFixed(2);
 }
@@ -52550,11 +52837,11 @@ function getFileTransferTransport() {
     const env = DataManager.getSettings('env');
     return env && DataManager.isBleConnect(env) ? 'BLE' : String(env !== null && env !== void 0 ? env : 'unknown');
 }
-function logFileTransferMetrics({ transport, status, path, transferredBytes, totalBytes, elapsedMs, rateBytesPerSecond, hostWriteElapsedMs, responseWaitElapsedMs, measuredAttempts, }) {
+function logFileTransferMetrics({ transport, status, path, transferredBytes, totalBytes, elapsedMs, rateBytesPerSecond, hostWriteElapsedMs, responseWaitElapsedMs, measuredAttempts, fileWriteWindow, chunkSize, retryCount, }) {
     const segmentedMetrics = measuredAttempts > 0
         ? ` hostWriteTotal=${(hostWriteElapsedMs / 1000).toFixed(2)}s responseWaitTotal=${(responseWaitElapsedMs / 1000).toFixed(2)}s measuredAttempts=${measuredAttempts}`
         : '';
-    Log$7.log(`[FileWrite] metrics transport=${transport} status=${status} path=${path} bytes=${transferredBytes}/${totalBytes} elapsed=${(elapsedMs / 1000).toFixed(2)}s speed=${formatFileTransferRate(rateBytesPerSecond)} KiB/s${segmentedMetrics}`);
+    Log$6.log(`[FileWrite] metrics transport=${transport} status=${status} path=${path} bytes=${transferredBytes}/${totalBytes} elapsed=${(elapsedMs / 1000).toFixed(2)}s speed=${formatFileTransferRate(rateBytesPerSecond)} KiB/s${segmentedMetrics} window=${fileWriteWindow} chunk=${chunkSize} retry=${retryCount} averageSpeed=${formatFileTransferRate(getAverageFileTransferRate(transferredBytes, elapsedMs))} KiB/s`);
 }
 function isProtocolV2ResponseTimeout(error) {
     var _a, _b;
@@ -52617,7 +52904,7 @@ function getConfirmedProgress(processed, total, written, length) {
     return 100;
 }
 function writeProtocolV2File(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    var _a, _b, _c, _d, _e, _f;
     return __awaiter(this, void 0, void 0, function* () {
         (_a = options.throwIfAborted) === null || _a === void 0 ? void 0 : _a.call(options);
         const data = yield dataToUint8Array(options.data);
@@ -52630,15 +52917,21 @@ function writeProtocolV2File(options) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite totalSize ${totalSize} is smaller than offset + data length ${startOffset + dataLength}`);
         }
         const defaultChunkSizeLimit = getProtocolV2FileChunkLimit(options.bleChunkSizeLimit);
+        const pipelineAsset = totalSize === dataLength && shouldPipelineAssetFileWrite(options);
         const configuredChunkSizeLimit = Number(options.chunkSizeLimit);
         const chunkSizeLimit = Number.isFinite(configuredChunkSizeLimit) && configuredChunkSizeLimit > 0
             ? Math.floor(configuredChunkSizeLimit)
             : defaultChunkSizeLimit;
-        const chunkSize = normalizeChunkSize((_b = options.chunkSize) !== null && _b !== void 0 ? _b : options.chunkLen, chunkSizeLimit);
+        const chunkSize = normalizeChunkSize((_b = options.chunkSize) !== null && _b !== void 0 ? _b : options.chunkLen, pipelineAsset ? Math.min(chunkSizeLimit, hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE) : chunkSizeLimit);
+        const fileWriteWindow = pipelineAsset && dataLength > chunkSize ? hdTransport.PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW : 1;
         let written = 0;
         let chunks = 0;
         let lastMessage;
-        const startTime = Date.now();
+        let { commands } = options;
+        let retryCount = 0;
+        const maxChunkRetries = Math.max(Math.floor((_c = options.maxChunkRetries) !== null && _c !== void 0 ? _c : 0), 0);
+        const canRecoverPipeline = pipelineAsset && dataLength > chunkSize && options.recoverConnection;
+        let startTime = Date.now();
         let rateWindowStartedAt = startTime;
         let rateWindowStartedBytes = 0;
         let rateBytesPerSecond;
@@ -52648,26 +52941,151 @@ function writeProtocolV2File(options) {
         let hostWriteElapsedMs = 0;
         let responseWaitElapsedMs = 0;
         let measuredAttempts = 0;
+        const createRequest = (position) => {
+            var _a, _b, _c, _d, _e;
+            const chunk = data.slice(position, Math.min(position + chunkSize, dataLength));
+            const offset = startOffset + position;
+            const progress = (_c = (_a = options.uiPercentage) !== null && _a !== void 0 ? _a : (_b = options.getUiPercentage) === null || _b === void 0 ? void 0 : _b.call(options, {
+                offset,
+                chunkLength: chunk.byteLength,
+                totalSize,
+            })) !== null && _c !== void 0 ? _c : getDeviceTransferProgress(offset, offset + chunk.byteLength, totalSize);
+            return {
+                file: { path: options.path, offset, total_size: totalSize, data: chunk },
+                overwrite: position === 0 ? (_d = options.overwrite) !== null && _d !== void 0 ? _d : false : false,
+                append: (_e = options.append) !== null && _e !== void 0 ? _e : false,
+                ui_percentage: progress,
+            };
+        };
+        const confirmChunk = (response, offset, chunkLength) => {
+            var _a, _b, _c, _d;
+            const responseType = response.type;
+            if (responseType && responseType !== 'FilesystemFile') {
+                const responseError = (_a = response.message) === null || _a === void 0 ? void 0 : _a.error;
+                if (typeof responseError === 'string' && responseError.includes(SESSION_ERROR$1)) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR$1);
+                }
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite received unexpected response ${responseType}`);
+            }
+            (_b = options.throwIfAborted) === null || _b === void 0 ? void 0 : _b.call(options);
+            lastMessage = response.message;
+            const rawProcessedByte = (_c = response.message) === null || _c === void 0 ? void 0 : _c.processed_byte;
+            const processedByte = Number(rawProcessedByte);
+            if (rawProcessedByte !== undefined &&
+                (!Number.isFinite(processedByte) ||
+                    processedByte <= offset ||
+                    processedByte > offset + chunkLength)) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite invalid processed_byte ${processedByte}`);
+            }
+            written = rawProcessedByte === undefined ? written + chunkLength : processedByte - startOffset;
+            chunks += 1;
+            const now = Date.now();
+            lastConfirmedAt = now;
+            const elapsedMs = now - startTime;
+            const transferredBytes = Math.min(written, dataLength);
+            const rateWindowElapsedMs = now - rateWindowStartedAt;
+            if (rateWindowElapsedMs >= FILE_TRANSFER_RATE_WINDOW_MS) {
+                const rateWindowBytes = Math.max(transferredBytes - rateWindowStartedBytes, 0);
+                rateBytesPerSecond = Math.round((rateWindowBytes / rateWindowElapsedMs) * 1000);
+                rateWindowStartedAt = now;
+                rateWindowStartedBytes = transferredBytes;
+            }
+            else if (rateBytesPerSecond === undefined && elapsedMs > 0) {
+                rateBytesPerSecond = Math.round((transferredBytes / elapsedMs) * 1000);
+            }
+            (_d = options.onProgress) === null || _d === void 0 ? void 0 : _d.call(options, Object.assign({ progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength), transferredBytes, totalBytes: dataLength, rateBytesPerSecond,
+                elapsedMs }, (retryCount > 0 ? { retryCount } : {})));
+            const logWindowElapsedMs = now - logWindowStartedAt;
+            if (logWindowElapsedMs >= FILE_TRANSFER_LOG_INTERVAL_MS && transferredBytes < dataLength) {
+                const logWindowBytes = Math.max(transferredBytes - logWindowStartedBytes, 0);
+                logFileTransferMetrics({
+                    transport,
+                    status: 'progress',
+                    path: options.path,
+                    transferredBytes,
+                    totalBytes: dataLength,
+                    elapsedMs,
+                    rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+                    hostWriteElapsedMs,
+                    responseWaitElapsedMs,
+                    measuredAttempts,
+                    fileWriteWindow,
+                    chunkSize,
+                    retryCount,
+                });
+                logWindowStartedAt = now;
+                logWindowStartedBytes = transferredBytes;
+            }
+        };
         const transport = getFileTransferTransport();
-        Log$7.log(`[FileWrite] started transport=${transport} path=${options.path} bytes=${dataLength} offset=${startOffset} chunk=${chunkSize}`);
-        try {
+        Log$6.log(`[FileWrite] started transport=${transport} path=${options.path} bytes=${dataLength} offset=${startOffset} chunk=${chunkSize}`);
+        const writeAttempt = () => __awaiter(this, void 0, void 0, function* () {
+            var _g, _h, _j, _k, _l, _m, _o, _p;
+            (_g = options.throwIfAborted) === null || _g === void 0 ? void 0 : _g.call(options);
+            const attemptRetryCount = retryCount;
+            if (fileWriteWindow === hdTransport.PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW) {
+                Log$6.debug('[FileWrite] BLE asset pipeline', {
+                    path: options.path,
+                    window: fileWriteWindow,
+                    chunkSize,
+                    retryCount,
+                    applicationVersion: (_j = (_h = commands.device) === null || _h === void 0 ? void 0 : _h.state) === null || _j === void 0 ? void 0 : _j.versions.firmware,
+                });
+                let sendOffset = chunkSize;
+                let interrupted = false;
+                let interruption;
+                const response = yield commands.typedCall('FilesystemFileWrite', 'FilesystemFile', createRequest(0), {
+                    timeoutMs: (_k = options.timeoutMs) !== null && _k !== void 0 ? _k : ASSET_FILE_WRITE_RESPONSE_TIMEOUT,
+                    writeWithResponse: false,
+                    fileWritePipeline: {
+                        next: () => {
+                            var _a;
+                            if (interrupted || attemptRetryCount !== retryCount || sendOffset >= dataLength)
+                                return Promise.resolve(undefined);
+                            try {
+                                (_a = options.throwIfAborted) === null || _a === void 0 ? void 0 : _a.call(options);
+                                const request = createRequest(sendOffset);
+                                sendOffset += request.file.data.byteLength;
+                                return Promise.resolve(request);
+                            }
+                            catch (error) {
+                                interrupted = true;
+                                interruption = error;
+                                return Promise.resolve(undefined);
+                            }
+                        },
+                        onResponse: confirmed => {
+                            if (interrupted || attemptRetryCount !== retryCount)
+                                return;
+                            try {
+                                const offset = startOffset + written;
+                                const length = Math.min(chunkSize, dataLength - written);
+                                if (Number(confirmed.message.processed_byte) !== offset + length) {
+                                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'FilesystemFileWrite pipeline did not confirm the complete chunk');
+                                }
+                                confirmChunk(confirmed, offset, length);
+                            }
+                            catch (error) {
+                                interrupted = true;
+                                interruption = error;
+                            }
+                        },
+                    },
+                });
+                (_l = options.throwIfAborted) === null || _l === void 0 ? void 0 : _l.call(options);
+                if (interrupted)
+                    throw interruption;
+                if (response.type !== 'FilesystemFile' ||
+                    Number(response.message.processed_byte) !== startOffset + dataLength ||
+                    written !== dataLength) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'FilesystemFileWrite pipeline ended before the complete file was confirmed');
+                }
+            }
             while (written < dataLength) {
-                (_c = options.throwIfAborted) === null || _c === void 0 ? void 0 : _c.call(options);
-                const chunk = data.slice(written, Math.min(written + chunkSize, dataLength));
-                const offset = startOffset + written;
-                const progress = (_f = (_d = options.uiPercentage) !== null && _d !== void 0 ? _d : (_e = options.getUiPercentage) === null || _e === void 0 ? void 0 : _e.call(options, {
-                    offset,
-                    chunkLength: chunk.byteLength,
-                    totalSize,
-                })) !== null && _f !== void 0 ? _f : getDeviceTransferProgress(offset, offset + chunk.byteLength, totalSize);
-                const request = {
-                    file: { path: options.path, offset, total_size: totalSize, data: chunk },
-                    overwrite: chunks === 0 ? (_g = options.overwrite) !== null && _g !== void 0 ? _g : false : false,
-                    append: (_h = options.append) !== null && _h !== void 0 ? _h : false,
-                    ui_percentage: progress,
-                };
-                const maxChunkRetries = Math.max(Math.floor((_j = options.maxChunkRetries) !== null && _j !== void 0 ? _j : 0), 0);
-                let retryCount = 0;
+                (_m = options.throwIfAborted) === null || _m === void 0 ? void 0 : _m.call(options);
+                const request = createRequest(written);
+                const { offset, data: chunk } = request.file;
+                let chunkRetryCount = 0;
                 let response;
                 let isWritePending = true;
                 while (isWritePending) {
@@ -52676,7 +53094,7 @@ function writeProtocolV2File(options) {
                     try {
                         const callOptions = options.writeWithResponse === undefined
                             ? {
-                                timeoutMs: options.timeoutMs,
+                                timeoutMs: (_o = options.timeoutMs) !== null && _o !== void 0 ? _o : (canRecoverPipeline ? ASSET_FILE_WRITE_RESPONSE_TIMEOUT : undefined),
                                 onWriteCompleted: ({ elapsedMs }) => {
                                     currentHostWriteElapsedMs = elapsedMs;
                                     responseWaitStartedAt = Date.now();
@@ -52686,14 +53104,16 @@ function writeProtocolV2File(options) {
                                     currentHostWriteElapsedMs = elapsedMs;
                                     responseWaitStartedAt = Date.now();
                                 } });
-                        response = yield options.commands.typedCall('FilesystemFileWrite', 'FilesystemFile', request, callOptions);
+                        response = yield commands.typedCall('FilesystemFileWrite', 'FilesystemFile', request, callOptions);
                         isWritePending = false;
                     }
                     catch (error) {
-                        if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error))
+                        if (canRecoverPipeline ||
+                            chunkRetryCount >= maxChunkRetries ||
+                            !isProtocolV2ResponseTimeout(error))
                             throw error;
-                        retryCount += 1;
-                        (_k = options.throwIfAborted) === null || _k === void 0 ? void 0 : _k.call(options);
+                        chunkRetryCount += 1;
+                        (_p = options.throwIfAborted) === null || _p === void 0 ? void 0 : _p.call(options);
                     }
                     finally {
                         if (currentHostWriteElapsedMs !== undefined && responseWaitStartedAt !== undefined) {
@@ -52706,92 +53126,71 @@ function writeProtocolV2File(options) {
                 if (!response) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'FilesystemFileWrite completed without a response');
                 }
-                const responseType = response.type;
-                if (responseType && responseType !== 'FilesystemFile') {
-                    const responseError = (_l = response.message) === null || _l === void 0 ? void 0 : _l.error;
-                    if (typeof responseError === 'string' && responseError.includes(SESSION_ERROR$1)) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR$1);
-                    }
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite received unexpected response ${responseType}`);
-                }
-                (_m = options.throwIfAborted) === null || _m === void 0 ? void 0 : _m.call(options);
-                lastMessage = response.message;
-                const rawProcessedByte = (_o = response.message) === null || _o === void 0 ? void 0 : _o.processed_byte;
-                const processedByte = Number(rawProcessedByte);
-                if (rawProcessedByte !== undefined &&
-                    (!Number.isFinite(processedByte) ||
-                        processedByte <= offset ||
-                        processedByte > offset + chunk.byteLength)) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite invalid processed_byte ${processedByte}`);
+                confirmChunk(response, offset, chunk.byteLength);
+                if (options.paceMs && options.paceMs > 0) {
+                    yield new Promise(resolve => {
+                        setTimeout(resolve, options.paceMs);
+                    });
                 }
-                written =
-                    rawProcessedByte === undefined ? written + chunk.byteLength : processedByte - startOffset;
-                chunks += 1;
+            }
+        });
+        while (true) {
+            try {
+                yield writeAttempt();
+                break;
+            }
+            catch (error) {
                 const now = Date.now();
-                lastConfirmedAt = now;
-                const elapsedMs = now - startTime;
-                const transferredBytes = Math.min(written, dataLength);
-                const rateWindowElapsedMs = now - rateWindowStartedAt;
-                if (rateWindowElapsedMs >= FILE_TRANSFER_RATE_WINDOW_MS) {
-                    const rateWindowBytes = Math.max(transferredBytes - rateWindowStartedBytes, 0);
-                    rateBytesPerSecond = Math.round((rateWindowBytes / rateWindowElapsedMs) * 1000);
-                    rateWindowStartedAt = now;
-                    rateWindowStartedBytes = transferredBytes;
-                }
-                else if (rateBytesPerSecond === undefined && elapsedMs > 0) {
-                    rateBytesPerSecond = Math.round((transferredBytes / elapsedMs) * 1000);
-                }
-                (_p = options.onProgress) === null || _p === void 0 ? void 0 : _p.call(options, {
-                    progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
-                    transferredBytes,
+                const elapsedMs = Math.max(now - startTime, 0);
+                const logWindowElapsedMs = Math.max(now - logWindowStartedAt, 0);
+                const logWindowBytes = Math.max(written - logWindowStartedBytes, 0);
+                logFileTransferMetrics({
+                    transport,
+                    status: 'failed',
+                    path: options.path,
+                    transferredBytes: written,
                     totalBytes: dataLength,
-                    rateBytesPerSecond,
                     elapsedMs,
+                    rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+                    hostWriteElapsedMs,
+                    responseWaitElapsedMs,
+                    measuredAttempts,
+                    fileWriteWindow,
+                    chunkSize,
+                    retryCount,
                 });
-                const logWindowElapsedMs = now - logWindowStartedAt;
-                if (logWindowElapsedMs >= FILE_TRANSFER_LOG_INTERVAL_MS && transferredBytes < dataLength) {
-                    const logWindowBytes = Math.max(transferredBytes - logWindowStartedBytes, 0);
-                    logFileTransferMetrics({
-                        transport,
-                        status: 'progress',
-                        path: options.path,
-                        transferredBytes,
-                        totalBytes: dataLength,
-                        elapsedMs,
-                        rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
-                        hostWriteElapsedMs,
-                        responseWaitElapsedMs,
-                        measuredAttempts,
-                    });
-                    logWindowStartedAt = now;
-                    logWindowStartedBytes = transferredBytes;
-                }
-                if (options.paceMs && options.paceMs > 0) {
-                    yield new Promise(resolve => {
-                        setTimeout(resolve, options.paceMs);
-                    });
+                if (!canRecoverPipeline ||
+                    retryCount >= maxChunkRetries ||
+                    !isProtocolV2ResponseTimeout(error)) {
+                    throw error;
                 }
+                (_d = options.throwIfAborted) === null || _d === void 0 ? void 0 : _d.call(options);
+                retryCount += 1;
+                Log$6.log(`[FileWrite] retry=${retryCount}/${maxChunkRetries} restarting window=${fileWriteWindow} after reconnect path=${options.path}`);
+                (_e = options.onProgress) === null || _e === void 0 ? void 0 : _e.call(options, {
+                    progress: 0,
+                    transferredBytes: 0,
+                    totalBytes: dataLength,
+                    elapsedMs: 0,
+                    retryCount,
+                });
+                commands = yield canRecoverPipeline();
+                (_f = options.throwIfAborted) === null || _f === void 0 ? void 0 : _f.call(options);
+                written = 0;
+                chunks = 0;
+                lastMessage = undefined;
+                startTime = Date.now();
+                lastConfirmedAt = startTime;
+                rateWindowStartedAt = startTime;
+                rateWindowStartedBytes = 0;
+                rateBytesPerSecond = undefined;
+                logWindowStartedAt = startTime;
+                logWindowStartedBytes = 0;
+                hostWriteElapsedMs = 0;
+                responseWaitElapsedMs = 0;
+                measuredAttempts = 0;
             }
         }
-        catch (error) {
-            const now = Date.now();
-            const elapsedMs = Math.max(now - startTime, 0);
-            const logWindowElapsedMs = Math.max(now - logWindowStartedAt, 0);
-            const logWindowBytes = Math.max(written - logWindowStartedBytes, 0);
-            logFileTransferMetrics({
-                transport,
-                status: 'failed',
-                path: options.path,
-                transferredBytes: written,
-                totalBytes: dataLength,
-                elapsedMs,
-                rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
-                hostWriteElapsedMs,
-                responseWaitElapsedMs,
-                measuredAttempts,
-            });
-            throw error;
-        }
         const elapsedMs = Math.max(lastConfirmedAt - startTime, 0);
         const logWindowElapsedMs = Math.max(lastConfirmedAt - logWindowStartedAt, 0);
         const logWindowBytes = Math.max(written - logWindowStartedBytes, 0);
@@ -52806,12 +53205,16 @@ function writeProtocolV2File(options) {
             hostWriteElapsedMs,
             responseWaitElapsedMs,
             measuredAttempts,
+            fileWriteWindow,
+            chunkSize,
+            retryCount,
         });
         return Object.assign(Object.assign({}, lastMessage), { path: options.path, offset: startOffset, total_size: totalSize, processed_byte: startOffset + written, chunks });
     });
 }
 
-const Log$6 = getLogger(exports.LoggerNames.Method);
+const Log$5 = getLogger(exports.LoggerNames.Method);
+const TransferLog = getLogger(exports.LoggerNames.Core);
 const SESSION_ERROR = 'session not found';
 const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
 const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 3 * 60 * 1000;
@@ -52836,6 +53239,7 @@ const PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT = 3;
 const PROTOCOL_V2_RESOURCE_HEADER_RECOVERY_LIMIT = 2;
 const PROTOCOL_V2_BLE_FILE_WRITE_WINDOW_MIN_BOOTLOADER_VERSION = '1.0.3';
 const PROTOCOL_V2_TRANSFER_PROGRESS_HEARTBEAT_MS = 1000;
+const PROTOCOL_V2_TRANSFER_LOG_INTERVAL_MS = 10000;
 const PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE = 'FirmwareInstallStatusConflict';
 const PROTOCOL_V2_INSTALL_FAILED_CODE = 'FirmwareInstallFailed';
 const PROTOCOL_V2_INSTALL_TIMEOUT_CODE = 'FirmwareInstallTimeout';
@@ -53143,7 +53547,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         this.protocolV2InstallTerminalSuccessObserved = false;
         this.protocolV2LastTransferProgressAt = 0;
         this.protocolV2LastTransferredBytes = 0;
-        this.protocolV2FileWriteWindowDisabled = false;
     }
     getSupportedProtocols() {
         return ['V2'];
@@ -53316,7 +53719,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            Log$6.debug('FirmwareUpdateV4 strategy: Protocol V2');
+            Log$5.debug('FirmwareUpdateV4 strategy: Protocol V2');
             return this.runProtocolV2();
         });
     }
@@ -53749,7 +54152,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             if (!observedVersion) {
                 const hasCompleteTargetEvidence = targetId !== undefined && this.protocolV2CompletedTargetIds.has(targetId);
                 if (hasCompleteTargetEvidence) {
-                    Log$6.warn(`Protocol V2 target ${target} has no observable final version; install completion is authoritative`);
+                    Log$5.warn(`Protocol V2 target ${target} has no observable final version; install completion is authoritative`);
                 }
                 else {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareVerificationFailed, `Protocol V2 target ${target} has no observable final version after status fallback`);
@@ -54061,8 +54464,8 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const chunkSize = this.getProtocolV2FirmwareChunkSize('read');
             const chunks = [];
             let offset = 0;
-            while (offset < PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE) {
-                const readLen = Math.min(chunkSize, PROTOCOL_V2_RESOURCE_PACKAGE_HEADER_SIZE - offset);
+            while (offset < PROTOCOL_V2_RESOURCE_PACKAGE_COMPARE_SIZE) {
+                const readLen = Math.min(chunkSize, PROTOCOL_V2_RESOURCE_PACKAGE_COMPARE_SIZE - offset);
                 const res = yield typedCall('FilesystemFileRead', 'FilesystemFile', {
                     file: {
                         path: filePath,
@@ -54073,7 +54476,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     ui_percentage: undefined,
                 });
                 const data = toProtocolV2Bytes((_d = res.message) === null || _d === void 0 ? void 0 : _d.data);
-                if (data.byteLength === 0)
+                if (data.byteLength === 0 || data.byteLength > readLen)
                     return null;
                 chunks.push(data);
                 offset += data.byteLength;
@@ -54119,7 +54522,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             catch (error) {
                 if (isProtocolV2ResourceHeaderLinkError(error))
                     throw error;
-                Log$6.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
+                Log$5.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
                 return false;
             }
         });
@@ -54133,11 +54536,11 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 catch (error) {
                     this.throwIfAborted();
                     if (recovery.remaining <= 0) {
-                        Log$6.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check lost the link; reconnect budget used up: `, getProtocolV2UnknownErrorText(error));
+                        Log$5.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check lost the link; reconnect budget used up: `, getProtocolV2UnknownErrorText(error));
                         return false;
                     }
                     recovery.remaining -= 1;
-                    Log$6.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check lost the link; reconnecting: `, getProtocolV2UnknownErrorText(error));
+                    Log$5.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check lost the link; reconnecting: `, getProtocolV2UnknownErrorText(error));
                 }
                 yield this.recoverProtocolV2FileTransfer();
                 this.throwIfAborted();
@@ -54165,11 +54568,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return ((_a = this.device.features) === null || _a === void 0 ? void 0 : _a.mode) === 'romloader';
     }
     rebootProtocolV2ToBootloader() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.AutoRebootToBootloader);
                 yield this.protocolV2Reboot(hdTransport.DeviceRebootType.Bootloader);
                 yield hdShared.wait(1000);
+                if (this.isBleReconnect()) {
+                    yield ((_a = this.device.deviceConnector) === null || _a === void 0 ? void 0 : _a.disconnect(this.device.originalDescriptor.id));
+                }
                 yield this.waitForProtocolV2BootloaderMode();
                 this.protocolV2ExecutionInLoader = true;
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.GoToBootloaderSuccess);
@@ -54179,7 +54586,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 if (error instanceof hdShared.HardwareError) {
                     throw error;
                 }
-                Log$6.log('Protocol V2 auto go to bootloader mode failed: ', error);
+                Log$5.log('Protocol V2 auto go to bootloader mode failed: ', error);
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure);
             }
         });
@@ -54187,12 +54594,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     enterProtocolV2BootloaderMode() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isProtocolV2RomloaderMode()) {
-                Log$6.debug('Protocol V2 device is in romloader mode; start firmware update directly');
+                Log$5.debug('Protocol V2 device is in romloader mode; start firmware update directly');
                 this.protocolV2ExecutionInLoader = true;
                 return false;
             }
             if (this.isProtocolV2BootloaderMode()) {
-                Log$6.debug('Protocol V2 device is already in bootloader mode, skip reboot');
+                Log$5.debug('Protocol V2 device is already in bootloader mode, skip reboot');
                 this.protocolV2ExecutionInLoader = true;
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.GoToBootloaderSuccess);
                 return false;
@@ -54208,12 +54615,17 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             while (Date.now() - startTime < timeout) {
                 try {
                     if (shouldReconnect) {
-                        yield this.reconnectProtocolV2Device();
+                        if (this.isBleReconnect()) {
+                            yield this.reconnectProtocolV2Device({ skipProtocolProbe: true });
+                        }
+                        else {
+                            yield this.reconnectProtocolV2Device();
+                        }
                         shouldReconnect = false;
                     }
                     const deviceInfo = yield requestProtocolV2DeviceInfo({
                         commands: this.device.getCommands(),
-                        timeoutMs: this.getProtocolV2DeviceInfoTimeout(),
+                        timeoutMs: Math.min(this.getProtocolV2DeviceInfoTimeout(), PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT),
                     });
                     this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
                     const features = yield this.device.probeProtocolV2RuntimeState(deviceInfo, PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT);
@@ -54228,7 +54640,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     }
                     shouldReconnect = true;
                     lastError = error;
-                    Log$6.log('Protocol V2 bootloader mode not ready, polling reconnect: ', error);
+                    Log$5.log('Protocol V2 bootloader mode not ready, polling reconnect: ', error);
                 }
                 yield hdShared.wait(retryInterval);
             }
@@ -54325,7 +54737,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const headerRecovery = { remaining: PROTOCOL_V2_RESOURCE_HEADER_RECOVERY_LIMIT };
             for (const resource of resourceSources) {
                 if (yield this.isProtocolV2ResourceBundleUpToDateWithRecovery(resource, headerRecovery)) {
-                    Log$6.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
+                    Log$5.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
                 }
                 else {
                     resourcesToSync.push(resource);
@@ -54377,7 +54789,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     rateBytesPerSecond,
                     elapsedMs,
                 });
-                Log$6.debug('[FirmwareUpdateV4] Protocol V2 transfer completed', {
+                Log$5.debug('[FirmwareUpdateV4] Protocol V2 transfer completed', {
                     files: resourcesToSync.length + installSources.length,
                     totalBytes: totalSize,
                     elapsedMs,
@@ -54397,7 +54809,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 yield this.protocolV2StartFirmwareUpdate({ targets });
                 yield hdShared.wait(PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY);
                 yield this.waitForProtocolV2FirmwareUpdateComplete(targets, true);
-                Log$6.debug('[FirmwareUpdateV4] Protocol V2 install completed', {
+                Log$5.debug('[FirmwareUpdateV4] Protocol V2 install completed', {
                     targets: targets.length,
                     elapsedMs: getProtocolV2ElapsedMs(installStartedAt),
                 });
@@ -54436,10 +54848,37 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 this.throwIfAborted();
                 const attemptStartedAt = Date.now();
                 let windowed = false;
+                let chunkSize = 0;
+                let confirmedBytes = 0;
+                let lastMetricsAt = attemptStartedAt;
+                const logTransfer = (status) => {
+                    const elapsedMs = getProtocolV2ElapsedMs(attemptStartedAt);
+                    TransferLog.log('[FirmwareUpdateV4] FileWrite metrics', {
+                        status,
+                        path: filePath,
+                        fileWriteWindow: windowed ? hdTransport.PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW : 1,
+                        chunkSize,
+                        attempt,
+                        retryCount: attempt - 1,
+                        transferredBytes: confirmedBytes,
+                        totalBytes: source.size,
+                        elapsedMs,
+                        rateBytesPerSecond: getProtocolV2TransferRate(confirmedBytes, elapsedMs),
+                    });
+                };
+                const reportAttemptChunk = (chunkEnd) => {
+                    confirmedBytes = chunkEnd;
+                    reportConfirmedChunk(chunkEnd);
+                    const now = Date.now();
+                    if (now - lastMetricsAt >= PROTOCOL_V2_TRANSFER_LOG_INTERVAL_MS && chunkEnd < source.size) {
+                        logTransfer('progress');
+                        lastMetricsAt = now;
+                    }
+                };
                 try {
-                    windowed =
-                        !this.protocolV2FileWriteWindowDisabled && this.shouldUseProtocolV2BleFileWriteWindow();
-                    const chunkSize = this.getProtocolV2FirmwareChunkSize('write', filePath, windowed);
+                    windowed = this.shouldUseProtocolV2BleFileWriteWindow();
+                    chunkSize = this.getProtocolV2FirmwareChunkSize('write', filePath, windowed);
+                    logTransfer('started');
                     if (windowed) {
                         yield this.writeProtocolV2SourceWindowed({
                             source,
@@ -54447,7 +54886,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             chunkSize,
                             processedSize,
                             totalSize,
-                            onChunkConfirmed: reportConfirmedChunk,
+                            onChunkConfirmed: reportAttemptChunk,
                         });
                     }
                     else {
@@ -54464,24 +54903,19 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                                 if (!Number.isFinite(nextOffset) || nextOffset !== chunkEnd) {
                                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `invalid processed_byte ${rawProcessedByte} for offset ${sourceOffset}`);
                                 }
-                                reportConfirmedChunk(chunkEnd);
+                                reportAttemptChunk(chunkEnd);
                                 return length;
                             }),
                         });
                     }
-                    Log$6.debug('[FirmwareUpdateV4] Protocol V2 file transferred', {
-                        path: filePath,
-                        bytes: source.size,
-                        elapsedMs: getProtocolV2ElapsedMs(attemptStartedAt),
-                        attempt,
-                        fileWriteWindow: windowed ? hdTransport.PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW : 1,
-                    });
+                    logTransfer('completed');
                     return processedSize + source.size;
                 }
                 catch (error) {
                     this.throwIfAborted();
                     lastError = error;
-                    Log$6.debug('[FirmwareUpdateV4] Protocol V2 file transfer attempt failed', {
+                    logTransfer('failed');
+                    TransferLog.debug('[FirmwareUpdateV4] Protocol V2 file transfer attempt failed', {
                         path: filePath,
                         attempt,
                         fileWriteWindow: windowed ? hdTransport.PROTOCOL_V2_FILE_WRITE_PIPELINE_WINDOW : 1,
@@ -54523,7 +54957,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     }
     assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths, liveTargetIds) {
         const resolvedExpectedPaths = expectedPaths !== null && expectedPaths !== void 0 ? expectedPaths : new Map();
-        Log$6.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateStatus records=${JSON.stringify(statusTargets)}`);
+        Log$5.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateStatus records=${JSON.stringify(statusTargets)}`);
         const failedTarget = statusTargets.find(target => {
             var _a;
             const targetId = (_a = normalizeProtocolV2TargetId(target.target_id)) !== null && _a !== void 0 ? _a : -1;
@@ -54538,7 +54972,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 payloadVersion: failedTarget.payload_version,
                 path: failedTarget.path,
             });
-            Log$6.error(`[FirmwareUpdateV4] firmware install failed target=${failedTargetDetails}`);
+            Log$5.error(`[FirmwareUpdateV4] firmware install failed target=${failedTargetDetails}`);
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareError, 'Protocol V2 firmware install failed', {
                 firmwareUpdateCode: PROTOCOL_V2_INSTALL_FAILED_CODE,
             });
@@ -54552,7 +54986,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     !liveTargetIds.has(targetId));
             });
             if (staleFailedTargets.length > 0) {
-                Log$6.log(`[FirmwareUpdateV4] ignoring stale failed firmware status until those targets start: ${JSON.stringify(staleFailedTargets.map(target => ({
+                Log$5.log(`[FirmwareUpdateV4] ignoring stale failed firmware status until those targets start: ${JSON.stringify(staleFailedTargets.map(target => ({
                     targetId: target.target_id,
                     status: target.status,
                     path: target.path,
@@ -54571,7 +55005,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             if (targetId === undefined ||
                 seenTargetIds.has(targetId) ||
                 pathConflictsWithCurrentInstall) {
-                Log$6.error(`[FirmwareUpdateV4] install status conflicts with target=${target.target_id}`);
+                Log$5.error(`[FirmwareUpdateV4] install status conflicts with target=${target.target_id}`);
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareError, 'Protocol V2 firmware install status conflict', {
                     firmwareUpdateCode: PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE,
                 });
@@ -54879,7 +55313,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             if (isNormalMode &&
                                 (installEvidenceObserved ||
                                     this.hasProtocolV2InstallVersionChanged(expectedTargetIds, currentDeviceInfo))) {
-                                Log$6.log('[FirmwareUpdateV4] empty firmware status after confirmed App reboot; update complete');
+                                Log$5.log('[FirmwareUpdateV4] empty firmware status after confirmed App reboot; update complete');
                                 this.recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds);
                                 this.postProgressMessage(100, 'installingFirmware');
                                 return;
@@ -54913,7 +55347,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             if (isNormalMode &&
                                 (installEvidenceObserved ||
                                     this.hasProtocolV2InstallVersionChanged(expectedTargetIds, deviceInfo))) {
-                                Log$6.log('[FirmwareUpdateV4] firmware status endpoint unavailable after confirmed App reboot');
+                                Log$5.log('[FirmwareUpdateV4] firmware status endpoint unavailable after confirmed App reboot');
                                 this.recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds);
                                 this.postProgressMessage(100, 'installingFirmware');
                                 return;
@@ -54931,7 +55365,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             deviceInfo = undefined;
                             bleInstallLinkReady = false;
                             lastError = error;
-                            Log$6.log('[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ', error);
+                            Log$5.log('[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ', error);
                         }
                     }
                 }
@@ -54951,13 +55385,13 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     shouldReconnect = true;
                     deviceInfo = undefined;
                     bleInstallLinkReady = false;
-                    Log$6.log('Protocol V2 firmware install device readiness probe failed: ', error);
+                    Log$5.log('Protocol V2 firmware install device readiness probe failed: ', error);
                 }
                 if (isFinalStatusCheck)
                     break;
                 yield hdShared.wait(1000);
             }
-            Log$6.error(`[FirmwareUpdateV4] install timed out after ${PROTOCOL_V2_INSTALL_TIMEOUT / 1000}s: ${this.normalizeErrorMessage(lastError)}`);
+            Log$5.error(`[FirmwareUpdateV4] install timed out after ${PROTOCOL_V2_INSTALL_TIMEOUT / 1000}s: ${this.normalizeErrorMessage(lastError)}`);
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareError, 'Protocol V2 firmware install timed out', {
                 firmwareUpdateCode: PROTOCOL_V2_INSTALL_TIMEOUT_CODE,
             });
@@ -54969,12 +55403,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const deviceInfo = yield this.verifyProtocolV2ReconnectIdentity();
             try {
                 if (yield this.probeProtocolV2NormalMode(deviceInfo)) {
-                    Log$6.log('[FirmwareUpdateV4] device already returned to App mode; skip Normal reboot');
+                    Log$5.log('[FirmwareUpdateV4] device already returned to App mode; skip Normal reboot');
                     return;
                 }
             }
             catch (error) {
-                Log$6.log('[FirmwareUpdateV4] unable to confirm App mode before Normal reboot: ', error);
+                Log$5.log('[FirmwareUpdateV4] unable to confirm App mode before Normal reboot: ', error);
             }
             yield this.protocolV2Reboot(hdTransport.DeviceRebootType.Normal);
             this.protocolV2ExecutionInLoader = false;
@@ -55002,7 +55436,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
         this.protocolV2LatestFinalFeatures = features;
         if (firmwareVersion === '0.0.0') {
-            Log$6.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.');
+            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.');
         }
         return {
             bootloaderVersion,
@@ -55053,7 +55487,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     }
                     shouldReconnect = true;
                     lastError = error;
-                    Log$6.log('Protocol V2 normal mode not ready, polling Ping: ', error);
+                    Log$5.log('Protocol V2 normal mode not ready, polling Ping: ', error);
                 }
                 yield hdShared.wait(1000);
             }
@@ -55117,7 +55551,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             if (!reconnectDevice) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
             }
-            Log$6.debug('Protocol V2 firmware reconnect using matched device:', reconnectDevice.getConnectId());
+            Log$5.debug('Protocol V2 firmware reconnect using matched device:', reconnectDevice.getConnectId());
             this.device.updateFromCache(reconnectDevice);
             yield this.ensureProtocolV2DeviceAcquired();
             this.device.commands.disposed = false;
@@ -55178,7 +55612,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         }
         const bootloaderVersion = getDeviceBootloaderVersion(this.device.features).join('.');
         const enabled = supportsProtocolV2BleFileWriteWindow(bootloaderVersion, minBootloaderVersion);
-        Log$6.debug('[FirmwareUpdateV4] BLE FileWrite window', {
+        TransferLog.debug('[FirmwareUpdateV4] BLE FileWrite window', {
             enabled,
             bootloaderVersion,
             bootloaderBuildId: (_b = (_a = this.device.features) === null || _a === void 0 ? void 0 : _a.verify) === null || _b === void 0 ? void 0 : _b.bootloaderBuildId,
@@ -55228,17 +55662,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         onChunkConfirmed(Number(confirmed.message.processed_byte));
                     },
                 },
-            })
-                .catch((error) => {
-                this.protocolV2FileWriteWindowDisabled = true;
-                throw error;
             });
             this.throwIfAborted();
             if (sourceError)
                 throw sourceError;
             const rawProcessedByte = response.message.processed_byte;
             if (Number(rawProcessedByte) !== source.size) {
-                this.protocolV2FileWriteWindowDisabled = true;
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `invalid processed_byte ${rawProcessedByte} for file size ${source.size}`);
             }
         });
@@ -55294,17 +55723,17 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             return;
                         this.protocolV2InstallTerminalSuccessObserved = true;
                         this.device.clearCancelableAction();
-                        Log$6.log('[FirmwareUpdateV4] firmware install completed by device response');
+                        Log$5.log('[FirmwareUpdateV4] firmware install completed by device response');
                     },
                 });
-                Log$6.log('[FirmwareUpdateV4] firmware install request written; continue with status polling');
+                Log$5.log('[FirmwareUpdateV4] firmware install request written; continue with status polling');
             }
             catch (error) {
                 this.throwIfAborted();
                 if (!isProtocolV2DeviceDisconnectedError(error)) {
                     throw error;
                 }
-                Log$6.log('[FirmwareUpdateV4] transport released while writing install request; continue status polling');
+                Log$5.log('[FirmwareUpdateV4] transport released while writing install request; continue status polling');
                 this.protocolV2InstallNeedsReconnect = true;
                 this.protocolV2InstallDisconnectObserved = !isProtocolV2InstallResponseTimeout(error);
             }
@@ -55339,7 +55768,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     }
 }
 
-const Log$5 = getLogger(exports.LoggerNames.Method);
+const Log$4 = getLogger(exports.LoggerNames.Method);
 class PromptWebDeviceAccess extends BaseMethod {
     init() {
         this.useDevice = false;
@@ -55394,7 +55823,7 @@ class PromptWebDeviceAccess extends BaseMethod {
                 return { device: null };
             }
             catch (error) {
-                Log$5.debug(error);
+                Log$4.debug(error);
                 return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
             }
         });
@@ -55765,7 +56194,7 @@ const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
 const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE$2 = 60805;
 const FILESYSTEM_DIR_MAKE_MESSAGE_TYPE = 60809;
 const WALLPAPER_PACKAGE_BLE_CHUNK_SIZE = 1960;
-const Log$4 = getLogger(exports.LoggerNames.Method);
+const Log$3 = getLogger(exports.LoggerNames.Method);
 function normalizeFileName(fileName, data) {
     if (fileName !== undefined && (!fileName || !SAFE_FILE_NAME.test(fileName))) {
         throw invalidParameter$1('Parameter [fileName] may only contain letters, numbers, underscores, hyphens and an optional .bin suffix.');
@@ -55848,6 +56277,7 @@ class DeviceUploadWallpaper extends BaseMethod {
                 chunkSize: this.params.chunkSize,
                 bleChunkSizeLimit,
                 maxChunkRetries: 3,
+                recoverConnection: createProtocolV2AssetFileWriteRecovery(this),
                 overwrite: true,
                 append: false,
                 throwIfAborted: () => this.throwIfAborted(),
@@ -55875,6 +56305,15 @@ class DeviceUploadWallpaper extends BaseMethod {
             if (useHostAssetPackage)
                 this.path = WALLPAPER_PACKAGE_PATH;
             yield this.upload(this.path, data, useHostAssetPackage ? WALLPAPER_PACKAGE_BLE_CHUNK_SIZE : undefined);
+            this.throwIfAborted();
+            new ProtocolV2UiInteractionCoordinator(this.device, this.postMessage).enterMethodInteraction({
+                request: 'button',
+                source: 'method-lifecycle',
+                reason: 'device-management',
+                completion: 'operation-completed',
+                deviceOnly: true,
+                operation: this.name,
+            });
             const response = yield this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
                 settings: { wallpaper_path: this.path },
             });
@@ -55882,7 +56321,7 @@ class DeviceUploadWallpaper extends BaseMethod {
                 yield this.device.refreshProtocolV2SettingsAfterMutation();
             }
             catch (error) {
-                Log$4.warn('Protocol V2 wallpaper settings refresh failed after apply', {
+                Log$3.warn('Protocol V2 wallpaper settings refresh failed after apply', {
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
@@ -56039,6 +56478,8 @@ class DeviceUploadNft extends BaseMethod {
                     chunkSize: this.params.chunkSize,
                     timeoutMs: this.params.timeoutMs,
                     paceMs: this.params.paceMs,
+                    maxChunkRetries: 3,
+                    recoverConnection: createProtocolV2AssetFileWriteRecovery(this),
                     overwrite: true,
                     append: false,
                     throwIfAborted: () => this.throwIfAborted(),
@@ -56093,25 +56534,13 @@ class FileWrite extends BaseMethod {
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            return writeProtocolV2File({
-                commands: this.device.commands,
-                path: this.params.path,
-                data: this.params.data,
-                offset: this.params.offset,
-                totalSize: this.params.totalSize,
-                chunkSize: this.params.chunkSize,
-                chunkLen: this.params.chunkLen,
-                overwrite: this.params.overwrite,
-                append: this.params.append,
-                uiPercentage: this.params.uiPercentage,
-                timeoutMs: this.params.timeoutMs === undefined ? undefined : Number(this.params.timeoutMs),
-                throwIfAborted: () => this.throwIfAborted(),
-                onProgress: payload => {
+            return writeProtocolV2File(Object.assign(Object.assign({ commands: this.device.commands, path: this.params.path, data: this.params.data, offset: this.params.offset, totalSize: this.params.totalSize, chunkSize: this.params.chunkSize, chunkLen: this.params.chunkLen, overwrite: this.params.overwrite, append: this.params.append, uiPercentage: this.params.uiPercentage, timeoutMs: this.params.timeoutMs === undefined ? undefined : Number(this.params.timeoutMs) }, (this.name === 'uploadPortfolio'
+                ? { maxChunkRetries: 3, recoverConnection: createProtocolV2AssetFileWriteRecovery(this) }
+                : {})), { throwIfAborted: () => this.throwIfAborted(), onProgress: payload => {
                     if (this.params.emitProgress && typeof this.postMessage === 'function') {
                         this.postMessage(createUiMessage(UI_REQUEST.DEVICE_PROGRESS, payload));
                     }
-                },
-            });
+                } }));
         });
     }
 }
@@ -56207,201 +56636,6 @@ class CipherKeyValue extends BaseMethod {
     }
 }
 
-const isProtocolV2UiEnabled = (method) => method.protocolV2UiMode !== 'none';
-const getDisplayState = (value) => {
-    const visited = new Set();
-    let seen = false;
-    let enabled = false;
-    const visit = (current) => {
-        if (current == null || typeof current !== 'object')
-            return;
-        if (visited.has(current))
-            return;
-        visited.add(current);
-        if (Array.isArray(current)) {
-            current.forEach(visit);
-            return;
-        }
-        Object.entries(current).forEach(([key, item]) => {
-            if ((key === 'show_display' || key === 'showOnOneKey') && typeof item === 'boolean') {
-                seen = true;
-                enabled || (enabled = item);
-                return;
-            }
-            visit(item);
-        });
-    };
-    visit(value);
-    return { seen, enabled };
-};
-const createMethodInteraction = (reason, operation) => ({
-    request: 'button',
-    source: 'method-lifecycle',
-    reason,
-    completion: 'operation-completed',
-    deviceOnly: true,
-    operation,
-});
-const hasCipherConfirmation = (value) => {
-    if (Array.isArray(value))
-        return value.some(hasCipherConfirmation);
-    if (value == null || typeof value !== 'object')
-        return false;
-    const params = value;
-    return params.encrypt === true ? params.ask_on_encrypt === true : params.ask_on_decrypt === true;
-};
-const resolveProtocolV2UiInteraction = (method) => {
-    if (method.protocolV2UiInteraction)
-        return method.protocolV2UiInteraction;
-    const operation = method.name;
-    if (!operation)
-        return undefined;
-    const isAddress = /getAddress(?:ByLoop)?$/i.test(operation);
-    const isPublicKey = /getPublicKey$/i.test(operation);
-    if (isAddress || isPublicKey) {
-        const paramsDisplay = getDisplayState(method.params);
-        const payloadDisplay = getDisplayState(method.payload);
-        const display = paramsDisplay.seen ? paramsDisplay : payloadDisplay;
-        const shouldDisplay = display.seen ? display.enabled : isAddress;
-        if (!shouldDisplay)
-            return undefined;
-        return createMethodInteraction(isAddress ? 'address-confirmation' : 'public-key-confirmation', operation);
-    }
-    if (/sign/i.test(operation) || /verifyMessage$/i.test(operation) || operation === 'lnurlAuth') {
-        return createMethodInteraction('signing-confirmation', operation);
-    }
-    if (operation === 'nostrEncryptMessage' || operation === 'nostrDecryptMessage') {
-        const display = getDisplayState(method.params);
-        if (!display.enabled)
-            return undefined;
-        return createMethodInteraction('signing-confirmation', operation);
-    }
-    if (operation === 'cipherKeyValue' && hasCipherConfirmation(method.params)) {
-        return createMethodInteraction('signing-confirmation', operation);
-    }
-    return undefined;
-};
-class ProtocolV2UiInteractionCoordinator {
-    constructor(device, postMessage) {
-        this.opened = false;
-        this.closed = false;
-        this.device = device;
-        this.postMessage = postMessage;
-    }
-    enterMethodInteraction(interaction) {
-        var _a, _b, _c, _d;
-        this.methodInteraction = interaction;
-        if (!interaction)
-            return;
-        const { request } = interaction, metadata = __rest(interaction, ["request"]);
-        const interactionMeta = (_b = (_a = this.device).createProtocolV2UiPhaseMetadata) === null || _b === void 0 ? void 0 : _b.call(_a, request === 'pin' ? 'pin' : 'button', 'start');
-        this.emit(request === 'pin' ? UI_REQUEST.REQUEST_PIN : UI_REQUEST.REQUEST_BUTTON, Object.assign(Object.assign({ device: this.device.toMessageObject() }, metadata), (interactionMeta ? { interaction: interactionMeta } : {})), `method:${request}:${interaction.reason}:${(_c = interaction.page) !== null && _c !== void 0 ? _c : ''}:${(_d = interaction.operation) !== null && _d !== void 0 ? _d : ''}`);
-    }
-    enterUnlockInteraction(method) {
-        var _a, _b;
-        const interaction = (_b = (_a = this.device).createProtocolV2UiPhaseMetadata) === null || _b === void 0 ? void 0 : _b.call(_a, 'pin', 'start');
-        this.emit(UI_REQUEST.REQUEST_PIN, Object.assign({ device: this.device.toMessageObject(), source: 'unlock-coordinator', reason: 'device-locked', deviceOnly: true, method }, (interaction ? { interaction } : {})), `unlock:${method !== null && method !== void 0 ? method : ''}`);
-        return interaction;
-    }
-    resumeMethodInteraction() {
-        this.enterMethodInteraction(this.methodInteraction);
-    }
-    close(options = {}) {
-        var _a, _b, _c, _d;
-        if ((!options.protocolV2Operation && !this.device.isProtocolV2()) ||
-            (!options.ensureOperationClose &&
-                !this.opened &&
-                !((_b = (_a = this.device).hasOpenProtocolV2UiInteraction) === null || _b === void 0 ? void 0 : _b.call(_a))) ||
-            this.closed)
-            return false;
-        this.closed = true;
-        const interaction = (_d = (_c = this.device).finishProtocolV2UiInteraction) === null || _d === void 0 ? void 0 : _d.call(_c, 'succeeded', {
-            ensureMetadata: options.ensureOperationClose,
-        });
-        const device = this.device.toMessageObject();
-        this.postMessage(interaction
-            ? createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW, Object.assign(Object.assign({}, interaction), (device ? { device } : {})))
-            : createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW));
-        return true;
-    }
-    emit(type, payload, phase) {
-        if (!this.device.isProtocolV2() || this.closed || this.currentPhase === phase)
-            return;
-        this.currentPhase = phase;
-        this.opened = true;
-        const message = type === UI_REQUEST.REQUEST_BUTTON
-            ? createUiMessage(UI_REQUEST.REQUEST_BUTTON, payload)
-            : createUiMessage(UI_REQUEST.REQUEST_PIN, payload);
-        this.postMessage(message);
-    }
-}
-
-const Log$3 = getLogger(exports.LoggerNames.Core);
-const createProtocolV2UnlockContext = () => ({
-    preflightCompleted: false,
-    preflightStatusRefreshed: false,
-    preflightMainPinSelected: false,
-});
-const resolvePreUnlockPinType = (method) => {
-    var _a, _b;
-    if (method.protocolV2PreUnlockPinType !== undefined) {
-        return method.protocolV2PreUnlockPinType;
-    }
-    const targetsKnownHiddenWallet = method.useDevicePassphraseState &&
-        ((_a = method.payload) === null || _a === void 0 ? void 0 : _a.useEmptyPassphrase) !== true &&
-        typeof ((_b = method.payload) === null || _b === void 0 ? void 0 : _b.passphraseState) === 'string' &&
-        method.payload.passphraseState.length > 0;
-    return targetsKnownHiddenWallet ? hdTransport.DeviceSessionPinType.Any : hdTransport.DeviceSessionPinType.Main;
-};
-function runMethodWithUnlockPolicy(method, device, options = {}) {
-    var _a, _b, _c;
-    return __awaiter(this, void 0, void 0, function* () {
-        const { context = createProtocolV2UnlockContext(), uiCoordinator, afterStatusBeforeUnlock, prepare, run: configuredRun, } = options;
-        const run = configuredRun !== null && configuredRun !== void 0 ? configuredRun : (() => method.run());
-        method.protocolV2UnlockContext = context;
-        const shouldEmitUi = isProtocolV2UiEnabled(method);
-        const shouldCoordinateUi = shouldEmitUi && uiCoordinator !== undefined;
-        const requiresPreUnlock = device.isProtocolV2() &&
-            (method.useDevicePassphraseState || method.unlockPolicy === 'unlock-before-run') &&
-            ((_a = device.state) === null || _a === void 0 ? void 0 : _a.status.initialized) !== false &&
-            !((_b = device.isBootloader) === null || _b === void 0 ? void 0 : _b.call(device)) &&
-            !((_c = device.isRomloader) === null || _c === void 0 ? void 0 : _c.call(device));
-        if (requiresPreUnlock && !context.preflightCompleted) {
-            const status = yield refreshProtocolV2DeviceStatus(device);
-            if (typeof (status === null || status === void 0 ? void 0 : status.unlocked) !== 'boolean') {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 DeviceStatus did not report an explicit unlock state.');
-            }
-            yield (afterStatusBeforeUnlock === null || afterStatusBeforeUnlock === void 0 ? void 0 : afterStatusBeforeUnlock());
-            if (!status.unlocked) {
-                const preUnlockPinType = resolvePreUnlockPinType(method);
-                const unlockInteraction = shouldCoordinateUi
-                    ? uiCoordinator.enterUnlockInteraction(method.name)
-                    : undefined;
-                const unlockedStatus = yield device.unlockDevice(preUnlockPinType, shouldCoordinateUi
-                    ? { emitUiEvent: false, interaction: unlockInteraction }
-                    : {
-                        source: 'unlock-coordinator',
-                        reason: 'device-locked',
-                        deviceOnly: true,
-                        method: method.name,
-                    });
-                if ((unlockedStatus === null || unlockedStatus === void 0 ? void 0 : unlockedStatus.unlocked) !== true) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 device remained locked after the unlock flow.');
-                }
-                context.preflightMainPinSelected = preUnlockPinType === hdTransport.DeviceSessionPinType.Main;
-                Log$3.debug('Protocol V2 pre-unlock completed', { method: method.name });
-            }
-            context.preflightStatusRefreshed = true;
-            context.preflightCompleted = true;
-        }
-        yield (prepare === null || prepare === void 0 ? void 0 : prepare());
-        if (shouldCoordinateUi) {
-            uiCoordinator.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
-        }
-        return run();
-    });
-}
-
 const Mainnet = 'mainnet';
 const MoneroNetworkTypes = new Map([
     [Mainnet, hdTransport.Messages.MoneroNetworkType.MAINNET],