@onekeyfe/hwk-trezor-adapter 1.2.8-alpha.12 → 1.2.8-alpha.13

package/dist/index.js

@@ -8,6 +8,24 @@
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -762,10 +780,34 @@ function debugLog(...args) {
   emitLog("debug", ...args);
 }
 
+// src/utils/queueKey.ts
+function trezorQueueKey({
+  operationId,
+  connectId
+}) {
+  return operationId || connectId || "";
+}
+
 // src/adapter/TrezorAdapter.ts
 var KNOWN_HARDWARE_ERROR_CODES = new Set(
   Object.values(_hwkadaptercore.HardwareErrorCode).filter((value) => typeof value === "number")
 );
+var ALL_NETWORK_COMMON_PARAM_KEYS = [
+  "autoInstallApp",
+  "passphraseState",
+  "useEmptyPassphrase",
+  "operationId",
+  "knownConnections",
+  "extra",
+  "allowDeviceSelection",
+  "supportedTransports"
+];
+var ALL_NETWORK_ROUTING_PARAM_KEYS = [
+  "operationId",
+  "knownConnections",
+  "allowDeviceSelection",
+  "supportedTransports"
+];
 var TREZOR_BTC_NETWORK_COIN_MAP = {
   btc: "Bitcoin",
   bitcoin: "Bitcoin",
@@ -782,9 +824,24 @@ var TREZOR_BTC_NETWORK_COIN_MAP = {
   dash: "Dash"
 };
 var _TrezorAdapter = class _TrezorAdapter {
-  constructor(connector) {
+  constructor(connector, options) {
     this.vendor = "trezor";
+    // The connector has no protocol-level cancel: the adapter stops waiting and
+    // drops the late response, the device carries on.
+    this.cancelCapability = "stops-waiting";
     this._emitter = new (0, _hwkadaptercore.TypedEventEmitter)();
+    this._operations = new (0, _hwkadaptercore.OperationRegistry)({
+      vendor: "trezor",
+      onEnded: (operation, reason) => {
+        this._emitter.emit(_hwkadaptercore.SDK.OPERATION_ENDED, {
+          type: _hwkadaptercore.SDK.OPERATION_ENDED,
+          payload: { operationId: operation.operationId, reason }
+        });
+        if (reason === "timeout") {
+          void this._releaseOperationConnection(operation).catch(() => void 0);
+        }
+      }
+    });
     this._devices = /* @__PURE__ */ new Map();
     this._sessions = /* @__PURE__ */ new Map();
     this._connectingPromises = /* @__PURE__ */ new Map();
@@ -793,12 +850,21 @@ var _TrezorAdapter = class _TrezorAdapter {
     this._uiRegistry = new (0, _hwkadaptercore.UiRequestRegistry)();
     this._passphraseRequestContextByConnectId = /* @__PURE__ */ new Map();
     this._verifiedPassphraseSessionsByConnectId = /* @__PURE__ */ new Map();
+    /** Raw connector calls that outlive an aborted caller, keyed by session. */
+    this._unsettledConnectorOperations = /* @__PURE__ */ new Map();
+    this._connectorIdleWaiters = /* @__PURE__ */ new Set();
+    this._resetPromise = null;
+    this._connectorTeardownTail = Promise.resolve();
+    this._pendingConnectorTeardowns = 0;
+    this._stateGeneration = 0;
+    this._knownDeviceConnections = /* @__PURE__ */ new Map();
     this._onDeviceConnect = (data) => {
       const device = this._connectorDeviceToDeviceInfo(data.device);
       this._devices.set(device.connectId, device);
       this._emitter.emit(_hwkadaptercore.DEVICE.CONNECT, { type: _hwkadaptercore.DEVICE.CONNECT, payload: device });
     };
     this._onDeviceDisconnect = (data) => {
+      this._operations.endByConnectionKey(data.connectId, "disconnect");
       this._sessions.delete(data.connectId);
       this._verifiedPassphraseSessionsByConnectId.delete(data.connectId);
       this._devices.delete(data.connectId);
@@ -818,25 +884,32 @@ var _TrezorAdapter = class _TrezorAdapter {
         payload: { device }
       });
     };
+    // The one outlet for every connector-raised UI request (PIN, passphrase,
+    // button, THP pairing), so the operation is stamped here instead of at each
+    // connector call site.
     this._onUiRequest = (data) => {
+      const operationId = this._activeOperationId();
+      const basePayload = data.payload && typeof data.payload === "object" ? data.payload : {};
+      const attribution = operationId === void 0 ? {} : { operationId };
       if (data.type === _hwkadaptercore.UI_REQUEST.REQUEST_PASSPHRASE) {
-        const payload = data.payload && typeof data.payload === "object" ? data.payload : {};
-        const connectId = typeof payload.connectId === "string" ? payload.connectId : void 0;
+        const connectId = typeof basePayload.connectId === "string" ? basePayload.connectId : void 0;
         const context = connectId ? this._passphraseRequestContextByConnectId.get(connectId) : void 0;
         this._emitter.emit(
           data.type,
           {
             ...data,
             payload: {
-              ...payload,
+              ...basePayload,
               ..._optionalChain([context, 'optionalAccess', _13 => _13.passphraseState]) !== void 0 ? { passphraseState: context.passphraseState } : {},
-              ..._optionalChain([context, 'optionalAccess', _14 => _14.useEmptyPassphrase]) !== void 0 ? { useEmptyPassphrase: context.useEmptyPassphrase } : {}
+              ..._optionalChain([context, 'optionalAccess', _14 => _14.useEmptyPassphrase]) !== void 0 ? { useEmptyPassphrase: context.useEmptyPassphrase } : {},
+              ...attribution
             }
           }
         );
         return;
       }
-      this._emitter.emit(data.type, data);
+      const payload = operationId === void 0 ? data.payload : { ...basePayload, ...attribution };
+      this._emitter.emit(data.type, { ...data, payload });
     };
     this._onUiEvent = (data) => {
       this._emitter.emit("ui-event", data);
@@ -848,6 +921,11 @@ var _TrezorAdapter = class _TrezorAdapter {
       });
     };
     this._connector = connector;
+    for (const connection of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.knownDeviceConnections]), () => ( []))) {
+      if (connection.deviceId) {
+        this._knownDeviceConnections.set(connection.deviceId, { ...connection });
+      }
+    }
     this._jobQueue = new (0, _hwkadaptercore.DeviceJobQueue)();
     this._registerConnectorEvents();
   }
@@ -872,29 +950,35 @@ var _TrezorAdapter = class _TrezorAdapter {
       const {
         passphraseState,
         autoInstallApp: _autoInstallApp,
+        operationId,
         useEmptyPassphrase,
+        knownConnections,
+        extra,
+        allowDeviceSelection,
+        supportedTransports,
         ...rest
       } = params;
       return {
         passphraseState: typeof passphraseState === "string" ? passphraseState : void 0,
         useEmptyPassphrase: typeof useEmptyPassphrase === "boolean" ? useEmptyPassphrase : void 0,
+        operationId: typeof operationId === "string" ? operationId : void 0,
+        connectionContext: _hwkadaptercore.pickConnectionContext.call(void 0, {
+          knownConnections,
+          extra,
+          allowDeviceSelection,
+          supportedTransports
+        }),
         rest
       };
     }
     return { rest: _nullishCoalesce(params, () => ( {})) };
   }
   static _withAllNetworkRequestCommonParams(item, commonParams) {
-    const autoInstallApp = _optionalChain([commonParams, 'optionalAccess', _15 => _15.autoInstallApp]);
-    const passphraseState = _optionalChain([commonParams, 'optionalAccess', _16 => _16.passphraseState]);
-    const useEmptyPassphrase = _optionalChain([commonParams, 'optionalAccess', _17 => _17.useEmptyPassphrase]);
-    if (autoInstallApp === void 0 && passphraseState === void 0 && useEmptyPassphrase === void 0) {
-      return item;
-    }
+    const defined = ALL_NETWORK_COMMON_PARAM_KEYS.filter((key) => _optionalChain([commonParams, 'optionalAccess', _16 => _16[key]]) !== void 0);
     return {
       ...item,
-      ...autoInstallApp !== void 0 ? { autoInstallApp } : {},
-      ...passphraseState !== void 0 ? { passphraseState } : {},
-      ...useEmptyPassphrase !== void 0 ? { useEmptyPassphrase } : {}
+      ...Object.fromEntries(defined.map((key) => [key, _optionalChain([commonParams, 'optionalAccess', _17 => _17[key]])])),
+      ...Object.fromEntries(ALL_NETWORK_ROUTING_PARAM_KEYS.map((key) => [key, _optionalChain([commonParams, 'optionalAccess', _18 => _18[key]])]))
     };
   }
   static _normalizeLogKey(key) {
@@ -950,8 +1034,8 @@ var _TrezorAdapter = class _TrezorAdapter {
     };
   }
   static _trezorFailureMessage(error) {
-    const response = _optionalChain([error, 'optionalAccess', _18 => _18.response]);
-    const message = _optionalChain([response, 'optionalAccess', _19 => _19.message]);
+    const response = _optionalChain([error, 'optionalAccess', _19 => _19.response]);
+    const message = _optionalChain([response, 'optionalAccess', _20 => _20.message]);
     if (!message || typeof message !== "object") return {};
     const failureMessage = message;
     return {
@@ -960,7 +1044,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     };
   }
   static _mapTrezorFailureCode(error) {
-    const directCode = _optionalChain([error, 'optionalAccess', _20 => _20.code]);
+    const directCode = _optionalChain([error, 'optionalAccess', _21 => _21.code]);
     if (directCode === "Device_InitializeFailed") {
       return _hwkadaptercore.HardwareErrorCode.PinCancelled;
     }
@@ -973,7 +1057,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (directCode === "Failure_UnexpectedMessage") {
       return _hwkadaptercore.HardwareErrorCode.MethodNotSupported;
     }
-    const message = _optionalChain([error, 'optionalAccess', _21 => _21.message]);
+    const message = _optionalChain([error, 'optionalAccess', _22 => _22.message]);
     if (typeof message === "string" && message.includes("Failed to execute 'transfer") && message.includes("on 'USBDevice'")) {
       return _hwkadaptercore.HardwareErrorCode.TransportError;
     }
@@ -1018,13 +1102,11 @@ var _TrezorAdapter = class _TrezorAdapter {
    * selected is gone (the device evicted it from its limited slot pool). The
    * caller drops the stale cache entry and recreates from scratch.
    *
-   * NOTE: the exact eviction code still needs real-device confirmation — match
-   * conservatively so a genuine error isn't mistaken for an evicted session
-   * (which would silently re-prompt the passphrase).
+   * Match only the protocol's explicit unallocated-channel code. Guessing from
+   * an error message could replay a request after an unrelated business error.
    */
   static _isStaleSessionError(code) {
-    if (typeof code !== "string") return false;
-    return code === "ThpUnallocatedChannel" || /invalid.?session|unallocated.?session|session.?not.?found/i.test(code);
+    return code === "ThpUnallocatedChannel";
   }
   static _errorCode(error) {
     return _nullishCoalesce(error.code, () => ( _TrezorAdapter._trezorFailureMessage(error).code));
@@ -1038,13 +1120,13 @@ var _TrezorAdapter = class _TrezorAdapter {
     return protocolError.name === "TrezorProtocolError" && protocolError.code === "Malformed protocol format" && protocolError.message === "Malformed protocol format";
   }
   /**
-   * Race a promise against an abort signal. Copied from LedgerAdapter:
-   * IConnector.call() can't actually be cancelled at the protocol level, but
-   * the caller gets the abort immediately and the underlying work completes
-   * uselessly in the background.
+   * Race a promise against an abort signal. IConnector.call() can't actually
+   * be cancelled at the protocol level, so the caller gets the abort while the
+   * adapter keeps the transport exclusively reserved until the raw call drains.
    */
   static _abortable(signal, promise) {
     if (signal.aborted) {
+      void promise.catch(() => void 0);
       return Promise.reject(
         _nullishCoalesce(signal.reason, () => ( new Error("Aborted")))
       );
@@ -1066,17 +1148,37 @@ var _TrezorAdapter = class _TrezorAdapter {
       );
     });
   }
-  async _connectSession(connectId, signal) {
+  async _connectSession(connectId, signal, stateGeneration, transportType) {
     const connectOnce = async () => {
-      const connectPromise = this._connector.connect(connectId);
-      if (!signal) return connectPromise;
+      if (_optionalChain([signal, 'optionalAccess', _23 => _23.aborted])) {
+        throw _nullishCoalesce(signal.reason, () => ( new Error("Aborted")));
+      }
+      this._assertConnectorIdle("connectDevice");
+      const releaseOperation = this._retainConnectorOperation(`connect:${connectId}`);
+      let connectPromise;
       try {
-        return await _TrezorAdapter._abortable(signal, connectPromise);
+        connectPromise = transportType ? this._connector.connect(connectId, { transportType }) : this._connector.connect(connectId);
       } catch (error) {
-        void connectPromise.then(
-          (orphan) => this._connector.disconnect(orphan.sessionId).catch(() => void 0),
-          () => void 0
-        );
+        releaseOperation();
+        throw error;
+      }
+      if (!signal) {
+        try {
+          return await connectPromise;
+        } finally {
+          releaseOperation();
+        }
+      }
+      try {
+        const session2 = await _TrezorAdapter._abortable(signal, connectPromise);
+        releaseOperation();
+        return session2;
+      } catch (error) {
+        if (signal.aborted) {
+          void connectPromise.then((orphan) => this._connector.disconnect(orphan.sessionId).catch(() => void 0)).catch(() => void 0).finally(releaseOperation);
+        } else {
+          releaseOperation();
+        }
         throw error;
       }
     };
@@ -1084,7 +1186,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     try {
       session = await connectOnce();
     } catch (error) {
-      if (_optionalChain([signal, 'optionalAccess', _22 => _22.aborted]) || !_TrezorAdapter._isRecoverableProtocolResidueError(error)) {
+      if (_optionalChain([signal, 'optionalAccess', _24 => _24.aborted]) || !_TrezorAdapter._isRecoverableProtocolResidueError(error)) {
         throw error;
       }
       debugLog("[TrezorAdapter] retrying connect after draining a stale THP frame", {
@@ -1092,8 +1194,13 @@ var _TrezorAdapter = class _TrezorAdapter {
       });
       session = await connectOnce();
     }
-    if (this._disconnectRequested.delete(connectId)) {
-      await this._connector.disconnect(session.sessionId).catch(() => void 0);
+    if (_optionalChain([signal, 'optionalAccess', _25 => _25.aborted]) || stateGeneration !== this._stateGeneration || this._disconnectRequested.delete(connectId)) {
+      const releaseCleanup = this._retainConnectorOperation(`disconnect:${session.sessionId}`);
+      try {
+        await this._connector.disconnect(session.sessionId).catch(() => void 0);
+      } finally {
+        releaseCleanup();
+      }
       throw Object.assign(new Error("Trezor connection aborted"), {
         code: _hwkadaptercore.HardwareErrorCode.UserAborted
       });
@@ -1109,14 +1216,9 @@ var _TrezorAdapter = class _TrezorAdapter {
   async init(_config) {
   }
   async dispose() {
+    await this._resetStateAndDisconnectSessions();
     this._unregisterConnectorEvents();
-    this._uiRegistry.reset();
-    this._jobQueue.clear();
     this._connector.reset();
-    this._devices.clear();
-    this._sessions.clear();
-    this._verifiedPassphraseSessionsByConnectId.clear();
-    this._connectingPromises.clear();
     this._emitter.removeAllListeners();
   }
   /**
@@ -1125,12 +1227,31 @@ var _TrezorAdapter = class _TrezorAdapter {
    * error flows. Aborts active jobs and releases UI waits.
    */
   resetState() {
+    void this._resetStateAndDisconnectSessions();
+  }
+  _resetStateAndDisconnectSessions() {
+    if (this._resetPromise) return this._resetPromise;
+    const sessionIds = new Set(this._sessions.values());
+    this._stateGeneration += 1;
+    this._operations.endAll("runtime-reset");
     this._uiRegistry.reset();
+    this._connector.uiResponse({ type: _hwkadaptercore.UI_RESPONSE.CANCEL });
     this._jobQueue.clear();
     this._devices.clear();
     this._sessions.clear();
     this._verifiedPassphraseSessionsByConnectId.clear();
     this._connectingPromises.clear();
+    const resetPromise = this._runConnectorTeardown(async () => {
+      for (const sessionId of sessionIds) {
+        await this._connector.disconnect(sessionId).catch(() => void 0);
+      }
+    });
+    this._resetPromise = resetPromise;
+    return resetPromise.finally(() => {
+      if (this._resetPromise === resetPromise) {
+        this._resetPromise = null;
+      }
+    });
   }
   getAvailableTransports() {
     return this.activeTransport ? [this.activeTransport] : [];
@@ -1138,32 +1259,160 @@ var _TrezorAdapter = class _TrezorAdapter {
   async switchTransport(_type) {
   }
   async searchDevices(options) {
-    await this._ensureDevicePermission();
+    await this._ensureDevicePermission(void 0, void 0, _optionalChain([options, 'optionalAccess', _26 => _26.transportType]));
+    return this._searchDevices(options);
+  }
+  async _searchDevices(options, signal) {
+    if (_optionalChain([options, 'optionalAccess', _27 => _27.transportType]) && !this._availableTransports().includes(options.transportType))
+      return [];
+    if (_optionalChain([options, 'optionalAccess', _28 => _28.resetSession])) {
+      await this._resetStateAndDisconnectSessions();
+    } else {
+      await this._connectorTeardownTail;
+    }
+    if (_optionalChain([signal, 'optionalAccess', _29 => _29.aborted])) throw signal.reason;
+    const stateGeneration = this._stateGeneration;
     const scanned = await this._connector.searchDevices(
-      _optionalChain([options, 'optionalAccess', _23 => _23.waitForAllTransports]) ? { waitForAll: true } : void 0
+      _optionalChain([options, 'optionalAccess', _30 => _30.waitForAllTransports]) || _optionalChain([options, 'optionalAccess', _31 => _31.transportType]) ? {
+        ...options.waitForAllTransports ? { waitForAll: true } : {},
+        ...options.transportType ? { transportType: options.transportType } : {}
+      } : void 0
     );
+    if (_optionalChain([signal, 'optionalAccess', _32 => _32.aborted])) throw signal.reason;
+    if (stateGeneration !== this._stateGeneration) {
+      throw _hwkadaptercore.createHwkError.call(void 0, {
+        code: _hwkadaptercore.HardwareErrorCode.UserAborted,
+        message: "Trezor discovery belongs to an ended operation"
+      });
+    }
     const scannedIds = new Set(scanned.map((d) => d.connectId));
     for (const connectId of [...this._devices.keys()]) {
-      if (!scannedIds.has(connectId) && !this._sessions.has(connectId)) {
+      if ((!_optionalChain([options, 'optionalAccess', _33 => _33.transportType]) || _optionalChain([this, 'access', _34 => _34._devices, 'access', _35 => _35.get, 'call', _36 => _36(connectId), 'optionalAccess', _37 => _37.connectionType]) === options.transportType) && !scannedIds.has(connectId) && !this._sessions.has(connectId)) {
         this._devices.delete(connectId);
       }
     }
     for (const device of scanned) {
       const info = this._connectorDeviceToDeviceInfo(device);
-      this._devices.set(info.connectId, info);
+      if (!this._sessions.has(info.connectId)) this._devices.set(info.connectId, info);
+    }
+    return Array.from(this._devices.values()).filter(
+      (device) => !_optionalChain([options, 'optionalAccess', _38 => _38.transportType]) || device.connectionType === options.transportType
+    );
+  }
+  async searchDeviceTargets(options) {
+    const devices = await this.searchDevices(options);
+    return devices.map((device) => _hwkadaptercore.toPhysicalDeviceSearchTarget.call(void 0, "trezor", device));
+  }
+  async bindBleDevice(params) {
+    if (_optionalChain([params, 'access', _39 => _39.identity, 'optionalAccess', _40 => _40.vendor]) !== "trezor" || !params.identity.value) {
+      return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.InvalidParams, "Trezor device identity is required");
+    }
+    const { value: deviceId } = params.identity;
+    try {
+      return await this._jobQueue.enqueue(
+        deviceId,
+        async (signal) => {
+          const selected = await this._selectBleDeviceForBinding(
+            deviceId,
+            signal,
+            { extra: params.extra },
+            "manual-rebind"
+          );
+          try {
+            const persisted = await this._emitVerifiedBinding(
+              deviceId,
+              selected.connectId,
+              selected.selectionRequestId,
+              { extra: params.extra },
+              signal
+            );
+            if (!persisted) {
+              throw _hwkadaptercore.createHwkError.call(void 0, {
+                code: _hwkadaptercore.HardwareErrorCode.UnknownError,
+                message: "Bluetooth binding could not be saved",
+                origin: "host"
+              });
+            }
+            this._rememberVerifiedConnection(deviceId, selected.connectId);
+            return _hwkadaptercore.success.call(void 0, selected.connectId);
+          } catch (error) {
+            await this._releaseProvisionalConnection(selected.connectId, signal);
+            throw error;
+          }
+        },
+        {
+          label: "bindBleDevice",
+          rejectIfBusy: true,
+          busyError: _TrezorAdapter._createDeviceBusyError("bindBleDevice")
+        }
+      );
+    } catch (error) {
+      return this._errorToFailure(error);
     }
-    return Array.from(this._devices.values());
   }
-  async connectDevice(connectId) {
+  async connectDevice(searchTargetId) {
+    const scope = this._jobQueue.createCancelScope(searchTargetId);
     try {
-      await this._ensureDevicePermission(connectId);
-      await this._ensureSession(connectId);
-      return _hwkadaptercore.success.call(void 0, connectId);
+      await _TrezorAdapter._abortable(
+        scope.signal,
+        this._ensureDevicePermission(
+          searchTargetId,
+          void 0,
+          _optionalChain([this, 'access', _41 => _41._devices, 'access', _42 => _42.get, 'call', _43 => _43(searchTargetId), 'optionalAccess', _44 => _44.connectionType])
+        )
+      );
+      await this._ensureSession(searchTargetId, scope.signal);
+      if (scope.signal.aborted) throw scope.signal.reason;
+      const device = this._devices.get(searchTargetId);
+      if (!device) {
+        return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.DeviceNotFound, "Trezor device not found after connect");
+      }
+      this._operations.endByConnectionKey(searchTargetId, "explicit");
+      const operation = this._operations.create({
+        searchTargetId,
+        connectId: searchTargetId,
+        device,
+        connectionType: device.connectionType,
+        connectionKeys: [_nullishCoalesce(this._sessions.get(searchTargetId), () => ( ""))]
+      });
+      return _hwkadaptercore.success.call(void 0, operation.operationId);
     } catch (error) {
+      if (scope.signal.aborted) {
+        await this._waitForConnectorOperationsToDrain();
+        return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.UserAborted, "Trezor connection aborted");
+      }
       return this._errorToFailure(error);
+    } finally {
+      scope.release();
     }
   }
-  async disconnectDevice(connectId) {
+  async releaseOperation(operationId) {
+    const operation = this._operations.findActive(operationId);
+    if (operation) this._cancelOperationWork(operation);
+    const endedOperation = this._operations.release(operationId);
+    if (!endedOperation) return;
+    await this._releaseOperationConnection(endedOperation);
+  }
+  /**
+   * Ends a released operation's calls and prompts before teardown, which otherwise waits on a call
+   * that waits on a prompt nobody will answer. Device I/O already on the wire still drains.
+   */
+  _cancelOperationWork(operation) {
+    const { operationId } = operation;
+    const reason = _hwkadaptercore.createHwkError.call(void 0, {
+      code: _hwkadaptercore.HardwareErrorCode.OperationEnded,
+      message: "Trezor operation was released",
+      params: { operationId, reason: "explicit" }
+    });
+    const queueKey = trezorQueueKey({ operationId });
+    const ownsRunningCall = _optionalChain([this, 'access', _45 => _45._jobQueue, 'access', _46 => _46.getActiveJob, 'call', _47 => _47(), 'optionalAccess', _48 => _48.deviceId]) === queueKey;
+    this._jobQueue.cancelActiveAndPending(queueKey, reason);
+    if (!ownsRunningCall) return;
+    this._uiRegistry.cancel(void 0, void 0, operationId);
+    this._connector.uiResponse({ type: _hwkadaptercore.UI_RESPONSE.CANCEL });
+  }
+  async _releaseOperationConnection(operation) {
+    const { connectId } = operation;
     const connecting = this._connectingPromises.has(connectId);
     this._connectingPromises.delete(connectId);
     const sessionId = this._sessions.get(connectId);
@@ -1171,90 +1420,131 @@ var _TrezorAdapter = class _TrezorAdapter {
       if (connecting) this._disconnectRequested.add(connectId);
       return;
     }
-    this._sessions.delete(connectId);
-    this._verifiedPassphraseSessionsByConnectId.delete(connectId);
-    await this._connector.disconnect(sessionId);
+    await this._disconnectSession(connectId, sessionId);
   }
-  async getDeviceInfo(connectId, deviceId) {
+  async getDeviceInfo(connectIdOrOperationId, deviceId) {
+    let connectId;
+    try {
+      connectId = _hwkadaptercore.isHardwareOperationId.call(void 0, connectIdOrOperationId) ? this._operations.resolve(connectIdOrOperationId).connectId : connectIdOrOperationId;
+    } catch (error) {
+      return this._errorToFailure(error);
+    }
     const device = _nullishCoalesce(this._devices.get(connectId), () => ( Array.from(this._devices.values()).find((item) => item.deviceId === deviceId)));
     if (!device) return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.DeviceNotFound, "Trezor device not found");
     return _hwkadaptercore.success.call(void 0, device);
   }
-  getSupportedChains() {
-    return ["btc", "evm", "sol", "tron"];
-  }
   async allNetworkGetAddress(connectId, deviceId, params) {
+    const target = _hwkadaptercore.resolveHardwareOperationTarget.call(void 0, connectId, params.operationId, "trezor");
+    if (!target.success) return target;
+    let effectiveTargetId = _nullishCoalesce(target.payload.targetId, () => ( ""));
+    let releaseOperationRetention;
+    try {
+      releaseOperationRetention = target.payload.operationId ? this._operations.retain(target.payload.operationId) : void 0;
+    } catch (error) {
+      return this._errorToFailure(error);
+    }
+    const cancelScope = this._jobQueue.createCancelScope(
+      trezorQueueKey({ operationId: target.payload.operationId, connectId: effectiveTargetId })
+    );
     let liveDeviceId = "";
+    const bundleContext = {};
     const topLevelFailureIndexes = /* @__PURE__ */ new Set();
     const isSingleNetworkBundle = params.bundle.every(
-      (item) => item.network === _optionalChain([params, 'access', _24 => _24.bundle, 'access', _25 => _25[0], 'optionalAccess', _26 => _26.network])
+      (item) => item.network === _optionalChain([params, 'access', _49 => _49.bundle, 'access', _50 => _50[0], 'optionalAccess', _51 => _51.network])
     );
-    const getLiveDeviceId = async () => {
+    const getLiveDeviceId = async (expectedDeviceId) => {
       if (liveDeviceId) return _hwkadaptercore.success.call(void 0, liveDeviceId);
-      const deviceIdResponse = await this._getTrezorDeviceId(connectId);
+      const deviceIdResponse = await this._getTrezorDeviceId(
+        effectiveTargetId,
+        expectedDeviceId || deviceId,
+        params,
+        bundleContext
+      );
       if (deviceIdResponse.success) {
         liveDeviceId = deviceIdResponse.payload;
+        if (!target.payload.operationId) {
+          effectiveTargetId = _nullishCoalesce(_optionalChain([bundleContext, 'access', _52 => _52.connection, 'optionalAccess', _53 => _53.connectId]), () => ( effectiveTargetId));
+        }
       }
       return deviceIdResponse;
     };
-    return _hwkadaptercore.runAllNetworkGetAddress.call(void 0, {
-      connectId,
-      deviceId,
-      params,
-      normalizeItem: _TrezorAdapter._normalizeAllNetworkItem,
-      callItem: async ({ method, item, index }) => {
-        const expectedDeviceId = _nullishCoalesce(_TrezorAdapter._getItemDeviceId(item), () => ( deviceId));
-        if (expectedDeviceId) {
-          const fingerprint = await getLiveDeviceId();
-          if (!fingerprint.success) {
+    try {
+      return await _hwkadaptercore.runAllNetworkGetAddress.call(void 0, {
+        connectId: effectiveTargetId,
+        deviceId,
+        params,
+        normalizeItem: _TrezorAdapter._normalizeAllNetworkItem,
+        callItem: async ({ method, item, index }) => {
+          if (cancelScope.signal.aborted) {
             topLevelFailureIndexes.add(index);
-            return fingerprint;
+            return _hwkadaptercore.buildAllNetworkCancelledFailure.call(void 0, cancelScope.signal);
           }
-          if (expectedDeviceId !== fingerprint.payload) {
-            topLevelFailureIndexes.add(index);
-            return _hwkadaptercore.failure.call(void 0, 
-              _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
-              `Wrong device: expected ${expectedDeviceId}, got ${fingerprint.payload}`,
-              { expected: expectedDeviceId, actual: fingerprint.payload }
-            );
+          const expectedDeviceId = _nullishCoalesce(_TrezorAdapter._getItemDeviceId(item), () => ( deviceId));
+          if (expectedDeviceId) {
+            const fingerprint = await getLiveDeviceId(expectedDeviceId);
+            if (!fingerprint.success) {
+              topLevelFailureIndexes.add(index);
+              return fingerprint;
+            }
+            if (expectedDeviceId !== fingerprint.payload) {
+              topLevelFailureIndexes.add(index);
+              return _hwkadaptercore.failure.call(void 0, 
+                _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
+                `Wrong device: expected ${expectedDeviceId}, got ${fingerprint.payload}`,
+                { expected: expectedDeviceId, actual: fingerprint.payload }
+              );
+            }
           }
-        }
-        const callItem = _TrezorAdapter._withAllNetworkRequestCommonParams(item, params);
-        return this._callAllNetworkMethod(connectId, method, callItem);
-      },
-      attachIdentity: async ({ item, chain, payload }) => {
-        if (!liveDeviceId) {
-          const fingerprint = await getLiveDeviceId();
-          if (!fingerprint.success) {
-            return { ...item, success: false, payload: fingerprint.payload };
+          const callItem = _TrezorAdapter._withAllNetworkRequestCommonParams(item, params);
+          return this._callAllNetworkMethod(effectiveTargetId, method, callItem, bundleContext);
+        },
+        attachIdentity: async ({ item, chain, payload, index }) => {
+          if (!liveDeviceId) {
+            if (cancelScope.signal.aborted) {
+              topLevelFailureIndexes.add(index);
+              const cancelled = _hwkadaptercore.buildAllNetworkCancelledFailure.call(void 0, cancelScope.signal);
+              return { ...item, success: false, payload: cancelled.payload };
+            }
+            const fingerprint = await getLiveDeviceId(deviceId);
+            if (!fingerprint.success) {
+              return { ...item, success: false, payload: fingerprint.payload };
+            }
           }
+          return {
+            ...item,
+            success: true,
+            payload: {
+              ...payload,
+              deviceIdentity: {
+                vendor: "trezor",
+                type: "deviceId",
+                value: liveDeviceId
+              },
+              chainFingerprint: liveDeviceId,
+              chainFingerprintChain: chain
+            }
+          };
+        },
+        // One named boolean per abort reason.
+        shouldAbortBundle: (response, { index }) => {
+          const isSessionLevelFailure = topLevelFailureIndexes.has(index);
+          const isWholeChainForbidden = isSingleNetworkBundle && _optionalChain([response, 'access', _54 => _54.payload, 'optionalAccess', _55 => _55.code]) === _hwkadaptercore.HardwareErrorCode.DevicePathForbidden;
+          const { code } = _nullishCoalesce(response.payload, () => ( {}));
+          return isSessionLevelFailure || isWholeChainForbidden || _hwkadaptercore.isWalletSafetyFailure.call(void 0, code) || _hwkadaptercore.isUserRefusal.call(void 0, code) || _hwkadaptercore.isConnectionLost.call(void 0, code);
         }
-        return {
-          ...item,
-          success: true,
-          payload: {
-            ...payload,
-            deviceIdentity: {
-              vendor: "trezor",
-              type: "deviceId",
-              value: liveDeviceId
-            },
-            chainFingerprint: liveDeviceId,
-            chainFingerprintChain: chain
-          }
-        };
-      },
-      // One named boolean per abort reason.
-      shouldAbortBundle: (response, { index }) => {
-        const isSessionLevelFailure = topLevelFailureIndexes.has(index);
-        const isWholeChainForbidden = isSingleNetworkBundle && _optionalChain([response, 'access', _27 => _27.payload, 'optionalAccess', _28 => _28.code]) === _hwkadaptercore.HardwareErrorCode.DevicePathForbidden;
-        const isPassphrasePolicyFailure = _optionalChain([response, 'access', _29 => _29.payload, 'optionalAccess', _30 => _30.code]) === _hwkadaptercore.HardwareErrorCode.PassphraseAlwaysOnDevice;
-        return isSessionLevelFailure || isWholeChainForbidden || isPassphrasePolicyFailure;
-      }
-    });
+      });
+    } finally {
+      cancelScope.release();
+      _optionalChain([releaseOperationRetention, 'optionalCall', _56 => _56()]);
+    }
   }
-  getFeatures(connectId) {
-    return this._callDeviceManagerMethod("getFeatures", connectId, {});
+  getFeatures(connectId, operationContext) {
+    return this._callDeviceManagerMethod(
+      "getFeatures",
+      connectId,
+      {},
+      operationContext
+    );
   }
   /**
    * Device authenticity attestation. Sends a host-generated challenge, has the
@@ -1289,7 +1579,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (!internalModel) {
       return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.UnknownError, "Device internal_model unavailable");
     }
-    const challengeHex = _nullishCoalesce(_optionalChain([params, 'access', _31 => _31.challenge, 'optionalAccess', _32 => _32.toLowerCase, 'call', _33 => _33()]), () => ( Buffer.from(_utils.randomBytes.call(void 0, 32)).toString("hex")));
+    const challengeHex = _nullishCoalesce(_optionalChain([params, 'access', _57 => _57.challenge, 'optionalAccess', _58 => _58.toLowerCase, 'call', _59 => _59()]), () => ( Buffer.from(_utils.randomBytes.call(void 0, 32)).toString("hex")));
     const challenge = Buffer.from(challengeHex, "hex");
     const proofRes = await this._callDeviceManagerMethod(
       "authenticateDevice",
@@ -1314,28 +1604,65 @@ var _TrezorAdapter = class _TrezorAdapter {
       }
     });
   }
-  deviceSettings(connectId, params) {
+  deviceSettings(connectId, params, operationContext) {
     return this._callDeviceManagerMethod(
       "deviceSettings",
       connectId,
-      params
+      params,
+      operationContext
     );
   }
-  setBrightness(connectId, params = {}) {
+  setBrightness(connectId, params = {}, operationContext) {
     return this._callDeviceManagerMethod(
       "setBrightness",
       connectId,
-      params
+      params,
+      operationContext
     );
   }
-  changePin(connectId, params = {}) {
-    return this._callDeviceManagerMethod("changePin", connectId, params);
+  changePin(connectId, params = {}, operationContext) {
+    return this._callDeviceManagerMethod(
+      "changePin",
+      connectId,
+      params,
+      operationContext
+    );
   }
-  wipeDevice(connectId) {
-    return this._callDeviceManagerMethod("wipeDevice", connectId, {});
+  wipeDevice(connectId, operationContext) {
+    return this._callDeviceManagerMethod(
+      "wipeDevice",
+      connectId,
+      {},
+      operationContext
+    );
   }
-  async _getTrezorDeviceId(connectId) {
-    const features = await this.getFeatures(connectId);
+  async _getTrezorDeviceId(connectId, expectedDeviceId, commonParams, bundleContext) {
+    const hasConnectionContext = _optionalChain([commonParams, 'optionalAccess', _60 => _60.knownConnections]) !== void 0 || _optionalChain([commonParams, 'optionalAccess', _61 => _61.extra]) !== void 0;
+    const features = bundleContext || hasConnectionContext ? await this._callMethod(
+      "getFeatures",
+      connectId,
+      hasConnectionContext || !connectId ? expectedDeviceId : void 0,
+      hasConnectionContext ? {
+        operationId: commonParams.operationId,
+        knownConnections: commonParams.knownConnections,
+        extra: commonParams.extra,
+        allowDeviceSelection: commonParams.allowDeviceSelection,
+        supportedTransports: commonParams.supportedTransports,
+        passphraseState: commonParams.passphraseState,
+        useEmptyPassphrase: commonParams.useEmptyPassphrase
+      } : {},
+      false,
+      bundleContext
+    ) : await this.getFeatures(
+      connectId,
+      !connectId && expectedDeviceId ? {
+        expectedDeviceIdentity: {
+          vendor: "trezor",
+          type: "deviceId",
+          value: expectedDeviceId
+        }
+      } : void 0
+    );
     if (!features.success) return features;
     const liveDeviceId = features.payload.device_id;
     if (typeof liveDeviceId !== "string" || liveDeviceId.length === 0) {
@@ -1344,23 +1671,64 @@ var _TrezorAdapter = class _TrezorAdapter {
     return _hwkadaptercore.success.call(void 0, liveDeviceId);
   }
   cancel(connectId) {
+    if (_hwkadaptercore.isHardwareOperationId.call(void 0, connectId)) {
+      try {
+        this._operations.resolve(connectId);
+      } catch (e5) {
+        return;
+      }
+    }
     const userAbortReason = Object.assign(new Error("User aborted operation"), {
       code: _hwkadaptercore.HardwareErrorCode.UserAborted
     });
-    this._uiRegistry.cancel();
-    this._connector.uiResponse({ type: _hwkadaptercore.UI_RESPONSE.CANCEL });
-    if (connectId) {
-      this._jobQueue.forceCancelActive(connectId, userAbortReason);
-      void this._connector.cancel(_nullishCoalesce(this._sessions.get(connectId), () => ( connectId)));
+    const activeJobId = _optionalChain([this, 'access', _62 => _62._jobQueue, 'access', _63 => _63.getActiveJob, 'call', _64 => _64(), 'optionalAccess', _65 => _65.deviceId]);
+    const targetId = _nullishCoalesce(connectId, () => ( activeJobId));
+    if (targetId) {
+      let resolvedConnectId = targetId;
+      let operationId;
+      if (_hwkadaptercore.isHardwareOperationId.call(void 0, targetId)) {
+        try {
+          operationId = targetId;
+          resolvedConnectId = this._operations.resolve(targetId).connectId;
+        } catch (e6) {
+          resolvedConnectId = "";
+        }
+      }
+      const interactionForPhysicalId = !operationId && connectId ? this._operations.findActiveByConnectionKey(connectId) : void 0;
+      const pendingOperationId = _nullishCoalesce(operationId, () => ( _optionalChain([interactionForPhysicalId, 'optionalAccess', _66 => _66.operationId])));
+      if (!connectId) {
+        this._uiRegistry.cancel();
+      } else if (pendingOperationId) {
+        this._uiRegistry.cancel(void 0, void 0, pendingOperationId);
+      }
+      const queueKeys = /* @__PURE__ */ new Set([trezorQueueKey({ connectId: targetId })]);
+      if (pendingOperationId) queueKeys.add(trezorQueueKey({ operationId: pendingOperationId }));
+      const ownsConnectorInteraction = activeJobId !== void 0 ? queueKeys.has(activeJobId) || pendingOperationId !== void 0 && this._activeOperationId() === pendingOperationId : this._connectingPromises.size === 1 && this._connectingPromises.has(resolvedConnectId);
+      if (connectId === void 0 || ownsConnectorInteraction) {
+        this._connector.uiResponse({ type: _hwkadaptercore.UI_RESPONSE.CANCEL });
+      }
+      for (const key of queueKeys) {
+        this._jobQueue.cancelActiveAndPending(key, userAbortReason);
+      }
+      if (resolvedConnectId) {
+        void this._connector.cancel(_nullishCoalesce(this._sessions.get(resolvedConnectId), () => ( resolvedConnectId)));
+      }
       return;
     }
-    for (const cid of this._sessions.keys()) {
-      this._jobQueue.forceCancelActive(cid, userAbortReason);
-    }
+    this._uiRegistry.cancel();
+    this._connector.uiResponse({ type: _hwkadaptercore.UI_RESPONSE.CANCEL });
+    this._jobQueue.cancelActiveAndPending(void 0, userAbortReason);
     for (const sessionId of this._sessions.values()) {
       void this._connector.cancel(sessionId);
     }
   }
+  /**
+   * Operation owning the running job: its queue key when pinned, else the live
+   * operation of its connectId, so a mid-call UI request can name it.
+   */
+  _activeOperationId() {
+    return this._operations.findOperationIdByJobKey(_optionalChain([this, 'access', _67 => _67._jobQueue, 'access', _68 => _68.getActiveJob, 'call', _69 => _69(), 'optionalAccess', _70 => _70.deviceId]));
+  }
   /**
    * Routes to BOTH the adapter's local UI registry (preemption decisions,
    * future SELECT_DEVICE / DEVICE_PERMISSION) AND the connector's registry
@@ -1369,6 +1737,7 @@ var _TrezorAdapter = class _TrezorAdapter {
    */
   uiResponse(response) {
     this._uiRegistry.resolve(response.type, response.payload);
+    if (response.type === _hwkadaptercore.UI_RESPONSE.RECEIVE_SELECT_DEVICE) return;
     this._connector.uiResponse(response);
   }
   /**
@@ -1380,8 +1749,8 @@ var _TrezorAdapter = class _TrezorAdapter {
    * Unlike Ledger (which hashes a per-chain address), it is chain-global, so
    * `chain` is accepted for API parity but ignored.
    */
-  async getChainFingerprint(connectId, _deviceId, _chain) {
-    return this._getTrezorDeviceId(connectId);
+  async getChainFingerprint(connectId, deviceId, _chain) {
+    return this._getTrezorDeviceId(connectId, deviceId);
   }
   /**
    * Resolve the active passphrase wallet identity (`passphraseState`).
@@ -1391,17 +1760,87 @@ var _TrezorAdapter = class _TrezorAdapter {
    * can't interleave with a chain call on the same device (which would desync
    * the THP session selection).
    */
-  getPassphraseState(connectId, passphraseState) {
-    return this._jobQueue.enqueue(
+  getPassphraseState(connectId, passphraseState, operationContext) {
+    const expectedIdentity = _optionalChain([operationContext, 'optionalAccess', _71 => _71.expectedDeviceIdentity]);
+    if (expectedIdentity && (expectedIdentity.vendor !== "trezor" || expectedIdentity.type !== "deviceId")) {
+      return Promise.resolve(
+        _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.InvalidParams, "Trezor device identity is required")
+      );
+    }
+    const target = _hwkadaptercore.resolveHardwareOperationTarget.call(void 0, 
       connectId,
+      _optionalChain([operationContext, 'optionalAccess', _72 => _72.operationId]),
+      "trezor"
+    );
+    if (!target.success) return Promise.resolve(target);
+    const { operationId } = target.payload;
+    let resolvedConnectId = _nullishCoalesce(target.payload.targetId, () => ( ""));
+    let releaseOperationRetention;
+    if (operationId) {
+      try {
+        resolvedConnectId = this._operations.resolve(operationId).connectId;
+        releaseOperationRetention = this._operations.retain(operationId);
+      } catch (error) {
+        return Promise.resolve(this._errorToFailure(error));
+      }
+    }
+    return this._jobQueue.enqueue(
+      trezorQueueKey({ operationId, connectId: resolvedConnectId }),
       async (signal) => {
-        const restorePassphraseRequestContext = this._setPassphraseRequestContext(connectId, {
-          passphraseState
-        });
+        let selectionRequestId;
+        let verified = false;
         try {
-          return await this._resolvePassphraseState(connectId, passphraseState, signal);
+          if (!operationId && _optionalChain([expectedIdentity, 'optionalAccess', _73 => _73.value]) && (!connectId || _optionalChain([operationContext, 'optionalAccess', _74 => _74.knownConnections]) !== void 0)) {
+            const resolved = await this._resolveExpectedDeviceConnectId(
+              expectedIdentity.value,
+              signal,
+              operationContext
+            );
+            resolvedConnectId = resolved.connectId;
+            selectionRequestId = resolved.selectionRequestId;
+          }
+          if (_optionalChain([expectedIdentity, 'optionalAccess', _75 => _75.value])) {
+            if (!operationId) await this._ensureSession(resolvedConnectId, signal);
+            if (_optionalChain([this, 'access', _76 => _76._devices, 'access', _77 => _77.get, 'call', _78 => _78(resolvedConnectId), 'optionalAccess', _79 => _79.deviceId]) !== expectedIdentity.value) {
+              return _hwkadaptercore.failure.call(void 0, 
+                _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
+                "Trezor device identity does not match"
+              );
+            }
+          }
+          const restorePassphraseRequestContext = this._setPassphraseRequestContext(
+            resolvedConnectId,
+            {
+              passphraseState
+            }
+          );
+          try {
+            const result = await this._resolvePassphraseState(
+              resolvedConnectId,
+              passphraseState,
+              signal,
+              operationId
+            );
+            if (result.success && _optionalChain([expectedIdentity, 'optionalAccess', _80 => _80.value])) {
+              await this._emitVerifiedBinding(
+                expectedIdentity.value,
+                resolvedConnectId,
+                selectionRequestId,
+                operationContext,
+                signal
+              );
+              verified = true;
+              this._rememberVerifiedConnection(expectedIdentity.value, resolvedConnectId);
+            }
+            return result;
+          } finally {
+            restorePassphraseRequestContext();
+          }
         } finally {
-          restorePassphraseRequestContext();
+          if (selectionRequestId && !verified) {
+            this._emitBindingStatus(selectionRequestId, signal.aborted ? "cancelled" : "failed");
+            await this._releaseProvisionalConnection(resolvedConnectId, signal);
+          }
         }
       },
       {
@@ -1409,7 +1848,7 @@ var _TrezorAdapter = class _TrezorAdapter {
         rejectIfBusy: true,
         busyError: _TrezorAdapter._createDeviceBusyError("getPassphraseState")
       }
-    ).catch((error) => this._errorToFailure(error));
+    ).catch((error) => this._errorToFailure(error)).finally(() => _optionalChain([releaseOperationRetention, 'optionalCall', _81 => _81()]));
   }
   evmGetAddress(connectId, deviceId, params) {
     return this._callWalletMethod("evmGetAddress", connectId, deviceId, params);
@@ -1472,11 +1911,100 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
     return result;
   }
-  static async _callConnector(connector, sessionId, method, params, signal) {
-    const promise = connector.call(sessionId, method, params);
+  async _callConnector(sessionId, method, params, signal) {
+    if (_optionalChain([signal, 'optionalAccess', _82 => _82.aborted])) {
+      throw _nullishCoalesce(signal.reason, () => ( new Error("Aborted")));
+    }
+    this._assertConnectorIdle(method);
+    const releaseOperation = this._retainConnectorOperation(`call:${sessionId}`);
+    let promise;
+    try {
+      promise = this._connector.call(sessionId, method, params).finally(() => {
+        releaseOperation();
+      });
+    } catch (error) {
+      releaseOperation();
+      throw error;
+    }
     const result = signal ? await _TrezorAdapter._abortable(signal, promise) : await promise;
     return _TrezorAdapter._unwrapConnectorResult(result);
   }
+  _assertConnectorIdle(method) {
+    if (this._resetPromise || this._pendingConnectorTeardowns > 0 || this._unsettledConnectorOperations.size > 0) {
+      throw _TrezorAdapter._createDeviceBusyError(method);
+    }
+  }
+  _runConnectorTeardown(task) {
+    const previous = this._connectorTeardownTail;
+    let releaseTail = () => void 0;
+    this._connectorTeardownTail = new Promise((resolve) => {
+      releaseTail = resolve;
+    });
+    this._pendingConnectorTeardowns += 1;
+    return (async () => {
+      try {
+        await previous;
+        await this._waitForConnectorOperationsToDrain();
+        await task();
+      } finally {
+        this._pendingConnectorTeardowns -= 1;
+        releaseTail();
+      }
+    })();
+  }
+  async _disconnectSession(connectId, sessionId = this._sessions.get(connectId)) {
+    this._sessions.delete(connectId);
+    this._verifiedPassphraseSessionsByConnectId.delete(connectId);
+    if (sessionId) await this._runConnectorTeardown(() => this._connector.disconnect(sessionId));
+  }
+  _availableTransports() {
+    return _nullishCoalesce(this._connector.availableTransports, () => ( [this._connector.connectionType]));
+  }
+  /** Transports the connector offers and the host's model table allows; discovery opens no other. */
+  _allowedTransports(context) {
+    const supported = _optionalChain([context, 'optionalAccess', _83 => _83.supportedTransports]);
+    const available = this._availableTransports();
+    return supported ? available.filter((transport) => supported.includes(transport)) : available;
+  }
+  async _releaseProvisionalConnection(connectId, signal) {
+    const sessionId = this._sessions.get(connectId);
+    this._sessions.delete(connectId);
+    this._verifiedPassphraseSessionsByConnectId.delete(connectId);
+    if (!sessionId) return;
+    const teardown = this._runConnectorTeardown(() => this._connector.disconnect(sessionId)).catch(
+      () => void 0
+    );
+    if (!signal.aborted) await teardown;
+  }
+  _waitForConnectorOperationsToDrain() {
+    if (this._unsettledConnectorOperations.size === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this._connectorIdleWaiters.add(resolve);
+    });
+  }
+  _retainConnectorOperation(key) {
+    this._unsettledConnectorOperations.set(
+      key,
+      (_nullishCoalesce(this._unsettledConnectorOperations.get(key), () => ( 0))) + 1
+    );
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const remaining = (_nullishCoalesce(this._unsettledConnectorOperations.get(key), () => ( 1))) - 1;
+      if (remaining > 0) {
+        this._unsettledConnectorOperations.set(key, remaining);
+      } else {
+        this._unsettledConnectorOperations.delete(key);
+      }
+      if (this._unsettledConnectorOperations.size === 0) {
+        for (const resolve of this._connectorIdleWaiters) resolve();
+        this._connectorIdleWaiters.clear();
+      }
+    };
+  }
   static _normalizeAllNetworkItem(method, item) {
     if (method !== "btcGetAddress" && method !== "btcGetPublicKey") {
       return item;
@@ -1495,18 +2023,14 @@ var _TrezorAdapter = class _TrezorAdapter {
     const { deviceId } = item;
     return typeof deviceId === "string" && deviceId.length > 0 ? deviceId : void 0;
   }
-  _callAllNetworkMethod(connectId, method, item) {
+  _callAllNetworkMethod(connectId, method, item, bundleContext) {
     switch (method) {
       case "evmGetAddress":
-        return this.evmGetAddress(connectId, "", item);
       case "btcGetAddress":
-        return this.btcGetAddress(connectId, "", item);
       case "btcGetPublicKey":
-        return this.btcGetPublicKey(connectId, "", item);
       case "solGetAddress":
-        return this.solGetAddress(connectId, "", item);
       case "tronGetAddress":
-        return this.tronGetAddress(connectId, "", item);
+        return this._callMethod(method, connectId, "", item, true, bundleContext);
       default:
         return Promise.resolve(
           _hwkadaptercore.failure.call(void 0, 
@@ -1525,11 +2049,51 @@ var _TrezorAdapter = class _TrezorAdapter {
   _callWalletMethod(methodName, connectId, deviceId, params) {
     return this._callMethod(methodName, connectId, deviceId, params, true);
   }
-  _callDeviceManagerMethod(methodName, connectId, params) {
-    return this._callMethod(methodName, connectId, void 0, params, false);
+  _callDeviceManagerMethod(methodName, connectId, params, operationContext) {
+    const expectedIdentity = _optionalChain([operationContext, 'optionalAccess', _84 => _84.expectedDeviceIdentity]);
+    if (expectedIdentity && (expectedIdentity.vendor !== "trezor" || expectedIdentity.type !== "deviceId")) {
+      return Promise.resolve(
+        _hwkadaptercore.failure.call(void 0, 
+          _hwkadaptercore.HardwareErrorCode.InvalidParams,
+          "Trezor device-manager operations require a Trezor deviceId identity"
+        )
+      );
+    }
+    return this._callMethod(
+      methodName,
+      connectId,
+      _optionalChain([expectedIdentity, 'optionalAccess', _85 => _85.value]),
+      {
+        ...params && typeof params === "object" ? params : {},
+        knownConnections: _optionalChain([operationContext, 'optionalAccess', _86 => _86.knownConnections]),
+        extra: _optionalChain([operationContext, 'optionalAccess', _87 => _87.extra]),
+        allowDeviceSelection: _optionalChain([operationContext, 'optionalAccess', _88 => _88.allowDeviceSelection]),
+        supportedTransports: _optionalChain([operationContext, 'optionalAccess', _89 => _89.supportedTransports]),
+        ..._optionalChain([operationContext, 'optionalAccess', _90 => _90.operationId]) ? { operationId: operationContext.operationId } : {}
+      },
+      false
+    );
   }
-  async _callMethod(methodName, connectId, deviceId, params, requiresWalletIntent) {
+  async _callMethod(methodName, connectId, deviceId, params, requiresWalletIntent, bundleContext) {
     const call = _TrezorAdapter._normalizeCallArgs(connectId, deviceId, params);
+    const commonParams = _TrezorAdapter._splitCommonParams(call.params);
+    const positionalOperationId = _hwkadaptercore.isHardwareOperationId.call(void 0, call.connectId) ? call.connectId : void 0;
+    if (positionalOperationId && commonParams.operationId && positionalOperationId !== commonParams.operationId) {
+      return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.InvalidParams, "Conflicting Trezor operation ids", {
+        positionalOperationId,
+        commonOperationId: commonParams.operationId
+      });
+    }
+    const operationId = _nullishCoalesce(commonParams.operationId, () => ( positionalOperationId));
+    let releaseOperationRetention;
+    try {
+      if (operationId) {
+        call.connectId = this._operations.resolve(operationId).connectId;
+        releaseOperationRetention = this._operations.retain(operationId);
+      }
+    } catch (error) {
+      return this._errorToFailure(error);
+    }
     debugLog("[TrezorAdapter][REQ]", {
       method: methodName,
       connectId: call.connectId || "(empty)",
@@ -1538,15 +2102,40 @@ var _TrezorAdapter = class _TrezorAdapter {
     });
     try {
       const response = await this._jobQueue.enqueue(
-        call.connectId,
-        (signal) => this._callWithRetry(
-          call.connectId,
-          methodName,
-          call.params,
-          requiresWalletIntent,
-          true,
-          signal
-        ),
+        trezorQueueKey({ operationId, connectId: call.connectId }),
+        async (signal) => {
+          let effectiveConnectId = call.connectId;
+          let selectionRequestId;
+          try {
+            if (!_optionalChain([bundleContext, 'optionalAccess', _91 => _91.connection]) && !operationId && deviceId && (!connectId || _optionalChain([commonParams, 'access', _92 => _92.connectionContext, 'optionalAccess', _93 => _93.knownConnections]) !== void 0)) {
+              const resolved = await this._resolveExpectedDeviceConnectId(
+                deviceId,
+                signal,
+                commonParams.connectionContext
+              );
+              effectiveConnectId = resolved.connectId;
+              selectionRequestId = resolved.selectionRequestId;
+            }
+          } catch (error) {
+            return this._errorToFailure(error);
+          }
+          const response2 = await this._callWithRetry(
+            _nullishCoalesce(_optionalChain([bundleContext, 'optionalAccess', _94 => _94.connection, 'optionalAccess', _95 => _95.connectId]), () => ( effectiveConnectId)),
+            methodName,
+            call.params,
+            deviceId || "",
+            requiresWalletIntent,
+            true,
+            signal,
+            operationId,
+            selectionRequestId,
+            bundleContext
+          );
+          if (!response2.success && selectionRequestId) {
+            await this._releaseProvisionalConnection(effectiveConnectId, signal);
+          }
+          return response2;
+        },
         {
           label: methodName,
           rejectIfBusy: true,
@@ -1567,16 +2156,53 @@ var _TrezorAdapter = class _TrezorAdapter {
         payload: _TrezorAdapter._sanitizeForLog(response.payload, methodName)
       });
       return response;
+    } finally {
+      _optionalChain([releaseOperationRetention, 'optionalCall', _96 => _96()]);
     }
   }
-  async _callWithRetry(connectId, methodName, params, requiresWalletIntent, allowRetry, signal) {
-    const { passphraseState, useEmptyPassphrase, rest } = _TrezorAdapter._splitCommonParams(params);
+  async _callWithRetry(connectId, methodName, params, expectedDeviceId, requiresWalletIntent, allowRetry, signal, operationId, selectionRequestId, bundleContext) {
+    const { passphraseState, useEmptyPassphrase, rest, connectionContext } = _TrezorAdapter._splitCommonParams(params);
+    let pendingBindingRequestId = selectionRequestId;
+    let businessCallStarted = false;
     const restorePassphraseRequestContext = this._setPassphraseRequestContext(connectId, {
       passphraseState,
       useEmptyPassphrase
     });
     try {
-      const sessionId = await this._ensureSession(connectId, signal);
+      if (_optionalChain([bundleContext, 'optionalAccess', _97 => _97.connection])) {
+        const pinned = bundleContext.connection;
+        if (this._sessions.get(pinned.connectId) !== pinned.sessionId) {
+          return _hwkadaptercore.failure.call(void 0, 
+            _hwkadaptercore.HardwareErrorCode.DeviceDisconnected,
+            "Trezor all-network connection ended"
+          );
+        }
+      }
+      const sessionId = operationId ? this._sessions.get(this._operations.resolve(operationId).connectId) : await this._ensureSession(connectId, signal);
+      if (!sessionId) {
+        if (operationId) {
+          this._operations.end(operationId, "disconnect");
+          return _hwkadaptercore.failure.call(void 0, 
+            _hwkadaptercore.HardwareErrorCode.OperationEnded,
+            "Trezor operation connection is no longer active",
+            { operationId, reason: "disconnect" }
+          );
+        }
+        return _hwkadaptercore.failure.call(void 0, _hwkadaptercore.HardwareErrorCode.DeviceNotFound, "Trezor session was not found");
+      }
+      if (bundleContext && !bundleContext.connection) {
+        bundleContext.connection = { connectId, sessionId };
+      }
+      if (expectedDeviceId) {
+        const actualDeviceId = _optionalChain([this, 'access', _98 => _98._devices, 'access', _99 => _99.get, 'call', _100 => _100(connectId), 'optionalAccess', _101 => _101.deviceId]);
+        if (!actualDeviceId || actualDeviceId !== expectedDeviceId) {
+          return _hwkadaptercore.failure.call(void 0, 
+            _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
+            `Wrong device: expected ${expectedDeviceId}, got ${actualDeviceId || "unknown"}`,
+            { expected: expectedDeviceId, actual: actualDeviceId || "" }
+          );
+        }
+      }
       if (requiresWalletIntent && !passphraseState && useEmptyPassphrase !== true) {
         return _hwkadaptercore.failure.call(void 0, 
           _hwkadaptercore.HardwareErrorCode.InvalidParams,
@@ -1591,39 +2217,85 @@ var _TrezorAdapter = class _TrezorAdapter {
       } else if (useEmptyPassphrase === true) {
         await _TrezorAdapter._abortable(signal, this._createFreshAppSession(sessionId, signal));
       }
+      if (expectedDeviceId) {
+        await this._emitVerifiedBinding(
+          expectedDeviceId,
+          connectId,
+          pendingBindingRequestId,
+          connectionContext,
+          signal
+        );
+        pendingBindingRequestId = void 0;
+        this._rememberVerifiedConnection(expectedDeviceId, connectId);
+      }
+      businessCallStarted = true;
       const result = await _TrezorAdapter._abortable(
         signal,
-        _TrezorAdapter._callConnector(this._connector, sessionId, methodName, rest)
+        this._callConnector(sessionId, methodName, rest, signal)
       );
       return _hwkadaptercore.success.call(void 0, result);
     } catch (error) {
       if (signal.aborted) {
+        if (pendingBindingRequestId) {
+          this._emitBindingStatus(pendingBindingRequestId, "cancelled");
+          pendingBindingRequestId = void 0;
+        }
         return this._errorToFailure(error);
       }
       const code = _TrezorAdapter._errorCode(error);
-      if (allowRetry && code === _hwkadaptercore.HardwareErrorCode.DeviceDisconnected) {
+      const willRetryStaleSession = allowRetry && (passphraseState || useEmptyPassphrase === true) && _TrezorAdapter._isStaleSessionError(code);
+      if (pendingBindingRequestId && !willRetryStaleSession) {
+        this._emitBindingStatus(pendingBindingRequestId, "failed");
+        pendingBindingRequestId = void 0;
+      }
+      const ambiguousTransportFailure = code === _hwkadaptercore.HardwareErrorCode.DeviceDisconnected || code === _hwkadaptercore.HardwareErrorCode.OperationTimeout || code === _hwkadaptercore.HardwareErrorCode.TransportError;
+      if (ambiguousTransportFailure) {
         this._sessions.delete(connectId);
         this._verifiedPassphraseSessionsByConnectId.delete(connectId);
-        return await this._callWithRetry(
-          connectId,
-          methodName,
-          params,
-          requiresWalletIntent,
-          false,
-          signal
-        );
+        const mayHaveCompleted = businessCallStarted && !_hwkadaptercore.canReplayHardwareMethodAfterTransportFailure.call(void 0, methodName);
+        const mayHaveCompletedMessage = `Trezor ${methodName} may have completed before the connection was lost`;
+        if (operationId) {
+          this._operations.end(operationId, "disconnect");
+          const endedParams = { operationId, reason: "disconnect" };
+          return mayHaveCompleted ? _hwkadaptercore.failure.call(void 0, 
+            _hwkadaptercore.HardwareErrorCode.OperationEnded,
+            mayHaveCompletedMessage,
+            _hwkadaptercore.operationMayHaveCompletedParams.call(void 0, methodName, endedParams),
+            void 0,
+            { scope: "unknown" }
+          ) : _hwkadaptercore.failure.call(void 0, 
+            _hwkadaptercore.HardwareErrorCode.OperationEnded,
+            "Trezor operation connection was lost",
+            endedParams
+          );
+        }
+        if (mayHaveCompleted) {
+          return _hwkadaptercore.failure.call(void 0, 
+            code,
+            mayHaveCompletedMessage,
+            _hwkadaptercore.operationMayHaveCompletedParams.call(void 0, methodName),
+            void 0,
+            { scope: "unknown" }
+          );
+        }
       }
-      if (allowRetry && (passphraseState || useEmptyPassphrase === true) && _TrezorAdapter._isStaleSessionError(code)) {
+      if (willRetryStaleSession) {
         if (passphraseState) {
           this._forgetVerifiedPassphraseSession(connectId, passphraseState);
         }
+        const retryBindingRequestId = pendingBindingRequestId;
+        pendingBindingRequestId = void 0;
         return await this._callWithRetry(
           connectId,
           methodName,
           params,
+          expectedDeviceId,
           requiresWalletIntent,
           false,
-          signal
+          signal,
+          operationId,
+          retryBindingRequestId,
+          bundleContext
         );
       }
       debugLog("[TrezorAdapter][ERROR]", {
@@ -1634,36 +2306,249 @@ var _TrezorAdapter = class _TrezorAdapter {
       return this._errorToFailure(error);
     } finally {
       restorePassphraseRequestContext();
+      if (pendingBindingRequestId) {
+        this._emitBindingStatus(pendingBindingRequestId, signal.aborted ? "cancelled" : "failed");
+        pendingBindingRequestId = void 0;
+      }
     }
   }
-  async _ensureSession(connectId, signal) {
+  async _ensureSession(connectId, signal, transportType) {
     const existing = this._sessions.get(connectId);
     if (existing) return existing;
     const pending = this._connectingPromises.get(connectId);
     if (pending) return pending;
+    const stateGeneration = this._stateGeneration;
     const promise = (async () => {
+      if (_optionalChain([signal, 'optionalAccess', _102 => _102.aborted])) {
+        throw Object.assign(new Error("Trezor connection aborted"), {
+          code: _hwkadaptercore.HardwareErrorCode.UserAborted
+        });
+      }
       try {
-        if (_optionalChain([signal, 'optionalAccess', _34 => _34.aborted])) {
-          throw Object.assign(new Error("Trezor connection aborted"), {
-            code: _hwkadaptercore.HardwareErrorCode.UserAborted
-          });
-        }
-        try {
-          return await this._connectSession(connectId, signal);
-        } catch (error) {
-          if (_TrezorAdapter._isConnectionUnavailableError(error)) {
-            this._sessions.delete(connectId);
-            this._verifiedPassphraseSessionsByConnectId.delete(connectId);
-          }
-          throw error;
+        return await this._connectSession(connectId, signal, stateGeneration, transportType);
+      } catch (error) {
+        if (_TrezorAdapter._isConnectionUnavailableError(error)) {
+          this._sessions.delete(connectId);
+          this._verifiedPassphraseSessionsByConnectId.delete(connectId);
         }
-      } finally {
-        this._connectingPromises.delete(connectId);
-        this._disconnectRequested.delete(connectId);
+        throw error;
       }
     })();
     this._connectingPromises.set(connectId, promise);
-    return promise;
+    try {
+      return await promise;
+    } finally {
+      if (this._connectingPromises.get(connectId) === promise) {
+        this._connectingPromises.delete(connectId);
+      }
+      this._disconnectRequested.delete(connectId);
+    }
+  }
+  /** An identity probe tears down only a session it opened; another caller's stays up. */
+  _hasSessionOrConnect(connectId) {
+    return this._sessions.has(connectId) || this._connectingPromises.has(connectId);
+  }
+  async _resolveExpectedDeviceConnectId(expectedDeviceId, signal, context) {
+    const connectedMatch = Array.from(this._devices.values()).find(
+      (device) => device.deviceId === expectedDeviceId && this._sessions.has(device.connectId)
+    );
+    if (connectedMatch) return { connectId: connectedMatch.connectId };
+    const allowedTransports = this._allowedTransports(context);
+    if (allowedTransports.includes("usb")) {
+      await _TrezorAdapter._abortable(
+        signal,
+        this._ensureDevicePermission(void 0, expectedDeviceId, "usb")
+      );
+    }
+    const candidates = allowedTransports.includes("usb") ? await _TrezorAdapter._abortable(
+      signal,
+      this._searchDevices({ transportType: "usb" }, signal)
+    ) : [];
+    const mismatchedDeviceIds = [];
+    const knownConnection = this._knownDeviceConnections.get(expectedDeviceId);
+    const knownUsbIds = _optionalChain([context, 'optionalAccess', _103 => _103.knownConnections]) !== void 0 ? context.knownConnections.flatMap(
+      (connection) => connection.transport === "usb" ? [connection.connectId] : []
+    ) : [_optionalChain([knownConnection, 'optionalAccess', _104 => _104.usbConnectId])].filter((id) => Boolean(id));
+    const suppliedBleIds = _optionalChain([context, 'optionalAccess', _105 => _105.knownConnections, 'optionalAccess', _106 => _106.flatMap, 'call', _107 => _107(
+      (connection) => connection.transport === "ble" ? [connection.connectId] : []
+    )]);
+    const knownBleIds = _optionalChain([suppliedBleIds, 'optionalAccess', _108 => _108.length]) ? suppliedBleIds : [_optionalChain([knownConnection, 'optionalAccess', _109 => _109.bleConnectId])].filter((id) => Boolean(id));
+    const usbCandidates = candidates.filter(
+      (device) => device.connectionType === "usb" && (!knownUsbIds.length || knownUsbIds.includes(device.connectId))
+    );
+    for (const candidate of usbCandidates) {
+      let sessionId;
+      const probeOpensSession = !this._hasSessionOrConnect(candidate.connectId);
+      try {
+        sessionId = await this._ensureSession(candidate.connectId, signal, "usb");
+        const actualDeviceId = _nullishCoalesce(_optionalChain([this, 'access', _110 => _110._devices, 'access', _111 => _111.get, 'call', _112 => _112(candidate.connectId), 'optionalAccess', _113 => _113.deviceId]), () => ( ""));
+        if (actualDeviceId === expectedDeviceId) return { connectId: candidate.connectId };
+        mismatchedDeviceIds.push(actualDeviceId || "unknown");
+      } catch (error) {
+        if (signal.aborted) throw error;
+        if (!_TrezorAdapter._isConnectionUnavailableError(error)) throw error;
+      }
+      if (sessionId && probeOpensSession) {
+        await this._disconnectSession(candidate.connectId, sessionId);
+      }
+    }
+    if (mismatchedDeviceIds.length) {
+      throw _hwkadaptercore.createHwkError.call(void 0, {
+        code: _hwkadaptercore.HardwareErrorCode.DeviceSearchMismatch,
+        message: "The connected Trezor is not the wallet this operation needs. Unplug it and connect the right device.",
+        params: { connectedDeviceIds: mismatchedDeviceIds }
+      });
+    }
+    if (usbCandidates.length > 0) {
+      throw _hwkadaptercore.createHwkError.call(void 0, {
+        code: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
+        message: "Trezor devices are present but none could be opened to check its identity."
+      });
+    }
+    const [knownBleConnectId] = knownBleIds;
+    if (knownBleConnectId && allowedTransports.includes("ble")) {
+      await _TrezorAdapter._abortable(
+        signal,
+        this._ensureDevicePermission(knownBleConnectId, expectedDeviceId, "ble")
+      );
+      const probeOpensSession = !this._hasSessionOrConnect(knownBleConnectId);
+      await this._ensureSession(knownBleConnectId, signal, "ble");
+      const actualDeviceId = _optionalChain([this, 'access', _114 => _114._devices, 'access', _115 => _115.get, 'call', _116 => _116(knownBleConnectId), 'optionalAccess', _117 => _117.deviceId]);
+      if (actualDeviceId === expectedDeviceId) return { connectId: knownBleConnectId };
+      if (probeOpensSession) await this._disconnectSession(knownBleConnectId);
+      throw _hwkadaptercore.createHwkError.call(void 0, {
+        code: _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
+        message: "The bound Trezor Bluetooth device has a different identity"
+      });
+    }
+    if (_optionalChain([context, 'optionalAccess', _118 => _118.supportedTransports]) && !context.supportedTransports.includes("ble")) {
+      throw _hwkadaptercore.createHwkError.call(void 0, {
+        code: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
+        message: "This Trezor model has no Bluetooth transport; connect it over USB"
+      });
+    }
+    if (_optionalChain([context, 'optionalAccess', _119 => _119.allowDeviceSelection]) === false) {
+      throw _hwkadaptercore.createHwkError.call(void 0, {
+        code: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
+        message: "No known Trezor connection is available"
+      });
+    }
+    return this._selectBleDeviceForBinding(expectedDeviceId, signal, context, "missing-binding");
+  }
+  async _selectBleDeviceForBinding(expectedDeviceId, signal, context, reason) {
+    const availableTransports = this._allowedTransports(context);
+    const allowUsbFallback = reason !== "manual-rebind" && availableTransports.includes("usb");
+    const knownUsbIds = _optionalChain([context, 'optionalAccess', _120 => _120.knownConnections]) ? context.knownConnections.flatMap(
+      (connection) => connection.transport === "usb" ? [connection.connectId] : []
+    ) : [_optionalChain([this, 'access', _121 => _121._knownDeviceConnections, 'access', _122 => _122.get, 'call', _123 => _123(expectedDeviceId), 'optionalAccess', _124 => _124.usbConnectId])];
+    if (availableTransports.includes("ble")) {
+      await _TrezorAdapter._abortable(
+        signal,
+        this._ensureDevicePermission(void 0, expectedDeviceId, "ble")
+      );
+    }
+    const bleCandidates = (await _TrezorAdapter._abortable(
+      signal,
+      this._searchDevices({ transportType: "ble", waitForAllTransports: true }, signal)
+    )).filter((device) => device.connectionType === "ble");
+    if (signal.aborted) throw signal.reason;
+    const rejectedConnectIds = /* @__PURE__ */ new Set();
+    const bindingSessionId = this._uiRegistry.createRequestId();
+    let rejectedConnectId;
+    while (availableTransports.includes("ble") && this._emitter.listenerCount(_hwkadaptercore.UI_REQUEST.REQUEST_SELECT_DEVICE)) {
+      const { device: selected, requestId } = await _hwkadaptercore.requestBleDeviceSelection.call(void 0, {
+        emitter: this._emitter,
+        registry: this._uiRegistry,
+        signal,
+        allowUsbFallback,
+        scan: async () => {
+          if (allowUsbFallback) {
+            const usbCandidates = (await this._searchDevices({ transportType: "usb" }, signal)).filter(
+              (device) => device.connectionType === "usb" && !rejectedConnectIds.has(device.connectId)
+            );
+            const candidate = _nullishCoalesce(usbCandidates.find((device) => knownUsbIds.includes(device.connectId)), () => ( usbCandidates[0]));
+            if (candidate) return [candidate];
+          }
+          return (await this._searchDevices({ transportType: "ble", waitForAllTransports: true }, signal)).filter(
+            (device) => device.connectionType === "ble" && !rejectedConnectIds.has(device.connectId)
+          );
+        },
+        request: {
+          devices: bleCandidates.filter((device) => !rejectedConnectIds.has(device.connectId)),
+          bindingSessionId,
+          rejectedConnectId,
+          context: {
+            kind: "bind-connection",
+            transport: "ble",
+            reason
+          },
+          extra: _optionalChain([context, 'optionalAccess', _125 => _125.extra]),
+          operationId: this._activeOperationId()
+        }
+      });
+      let probeOpensSession = false;
+      try {
+        if (reason === "manual-rebind") {
+          this._operations.endByConnectionKey(selected.connectId, "explicit");
+          await this._releaseProvisionalConnection(selected.connectId, signal);
+        }
+        probeOpensSession = !this._hasSessionOrConnect(selected.connectId);
+        await this._ensureSession(selected.connectId, signal, selected.connectionType);
+      } catch (error) {
+        this._emitBindingStatus(requestId, signal.aborted ? "cancelled" : "failed");
+        throw error;
+      }
+      if (_optionalChain([this, 'access', _126 => _126._devices, 'access', _127 => _127.get, 'call', _128 => _128(selected.connectId), 'optionalAccess', _129 => _129.deviceId]) !== expectedDeviceId) {
+        if (probeOpensSession) await this._disconnectSession(selected.connectId);
+        rejectedConnectId = selected.connectId;
+        rejectedConnectIds.add(selected.connectId);
+        continue;
+      }
+      if (selected.connectionType === "usb") {
+        this._emitBindingStatus(requestId, "cancelled");
+        return { connectId: selected.connectId };
+      }
+      return { connectId: selected.connectId, selectionRequestId: requestId };
+    }
+    throw _hwkadaptercore.createHwkError.call(void 0, {
+      code: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
+      message: "No readable Trezor device is available"
+    });
+  }
+  _emitBindingStatus(selectionRequestId, status) {
+    _hwkadaptercore.emitDeviceBindingStatus.call(void 0, this._emitter, selectionRequestId, status);
+  }
+  _rememberVerifiedConnection(deviceId, connectId) {
+    const device = this._devices.get(connectId);
+    if (!device || device.deviceId !== deviceId) return;
+    const known = _nullishCoalesce(this._knownDeviceConnections.get(deviceId), () => ( { deviceId }));
+    if (device.connectionType === "ble") {
+      known.bleConnectId = connectId;
+    } else if (device.connectionType === "usb" && _optionalChain([device, 'access', _130 => _130.capabilities, 'optionalAccess', _131 => _131.persistentDeviceIdentity])) {
+      known.usbConnectId = connectId;
+    }
+    this._knownDeviceConnections.set(deviceId, known);
+  }
+  async _emitVerifiedBinding(deviceId, connectId, selectionRequestId, context, signal) {
+    if (!selectionRequestId) return false;
+    const device = this._devices.get(connectId);
+    if (!device || device.deviceId !== deviceId || device.connectionType !== "ble") {
+      this._emitBindingStatus(selectionRequestId, "cancelled");
+      return false;
+    }
+    const outcome = await _hwkadaptercore.requestSaveDeviceBinding.call(void 0, 
+      this._emitter,
+      this._uiRegistry,
+      {
+        selectionRequestId,
+        connection: { transport: "ble", connectId },
+        identity: { vendor: "trezor", type: "deviceId", value: deviceId },
+        extra: _optionalChain([context, 'optionalAccess', _132 => _132.extra]),
+        operationId: this._activeOperationId()
+      },
+      signal
+    );
+    return outcome.saved;
   }
   /**
    * Pin the device's active wallet session to `passphraseState` (the target
@@ -1685,12 +2570,21 @@ var _TrezorAdapter = class _TrezorAdapter {
     if (reused) return;
     const created = await _TrezorAdapter._abortable(
       signal,
-      _TrezorAdapter._callConnector(this._connector, sessionId, "__thpCreateSession", {
-        passphraseMode: "prompt"
-      })
+      this._callConnector(
+        sessionId,
+        "__thpCreateSession",
+        {
+          passphraseMode: "prompt"
+        },
+        signal
+      )
     );
-    if (_optionalChain([created, 'optionalAccess', _35 => _35.protocol]) === "thp" && !created.thpSessionId) return;
-    if (_optionalChain([created, 'optionalAccess', _36 => _36.protocol]) !== "thp" && _optionalChain([created, 'optionalAccess', _37 => _37.protocol]) !== "v1") return;
+    if (_optionalChain([created, 'optionalAccess', _133 => _133.protocol]) === "thp" && !created.thpSessionId || _optionalChain([created, 'optionalAccess', _134 => _134.protocol]) !== "thp" && _optionalChain([created, 'optionalAccess', _135 => _135.protocol]) !== "v1") {
+      throw _hwkadaptercore.createHwkError.call(void 0, {
+        code: _hwkadaptercore.HardwareErrorCode.TransportError,
+        message: "Cannot verify the requested Trezor wallet session"
+      });
+    }
     const state = await this._deriveState(sessionId, signal);
     if (state !== passphraseState) {
       throw Object.assign(
@@ -1704,13 +2598,13 @@ var _TrezorAdapter = class _TrezorAdapter {
   }
   _rememberVerifiedPassphraseSession(connectId, passphraseState, sessionId, created) {
     let session;
-    if (_optionalChain([created, 'optionalAccess', _38 => _38.protocol]) === "thp" && typeof created.thpSessionId === "string") {
+    if (_optionalChain([created, 'optionalAccess', _136 => _136.protocol]) === "thp" && typeof created.thpSessionId === "string") {
       session = {
         sessionId,
         protocol: "thp",
         thpSessionId: created.thpSessionId
       };
-    } else if (_optionalChain([created, 'optionalAccess', _39 => _39.protocol]) === "v1") {
+    } else if (_optionalChain([created, 'optionalAccess', _137 => _137.protocol]) === "v1") {
       session = {
         sessionId,
         protocol: "v1"
@@ -1730,7 +2624,7 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
   }
   async _reuseVerifiedPassphraseSession(connectId, sessionId, passphraseState, signal) {
-    const cached = _optionalChain([this, 'access', _40 => _40._verifiedPassphraseSessionsByConnectId, 'access', _41 => _41.get, 'call', _42 => _42(connectId), 'optionalAccess', _43 => _43.get, 'call', _44 => _44(passphraseState)]);
+    const cached = _optionalChain([this, 'access', _138 => _138._verifiedPassphraseSessionsByConnectId, 'access', _139 => _139.get, 'call', _140 => _140(connectId), 'optionalAccess', _141 => _141.get, 'call', _142 => _142(passphraseState)]);
     if (!cached || cached.sessionId !== sessionId) {
       this._forgetVerifiedPassphraseSession(connectId, passphraseState);
       return false;
@@ -1740,9 +2634,14 @@ var _TrezorAdapter = class _TrezorAdapter {
         if (!cached.thpSessionId) return false;
         await _TrezorAdapter._abortable(
           signal,
-          _TrezorAdapter._callConnector(this._connector, sessionId, "__thpSelectSession", {
-            thpSessionId: cached.thpSessionId
-          })
+          this._callConnector(
+            sessionId,
+            "__thpSelectSession",
+            {
+              thpSessionId: cached.thpSessionId
+            },
+            signal
+          )
         );
       }
       const state = await this._deriveState(sessionId, signal);
@@ -1760,9 +2659,14 @@ var _TrezorAdapter = class _TrezorAdapter {
   async _createFreshAppSession(sessionId, signal) {
     await _TrezorAdapter._abortable(
       signal,
-      _TrezorAdapter._callConnector(this._connector, sessionId, "__thpCreateSession", {
-        passphraseMode: "empty"
-      })
+      this._callConnector(
+        sessionId,
+        "__thpCreateSession",
+        {
+          passphraseMode: "empty"
+        },
+        signal
+      )
     );
   }
   /**
@@ -1777,12 +2681,17 @@ var _TrezorAdapter = class _TrezorAdapter {
   async _deriveState(sessionId, signal) {
     const derived = await _TrezorAdapter._abortable(
       signal,
-      _TrezorAdapter._callConnector(this._connector, sessionId, "btcGetPublicKey", {
-        path: "m/44'/0'/0'",
-        showOnDevice: false
-      })
+      this._callConnector(
+        sessionId,
+        "btcGetPublicKey",
+        {
+          path: "m/44'/0'/0'",
+          showOnDevice: false
+        },
+        signal
+      )
     );
-    const state = _optionalChain([derived, 'optionalAccess', _45 => _45.publicKey]);
+    const state = _optionalChain([derived, 'optionalAccess', _143 => _143.publicKey]);
     if (!state) {
       throw Object.assign(new Error("Failed to derive passphrase state (wallet public key)"), {
         code: _hwkadaptercore.HardwareErrorCode.UnknownError
@@ -1790,25 +2699,36 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
     return state;
   }
-  async _resolvePassphraseState(connectId, passphraseState, signal) {
+  async _resolvePassphraseState(connectId, passphraseState, signal, operationId) {
     try {
-      const sessionId = await this._ensureSession(connectId, signal);
+      const sessionId = operationId ? this._sessions.get(this._operations.resolve(operationId).connectId) : await this._ensureSession(connectId, signal);
+      if (!sessionId) {
+        return _hwkadaptercore.failure.call(void 0, 
+          _hwkadaptercore.HardwareErrorCode.OperationEnded,
+          "Trezor operation connection is no longer active"
+        );
+      }
       if (passphraseState) {
         await this._alignAppSession(connectId, sessionId, passphraseState, signal);
         return _hwkadaptercore.success.call(void 0, passphraseState);
       }
       const created = await _TrezorAdapter._abortable(
         signal,
-        _TrezorAdapter._callConnector(this._connector, sessionId, "__thpCreateSession", {
-          passphraseMode: "prompt"
-        })
+        this._callConnector(
+          sessionId,
+          "__thpCreateSession",
+          {
+            passphraseMode: "prompt"
+          },
+          signal
+        )
       );
       const state = await this._deriveState(sessionId, signal);
       const features = await _TrezorAdapter._abortable(
         signal,
-        _TrezorAdapter._callConnector(this._connector, sessionId, "getFeatures", { refresh: true })
+        this._callConnector(sessionId, "getFeatures", { refresh: true }, signal)
       );
-      if (_optionalChain([features, 'optionalAccess', _46 => _46.passphrase_protection]) !== true) {
+      if (_optionalChain([features, 'optionalAccess', _144 => _144.passphrase_protection]) !== true) {
         return _hwkadaptercore.success.call(void 0, null);
       }
       this._rememberVerifiedPassphraseSession(connectId, state, sessionId, created);
@@ -1856,7 +2776,16 @@ var _TrezorAdapter = class _TrezorAdapter {
     }
     const trustedNumericCode = typeof typed.code === "number" && KNOWN_HARDWARE_ERROR_CODES.has(typed.code) ? typed.code : void 0;
     const code = _nullishCoalesce(_nullishCoalesce(trustedNumericCode, () => ( _TrezorAdapter._mapTrezorFailureCode(error))), () => ( _hwkadaptercore.HardwareErrorCode.UnknownError));
-    return _hwkadaptercore.failure.call(void 0, code, _nullishCoalesce(typed.message, () => ( String(error))));
+    const stampedOrigin = _optionalChain([error, 'optionalAccess', _145 => _145.origin]);
+    const origin = stampedOrigin === "device" || stampedOrigin === "transport" || stampedOrigin === "host" ? stampedOrigin : _hwkadaptercore.defaultOriginForCode.call(void 0, code);
+    const params = typed.params && typeof typed.params === "object" ? typed.params : void 0;
+    return _hwkadaptercore.failure.call(void 0, 
+      code,
+      _nullishCoalesce(typed.message, () => ( String(error))),
+      params,
+      origin,
+      _hwkadaptercore.isHwkRecoveryHint.call(void 0, typed.recovery) ? typed.recovery : void 0
+    );
   }
   /**
    * Emit `REQUEST_DEVICE_PERMISSION` and await the host's
@@ -1871,29 +2800,33 @@ var _TrezorAdapter = class _TrezorAdapter {
    *   - no `connectId` → environment-level check (scan / picker)
    *   - with `connectId` → device-level check (per-call gating)
    */
-  async _ensureDevicePermission(connectId, deviceId) {
+  async _ensureDevicePermission(connectId, deviceId, requestedTransport) {
     if (!this._emitter.listenerCount(_hwkadaptercore.UI_REQUEST.REQUEST_DEVICE_PERMISSION)) {
       return;
     }
-    const transportType = _nullishCoalesce(this.activeTransport, () => ( "usb"));
+    const transportType = _nullishCoalesce(_nullishCoalesce(requestedTransport, () => ( this.activeTransport)), () => ( "usb"));
+    const operationId = this._activeOperationId();
     const waitPromise = this._uiRegistry.wait(
       _hwkadaptercore.UI_REQUEST.REQUEST_DEVICE_PERMISSION,
-      { timeoutMs: 6e4 }
+      { timeoutMs: 6e4, operationId }
     );
     this._emitter.emit(_hwkadaptercore.UI_REQUEST.REQUEST_DEVICE_PERMISSION, {
       type: _hwkadaptercore.UI_REQUEST.REQUEST_DEVICE_PERMISSION,
-      payload: { transportType, connectId, deviceId }
+      payload: { transportType, connectId, deviceId, operationId }
     });
-    const { granted } = await waitPromise;
+    const { granted, reason } = await waitPromise;
     if (!granted) {
       throw Object.assign(new Error("Device permission denied"), {
-        code: _hwkadaptercore.HardwareErrorCode.DevicePermissionDenied
+        code: _hwkadaptercore.HardwareErrorCode.DevicePermissionDenied,
+        ...reason ? { params: { permissionDeniedReason: reason } } : {}
       });
     }
   }
 };
 // Keys are matched after normalizeLogKey, so snake_case/camelCase both hit.
 _TrezorAdapter._sensitiveLogKeys = /* @__PURE__ */ new Set([
+  "extra",
+  "knownconnections",
   "credential",
   "credentials",
   "entropy",
@@ -2012,7 +2945,7 @@ async function fetchDefinitionHex(url, fetchImpl) {
       }
       return arrayBufferToHex(await response.arrayBuffer());
     });
-  } catch (e5) {
+  } catch (e7) {
     return void 0;
   }
 }
@@ -2041,7 +2974,7 @@ async function fetchSolanaTokenDefinition({
       }
       return Buffer.from(await response.arrayBuffer()).toString("hex");
     });
-  } catch (e6) {
+  } catch (e8) {
     return void 0;
   }
 }