@interopio/desktop 6.13.1 → 6.15.0

package/dist/desktop.browser.js

@@ -216,7 +216,10 @@
                   type: "define",
                   metrics: [rootStateMetric],
               };
-              session.send(defineRootMetricsMsg);
+              session.sendFireAndForget(defineRootMetricsMsg)
+                  .catch((err) => {
+                  config.logger.warn(`Failed to send define for root state metric: ${JSON.stringify(err)}`);
+              });
               if (reconnect) {
                   replayRepo(repo);
               }
@@ -264,7 +267,10 @@
               type: "define",
               metrics: [metric],
           };
-          session.send(createMetricsMsg);
+          session.sendFireAndForget(createMetricsMsg)
+              .catch((err) => {
+              config.logger.warn(`Failed to send define for system state metric of ${system.name}: ${JSON.stringify(err)}`);
+          });
       };
       const updateSystem = async (system, state) => {
           await joinPromise;
@@ -279,7 +285,10 @@
                       timestamp: Date.now(),
                   }],
           };
-          session.send(shadowedUpdateMetric);
+          session.sendFireAndForget(shadowedUpdateMetric)
+              .catch((err) => {
+              config.logger.warn(`Failed to send update for system state metric of ${system.name}: ${JSON.stringify(err)}`);
+          });
           const stateObj = composeMsgForRootStateMetric(system);
           const rootMetric = {
               type: "publish",
@@ -293,7 +302,10 @@
                       timestamp: Date.now(),
                   }],
           };
-          session.send(rootMetric);
+          session.sendFireAndForget(rootMetric)
+              .catch((err) => {
+              config.logger.warn(`Failed to send update for root state metric of ${system.name}: ${JSON.stringify(err)}`);
+          });
       };
       const createMetric = async (metric) => {
           const metricClone = cloneMetric(metric);
@@ -303,7 +315,10 @@
               type: "define",
               metrics: [m],
           };
-          session.send(createMetricsMsg);
+          session.sendFireAndForget(createMetricsMsg)
+              .catch((err) => {
+              config.logger.warn(`Failed to send define for metric ${metric.name}: ${JSON.stringify(err)}`);
+          });
           if (typeof metricClone.value !== "undefined") {
               updateMetricCore(metricClone);
           }
@@ -324,7 +339,10 @@
                           timestamp: Date.now(),
                       }],
               };
-              return session.sendFireAndForget(publishMetricsMsg);
+              return session.sendFireAndForget(publishMetricsMsg)
+                  .catch((err) => {
+                  config.logger.warn(`Failed to publish metric ${metric.name}: ${JSON.stringify(err)}`);
+              });
           }
           return Promise.resolve();
       };
@@ -1191,12 +1209,10 @@
           const pw = new PromiseWrapper$1();
           this.logger.debug(`initiating ws to ${this.settings.ws}...`);
           this.ws = new WebSocketConstructor(this.settings.ws ?? "");
+          let wasOpen = false;
           this.ws.onerror = (err) => {
-              let reason = "";
+              let reason;
               try {
-                  reason = JSON.stringify(err);
-              }
-              catch (error) {
                   const seen = new WeakSet();
                   const replacer = (key, value) => {
                       if (typeof value === "object" && value !== null) {
@@ -1205,23 +1221,42 @@
                           }
                           seen.add(value);
                       }
+                      if (value instanceof Error) {
+                          return {
+                              message: value.message,
+                              name: value.name,
+                              stack: value.stack
+                          };
+                      }
                       return value;
                   };
                   reason = JSON.stringify(err, replacer);
               }
+              catch {
+                  reason = err.message;
+              }
               this.logger.info(`ws error - reason: ${reason}`);
               pw.reject("error");
+              if (wasOpen) {
+                  wasOpen = false;
+                  this.notifyForSocketState("error");
+              }
               this.notifyStatusChanged(false, reason);
           };
           this.ws.onclose = (err) => {
               this.logger.info(`ws closed - code: ${err?.code} reason: ${err?.reason}`);
               pw.reject("closed");
+              if (wasOpen) {
+                  wasOpen = false;
+                  this.notifyForSocketState("closed");
+              }
               this.notifyStatusChanged(false);
           };
           this.ws.onopen = () => {
               this.startupTimer.mark("ws-opened");
               this.logger.info(`ws opened ${this.settings.identity?.application}`);
               pw.resolve();
+              wasOpen = true;
               this.notifyStatusChanged(true);
           };
           this.ws.onmessage = (message) => {
@@ -1312,11 +1347,12 @@
       }
   }
 
+  /* @ts-self-types="./index.d.ts" */
   let urlAlphabet$1 =
     'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
   let nanoid$1 = (size = 21) => {
     let id = '';
-    let i = size;
+    let i = size | 0;
     while (i--) {
       id += urlAlphabet$1[(Math.random() * 64) | 0];
     }
@@ -2054,17 +2090,31 @@
           callbacks.execute("onJoined", wasReconnect);
       }
       function handleConnectionDisconnected() {
-          _connectionOn = false;
           logger.debug("connection is down");
+          _connectionOn = false;
           isJoined = false;
           tryReconnecting = true;
+          Object.keys(requestsMap).forEach(requestId => {
+              const request = requestsMap[requestId];
+              if (request) {
+                  logger.trace(`failing pending request ${requestId} due to connection lost`);
+                  request.error({
+                      err: "Connection lost - gateway connection was disconnected"
+                  });
+              }
+          });
           callbacks.execute("onLeft", { disconnected: true });
       }
-      function handleConnectionLoggedIn() {
+      async function handleConnectionLoggedIn() {
           _connectionOn = true;
           if (tryReconnecting) {
               logger.debug("connection is now up - trying to reconnect...");
-              join(_latestOptions);
+              try {
+                  await join(_latestOptions);
+              }
+              catch {
+                  logger.trace(`failed to reconnect`);
+              }
           }
       }
       function onJoined(callback) {
@@ -2157,7 +2207,7 @@
               connection
                   .send(msg, options)
                   .catch((err) => {
-                  requestsMap[requestId].error({ err });
+                  requestsMap[requestId]?.error({ err });
               });
           });
       }
@@ -2236,6 +2286,7 @@
       initialLogin = true;
       initialLoginAttempts = 3;
       loginConfig;
+      loginRetryInProgress = false;
       constructor(settings, logger) {
           this.settings = settings;
           this.logger = logger;
@@ -2349,6 +2400,7 @@
           return this.registry.add("disconnected", callback);
       }
       async login(authRequest, reconnect) {
+          this.logger.debug(`Login initiated - reconnect: ${reconnect}, transport: ${this.transport.name()}`);
           if (!this._defaultAuth) {
               this._defaultAuth = authRequest;
           }
@@ -2357,19 +2409,18 @@
               const newAuth = this.transportSwap();
               authRequest = newAuth ?? authRequest;
           }
-          this.logger.trace(`Starting login for transport: ${this.transport.name()} and auth ${JSON.stringify(authRequest)}`);
           try {
               await this.transport.open();
-              this.logger.trace(`Transport: ${this.transport.name()} opened, logging in`);
+              this.logger.debug(`Transport: ${this.transport.name()} opened, logging in`);
               timer("connection").mark("transport-opened");
               const identity = await this.loginCore(authRequest, reconnect);
-              this.logger.trace(`Logged in with identity: ${JSON.stringify(identity)}`);
+              this.logger.debug(`Logged in with identity: ${JSON.stringify(identity)}`);
               timer("connection").mark("protocol-logged-in");
               return identity;
           }
           catch (error) {
               if (this._switchInProgress) {
-                  this.logger.trace("An error while logging in after a transport swap, preparing a default swap.");
+                  this.logger.debug("An error while logging in after a transport swap, preparing a default swap.");
                   this.prepareDefaultSwap();
               }
               throw new Error(error);
@@ -2412,6 +2463,7 @@
       setLoggedIn(value) {
           this._isLoggedIn = value;
           if (this._isLoggedIn) {
+              this.initialLogin = false;
               this.registry.execute("onLoggedIn");
           }
       }
@@ -2438,8 +2490,10 @@
       }
       handleConnectionChanged(connected) {
           if (this._connected === connected) {
+              this.logger.trace("connection state unchanged, skipping");
               return;
           }
+          this.logger.info(`connection state changed to ${connected ? "connected" : "disconnected"}`);
           this._connected = connected;
           if (connected) {
               if (this.settings?.replaySpecs?.length) {
@@ -2449,28 +2503,44 @@
               this.registry.execute("connected");
           }
           else {
-              this.handleDisconnected();
+              this.setLoggedIn(false);
+              if (this.shouldTryLogin) {
+                  this.attemptLoginWithRetry();
+              }
               this.registry.execute("disconnected");
           }
       }
-      handleDisconnected() {
-          this.setLoggedIn(false);
-          const tryToLogin = this.shouldTryLogin;
-          if (tryToLogin && this.initialLogin) {
+      async attemptLoginWithRetry() {
+          if (!this.loginConfig) {
+              throw new Error("no login info");
+          }
+          if (this.loginRetryInProgress) {
+              this.logger.debug("login attempt already in progress, ignoring request...");
+              return;
+          }
+          if (this._isLoggedIn) {
+              this.logger.debug("already logged in, ignoring request...");
+              return;
+          }
+          if (this.initialLogin) {
+              this.logger.debug(`initial login attempt failed, ${this.initialLoginAttempts} attempts remaining...`);
               if (this.initialLoginAttempts <= 0) {
+                  this.logger.info("maximum initial login attempts reached, will not try to login again");
                   return;
               }
               this.initialLoginAttempts--;
           }
-          this.logger.debug("disconnected - will try new login?" + this.shouldTryLogin);
-          if (this.shouldTryLogin) {
-              if (!this.loginConfig) {
-                  throw new Error("no login info");
-              }
-              this.login(this.loginConfig, true)
-                  .catch(() => {
-                  setTimeout(this.handleDisconnected.bind(this), this.settings.reconnectInterval || 1000);
-              });
+          try {
+              this.logger.debug(`will try a new login... ${this.loginRetryInProgress}`);
+              this.loginRetryInProgress = true;
+              await this.login(this.loginConfig, true);
+          }
+          catch (e) {
+              this.logger.error(`error trying to login: ${e?.message}`, e);
+              setTimeout(this.attemptLoginWithRetry.bind(this), this.settings.reconnectInterval ?? 1000);
+          }
+          finally {
+              this.loginRetryInProgress = false;
           }
       }
       handleTransportMessage(msg) {
@@ -2597,7 +2667,6 @@
           return message;
       }
       async loginCore(config, reconnect) {
-          this.logger.info("logging in...");
           this.loginConfig = config;
           if (!this.loginConfig) {
               this.loginConfig = { username: "", password: "" };
@@ -2612,11 +2681,13 @@
           if (config.sessionId) {
               helloMsg.request_id = config.sessionId;
           }
-          this.globalDomain = domainSession("global", this, this.logger.subLogger("global-domain"), [
-              "welcome",
-              "token",
-              "authentication-request"
-          ]);
+          if (!this.globalDomain) {
+              this.globalDomain = domainSession("global", this, this.logger.subLogger("global-domain"), [
+                  "welcome",
+                  "token",
+                  "authentication-request"
+              ]);
+          }
           const sendOptions = { skipPeerId: true };
           if (this.initialLogin) {
               sendOptions.retryInterval = this.settings.reconnectInterval;
@@ -2624,7 +2695,6 @@
           }
           try {
               const welcomeMsg = await this.tryAuthenticate(this.globalDomain, helloMsg, sendOptions, config);
-              this.initialLogin = false;
               this.logger.info("login successful with peerId " + welcomeMsg.peer_id);
               this.peerId = welcomeMsg.peer_id;
               this.resolvedIdentity = welcomeMsg.resolved_identity;
@@ -2727,7 +2797,7 @@
               clearTimeout(this.pingTimer);
           }
           const promises = this.sessions.map((session) => {
-              session.leave();
+              return session.leave();
           });
           await Promise.all(promises);
       }
@@ -2866,7 +2936,10 @@
                                   stack: error.stack ?? ""
                               };
                           }
-                          interop.invoke(Logger.InteropMethodName, args);
+                          interop.invoke(Logger.InteropMethodName, args)
+                              .catch((e) => {
+                              this.logFn.warn(`Unable to send log message to the platform: ${e.message}`, e);
+                          });
                       }
                   }
                   catch {
@@ -2900,7 +2973,12 @@
                       this.logFn.warn(toPrint);
                       break;
                   case "error":
-                      this.logFn.error(toPrint, error);
+                      if (error) {
+                          this.logFn.error(toPrint, error);
+                      }
+                      else {
+                          this.logFn.error(toPrint);
+                      }
                       break;
               }
           }
@@ -2944,7 +3022,7 @@
       }
   };
 
-  var version$1 = "6.5.2-fmr-beta";
+  var version$1 = "6.5.3-iocd-beta";
 
   function prepareConfig$1 (configuration, ext, glue42gd) {
       let nodeStartingContext;
@@ -5109,7 +5187,11 @@
               if (!this._reAnnounceKnownContexts) {
                   return this._connection.setLibReAnnounced({ name: "contexts" });
               }
-              this.reInitiateState().then(() => this._connection.setLibReAnnounced({ name: "contexts" }));
+              this.reInitiateState()
+                  .then(() => this._connection.setLibReAnnounced({ name: "contexts" }))
+                  .catch((err) => {
+                  this._logger.warn(`Error while re-announcing contexts: ${JSON.stringify(err)}`);
+              });
           });
           this.subscribeToContextCreatedMessages();
           this.subscribeToContextUpdatedMessages();
@@ -5187,7 +5269,8 @@
           }
           const contextData = this._contextNameToData[name];
           if (!contextData || !contextData.isAnnounced) {
-              return this.createContext(name, delta);
+              await this.createContext(name, delta);
+              return;
           }
           let currentContext = contextData.context;
           if (!contextData.hasCallbacks()) {
@@ -5304,11 +5387,11 @@
               return Promise.resolve({});
           }
           if (contextData && (!contextData.hasCallbacks() || !contextData.hasReceivedSnapshot)) {
-              return new Promise((resolve) => {
+              return new Promise((resolve, reject) => {
                   this.subscribe(name, (data, _d, _r, un) => {
                       this.unsubscribe(un);
                       resolve(data);
-                  });
+                  }).catch(reject);
               });
           }
           const context = contextData?.context ?? {};
@@ -5397,7 +5480,7 @@
               type: GW_MESSAGE_DESTROY_CONTEXT,
               domain: "global",
               context_id: contextData.contextId,
-          }).then((_) => undefined);
+          }).then(() => undefined);
       }
       handleUpdated(contextData, delta, extraData) {
           const oldContext = contextData.context;
@@ -5450,7 +5533,7 @@
                   contextData.contextId = contextCreatedMsg.context_id;
                   contextData.activityId = contextCreatedMsg.activity_id;
                   if (!contextData.sentExplicitSubscription) {
-                      this.sendSubscribe(contextData);
+                      this.sendSubscribe(contextData).catch(() => { });
                   }
               }
           }
@@ -5602,16 +5685,25 @@
               type: GW_MESSAGE_SUBSCRIBE_CONTEXT,
               domain: "global",
               context_id: contextData.contextId,
-          }).then((_) => undefined);
+          })
+              .then(() => undefined)
+              .catch(() => {
+              contextData.sentExplicitSubscription = false;
+          });
       }
       sendUnsubscribe(contextData) {
+          const prev = contextData.sentExplicitSubscription;
           contextData.sentExplicitSubscription = false;
           return this._gw3Session
               .send({
               type: GW_MESSAGE_UNSUBSCRIBE_CONTEXT,
               domain: "global",
               context_id: contextData.contextId,
-          }).then((_) => undefined);
+          })
+              .then(() => undefined)
+              .catch(() => {
+              contextData.sentExplicitSubscription = prev;
+          });
       }
       calculateContextDeltaV1(from, to) {
           const delta = { added: {}, updated: {}, removed: [], reset: undefined };
@@ -5664,10 +5756,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 = {};
@@ -7021,13 +7110,15 @@
       session;
       repository;
       serverRepository;
+      logger;
       ERR_URI_SUBSCRIPTION_FAILED = "com.tick42.agm.errors.subscription.failure";
       callbacks = CallbackRegistryFactory$1();
       nextStreamId = 0;
-      constructor(session, repository, serverRepository) {
+      constructor(session, repository, serverRepository, logger) {
           this.session = session;
           this.repository = repository;
           this.serverRepository = serverRepository;
+          this.logger = logger;
           session.on("add-interest", (msg) => {
               this.handleAddInterest(msg);
           });
@@ -7060,6 +7151,8 @@
               type: "accepted",
               subscription_id: key,
               stream_id: streamId,
+          }).catch((err) => {
+              this.logger.warn(`Failed to send accepted message for subscription ${key}: ${JSON.stringify(err)}`);
           });
           this.callbacks.execute(SUBSCRIPTION_ADDED, subscription, streamingMethod);
       }
@@ -7097,7 +7190,10 @@
                   stream_id: streamId,
                   data,
               };
-              this.session.sendFireAndForget(publishMessage);
+              this.session.sendFireAndForget(publishMessage)
+                  .catch((err) => {
+                  this.logger.warn(`Failed to send publish message for stream ${streamId}: ${JSON.stringify(err)}`);
+              });
           });
       }
       pushDataToSingle(method, subscription, data) {
@@ -7109,7 +7205,10 @@
               subscription_id: subscription.id,
               data,
           };
-          this.session.sendFireAndForget(postMessage);
+          this.session.sendFireAndForget(postMessage)
+              .catch((err) => {
+              this.logger.warn(`Failed to send post message for subscription ${subscription.id}: ${JSON.stringify(err)}`);
+          });
       }
       closeSingleSubscription(streamingMethod, subscription) {
           if (streamingMethod.protocolState.subscriptionsMap) {
@@ -7120,7 +7219,10 @@
               subscription_id: subscription.id,
               reason: "Server dropping a single subscription",
           };
-          this.session.sendFireAndForget(dropSubscriptionMessage);
+          this.session.sendFireAndForget(dropSubscriptionMessage)
+              .catch((err) => {
+              this.logger.warn(`Failed to send drop-subscription message for subscription ${subscription.id}: ${JSON.stringify(err)}`);
+          });
           subscription.instance;
           this.callbacks.execute(SUBSCRIPTION_REMOVED, subscription, streamingMethod);
       }
@@ -7148,7 +7250,10 @@
                   subscription_id: subscription.id,
                   reason: "Server dropping all subscriptions on stream_id: " + subscription.streamId,
               };
-              this.session.sendFireAndForget(drop);
+              this.session.sendFireAndForget(drop)
+                  .catch((err) => {
+                  this.logger.warn(`Failed to send drop-subscription message for subscription ${subscription.id}: ${JSON.stringify(err)}`);
+              });
           });
       }
       getSubscriptionList(streamingMethod, branchKey) {
@@ -7257,7 +7362,10 @@
               reason,
               request_id: subscriptionId,
           };
-          this.session.sendFireAndForget(errorMessage);
+          this.session.sendFireAndForget(errorMessage)
+              .catch((err) => {
+              this.logger.warn(`Failed to send subscription failed message for subscription ${subscriptionId}: ${JSON.stringify(err)}`);
+          });
       }
       getStreamId(streamingMethod, branchKey) {
           if (typeof branchKey !== "string") {
@@ -7290,7 +7398,7 @@
           this.clientRepository = clientRepository;
           this.serverRepository = serverRepository;
           this.logger = logger;
-          this.streaming = new ServerStreaming(session, clientRepository, serverRepository);
+          this.streaming = new ServerStreaming(session, clientRepository, serverRepository, logger.subLogger("streaming"));
           this.session.on("invoke", (msg) => this.handleInvokeMessage(msg));
       }
       createStream(repoMethod) {
@@ -7349,7 +7457,10 @@
                   request_id: undefined,
               };
           }
-          this.session.sendFireAndForget(msg);
+          this.session.sendFireAndForget(msg)
+              .catch((error => {
+              this.logger.warn(`Failed to send method invocation result for method ${method.definition.name} invocation ${invocationId} - ${JSON.stringify(error)}`);
+          }));
       }
       async unregister(method) {
           const msg = {
@@ -7809,6 +7920,8 @@
                   subscription_id: server.subscriptionId,
                   reason_uri: "",
                   reason: ON_CLOSE_MSG_CLIENT_INIT,
+              }).catch((err) => {
+                  this.logger.warn(`Error sending unsubscribe for subscription id ${server.subscriptionId}: ${JSON.stringify(err)}`);
               });
               delete this.subscriptionIdToLocalKeyMap[server.subscriptionId];
           });
@@ -8148,7 +8261,10 @@
               routing_key: routingKey,
               target_identity: target
           });
-          this.session.send(args);
+          this.session.send(args)
+              .catch((err) => {
+              this.logger.error(`Failed to publish message to topic ${topic} with routing key ${routingKey} for ${JSON.stringify(target)}: ${JSON.stringify(err)}`);
+          });
       };
       subscribe = (topic, callback, options) => {
           return new Promise((resolve, reject) => {
@@ -8166,8 +8282,12 @@
                   this.subscriptions.push({ subscription_id, topic, callback, source: target });
                   resolve({
                       unsubscribe: () => {
-                          this.session.send({ type: "unsubscribe", subscription_id, peer_id: this.peerId });
-                          this.subscriptions = this.subscriptions.filter((s) => s.subscription_id !== subscription_id);
+                          this.session.send({ type: "unsubscribe", subscription_id, peer_id: this.peerId })
+                              .then(() => {
+                              this.subscriptions = this.subscriptions.filter((s) => s.subscription_id !== subscription_id);
+                          }).catch((err) => {
+                              this.logger.warn(`Failed to send unsubscribe request for ${subscription_id}: ${JSON.stringify(err)}`);
+                          });
                           return Promise.resolve();
                       }
                   });
@@ -11702,6 +11822,9 @@
               height: a.height
           };
       }
+      static isRunningInIoCdContext() {
+          return typeof window !== "undefined" && (window.glue42gd || window.iodesktop);
+      }
       static isNode() {
           if (typeof Utils._isNode !== "undefined") {
               return Utils._isNode;
@@ -12689,24 +12812,23 @@
                       .forEach((item) => entitlements.handleBranchesModified(item));
                   if (!initiated) {
                       initiated = true;
-                      const hasMyAppInSnapShot = onApplicationAddedEventArgs.some((a) => a.Name === agm.instance.application);
-                      const hasMyInstanceInSnapShot = onApplicationStartedEventArgs.some((i) => i.Id === agm.instance.instance);
-                      if (hasMyAppInSnapShot) {
-                          if (hasMyInstanceInSnapShot) {
-                              resolveFunc(configuration);
-                          }
-                          else {
-                              const un = applications.onInstanceStarted((i) => {
-                                  if (i.id === agm.instance.instance) {
-                                      un();
-                                      resolveFunc(configuration);
-                                  }
-                              });
-                          }
-                      }
-                      else {
+                      const myInstance = agm.instance;
+                      const hasMyAppInSnapShot = onApplicationAddedEventArgs.some((a) => a.Name === myInstance.application);
+                      const hasMyInstanceInSnapShot = onApplicationStartedEventArgs.some((i) => i.Id === myInstance.instance);
+                      if (!hasMyAppInSnapShot) {
                           resolveFunc(configuration);
+                          return;
                       }
+                      if (!hasMyInstanceInSnapShot && (Utils.isNode() || Utils.isRunningInIoCdContext())) {
+                          const un = applications.onInstanceStarted((i) => {
+                              if (i.id === myInstance.instance) {
+                                  un();
+                                  resolveFunc(configuration);
+                              }
+                          });
+                          return;
+                      }
+                      resolveFunc(configuration);
                   }
               });
               subscription.onFailed((err) => rejectFunc(err));
@@ -13511,6 +13633,9 @@
               return executor.snap(resultWindow, target, direction);
           }, success, error);
       }
+      function dragMove(dragMoveSettings) {
+          return executor.dragMove(resultWindow, dragMoveSettings);
+      }
       function attachTab(tab, opt, success, error) {
           return Utils.callbackifyPromise(() => {
               var _a;
@@ -13740,6 +13865,9 @@
       function place(placementSettings) {
           return executor.place(resultWindow, placementSettings);
       }
+      function clearPlacement(clearPlacementSettings) {
+          return executor.clearPlacement(resultWindow, clearPlacementSettings);
+      }
       function refresh(ignoreCache) {
           return executor.refresh(resultWindow, ignoreCache);
       }
@@ -14493,6 +14621,7 @@
           center,
           close,
           snap,
+          dragMove,
           showLoader,
           hideLoader,
           updateContext,
@@ -14523,6 +14652,7 @@
           print,
           printToPDF,
           place,
+          clearPlacement,
           ungroup,
           refresh,
           goBack,
@@ -15006,6 +15136,9 @@
           await this.execute("snap", { windowId: w.id, options: args }, "CompositionChanged", `CompositionChanged-${targetWindow.id}`);
           return w;
       }
+      dragMove(window, options) {
+          return this.execute("dragMove", { windowId: window.id, options });
+      }
       async attachTab(w, sourceWindow, options) {
           await this.execute("attachTab", {
               windowId: w.id,
@@ -15266,6 +15399,9 @@
           }
           return this.execute("place", { windowId: window.id, options: { ...copy } });
       }
+      async clearPlacement(window, options) {
+          return this.execute("clearPlacement", { windowId: window.id, options });
+      }
       async refresh(resultWindow, ignoreCache) {
           await this.execute("refresh", { windowId: resultWindow.id, options: { ignoreCache } });
           return resultWindow;
@@ -16928,7 +17064,8 @@
       }
       registerRequestMethods() {
           this.interop.register(SaveContextMethodName, (args) => {
-              const usersCbs = this.callbacks.execute("saveRequested", args);
+              const { ignoreContexts, ...cbArgs } = args;
+              const usersCbs = this.callbacks.execute("saveRequested", cbArgs);
               if ((usersCbs === null || usersCbs === void 0 ? void 0 : usersCbs.length) > 1) {
                   this.logger.warn(`Multiple subscriptions for "glue.layouts.onSaveRequested" - only the first one will be used`);
               }
@@ -16944,7 +17081,7 @@
               if (this.isActivityOwner()) {
                   result.activityContext = requestResult === null || requestResult === void 0 ? void 0 : requestResult.activityContext;
               }
-              return result;
+              return ignoreContexts ? { windowContext: undefined, activityContext: undefined } : result;
           });
       }
   }
@@ -17150,6 +17287,9 @@
                   if (typeof layout.setAsCurrent === "boolean") {
                       layoutObject.options.setAsCurrent = layout.setAsCurrent;
                   }
+                  if (typeof layout.ignoreContexts === "boolean") {
+                      layoutObject.options.ignoreContexts = layout.ignoreContexts;
+                  }
               }
               else {
                   return reject(new Error(`layout type ${layout.type} is not supported`));
@@ -17401,6 +17541,16 @@
       onChanged(callback) {
           return this.callbacks.add("changed", callback);
       }
+      onDefaultGlobalChanged(callback) {
+          if (typeof callback !== "function") {
+              throw new Error("callback must be a function");
+          }
+          this.getDefaultGlobal()
+              .then((layout) => callback(layout ? { name: layout.name } : undefined))
+              .catch(() => {
+          });
+          return this.callbacks.add("default-changed", callback);
+      }
       onRestored(callback) {
           return this.callbacks.add("restored", callback);
       }
@@ -17586,6 +17736,8 @@
                       this.changeLayouts(transform(data.OnLayoutChanged));
                       this.renameLayouts(transform(data.OnLayoutRenamed));
                       this.restoredLayout(transform(data.OnLayoutRestored));
+                      this.selectedDefaultLayout(transform(data.OnLayoutSelectedDefault), false);
+                      this.selectedDefaultLayout(transform(data.OnLayoutDeselectedDefault), true);
                       this.callbacks.execute("streamEvent", data);
                   });
                   subs.onFailed((err) => {
@@ -17620,7 +17772,7 @@
               });
               setTimeout(() => {
                   if (!done) {
-                      reject("timed out");
+                      reject(new Error(`Timeout waiting for token ${token}`));
                   }
               }, timeout);
           });
@@ -17686,7 +17838,7 @@
                   throw Error(`received rename event for unknown layout with type ${renamedLayout.type} and name ${renamedLayout.oldName}`);
               }
               existingLayout.name = renamedLayout.newName;
-              this.callbacks.execute("renamed", existingLayout);
+              this.callbacks.execute("renamed", existingLayout, { name: renamedLayout.oldName });
           });
       }
       compareLayouts(layout1, layout2) {
@@ -17707,6 +17859,17 @@
               this.callbacks.execute("restored", existingLayout);
           });
       }
+      selectedDefaultLayout(selectedDefaultLayouts, deselected) {
+          if (!selectedDefaultLayouts || selectedDefaultLayouts.length === 0) {
+              return;
+          }
+          if (deselected) {
+              this.callbacks.execute("default-changed", undefined);
+          }
+          else {
+              this.callbacks.execute("default-changed", selectedDefaultLayouts[0]);
+          }
+      }
   }
 
   function LayoutsFactory (config) {
@@ -18588,7 +18751,16 @@
               data: info.data || {}
           };
           this.logger.trace(`adding channel: ${info.name}`);
-          await addOrRemoveChannel("addChannel", info.name, info.meta.color, (_a = info.meta) === null || _a === void 0 ? void 0 : _a.label);
+          try {
+              await addOrRemoveChannel("addChannel", info.name, info.meta.color, (_a = info.meta) === null || _a === void 0 ? void 0 : _a.label);
+          }
+          catch (error) {
+              if ("message" in error && error.message.includes(`Channel with name '${info.name}' already exists.`)) {
+                  this.logger.trace(`channel: ${info.name} already exists - ignore channel add request`);
+                  await this.verifyChannelExists(info.name, 10 * 1000);
+              }
+              throw error;
+          }
           await this.shared.updateChannel(info.name, context);
           return context;
       }
@@ -18694,7 +18866,7 @@
           this.raiseChannelsChangedEvents();
           this.logger.trace(`joined channel: ${name} ${changeSelector ? "" : "from command"} - current channel/s: ${this.currentChannelID.toString()}`);
       }
-      async verifyChannelExists(name) {
+      async verifyChannelExists(name, timeout, interval) {
           const doesChannelExist = (channelName) => {
               const channelNames = this.shared.all();
               return channelNames.includes(channelName);
@@ -18707,11 +18879,11 @@
                           clearInterval(intervalId);
                           resolve();
                       }
-                  }, 100);
+                  }, interval !== null && interval !== void 0 ? interval : 100);
                   const timeoutId = setTimeout(() => {
                       clearInterval(intervalId);
                       return reject(new Error(`A channel with name: ${name} doesn't exist!`));
-                  }, 3000);
+                  }, timeout !== null && timeout !== void 0 ? timeout : 3000);
               });
               await channelExistsPromise;
           }
@@ -19183,7 +19355,7 @@
       };
   }
 
-  var version = "6.13.1";
+  var version = "6.15.0";
 
   var prepareConfig = (options) => {
       function getLibConfig(value, defaultMode, trueMode) {
@@ -21441,11 +21613,34 @@
           throw new Error("Please provide waitUserResponseIndefinitely as a boolean");
       }
   };
+  const isExcludeListValid = (excludeList) => {
+      if (!Array.isArray(excludeList)) {
+          return false;
+      }
+      const everyItemIsObject = excludeList.every(item => typeof item === "object" && !Array.isArray(item) && item !== null);
+      if (!everyItemIsObject) {
+          return false;
+      }
+      const everyItemHasValidKey = excludeList.every(item => "applicationName" in item || "instanceId" in item);
+      if (!everyItemHasValidKey) {
+          return false;
+      }
+      const everyItemKeysAreValid = excludeList.every(item => {
+          if ("applicationName" in item) {
+              return typeof item.applicationName === "string" && item.applicationName.length;
+          }
+          if ("instanceId" in item) {
+              return typeof item.instanceId === "string" && item.instanceId.length;
+          }
+          return false;
+      });
+      return everyItemKeysAreValid;
+  };
   const validateHandlerFilter = (handlerFilter) => {
       if (!handlerFilter) {
           throw new Error(`Provide 'handlerFilter' with at least one filter criteria of the following: 'intent' | 'contextTypes' | 'resultType' | 'applicationNames'`);
       }
-      const { title, openResolver, timeout, intent, contextTypes, resultType, applicationNames } = handlerFilter;
+      const { title, openResolver, timeout, intent, contextTypes, resultType, applicationNames, excludeList } = handlerFilter;
       if (typeof title !== "undefined" && (typeof title !== "string" || !title.length)) {
           throw new Error(`Provide 'title' as a non empty string`);
       }
@@ -21467,11 +21662,15 @@
       if (typeof applicationNames !== "undefined" && (!Array.isArray(applicationNames) || applicationNames.some(appName => typeof appName !== "string"))) {
           throw new Error(`Provide 'applicationNames' as an array of non empty strings`);
       }
+      const excludeListValidation = excludeList ? isExcludeListValid(excludeList) : true;
+      if (!excludeListValidation) {
+          throw new Error("Provide 'excludeList' as an array of objects with either 'applicationName' or 'instanceId' key");
+      }
       const errorMsg = "Provide at least one filter criteria of the following: 'intent' | 'contextTypes' | 'resultType' | 'applicationNames'";
       if (!Object.keys(handlerFilter).length) {
           throw new Error(errorMsg);
       }
-      if (!intent && !resultType && (!contextTypes || !contextTypes.length) && (!applicationNames || !applicationNames.length)) {
+      if (!intent && !resultType && (!(contextTypes === null || contextTypes === void 0 ? void 0 : contextTypes.length)) && (!(applicationNames === null || applicationNames === void 0 ? void 0 : applicationNames.length))) {
           throw new Error(errorMsg);
       }
   };
@@ -21765,8 +21964,9 @@
               throw new Error("Cannot resolve 'filterHandlers' request using Intents Resolver UI because it's globally disabled");
           }
           (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace(`Received 'filterHandlers' command with request: ${JSON.stringify(handlerFilter)}`);
-          const filteredHandlers = this.filterHandlersBy(await this.all(), handlerFilter);
-          if (!filteredHandlers || !filteredHandlers.length) {
+          const intents = await this.all();
+          const filteredHandlers = this.filterHandlersBy(intents, handlerFilter);
+          if (!(filteredHandlers === null || filteredHandlers === void 0 ? void 0 : filteredHandlers.length)) {
               return { handlers: [] };
           }
           const { open, reason } = this.checkIfResolverShouldBeOpenedForFilterHandlers(filteredHandlers, handlerFilter);
@@ -21881,6 +22081,9 @@
               if (filter.intent && filter.intent !== intent.name) {
                   return;
               }
+              if (filter.excludeList) {
+                  intent.handlers = this.excludeIntentHandlers(intent, filter.excludeList);
+              }
               if (filter.resultType) {
                   const filteredHandlers = intent.handlers.filter((handler) => handler.resultType && handler.resultType === filter.resultType);
                   if (!filteredHandlers.length)
@@ -21903,6 +22106,21 @@
           });
           return filteredIntentsWithHandlers.map((intent) => intent.handlers).flat(1);
       }
+      excludeIntentHandlers(intent, excludeList) {
+          const filtered = intent.handlers.filter((handler) => {
+              const isExcluded = excludeList.some((exclusion) => {
+                  if ("applicationName" in exclusion) {
+                      return exclusion.applicationName === handler.applicationName;
+                  }
+                  if ("instanceId" in exclusion) {
+                      return exclusion.instanceId === handler.instanceId;
+                  }
+                  return false;
+              });
+              return !isExcluded;
+          });
+          return filtered;
+      }
       async coreRaiseIntent({ request, resolverInstance, timeout }) {
           var _a, _b;
           const intentDef = await this.get(request.intent);