@interopio/desktop 6.10.1 → 6.11.0

package/dist/desktop.browser.js

@@ -2944,7 +2944,7 @@
       }
   };
 
-  var version$1 = "6.5.2-fmr-beta";
+  var version$1 = "6.5.2";
 
   function prepareConfig$1 (configuration, ext, glue42gd) {
       let nodeStartingContext;
@@ -5664,10 +5664,7 @@
           this._contextIdToName = {};
           delete this._protocolVersion;
           this._contextsTempCache = Object.keys(this._contextNameToData).reduce((cacheSoFar, ctxName) => {
-              const contextData = this._contextNameToData[ctxName];
-              if (contextData.isAnnounced && (contextData.activityId || contextData.sentExplicitSubscription)) {
-                  cacheSoFar[ctxName] = this._contextNameToData[ctxName].context;
-              }
+              cacheSoFar[ctxName] = this._contextNameToData[ctxName].context;
               return cacheSoFar;
           }, {});
           this._contextNameToData = {};
@@ -11596,6 +11593,164 @@
       }
   }
 
+  const INTEROP_METHOD_RESPONSE_TIMEOUT_MS = 90000;
+  const INTEROP_METHOD_WAIT_TIMEOUT_MS = 90000;
+
+  // This alphabet uses `A-Za-z0-9_-` symbols.
+  // The order of characters is optimized for better gzip and brotli compression.
+  // References to the same file (works both for gzip and brotli):
+  // `'use`, `andom`, and `rict'`
+  // References to the brotli default dictionary:
+  // `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`
+  let urlAlphabet =
+    'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+
+  let nanoid = (size = 21) => {
+    let id = '';
+    // A compact alternative for `for (var i = 0; i < step; i++)`.
+    let i = size | 0;
+    while (i--) {
+      // `| 0` is more compact and faster than `Math.floor()`.
+      id += urlAlphabet[(Math.random() * 64) | 0];
+    }
+    return id
+  };
+
+  class Utils {
+      static getGDMajorVersion() {
+          if (typeof window === "undefined") {
+              return -1;
+          }
+          if (!window.glueDesktop) {
+              return -1;
+          }
+          if (!window.glueDesktop.version) {
+              return -1;
+          }
+          const parsed = window.glueDesktop.version.split(".");
+          const major = Number(parsed[0]);
+          return isNaN(major) ? -1 : major;
+      }
+      static typedError(error) {
+          let err;
+          if (error instanceof Error) {
+              err = error;
+          }
+          else if (typeof error === "string") {
+              err = new Error(error);
+          }
+          else if ("message" in error && typeof error.message === "string" && error.message.length > 0) {
+              err = new Error(error.message);
+          }
+          else if ("returned" in error
+              && typeof error.returned === "object"
+              && "errorMsg" in error.returned
+              && typeof error.returned.errorMsg === "string"
+              && error.returned.errorMsg.length > 0) {
+              err = new Error(error.returned.errorMsg);
+          }
+          else {
+              err = new Error("Unknown error");
+          }
+          return err;
+      }
+      static async callbackifyPromise(action, successCallback, errorCallback) {
+          const success = (result) => {
+              if (typeof successCallback === "function") {
+                  successCallback(result);
+              }
+              return Promise.resolve(result);
+          };
+          const fail = (error) => {
+              const err = Utils.typedError(error);
+              if (typeof errorCallback === "function") {
+                  errorCallback(err.message);
+                  return;
+              }
+              return Promise.reject(err);
+          };
+          try {
+              const result = await action();
+              return success(result);
+          }
+          catch (error) {
+              return fail(error);
+          }
+      }
+      static getMonitor(bounds, displays) {
+          const monitorsSortedByOverlap = displays.map((m) => {
+              const { left, top, workingAreaWidth: width, workingAreaHeight: height } = m;
+              const overlap = this.calculateTotalOverlap({ left, top, width, height }, bounds);
+              return {
+                  monitor: m,
+                  totalOverlap: overlap
+              };
+          }).sort((a, b) => b.totalOverlap - a.totalOverlap);
+          return monitorsSortedByOverlap[0].monitor;
+      }
+      static getDisplayCenterOfScreen(a, currentDisplay, primaryDisplay) {
+          const physicalWidth = a.width / currentDisplay.scaleFactor;
+          const physicalHeight = a.height / currentDisplay.scaleFactor;
+          const physicalDisplayLeft = currentDisplay.workArea.left / primaryDisplay.scaleFactor;
+          const physicalDisplayTop = currentDisplay.workArea.top / primaryDisplay.scaleFactor;
+          const physicalDisplayWidth = currentDisplay.workArea.width / currentDisplay.scaleFactor;
+          const physicalDisplayHeight = currentDisplay.workArea.height / currentDisplay.scaleFactor;
+          const physicalHOffset = Math.max((physicalDisplayWidth - physicalWidth) / 2, 0);
+          const physicalVOffset = Math.max((physicalDisplayHeight - physicalHeight) / 2, 0);
+          const centeredPhysicalLeft = Math.floor(physicalDisplayLeft + physicalHOffset);
+          const centeredPhysicalTop = Math.floor(physicalDisplayTop + physicalVOffset);
+          const left = centeredPhysicalLeft * primaryDisplay.scaleFactor;
+          const top = centeredPhysicalTop * primaryDisplay.scaleFactor;
+          return {
+              left,
+              top,
+              width: a.width,
+              height: a.height
+          };
+      }
+      static isNode() {
+          if (typeof Utils._isNode !== "undefined") {
+              return Utils._isNode;
+          }
+          if (typeof window !== "undefined") {
+              Utils._isNode = false;
+              return false;
+          }
+          try {
+              Utils._isNode = Object.prototype.toString.call(global.process) === "[object process]";
+          }
+          catch (e) {
+              Utils._isNode = false;
+          }
+          return Utils._isNode;
+      }
+      static generateId() {
+          return nanoid(10);
+      }
+      static isPromise(value) {
+          return Boolean(value && typeof value.then === 'function');
+      }
+      static isAsyncFunction(value) {
+          return value && {}.toString.call(value) === '[object AsyncFunction]';
+      }
+      static isNullOrUndefined(value) {
+          return value === null || value === undefined;
+      }
+      static calculateTotalOverlap(r1, r2) {
+          const r1x = r1.left;
+          const r1y = r1.top;
+          const r1xMax = r1x + r1.width;
+          const r1yMax = r1y + r1.height;
+          const r2x = r2.left;
+          const r2y = r2.top;
+          const r2xMax = r2x + r2.width;
+          const r2yMax = r2y + r2.height;
+          const xOverlap = Math.max(0, Math.min(r1xMax, r2xMax) - Math.max(r1x, r2x));
+          const yOverlap = Math.max(0, Math.min(r1yMax, r2yMax) - Math.max(r1y, r2y));
+          return xOverlap * yOverlap;
+      }
+  }
+
   class ApplicationImpl {
       constructor(_appManager, _name, _agm, _logger, _configuration) {
           this._appManager = _appManager;
@@ -11725,7 +11880,10 @@
           return "flat";
       }
       async getConfiguration() {
-          const result = await this._agm.invoke(GetApplicationsMethodName, { v2: { apps: [this._name] } });
+          const result = await this._agm.invoke(GetApplicationsMethodName, { v2: { apps: [this._name] } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           const config = result.returned.applications[0];
           return config;
       }
@@ -11739,7 +11897,7 @@
       }
       start(context, options) {
           return new Promise(async (resolve, reject) => {
-              var _a, _b, _c, _d, _e;
+              var _a, _b, _c, _d;
               if (isUndefinedOrNull(context)) {
                   context = {};
               }
@@ -11783,7 +11941,13 @@
                       resolve(i);
                   };
                   if (waitForAGMInstance) {
-                      unsub = this._appManager.onInstanceAgmServerReady(waitFunc);
+                      const instance = this._appManager.instances().find((i) => i.id === id);
+                      if (instance) {
+                          unsub = instance.onAgmReady(waitFunc);
+                      }
+                      else {
+                          unsub = this._appManager.onInstanceAgmServerReady(waitFunc);
+                      }
                   }
                   else {
                       unsub = this._appManager.onInstanceStarted(waitFunc);
@@ -11796,7 +11960,8 @@
                       Context: context,
                       Options: options
                   }, "best", {
-                      methodResponseTimeoutMs: startTimeout
+                      methodResponseTimeoutMs: startTimeout,
+                      waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
                   });
                   const acsResult = result.returned;
                   if (typeof acsResult.timeout !== "undefined" && typeof options.timeout === "undefined") {
@@ -11827,7 +11992,8 @@
                   }
               }
               catch (error) {
-                  reject((_e = error.message) !== null && _e !== void 0 ? _e : error);
+                  const err = Utils.typedError(error);
+                  reject(err);
               }
           });
       }
@@ -12029,6 +12195,9 @@
               this._agm.invoke(StopApplicationMethodName, {
                   Name: this._appName,
                   Id: this._id
+              }, "best", {
+                  waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                  methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
               })
                   .then(() => {
                   if (this._appManager.mode === "startOnly") {
@@ -12043,7 +12212,10 @@
           });
       }
       activate() {
-          return this._agm.invoke(ActivateApplicationMethodName, { Name: this._appName, Id: this._id });
+          return this._agm.invoke(ActivateApplicationMethodName, { Name: this._appName, Id: this._id }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       done() {
           this._registry.clear();
@@ -12054,7 +12226,10 @@
           return Promise.resolve(this.context);
       }
       async startedBy() {
-          const result = await this._agm.invoke(ACSExecute, { command: "getStartedBy", Name: this._appName, Id: this._id });
+          const result = await this._agm.invoke(ACSExecute, { command: "getStartedBy", Name: this._appName, Id: this._id }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           return result.returned;
       }
   }
@@ -12082,7 +12257,10 @@
                       apps
                   };
               }
-              const result = await this._agm.invoke(GetApplicationsMethodName, args);
+              const result = await this._agm.invoke(GetApplicationsMethodName, args, "best", {
+                  waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                  methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+              });
               return result.returned.applications;
           };
           this.application = (name) => {
@@ -12399,7 +12577,10 @@
               args = args || {};
               return new Promise((resolve, reject) => {
                   const errHandler = (error) => reject(error);
-                  this._agm.invoke(method, args)
+                  this._agm.invoke(method, args, "best", {
+                      waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                      methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+                  })
                       .then((result) => {
                       if (!transformFunction) {
                           transformFunction = (d) => d.returned;
@@ -12428,7 +12609,10 @@
 
   function snapshot(interop, appManager) {
       return new Promise((resolve, reject) => {
-          interop.invoke(GetApplicationsMethodName, { skipIcon: true })
+          interop.invoke(GetApplicationsMethodName, { skipIcon: true }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          })
               .then((response) => {
               var _a;
               const data = response.returned;
@@ -12443,7 +12627,7 @@
               objectValues(applications).map((item) => appManager.handleAppAdded(item));
               resolve(configuration);
           })
-              .catch((err) => reject(`Error getting application snapshot: ${err.message}`));
+              .catch((err) => reject(new Error(`Error getting application snapshot: ${err.message}`)));
       });
   }
 
@@ -12553,10 +12737,10 @@
       }
       import(apps, mode) {
           if (!apps || !Array.isArray(apps)) {
-              return Promise.reject("invalid apps argument - should be an array of application definitions");
+              return Promise.reject(new Error("invalid apps argument - should be an array of application definitions"));
           }
           if (mode && mode !== "replace" && mode !== "merge") {
-              return Promise.reject("invalid mode argument - should be 'replace' or 'merge'");
+              return Promise.reject(new Error("invalid mode argument - should be 'replace' or 'merge'"));
           }
           mode = mode !== null && mode !== void 0 ? mode : "replace";
           const command = {
@@ -12566,16 +12750,22 @@
                   mode
               }
           };
-          return this.interop.invoke(InMemoryStoreCommandMethodName, command)
+          return this.interop.invoke(InMemoryStoreCommandMethodName, command, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          })
               .then((r) => r.returned);
       }
       export() {
-          return this.interop.invoke(InMemoryStoreCommandMethodName, { command: "export" })
+          return this.interop.invoke(InMemoryStoreCommandMethodName, { command: "export" }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          })
               .then((r) => r.returned.apps);
       }
       remove(app) {
           if (!app || typeof app !== "string") {
-              return Promise.reject("invalid app name, should be a string value");
+              return Promise.reject(new Error("invalid app name, should be a string value"));
           }
           const command = {
               command: "remove",
@@ -12583,13 +12773,19 @@
                   apps: [app]
               }
           };
-          return this.interop.invoke(InMemoryStoreCommandMethodName, command).then((r) => r.returned);
+          return this.interop.invoke(InMemoryStoreCommandMethodName, command, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          }).then((r) => r.returned);
       }
       clear() {
           const command = {
               command: "clear"
           };
-          return this.interop.invoke(InMemoryStoreCommandMethodName, command).then((r) => r.returned);
+          return this.interop.invoke(InMemoryStoreCommandMethodName, command, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          }).then((r) => r.returned);
       }
       createAppDef(name, url) {
           if (!url) {
@@ -12675,157 +12871,6 @@
       return api;
   };
 
-  // This alphabet uses `A-Za-z0-9_-` symbols.
-  // The order of characters is optimized for better gzip and brotli compression.
-  // References to the same file (works both for gzip and brotli):
-  // `'use`, `andom`, and `rict'`
-  // References to the brotli default dictionary:
-  // `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`
-  let urlAlphabet =
-    'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
-
-  let nanoid = (size = 21) => {
-    let id = '';
-    // A compact alternative for `for (var i = 0; i < step; i++)`.
-    let i = size | 0;
-    while (i--) {
-      // `| 0` is more compact and faster than `Math.floor()`.
-      id += urlAlphabet[(Math.random() * 64) | 0];
-    }
-    return id
-  };
-
-  class Utils {
-      static getGDMajorVersion() {
-          if (typeof window === "undefined") {
-              return -1;
-          }
-          if (!window.glueDesktop) {
-              return -1;
-          }
-          if (!window.glueDesktop.version) {
-              return -1;
-          }
-          const parsed = window.glueDesktop.version.split(".");
-          const major = Number(parsed[0]);
-          return isNaN(major) ? -1 : major;
-      }
-      static async callbackifyPromise(action, successCallback, errorCallback) {
-          const success = (result) => {
-              if (typeof successCallback === "function") {
-                  successCallback(result);
-              }
-              return Promise.resolve(result);
-          };
-          const fail = (error) => {
-              let err;
-              if (error instanceof Error) {
-                  err = error;
-              }
-              else if (typeof error === "string") {
-                  err = new Error(error);
-              }
-              else if ("message" in error && typeof error.message === "string" && error.message.length > 0) {
-                  err = new Error(error.message);
-              }
-              else if ("returned" in error
-                  && typeof error.returned === "object"
-                  && "errorMsg" in error.returned
-                  && typeof error.returned.errorMsg === "string"
-                  && error.returned.errorMsg.length > 0) {
-                  err = new Error(error.returned.errorMsg);
-              }
-              else {
-                  err = new Error("Unknown error");
-              }
-              if (typeof errorCallback === "function") {
-                  errorCallback(err.message);
-                  return;
-              }
-              return Promise.reject(err);
-          };
-          try {
-              const result = await action();
-              return success(result);
-          }
-          catch (error) {
-              return fail(error);
-          }
-      }
-      static getMonitor(bounds, displays) {
-          const monitorsSortedByOverlap = displays.map((m) => {
-              const { left, top, workingAreaWidth: width, workingAreaHeight: height } = m;
-              const overlap = this.calculateTotalOverlap({ left, top, width, height }, bounds);
-              return {
-                  monitor: m,
-                  totalOverlap: overlap
-              };
-          }).sort((a, b) => b.totalOverlap - a.totalOverlap);
-          return monitorsSortedByOverlap[0].monitor;
-      }
-      static getDisplayCenterOfScreen(a, currentDisplay, primaryDisplay) {
-          const physicalWidth = a.width / currentDisplay.scaleFactor;
-          const physicalHeight = a.height / currentDisplay.scaleFactor;
-          const physicalDisplayLeft = currentDisplay.workArea.left / primaryDisplay.scaleFactor;
-          const physicalDisplayTop = currentDisplay.workArea.top / primaryDisplay.scaleFactor;
-          const physicalDisplayWidth = currentDisplay.workArea.width / currentDisplay.scaleFactor;
-          const physicalDisplayHeight = currentDisplay.workArea.height / currentDisplay.scaleFactor;
-          const physicalHOffset = Math.max((physicalDisplayWidth - physicalWidth) / 2, 0);
-          const physicalVOffset = Math.max((physicalDisplayHeight - physicalHeight) / 2, 0);
-          const centeredPhysicalLeft = Math.floor(physicalDisplayLeft + physicalHOffset);
-          const centeredPhysicalTop = Math.floor(physicalDisplayTop + physicalVOffset);
-          const left = centeredPhysicalLeft * primaryDisplay.scaleFactor;
-          const top = centeredPhysicalTop * primaryDisplay.scaleFactor;
-          return {
-              left,
-              top,
-              width: a.width,
-              height: a.height
-          };
-      }
-      static isNode() {
-          if (typeof Utils._isNode !== "undefined") {
-              return Utils._isNode;
-          }
-          if (typeof window !== "undefined") {
-              Utils._isNode = false;
-              return false;
-          }
-          try {
-              Utils._isNode = Object.prototype.toString.call(global.process) === "[object process]";
-          }
-          catch (e) {
-              Utils._isNode = false;
-          }
-          return Utils._isNode;
-      }
-      static generateId() {
-          return nanoid(10);
-      }
-      static isPromise(value) {
-          return Boolean(value && typeof value.then === 'function');
-      }
-      static isAsyncFunction(value) {
-          return value && {}.toString.call(value) === '[object AsyncFunction]';
-      }
-      static isNullOrUndefined(value) {
-          return value === null || value === undefined;
-      }
-      static calculateTotalOverlap(r1, r2) {
-          const r1x = r1.left;
-          const r1y = r1.top;
-          const r1xMax = r1x + r1.width;
-          const r1yMax = r1y + r1.height;
-          const r2x = r2.left;
-          const r2y = r2.top;
-          const r2xMax = r2x + r2.width;
-          const r2yMax = r2y + r2.height;
-          const xOverlap = Math.max(0, Math.min(r1xMax, r2xMax) - Math.max(r1x, r2x));
-          const yOverlap = Math.max(0, Math.min(r1yMax, r2yMax) - Math.max(r1y, r2y));
-          return xOverlap * yOverlap;
-      }
-  }
-
   const T42JumpListAction = "T42.JumpList.Action";
   class JumpListManager {
       constructor() {
@@ -14707,7 +14752,10 @@
               finishedResolve = resolve;
           });
           try {
-              const result = await this.agm.invoke("T42.Wnd.Create", options, this.agmTarget);
+              const result = await this.agm.invoke("T42.Wnd.Create", options, this.agmTarget, {
+                  waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                  methodResponseTimeoutMs: INTEROP_METHOD_RESPONSE_TIMEOUT_MS
+              });
               if (result.returned === undefined) {
                   throw new Error("failed to execute T42.Wnd.Create - unknown reason");
               }
@@ -15297,7 +15345,7 @@
                       const data = args.data;
                       if ("status" in data) {
                           if (data.status === "failed") {
-                              rej(data.message);
+                              rej(new Error(data.message));
                           }
                           else if (data.status === "successful") {
                               res(data.result);
@@ -15503,7 +15551,10 @@
               });
           });
           const action = new Promise((resolve, reject) => {
-              this.agm.invoke("T42.Wnd.Execute", params, this.agmTarget)
+              this.agm.invoke("T42.Wnd.Execute", params, this.agmTarget, {
+                  waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                  methodResponseTimeoutMs: INTEROP_METHOD_RESPONSE_TIMEOUT_MS
+              })
                   .then((i) => {
                   if (i.returned && i.returned.errorMsg) {
                       reject(i);
@@ -15557,17 +15608,30 @@
               });
               const execute = new Promise((resolve, reject) => {
                   options.token = token;
+                  if (!invocationOptions) {
+                      invocationOptions = {
+                          waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                          methodResponseTimeoutMs: INTEROP_METHOD_RESPONSE_TIMEOUT_MS
+                      };
+                  }
+                  else if (!invocationOptions.methodResponseTimeoutMs) {
+                      invocationOptions.methodResponseTimeoutMs = INTEROP_METHOD_RESPONSE_TIMEOUT_MS;
+                  }
+                  else if (!invocationOptions.waitTimeoutMs) {
+                      invocationOptions.waitTimeoutMs = INTEROP_METHOD_WAIT_TIMEOUT_MS;
+                  }
                   this.agm.invoke(methodName, options, this.agmTarget, invocationOptions)
                       .then((i) => {
                       if (i.returned && i.returned.errorMsg) {
-                          reject(i);
+                          reject(new Error(i.returned.errorMsg));
                       }
                       else {
                           resolve(i.returned);
                       }
                   })
-                      .catch((i) => {
-                      reject(i);
+                      .catch((e) => {
+                      const error = Utils.typedError(e);
+                      reject(error);
                   });
               });
               const result = await Promise.all([execute, event]);
@@ -15720,13 +15784,6 @@
       myGroup() {
           return this._groupId;
       }
-      execute(command, windowId, options) {
-          return this._agm.invoke("T42.Wnd.Execute", {
-              command,
-              options,
-              windowId,
-          });
-      }
       onCompositionChanged(callback) {
           return this._registry.add("composition-changed", callback);
       }
@@ -17404,7 +17461,7 @@
       updateAppContextInCurrent(context) {
           return new Promise((resolve, reject) => {
               if (context && typeof context !== "object") {
-                  return reject(new Error("context must be an object"));
+                  return reject(new Error("Context must be an object"));
               }
               context = context !== null && context !== void 0 ? context : {};
               const request = {
@@ -17416,7 +17473,7 @@
       updateDefaultContext(context) {
           return new Promise((resolve, reject) => {
               if (context && typeof context !== "object") {
-                  return reject(new Error("context must be an object"));
+                  return reject(new Error("Context must be an object"));
               }
               context = context !== null && context !== void 0 ? context : {};
               const request = {
@@ -17503,6 +17560,13 @@
               .catch((err) => reject(err));
       }
       async invokeMethodCore(methodName, args, target, options) {
+          options = options !== null && options !== void 0 ? options : {};
+          if (typeof options.methodResponseTimeoutMs === "undefined") {
+              options.methodResponseTimeoutMs = INTEROP_METHOD_WAIT_TIMEOUT_MS;
+          }
+          if (typeof options.waitTimeoutMs === "undefined") {
+              options.waitTimeoutMs = INTEROP_METHOD_WAIT_TIMEOUT_MS;
+          }
           if (this.isCommandMethodPresent()) {
               return await this.config.agm.invoke(LayoutsCommandMethod, { command: methodName, data: args }, target, options);
           }
@@ -17683,16 +17747,6 @@
       }
   }
 
-  function streamNull () {
-      return {
-          ready: Promise.resolve(undefined),
-          subscribe: () => { },
-          onEvent: (callback) => () => { },
-          waitFor: (token, timeout) => Promise.resolve(undefined),
-          gotSnapshot: Promise.resolve(undefined),
-      };
-  }
-
   function LayoutsFactory (config) {
       if (!config.agm) {
           throw Error("config.agm is required");
@@ -17707,9 +17761,6 @@
       if (config.mode === "full" || "fullWaitSnapshot") {
           acsStream = new ACSStream(config.agm, callbacks);
       }
-      else {
-          acsStream = streamNull();
-      }
       return new LayoutsAPIImpl(config, acsStream, callbacks, logger);
   }
 
@@ -17746,7 +17797,10 @@
               return point;
           };
           this.callGD = async (command, options) => {
-              const invocationResult = await this._agm.invoke(T42DisplayCommand, { options: { ...options }, command });
+              const invocationResult = await this._agm.invoke(T42DisplayCommand, { options: { ...options }, command }, "best", {
+                  waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                  methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+              });
               return invocationResult.returned.data;
           };
           this.decorateDisplay = (original) => {
@@ -17941,61 +17995,42 @@
           }
           throw new Error(`unknown command ${command}`);
       });
-      const result = await interop.invoke(T42_ANNOUNCE_METHOD_NAME, { swId: windowId, instance: interop.instance.instance });
+      const result = await interop.invoke(T42_ANNOUNCE_METHOD_NAME, { swId: windowId, instance: interop.instance.instance }, "best", {
+          waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+          methodResponseTimeoutMs: INTEROP_METHOD_RESPONSE_TIMEOUT_MS
+      });
       if ((_a = result.returned) === null || _a === void 0 ? void 0 : _a.restrictions) {
           channels.handleRestrictionsChanged((_b = result.returned) === null || _b === void 0 ? void 0 : _b.restrictions, windowId);
       }
   }
   async function sendLeaveChannel(channel, winId) {
-      await interop.invoke(T42_ANNOUNCE_METHOD_NAME, {
-          swId: winId !== null && winId !== void 0 ? winId : windowId,
-          command: "leaveChannel",
-          data: { channel }
-      });
+      await invoke("leaveChannel", { channel }, winId !== null && winId !== void 0 ? winId : windowId);
   }
   async function sendSwitchChannelUI(channel, winId) {
-      await interop.invoke(T42_ANNOUNCE_METHOD_NAME, {
-          swId: winId !== null && winId !== void 0 ? winId : windowId,
-          command: "switchChannel",
-          data: { newChannel: channel }
-      });
+      await invoke("switchChannel", { newChannel: channel }, winId !== null && winId !== void 0 ? winId : windowId);
   }
   async function setRestrictions(restrictions) {
       var _a;
-      await interop.invoke(T42_ANNOUNCE_METHOD_NAME, {
-          swId: (_a = restrictions.windowId) !== null && _a !== void 0 ? _a : windowId,
-          command: "restrict",
-          data: restrictions
-      });
-      return;
+      await invoke("restrict", restrictions, (_a = restrictions.windowId) !== null && _a !== void 0 ? _a : windowId);
   }
   async function getRestrictionsByWindow(id) {
       try {
-          const result = await interop.invoke(T42_ANNOUNCE_METHOD_NAME, {
-              swId: id !== null && id !== void 0 ? id : windowId,
-              command: "getRestrictions"
-          });
+          const result = await invoke("getRestrictions", {}, id !== null && id !== void 0 ? id : windowId);
           return result.returned;
       }
       catch (e) {
-          return;
       }
   }
   async function setRestrictionsForAllChannels(restrictions) {
       var _a;
-      await interop.invoke(T42_ANNOUNCE_METHOD_NAME, {
-          swId: (_a = restrictions.windowId) !== null && _a !== void 0 ? _a : windowId,
-          command: "restrictAll",
-          data: restrictions
-      });
-      return;
+      await invoke("restrictAll", restrictions, (_a = restrictions.windowId) !== null && _a !== void 0 ? _a : windowId);
   }
   async function getWindowsWithChannels(filter) {
-      const result = await interop.invoke(T42_ANNOUNCE_METHOD_NAME, { command: "getChannelsInfo", data: { filter } });
+      const result = await invoke("getChannelsInfo", { filter });
       return result.returned;
   }
   async function addOrRemoveChannel(command, id, color, label) {
-      await interop.invoke(T42_ANNOUNCE_METHOD_NAME, { command, data: { id, color, label } });
+      await invoke(command, { id, color, label });
   }
   async function getChannelsMode(config, i) {
       if (typeof config.operationMode !== "boolean" && typeof config.operationMode === "string") {
@@ -18003,7 +18038,10 @@
           return config.operationMode;
       }
       try {
-          const result = await i.invoke(T42_ANNOUNCE_METHOD_NAME, { command: "getChannelsMode" });
+          const result = await i.invoke(T42_ANNOUNCE_METHOD_NAME, { command: "getChannelsMode" }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_RESPONSE_TIMEOUT_MS,
+          });
           if (result.returned.mode === "single") {
               return "single";
           }
@@ -18018,6 +18056,16 @@
           return "single";
       }
   }
+  function invoke(command, data, swId) {
+      const args = { command, data };
+      if (swId) {
+          args.swId = swId;
+      }
+      return interop.invoke(T42_ANNOUNCE_METHOD_NAME, args, "best", {
+          waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+          methodResponseTimeoutMs: INTEROP_METHOD_RESPONSE_TIMEOUT_MS,
+      });
+  }
   function validateMode(mode) {
       if (mode !== "single" && mode !== "multi") {
           throw new Error(`Invalid mode: ${mode}`);
@@ -18987,7 +19035,10 @@
               await this.registerInvokeAGMMethod();
           }
           this.registry.add(hkToLower, callback);
-          await this.agm.invoke(CommandMethod, { command: RegisterCommand, hotkey: hkToLower, description: info.description });
+          await this.agm.invoke(CommandMethod, { command: RegisterCommand, hotkey: hkToLower, description: info.description }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           this.hotkeys.set(hkToLower, info);
       }
       async unregister(hotkey) {
@@ -18998,12 +19049,18 @@
               throw new Error("hotkey parameter must be string");
           }
           const hkToLower = this.formatHotkey(hotkey);
-          await this.agm.invoke(CommandMethod, { command: UnregisterCommand, hotkey: hkToLower });
+          await this.agm.invoke(CommandMethod, { command: UnregisterCommand, hotkey: hkToLower }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           this.hotkeys.delete(hkToLower);
           this.registry.clearKey(hkToLower);
       }
       async unregisterAll() {
-          await this.agm.invoke(CommandMethod, { command: UnregisterAllCommand });
+          await this.agm.invoke(CommandMethod, { command: UnregisterAllCommand }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           this.hotkeys.clear();
           this.registry.clear();
       }
@@ -19036,7 +19093,7 @@
       };
   }
 
-  var version = "6.10.1";
+  var version = "6.11.0";
 
   var prepareConfig = (options) => {
       function getLibConfig(value, defaultMode, trueMode) {
@@ -19154,16 +19211,25 @@
           return this.onStreamEvent("on-panel-visibility-changed", callback);
       }
       toggle() {
-          return this.interop.invoke("T42.Notifications.Show");
+          return this.interop.invoke("T42.Notifications.Show", undefined, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       show() {
-          return this.interop.invoke("T42.Notifications.Show", { show: true });
+          return this.interop.invoke("T42.Notifications.Show", { show: true }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       hide() {
           return this.interop.invoke("T42.Notifications.Hide");
       }
       async isVisible() {
-          const interopResult = await this.interop.invoke("T42.Notifications.Execute", { command: "isPanelVisible" });
+          const interopResult = await this.interop.invoke("T42.Notifications.Execute", { command: "isPanelVisible" }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           return interopResult.returned.panelVisible;
       }
       toAPI() {
@@ -19185,6 +19251,7 @@
           this.NotificationsCounterStream = "T42.Notifications.Counter";
           this.RaiseNotificationMethodName = "T42.GNS.Publish.RaiseNotification";
           this.NotificationsExecuteMethod = "T42.Notifications.Execute";
+          this.NotificationFilterMethodName = "T42.Notifications.Filter";
           this.methodsRegistered = false;
           this.NOTIFICATIONS_CONFIGURE_METHOD_NAME = "T42.Notifications.Configure";
           this.methodNameRoot = "T42.Notifications.Handler-" + Utils.generateId();
@@ -19212,7 +19279,10 @@
           const g42notification = new Glue42Notification(options);
           this.notifications[notification.id] = g42notification;
           try {
-              const invocationResult = await this.interop.invoke(this.RaiseNotificationMethodName, { notification });
+              const invocationResult = await this.interop.invoke(this.RaiseNotificationMethodName, { notification }, "best", {
+                  waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                  methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+              });
               g42notification.id = (_a = invocationResult.returned) === null || _a === void 0 ? void 0 : _a.id;
           }
           catch (err) {
@@ -19224,11 +19294,17 @@
           return g42notification;
       }
       async setFilter(filter) {
-          const result = await this.interop.invoke("T42.Notifications.Filter", filter);
+          const result = await this.interop.invoke(this.NotificationFilterMethodName, filter, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           return result.returned;
       }
       async getFilter() {
-          const result = await this.interop.invoke("T42.Notifications.Filter");
+          const result = await this.interop.invoke(this.NotificationFilterMethodName, undefined, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           return result.returned;
       }
       async configure(options) {
@@ -19278,15 +19354,27 @@
           if (typeof options.closeNotificationOnClick !== "undefined" && typeof options.closeNotificationOnClick !== "boolean") {
               throw new Error("Expected type of closeNotificationOnClick - boolean.");
           }
-          const result = await this.interop.invoke(this.NOTIFICATIONS_CONFIGURE_METHOD_NAME, options);
+          const result = await this.interop.invoke(this.NOTIFICATIONS_CONFIGURE_METHOD_NAME, options, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           return result.returned;
       }
       async getConfiguration() {
-          const result = await this.interop.invoke(this.NotificationsExecuteMethod, { command: "getConfiguration" });
+          const result = await this.interop.invoke(this.NotificationsExecuteMethod, { command: "getConfiguration" }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           return result.returned;
       }
       async list() {
-          const interopResult = await this.interop.invoke(this.NotificationsExecuteMethod, { command: "list", data: { statesVersion2: true } });
+          const interopResult = await this.interop.invoke(this.NotificationsExecuteMethod, {
+              command: "list",
+              data: { statesVersion2: true }
+          }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           return interopResult.returned.notifications;
       }
       async updateData(id, data) {
@@ -19297,7 +19385,10 @@
                   stringValue: JSON.stringify(data, replacer)
               }
           };
-          const interopResult = await this.interop.invoke(this.NotificationsExecuteMethod, { command: "create-or-update-attribute", data: { id, attribute } });
+          const interopResult = await this.interop.invoke(this.NotificationsExecuteMethod, { command: "create-or-update-attribute", data: { id, attribute } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           return interopResult.returned;
       }
       onRaised(callback) {
@@ -19343,10 +19434,16 @@
           };
       }
       async clearAll() {
-          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "clearAll" });
+          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "clearAll" }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async clearOld() {
-          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "clearAllOld", data: { statesVersion2: true } });
+          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "clearAllOld", data: { statesVersion2: true } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async clear(id) {
           if (!id) {
@@ -19355,17 +19452,29 @@
           if (typeof (id) !== "string") {
               throw new Error("The 'id' argument must be a string");
           }
-          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "clear", data: { id } });
+          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "clear", data: { id } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async clearMany(notifications) {
           this.validateNotificationsArr(notifications);
-          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "clearMany", data: { notifications } });
+          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "clearMany", data: { notifications } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async click(id, action, options) {
-          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "click", data: { id, action, options } });
+          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "click", data: { id, action, options } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async snooze(id, duration) {
-          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "snooze", data: { id, duration } });
+          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "snooze", data: { id, duration } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async snoozeMany(notifications, duration) {
           if (!duration) {
@@ -19375,7 +19484,10 @@
               throw new Error("The 'duration' argument must be a valid number");
           }
           this.validateNotificationsArr(notifications);
-          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "snoozeMany", data: { notifications, duration } });
+          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "snoozeMany", data: { notifications, duration } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async setState(id, state) {
           if (!id) {
@@ -19388,7 +19500,10 @@
               throw new Error("The 'state' argument cannot be null or undefined");
           }
           this.validateState(state);
-          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "updateState", data: { id, state } });
+          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "updateState", data: { id, state } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async setStates(notifications, state) {
           if (!state) {
@@ -19398,7 +19513,10 @@
               throw new Error("The 'state' argument must be a valid string");
           }
           this.validateNotificationsArr(notifications);
-          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "updateStates", data: { notifications, state } });
+          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "updateStates", data: { notifications, state } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       toAPI() {
           return {
@@ -19434,7 +19552,10 @@
               throw new Error("Notifications argument must be a valid array with notification options");
           }
           const notificationsToImport = await Promise.all(notifications.map((notificationOptions) => this.createNotification(notificationOptions, true)));
-          const invocationResult = await this.interop.invoke(this.NotificationsExecuteMethod, { command: "importNotifications", data: { notificationSettings: notificationsToImport } });
+          const invocationResult = await this.interop.invoke(this.NotificationsExecuteMethod, { command: "importNotifications", data: { notificationSettings: notificationsToImport } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           return invocationResult.returned.notifications;
       }
       async createNotification(options, imported) {
@@ -21402,7 +21523,10 @@
           await Promise.all(this.unregisterIntentPromises);
           let apps;
           try {
-              const result = await this.interop.invoke("T42.ACS.GetApplications", { withIntentsInfo: true });
+              const result = await this.interop.invoke("T42.ACS.GetApplications", { withIntentsInfo: true }, "best", {
+                  waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                  methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+              });
               apps = result.returned.applications;
           }
           catch (e) {
@@ -21441,7 +21565,10 @@
           let windowsInfos;
           if (isT42WndGetInfoMethodRegistered) {
               try {
-                  const result = await this.interop.invoke(T42WndGetInfo, { ids: serverWindowIds });
+                  const result = await this.interop.invoke(T42WndGetInfo, { ids: serverWindowIds }, "best", {
+                      waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                      methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+                  });
                   windowsInfos = result.returned.windows;
               }
               catch (e) {
@@ -21892,7 +22019,10 @@
           this.intentsResolverResponsePromises[instanceId] = { intent, resolve, reject, promise, methodName: responseMethodName };
       }
       async invokeStartApp(application, context, options) {
-          const result = await this.interop.invoke("T42.ACS.StartApplication", { Name: application, options: { ...options, startedByIntentAPI: true } });
+          const result = await this.interop.invoke("T42.ACS.StartApplication", { Name: application, options: { ...options, startedByIntentAPI: true } }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           return result.returned.Id;
       }
       subscribeOnInstanceStopped(instance, method) {
@@ -21978,10 +22108,10 @@
               return handlers.length > 1;
           }
           if (request.target === "reuse") {
-              return handlers.filter((handler) => handler.type === "instance" && handler.instanceId).length > 1 || intent.handlers.filter((handler) => handler.type === "app").length > 1;
+              return handlers.filter(handler => handler.type === "instance" && handler.instanceId).length > 1 || intent.handlers.filter(handler => handler.type === "app").length > 1;
           }
           if (request.target === "startNew") {
-              return handlers.filter((handler) => handler.type === "app").length > 1;
+              return handlers.filter(handler => handler.type === "app").length > 1;
           }
           if (request.target.instance) {
               return false;
@@ -22223,13 +22353,19 @@
           this.interopMethodRegistered = false;
       }
       async get(app) {
-          const data = (await this.interop.invoke("T42.Prefs.Get", { app: app !== null && app !== void 0 ? app : this.appName }));
+          const data = (await this.interop.invoke(Prefs.T42GetPrefsMethodName, { app: app !== null && app !== void 0 ? app : this.appName }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          }));
           return data.returned;
       }
       async set(data, options) {
           var _a;
           this.verifyDataObject(data);
-          await this.interop.invoke("T42.Prefs.Set", { app: (_a = options === null || options === void 0 ? void 0 : options.app) !== null && _a !== void 0 ? _a : this.appName, data, merge: false });
+          await this.interop.invoke(Prefs.T42SetPrefsMethodName, { app: (_a = options === null || options === void 0 ? void 0 : options.app) !== null && _a !== void 0 ? _a : this.appName, data, merge: false }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async setFor(app, data) {
           this.verifyApp(app);
@@ -22239,7 +22375,10 @@
       async update(data, options) {
           var _a;
           this.verifyDataObject(data);
-          await this.interop.invoke("T42.Prefs.Set", { app: (_a = options === null || options === void 0 ? void 0 : options.app) !== null && _a !== void 0 ? _a : this.appName, data, merge: true });
+          await this.interop.invoke(Prefs.T42SetPrefsMethodName, { app: (_a = options === null || options === void 0 ? void 0 : options.app) !== null && _a !== void 0 ? _a : this.appName, data, merge: true }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async updateFor(app, data) {
           this.verifyApp(app);
@@ -22247,18 +22386,30 @@
           return this.update(data, { app });
       }
       async clear(app) {
-          await this.interop.invoke("T42.Prefs.Set", { app: app !== null && app !== void 0 ? app : this.appName, clear: true });
+          await this.interop.invoke(Prefs.T42SetPrefsMethodName, { app: app !== null && app !== void 0 ? app : this.appName, clear: true }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async clearFor(app) {
           this.verifyApp(app);
-          await this.interop.invoke("T42.Prefs.Set", { app, clear: true });
+          await this.interop.invoke(Prefs.T42SetPrefsMethodName, { app, clear: true }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       async getAll() {
-          const data = (await this.interop.invoke("T42.Prefs.Get"));
+          const data = (await this.interop.invoke(Prefs.T42GetPrefsMethodName, undefined, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          }));
           return data.returned;
       }
       async clearAll() {
-          await this.interop.invoke("T42.Prefs.Set", { clear: true });
+          await this.interop.invoke(Prefs.T42SetPrefsMethodName, { clear: true }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
       }
       subscribe(callback) {
           this.verifyCallback(callback);
@@ -22270,7 +22421,10 @@
           const unsubscribeFn = this.registry.add(app, callback);
           this.registerInteropIfNeeded()
               .then(() => {
-              this.interop.invoke("T42.Prefs.Get", { app, subscribe: true });
+              this.interop.invoke(Prefs.T42GetPrefsMethodName, { app, subscribe: true }, "best", {
+                  waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                  methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+              });
           });
           return () => {
               unsubscribeFn();
@@ -22281,7 +22435,7 @@
               return;
           }
           this.interopMethodRegistered = true;
-          await this.interop.register("T42.Prefs.Update", (args) => {
+          await this.interop.register(Prefs.T42UpdatePrefsMethodName, (args) => {
               this.registry.execute(args.app, args);
           });
       }
@@ -22307,6 +22461,9 @@
           }
       }
   }
+  Prefs.T42UpdatePrefsMethodName = "T42.Prefs.Update";
+  Prefs.T42GetPrefsMethodName = "T42.Prefs.Get";
+  Prefs.T42SetPrefsMethodName = "T42.Prefs.Set";
 
   class Cookies {
       constructor(methodName, interop) {
@@ -22331,7 +22488,10 @@
           await this.invoke("remove-cookie", { url, name });
       }
       invoke(command, data) {
-          return this.interop.invoke(this.methodName, { command, args: data });
+          return this.interop.invoke(this.methodName, { command, args: data }, "best", {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_RESPONSE_TIMEOUT_MS,
+          });
       }
       verifyCookieObject(cookie) {
           if (!cookie) {
@@ -22479,6 +22639,9 @@
               await this.interop.invoke(this.InterceptorMethodName, {
                   command: "register",
                   interceptions
+              }, "best", {
+                  waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                  methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
               });
               await this.registerMethodIfNotRegistered();
           }
@@ -22499,6 +22662,9 @@
               await this.interop.invoke(this.InterceptorMethodName, {
                   command: "unregister",
                   interceptions
+              }, "best", {
+                  waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+                  methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
               });
               this.interceptions = this.interceptions.filter((config) => {
                   return !interceptions.some((interception) => {
@@ -22526,7 +22692,10 @@
                       operation,
                       phase
                   }]
-          }, 'best', { methodResponseTimeoutMs: 60 * 1000 });
+          }, 'best', {
+              waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
+              methodResponseTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS
+          });
           return result.returned;
       }
       static createProxyObject(apiToIntercept, domain, interception) {