@onekeyfe/hd-core 1.2.0-alpha.183 → 1.2.0-alpha.185

package/dist/index.js

@@ -27476,6 +27476,9 @@ var nested = {
 			MessageType_DeviceCertificateSignature: 60423,
 			MessageType_DeviceCertificateSign: 60424,
 			MessageType_DeviceMiscUsbMscControl: 60440,
+			MessageType_DeviceFindMyTokenState: 60450,
+			MessageType_DeviceFindMyTokenUpdate: 60451,
+			MessageType_DeviceFindMyTokenStateGet: 60452,
 			MessageType_DeviceInfoGet: 60600,
 			MessageType_DeviceInfo: 60601,
 			MessageType_DeviceStatusGet: 60602,
@@ -32452,6 +32455,10 @@ var nested = {
 			request_id: {
 				type: "bytes",
 				id: 5
+			},
+			source_fingerprint: {
+				type: "uint32",
+				id: 6
 			}
 		}
 	},
@@ -32587,6 +32594,14 @@ var nested = {
 			tx_type: {
 				type: "uint32",
 				id: 10
+			},
+			expected_address: {
+				type: "bytes",
+				id: 12
+			},
+			source_fingerprint: {
+				type: "uint32",
+				id: 13
 			}
 		}
 	},
@@ -32667,6 +32682,14 @@ var nested = {
 				rule: "repeated",
 				type: "EthereumAccessListOneKey",
 				id: 11
+			},
+			expected_address: {
+				type: "bytes",
+				id: 12
+			},
+			source_fingerprint: {
+				type: "uint32",
+				id: 13
 			}
 		}
 	},
@@ -32843,6 +32866,10 @@ var nested = {
 			chain_id: {
 				type: "uint64",
 				id: 3
+			},
+			source_fingerprint: {
+				type: "uint32",
+				id: 4
 			}
 		}
 	},
@@ -36545,6 +36572,10 @@ var nested = {
 				rule: "required",
 				type: "bytes",
 				id: 2
+			},
+			source_fingerprint: {
+				type: "uint32",
+				id: 3
 			}
 		}
 	},
@@ -36589,6 +36620,10 @@ var nested = {
 			application_domain: {
 				type: "bytes",
 				id: 5
+			},
+			source_fingerprint: {
+				type: "uint32",
+				id: 6
 			}
 		}
 	},
@@ -36606,6 +36641,10 @@ var nested = {
 				rule: "required",
 				type: "bytes",
 				id: 2
+			},
+			source_fingerprint: {
+				type: "uint32",
+				id: 3
 			}
 		}
 	},
@@ -38841,6 +38880,28 @@ var nested = {
 			}
 		}
 	},
+	DeviceFindMyTokenUpdate: {
+		fields: {
+			token: {
+				rule: "required",
+				type: "bytes",
+				id: 1
+			}
+		}
+	},
+	DeviceFindMyTokenStateGet: {
+		fields: {
+		}
+	},
+	DeviceFindMyTokenState: {
+		fields: {
+			burned: {
+				rule: "required",
+				type: "bool",
+				id: 1
+			}
+		}
+	},
 	DeviceFactoryAck: {
 		values: {
 			FACTORY_ACK_SUCCESS: 0,
@@ -38971,6 +39032,13 @@ var nested = {
 			FW_MGMT_UPDATER_TASK_STATUS_FAILED_ENTRY_OUT_OF_BOUNDS: 10
 		}
 	},
+	DeviceFirmwareUpdatePhase: {
+		values: {
+			FW_MGMT_UPDATER_PHASE_PREPARE: 0,
+			FW_MGMT_UPDATER_PHASE_INSTALL: 1,
+			FW_MGMT_UPDATER_PHASE_VERIFY: 2
+		}
+	},
 	DeviceFirmwareTarget: {
 		fields: {
 			target_id: {
@@ -38996,6 +39064,24 @@ var nested = {
 	},
 	DeviceFirmwareUpdateRequest: {
 		fields: {
+			reboot_after_update: {
+				type: "bool",
+				id: 1
+			}
+		}
+	},
+	DeviceFirmwareUpdatePhaseInfo: {
+		fields: {
+			phase: {
+				rule: "required",
+				type: "DeviceFirmwareUpdatePhase",
+				id: 1
+			},
+			progress_percent: {
+				rule: "required",
+				type: "uint32",
+				id: 2
+			}
 		}
 	},
 	DeviceFirmwareUpdateRecord: {
@@ -39009,6 +39095,14 @@ var nested = {
 				type: "DeviceFirmwareUpdateTaskStatus",
 				id: 10
 			},
+			progress_percent: {
+				type: "uint32",
+				id: 11
+			},
+			phase_info: {
+				type: "DeviceFirmwareUpdatePhaseInfo",
+				id: 12
+			},
 			payload_version: {
 				type: "uint32",
 				id: 20
@@ -39025,6 +39119,14 @@ var nested = {
 				type: "bool",
 				id: 10
 			},
+			progress_percent: {
+				type: "bool",
+				id: 11
+			},
+			phase_info: {
+				type: "bool",
+				id: 12
+			},
 			payload_version: {
 				type: "bool",
 				id: 20
@@ -39796,6 +39898,10 @@ var nested = {
 			text_id: {
 				type: "uint32",
 				id: 3
+			},
+			text_arg: {
+				type: "string",
+				id: 4
 			}
 		}
 	},
@@ -39863,6 +39969,10 @@ var nested = {
 			title_id: {
 				type: "uint32",
 				id: 8
+			},
+			title_arg: {
+				type: "string",
+				id: 9
 			}
 		}
 	},
@@ -41579,11 +41689,12 @@ const buildDeviceSessionGetRequest = ({ sessionId, expectedPassphraseState, deri
             hdTransport.DeviceSessionSeedDomain.SeedDomain_Standard,
             ...(deriveCardano ? [hdTransport.DeviceSessionSeedDomain.SeedDomain_Cardano] : []),
         ] }));
-const askDevicePassphrase = (device, requestPayload) => __awaiter(void 0, void 0, void 0, function* () {
+const askDevicePassphrase = (device, requestPayload, onStatusRefreshed) => __awaiter(void 0, void 0, void 0, function* () {
     yield device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', requestPayload);
     yield refreshProtocolV2DeviceStatus(device);
+    onStatusRefreshed === null || onStatusRefreshed === void 0 ? void 0 : onStatusRefreshed();
 });
-const selectDeviceSession = (device, expectedPassphraseState, deriveCardano) => __awaiter(void 0, void 0, void 0, function* () {
+const selectDeviceSession = (device, expectedPassphraseState, deriveCardano, onStatusRefreshed) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d;
     const existsAttachPinUser = ((_a = device.features) === null || _a === void 0 ? void 0 : _a.attachToPinEnabled) === true;
     const metadata = Object.assign({ source: 'wallet-session-coordinator', reason: expectedPassphraseState ? 'session-recovery' : 'open-wallet' }, (expectedPassphraseState ? { expectedPassphraseState } : {}));
@@ -41616,18 +41727,19 @@ const selectDeviceSession = (device, expectedPassphraseState, deriveCardano) =>
             emitUiEvent: false,
             interaction: attachPinInteraction,
         });
+        onStatusRefreshed === null || onStatusRefreshed === void 0 ? void 0 : onStatusRefreshed();
         return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
     }
     if (hasHostPassphrase) {
         yield askDevicePassphrase(device, {
             passphrase: hostPassphrase,
             on_device: false,
-        });
+        }, onStatusRefreshed);
         return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
     }
     const passphraseOnDeviceInteraction = (_d = device.createProtocolV2UiPhaseMetadata) === null || _d === void 0 ? void 0 : _d.call(device, 'passphrase-on-device', 'start');
     device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, Object.assign(Object.assign({}, metadata), (passphraseOnDeviceInteraction ? { interaction: passphraseOnDeviceInteraction } : {})));
-    yield askDevicePassphrase(device, { on_device: true });
+    yield askDevicePassphrase(device, { on_device: true }, onStatusRefreshed);
     return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
 });
 function getProtocolV2WalletSession(device, options) {
@@ -41661,9 +41773,15 @@ function getProtocolV2WalletSession(device, options) {
             : undefined;
         let response;
         let resumed = false;
-        let mainPinSelected = (options === null || options === void 0 ? void 0 : options.onlyMainPin) === true &&
-            ((_d = device.features) === null || _d === void 0 ? void 0 : _d.unlocked) === true &&
-            ((_e = device.features) === null || _e === void 0 ? void 0 : _e.unlockedAttachPin) === false;
+        let walletStatusRefreshed = false;
+        const markWalletStatusRefreshed = () => {
+            walletStatusRefreshed = true;
+        };
+        let mainPinAuthenticated = (options === null || options === void 0 ? void 0 : options.mainPinSelected) === true ||
+            ((options === null || options === void 0 ? void 0 : options.onlyMainPin) === true &&
+                ((_d = device.features) === null || _d === void 0 ? void 0 : _d.unlocked) === true &&
+                ((_e = device.features) === null || _e === void 0 ? void 0 : _e.unlockedAttachPin) === false);
+        let standardWalletSelected = (options === null || options === void 0 ? void 0 : options.mainPinSelected) === true;
         const clearCurrentWalletSession = () => {
             var _a;
             if (options === null || options === void 0 ? void 0 : options.onlyMainPin) {
@@ -41676,6 +41794,7 @@ function getProtocolV2WalletSession(device, options) {
         const rejectMismatchedAttachPinWallet = () => __awaiter(this, void 0, void 0, function* () {
             var _k;
             const features = yield refreshProtocolV2DeviceStatus(device);
+            markWalletStatusRefreshed();
             if (features.unlockedAttachPin !== true) {
                 return;
             }
@@ -41697,28 +41816,35 @@ function getProtocolV2WalletSession(device, options) {
             yield rejectMismatchedAttachPinWallet();
         }
         const selectMainPin = (force = false) => __awaiter(this, void 0, void 0, function* () {
-            if (force || !mainPinSelected) {
+            if (force || !mainPinAuthenticated) {
                 yield device.unlockDevice(hdTransport.DeviceSessionPinType.Main, {
                     source: 'wallet-session-coordinator',
                     reason: expectedPassphraseState ? 'session-recovery' : 'open-wallet',
                     deviceOnly: true,
                 });
-                mainPinSelected = true;
+                markWalletStatusRefreshed();
+                mainPinAuthenticated = true;
+                standardWalletSelected = true;
             }
         });
         const selectStandardWallet = () => __awaiter(this, void 0, void 0, function* () {
             var _m;
-            yield selectMainPin();
             if (((_m = device.features) === null || _m === void 0 ? void 0 : _m.passphraseProtection) === true) {
+                yield selectMainPin();
                 yield askDevicePassphrase(device, {
                     passphrase: '',
                     on_device: false,
-                });
+                }, markWalletStatusRefreshed);
+                standardWalletSelected = true;
+            }
+            else if (!standardWalletSelected) {
+                yield selectMainPin(true);
             }
         });
         if (readCurrentAttachPinSession) {
             const status = yield requestProtocolV2DeviceStatus$1(device);
             device.updateProtocolV2Status(status);
+            markWalletStatusRefreshed();
             if (status.unlocked !== true ||
                 status.passphrase_enabled !== true ||
                 status.unlocked_by_attach_to_pin !== true) {
@@ -41789,7 +41915,7 @@ function getProtocolV2WalletSession(device, options) {
                 device.clearInternalState();
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.WalletSessionInvalid);
             }
-            response = yield selectDeviceSession(device, expectedPassphraseState, options === null || options === void 0 ? void 0 : options.deriveCardano);
+            response = yield selectDeviceSession(device, expectedPassphraseState, options === null || options === void 0 ? void 0 : options.deriveCardano, markWalletStatusRefreshed);
         }
         let { message } = response;
         try {
@@ -41818,7 +41944,7 @@ function getProtocolV2WalletSession(device, options) {
             }
             else {
                 device.clearInternalState();
-                response = yield selectDeviceSession(device, expectedPassphraseState, options === null || options === void 0 ? void 0 : options.deriveCardano);
+                response = yield selectDeviceSession(device, expectedPassphraseState, options === null || options === void 0 ? void 0 : options.deriveCardano, markWalletStatusRefreshed);
             }
             message = response.message;
             try {
@@ -41856,7 +41982,7 @@ function getProtocolV2WalletSession(device, options) {
         if (readCurrentAttachPinSession) {
             unlockedAttachPin = true;
         }
-        else if (mainPinSelected) {
+        else if (mainPinAuthenticated) {
             unlockedAttachPin = false;
         }
         return {
@@ -41864,6 +41990,7 @@ function getProtocolV2WalletSession(device, options) {
             newSession: message.session_id,
             unlockedAttachPin,
             resumed,
+            walletStatusRefreshed,
         };
     });
 }
@@ -41931,6 +42058,7 @@ const getPassphraseStateWithRefreshDeviceInfo = (device, options) => __awaiter(v
             onlyMainPin: options === null || options === void 0 ? void 0 : options.onlyMainPin,
             deriveCardano: options === null || options === void 0 ? void 0 : options.deriveCardano,
             rejectAttachPinForMainWallet: options === null || options === void 0 ? void 0 : options.rejectAttachPinForMainWallet,
+            mainPinSelected: options === null || options === void 0 ? void 0 : options.mainPinSelected,
         });
     }
     const { features } = device;
@@ -41976,6 +42104,7 @@ const getPassphraseState = (device, options) => __awaiter(void 0, void 0, void 0
             onlyMainPin: options === null || options === void 0 ? void 0 : options.onlyMainPin,
             deriveCardano: options === null || options === void 0 ? void 0 : options.deriveCardano,
             rejectAttachPinForMainWallet: options === null || options === void 0 ? void 0 : options.rejectAttachPinForMainWallet,
+            mainPinSelected: options === null || options === void 0 ? void 0 : options.mainPinSelected,
         });
     }
     const supportAttachPinCapability = existCapability(features, hdTransport.Enum_Capability.Capability_AttachToPin);
@@ -46460,7 +46589,7 @@ class Device extends events.exports {
             return Promise.resolve(features);
         });
     }
-    checkPassphraseStateSafety(passphraseState, useEmptyPassphrase, skipPassphraseCheck, deriveCardano) {
+    checkPassphraseStateSafety(passphraseState, useEmptyPassphrase, skipPassphraseCheck, deriveCardano, mainPinSelected) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isUnacquired())
                 return false;
@@ -46470,6 +46599,7 @@ class Device extends events.exports {
                 onlyMainPin: useEmptyPassphrase,
                 deriveCardano,
                 rejectAttachPinForMainWallet: useEmptyPassphrase === true,
+                mainPinSelected,
             });
             const mainWalletUseAttachPin = unlockedAttachPin && useEmptyPassphrase;
             const useErrorAttachPin = unlockedAttachPin &&
@@ -47294,6 +47424,10 @@ const wasResumed = (session) => !!session &&
     typeof session === 'object' &&
     'resumed' in session &&
     session.resumed === true;
+const wasWalletStatusRefreshed = (session) => !!session &&
+    typeof session === 'object' &&
+    'walletStatusRefreshed' in session &&
+    session.walletStatusRefreshed === true;
 const requireHiddenWalletResponse = (session) => {
     if (!session.passphraseState) {
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed, 'Hidden wallet response is missing passphraseState');
@@ -47336,12 +47470,20 @@ class OpenWalletSession extends BaseMethod {
         this.unlockPolicy = 'unlock-before-run';
         this.skipForceUpdateCheck = true;
         this.params = normalizeParams(this.payload);
+        this.protocolV2PreUnlockPinType =
+            this.params.mode === OpenWalletSessionMode.SelectHidden
+                ? hdTransport.DeviceSessionPinType.Any
+                : hdTransport.DeviceSessionPinType.Main;
         this.payload.useEmptyPassphrase = this.params.mode === OpenWalletSessionMode.Standard;
     }
     run() {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const isProtocolV2 = this.device.isProtocolV2();
-            let state = yield this.device.getDeviceState({ refreshSections: ['status'] });
+            const reusePreflightStatus = isProtocolV2 && ((_a = this.protocolV2UnlockContext) === null || _a === void 0 ? void 0 : _a.preflightStatusRefreshed) === true;
+            let state = reusePreflightStatus
+                ? yield this.device.getDeviceState()
+                : yield this.device.getDeviceState({ refreshSections: ['status'] });
             let currentDeviceId = state.identity.deviceId;
             const hasAuthoritativeProtocolV2WalletStatus = (candidate) => candidate.status.unlocked === true &&
                 typeof candidate.status.passphraseProtection === 'boolean' &&
@@ -47363,9 +47505,18 @@ class OpenWalletSession extends BaseMethod {
                 currentDeviceId = state.identity.deviceId;
                 return state;
             });
+            const resolveProtocolV2DeviceStateAfterSession = (session) => __awaiter(this, void 0, void 0, function* () {
+                if (!wasWalletStatusRefreshed(session)) {
+                    return refreshProtocolV2DeviceState();
+                }
+                state = yield this.device.getDeviceState();
+                currentDeviceId = state.identity.deviceId;
+                return state;
+            });
             const ensureProtocolV2WalletStatus = () => __awaiter(this, void 0, void 0, function* () {
+                var _d;
                 if (isProtocolV2 && !hasAuthoritativeProtocolV2WalletStatus(state)) {
-                    yield this.device.unlockDevice(hdTransport.DeviceSessionPinType.Main, {
+                    yield this.device.unlockDevice((_d = this.protocolV2PreUnlockPinType) !== null && _d !== void 0 ? _d : hdTransport.DeviceSessionPinType.Main, {
                         source: 'unlock-coordinator',
                         reason: 'device-locked',
                         deviceOnly: true,
@@ -47384,13 +47535,14 @@ class OpenWalletSession extends BaseMethod {
                         deriveCardano: this.payload.deriveCardano,
                         selectMainWalletBeforeRestore: !hasAuthoritativeProtocolV2WalletStatus(state) ||
                             state.status.unlockedAttachPin === true,
+                        mainPinSelected: (_b = this.protocolV2UnlockContext) === null || _b === void 0 ? void 0 : _b.preflightMainPinSelected,
                     })
                     : yield getPassphraseStateWithRefreshDeviceInfo(this.device, {
                         onlyMainPin: true,
                         initSession: this.payload.initSession,
                     });
                 const refreshedState = isProtocolV2
-                    ? requireAuthoritativeProtocolV2WalletStatus(yield refreshProtocolV2DeviceState())
+                    ? requireAuthoritativeProtocolV2WalletStatus(yield resolveProtocolV2DeviceStateAfterSession(session))
                     : state;
                 const deviceId = requireDeviceId();
                 if (session.unlockedAttachPin ||
@@ -47398,7 +47550,7 @@ class OpenWalletSession extends BaseMethod {
                     try {
                         yield this.device.lockDevice();
                     }
-                    catch (_a) {
+                    catch (_c) {
                     }
                     this.device.clearInternalState();
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckUnlockTypeError);
@@ -47462,7 +47614,7 @@ class OpenWalletSession extends BaseMethod {
                     : { forceWalletSelection: true })), { deriveCardano: this.payload.deriveCardano }))
                 : yield getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
             const refreshedState = isProtocolV2
-                ? requireAuthoritativeProtocolV2WalletStatus(yield refreshProtocolV2DeviceState())
+                ? requireAuthoritativeProtocolV2WalletStatus(yield resolveProtocolV2DeviceStateAfterSession(session))
                 : state;
             const deviceId = requireDeviceId();
             if (isProtocolV2 && refreshedState.status.passphraseProtection !== true) {
@@ -51708,14 +51860,289 @@ const INSTALLABLE_FIRMWARE_TARGET_IDS = new Set([
 ]);
 new Map(Object.entries(ProtocolV2FirmwareTargetType).flatMap(([key, value]) => INSTALLABLE_FIRMWARE_TARGET_IDS.has(value) ? [[key, value]] : []));
 
-const Log$7 = getLogger(exports.LoggerNames.Method);
+const Log$7 = 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';
+function formatFileTransferRate(bytesPerSecond) {
+    return (Math.max(bytesPerSecond, 0) / 1024).toFixed(2);
+}
+function getAverageFileTransferRate(transferredBytes, elapsedMs) {
+    if (elapsedMs <= 0)
+        return 0;
+    return Math.round((Math.max(transferredBytes, 0) / elapsedMs) * 1000);
+}
+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, }) {
+    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}`);
+}
+function isProtocolV2ResponseTimeout(error) {
+    var _a, _b;
+    if (!error || typeof error !== 'object')
+        return false;
+    const candidate = error;
+    const code = (_a = candidate.errorCode) !== null && _a !== void 0 ? _a : candidate.code;
+    return (code === hdShared.HardwareErrorCode.BleTimeoutError ||
+        code === 'response-timeout' ||
+        /(?:BLE|Lowlevel|Protocol V2) response timeout/i.test((_b = candidate.message) !== null && _b !== void 0 ? _b : ''));
+}
+function getProtocolV2FileChunkLimit() {
+    const env = DataManager.getSettings('env');
+    return env && DataManager.isBleConnect(env)
+        ? hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
+        : hdTransport.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+}
+function dataToUint8Array(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof data === 'string')
+            return new TextEncoder().encode(data);
+        if (data instanceof ArrayBuffer)
+            return new Uint8Array(data);
+        if (ArrayBuffer.isView(data)) {
+            return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        if (typeof Blob !== 'undefined' && data instanceof Blob) {
+            return new Uint8Array(yield data.arrayBuffer());
+        }
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Unsupported FilesystemFileWrite data');
+    });
+}
+function normalizeChunkSize(value, maxChunkSize) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric <= 0)
+        return maxChunkSize;
+    return Math.min(Math.max(Math.floor(numeric), MIN_FILE_CHUNK_SIZE), maxChunkSize);
+}
+function getDeviceTransferProgress(before, after, total) {
+    if (!Number.isFinite(total) || total <= 0)
+        return 100;
+    if (before <= 0 && after < total)
+        return 0;
+    if (after >= total)
+        return 100;
+    return Math.min(Math.max(Math.ceil((after / total) * 100), 1), 99);
+}
+function getConfirmedProgress(processed, total, written, length) {
+    if (Number.isFinite(processed) && Number.isFinite(total) && total > 0) {
+        if (processed >= total)
+            return 100;
+        return Math.min(Math.max(Math.floor((processed / total) * 100), 0), 99);
+    }
+    if (length > 0)
+        return written >= length ? 100 : Math.floor((written / length) * 100);
+    return 100;
+}
+function writeProtocolV2File(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    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);
+        const dataLength = data.byteLength;
+        const startOffset = Number.isFinite(options.offset) && Number(options.offset) > 0 ? Number(options.offset) : 0;
+        const totalSize = Number.isFinite(options.totalSize) && Number(options.totalSize) > 0
+            ? Number(options.totalSize)
+            : startOffset + dataLength;
+        if (totalSize < startOffset + dataLength) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite totalSize ${totalSize} is smaller than offset + data length ${startOffset + dataLength}`);
+        }
+        const defaultChunkSizeLimit = getProtocolV2FileChunkLimit();
+        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);
+        let written = 0;
+        let chunks = 0;
+        let lastMessage;
+        const startTime = Date.now();
+        let rateWindowStartedAt = startTime;
+        let rateWindowStartedBytes = 0;
+        let rateBytesPerSecond;
+        let lastConfirmedAt = startTime;
+        let logWindowStartedAt = startTime;
+        let logWindowStartedBytes = 0;
+        let hostWriteElapsedMs = 0;
+        let responseWaitElapsedMs = 0;
+        let measuredAttempts = 0;
+        const transport = getFileTransferTransport();
+        Log$7.log(`[FileWrite] started transport=${transport} path=${options.path} bytes=${dataLength} offset=${startOffset} chunk=${chunkSize}`);
+        try {
+            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;
+                let response;
+                let isWritePending = true;
+                while (isWritePending) {
+                    let currentHostWriteElapsedMs;
+                    let responseWaitStartedAt;
+                    try {
+                        const callOptions = options.writeWithResponse === undefined
+                            ? {
+                                timeoutMs: options.timeoutMs,
+                                onWriteCompleted: ({ elapsedMs }) => {
+                                    currentHostWriteElapsedMs = elapsedMs;
+                                    responseWaitStartedAt = Date.now();
+                                },
+                            }
+                            : Object.assign(Object.assign({}, (options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs })), { writeWithResponse: options.writeWithResponse, onWriteCompleted: ({ elapsedMs }) => {
+                                    currentHostWriteElapsedMs = elapsedMs;
+                                    responseWaitStartedAt = Date.now();
+                                } });
+                        response = yield options.commands.typedCall('FilesystemFileWrite', 'FilesystemFile', request, callOptions);
+                        isWritePending = false;
+                    }
+                    catch (error) {
+                        if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error))
+                            throw error;
+                        retryCount += 1;
+                        (_k = options.throwIfAborted) === null || _k === void 0 ? void 0 : _k.call(options);
+                    }
+                    finally {
+                        if (currentHostWriteElapsedMs !== undefined && responseWaitStartedAt !== undefined) {
+                            hostWriteElapsedMs += currentHostWriteElapsedMs;
+                            responseWaitElapsedMs += Math.max(Date.now() - responseWaitStartedAt, 0);
+                            measuredAttempts += 1;
+                        }
+                    }
+                }
+                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}`);
+                }
+                written =
+                    rawProcessedByte === undefined ? written + chunk.byteLength : 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);
+                }
+                (_p = options.onProgress) === null || _p === void 0 ? void 0 : _p.call(options, {
+                    progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
+                    transferredBytes,
+                    totalBytes: dataLength,
+                    rateBytesPerSecond,
+                    elapsedMs,
+                });
+                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);
+                    });
+                }
+            }
+        }
+        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);
+        logFileTransferMetrics({
+            transport,
+            status: 'completed',
+            path: options.path,
+            transferredBytes: written,
+            totalBytes: dataLength,
+            elapsedMs,
+            rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+            hostWriteElapsedMs,
+            responseWaitElapsedMs,
+            measuredAttempts,
+        });
+        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 SESSION_ERROR = 'session not found';
 const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
 const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
 const PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT = 15 * 1000;
 const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
 const PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY = 1000;
+const PROTOCOL_V2_INSTALL_FINISHED_AFTER_RECONNECT_POLLS = 4;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
 const PROTOCOL_V2_TARGET_STATUS_FINISHED = 2;
@@ -51871,11 +52298,12 @@ const isProtocolV2FirmwareStatusEndpointUnavailable = (error) => {
 };
 const isProtocolV2TerminalInstallStatusError = (error) => {
     var _a;
-    return error instanceof hdShared.HardwareError &&
-        (error.errorCode === hdShared.HardwareErrorCode.ActionCancelled ||
-            error.errorCode === hdShared.HardwareErrorCode.FirmwareError ||
-            error.errorCode === hdShared.HardwareErrorCode.FirmwareVerificationFailed ||
-            ((_a = error.params) === null || _a === void 0 ? void 0 : _a.firmwareUpdateCode) === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE);
+    return hdShared.isBleStaleBondHardwareError(error) ||
+        (error instanceof hdShared.HardwareError &&
+            (error.errorCode === hdShared.HardwareErrorCode.ActionCancelled ||
+                error.errorCode === hdShared.HardwareErrorCode.FirmwareError ||
+                error.errorCode === hdShared.HardwareErrorCode.FirmwareVerificationFailed ||
+                ((_a = error.params) === null || _a === void 0 ? void 0 : _a.firmwareUpdateCode) === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE));
 };
 const isProtocolV2TargetStatusFinished = (status) => normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_FINISHED;
 const isProtocolV2TargetStatusInProgress = (status) => normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_PENDING ||
@@ -51899,6 +52327,14 @@ const normalizeProtocolV2TargetStatus = (status) => {
     }
     return undefined;
 };
+const PROTOCOL_V2_INSTALL_PHASE_BY_DECODED_VALUE = new Map([
+    [0, 'prepare'],
+    [1, 'install'],
+    [2, 'verify'],
+    ['FW_MGMT_UPDATER_PHASE_PREPARE', 'prepare'],
+    ['FW_MGMT_UPDATER_PHASE_INSTALL', 'install'],
+    ['FW_MGMT_UPDATER_PHASE_VERIFY', 'verify'],
+]);
 const normalizeProtocolV2Hex = (value) => value === null || value === void 0 ? void 0 : value.replace(/^0x/i, '').toLowerCase();
 const versionArrayToNumber = (version) => {
     if (!version)
@@ -51954,6 +52390,10 @@ const toProtocolV2FiniteNumber = (value) => {
     }
     return undefined;
 };
+const normalizeProtocolV2ProgressPercent = (value) => {
+    const progress = toProtocolV2FiniteNumber(value);
+    return progress === undefined ? undefined : Math.min(100, Math.max(0, progress));
+};
 const isProtocolV2FirmwareFingerprintValid = (binary, fingerprint) => {
     const expectedFingerprint = normalizeProtocolV2Hex(fingerprint);
     if (!expectedFingerprint)
@@ -52154,7 +52594,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            Log$7.debug('FirmwareUpdateV4 strategy: Protocol V2');
+            Log$6.debug('FirmwareUpdateV4 strategy: Protocol V2');
             return this.runProtocolV2();
         });
     }
@@ -52586,7 +53026,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             if (!observedVersion) {
                 const hasCompleteTargetEvidence = targetId !== undefined && this.protocolV2CompletedTargetIds.has(targetId);
                 if (hasCompleteTargetEvidence) {
-                    Log$7.warn(`Protocol V2 target ${target} has no observable final version; install completion is authoritative`);
+                    Log$6.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`);
@@ -52949,7 +53389,10 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 return true;
             }
             catch (error) {
-                Log$7.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
+                if (hdShared.isBleStaleBondHardwareError(error)) {
+                    throw error;
+                }
+                Log$6.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
                 return false;
             }
         });
@@ -52989,7 +53432,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 if (error instanceof hdShared.HardwareError) {
                     throw error;
                 }
-                Log$7.log('Protocol V2 auto go to bootloader mode failed: ', error);
+                Log$6.log('Protocol V2 auto go to bootloader mode failed: ', error);
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure);
             }
         });
@@ -52997,12 +53440,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     enterProtocolV2BootloaderMode() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isProtocolV2RomloaderMode()) {
-                Log$7.debug('Protocol V2 device is in romloader mode; start firmware update directly');
+                Log$6.debug('Protocol V2 device is in romloader mode; start firmware update directly');
                 this.protocolV2ExecutionInLoader = true;
                 return false;
             }
             if (this.isProtocolV2BootloaderMode()) {
-                Log$7.debug('Protocol V2 device is already in bootloader mode, skip reboot');
+                Log$6.debug('Protocol V2 device is already in bootloader mode, skip reboot');
                 this.protocolV2ExecutionInLoader = true;
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.GoToBootloaderSuccess);
                 return false;
@@ -53033,12 +53476,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     lastError = new Error('Protocol V2 device is reachable but is not in bootloader mode');
                 }
                 catch (error) {
-                    if (this.isProtocolV2ReconnectIdentityError(error)) {
+                    if (hdShared.isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
                         throw error;
                     }
                     shouldReconnect = true;
                     lastError = error;
-                    Log$7.log('Protocol V2 bootloader mode not ready, polling reconnect: ', error);
+                    Log$6.log('Protocol V2 bootloader mode not ready, polling reconnect: ', error);
                 }
                 yield hdShared.wait(retryInterval);
             }
@@ -53134,7 +53577,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const resourcesToSync = [];
             for (const resource of resourceSources) {
                 if (yield this.isProtocolV2ResourceBundleUpToDate(resource)) {
-                    Log$7.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
+                    Log$6.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
                 }
                 else {
                     resourcesToSync.push(resource);
@@ -53236,6 +53679,9 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     return processedSize + source.size;
                 }
                 catch (error) {
+                    if (hdShared.isBleStaleBondHardwareError(error)) {
+                        throw error;
+                    }
                     lastError = error;
                     if (attempt < PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
                         yield this.recoverProtocolV2FileTransfer();
@@ -53271,7 +53717,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     }
     assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths, liveTargetIds) {
         const resolvedExpectedPaths = expectedPaths !== null && expectedPaths !== void 0 ? expectedPaths : new Map();
-        Log$7.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateStatus records=${JSON.stringify(statusTargets)}`);
+        Log$6.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;
@@ -53286,7 +53732,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 payloadVersion: failedTarget.payload_version,
                 path: failedTarget.path,
             });
-            Log$7.error(`[FirmwareUpdateV4] firmware install failed target=${failedTargetDetails}`);
+            Log$6.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,
             });
@@ -53300,7 +53746,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     !liveTargetIds.has(targetId));
             });
             if (staleFailedTargets.length > 0) {
-                Log$7.log(`[FirmwareUpdateV4] ignoring stale failed firmware status until those targets start: ${JSON.stringify(staleFailedTargets.map(target => ({
+                Log$6.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,
@@ -53311,14 +53757,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         const seenTargetIds = new Set();
         for (const target of matchingTargets) {
             const targetId = normalizeProtocolV2TargetId(target.target_id);
-            const pathConflictsWithCurrentInstall = Boolean(target.path) &&
+            const pathConflictsWithCurrentInstall = targetId !== undefined &&
+                Boolean(target.path) &&
                 Boolean(resolvedExpectedPaths.get(targetId)) &&
                 target.path !== resolvedExpectedPaths.get(targetId) &&
                 (!liveTargetIds || liveTargetIds.has(targetId));
             if (targetId === undefined ||
                 seenTargetIds.has(targetId) ||
                 pathConflictsWithCurrentInstall) {
-                Log$7.error(`[FirmwareUpdateV4] install status conflicts with target=${target.target_id}`);
+                Log$6.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,
                 });
@@ -53359,10 +53806,41 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return true;
         }
         if (expectedTargetIds.size > 0 && matchingTargets.length > 0) {
-            const hasInProgressTarget = matchingTargets.some(target => isProtocolV2TargetStatusInProgress(target.status));
+            let detailedProgress = completedTargetIds.size * 100;
+            let installProgressMetadata;
+            let hasInProgressTarget = false;
+            matchingTargets.forEach(target => {
+                var _a, _b;
+                const targetId = normalizeProtocolV2TargetId(target.target_id);
+                if (targetId === undefined ||
+                    completedTargetIds.has(targetId) ||
+                    !isProtocolV2TargetStatusInProgress(target.status) ||
+                    (liveTargetIds && !liveTargetIds.has(targetId))) {
+                    return;
+                }
+                hasInProgressTarget = true;
+                detailedProgress += (_a = normalizeProtocolV2ProgressPercent(target.progress_percent)) !== null && _a !== void 0 ? _a : 0;
+                const installPhase = target.phase_info
+                    ? PROTOCOL_V2_INSTALL_PHASE_BY_DECODED_VALUE.get(target.phase_info.phase)
+                    : undefined;
+                const installPhaseProgress = normalizeProtocolV2ProgressPercent((_b = target.phase_info) === null || _b === void 0 ? void 0 : _b.progress_percent);
+                if (installPhase && installPhaseProgress !== undefined && !installProgressMetadata) {
+                    installProgressMetadata = {
+                        installTargetId: targetId,
+                        installPhase,
+                        installPhaseProgress,
+                    };
+                }
+            });
             const completedProgress = Math.floor((completedTargetIds.size / expectedTargetIds.size) * 100);
-            const progress = Math.min(99, Math.max(completedProgress, hasInProgressTarget ? 1 : 0));
-            this.postProgressMessage(progress, 'installingFirmware');
+            const reportedProgress = Math.floor(detailedProgress / expectedTargetIds.size);
+            const progress = Math.min(99, Math.max(completedProgress, reportedProgress, hasInProgressTarget ? 1 : 0));
+            if (installProgressMetadata) {
+                this.postProgressMessage(progress, 'installingFirmware', installProgressMetadata);
+            }
+            else {
+                this.postProgressMessage(progress, 'installingFirmware');
+            }
         }
         return false;
     }
@@ -53418,9 +53896,14 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const startTime = Date.now();
             let lastError;
             let shouldReconnect = this.protocolV2InstallNeedsReconnect;
+            let installTransportReleaseObserved = shouldReconnect;
             this.protocolV2InstallNeedsReconnect = false;
             let deviceInfo;
             let bleInstallLinkReady = false;
+            let installReconnectObserved = false;
+            let finishedStatusSnapshotKey;
+            let finishedStatusSnapshotPolls = 0;
+            let fastFinishedInstallProgressReported = false;
             let installEvidenceObserved = this.protocolV2InstallTerminalSuccessObserved;
             let currentInstallStatusObserved = false;
             const liveTargetIds = new Set();
@@ -53434,6 +53917,9 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         deviceInfo = isBleInstallReconnect
                             ? undefined
                             : yield this.verifyProtocolV2ReconnectIdentity();
+                        if (installTransportReleaseObserved) {
+                            installReconnectObserved = true;
+                        }
                         shouldReconnect = false;
                     }
                     let currentDeviceInfo = deviceInfo;
@@ -53441,6 +53927,8 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         const statusResponse = yield this.device.getCommands().typedCall('DeviceFirmwareUpdateStatusGet', 'DeviceFirmwareUpdateStatus', {
                             fields: {
                                 status: true,
+                                progress_percent: true,
+                                phase_info: true,
                                 payload_version: true,
                                 path: true,
                             },
@@ -53465,10 +53953,67 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             const targetId = normalizeProtocolV2TargetId(target.target_id);
                             return targetId !== undefined && expectedTargetIds.has(targetId);
                         });
-                        const hasCurrentInstallEvidence = currentInstallStatusObserved || this.protocolV2InstallTerminalSuccessObserved;
+                        const matchingFinishedTargetIds = new Set();
+                        const matchingFinishedStatus = matchingStatusTargets
+                            .map(target => {
+                            const targetId = normalizeProtocolV2TargetId(target.target_id);
+                            const expectedPath = targetId === undefined ? undefined : expectedPaths.get(targetId);
+                            const expectedVersion = targetId === undefined
+                                ? undefined
+                                : this.getExpectedProtocolV2TargetVersion(targetId);
+                            const payloadVersion = toProtocolV2FiniteNumber(target.payload_version);
+                            if (targetId === undefined ||
+                                matchingFinishedTargetIds.has(targetId) ||
+                                !isProtocolV2TargetStatusFinished(target.status) ||
+                                target.path !== expectedPath ||
+                                (expectedVersion !== undefined && payloadVersion !== expectedVersion)) {
+                                return undefined;
+                            }
+                            matchingFinishedTargetIds.add(targetId);
+                            return [targetId, target.path, payloadVersion !== null && payloadVersion !== void 0 ? payloadVersion : null];
+                        })
+                            .filter((target) => !!target)
+                            .sort(([leftTargetId], [rightTargetId]) => leftTargetId - rightTargetId);
+                        const hasCompleteMatchingFinishedStatus = matchingFinishedStatus.length === expectedTargetIds.size &&
+                            matchingFinishedTargetIds.size === expectedTargetIds.size &&
+                            expectedTargetIds.size > 0;
+                        if (requireCurrentInstallStatus &&
+                            installReconnectObserved &&
+                            hasCompleteMatchingFinishedStatus) {
+                            const nextSnapshotKey = JSON.stringify(matchingFinishedStatus);
+                            if (nextSnapshotKey === finishedStatusSnapshotKey) {
+                                finishedStatusSnapshotPolls += 1;
+                            }
+                            else {
+                                finishedStatusSnapshotKey = nextSnapshotKey;
+                                finishedStatusSnapshotPolls = 1;
+                            }
+                        }
+                        else {
+                            finishedStatusSnapshotKey = undefined;
+                            finishedStatusSnapshotPolls = 0;
+                        }
+                        if (requireCurrentInstallStatus &&
+                            installReconnectObserved &&
+                            hasCompleteMatchingFinishedStatus &&
+                            !currentInstallStatusObserved &&
+                            !this.protocolV2InstallTerminalSuccessObserved &&
+                            !fastFinishedInstallProgressReported) {
+                            this.postProgressMessage(1, 'installingFirmware');
+                            fastFinishedInstallProgressReported = true;
+                        }
+                        const finishedAfterReconnectObserved = finishedStatusSnapshotPolls >= PROTOCOL_V2_INSTALL_FINISHED_AFTER_RECONNECT_POLLS;
+                        const hasCurrentInstallEvidence = currentInstallStatusObserved ||
+                            this.protocolV2InstallTerminalSuccessObserved ||
+                            finishedAfterReconnectObserved;
+                        if (hasCurrentInstallEvidence) {
+                            installEvidenceObserved = true;
+                        }
                         const shouldVerifyTargetCompletion = !requireCurrentInstallStatus || hasCurrentInstallEvidence;
                         if (shouldVerifyTargetCompletion &&
-                            this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths, requireCurrentInstallStatus && !this.protocolV2InstallTerminalSuccessObserved
+                            this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths, requireCurrentInstallStatus &&
+                                !this.protocolV2InstallTerminalSuccessObserved &&
+                                !finishedAfterReconnectObserved
                                 ? liveTargetIds
                                 : undefined)) {
                             return;
@@ -53493,7 +54038,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             if (isNormalMode &&
                                 (installEvidenceObserved ||
                                     this.hasProtocolV2InstallVersionChanged(expectedTargetIds))) {
-                                Log$7.log('[FirmwareUpdateV4] empty firmware status after confirmed App reboot; update complete');
+                                Log$6.log('[FirmwareUpdateV4] empty firmware status after confirmed App reboot; update complete');
                                 this.recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds);
                                 this.postProgressMessage(100, 'installingFirmware');
                                 return;
@@ -53532,7 +54077,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             if (isNormalMode &&
                                 (installEvidenceObserved ||
                                     this.hasProtocolV2InstallVersionChanged(expectedTargetIds))) {
-                                Log$7.log('[FirmwareUpdateV4] firmware status endpoint unavailable after confirmed App reboot');
+                                Log$6.log('[FirmwareUpdateV4] firmware status endpoint unavailable after confirmed App reboot');
                                 this.recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds);
                                 this.postProgressMessage(100, 'installingFirmware');
                                 return;
@@ -53545,11 +54090,16 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             }
                         }
                         else {
+                            if (isProtocolV2DeviceDisconnectedError(error) || isProtocolV2ResponseTimeout(error)) {
+                                installTransportReleaseObserved = true;
+                                finishedStatusSnapshotKey = undefined;
+                                finishedStatusSnapshotPolls = 0;
+                            }
                             shouldReconnect = true;
                             deviceInfo = undefined;
                             bleInstallLinkReady = false;
                             lastError = error;
-                            Log$7.log('[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ', error);
+                            Log$6.log('[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ', error);
                         }
                     }
                 }
@@ -53568,11 +54118,11 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     shouldReconnect = true;
                     deviceInfo = undefined;
                     bleInstallLinkReady = false;
-                    Log$7.log('Protocol V2 firmware install device readiness probe failed: ', error);
+                    Log$6.log('Protocol V2 firmware install device readiness probe failed: ', error);
                 }
                 yield hdShared.wait(1000);
             }
-            Log$7.error(`[FirmwareUpdateV4] install timed out after ${PROTOCOL_V2_INSTALL_TIMEOUT / 1000}s: ${this.normalizeErrorMessage(lastError)}`);
+            Log$6.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,
             });
@@ -53584,12 +54134,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const deviceInfo = yield this.verifyProtocolV2ReconnectIdentity();
             try {
                 if (yield this.probeProtocolV2NormalMode(deviceInfo)) {
-                    Log$7.log('[FirmwareUpdateV4] device already returned to App mode; skip Normal reboot');
+                    Log$6.log('[FirmwareUpdateV4] device already returned to App mode; skip Normal reboot');
                     return;
                 }
             }
             catch (error) {
-                Log$7.log('[FirmwareUpdateV4] unable to confirm App mode before Normal reboot: ', error);
+                if (hdShared.isBleStaleBondHardwareError(error)) {
+                    throw error;
+                }
+                Log$6.log('[FirmwareUpdateV4] unable to confirm App mode before Normal reboot: ', error);
             }
             yield this.protocolV2Reboot(hdTransport.DeviceRebootType.Normal);
             this.protocolV2ExecutionInLoader = false;
@@ -53617,7 +54170,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
         this.protocolV2LatestFinalFeatures = features;
         if (firmwareVersion === '0.0.0') {
-            Log$7.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$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.');
         }
         return {
             bootloaderVersion,
@@ -53663,12 +54216,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     lastError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'Protocol V2 device is still in bootloader mode');
                 }
                 catch (error) {
-                    if (this.isProtocolV2ReconnectIdentityError(error)) {
+                    if (hdShared.isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
                         throw error;
                     }
                     shouldReconnect = true;
                     lastError = error;
-                    Log$7.log('Protocol V2 normal mode not ready, polling Ping: ', error);
+                    Log$6.log('Protocol V2 normal mode not ready, polling Ping: ', error);
                 }
                 yield hdShared.wait(1000);
             }
@@ -53732,7 +54285,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             if (!reconnectDevice) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
             }
-            Log$7.debug('Protocol V2 firmware reconnect using matched device:', reconnectDevice.getConnectId());
+            Log$6.debug('Protocol V2 firmware reconnect using matched device:', reconnectDevice.getConnectId());
             this.device.updateFromCache(reconnectDevice);
             yield this.ensureProtocolV2DeviceAcquired();
             this.device.commands.disposed = false;
@@ -53773,8 +54326,8 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             });
             if (writeRes.type !== 'FilesystemFile') {
                 if (writeRes.type === 'CallMethodError') {
-                    if (((_a = writeRes.message.error) !== null && _a !== void 0 ? _a : '').indexOf(SESSION_ERROR$1) > -1) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR$1);
+                    if (((_a = writeRes.message.error) !== null && _a !== void 0 ? _a : '').indexOf(SESSION_ERROR) > -1) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR);
                     }
                 }
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
@@ -53826,17 +54379,17 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             return;
                         this.protocolV2InstallTerminalSuccessObserved = true;
                         this.device.clearCancelableAction();
-                        Log$7.log('[FirmwareUpdateV4] firmware install completed by device response');
+                        Log$6.log('[FirmwareUpdateV4] firmware install completed by device response');
                     },
                 });
-                Log$7.log('[FirmwareUpdateV4] firmware install request written; continue with status polling');
+                Log$6.log('[FirmwareUpdateV4] firmware install request written; continue with status polling');
             }
             catch (error) {
                 this.throwIfAborted();
                 if (!isProtocolV2DeviceDisconnectedError(error)) {
                     throw error;
                 }
-                Log$7.log('[FirmwareUpdateV4] transport released while writing install request; continue status polling');
+                Log$6.log('[FirmwareUpdateV4] transport released while writing install request; continue status polling');
                 this.protocolV2InstallNeedsReconnect = true;
             }
         });
@@ -53847,12 +54400,14 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             try {
                 const res = yield typedCall('DeviceReboot', 'Success', {
                     reboot_type: rebootType,
-                });
+                }, { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT });
                 this.device.markProtocolV2Reboot(rebootType);
                 return res.message;
             }
             catch (error) {
-                if (isProtocolV2DeviceDisconnectedError(error) || isProtocolV2ReconnectProbeError(error)) {
+                if (isProtocolV2DeviceDisconnectedError(error) ||
+                    isProtocolV2ReconnectProbeError(error) ||
+                    isProtocolV2ResponseTimeout(error)) {
                     this.device.markProtocolV2Reboot(rebootType);
                     return { message: 'Device rebooted successfully' };
                 }
@@ -53868,7 +54423,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     }
 }
 
-const Log$6 = getLogger(exports.LoggerNames.Method);
+const Log$5 = getLogger(exports.LoggerNames.Method);
 class PromptWebDeviceAccess extends BaseMethod {
     init() {
         this.useDevice = false;
@@ -53923,7 +54478,7 @@ class PromptWebDeviceAccess extends BaseMethod {
                 return { device: null };
             }
             catch (error) {
-                Log$6.debug(error);
+                Log$5.debug(error);
                 return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
             }
         });
@@ -54028,280 +54583,6 @@ function decodeJpegBase64ToRgba({ jpegBase64, parameterName, expectedWidth, expe
     return decoded;
 }
 
-const Log$5 = 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 = 'session not found';
-function formatFileTransferRate(bytesPerSecond) {
-    return (Math.max(bytesPerSecond, 0) / 1024).toFixed(2);
-}
-function getAverageFileTransferRate(transferredBytes, elapsedMs) {
-    if (elapsedMs <= 0)
-        return 0;
-    return Math.round((Math.max(transferredBytes, 0) / elapsedMs) * 1000);
-}
-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, }) {
-    const segmentedMetrics = measuredAttempts > 0
-        ? ` hostWriteTotal=${(hostWriteElapsedMs / 1000).toFixed(2)}s responseWaitTotal=${(responseWaitElapsedMs / 1000).toFixed(2)}s measuredAttempts=${measuredAttempts}`
-        : '';
-    Log$5.log(`[FileWrite] metrics transport=${transport} status=${status} path=${path} bytes=${transferredBytes}/${totalBytes} elapsed=${(elapsedMs / 1000).toFixed(2)}s speed=${formatFileTransferRate(rateBytesPerSecond)} KiB/s${segmentedMetrics}`);
-}
-function isProtocolV2ResponseTimeout(error) {
-    var _a, _b;
-    if (!error || typeof error !== 'object')
-        return false;
-    const candidate = error;
-    const code = (_a = candidate.errorCode) !== null && _a !== void 0 ? _a : candidate.code;
-    return (code === hdShared.HardwareErrorCode.BleTimeoutError ||
-        code === 'response-timeout' ||
-        /(?:BLE|Lowlevel|Protocol V2) response timeout/i.test((_b = candidate.message) !== null && _b !== void 0 ? _b : ''));
-}
-function getProtocolV2FileChunkLimit() {
-    const env = DataManager.getSettings('env');
-    return env && DataManager.isBleConnect(env)
-        ? hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
-        : hdTransport.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
-}
-function dataToUint8Array(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof data === 'string')
-            return new TextEncoder().encode(data);
-        if (data instanceof ArrayBuffer)
-            return new Uint8Array(data);
-        if (ArrayBuffer.isView(data)) {
-            return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-        }
-        if (typeof Blob !== 'undefined' && data instanceof Blob) {
-            return new Uint8Array(yield data.arrayBuffer());
-        }
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Unsupported FilesystemFileWrite data');
-    });
-}
-function normalizeChunkSize(value, maxChunkSize) {
-    const numeric = Number(value);
-    if (!Number.isFinite(numeric) || numeric <= 0)
-        return maxChunkSize;
-    return Math.min(Math.max(Math.floor(numeric), MIN_FILE_CHUNK_SIZE), maxChunkSize);
-}
-function getDeviceTransferProgress(before, after, total) {
-    if (!Number.isFinite(total) || total <= 0)
-        return 100;
-    if (before <= 0 && after < total)
-        return 0;
-    if (after >= total)
-        return 100;
-    return Math.min(Math.max(Math.ceil((after / total) * 100), 1), 99);
-}
-function getConfirmedProgress(processed, total, written, length) {
-    if (Number.isFinite(processed) && Number.isFinite(total) && total > 0) {
-        if (processed >= total)
-            return 100;
-        return Math.min(Math.max(Math.floor((processed / total) * 100), 0), 99);
-    }
-    if (length > 0)
-        return written >= length ? 100 : Math.floor((written / length) * 100);
-    return 100;
-}
-function writeProtocolV2File(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
-    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);
-        const dataLength = data.byteLength;
-        const startOffset = Number.isFinite(options.offset) && Number(options.offset) > 0 ? Number(options.offset) : 0;
-        const totalSize = Number.isFinite(options.totalSize) && Number(options.totalSize) > 0
-            ? Number(options.totalSize)
-            : startOffset + dataLength;
-        if (totalSize < startOffset + dataLength) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite totalSize ${totalSize} is smaller than offset + data length ${startOffset + dataLength}`);
-        }
-        const defaultChunkSizeLimit = getProtocolV2FileChunkLimit();
-        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);
-        let written = 0;
-        let chunks = 0;
-        let lastMessage;
-        const startTime = Date.now();
-        let rateWindowStartedAt = startTime;
-        let rateWindowStartedBytes = 0;
-        let rateBytesPerSecond;
-        let lastConfirmedAt = startTime;
-        let logWindowStartedAt = startTime;
-        let logWindowStartedBytes = 0;
-        let hostWriteElapsedMs = 0;
-        let responseWaitElapsedMs = 0;
-        let measuredAttempts = 0;
-        const transport = getFileTransferTransport();
-        Log$5.log(`[FileWrite] started transport=${transport} path=${options.path} bytes=${dataLength} offset=${startOffset} chunk=${chunkSize}`);
-        try {
-            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;
-                let response;
-                let isWritePending = true;
-                while (isWritePending) {
-                    let currentHostWriteElapsedMs;
-                    let responseWaitStartedAt;
-                    try {
-                        const callOptions = options.writeWithResponse === undefined
-                            ? {
-                                timeoutMs: options.timeoutMs,
-                                onWriteCompleted: ({ elapsedMs }) => {
-                                    currentHostWriteElapsedMs = elapsedMs;
-                                    responseWaitStartedAt = Date.now();
-                                },
-                            }
-                            : Object.assign(Object.assign({}, (options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs })), { writeWithResponse: options.writeWithResponse, onWriteCompleted: ({ elapsedMs }) => {
-                                    currentHostWriteElapsedMs = elapsedMs;
-                                    responseWaitStartedAt = Date.now();
-                                } });
-                        response = yield options.commands.typedCall('FilesystemFileWrite', 'FilesystemFile', request, callOptions);
-                        isWritePending = false;
-                    }
-                    catch (error) {
-                        if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error))
-                            throw error;
-                        retryCount += 1;
-                        (_k = options.throwIfAborted) === null || _k === void 0 ? void 0 : _k.call(options);
-                    }
-                    finally {
-                        if (currentHostWriteElapsedMs !== undefined && responseWaitStartedAt !== undefined) {
-                            hostWriteElapsedMs += currentHostWriteElapsedMs;
-                            responseWaitElapsedMs += Math.max(Date.now() - responseWaitStartedAt, 0);
-                            measuredAttempts += 1;
-                        }
-                    }
-                }
-                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)) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR);
-                    }
-                    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}`);
-                }
-                written =
-                    rawProcessedByte === undefined ? written + chunk.byteLength : 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);
-                }
-                (_p = options.onProgress) === null || _p === void 0 ? void 0 : _p.call(options, {
-                    progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
-                    transferredBytes,
-                    totalBytes: dataLength,
-                    rateBytesPerSecond,
-                    elapsedMs,
-                });
-                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);
-                    });
-                }
-            }
-        }
-        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);
-        logFileTransferMetrics({
-            transport,
-            status: 'completed',
-            path: options.path,
-            transferredBytes: written,
-            totalBytes: dataLength,
-            elapsedMs,
-            rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
-            hostWriteElapsedMs,
-            responseWaitElapsedMs,
-            measuredAttempts,
-        });
-        return Object.assign(Object.assign({}, lastMessage), { path: options.path, offset: startOffset, total_size: totalSize, processed_byte: startOffset + written, chunks });
-    });
-}
-
 const WALLPAPER_DIRECTORY = 'vol1:/wallpapers';
 const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
@@ -54861,6 +55142,8 @@ class ProtocolV2UiInteractionCoordinator {
 const Log$3 = getLogger(exports.LoggerNames.Core);
 const createProtocolV2UnlockContext = () => ({
     preflightCompleted: false,
+    preflightStatusRefreshed: false,
+    preflightMainPinSelected: false,
 });
 const resolvePreUnlockPinType = (method) => {
     var _a, _b;
@@ -54893,10 +55176,11 @@ function runMethodWithUnlockPolicy(method, device, options = {}) {
             }
             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(resolvePreUnlockPinType(method), shouldCoordinateUi
+                const unlockedStatus = yield device.unlockDevice(preUnlockPinType, shouldCoordinateUi
                     ? { emitUiEvent: false, interaction: unlockInteraction }
                     : {
                         source: 'unlock-coordinator',
@@ -54907,8 +55191,10 @@ function runMethodWithUnlockPolicy(method, device, options = {}) {
                 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());
@@ -55197,6 +55483,7 @@ class AllNetworkGetAddressBase extends BaseMethod {
                 const response = yield runMethodWithUnlockPolicy(method, this.device, {
                     context: this.protocolV2UnlockContext,
                     prepare: () => __awaiter(this, void 0, void 0, function* () {
+                        var _d;
                         if (this.temporarySafetyCheckPrompted) {
                             method.temporarySafetyCheckPrompted = true;
                         }
@@ -55210,7 +55497,7 @@ class AllNetworkGetAddressBase extends BaseMethod {
                         const deriveCardano = method.name.startsWith('cardano');
                         const shouldResumeWalletSession = useEmptyPassphrase || !!this.payload.passphraseState;
                         if (this.device.isProtocolV2() && shouldResumeWalletSession) {
-                            const passphraseStateSafety = yield this.device.checkPassphraseStateSafety(this.payload.passphraseState, useEmptyPassphrase, this.payload.skipPassphraseCheck, deriveCardano);
+                            const passphraseStateSafety = yield this.device.checkPassphraseStateSafety(this.payload.passphraseState, useEmptyPassphrase, this.payload.skipPassphraseCheck, deriveCardano, (_d = this.protocolV2UnlockContext) === null || _d === void 0 ? void 0 : _d.preflightMainPinSelected);
                             if (!passphraseStateSafety) {
                                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckPassphraseStateError);
                             }
@@ -65307,7 +65594,7 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
                         }
                     },
                     prepare: () => __awaiter(void 0, void 0, void 0, function* () {
-                        var _o, _p, _q, _r, _s;
+                        var _o, _p, _q, _r, _s, _t;
                         if (method.deviceId && method.checkDeviceId && !deviceIdCheckedDuringUnlockPreflight) {
                             const isSameDeviceID = yield checkLiveDeviceId(device, method.deviceId);
                             if (!isSameDeviceID) {
@@ -65327,7 +65614,7 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
                                     require: support.require,
                                 });
                             }
-                            const passphraseStateSafety = yield device.checkPassphraseStateSafety((_o = method.payload) === null || _o === void 0 ? void 0 : _o.passphraseState, (_p = method.payload) === null || _p === void 0 ? void 0 : _p.useEmptyPassphrase, (_q = method.payload) === null || _q === void 0 ? void 0 : _q.skipPassphraseCheck, hasDeriveCardano(method));
+                            const passphraseStateSafety = yield device.checkPassphraseStateSafety((_o = method.payload) === null || _o === void 0 ? void 0 : _o.passphraseState, (_p = method.payload) === null || _p === void 0 ? void 0 : _p.useEmptyPassphrase, (_q = method.payload) === null || _q === void 0 ? void 0 : _q.skipPassphraseCheck, hasDeriveCardano(method), (_r = method.protocolV2UnlockContext) === null || _r === void 0 ? void 0 : _r.preflightMainPinSelected);
                             checkPassphraseEnableState(method, device.features);
                             if (!passphraseStateSafety) {
                                 DevicePool.clearDeviceCache(method.payload.connectId);
@@ -65345,7 +65632,7 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
                                 ? e
                                 : hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'open safety check failed.');
                         }
-                        (_s = (_r = method.device) === null || _r === void 0 ? void 0 : _r.commands) === null || _s === void 0 ? void 0 : _s.checkDisposed();
+                        (_t = (_s = method.device) === null || _s === void 0 ? void 0 : _s.commands) === null || _t === void 0 ? void 0 : _t.checkDisposed();
                     }),
                 });
                 messageResponse = createResponseMessage(method.responseID, true, response);
@@ -65561,6 +65848,11 @@ function isMissingDetectedProtocolV2Error(method, error) {
         typeof typedError.message === 'string' &&
         typedError.message.includes('Device protocol has not been detected'));
 }
+function isProtocolV2PeerRemovedPairingError(method, error) {
+    return (method.payload.connectProtocol === 'V2' &&
+        (error === null || error === void 0 ? void 0 : error.errorCode) ===
+            hdShared.HardwareErrorCode.BlePeerRemovedPairingInformation);
+}
 const BLE_ACQUIRE_DEADLINE_MS = 60 * 1000;
 function raceBleAcquire(acquirePromise, abortSignal) {
     return new Promise((resolve, reject) => {
@@ -65672,7 +65964,7 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
     Log.debug(`EnsureConnected function start, MAX_RETRY_COUNT=${MAX_RETRY_COUNT}, POLL_INTERVAL_TIME=${POLL_INTERVAL_TIME}  `);
     const poll = (time = POLL_INTERVAL_TIME) => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
-            var _t;
+            var _u;
             const abort = () => {
                 if (abortSignal && abortSignal.aborted) {
                     if (timer) {
@@ -65782,7 +66074,8 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                     hdShared.HardwareErrorCode.BridgeNeedsPermission,
                     hdShared.HardwareErrorCode.DeviceInterruptedFromUser,
                     hdShared.HardwareErrorCode.CallQueueActionCancelled,
-                ].includes(error.errorCode)) {
+                ].includes(error.errorCode) ||
+                    isProtocolV2PeerRemovedPairingError(method, error)) {
                     reject(error);
                     return;
                 }
@@ -65792,7 +66085,7 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                     clearTimeout(timer);
                 }
                 Log.debug('EnsureConnected get to max try count, will return: ', tryCount);
-                if (DataManager.isBrowserWebUsb(env) && !((_t = method.payload) === null || _t === void 0 ? void 0 : _t.skipWebDevicePrompt)) {
+                if (DataManager.isBrowserWebUsb(env) && !((_u = method.payload) === null || _u === void 0 ? void 0 : _u.skipWebDevicePrompt)) {
                     postMessage(createUiMessage(UI_REQUEST.WEB_DEVICE_PROMPT_ACCESS_PERMISSION));
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission));
                 }
@@ -65905,8 +66198,12 @@ const checkPassphraseEnableState = (method, features) => {
     }
 };
 const shouldCheckPassphraseState = (method, device) => {
+    var _a;
     if (!method.useDevicePassphraseState)
         return false;
+    if (device.isProtocolV2() && ((_a = method.payload) === null || _a === void 0 ? void 0 : _a.useEmptyPassphrase) === true) {
+        return true;
+    }
     return device.hasUsePassphrase();
 };
 const cleanup = () => {