@interopio/desktop 6.2.2 → 6.4.0

package/dist/desktop.es.js

@@ -1315,6 +1315,7 @@ var WS = (function () {
             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;
@@ -1352,9 +1353,10 @@ var WS = (function () {
     };
     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 {
@@ -1373,11 +1375,12 @@ var WS = (function () {
                 };
                 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);
         };
@@ -1412,6 +1415,80 @@ var WS = (function () {
     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; },
@@ -1760,743 +1837,127 @@ var isValid = isShortId;
 
 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];
+                }
             });
         });
     };
@@ -2629,6 +2090,11 @@ var WebPlatformTransport = (function () {
             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;
@@ -2736,6 +2202,11 @@ var WebPlatformTransport = (function () {
             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) {
@@ -3100,13 +2571,250 @@ var AsyncSequelizer = (function () {
         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();
@@ -3115,10 +2823,19 @@ var Connection = (function () {
         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"));
         }
@@ -3136,21 +2853,13 @@ var Connection = (function () {
         }
         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;
@@ -3198,239 +2907,555 @@ var Connection = (function () {
                         });
                     }); })];
             });
-        });
+        });
+    };
+    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;
 }());
@@ -3613,7 +3638,7 @@ var ContextMessageReplaySpec = {
     }
 };
 
-var version$2 = "6.1.0";
+var version$2 = "6.2.1";
 
 function prepareConfig$1 (configuration, ext, glue42gd) {
     var _a, _b, _c, _d;
@@ -5889,7 +5914,7 @@ var GW3Bridge$1 = (function () {
                         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
@@ -7394,41 +7419,46 @@ var Server = (function () {
         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);
     };
@@ -7539,7 +7569,7 @@ var Server = (function () {
                             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();
@@ -8869,10 +8899,11 @@ function gW3ProtocolFactory (instance, connection, clientRepository, serverRepos
     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) {
@@ -8897,25 +8928,29 @@ function gW3ProtocolFactory (instance, connection, clientRepository, serverRepos
                         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];
                 }
@@ -12375,6 +12410,7 @@ const CanIMethodName = "T42.ACS.CanI";
 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";
 
@@ -12960,6 +12996,10 @@ class InstanceImpl {
     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 {
@@ -13016,8 +13056,9 @@ class AppManagerImpl {
             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) => {
@@ -15886,20 +15927,15 @@ class GDExecutor {
         }, "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
@@ -16396,16 +16432,33 @@ class GDExecutor {
             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;
@@ -16480,6 +16533,9 @@ class GDEnvironment {
     my() {
         return this._windowId;
     }
+    myGroup() {
+        return this._groupId;
+    }
     execute(command, windowId, options) {
         return this._agm.invoke("T42.Wnd.Execute", {
             command,
@@ -16774,6 +16830,7 @@ class GDEnvironment {
 }
 
 var envDetector = (agm, logger, appManagerGetter, displayAPIGetter, channelsAPIGetter, gdMajorVersion) => {
+    var _a;
     const _logger = logger;
     if (gdMajorVersion === 2) {
         _logger.trace("running in HC");
@@ -16781,7 +16838,7 @@ var envDetector = (agm, logger, appManagerGetter, displayAPIGetter, channelsAPIG
     }
     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();
@@ -16973,6 +17030,14 @@ var groupFactory = (id, executor) => {
                 groupId: id
             });
         },
+        close: () => {
+            return executor.executeGroup("closeGroup", {
+                groupId: id
+            });
+        },
+        showPopup: (options) => {
+            return executor.showGroupPopup(id, options);
+        },
         onHeaderVisibilityChanged,
         onWindowAdded,
         onWindowRemoved,
@@ -17039,20 +17104,55 @@ var groupsFactory = (environment, logger) => {
     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) => {
@@ -17084,15 +17184,13 @@ var groupsFactory = (environment, logger) => {
             }
             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];
@@ -17109,6 +17207,10 @@ var groupsFactory = (environment, logger) => {
             }
         });
     }
+    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!");
@@ -17230,9 +17332,12 @@ var groupsFactory = (environment, logger) => {
         get my() {
             return my();
         },
+        create,
+        close,
         list,
         findGroupByWindow,
         waitForGroup,
+        getMyGroup,
         onGroupAdded,
         onGroupRemoved,
         hibernate,
@@ -18395,6 +18500,36 @@ async function switchChannel(channel, id) {
         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;
@@ -18535,19 +18670,25 @@ class ChannelsImpl {
         }
         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();
@@ -18574,11 +18715,17 @@ class ChannelsImpl {
             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() {
@@ -18706,6 +18853,15 @@ class ChannelsImpl {
         }
         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;
@@ -18760,6 +18916,22 @@ class ChannelsImpl {
         }
         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) {
@@ -18775,6 +18947,9 @@ function factory$4(contexts, agm, getWindows, logger) {
         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),
@@ -18878,7 +19053,7 @@ function factory$3(agm) {
     };
 }
 
-var version = "6.2.2";
+var version = "6.4.0";
 
 var prepareConfig = (options) => {
     function getLibConfig(value, defaultMode, trueMode) {
@@ -19028,13 +19203,14 @@ class Notifications {
         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;
@@ -19141,7 +19317,7 @@ class Notifications {
         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) {
@@ -19201,7 +19377,7 @@ class Notifications {
         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) {
@@ -19215,6 +19391,9 @@ class Notifications {
     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");
@@ -19250,6 +19429,7 @@ class Notifications {
             click: this.click.bind(this),
             setState: this.setState.bind(this),
             updateData: this.updateData.bind(this),
+            snooze: this.snooze.bind(this)
         };
     }
     onStreamEventCore(key, callback) {
@@ -19360,7 +19540,8 @@ class Notifications {
             this.interop
                 .subscribe(this.NotificationsSubscribeStream, {
                 arguments: {
-                    sendDeltaOnly: true
+                    sendDeltaOnly: true,
+                    statesVersion2: true
                 }
             })
                 .then((sub) => {
@@ -20384,7 +20565,7 @@ class Intents {
         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) {
@@ -20913,7 +21094,7 @@ const factoryCore = async (options, glue42gd) => {
     }
     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;