@interopio/desktop 6.2.2 → 6.4.0

package/dist/desktop.browser.js

@@ -1321,6 +1321,7 @@
               return __generator(this, function (_b) {
                   switch (_b.label) {
                       case 0:
+                          this.logger.info("opening ws to ".concat(this.settings.ws, ", retryInterval: ").concat(retryInterval, ", retriesLeft: ").concat(retriesLeft, "..."));
                           this.startupTimer.mark("opening-socket");
                           if (retryInterval === undefined) {
                               retryInterval = this.settings.reconnectInterval;
@@ -1358,9 +1359,10 @@
       };
       WS.prototype.initiateSocket = function () {
           var _this = this;
+          var _a;
           var pw = new PromiseWrapper();
           this.logger.debug("initiating ws to ".concat(this.settings.ws, "..."));
-          this.ws = new WebSocketConstructor(this.settings.ws || "");
+          this.ws = new WebSocketConstructor((_a = this.settings.ws) !== null && _a !== void 0 ? _a : "");
           this.ws.onerror = function (err) {
               var reason = "";
               try {
@@ -1379,11 +1381,12 @@
                   };
                   reason = JSON.stringify(err, replacer);
               }
+              _this.logger.info("ws error - reason: ".concat(reason));
               pw.reject("error");
               _this.notifyStatusChanged(false, reason);
           };
           this.ws.onclose = function (err) {
-              _this.logger.info("ws closed ".concat(err));
+              _this.logger.info("ws closed - code: ".concat(err === null || err === void 0 ? void 0 : err.code, " reason: ").concat(err === null || err === void 0 ? void 0 : err.reason));
               pw.reject("closed");
               _this.notifyStatusChanged(false);
           };
@@ -1418,6 +1421,80 @@
       return WS;
   }());
 
+  var MessageReplayerImpl = (function () {
+      function MessageReplayerImpl(specs) {
+          this.specsNames = [];
+          this.messages = {};
+          this.subs = {};
+          this.subsRefCount = {};
+          this.specs = {};
+          for (var _i = 0, specs_1 = specs; _i < specs_1.length; _i++) {
+              var spec = specs_1[_i];
+              this.specs[spec.name] = spec;
+              this.specsNames.push(spec.name);
+          }
+      }
+      MessageReplayerImpl.prototype.init = function (connection) {
+          var _this = this;
+          this.connection = connection;
+          for (var _i = 0, _a = this.specsNames; _i < _a.length; _i++) {
+              var name_1 = _a[_i];
+              var _loop_1 = function (type) {
+                  var refCount = this_1.subsRefCount[type];
+                  if (!refCount) {
+                      refCount = 0;
+                  }
+                  refCount += 1;
+                  this_1.subsRefCount[type] = refCount;
+                  if (refCount > 1) {
+                      return "continue";
+                  }
+                  var sub = connection.on(type, function (msg) { return _this.processMessage(type, msg); });
+                  this_1.subs[type] = sub;
+              };
+              var this_1 = this;
+              for (var _b = 0, _c = this.specs[name_1].types; _b < _c.length; _b++) {
+                  var type = _c[_b];
+                  _loop_1(type);
+              }
+          }
+      };
+      MessageReplayerImpl.prototype.processMessage = function (type, msg) {
+          if (this.isDone || !msg) {
+              return;
+          }
+          for (var _i = 0, _a = this.specsNames; _i < _a.length; _i++) {
+              var name_2 = _a[_i];
+              if (this.specs[name_2].types.indexOf(type) !== -1) {
+                  var messages = this.messages[name_2] || [];
+                  this.messages[name_2] = messages;
+                  messages.push(msg);
+              }
+          }
+      };
+      MessageReplayerImpl.prototype.drain = function (name, callback) {
+          var _a;
+          if (callback) {
+              (this.messages[name] || []).forEach(callback);
+          }
+          delete this.messages[name];
+          for (var _i = 0, _b = this.specs[name].types; _i < _b.length; _i++) {
+              var type = _b[_i];
+              this.subsRefCount[type] -= 1;
+              if (this.subsRefCount[type] <= 0) {
+                  (_a = this.connection) === null || _a === void 0 ? void 0 : _a.off(this.subs[type]);
+                  delete this.subs[type];
+                  delete this.subsRefCount[type];
+              }
+          }
+          delete this.specs[name];
+          if (!this.specs.length) {
+              this.isDone = true;
+          }
+      };
+      return MessageReplayerImpl;
+  }());
+
   var shortidExports = {};
   var shortid$1 = {
     get exports(){ return shortidExports; },
@@ -1766,743 +1843,127 @@
 
   var shortid = /*@__PURE__*/getDefaultExportFromCjs(shortidExports);
 
-  function domainSession (domain, connection, logger, successMessages, errorMessages) {
-      if (domain == null) {
-          domain = "global";
-      }
-      successMessages = successMessages || ["success"];
-      errorMessages = errorMessages || ["error"];
-      var isJoined = false;
-      var tryReconnecting = false;
-      var _latestOptions;
-      var _connectionOn = false;
-      var callbacks = lib$1();
-      connection.disconnected(handleConnectionDisconnected);
-      connection.loggedIn(handleConnectionLoggedIn);
-      connection.on("success", function (msg) { return handleSuccessMessage(msg); });
-      connection.on("error", function (msg) { return handleErrorMessage(msg); });
-      connection.on("result", function (msg) { return handleSuccessMessage(msg); });
-      if (successMessages) {
-          successMessages.forEach(function (sm) {
-              connection.on(sm, function (msg) { return handleSuccessMessage(msg); });
+  var PromisePlus$1 = function (executor, timeoutMilliseconds, timeoutMessage) {
+      return new Promise(function (resolve, reject) {
+          var timeout = setTimeout(function () {
+              var message = timeoutMessage || "Promise timeout hit: ".concat(timeoutMilliseconds);
+              reject(message);
+          }, timeoutMilliseconds);
+          var providedPromise = new Promise(executor);
+          providedPromise
+              .then(function (result) {
+              clearTimeout(timeout);
+              resolve(result);
+          })
+              .catch(function (error) {
+              clearTimeout(timeout);
+              reject(error);
           });
+      });
+  };
+
+  var WebPlatformTransport = (function () {
+      function WebPlatformTransport(settings, logger, identity) {
+          this.settings = settings;
+          this.logger = logger;
+          this.identity = identity;
+          this.iAmConnected = false;
+          this.parentReady = false;
+          this.rejected = false;
+          this.children = [];
+          this.extContentAvailable = false;
+          this.extContentConnecting = false;
+          this.extContentConnected = false;
+          this.parentInExtMode = false;
+          this.webNamespace = "g42_core_web";
+          this.parentPingTimeout = 5000;
+          this.connectionRequestTimeout = 7000;
+          this.defaultTargetString = "*";
+          this.registry = lib$1();
+          this.messages = {
+              connectionAccepted: { name: "connectionAccepted", handle: this.handleConnectionAccepted.bind(this) },
+              connectionRejected: { name: "connectionRejected", handle: this.handleConnectionRejected.bind(this) },
+              connectionRequest: { name: "connectionRequest", handle: this.handleConnectionRequest.bind(this) },
+              parentReady: {
+                  name: "parentReady", handle: function () {
+                  }
+              },
+              parentPing: { name: "parentPing", handle: this.handleParentPing.bind(this) },
+              platformPing: { name: "platformPing", handle: this.handlePlatformPing.bind(this) },
+              platformReady: { name: "platformReady", handle: this.handlePlatformReady.bind(this) },
+              clientUnload: { name: "clientUnload", handle: this.handleClientUnload.bind(this) },
+              manualUnload: { name: "manualUnload", handle: this.handleManualUnload.bind(this) },
+              extConnectionResponse: { name: "extConnectionResponse", handle: this.handleExtConnectionResponse.bind(this) },
+              extSetupRequest: { name: "extSetupRequest", handle: this.handleExtSetupRequest.bind(this) },
+              gatewayDisconnect: { name: "gatewayDisconnect", handle: this.handleGatewayDisconnect.bind(this) },
+              gatewayInternalConnect: { name: "gatewayInternalConnect", handle: this.handleGatewayInternalConnect.bind(this) }
+          };
+          this.extContentAvailable = !!window.glue42ext;
+          this.setUpMessageListener();
+          this.setUpUnload();
+          this.setupPlatformUnloadListener();
+          this.parentType = window.name.includes("#wsp") ? "workspace" : undefined;
       }
-      if (errorMessages) {
-          errorMessages.forEach(function (sm) {
-              connection.on(sm, function (msg) { return handleErrorMessage(msg); });
+      WebPlatformTransport.prototype.manualSetReadyState = function () {
+          this.iAmConnected = true;
+          this.parentReady = true;
+      };
+      Object.defineProperty(WebPlatformTransport.prototype, "transportWindowId", {
+          get: function () {
+              return this.publicWindowId;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(WebPlatformTransport.prototype, "communicationId", {
+          get: function () {
+              return this._communicationId;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      WebPlatformTransport.prototype.sendObject = function (msg) {
+          return __awaiter(this, void 0, void 0, function () {
+              return __generator(this, function (_a) {
+                  if (this.extContentConnected) {
+                      return [2, window.postMessage({ glue42ExtOut: msg }, this.defaultTargetString)];
+                  }
+                  if (!this.port) {
+                      throw new Error("Cannot send message, because the port was not opened yet");
+                  }
+                  this.port.postMessage(msg);
+                  return [2];
+              });
           });
-      }
-      var requestsMap = {};
-      function join(options) {
-          _latestOptions = options;
-          return new Promise(function (resolve, reject) {
-              if (isJoined) {
-                  resolve({});
-                  return;
-              }
-              var joinPromise;
-              if (domain === "global") {
-                  joinPromise = _connectionOn ? Promise.resolve({}) : Promise.reject("not connected to gateway");
-              }
-              else {
-                  logger.debug("joining domain ".concat(domain));
-                  var joinMsg = {
-                      type: "join",
-                      destination: domain,
-                      domain: "global",
-                      options: options,
-                  };
-                  joinPromise = send(joinMsg);
-              }
-              joinPromise
-                  .then(function () {
-                  handleJoined();
-                  resolve({});
-              })
-                  .catch(function (err) {
-                  logger.debug("error joining " + domain + " domain: " + JSON.stringify(err));
-                  reject(err);
-              });
-          });
-      }
-      function leave() {
-          if (domain === "global") {
-              return Promise.resolve();
-          }
-          logger.debug("stopping session " + domain + "...");
-          var leaveMsg = {
-              type: "leave",
-              destination: domain,
-              domain: "global",
-          };
-          tryReconnecting = false;
-          return send(leaveMsg)
-              .then(function () {
-              isJoined = false;
-              callbacks.execute("onLeft");
-          })
-              .catch(function () {
-              isJoined = false;
-              callbacks.execute("onLeft");
-          });
-      }
-      function handleJoined() {
-          logger.debug("did join " + domain);
-          isJoined = true;
-          var wasReconnect = tryReconnecting;
-          tryReconnecting = false;
-          callbacks.execute("onJoined", wasReconnect);
-      }
-      function handleConnectionDisconnected() {
-          _connectionOn = false;
-          logger.debug("connection is down");
-          isJoined = false;
-          tryReconnecting = true;
-          callbacks.execute("onLeft", { disconnected: true });
-      }
-      function handleConnectionLoggedIn() {
-          _connectionOn = true;
-          if (tryReconnecting) {
-              logger.debug("connection is now up - trying to reconnect...");
-              join(_latestOptions);
-          }
-      }
-      function onJoined(callback) {
-          if (isJoined) {
-              callback(false);
-          }
-          return callbacks.add("onJoined", callback);
-      }
-      function onLeft(callback) {
-          if (!isJoined) {
-              callback();
-          }
-          return callbacks.add("onLeft", callback);
-      }
-      function handleErrorMessage(msg) {
-          if (domain !== msg.domain) {
-              return;
-          }
-          var requestId = msg.request_id;
-          if (!requestId) {
-              return;
-          }
-          var entry = requestsMap[requestId];
-          if (!entry) {
-              return;
-          }
-          entry.error(msg);
-      }
-      function handleSuccessMessage(msg) {
-          if (msg.domain !== domain) {
-              return;
-          }
-          var requestId = msg.request_id;
-          if (!requestId) {
-              return;
-          }
-          var entry = requestsMap[requestId];
-          if (!entry) {
-              return;
-          }
-          entry.success(msg);
-      }
-      function getNextRequestId() {
-          return shortid();
-      }
-      function send(msg, tag, options) {
-          options = options || {};
-          msg.request_id = msg.request_id || getNextRequestId();
-          msg.domain = msg.domain || domain;
-          if (!options.skipPeerId) {
-              msg.peer_id = connection.peerId;
-          }
-          var requestId = msg.request_id;
-          return new Promise(function (resolve, reject) {
-              requestsMap[requestId] = {
-                  success: function (successMsg) {
-                      delete requestsMap[requestId];
-                      successMsg._tag = tag;
-                      resolve(successMsg);
-                  },
-                  error: function (errorMsg) {
-                      logger.warn("GW error - ".concat(JSON.stringify(errorMsg), " for request ").concat(JSON.stringify(msg)));
-                      delete requestsMap[requestId];
-                      errorMsg._tag = tag;
-                      reject(errorMsg);
-                  },
-              };
-              connection
-                  .send(msg, options)
-                  .catch(function (err) {
-                  requestsMap[requestId].error({ err: err });
-              });
-          });
-      }
-      function sendFireAndForget(msg) {
-          msg.request_id = msg.request_id ? msg.request_id : getNextRequestId();
-          msg.domain = msg.domain || domain;
-          msg.peer_id = connection.peerId;
-          return connection.send(msg);
-      }
-      return {
-          join: join,
-          leave: leave,
-          onJoined: onJoined,
-          onLeft: onLeft,
-          send: send,
-          sendFireAndForget: sendFireAndForget,
-          on: function (type, callback) {
-              connection.on(type, function (msg) {
-                  if (msg.domain !== domain) {
-                      return;
-                  }
-                  try {
-                      callback(msg);
-                  }
-                  catch (e) {
-                      logger.error("Callback  failed: ".concat(e, " \n ").concat(e.stack, " \n msg was: ").concat(JSON.stringify(msg)), e);
-                  }
-              });
-          },
-          loggedIn: function (callback) { return connection.loggedIn(callback); },
-          connected: function (callback) { return connection.connected(callback); },
-          disconnected: function (callback) { return connection.disconnected(callback); },
-          get peerId() {
-              return connection.peerId;
-          },
-          get domain() {
-              return domain;
-          },
-      };
-  }
-
-  var GW3ProtocolImpl = (function () {
-      function GW3ProtocolImpl(connection, settings, logger) {
-          var _this = this;
-          this.connection = connection;
-          this.settings = settings;
-          this.logger = logger;
-          this.protocolVersion = 3;
-          this.datePrefix = "#T42_DATE#";
-          this.datePrefixLen = this.datePrefix.length;
-          this.dateMinLen = this.datePrefixLen + 1;
-          this.datePrefixFirstChar = this.datePrefix[0];
-          this.registry = lib$1();
-          this._isLoggedIn = false;
-          this.shouldTryLogin = true;
-          this.initialLogin = true;
-          this.initialLoginAttempts = 3;
-          this.sessions = [];
-          connection.disconnected(function () {
-              _this.handleDisconnected();
-          });
-          this.ping();
-      }
-      Object.defineProperty(GW3ProtocolImpl.prototype, "isLoggedIn", {
-          get: function () {
-              return this._isLoggedIn;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      GW3ProtocolImpl.prototype.processStringMessage = function (message) {
-          var _this = this;
-          var msg = JSON.parse(message, function (key, value) {
-              if (typeof value !== "string") {
-                  return value;
-              }
-              if (value.length < _this.dateMinLen) {
-                  return value;
-              }
-              if (value[0] !== _this.datePrefixFirstChar) {
-                  return value;
-              }
-              if (value.substring(0, _this.datePrefixLen) !== _this.datePrefix) {
-                  return value;
-              }
-              try {
-                  var milliseconds = parseInt(value.substring(_this.datePrefixLen, value.length), 10);
-                  if (isNaN(milliseconds)) {
-                      return value;
-                  }
-                  return new Date(milliseconds);
-              }
-              catch (ex) {
-                  return value;
-              }
-          });
-          return {
-              msg: msg,
-              msgType: msg.type,
-          };
-      };
-      GW3ProtocolImpl.prototype.createStringMessage = function (message) {
-          var oldToJson = Date.prototype.toJSON;
-          try {
-              var datePrefix_1 = this.datePrefix;
-              Date.prototype.toJSON = function () {
-                  return datePrefix_1 + this.getTime();
-              };
-              var result = JSON.stringify(message);
-              return result;
-          }
-          finally {
-              Date.prototype.toJSON = oldToJson;
-          }
-      };
-      GW3ProtocolImpl.prototype.processObjectMessage = function (message) {
-          if (!message.type) {
-              throw new Error("Object should have type property");
-          }
-          return {
-              msg: message,
-              msgType: message.type,
-          };
-      };
-      GW3ProtocolImpl.prototype.createObjectMessage = function (message) {
-          return message;
-      };
-      GW3ProtocolImpl.prototype.login = function (config, reconnect) {
-          return __awaiter(this, void 0, void 0, function () {
-              var authentication, token, e_1, _a, helloMsg, sendOptions, welcomeMsg, msg, token, _b, err_1;
-              return __generator(this, function (_c) {
-                  switch (_c.label) {
-                      case 0:
-                          this.logger.debug("logging in...");
-                          this.loginConfig = config;
-                          if (!this.loginConfig) {
-                              this.loginConfig = { username: "", password: "" };
-                          }
-                          this.shouldTryLogin = true;
-                          authentication = {};
-                          this.connection.gatewayToken = config.gatewayToken;
-                          if (!config.gatewayToken) return [3, 5];
-                          if (!reconnect) return [3, 4];
-                          _c.label = 1;
-                      case 1:
-                          _c.trys.push([1, 3, , 4]);
-                          return [4, this.getNewGWToken()];
-                      case 2:
-                          token = _c.sent();
-                          config.gatewayToken = token;
-                          return [3, 4];
-                      case 3:
-                          e_1 = _c.sent();
-                          this.logger.warn("failed to get GW token when reconnecting ".concat((e_1 === null || e_1 === void 0 ? void 0 : e_1.message) || e_1));
-                          return [3, 4];
-                      case 4:
-                          authentication.method = "gateway-token";
-                          authentication.token = config.gatewayToken;
-                          this.connection.gatewayToken = config.gatewayToken;
-                          return [3, 10];
-                      case 5:
-                          if (!(config.flowName === "sspi")) return [3, 9];
-                          authentication.provider = "win";
-                          authentication.method = "access-token";
-                          if (!(config.flowCallback && config.sessionId)) return [3, 7];
-                          _a = authentication;
-                          return [4, config.flowCallback(config.sessionId, null)];
-                      case 6:
-                          _a.token =
-                              (_c.sent())
-                                  .data
-                                  .toString("base64");
-                          return [3, 8];
-                      case 7: throw new Error("Invalid SSPI config");
-                      case 8: return [3, 10];
-                      case 9:
-                          if (config.token) {
-                              authentication.method = "access-token";
-                              authentication.token = config.token;
-                          }
-                          else if (config.username) {
-                              authentication.method = "secret";
-                              authentication.login = config.username;
-                              authentication.secret = config.password;
-                          }
-                          else if (config.provider) {
-                              authentication.provider = config.provider;
-                              authentication.providerContext = config.providerContext;
-                          }
-                          else {
-                              throw new Error("invalid auth message" + JSON.stringify(config));
-                          }
-                          _c.label = 10;
-                      case 10:
-                          helloMsg = {
-                              type: "hello",
-                              identity: this.settings.identity,
-                              authentication: authentication
-                          };
-                          if (config.sessionId) {
-                              helloMsg.request_id = config.sessionId;
-                          }
-                          this.globalDomain = domainSession("global", this.connection, this.logger.subLogger("global-domain"), [
-                              "welcome",
-                              "token",
-                              "authentication-request"
-                          ]);
-                          sendOptions = { skipPeerId: true };
-                          if (this.initialLogin) {
-                              sendOptions.retryInterval = this.settings.reconnectInterval;
-                              sendOptions.maxRetries = this.settings.reconnectAttempts;
-                          }
-                          _c.label = 11;
-                      case 11:
-                          _c.trys.push([11, 19, 20, 21]);
-                          welcomeMsg = void 0;
-                          _c.label = 12;
-                      case 12:
-                          return [4, this.globalDomain.send(helloMsg, undefined, sendOptions)];
-                      case 13:
-                          msg = _c.sent();
-                          if (!(msg.type === "authentication-request")) return [3, 16];
-                          token = Buffer.from(msg.authentication.token, "base64");
-                          if (!(config.flowCallback && config.sessionId)) return [3, 15];
-                          _b = helloMsg.authentication;
-                          return [4, config.flowCallback(config.sessionId, token)];
-                      case 14:
-                          _b.token =
-                              (_c.sent())
-                                  .data
-                                  .toString("base64");
-                          _c.label = 15;
-                      case 15:
-                          helloMsg.request_id = config.sessionId;
-                          return [3, 12];
-                      case 16:
-                          if (msg.type === "welcome") {
-                              welcomeMsg = msg;
-                              return [3, 18];
-                          }
-                          else if (msg.type === "error") {
-                              throw new Error("Authentication failed: " + msg.reason);
-                          }
-                          else {
-                              throw new Error("Unexpected message type during authentication: " + msg.type);
-                          }
-                      case 17: return [3, 12];
-                      case 18:
-                          this.initialLogin = false;
-                          this.logger.debug("login successful with peerId " + welcomeMsg.peer_id);
-                          this.connection.peerId = welcomeMsg.peer_id;
-                          this.connection.resolvedIdentity = welcomeMsg.resolved_identity;
-                          this.connection.availableDomains = welcomeMsg.available_domains;
-                          if (welcomeMsg.options) {
-                              this.connection.token = welcomeMsg.options.access_token;
-                              this.connection.info = welcomeMsg.options.info;
-                          }
-                          this.setLoggedIn(true);
-                          return [2, welcomeMsg.resolved_identity];
-                      case 19:
-                          err_1 = _c.sent();
-                          this.logger.error("error sending hello message - " + (err_1.message || err_1.msg || err_1.reason || err_1), err_1);
-                          throw err_1;
-                      case 20:
-                          if (config && config.flowCallback && config.sessionId) {
-                              config.flowCallback(config.sessionId, null);
-                          }
-                          return [7];
-                      case 21: return [2];
-                  }
-              });
-          });
-      };
-      GW3ProtocolImpl.prototype.logout = function () {
-          return __awaiter(this, void 0, void 0, function () {
-              var promises;
-              return __generator(this, function (_a) {
-                  switch (_a.label) {
-                      case 0:
-                          this.logger.debug("logging out...");
-                          this.shouldTryLogin = false;
-                          if (this.pingTimer) {
-                              clearTimeout(this.pingTimer);
-                          }
-                          promises = this.sessions.map(function (session) {
-                              session.leave();
-                          });
-                          return [4, Promise.all(promises)];
-                      case 1:
-                          _a.sent();
-                          return [2];
-                  }
-              });
-          });
-      };
-      GW3ProtocolImpl.prototype.loggedIn = function (callback) {
-          if (this._isLoggedIn) {
-              callback();
-          }
-          return this.registry.add("onLoggedIn", callback);
-      };
-      GW3ProtocolImpl.prototype.domain = function (domainName, domainLogger, successMessages, errorMessages) {
-          var session = this.sessions.filter(function (s) { return s.domain === domainName; })[0];
-          if (!session) {
-              session = domainSession(domainName, this.connection, domainLogger, successMessages, errorMessages);
-              this.sessions.push(session);
-          }
-          return session;
-      };
-      GW3ProtocolImpl.prototype.handleDisconnected = function () {
-          var _this = this;
-          this.setLoggedIn(false);
-          var tryToLogin = this.shouldTryLogin;
-          if (tryToLogin && this.initialLogin) {
-              if (this.initialLoginAttempts <= 0) {
-                  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.connection.login(this.loginConfig, true)
-                  .catch(function () {
-                  setTimeout(_this.handleDisconnected.bind(_this), _this.settings.reconnectInterval || 1000);
-              });
-          }
-      };
-      GW3ProtocolImpl.prototype.setLoggedIn = function (value) {
-          this._isLoggedIn = value;
-          if (this._isLoggedIn) {
-              this.registry.execute("onLoggedIn");
-          }
-      };
-      GW3ProtocolImpl.prototype.ping = function () {
-          var _this = this;
-          if (!this.shouldTryLogin) {
-              return;
-          }
-          if (this._isLoggedIn) {
-              this.connection.send({ type: "ping" });
-          }
-          this.pingTimer = setTimeout(function () {
-              _this.ping();
-          }, 30 * 1000);
-      };
-      GW3ProtocolImpl.prototype.authToken = function () {
-          var createTokenReq = {
-              type: "create-token"
-          };
-          if (!this.globalDomain) {
-              return Promise.reject(new Error("no global domain session"));
-          }
-          return this.globalDomain.send(createTokenReq)
-              .then(function (res) {
-              return res.token;
-          });
-      };
-      GW3ProtocolImpl.prototype.getNewGWToken = function () {
-          if (typeof window !== undefined) {
-              var glue42gd = window.glue42gd;
-              if (glue42gd) {
-                  return glue42gd.getGWToken();
-              }
-          }
-          return Promise.reject(new Error("not running in GD"));
-      };
-      return GW3ProtocolImpl;
-  }());
-
-  var MessageReplayerImpl = (function () {
-      function MessageReplayerImpl(specs) {
-          this.specsNames = [];
-          this.messages = {};
-          this.subs = {};
-          this.subsRefCount = {};
-          this.specs = {};
-          for (var _i = 0, specs_1 = specs; _i < specs_1.length; _i++) {
-              var spec = specs_1[_i];
-              this.specs[spec.name] = spec;
-              this.specsNames.push(spec.name);
-          }
-      }
-      MessageReplayerImpl.prototype.init = function (connection) {
-          var _this = this;
-          this.connection = connection;
-          for (var _i = 0, _a = this.specsNames; _i < _a.length; _i++) {
-              var name_1 = _a[_i];
-              var _loop_1 = function (type) {
-                  var refCount = this_1.subsRefCount[type];
-                  if (!refCount) {
-                      refCount = 0;
-                  }
-                  refCount += 1;
-                  this_1.subsRefCount[type] = refCount;
-                  if (refCount > 1) {
-                      return "continue";
-                  }
-                  var sub = connection.on(type, function (msg) { return _this.processMessage(type, msg); });
-                  this_1.subs[type] = sub;
-              };
-              var this_1 = this;
-              for (var _b = 0, _c = this.specs[name_1].types; _b < _c.length; _b++) {
-                  var type = _c[_b];
-                  _loop_1(type);
-              }
-          }
-      };
-      MessageReplayerImpl.prototype.processMessage = function (type, msg) {
-          if (this.isDone || !msg) {
-              return;
-          }
-          for (var _i = 0, _a = this.specsNames; _i < _a.length; _i++) {
-              var name_2 = _a[_i];
-              if (this.specs[name_2].types.indexOf(type) !== -1) {
-                  var messages = this.messages[name_2] || [];
-                  this.messages[name_2] = messages;
-                  messages.push(msg);
-              }
-          }
-      };
-      MessageReplayerImpl.prototype.drain = function (name, callback) {
-          var _a;
-          if (callback) {
-              (this.messages[name] || []).forEach(callback);
-          }
-          delete this.messages[name];
-          for (var _i = 0, _b = this.specs[name].types; _i < _b.length; _i++) {
-              var type = _b[_i];
-              this.subsRefCount[type] -= 1;
-              if (this.subsRefCount[type] <= 0) {
-                  (_a = this.connection) === null || _a === void 0 ? void 0 : _a.off(this.subs[type]);
-                  delete this.subs[type];
-                  delete this.subsRefCount[type];
-              }
-          }
-          delete this.specs[name];
-          if (!this.specs.length) {
-              this.isDone = true;
-          }
-      };
-      return MessageReplayerImpl;
-  }());
-
-  var PromisePlus$1 = function (executor, timeoutMilliseconds, timeoutMessage) {
-      return new Promise(function (resolve, reject) {
-          var timeout = setTimeout(function () {
-              var message = timeoutMessage || "Promise timeout hit: ".concat(timeoutMilliseconds);
-              reject(message);
-          }, timeoutMilliseconds);
-          var providedPromise = new Promise(executor);
-          providedPromise
-              .then(function (result) {
-              clearTimeout(timeout);
-              resolve(result);
-          })
-              .catch(function (error) {
-              clearTimeout(timeout);
-              reject(error);
-          });
-      });
-  };
-
-  var WebPlatformTransport = (function () {
-      function WebPlatformTransport(settings, logger, identity) {
-          this.settings = settings;
-          this.logger = logger;
-          this.identity = identity;
-          this.iAmConnected = false;
-          this.parentReady = false;
-          this.rejected = false;
-          this.children = [];
-          this.extContentAvailable = false;
-          this.extContentConnecting = false;
-          this.extContentConnected = false;
-          this.parentInExtMode = false;
-          this.webNamespace = "g42_core_web";
-          this.parentPingTimeout = 5000;
-          this.connectionRequestTimeout = 7000;
-          this.defaultTargetString = "*";
-          this.registry = lib$1();
-          this.messages = {
-              connectionAccepted: { name: "connectionAccepted", handle: this.handleConnectionAccepted.bind(this) },
-              connectionRejected: { name: "connectionRejected", handle: this.handleConnectionRejected.bind(this) },
-              connectionRequest: { name: "connectionRequest", handle: this.handleConnectionRequest.bind(this) },
-              parentReady: {
-                  name: "parentReady", handle: function () {
-                  }
-              },
-              parentPing: { name: "parentPing", handle: this.handleParentPing.bind(this) },
-              platformPing: { name: "platformPing", handle: this.handlePlatformPing.bind(this) },
-              platformReady: { name: "platformReady", handle: this.handlePlatformReady.bind(this) },
-              clientUnload: { name: "clientUnload", handle: this.handleClientUnload.bind(this) },
-              manualUnload: { name: "manualUnload", handle: this.handleManualUnload.bind(this) },
-              extConnectionResponse: { name: "extConnectionResponse", handle: this.handleExtConnectionResponse.bind(this) },
-              extSetupRequest: { name: "extSetupRequest", handle: this.handleExtSetupRequest.bind(this) },
-              gatewayDisconnect: { name: "gatewayDisconnect", handle: this.handleGatewayDisconnect.bind(this) },
-              gatewayInternalConnect: { name: "gatewayInternalConnect", handle: this.handleGatewayInternalConnect.bind(this) }
-          };
-          this.extContentAvailable = !!window.glue42ext;
-          this.setUpMessageListener();
-          this.setUpUnload();
-          this.setupPlatformUnloadListener();
-          this.parentType = window.name.includes("#wsp") ? "workspace" : undefined;
-      }
-      WebPlatformTransport.prototype.manualSetReadyState = function () {
-          this.iAmConnected = true;
-          this.parentReady = true;
-      };
-      Object.defineProperty(WebPlatformTransport.prototype, "transportWindowId", {
-          get: function () {
-              return this.publicWindowId;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Object.defineProperty(WebPlatformTransport.prototype, "communicationId", {
-          get: function () {
-              return this._communicationId;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      WebPlatformTransport.prototype.sendObject = function (msg) {
-          return __awaiter(this, void 0, void 0, function () {
-              return __generator(this, function (_a) {
-                  if (this.extContentConnected) {
-                      return [2, window.postMessage({ glue42ExtOut: msg }, this.defaultTargetString)];
-                  }
-                  if (!this.port) {
-                      throw new Error("Cannot send message, because the port was not opened yet");
-                  }
-                  this.port.postMessage(msg);
-                  return [2];
-              });
-          });
-      };
-      Object.defineProperty(WebPlatformTransport.prototype, "isObjectBasedTransport", {
-          get: function () {
-              return true;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      WebPlatformTransport.prototype.onMessage = function (callback) {
-          return this.registry.add("onMessage", callback);
-      };
-      WebPlatformTransport.prototype.send = function () {
-          return Promise.reject("not supported");
-      };
-      WebPlatformTransport.prototype.onConnectedChanged = function (callback) {
-          return this.registry.add("onConnectedChanged", callback);
-      };
-      WebPlatformTransport.prototype.open = function () {
-          return __awaiter(this, void 0, void 0, function () {
-              return __generator(this, function (_a) {
-                  switch (_a.label) {
-                      case 0:
-                          this.logger.debug("opening a connection to the web platform gateway.");
-                          return [4, this.connect()];
-                      case 1:
-                          _a.sent();
-                          this.notifyStatusChanged(true);
-                          return [2];
-                  }
+      };
+      Object.defineProperty(WebPlatformTransport.prototype, "isObjectBasedTransport", {
+          get: function () {
+              return true;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      WebPlatformTransport.prototype.onMessage = function (callback) {
+          return this.registry.add("onMessage", callback);
+      };
+      WebPlatformTransport.prototype.send = function () {
+          return Promise.reject("not supported");
+      };
+      WebPlatformTransport.prototype.onConnectedChanged = function (callback) {
+          return this.registry.add("onConnectedChanged", callback);
+      };
+      WebPlatformTransport.prototype.open = function () {
+          return __awaiter(this, void 0, void 0, function () {
+              return __generator(this, function (_a) {
+                  switch (_a.label) {
+                      case 0:
+                          this.logger.debug("opening a connection to the web platform gateway.");
+                          return [4, this.connect()];
+                      case 1:
+                          _a.sent();
+                          this.notifyStatusChanged(true);
+                          return [2];
+                  }
               });
           });
       };
@@ -2635,6 +2096,11 @@
               if (!data || _this.rejected) {
                   return;
               }
+              var allowedOrigins = _this.settings.allowedOrigins || [];
+              if (allowedOrigins.length && !allowedOrigins.includes(event.origin)) {
+                  _this.logger.warn("received a message from an origin which is not in the allowed list: ".concat(event.origin));
+                  return;
+              }
               if (!_this.checkMessageTypeValid(data.type)) {
                   _this.logger.error("cannot handle the incoming glue42 core message, because the type is invalid: ".concat(data.type));
                   return;
@@ -2742,6 +2208,11 @@
               if (!extData) {
                   return;
               }
+              var allowedOrigins = _this.settings.allowedOrigins || [];
+              if (allowedOrigins.length && !allowedOrigins.includes(event.origin)) {
+                  _this.logger.warn("received a message from an origin which is not in the allowed list: ".concat(event.origin));
+                  return;
+              }
               _this.registry.execute("onMessage", extData);
           });
           if (this.connectionResolve) {
@@ -3106,13 +2577,250 @@
           var _this = this;
           return new Promise(function (res) { return setTimeout(res, _this.minSequenceInterval); });
       };
-      return AsyncSequelizer;
-  }());
+      return AsyncSequelizer;
+  }());
+
+  function domainSession (domain, connection, logger, successMessages, errorMessages) {
+      if (domain == null) {
+          domain = "global";
+      }
+      successMessages = successMessages !== null && successMessages !== void 0 ? successMessages : ["success"];
+      errorMessages = errorMessages !== null && errorMessages !== void 0 ? errorMessages : ["error"];
+      var isJoined = domain === "global";
+      var tryReconnecting = false;
+      var _latestOptions;
+      var _connectionOn = false;
+      var callbacks = lib$1();
+      connection.disconnected(handleConnectionDisconnected);
+      connection.loggedIn(handleConnectionLoggedIn);
+      connection.on("success", function (msg) { return handleSuccessMessage(msg); });
+      connection.on("error", function (msg) { return handleErrorMessage(msg); });
+      connection.on("result", function (msg) { return handleSuccessMessage(msg); });
+      if (successMessages) {
+          successMessages.forEach(function (sm) {
+              connection.on(sm, function (msg) { return handleSuccessMessage(msg); });
+          });
+      }
+      if (errorMessages) {
+          errorMessages.forEach(function (sm) {
+              connection.on(sm, function (msg) { return handleErrorMessage(msg); });
+          });
+      }
+      var requestsMap = {};
+      function join(options) {
+          _latestOptions = options;
+          return new Promise(function (resolve, reject) {
+              if (isJoined) {
+                  resolve({});
+                  return;
+              }
+              var joinPromise;
+              if (domain === "global") {
+                  joinPromise = _connectionOn ? Promise.resolve({}) : Promise.reject("not connected to gateway");
+              }
+              else {
+                  logger.debug("joining domain ".concat(domain));
+                  var joinMsg = {
+                      type: "join",
+                      destination: domain,
+                      domain: "global",
+                      options: options,
+                  };
+                  joinPromise = send(joinMsg);
+              }
+              joinPromise
+                  .then(function () {
+                  handleJoined();
+                  resolve({});
+              })
+                  .catch(function (err) {
+                  logger.debug("error joining " + domain + " domain: " + JSON.stringify(err));
+                  reject(err);
+              });
+          });
+      }
+      function leave() {
+          if (domain === "global") {
+              return Promise.resolve();
+          }
+          logger.debug("stopping session " + domain + "...");
+          var leaveMsg = {
+              type: "leave",
+              destination: domain,
+              domain: "global",
+          };
+          tryReconnecting = false;
+          return send(leaveMsg)
+              .then(function () {
+              isJoined = false;
+              callbacks.execute("onLeft");
+          })
+              .catch(function () {
+              isJoined = false;
+              callbacks.execute("onLeft");
+          });
+      }
+      function handleJoined() {
+          logger.debug("did join " + domain);
+          isJoined = true;
+          var wasReconnect = tryReconnecting;
+          tryReconnecting = false;
+          callbacks.execute("onJoined", wasReconnect);
+      }
+      function handleConnectionDisconnected() {
+          _connectionOn = false;
+          logger.debug("connection is down");
+          isJoined = false;
+          tryReconnecting = true;
+          callbacks.execute("onLeft", { disconnected: true });
+      }
+      function handleConnectionLoggedIn() {
+          _connectionOn = true;
+          if (tryReconnecting) {
+              logger.debug("connection is now up - trying to reconnect...");
+              join(_latestOptions);
+          }
+      }
+      function onJoined(callback) {
+          if (isJoined) {
+              callback(false);
+          }
+          return callbacks.add("onJoined", callback);
+      }
+      function onLeft(callback) {
+          if (!isJoined) {
+              callback();
+          }
+          return callbacks.add("onLeft", callback);
+      }
+      function handleErrorMessage(msg) {
+          if (domain !== msg.domain) {
+              return;
+          }
+          var requestId = msg.request_id;
+          if (!requestId) {
+              return;
+          }
+          var entry = requestsMap[requestId];
+          if (!entry) {
+              return;
+          }
+          entry.error(msg);
+      }
+      function handleSuccessMessage(msg) {
+          if (msg.domain !== domain) {
+              return;
+          }
+          var requestId = msg.request_id;
+          if (!requestId) {
+              return;
+          }
+          var entry = requestsMap[requestId];
+          if (!entry) {
+              return;
+          }
+          entry.success(msg);
+      }
+      function getNextRequestId() {
+          return shortid();
+      }
+      var queuedCalls = [];
+      function send(msg, tag, options) {
+          var _a, _b;
+          var ignore = ["hello", "join"];
+          if (msg.type && ignore.indexOf(msg.type) === -1) {
+              if (!isJoined) {
+                  logger.warn("trying to send a message (".concat(msg.domain, " ").concat(msg.type, ") but not connected, will queue"));
+                  var pw = new PromiseWrapper();
+                  queuedCalls.push({ msg: msg, tag: tag, options: options, pw: pw });
+                  if (queuedCalls.length === 1) {
+                      var unsubscribe_1 = onJoined(function () {
+                          logger.info("joined - will now send queued messages (".concat(queuedCalls.length, " -> [").concat(queuedCalls.map(function (m) { return m.msg.type; }), "])"));
+                          queuedCalls.forEach(function (qm) {
+                              send(qm.msg, qm.tag, qm.options)
+                                  .then(function (t) { return qm.pw.resolve(t); })
+                                  .catch(function (e) { return qm.pw.reject(e); });
+                          });
+                          queuedCalls = [];
+                          unsubscribe_1();
+                      });
+                  }
+                  return pw.promise;
+              }
+          }
+          options = options !== null && options !== void 0 ? options : {};
+          msg.request_id = (_a = msg.request_id) !== null && _a !== void 0 ? _a : getNextRequestId();
+          msg.domain = (_b = msg.domain) !== null && _b !== void 0 ? _b : domain;
+          if (!options.skipPeerId) {
+              msg.peer_id = connection.peerId;
+          }
+          var requestId = msg.request_id;
+          return new Promise(function (resolve, reject) {
+              requestsMap[requestId] = {
+                  success: function (successMsg) {
+                      delete requestsMap[requestId];
+                      successMsg._tag = tag;
+                      resolve(successMsg);
+                  },
+                  error: function (errorMsg) {
+                      logger.warn("GW error - ".concat(JSON.stringify(errorMsg), " for request ").concat(JSON.stringify(msg)));
+                      delete requestsMap[requestId];
+                      errorMsg._tag = tag;
+                      reject(errorMsg);
+                  },
+              };
+              connection
+                  .send(msg, options)
+                  .catch(function (err) {
+                  requestsMap[requestId].error({ err: err });
+              });
+          });
+      }
+      function sendFireAndForget(msg) {
+          var _a;
+          msg.request_id = msg.request_id ? msg.request_id : getNextRequestId();
+          msg.domain = (_a = msg.domain) !== null && _a !== void 0 ? _a : domain;
+          msg.peer_id = connection.peerId;
+          return connection.send(msg);
+      }
+      return {
+          join: join,
+          leave: leave,
+          onJoined: onJoined,
+          onLeft: onLeft,
+          send: send,
+          sendFireAndForget: sendFireAndForget,
+          on: function (type, callback) {
+              connection.on(type, function (msg) {
+                  if (msg.domain !== domain) {
+                      return;
+                  }
+                  try {
+                      callback(msg);
+                  }
+                  catch (e) {
+                      logger.error("Callback  failed: ".concat(e, " \n ").concat(e.stack, " \n msg was: ").concat(JSON.stringify(msg)), e);
+                  }
+              });
+          },
+          loggedIn: function (callback) { return connection.loggedIn(callback); },
+          connected: function (callback) { return connection.connected(callback); },
+          disconnected: function (callback) { return connection.disconnected(callback); },
+          get peerId() {
+              return connection.peerId;
+          },
+          get domain() {
+              return domain;
+          },
+      };
+  }
 
   var Connection = (function () {
       function Connection(settings, logger) {
+          var _a, _b;
           this.settings = settings;
           this.logger = logger;
+          this.protocolVersion = 3;
           this.messageHandlers = {};
           this.ids = 1;
           this.registry = lib$1();
@@ -3121,10 +2829,19 @@
           this._swapTransport = false;
           this._switchInProgress = false;
           this._transportSubscriptions = [];
+          this.datePrefix = "#T42_DATE#";
+          this.datePrefixLen = this.datePrefix.length;
+          this.dateMinLen = this.datePrefixLen + 1;
+          this.datePrefixFirstChar = this.datePrefix[0];
           this._sequelizer = new AsyncSequelizer();
+          this._isLoggedIn = false;
+          this.shouldTryLogin = true;
+          this.sessions = [];
+          this.initialLogin = true;
+          this.initialLoginAttempts = 3;
           settings = settings || {};
-          settings.reconnectAttempts = settings.reconnectAttempts || 10;
-          settings.reconnectInterval = settings.reconnectInterval || 1000;
+          settings.reconnectAttempts = (_a = settings.reconnectAttempts) !== null && _a !== void 0 ? _a : 10;
+          settings.reconnectInterval = (_b = settings.reconnectInterval) !== null && _b !== void 0 ? _b : 1000;
           if (settings.inproc) {
               this.transport = new InProcTransport(settings.inproc, logger.subLogger("inMemory"));
           }
@@ -3142,21 +2859,13 @@
           }
           this.isTrace = logger.canPublish("trace");
           logger.debug("starting with ".concat(this.transport.name(), " transport"));
-          this.protocol = new GW3ProtocolImpl(this, settings, logger.subLogger("protocol"));
           var unsubConnectionChanged = this.transport.onConnectedChanged(this.handleConnectionChanged.bind(this));
           var unsubOnMessage = this.transport.onMessage(this.handleTransportMessage.bind(this));
           this._transportSubscriptions.push(unsubConnectionChanged);
           this._transportSubscriptions.push(unsubOnMessage);
           this._defaultTransport = this.transport;
+          this.ping();
       }
-      Object.defineProperty(Connection.prototype, "protocolVersion", {
-          get: function () {
-              var _a;
-              return (_a = this.protocol) === null || _a === void 0 ? void 0 : _a.protocolVersion;
-          },
-          enumerable: false,
-          configurable: true
-      });
       Connection.prototype.switchTransport = function (settings) {
           return __awaiter(this, void 0, void 0, function () {
               var _this = this;
@@ -3204,239 +2913,555 @@
                           });
                       }); })];
               });
-          });
+          });
+      };
+      Connection.prototype.onLibReAnnounced = function (callback) {
+          return this.registry.add("libReAnnounced", callback);
+      };
+      Connection.prototype.setLibReAnnounced = function (lib) {
+          this.registry.execute("libReAnnounced", lib);
+      };
+      Connection.prototype.send = function (message, options) {
+          if (this.transport.sendObject &&
+              this.transport.isObjectBasedTransport) {
+              var msg = this.createObjectMessage(message);
+              if (this.isTrace) {
+                  this.logger.trace(">> ".concat(JSON.stringify(msg)));
+              }
+              return this.transport.sendObject(msg, options);
+          }
+          else {
+              var strMessage = this.createStringMessage(message);
+              if (this.isTrace) {
+                  this.logger.trace(">> ".concat(strMessage));
+              }
+              return this.transport.send(strMessage, options);
+          }
+      };
+      Connection.prototype.on = function (type, messageHandler) {
+          type = type.toLowerCase();
+          if (this.messageHandlers[type] === undefined) {
+              this.messageHandlers[type] = {};
+          }
+          var id = this.ids++;
+          this.messageHandlers[type][id] = messageHandler;
+          return {
+              type: type,
+              id: id,
+          };
+      };
+      Connection.prototype.off = function (info) {
+          delete this.messageHandlers[info.type.toLowerCase()][info.id];
+      };
+      Object.defineProperty(Connection.prototype, "isConnected", {
+          get: function () {
+              return this._isLoggedIn;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Connection.prototype.connected = function (callback) {
+          var _this = this;
+          return this.loggedIn(function () {
+              var currentServer = _this.transport.name();
+              callback(currentServer);
+          });
+      };
+      Connection.prototype.disconnected = function (callback) {
+          return this.registry.add("disconnected", callback);
+      };
+      Connection.prototype.login = function (authRequest, reconnect) {
+          return __awaiter(this, void 0, void 0, function () {
+              var newAuth, identity, error_2;
+              return __generator(this, function (_a) {
+                  switch (_a.label) {
+                      case 0:
+                          if (!this._defaultAuth) {
+                              this._defaultAuth = authRequest;
+                          }
+                          if (this._swapTransport) {
+                              this.logger.trace("Detected a transport swap, swapping transports");
+                              newAuth = this.transportSwap();
+                              authRequest = newAuth !== null && newAuth !== void 0 ? newAuth : authRequest;
+                          }
+                          this.logger.trace("Starting login for transport: ".concat(this.transport.name(), " and auth ").concat(JSON.stringify(authRequest)));
+                          _a.label = 1;
+                      case 1:
+                          _a.trys.push([1, 4, , 5]);
+                          return [4, this.transport.open()];
+                      case 2:
+                          _a.sent();
+                          this.logger.trace("Transport: ".concat(this.transport.name(), " opened, logging in"));
+                          timer("connection").mark("transport-opened");
+                          return [4, this.loginCore(authRequest, reconnect)];
+                      case 3:
+                          identity = _a.sent();
+                          this.logger.trace("Logged in with identity: ".concat(JSON.stringify(identity)));
+                          timer("connection").mark("protocol-logged-in");
+                          return [2, identity];
+                      case 4:
+                          error_2 = _a.sent();
+                          if (this._switchInProgress) {
+                              this.logger.trace("An error while logging in after a transport swap, preparing a default swap.");
+                              this.prepareDefaultSwap();
+                          }
+                          throw new Error(error_2);
+                      case 5: return [2];
+                  }
+              });
+          });
+      };
+      Connection.prototype.logout = function () {
+          return __awaiter(this, void 0, void 0, function () {
+              return __generator(this, function (_a) {
+                  switch (_a.label) {
+                      case 0: return [4, this.logoutCore()];
+                      case 1:
+                          _a.sent();
+                          return [4, this.transport.close()];
+                      case 2:
+                          _a.sent();
+                          return [2];
+                  }
+              });
+          });
+      };
+      Connection.prototype.loggedIn = function (callback) {
+          if (this._isLoggedIn) {
+              callback();
+          }
+          return this.registry.add("onLoggedIn", callback);
+      };
+      Connection.prototype.domain = function (domain, successMessages, errorMessages) {
+          var session = this.sessions.find(function (s) { return s.domain === domain; });
+          if (!session) {
+              session = domainSession(domain, this, this.logger.subLogger("domain=".concat(domain)), successMessages, errorMessages);
+              this.sessions.push(session);
+          }
+          return session;
+      };
+      Connection.prototype.authToken = function () {
+          var createTokenReq = {
+              domain: "global",
+              type: "create-token"
+          };
+          if (!this.globalDomain) {
+              return Promise.reject(new Error("no global domain session"));
+          }
+          return this.globalDomain.send(createTokenReq)
+              .then(function (res) {
+              return res.token;
+          });
+      };
+      Connection.prototype.reconnect = function () {
+          return this.transport.reconnect();
+      };
+      Connection.prototype.setLoggedIn = function (value) {
+          this._isLoggedIn = value;
+          if (this._isLoggedIn) {
+              this.registry.execute("onLoggedIn");
+          }
+      };
+      Connection.prototype.distributeMessage = function (message, type) {
+          var _this = this;
+          var handlers = this.messageHandlers[type.toLowerCase()];
+          if (handlers !== undefined) {
+              Object.keys(handlers).forEach(function (handlerId) {
+                  var handler = handlers[handlerId];
+                  if (handler !== undefined) {
+                      try {
+                          handler(message);
+                      }
+                      catch (error) {
+                          try {
+                              _this.logger.error("Message handler failed with ".concat(error.stack), error);
+                          }
+                          catch (loggerError) {
+                              console.log("Message handler failed", error);
+                          }
+                      }
+                  }
+              });
+          }
+      };
+      Connection.prototype.handleConnectionChanged = function (connected) {
+          var _a, _b;
+          if (this._connected === connected) {
+              return;
+          }
+          this._connected = connected;
+          if (connected) {
+              if ((_b = (_a = this.settings) === null || _a === void 0 ? void 0 : _a.replaySpecs) === null || _b === void 0 ? void 0 : _b.length) {
+                  this.replayer = new MessageReplayerImpl(this.settings.replaySpecs);
+                  this.replayer.init(this);
+              }
+              this.registry.execute("connected");
+          }
+          else {
+              this.handleDisconnected();
+              this.registry.execute("disconnected");
+          }
+      };
+      Connection.prototype.handleDisconnected = function () {
+          var _this = this;
+          this.setLoggedIn(false);
+          var tryToLogin = this.shouldTryLogin;
+          if (tryToLogin && this.initialLogin) {
+              if (this.initialLoginAttempts <= 0) {
+                  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(function () {
+                  setTimeout(_this.handleDisconnected.bind(_this), _this.settings.reconnectInterval || 1000);
+              });
+          }
+      };
+      Connection.prototype.handleTransportMessage = function (msg) {
+          var msgObj;
+          if (typeof msg === "string") {
+              msgObj = this.processStringMessage(msg);
+          }
+          else {
+              msgObj = this.processObjectMessage(msg);
+          }
+          if (this.isTrace) {
+              this.logger.trace("<< ".concat(JSON.stringify(msgObj)));
+          }
+          this.distributeMessage(msgObj.msg, msgObj.msgType);
+      };
+      Connection.prototype.verifyConnection = function () {
+          var _this = this;
+          return PromisePlus$1(function (resolve) {
+              var unsub;
+              var ready = waitForInvocations(2, function () {
+                  if (unsub) {
+                      unsub();
+                  }
+                  resolve();
+              });
+              unsub = _this.onLibReAnnounced(function (lib) {
+                  if (lib.name === "interop") {
+                      return ready();
+                  }
+                  if (lib.name === "contexts") {
+                      return ready();
+                  }
+              });
+          }, 10000, "Transport switch timed out waiting for all libraries to be re-announced");
       };
-      Connection.prototype.onLibReAnnounced = function (callback) {
-          return this.registry.add("libReAnnounced", callback);
+      Connection.prototype.getNewSecondaryTransport = function (settings) {
+          var _a;
+          if (!((_a = settings.transportConfig) === null || _a === void 0 ? void 0 : _a.url)) {
+              throw new Error("Missing secondary transport URL.");
+          }
+          return new WS(Object.assign({}, this.settings, { ws: settings.transportConfig.url, reconnectAttempts: 1 }), this.logger.subLogger("ws-secondary"));
       };
-      Connection.prototype.setLibReAnnounced = function (lib) {
-          this.registry.execute("libReAnnounced", lib);
+      Connection.prototype.getNewSecondaryAuth = function (settings) {
+          var _a;
+          if (!((_a = settings.transportConfig) === null || _a === void 0 ? void 0 : _a.auth)) {
+              throw new Error("Missing secondary transport auth information.");
+          }
+          return settings.transportConfig.auth;
       };
-      Connection.prototype.send = function (message, options) {
-          if (this.transport.sendObject &&
-              this.transport.isObjectBasedTransport) {
-              var msg = this.protocol.createObjectMessage(message);
-              if (this.isTrace) {
-                  this.logger.trace(">> ".concat(JSON.stringify(msg)));
-              }
-              return this.transport.sendObject(msg, options);
+      Connection.prototype.transportSwap = function () {
+          this._swapTransport = false;
+          if (!this._targetTransport || !this._targetAuth) {
+              this.logger.warn("Error while switching transports - either the target transport or auth is not defined: transport defined -> ".concat(!!this._defaultTransport, ", auth defined -> ").concat(!!this._targetAuth, ". Staying on the current one."));
+              return;
           }
-          else {
-              var strMessage = this.protocol.createStringMessage(message);
-              if (this.isTrace) {
-                  this.logger.trace(">> ".concat(strMessage));
+          this._transportSubscriptions.forEach(function (unsub) { return unsub(); });
+          this._transportSubscriptions = [];
+          this.transport = this._targetTransport;
+          var unsubConnectionChanged = this.transport.onConnectedChanged(this.handleConnectionChanged.bind(this));
+          var unsubOnMessage = this.transport.onMessage(this.handleTransportMessage.bind(this));
+          this._transportSubscriptions.push(unsubConnectionChanged);
+          this._transportSubscriptions.push(unsubOnMessage);
+          return this._targetAuth;
+      };
+      Connection.prototype.prepareDefaultSwap = function () {
+          var _this = this;
+          this._transportSubscriptions.forEach(function (unsub) { return unsub(); });
+          this._transportSubscriptions = [];
+          this.transport.close().catch(function (error) { return _this.logger.warn("Error closing the ".concat(_this.transport.name(), " transport after a failed connection attempt: ").concat(JSON.stringify(error))); });
+          this._targetTransport = this._defaultTransport;
+          this._targetAuth = this._defaultAuth;
+          this._swapTransport = true;
+      };
+      Connection.prototype.processStringMessage = function (message) {
+          var _this = this;
+          var msg = JSON.parse(message, function (key, value) {
+              if (typeof value !== "string") {
+                  return value;
               }
-              return this.transport.send(strMessage, options);
+              if (value.length < _this.dateMinLen) {
+                  return value;
+              }
+              if (!value.startsWith(_this.datePrefixFirstChar)) {
+                  return value;
+              }
+              if (value.substring(0, _this.datePrefixLen) !== _this.datePrefix) {
+                  return value;
+              }
+              try {
+                  var milliseconds = parseInt(value.substring(_this.datePrefixLen, value.length), 10);
+                  if (isNaN(milliseconds)) {
+                      return value;
+                  }
+                  return new Date(milliseconds);
+              }
+              catch (ex) {
+                  return value;
+              }
+          });
+          return {
+              msg: msg,
+              msgType: msg.type,
+          };
+      };
+      Connection.prototype.createStringMessage = function (message) {
+          var oldToJson = Date.prototype.toJSON;
+          try {
+              var datePrefix_1 = this.datePrefix;
+              Date.prototype.toJSON = function () {
+                  return datePrefix_1 + this.getTime();
+              };
+              var result = JSON.stringify(message);
+              return result;
+          }
+          finally {
+              Date.prototype.toJSON = oldToJson;
           }
       };
-      Connection.prototype.on = function (type, messageHandler) {
-          type = type.toLowerCase();
-          if (this.messageHandlers[type] === undefined) {
-              this.messageHandlers[type] = {};
+      Connection.prototype.processObjectMessage = function (message) {
+          if (!message.type) {
+              throw new Error("Object should have type property");
           }
-          var id = this.ids++;
-          this.messageHandlers[type][id] = messageHandler;
           return {
-              type: type,
-              id: id,
+              msg: message,
+              msgType: message.type,
           };
       };
-      Connection.prototype.off = function (info) {
-          delete this.messageHandlers[info.type.toLowerCase()][info.id];
-      };
-      Object.defineProperty(Connection.prototype, "isConnected", {
-          get: function () {
-              return this.protocol.isLoggedIn;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      Connection.prototype.connected = function (callback) {
-          var _this = this;
-          return this.protocol.loggedIn(function () {
-              var currentServer = _this.transport.name();
-              callback(currentServer);
-          });
-      };
-      Connection.prototype.disconnected = function (callback) {
-          return this.registry.add("disconnected", callback);
+      Connection.prototype.createObjectMessage = function (message) {
+          return message;
       };
-      Connection.prototype.login = function (authRequest, reconnect) {
+      Connection.prototype.loginCore = function (config, reconnect) {
           return __awaiter(this, void 0, void 0, function () {
-              var newAuth, identity, error_2;
+              var authentication, helloMsg, sendOptions, welcomeMsg, err_1;
               return __generator(this, function (_a) {
                   switch (_a.label) {
                       case 0:
-                          if (!this._defaultAuth) {
-                              this._defaultAuth = authRequest;
+                          this.logger.info("logging in...");
+                          this.loginConfig = config;
+                          if (!this.loginConfig) {
+                              this.loginConfig = { username: "", password: "" };
                           }
-                          if (this._swapTransport) {
-                              this.logger.trace("Detected a transport swap, swapping transports");
-                              newAuth = this.transportSwap();
-                              authRequest = newAuth !== null && newAuth !== void 0 ? newAuth : authRequest;
+                          this.shouldTryLogin = true;
+                          return [4, this.setupAuthConfig(config, reconnect)];
+                      case 1:
+                          authentication = _a.sent();
+                          helloMsg = {
+                              type: "hello",
+                              identity: this.settings.identity,
+                              authentication: authentication
+                          };
+                          if (config.sessionId) {
+                              helloMsg.request_id = config.sessionId;
                           }
-                          this.logger.trace("Starting login for transport: ".concat(this.transport.name(), " and auth ").concat(JSON.stringify(authRequest)));
-                          _a.label = 1;
+                          this.globalDomain = domainSession("global", this, this.logger.subLogger("global-domain"), [
+                              "welcome",
+                              "token",
+                              "authentication-request"
+                          ]);
+                          sendOptions = { skipPeerId: true };
+                          if (this.initialLogin) {
+                              sendOptions.retryInterval = this.settings.reconnectInterval;
+                              sendOptions.maxRetries = this.settings.reconnectAttempts;
+                          }
+                          _a.label = 2;
+                      case 2:
+                          _a.trys.push([2, 4, 5, 6]);
+                          return [4, this.tryAuthenticate(this.globalDomain, helloMsg, sendOptions, config)];
+                      case 3:
+                          welcomeMsg = _a.sent();
+                          this.initialLogin = false;
+                          this.logger.info("login successful with peerId " + welcomeMsg.peer_id);
+                          this.peerId = welcomeMsg.peer_id;
+                          this.resolvedIdentity = welcomeMsg.resolved_identity;
+                          this.availableDomains = welcomeMsg.available_domains;
+                          if (welcomeMsg.options) {
+                              this.token = welcomeMsg.options.access_token;
+                              this.info = welcomeMsg.options.info;
+                          }
+                          this.setLoggedIn(true);
+                          return [2, welcomeMsg.resolved_identity];
+                      case 4:
+                          err_1 = _a.sent();
+                          this.logger.error("error sending hello message - " + (err_1.message || err_1.msg || err_1.reason || err_1), err_1);
+                          throw err_1;
+                      case 5:
+                          if ((config === null || config === void 0 ? void 0 : config.flowCallback) && config.sessionId) {
+                              config.flowCallback(config.sessionId, null);
+                          }
+                          return [7];
+                      case 6: return [2];
+                  }
+              });
+          });
+      };
+      Connection.prototype.tryAuthenticate = function (globalDomain, helloMsg, sendOptions, config) {
+          return __awaiter(this, void 0, void 0, function () {
+              var welcomeMsg, msg, token, _a;
+              return __generator(this, function (_b) {
+                  switch (_b.label) {
+                      case 0:
+                          return [4, globalDomain.send(helloMsg, undefined, sendOptions)];
                       case 1:
-                          _a.trys.push([1, 4, , 5]);
-                          return [4, this.transport.open()];
+                          msg = _b.sent();
+                          if (!(msg.type === "authentication-request")) return [3, 4];
+                          token = Buffer.from(msg.authentication.token, "base64");
+                          if (!(config.flowCallback && config.sessionId)) return [3, 3];
+                          _a = helloMsg.authentication;
+                          return [4, config.flowCallback(config.sessionId, token)];
                       case 2:
-                          _a.sent();
-                          this.logger.trace("Transport: ".concat(this.transport.name(), " opened, logging in"));
-                          timer("connection").mark("transport-opened");
-                          return [4, this.protocol.login(authRequest, reconnect)];
+                          _a.token =
+                              (_b.sent())
+                                  .data
+                                  .toString("base64");
+                          _b.label = 3;
                       case 3:
-                          identity = _a.sent();
-                          this.logger.trace("Logged in with identity: ".concat(JSON.stringify(identity)));
-                          timer("connection").mark("protocol-logged-in");
-                          return [2, identity];
+                          helloMsg.request_id = config.sessionId;
+                          return [3, 5];
                       case 4:
-                          error_2 = _a.sent();
-                          if (this._switchInProgress) {
-                              this.logger.trace("An error while logging in after a transport swap, preparing a default swap.");
-                              this.prepareDefaultSwap();
+                          if (msg.type === "welcome") {
+                              welcomeMsg = msg;
+                              return [3, 6];
+                          }
+                          else if (msg.type === "error") {
+                              throw new Error("Authentication failed: " + msg.reason);
+                          }
+                          else {
+                              throw new Error("Unexpected message type during authentication: " + msg.type);
+                          }
+                      case 5: return [3, 0];
+                      case 6: return [2, welcomeMsg];
+                  }
+              });
+          });
+      };
+      Connection.prototype.setupAuthConfig = function (config, reconnect) {
+          return __awaiter(this, void 0, void 0, function () {
+              var authentication, _a, e_1, _b;
+              return __generator(this, function (_c) {
+                  switch (_c.label) {
+                      case 0:
+                          authentication = {};
+                          this.gatewayToken = config.gatewayToken;
+                          if (!config.gatewayToken) return [3, 5];
+                          if (!reconnect) return [3, 4];
+                          _c.label = 1;
+                      case 1:
+                          _c.trys.push([1, 3, , 4]);
+                          _a = config;
+                          return [4, this.getNewGWToken()];
+                      case 2:
+                          _a.gatewayToken = _c.sent();
+                          return [3, 4];
+                      case 3:
+                          e_1 = _c.sent();
+                          this.logger.warn("failed to get GW token when reconnecting ".concat((e_1 === null || e_1 === void 0 ? void 0 : e_1.message) || e_1));
+                          return [3, 4];
+                      case 4:
+                          authentication.method = "gateway-token";
+                          authentication.token = config.gatewayToken;
+                          this.gatewayToken = config.gatewayToken;
+                          return [3, 10];
+                      case 5:
+                          if (!(config.flowName === "sspi")) return [3, 9];
+                          authentication.provider = "win";
+                          authentication.method = "access-token";
+                          if (!(config.flowCallback && config.sessionId)) return [3, 7];
+                          _b = authentication;
+                          return [4, config.flowCallback(config.sessionId, null)];
+                      case 6:
+                          _b.token =
+                              (_c.sent())
+                                  .data
+                                  .toString("base64");
+                          return [3, 8];
+                      case 7: throw new Error("Invalid SSPI config");
+                      case 8: return [3, 10];
+                      case 9:
+                          if (config.token) {
+                              authentication.method = "access-token";
+                              authentication.token = config.token;
+                          }
+                          else if (config.username) {
+                              authentication.method = "secret";
+                              authentication.login = config.username;
+                              authentication.secret = config.password;
                           }
-                          throw new Error(error_2);
-                      case 5: return [2];
+                          else if (config.provider) {
+                              authentication.provider = config.provider;
+                              authentication.providerContext = config.providerContext;
+                          }
+                          else {
+                              throw new Error("invalid auth message" + JSON.stringify(config));
+                          }
+                          _c.label = 10;
+                      case 10: return [2, authentication];
                   }
               });
           });
       };
-      Connection.prototype.logout = function () {
+      Connection.prototype.logoutCore = function () {
           return __awaiter(this, void 0, void 0, function () {
+              var promises;
               return __generator(this, function (_a) {
                   switch (_a.label) {
-                      case 0: return [4, this.protocol.logout()];
+                      case 0:
+                          this.logger.debug("logging out...");
+                          this.shouldTryLogin = false;
+                          if (this.pingTimer) {
+                              clearTimeout(this.pingTimer);
+                          }
+                          promises = this.sessions.map(function (session) {
+                              session.leave();
+                          });
+                          return [4, Promise.all(promises)];
                       case 1:
-                          _a.sent();
-                          return [4, this.transport.close()];
-                      case 2:
                           _a.sent();
                           return [2];
                   }
               });
           });
       };
-      Connection.prototype.loggedIn = function (callback) {
-          return this.protocol.loggedIn(callback);
-      };
-      Connection.prototype.domain = function (domain, successMessages, errorMessages) {
-          return this.protocol.domain(domain, this.logger.subLogger("domain=".concat(domain)), successMessages, errorMessages);
-      };
-      Connection.prototype.authToken = function () {
-          return this.protocol.authToken();
-      };
-      Connection.prototype.reconnect = function () {
-          return this.transport.reconnect();
-      };
-      Connection.prototype.distributeMessage = function (message, type) {
-          var _this = this;
-          var handlers = this.messageHandlers[type.toLowerCase()];
-          if (handlers !== undefined) {
-              Object.keys(handlers).forEach(function (handlerId) {
-                  var handler = handlers[handlerId];
-                  if (handler !== undefined) {
-                      try {
-                          handler(message);
-                      }
-                      catch (error) {
-                          try {
-                              _this.logger.error("Message handler failed with ".concat(error.stack), error);
-                          }
-                          catch (loggerError) {
-                              console.log("Message handler failed", error);
-                          }
-                      }
-                  }
-              });
-          }
-      };
-      Connection.prototype.handleConnectionChanged = function (connected) {
-          if (this._connected === connected) {
-              return;
-          }
-          this._connected = connected;
-          if (connected) {
-              if (this.settings.replaySpecs && this.settings.replaySpecs.length) {
-                  this.replayer = new MessageReplayerImpl(this.settings.replaySpecs);
-                  this.replayer.init(this);
+      Connection.prototype.getNewGWToken = function () {
+          if (typeof window !== "undefined") {
+              var glue42gd = window.glue42gd;
+              if (glue42gd) {
+                  return glue42gd.getGWToken();
               }
-              this.registry.execute("connected");
-          }
-          else {
-              this.registry.execute("disconnected");
-          }
-      };
-      Connection.prototype.handleTransportMessage = function (msg) {
-          var msgObj;
-          if (typeof msg === "string") {
-              msgObj = this.protocol.processStringMessage(msg);
-          }
-          else {
-              msgObj = this.protocol.processObjectMessage(msg);
           }
-          if (this.isTrace) {
-              this.logger.trace("<< ".concat(JSON.stringify(msgObj)));
-          }
-          this.distributeMessage(msgObj.msg, msgObj.msgType);
+          return Promise.reject(new Error("not running in GD"));
       };
-      Connection.prototype.verifyConnection = function () {
+      Connection.prototype.ping = function () {
           var _this = this;
-          return PromisePlus$1(function (resolve) {
-              var unsub;
-              var ready = waitForInvocations(2, function () {
-                  if (unsub) {
-                      unsub();
-                  }
-                  resolve();
-              });
-              unsub = _this.onLibReAnnounced(function (lib) {
-                  if (lib.name === "interop") {
-                      return ready();
-                  }
-                  if (lib.name === "contexts") {
-                      return ready();
-                  }
-              });
-          }, 10000, "Transport switch timed out waiting for all libraries to be re-announced");
-      };
-      Connection.prototype.getNewSecondaryTransport = function (settings) {
-          var _a;
-          if (!((_a = settings.transportConfig) === null || _a === void 0 ? void 0 : _a.url)) {
-              throw new Error("Missing secondary transport URL.");
-          }
-          return new WS(Object.assign({}, this.settings, { ws: settings.transportConfig.url, reconnectAttempts: 1 }), this.logger.subLogger("ws-secondary"));
-      };
-      Connection.prototype.getNewSecondaryAuth = function (settings) {
-          var _a;
-          if (!((_a = settings.transportConfig) === null || _a === void 0 ? void 0 : _a.auth)) {
-              throw new Error("Missing secondary transport auth information.");
-          }
-          return settings.transportConfig.auth;
-      };
-      Connection.prototype.transportSwap = function () {
-          this._swapTransport = false;
-          if (!this._targetTransport || !this._targetAuth) {
-              this.logger.warn("Error while switching transports - either the target transport or auth is not defined: transport defined -> ".concat(!!this._defaultTransport, ", auth defined -> ").concat(!!this._targetAuth, ". Staying on the current one."));
+          if (!this.shouldTryLogin) {
               return;
           }
-          this._transportSubscriptions.forEach(function (unsub) { return unsub(); });
-          this._transportSubscriptions = [];
-          this.transport = this._targetTransport;
-          var unsubConnectionChanged = this.transport.onConnectedChanged(this.handleConnectionChanged.bind(this));
-          var unsubOnMessage = this.transport.onMessage(this.handleTransportMessage.bind(this));
-          this._transportSubscriptions.push(unsubConnectionChanged);
-          this._transportSubscriptions.push(unsubOnMessage);
-          return this._targetAuth;
-      };
-      Connection.prototype.prepareDefaultSwap = function () {
-          var _this = this;
-          this._transportSubscriptions.forEach(function (unsub) { return unsub(); });
-          this._transportSubscriptions = [];
-          this.transport.close().catch(function (error) { return _this.logger.warn("Error closing the ".concat(_this.transport.name(), " transport after a failed connection attempt: ").concat(JSON.stringify(error))); });
-          this._targetTransport = this._defaultTransport;
-          this._targetAuth = this._defaultAuth;
-          this._swapTransport = true;
+          if (this._isLoggedIn) {
+              this.send({ type: "ping" });
+          }
+          this.pingTimer = setTimeout(function () {
+              _this.ping();
+          }, 30 * 1000);
       };
       return Connection;
   }());
@@ -3619,7 +3644,7 @@
       }
   };
 
-  var version$2 = "6.1.0";
+  var version$2 = "6.2.1";
 
   function prepareConfig$1 (configuration, ext, glue42gd) {
       var _a, _b, _c, _d;
@@ -5895,7 +5920,7 @@
                           currentContext = _b.sent();
                           _b.label = 4;
                       case 4:
-                          calculatedDelta = this.protocolVersion === 2 ?
+                          calculatedDelta = this.setPathSupported ?
                               this.calculateContextDeltaV2(currentContext, delta) :
                               this.calculateContextDeltaV1(currentContext, delta);
                           if (!Object.keys(calculatedDelta.added).length
@@ -7400,41 +7425,46 @@
           return this.registerCore(methodDefinition, wrappedCallbackFunction);
       };
       Server.prototype.registerAsync = function (methodDefinition, callback) {
+          var _this = this;
           if (!methodDefinition) {
               return Promise.reject("Method definition is required. Please, provide either a unique string for a method name or a “methodDefinition” object with a required “name” property.");
           }
           if (typeof callback !== "function") {
               return Promise.reject("The second parameter must be a callback function. Method: ".concat(typeof methodDefinition === "string" ? methodDefinition : methodDefinition.name));
           }
-          var wrappedCallback = function (context, resultCallback) {
-              try {
-                  var resultCalled_1 = false;
-                  var success = function (result) {
-                      if (!resultCalled_1) {
-                          resultCallback(undefined, result);
-                      }
-                      resultCalled_1 = true;
-                  };
-                  var error = function (e) {
-                      if (!resultCalled_1) {
-                          if (!e) {
-                              e = "";
+          var wrappedCallback = function (context, resultCallback) { return __awaiter(_this, void 0, void 0, function () {
+              var resultCalled_1, success, error, methodResult;
+              return __generator(this, function (_a) {
+                  try {
+                      resultCalled_1 = false;
+                      success = function (result) {
+                          if (!resultCalled_1) {
+                              resultCallback(undefined, result);
                           }
-                          resultCallback(e, e);
+                          resultCalled_1 = true;
+                      };
+                      error = function (e) {
+                          if (!resultCalled_1) {
+                              if (!e) {
+                                  e = "";
+                              }
+                              resultCallback(e, e);
+                          }
+                          resultCalled_1 = true;
+                      };
+                      methodResult = callback(context.args, context.instance, success, error);
+                      if (methodResult && typeof methodResult.then === "function") {
+                          methodResult
+                              .then(success)
+                              .catch(error);
                       }
-                      resultCalled_1 = true;
-                  };
-                  var methodResult = callback(context.args, context.instance, success, error);
-                  if (methodResult && typeof methodResult.then === "function") {
-                      methodResult
-                          .then(success)
-                          .catch(error);
                   }
-              }
-              catch (e) {
-                  resultCallback(e, undefined);
-              }
-          };
+                  catch (e) {
+                      resultCallback(e, undefined);
+                  }
+                  return [2];
+              });
+          }); };
           wrappedCallback.userCallbackAsync = callback;
           return this.registerCore(methodDefinition, wrappedCallback);
       };
@@ -7545,7 +7575,7 @@
                               return [2, Promise.reject("Please, provide a (unique) string value for the \u201Cname\u201D property in the \u201CmethodDefinition\u201D object: ".concat(JSON.stringify(method)))];
                           }
                           unregisterInProgress = this.currentlyUnregistering[methodDefinition.name];
-                          if (!unregisterInProgress) return [3, 2];
+                          if (!(typeof unregisterInProgress !== "undefined")) return [3, 2];
                           return [4, unregisterInProgress];
                       case 1:
                           _a.sent();
@@ -8875,10 +8905,11 @@
       var server = new ServerProtocol(session, clientRepository, serverRepository, logger.subLogger("server"));
       var client = new ClientProtocol(session, clientRepository, logger.subLogger("client"));
       function handleReconnect() {
+          var _a, _b;
           return __awaiter(this, void 0, void 0, function () {
-              var reconnectionPromises, existingSubscriptions, _loop_1, _i, existingSubscriptions_1, sub, registeredMethods, _loop_2, _a, registeredMethods_1, method;
-              return __generator(this, function (_b) {
-                  switch (_b.label) {
+              var reconnectionPromises, existingSubscriptions, _loop_1, _i, existingSubscriptions_1, sub, registeredMethods, _loop_2, _c, registeredMethods_1, method;
+              return __generator(this, function (_d) {
+                  switch (_d.label) {
                       case 0:
                           logger.info("reconnected - will replay registered methods and subscriptions");
                           client.drainSubscriptionsCache().forEach(function (sub) {
@@ -8903,25 +8934,29 @@
                           serverRepository.reset();
                           _loop_2 = function (method) {
                               var def = method.definition;
-                              logger.info("re-publishing method ".concat(def.name));
                               if (method.stream) {
-                                  reconnectionPromises.push(interop.server.createStream(def, method.streamCallbacks, undefined, undefined, method.stream).then(function () { return logger.info("subscribing to method ".concat(def.name, " DONE")); }));
+                                  reconnectionPromises.push(interop.server.createStream(def, method.streamCallbacks, undefined, undefined, method.stream)
+                                      .then(function () { return logger.info("subscribing to method ".concat(def.name, " DONE")); })
+                                      .catch(function () { return logger.warn("subscribing to method ".concat(def.name, " FAILED")); }));
                               }
-                              else if (method.theFunction && method.theFunction.userCallback) {
-                                  reconnectionPromises.push(interop.register(def, method.theFunction.userCallback).then(function () { return logger.info("subscribing to method ".concat(def.name, " DONE")); }));
+                              else if ((_a = method === null || method === void 0 ? void 0 : method.theFunction) === null || _a === void 0 ? void 0 : _a.userCallback) {
+                                  reconnectionPromises.push(interop.register(def, method.theFunction.userCallback)
+                                      .then(function () { return logger.info("registering method ".concat(def.name, " DONE")); })
+                                      .catch(function () { return logger.warn("registering method ".concat(def.name, " FAILED")); }));
                               }
-                              else if (method.theFunction && method.theFunction.userCallbackAsync) {
-                                  reconnectionPromises.push(interop.registerAsync(def, method.theFunction.userCallbackAsync).then(function () { return logger.info("subscribing to method ".concat(def.name, " DONE")); }));
+                              else if ((_b = method === null || method === void 0 ? void 0 : method.theFunction) === null || _b === void 0 ? void 0 : _b.userCallbackAsync) {
+                                  reconnectionPromises.push(interop.registerAsync(def, method.theFunction.userCallbackAsync)
+                                      .then(function () { return logger.info("registering method ".concat(def.name, " DONE")); })
+                                      .catch(function () { return logger.warn("registering method ".concat(def.name, " FAILED")); }));
                               }
-                              logger.info("re-publishing method ".concat(def.name, " DONE"));
                           };
-                          for (_a = 0, registeredMethods_1 = registeredMethods; _a < registeredMethods_1.length; _a++) {
-                              method = registeredMethods_1[_a];
+                          for (_c = 0, registeredMethods_1 = registeredMethods; _c < registeredMethods_1.length; _c++) {
+                              method = registeredMethods_1[_c];
                               _loop_2(method);
                           }
                           return [4, Promise.all(reconnectionPromises)];
                       case 1:
-                          _b.sent();
+                          _d.sent();
                           logger.info("Interop is re-announced");
                           return [2];
                   }
@@ -12381,6 +12416,7 @@
   const StartApplicationMethodName = "T42.ACS.StartApplication";
   const StopApplicationMethodName = "T42.ACS.StopApplication";
   const ActivateApplicationMethodName = "T42.ACS.ActivateApplication";
+  const ACSExecute = "T42.ACS.Execute";
   const OnEventMethodName = "T42.ACS.OnEvent";
   const GetApplicationsMethodName = "T42.ACS.GetApplications";
 
@@ -12966,6 +13002,10 @@
       getContext() {
           return Promise.resolve(this.context);
       }
+      async startedBy() {
+          const result = await this._agm.invoke(ACSExecute, { command: "getStartedBy", Name: this._appName, Id: this._id });
+          return result.returned;
+      }
   }
 
   class AppManagerImpl {
@@ -13022,8 +13062,9 @@
               return undefined;
           };
           this.getMyApplication = () => {
+              var _a;
               if (this._agm.instance) {
-                  return this.application(this._agm.instance.applicationName);
+                  return (_a = this.application(this._agm.instance.applicationName)) !== null && _a !== void 0 ? _a : this.application(this._agm.instance.application);
               }
           };
           this.handleSnapshotAppsAdded = (newApps) => {
@@ -15892,20 +15933,15 @@
           }, "TabHeaderVisibilityChanged");
           return w;
       }
+      async showGroupPopup(id, options) {
+          const reformatedOptions = this.showPopupCore(id, options);
+          await this.executeGroup("showGroupPopup", {
+              groupId: id,
+              options: reformatedOptions
+          });
+      }
       async showPopup(targetWindow, options) {
-          if (!options) {
-              throw new Error("The options object is not valid!");
-          }
-          const optionsCopy = { ...options };
-          if (!optionsCopy.targetLocation) {
-              optionsCopy.targetLocation = "bottom";
-          }
-          const reformatedOptions = {
-              ...optionsCopy,
-              popupBounds: optionsCopy.size,
-              targetId: targetWindow.id,
-              popupId: optionsCopy.windowId
-          };
+          const reformatedOptions = this.showPopupCore(targetWindow.id, options);
           await this.execute("showPopupWindow", {
               windowId: targetWindow.id,
               options: reformatedOptions
@@ -16402,16 +16438,33 @@
               return context;
           }
       }
+      showPopupCore(id, options) {
+          if (!options) {
+              throw new Error("The options object is not valid!");
+          }
+          const optionsCopy = { ...options };
+          if (!optionsCopy.targetLocation) {
+              optionsCopy.targetLocation = "bottom";
+          }
+          const reformatedOptions = {
+              ...optionsCopy,
+              popupBounds: optionsCopy.size,
+              targetId: id,
+              popupId: optionsCopy.windowId
+          };
+          return reformatedOptions;
+      }
   }
   var executor = new GDExecutor();
 
   class GDEnvironment {
-      constructor(agm, logger, appManagerGetter, displayAPIGetter, channelsAPIGetter, wndId) {
+      constructor(agm, logger, appManagerGetter, displayAPIGetter, channelsAPIGetter, wndId, groupId) {
           this._registry = lib();
           this._waitTimeout = 10000;
           this._agm = agm;
           this._logger = logger.subLogger("gd-env");
           this._windowId = wndId;
+          this._groupId = groupId;
           this._appManagerGetter = appManagerGetter;
           this._displayAPIGetter = displayAPIGetter;
           this._channelsAPIGetter = channelsAPIGetter;
@@ -16486,6 +16539,9 @@
       my() {
           return this._windowId;
       }
+      myGroup() {
+          return this._groupId;
+      }
       execute(command, windowId, options) {
           return this._agm.invoke("T42.Wnd.Execute", {
               command,
@@ -16780,6 +16836,7 @@
   }
 
   var envDetector = (agm, logger, appManagerGetter, displayAPIGetter, channelsAPIGetter, gdMajorVersion) => {
+      var _a;
       const _logger = logger;
       if (gdMajorVersion === 2) {
           _logger.trace("running in HC");
@@ -16787,7 +16844,7 @@
       }
       else if (gdMajorVersion >= 3) {
           _logger.trace("running in GD 3");
-          return new GDEnvironment(agm, _logger, appManagerGetter, displayAPIGetter, channelsAPIGetter, window.glue42gd.windowId).init();
+          return new GDEnvironment(agm, _logger, appManagerGetter, displayAPIGetter, channelsAPIGetter, window.glue42gd.windowId, (_a = window.webGroupsManager) === null || _a === void 0 ? void 0 : _a.id).init();
       }
       else {
           return new GDEnvironment(agm, _logger, appManagerGetter, displayAPIGetter, channelsAPIGetter).init();
@@ -16979,6 +17036,14 @@
                   groupId: id
               });
           },
+          close: () => {
+              return executor.executeGroup("closeGroup", {
+                  groupId: id
+              });
+          },
+          showPopup: (options) => {
+              return executor.showGroupPopup(id, options);
+          },
           onHeaderVisibilityChanged,
           onWindowAdded,
           onWindowRemoved,
@@ -17045,20 +17110,55 @@
       environment.onGroupStateChanged((data) => {
           const groupWrapper = _groups[data.groupId];
           if (data.state === "hibernated") {
-              if (groupWrapper && groupWrapper.groupAPI) {
+              if (groupWrapper === null || groupWrapper === void 0 ? void 0 : groupWrapper.groupAPI) {
                   groupWrapper.groupInternal.handleGroupHibernateChanged(true);
               }
               _registry.execute("group-hibernated", data.groupId);
           }
           else if (data.state === "resumed") {
-              if (groupWrapper && groupWrapper.groupAPI) {
+              if (groupWrapper === null || groupWrapper === void 0 ? void 0 : groupWrapper.groupAPI) {
                   groupWrapper.groupInternal.handleGroupHibernateChanged(false);
               }
               _registry.execute("group-resumed", groupWrapper.groupAPI);
           }
       });
       function my() {
-          return findGroupByWindow(environment.my());
+          var _a;
+          return findGroupByWindow((_a = environment.myGroup()) !== null && _a !== void 0 ? _a : environment.my());
+      }
+      async function create(options) {
+          if (isUndefinedOrNull(options)) {
+              throw new Error(`options must be defined`);
+          }
+          if (isUndefinedOrNull(options.groups) || !Array.isArray(options.groups) || options.groups.length === 0) {
+              throw new Error(`options.groups must be defined`);
+          }
+          const { groupIds } = await executor.executeGroup("createGroups", {
+              options
+          });
+          const groups = groupIds.map((groupId) => {
+              return waitForGroup(groupId);
+          });
+          return Promise.all(groups);
+      }
+      async function close(idOrGroup, options) {
+          if (isUndefinedOrNull(idOrGroup)) {
+              throw new Error(`group must be defined`);
+          }
+          let groupId = "";
+          if (typeof idOrGroup === "string") {
+              groupId = idOrGroup;
+          }
+          else {
+              groupId = idOrGroup.id;
+          }
+          if (isUndefinedOrNull(options)) {
+              throw new Error(`options must be defined`);
+          }
+          await executor.executeGroup("closeGroup", {
+              groupId,
+              options
+          });
       }
       function list(success) {
           const result = Object.keys(_groups).map((groupId) => {
@@ -17090,15 +17190,13 @@
               }
               return result.groupAPI;
           }
-          else {
-              if (typeof error === "function") {
-                  error(`Cannot find the group of the window.`);
-              }
+          else if (typeof error === "function") {
+              error(`Cannot find the group of the window.`);
           }
       }
       function waitForGroup(groupId) {
           if (!groupId) {
-              return Promise.reject(`groupId must be defined`);
+              return Promise.reject(new Error(`groupId must be defined`));
           }
           return new Promise((res, rej) => {
               const groupWrapper = _groups[groupId];
@@ -17115,6 +17213,10 @@
               }
           });
       }
+      function getMyGroup() {
+          var _a;
+          return waitForGroup((_a = environment.myGroup()) !== null && _a !== void 0 ? _a : environment.my());
+      }
       async function resume(groupId, activate) {
           if (!isUndefinedOrNull(activate) && !isBoolean(activate)) {
               throw new Error("Activate flag must be a boolean!");
@@ -17236,9 +17338,12 @@
           get my() {
               return my();
           },
+          create,
+          close,
           list,
           findGroupByWindow,
           waitForGroup,
+          getMyGroup,
           onGroupAdded,
           onGroupRemoved,
           hibernate,
@@ -18401,6 +18506,36 @@
           data: { newChannel: channel }
       });
   }
+  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;
+  }
+  async function getRestrictionsByWindow(id) {
+      try {
+          const result = await interop.invoke(T42_ANNOUNCE_METHOD_NAME, {
+              swId: id !== null && id !== void 0 ? id : windowId,
+              command: "getRestrictions"
+          });
+          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;
+  }
   async function getWindowsWithChannels(filter) {
       const result = await interop.invoke(T42_ANNOUNCE_METHOD_NAME, { command: "getChannelsInfo", data: { filter } });
       return result.returned;
@@ -18541,19 +18676,25 @@
           }
           const id = Utils.generateId();
           this.pendingReplays[id] = true;
+          const callbackWithPermissionCheck = async (data, context, updaterId) => {
+              const canRead = await this.canReadFromChannel(context.name);
+              if (canRead) {
+                  callback(data, context, updaterId);
+              }
+          };
           if (this.lastUpdate) {
               let lastUpdate = Object.assign({}, this.lastUpdate);
-              setTimeout(() => {
+              setTimeout(async () => {
                   if (this.pendingReplays[id]) {
                       if (this.lastUpdate) {
                           lastUpdate = this.lastUpdate;
                       }
-                      callback(lastUpdate.context.data, lastUpdate.context, lastUpdate.updaterId);
+                      callbackWithPermissionCheck(lastUpdate.context.data, lastUpdate.context, lastUpdate.updaterId);
                   }
                   delete this.pendingReplays[id];
               }, 0);
           }
-          const unsub = this.registry.add(this.subsKey, callback);
+          const unsub = this.registry.add(this.subsKey, callbackWithPermissionCheck);
           return () => {
               this.pendingReplays[id] = false;
               unsub();
@@ -18580,11 +18721,17 @@
               if (!this.shared.isChannel(name)) {
                   return Promise.reject(new Error(`A channel with name: ${name} doesn't exist!`));
               }
+              if (!await this.canWriteToChannel(name)) {
+                  throw new Error(`Window does not have permission to write to channel ${name}`);
+              }
               return this.shared.updateData(name, data);
           }
           if (!this.currentContext) {
               throw new Error("Not joined to any channel!");
           }
+          if (!await this.canWriteToChannel(this.currentContext)) {
+              throw new Error(`Window does not have permission to write to channel ${this.currentContext}`);
+          }
           return this.shared.updateData(this.currentContext, data);
       }
       all() {
@@ -18712,6 +18859,15 @@
           }
           return [];
       }
+      async restrict(restriction) {
+          return setRestrictions(restriction);
+      }
+      async getRestrictions(windowId) {
+          return getRestrictionsByWindow(windowId);
+      }
+      async restrictAll(restriction) {
+          return setRestrictionsForAllChannels(restriction);
+      }
       handler(data, context, updaterId) {
           if (!context && !updaterId) {
               this.lastUpdate = undefined;
@@ -18766,6 +18922,22 @@
           }
           return Promise.resolve();
       }
+      async canReadFromChannel(channelName) {
+          const restrictions = await getRestrictionsByWindow();
+          if (!restrictions || !Array.isArray(restrictions.channels) || !restrictions.channels.find(c => c.name === channelName)) {
+              return true;
+          }
+          const byChannel = restrictions.channels.find(c => c.name === channelName);
+          return byChannel.read;
+      }
+      async canWriteToChannel(channelName) {
+          const restrictions = await getRestrictionsByWindow();
+          if (!restrictions || !Array.isArray(restrictions.channels) || !restrictions.channels.find(c => c.name === channelName)) {
+              return true;
+          }
+          const byChannel = restrictions.channels.find(c => c.name === channelName);
+          return byChannel.write;
+      }
   }
 
   function factory$4(contexts, agm, getWindows, logger) {
@@ -18781,6 +18953,9 @@
           get: channels.get.bind(channels),
           join: channels.join.bind(channels),
           leave: channels.leave.bind(channels),
+          restrict: channels.restrict.bind(channels),
+          getRestrictions: channels.getRestrictions.bind(channels),
+          restrictAll: channels.restrictAll.bind(channels),
           current: channels.current.bind(channels),
           my: channels.my.bind(channels),
           changed: channels.changed.bind(channels),
@@ -18884,7 +19059,7 @@
       };
   }
 
-  var version = "6.2.2";
+  var version = "6.4.0";
 
   var prepareConfig = (options) => {
       function getLibConfig(value, defaultMode, trueMode) {
@@ -19034,13 +19209,14 @@
           this.subscriptionsCountForCounter = 0;
           this.logger = logger.subLogger("notifications");
           this._panel = new PanelAPI(interop, this.onStreamEventCore.bind(this));
+          this._panelAPI = this._panel.toAPI();
           this.subscribeInternalEvents();
       }
       get maxActions() {
           return 2;
       }
       get panel() {
-          return this._panel.toAPI();
+          return this._panelAPI;
       }
       async raise(options) {
           var _a, _b, _c, _d;
@@ -19147,7 +19323,7 @@
           return result.returned;
       }
       async list() {
-          const interopResult = await this.interop.invoke(this.NotificationsExecuteMethod, { command: "list" });
+          const interopResult = await this.interop.invoke(this.NotificationsExecuteMethod, { command: "list", data: { statesVersion2: true } });
           return interopResult.returned.notifications;
       }
       async updateData(id, data) {
@@ -19207,7 +19383,7 @@
           await this.interop.invoke(this.NotificationsExecuteMethod, { command: "clearAll" });
       }
       async clearOld() {
-          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "clearAllOld" });
+          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "clearAllOld", data: { statesVersion2: true } });
       }
       async clear(id) {
           if (!id) {
@@ -19221,6 +19397,9 @@
       async click(id, action, options) {
           await this.interop.invoke(this.NotificationsExecuteMethod, { command: "click", data: { id, action, options } });
       }
+      async snooze(id, duration) {
+          await this.interop.invoke(this.NotificationsExecuteMethod, { command: "snooze", data: { id, duration } });
+      }
       async setState(id, state) {
           if (!id) {
               throw new Error("The 'id' argument cannot be null or undefined");
@@ -19256,6 +19435,7 @@
               click: this.click.bind(this),
               setState: this.setState.bind(this),
               updateData: this.updateData.bind(this),
+              snooze: this.snooze.bind(this)
           };
       }
       onStreamEventCore(key, callback) {
@@ -19366,7 +19546,8 @@
               this.interop
                   .subscribe(this.NotificationsSubscribeStream, {
                   arguments: {
-                      sendDeltaOnly: true
+                      sendDeltaOnly: true,
+                      statesVersion2: true
                   }
               })
                   .then((sub) => {
@@ -20390,7 +20571,7 @@
           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 });
+          const result = await this.interop.invoke("T42.ACS.StartApplication", { Name: application, options: { ...options, startedByIntentAPI: true } });
           return result.returned.Id;
       }
       subscribeOnInstanceStopped(instance, method) {
@@ -20919,7 +21100,7 @@
       }
       function createPrefs(core) {
           var _a, _b;
-          const appName = (_b = (_a = options.application) !== null && _a !== void 0 ? _a : glue42gd === null || glue42gd === void 0 ? void 0 : glue42gd.application) !== null && _b !== void 0 ? _b : core.interop.instance.application;
+          const appName = (_b = (_a = options.application) !== null && _a !== void 0 ? _a : glue42gd === null || glue42gd === void 0 ? void 0 : glue42gd.applicationName) !== null && _b !== void 0 ? _b : core.interop.instance.application;
           const prefs = new Prefs(appName, core.interop);
           debugLog(prefs);
           return prefs;