@codingame/monaco-vscode-api 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/devTunnelsModule.js

@@ -18387,7 +18387,6 @@ var require_tunnelProtocol = __commonJS({
             TunnelProtocol2["Auto"] = "auto";
             TunnelProtocol2["Tcp"] = "tcp";
             TunnelProtocol2["Udp"] = "udp";
-            TunnelProtocol2["Ssh"] = "ssh";
             TunnelProtocol2["Rdp"] = "rdp";
             TunnelProtocol2["Http"] = "http";
             TunnelProtocol2["Https"] = "https";
@@ -18831,7 +18830,7 @@ var require_package2 = __commonJS({
     "node_modules/@microsoft/dev-tunnels-management/package.json"(exports, module) {
         module.exports = {
             name: "@microsoft/dev-tunnels-management",
-            version: "1.3.55",
+            version: "1.3.61",
             description: "Tunnels library for Visual Studio tools",
             keywords: ["Tunnels"],
             author: "Microsoft",
@@ -18840,7 +18839,7 @@ var require_package2 = __commonJS({
                 buffer: "^5.2.1",
                 debug: "^4.1.1",
                 "vscode-jsonrpc": "^4.0.0",
-                "@microsoft/dev-tunnels-contracts": "1.3.55",
+                "@microsoft/dev-tunnels-contracts": "1.3.61",
                 axios: "^1.8.4"
             },
             main: "./index.js"
@@ -18884,22 +18883,82 @@ var require_axios = __commonJS({
                 hasOwnProperty: hasOwnProperty2
             }
         ) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
+        var isUnsafeObjectKey = prop => typeof prop === "string" && (prop === "__proto__" || prop === "constructor" || prop === "prototype");
+        var isPrototypeBoundary = (obj, prototype2, source) => obj === Object.prototype || !source && prototype2 === null;
+        var isSafeAndFullyMutable = obj => {
+            if (!Object.isExtensible(obj)) {
+                return false;
+            }
+            const props = Object.getOwnPropertyNames(obj);
+            if (Object.getOwnPropertySymbols) {
+                props.push(...Object.getOwnPropertySymbols(obj));
+            }
+            return props.every(prop => {
+                if (isUnsafeObjectKey(prop)) {
+                    return false;
+                }
+                const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+                return !!descriptor && descriptor.configurable && descriptor.writable === true;
+            });
+        };
         var hasOwnInPrototypeChain = (thing, prop) => {
             let obj = thing;
             const seen = [];
-            while (obj != null && obj !== Object.prototype) {
+            while (obj != null) {
                 if (seen.indexOf(obj) !== -1) {
                     return false;
                 }
                 seen.push(obj);
+                const prototype2 = getPrototypeOf(obj);
+                if (isPrototypeBoundary(obj, prototype2, obj === thing)) {
+                    return false;
+                }
                 if (hasOwnProperty(obj, prop)) {
                     return true;
                 }
-                obj = getPrototypeOf(obj);
+                obj = prototype2;
             }
             return false;
         };
         var getSafeProp = (obj, prop) => obj != null && hasOwnInPrototypeChain(obj, prop) ? obj[prop] : void 0;
+        var toSafeFlatObject = thing => {
+            if (thing == null || typeof thing !== "object" && typeof thing !== "function") {
+                return thing;
+            }
+            const sourcePrototype = getPrototypeOf(thing);
+            if (sourcePrototype === null && isSafeAndFullyMutable(thing)) {
+                return thing;
+            }
+            const result =  Object.create(null);
+            const merged =  Object.create(null);
+            const seen = [];
+            let current = thing;
+            while (current != null) {
+                if (seen.indexOf(current) !== -1) {
+                    break;
+                }
+                seen.push(current);
+                const prototype2 = current === thing ? sourcePrototype : getPrototypeOf(current);
+                if (isPrototypeBoundary(current, prototype2, current === thing)) {
+                    break;
+                }
+                const props = Object.getOwnPropertyNames(current);
+                if (Object.getOwnPropertySymbols) {
+                    props.push(...Object.getOwnPropertySymbols(current));
+                }
+                for (const prop of props) {
+                    if (isUnsafeObjectKey(prop)) {
+                        continue;
+                    }
+                    if (!hasOwnProperty(merged, prop)) {
+                        result[prop] = thing[prop];
+                        merged[prop] = true;
+                    }
+                }
+                current = prototype2;
+            }
+            return result;
+        };
         var kindOf =  (cache => thing => {
             const str = toString.call(thing);
             return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
@@ -18959,6 +19018,7 @@ var require_axios = __commonJS({
         var isReactNative = formData => formData && typeof formData.getParts !== "undefined";
         var isBlob = kindOfTest("Blob");
         var isFileList = kindOfTest("FileList");
+        var isSet = kindOfTest("Set");
         var isStream = val => isObject(val) && isFunction$1(val.pipe);
         function getGlobal() {
             if (typeof globalThis !== "undefined")
@@ -19277,11 +19337,20 @@ var require_axios = __commonJS({
                     }
                     if (!("toJSON" in source)) {
                         visited.add(source);
-                        const target = isArray(source) ? [] : {};
-                        forEach(source, (value, key) => {
-                            const reducedValue = visit(value);
-                            !isUndefined(reducedValue) && (target[key] = reducedValue);
-                        });
+                        let target;
+                        if (isSet(source)) {
+                            target = [];
+                            for (const value of source) {
+                                const reducedValue = visit(value);
+                                !isUndefined(reducedValue) && target.push(reducedValue);
+                            }
+                        } else {
+                            target = isArray(source) ? [] : {};
+                            forEach(source, (value, key) => {
+                                const reducedValue = visit(value);
+                                !isUndefined(reducedValue) && (target[key] = reducedValue);
+                            });
+                        }
                         visited.delete(source);
                         return target;
                     }
@@ -19362,6 +19431,7 @@ var require_axios = __commonJS({
             hasOwnProp: hasOwnProperty,
             hasOwnInPrototypeChain,
             getSafeProp,
+            toSafeFlatObject,
             reduceDescriptors,
             freezeMethods,
             toObjectSet,
@@ -19408,17 +19478,18 @@ var require_axios = __commonJS({
                 i = line.indexOf(":");
                 key = line.substring(0, i).trim().toLowerCase();
                 val = line.substring(i + 1).trim();
-                if (!key || parsed[key] && ignoreDuplicateOf[key]) {
+                const hasKey = utils$1.hasOwnProp(parsed, key);
+                if (!key || hasKey && utils$1.hasOwnProp(ignoreDuplicateOf, key)) {
                     return;
                 }
                 if (key === "set-cookie") {
-                    if (parsed[key]) {
+                    if (hasKey) {
                         parsed[key].push(val);
                     } else {
                         parsed[key] = [val];
                     }
                 } else {
-                    parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
+                    parsed[key] = hasKey ? parsed[key] + ", " + val : val;
                 }
             });
             return parsed;
@@ -19459,7 +19530,7 @@ var require_axios = __commonJS({
             });
             return byteStringHeaders;
         }
-        var $internals =  Symbol("internals");
+        var $internals$1 =  Symbol("internals");
         function normalizeHeader(header) {
             return header && String(header).trim().toLowerCase();
         }
@@ -19478,6 +19549,90 @@ var require_axios = __commonJS({
             }
             return tokens;
         }
+        var parameterNameRE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+        function trimOWS(value) {
+            let start = 0;
+            let end = value.length;
+            while (start < end) {
+                const code = value.charCodeAt(start);
+                if (code !== 9 && code !== 32) {
+                    break;
+                }
+                start += 1;
+            }
+            while (end > start) {
+                const code = value.charCodeAt(end - 1);
+                if (code !== 9 && code !== 32) {
+                    break;
+                }
+                end -= 1;
+            }
+            return start === 0 && end === value.length ? value : value.slice(start, end);
+        }
+        function decodeQuotedString(value) {
+            const last = value.length - 1;
+            if (last < 1 || value.charCodeAt(0) !== 34 || value.charCodeAt(last) !== 34) {
+                return value;
+            }
+            let decoded = "";
+            for (let i = 1; i < last; i++) {
+                const code = value.charCodeAt(i);
+                if (code === 34) {
+                    return value;
+                }
+                if (code === 92) {
+                    i += 1;
+                    if (i >= last) {
+                        return value;
+                    }
+                }
+                decoded += value[i];
+            }
+            return decoded;
+        }
+        function parseParameters(value) {
+            const parameters =  Object.create(null);
+            const str = String(value);
+            let start = 0;
+            let quoted = false;
+            let escaped = false;
+            function parseParameter(end) {
+                const part = trimOWS(str.slice(start, end));
+                const equals = part.indexOf("=");
+                if (equals < 1) {
+                    return;
+                }
+                const name = trimOWS(part.slice(0, equals));
+                if (!parameterNameRE.test(name)) {
+                    return;
+                }
+                const normalizedName = name.toLowerCase();
+                if (normalizedName === "__proto__" || normalizedName === "constructor" || normalizedName === "prototype") {
+                    return;
+                }
+                const parameterValue = trimOWS(part.slice(equals + 1));
+                parameters[normalizedName] = decodeQuotedString(parameterValue);
+            }
+            for (let i = 0; i < str.length; i++) {
+                const code = str.charCodeAt(i);
+                if (quoted) {
+                    if (escaped) {
+                        escaped = false;
+                    } else if (code === 92) {
+                        escaped = true;
+                    } else if (code === 34) {
+                        quoted = false;
+                    }
+                } else if (code === 34) {
+                    quoted = true;
+                } else if (code === 44 || code === 59) {
+                    parseParameter(i);
+                    start = i + 1;
+                }
+            }
+            parseParameter(str.length);
+            return parameters;
+        }
         var isValidHeaderName = str => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
         function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
             if (utils$1.isFunction(filter)) {
@@ -19652,7 +19807,8 @@ var require_axios = __commonJS({
                 return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join("\n");
             }
             getSetCookie() {
-                return this.get("set-cookie") || [];
+                const value = this.get("set-cookie");
+                return utils$1.isArray(value) ? value : value == null || value === false ? [] : [value];
             }
             get [Symbol.toStringTag]() {
                 return "AxiosHeaders";
@@ -19660,13 +19816,16 @@ var require_axios = __commonJS({
             static from(thing) {
                 return thing instanceof this ? thing : new this(thing);
             }
+            static parseParameters(value) {
+                return parseParameters(value);
+            }
             static concat(first, ...targets) {
                 const computed = new this(first);
                 targets.forEach(target => computed.set(target));
                 return computed;
             }
             static accessor(header) {
-                const internals = this[$internals] = this[$internals] = {
+                const internals = this[$internals$1] = this[$internals$1] = {
                     accessors: {}
                 };
                 const accessors = internals.accessors;
@@ -19760,9 +19919,30 @@ var require_axios = __commonJS({
             };
             return visit(config);
         }
+        function stringifySafely$1(value) {
+            try {
+                return String(value);
+            } catch (err) {
+                return "";
+            }
+        }
+        function aggregateErrorMessage(error) {
+            const message = error.errors.map(entry => {
+                try {
+                    return entry && entry.message ? stringifySafely$1(entry.message) : stringifySafely$1(entry);
+                } catch (err) {
+                    return "";
+                }
+            }).filter(Boolean).join("; ");
+            return message || error.name || "AggregateError";
+        }
         var AxiosError = class _AxiosError extends Error {
             static from(error, code, config, request, response, customProps) {
-                const axiosError = ( new _AxiosError(error.message, code || error.code, config, request, response));
+                let message = error.message;
+                if (!message && utils$1.isArray(error.errors) && error.errors.length) {
+                    message = aggregateErrorMessage(error);
+                }
+                const axiosError = ( new _AxiosError(message, code || error.code, config, request, response));
                 Object.defineProperty(axiosError, "cause", {
                     __proto__: null,
                     value: error,
@@ -19856,19 +20036,16 @@ var require_axios = __commonJS({
                 throw ( new TypeError("target must be an object"));
             }
             formData = formData || ( new FormData());
-            options = utils$1.toFlatObject(options, {
-                metaTokens: true,
-                dots: false,
-                indexes: false
-            }, false, function defined(option, source) {
-                return !utils$1.isUndefined(source[option]);
-            });
-            const metaTokens = options.metaTokens;
-            const visitor = options.visitor || defaultVisitor;
-            const dots = options.dots;
-            const indexes = options.indexes;
-            const _Blob = options.Blob || typeof Blob !== "undefined" && Blob;
-            const maxDepth = options.maxDepth === void 0 ? DEFAULT_FORM_DATA_MAX_DEPTH : options.maxDepth;
+            const option = (name, fallback) => {
+                const value = utils$1.getSafeProp(options, name);
+                return utils$1.isUndefined(value) ? fallback : value;
+            };
+            const metaTokens = option("metaTokens", true);
+            const visitor = option("visitor") || defaultVisitor;
+            const dots = option("dots", false);
+            const indexes = option("indexes", false);
+            const _Blob = option("Blob") || typeof Blob !== "undefined" && Blob;
+            const maxDepth = option("maxDepth", DEFAULT_FORM_DATA_MAX_DEPTH);
             const useBlob = _Blob && utils$1.isSpecCompliantForm(formData);
             const stack = [];
             if (!utils$1.isFunction(visitor)) {
@@ -19890,9 +20067,6 @@ var require_axios = __commonJS({
                     if (useBlob && typeof _Blob === "function") {
                         return ( new _Blob([value]));
                     }
-                    if (typeof import_buffer.Buffer !== "undefined") {
-                        return import_buffer.Buffer.from(value);
-                    }
                     throw ( new AxiosError("Blob is not supported. Use a Buffer instead.", AxiosError.ERR_NOT_SUPPORT));
                 }
                 return value;
@@ -20035,35 +20209,108 @@ var require_axios = __commonJS({
             }
             return url;
         }
+        var $internals =  Symbol("internals");
+        function countHandlers(handlers) {
+            return handlers ? handlers.length : 0;
+        }
+        function trimHandlers(handlers) {
+            if (!handlers) {
+                return;
+            }
+            while (handlers.length && handlers[handlers.length - 1] === null) {
+                handlers.pop();
+            }
+        }
+        function syncHandlerEntries(manager, internals) {
+            const handlers = manager.handlers;
+            const length = countHandlers(handlers);
+            if (handlers !== internals.handlersRef) {
+                internals.handlersRef = handlers;
+                internals.handlerEntries.clear();
+            } else if (length !== internals.handlersLength) {
+                if (!length) {
+                    internals.handlerEntries.clear();
+                } else {
+                    internals.handlerEntries.forEach(function removeStaleEntry(entry, id) {
+                        if (handlers[entry.index] !== entry.handler) {
+                            internals.handlerEntries.delete(id);
+                        }
+                    });
+                }
+            }
+            internals.handlersLength = length;
+        }
         var InterceptorManager = class {
             constructor() {
                 this.handlers = [];
+                this[$internals] = {
+                    handlersRef: this.handlers,
+                    handlersLength: this.handlers.length,
+                    handlerEntries: (  new Map()),
+                    iterationDepth: 0,
+                    nextId: 0
+                };
             }
             use(fulfilled, rejected, options) {
-                this.handlers.push({
+                const handler = {
                     fulfilled,
                     rejected,
                     synchronous: options ? options.synchronous : false,
                     runWhen: options ? options.runWhen : null
+                };
+                const internals = this[$internals];
+                if (this.handlers == null) {
+                    this.handlers = [];
+                }
+                syncHandlerEntries(this, internals);
+                const id = internals.nextId++;
+                this.handlers.push(handler);
+                internals.handlerEntries.set(id, {
+                    handler,
+                    index: this.handlers.length - 1
                 });
-                return this.handlers.length - 1;
+                internals.handlersLength = this.handlers.length;
+                return id;
             }
             eject(id) {
-                if (this.handlers[id]) {
-                    this.handlers[id] = null;
+                const internals = this[$internals];
+                syncHandlerEntries(this, internals);
+                const entry = internals.handlerEntries.get(id);
+                if (entry) {
+                    internals.handlerEntries.delete(id);
+                    if (this.handlers[entry.index] !== entry.handler) {
+                        return;
+                    }
+                    this.handlers[entry.index] = null;
+                    if (!internals.iterationDepth) {
+                        trimHandlers(this.handlers);
+                        internals.handlersLength = this.handlers.length;
+                    }
                 }
             }
             clear() {
                 if (this.handlers) {
                     this.handlers = [];
+                    syncHandlerEntries(this, this[$internals]);
                 }
             }
             forEach(fn) {
-                utils$1.forEach(this.handlers, function forEachHandler(h) {
-                    if (h !== null) {
-                        fn(h);
+                const internals = this[$internals];
+                syncHandlerEntries(this, internals);
+                internals.iterationDepth++;
+                try {
+                    utils$1.forEach(this.handlers, function forEachHandler(h) {
+                        if (h !== null) {
+                            fn(h);
+                        }
+                    });
+                } finally {
+                    if (!--internals.iterationDepth) {
+                        syncHandlerEntries(this, internals);
+                        trimHandlers(this.handlers);
+                        internals.handlersLength = countHandlers(this.handlers);
                     }
-                });
+                }
             }
         };
         var transitionalDefaults = {
@@ -20130,7 +20377,7 @@ var require_axios = __commonJS({
         }
         function parsePropPath(name) {
             const path = [];
-            const pattern = /\w+|\[(\w*)]/g;
+            const pattern = /[^.[\]]+|\[([^.[\]]*)]/g;
             let match;
             while ((match = pattern.exec(name)) !== null) {
                 throwIfDepthExceeded(path.length);
@@ -20185,6 +20432,19 @@ var require_axios = __commonJS({
             }
             return null;
         }
+        var methodList = ( Object.freeze([
+            "get",
+            "delete",
+            "head",
+            "options",
+            "post",
+            "put",
+            "patch",
+            "purge",
+            "link",
+            "unlink",
+            "query"
+        ]));
         var own = (obj, key) => obj != null && utils$1.hasOwnProp(obj, key) ? obj[key] : void 0;
         function stringifySafely(rawValue, parser, encoder) {
             if (utils$1.isString(rawValue)) {
@@ -20286,7 +20546,7 @@ var require_axios = __commonJS({
                 }
             }
         };
-        utils$1.forEach(["delete", "get", "head", "post", "put", "patch", "query"], method => {
+        utils$1.forEach(methodList, method => {
             defaults.headers[method] = {};
         });
         function transformData(fns, response) {
@@ -20329,6 +20589,17 @@ var require_axios = __commonJS({
                 )));
             }
         }
+        var urlParserControlCharacters = /[\t\n\r]/g;
+        function normalizeURLForProtocolCheck(url) {
+            if (typeof url !== "string") {
+                return url;
+            }
+            let start = 0;
+            while (start < url.length && url.charCodeAt(start) <= 32) {
+                start++;
+            }
+            return url.slice(start).replace(urlParserControlCharacters, "");
+        }
         function parseProtocol(url) {
             const match = /^([-+\w]{1,25}):(?:\/\/)?/.exec(url);
             return match && match[1] || "";
@@ -20396,18 +20667,19 @@ var require_axios = __commonJS({
                 }
             };
             const flush = () => lastArgs && invoke(lastArgs);
-            return [throttled, flush];
+            const flushWith = (...args) => invoke(args);
+            return [throttled, flush, flushWith];
         }
         var progressEventReducer = (listener, isDownloadStream, freq = 3) => {
             let bytesNotified = 0;
             const _speedometer = speedometer(50, 250);
             return throttle(e => {
-                if (!e || typeof e.loaded !== "number") {
+                if (!e || !utils$1.isNumber(e.loaded)) {
                     return;
                 }
                 const rawLoaded = e.loaded;
                 const total = e.lengthComputable ? e.total : void 0;
-                const loaded = total != null ? Math.min(rawLoaded, total) : rawLoaded;
+                const loaded = Math.max(0, total != null ? Math.min(rawLoaded, total) : rawLoaded);
                 const progressBytes = Math.max(0, loaded - bytesNotified);
                 const rate = _speedometer(progressBytes);
                 bytesNotified = Math.max(bytesNotified, loaded);
@@ -20433,7 +20705,7 @@ var require_axios = __commonJS({
                 loaded
             }), throttled[1]];
         };
-        var asyncDecorator = fn => (...args) => utils$1.asap(() => fn(...args));
+        var asyncDecorator = (fn, scheduler = utils$1.asap) => (...args) => scheduler(() => fn(...args));
         var isURLSameOrigin = platform.hasStandardBrowserEnv ?  ((origin2, isMSIE) => url => {
             url = ( new URL(url, platform.origin));
             return origin2.protocol === url.protocol && origin2.host === url.host && (isMSIE || origin2.port === url.port);
@@ -20496,27 +20768,44 @@ var require_axios = __commonJS({
             return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
         }
         function combineURLs(baseURL, relativeURL) {
-            return relativeURL ? baseURL.replace(/\/?\/$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+            if (!relativeURL) {
+                return baseURL;
+            }
+            let end = baseURL.length;
+            while (end > 0 && baseURL.charCodeAt(end - 1) === 47) {
+                end--;
+            }
+            return baseURL.slice(0, end) + "/" + relativeURL.replace(/^\/+/, "");
         }
         var malformedHttpProtocol = /^https?:(?!\/\/)/i;
-        var httpProtocolControlCharacters = /[\t\n\r]/g;
-        function stripLeadingC0ControlOrSpace(url) {
-            let i = 0;
-            while (i < url.length && url.charCodeAt(i) <= 32) {
-                i++;
+        function redactFragment(fragment) {
+            if (!fragment) {
+                return fragment;
             }
-            return url.slice(i);
+            return fragment.replace(/(^|&)([^=&]*=)?[^&]+/g, (match, separator, parameterName = "") => {
+                return `${separator}${parameterName}${REDACTED}`;
+            });
         }
-        function normalizeURLForProtocolCheck(url) {
-            return stripLeadingC0ControlOrSpace(url).replace(httpProtocolControlCharacters, "");
+        function redactSensitiveURLParts(url) {
+            const redactedURL = url.replace(/^(https?:\/{0,2})[^/?#]*@/i, `$1${REDACTED}@`);
+            const fragmentIndex = redactedURL.indexOf("#");
+            const urlWithoutFragment = fragmentIndex === -1 ? redactedURL : redactedURL.slice(0, fragmentIndex);
+            const redactedURLWithoutFragment = urlWithoutFragment.replace(/([?&][^=&#]*=)[^&#]*/g, `$1${REDACTED}`);
+            if (fragmentIndex === -1) {
+                return redactedURLWithoutFragment;
+            }
+            return `${redactedURLWithoutFragment}#${redactFragment(redactedURL.slice(fragmentIndex + 1))}`;
         }
         function assertValidHttpProtocolURL(url, config) {
-            if (typeof url === "string" && malformedHttpProtocol.test(normalizeURLForProtocolCheck(url))) {
-                throw ( new AxiosError(
-                    "Invalid URL: missing \"//\" after protocol",
-                    AxiosError.ERR_INVALID_URL,
-                    config
-                ));
+            if (typeof url === "string") {
+                const normalizedURL = normalizeURLForProtocolCheck(url);
+                if (malformedHttpProtocol.test(normalizedURL)) {
+                    throw ( new AxiosError(
+                        `Invalid URL ${JSON.stringify(redactSensitiveURLParts(normalizedURL))}: missing "//" after protocol`,
+                        AxiosError.ERR_INVALID_URL,
+                        config
+                    ));
+                }
             }
         }
         function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls, config) {
@@ -20531,6 +20820,14 @@ var require_axios = __commonJS({
         var headersToObject = thing => thing instanceof AxiosHeaders ? {
             ...thing
         } : thing;
+        var ownEnumerableKeys = thing => {
+            if (Object.getOwnPropertySymbols && Object.getOwnPropertyDescriptor) {
+                return ( Object.keys(thing)).concat(
+                    Object.getOwnPropertySymbols(thing).filter(symbol => Object.getOwnPropertyDescriptor(thing, symbol).enumerable)
+                );
+            }
+            return ( Object.keys(thing));
+        };
         function mergeConfig(config1, config2) {
             config1 = config1 || {};
             config2 = config2 || {};
@@ -20606,7 +20903,7 @@ var require_axios = __commonJS({
                 transformResponse: defaultToConfig2,
                 paramsSerializer: defaultToConfig2,
                 timeout: defaultToConfig2,
-                timeoutMessage: defaultToConfig2,
+                timeoutErrorMessage: defaultToConfig2,
                 withCredentials: defaultToConfig2,
                 withXSRFToken: defaultToConfig2,
                 adapter: defaultToConfig2,
@@ -20629,10 +20926,10 @@ var require_axios = __commonJS({
                 validateStatus: mergeDirectKeys,
                 headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
             };
-            utils$1.forEach(( Object.keys({
+            utils$1.forEach(ownEnumerableKeys({
                 ...config1,
                 ...config2
-            })), function computeConfigValue(prop) {
+            }), function computeConfigValue(prop) {
                 if (prop === "__proto__" || prop === "constructor" || prop === "prototype")
                     return;
                 const merge2 = utils$1.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;
@@ -20694,10 +20991,11 @@ var require_axios = __commonJS({
                 }
             }
             if (utils$1.isFormData(data)) {
+                const getHeaders = utils$1.getSafeProp(data, "getHeaders");
                 if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv || utils$1.isReactNative(data)) {
                     headers.setContentType(void 0);
-                } else if (utils$1.isFunction(data.getHeaders)) {
-                    setFormDataHeaders(headers, data.getHeaders(), own2("formDataHeaderPolicy"));
+                } else if (utils$1.isFunction(getHeaders)) {
+                    setFormDataHeaders(headers, getHeaders.call(data), own2("formDataHeaderPolicy"));
                 }
             }
             if (platform.hasStandardBrowserEnv) {
@@ -20727,7 +21025,7 @@ var require_axios = __commonJS({
                 } = _config;
                 let onCanceled;
                 let uploadThrottled, downloadThrottled;
-                let flushUpload, flushDownload;
+                let flushUpload, flushDownload, flushDownloadWithEvent;
                 function done() {
                     flushUpload && flushUpload();
                     flushDownload && flushDownload();
@@ -20737,7 +21035,27 @@ var require_axios = __commonJS({
                 let request = ( new XMLHttpRequest());
                 request.open(_config.method.toUpperCase(), _config.url, true);
                 request.timeout = _config.timeout;
-                function onloadend() {
+                function onloadend(event) {
+                    if (!request) {
+                        return;
+                    }
+                    if (request.status === 0 && (parseProtocol(normalizeURLForProtocolCheck(_config.url)) || parseProtocol(platform.origin)) !== "file" && !(request.responseURL && request.responseURL.startsWith("file:"))) {
+                        reject(( new AxiosError("Request aborted", AxiosError.ECONNABORTED, config, request)));
+                        done();
+                        request = null;
+                        return;
+                    }
+                    try {
+                        if (event) {
+                            flushDownloadWithEvent && flushDownloadWithEvent(event);
+                        } else {
+                            flushDownload && flushDownload();
+                        }
+                    } catch (err) {
+                        setTimeout(() => {
+                            throw err;
+                        });
+                    }
                     if (!request) {
                         return;
                     }
@@ -20820,7 +21138,7 @@ var require_axios = __commonJS({
                     request.responseType = _config.responseType;
                 }
                 if (onDownloadProgress) {
-                    [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
+                    [downloadThrottled, flushDownload, flushDownloadWithEvent] = progressEventReducer(onDownloadProgress, true);
                     request.addEventListener("progress", downloadThrottled);
                 }
                 if (onUploadProgress && request.upload) {
@@ -20886,9 +21204,18 @@ var require_axios = __commonJS({
                 });
                 signals = null;
             };
-            signals.forEach(signal2 => signal2.addEventListener("abort", onabort, {
-                once: true
-            }));
+            signals.forEach(signal2 => {
+                if (aborted) {
+                    return;
+                }
+                if (signal2.aborted) {
+                    onabort.call(signal2);
+                    return;
+                }
+                signal2.addEventListener("abort", onabort, {
+                    once: true
+                });
+            });
             const {
                 signal
             } = controller;
@@ -20978,7 +21305,56 @@ var require_axios = __commonJS({
         };
         var isHexDigit = charCode => charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 70 || charCode >= 97 && charCode <= 102;
         var isPercentEncodedByte = (str, i, len) => i + 2 < len && isHexDigit(str.charCodeAt(i + 1)) && isHexDigit(str.charCodeAt(i + 2));
-        function estimateDataURLDecodedBytes(url) {
+        var hexValue = charCode => charCode <= 57 ? charCode - 48 : (charCode & 223) - 55;
+        var isBase64Char = charCode =>
+        charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122 || charCode >= 48 && charCode <= 57 || charCode === 43 || charCode === 47 || charCode === 45 || charCode === 95;
+        var isBase64Whitespace = charCode => charCode === 9 || charCode === 10 || charCode === 12 || charCode === 13 || charCode === 32;
+        var base64Bytes = significant => {
+            const groups = Math.floor(significant / 4);
+            const remainder = significant % 4;
+            return groups * 3 + (remainder === 2 ? 1 : remainder === 3 ? 2 : 0);
+        };
+        var estimateBase64BufferAllocation = body => {
+            const len = body.length;
+            let padding = 0;
+            if (len > 0 && body.charCodeAt(len - 1) === 61) {
+                padding++;
+                if (len > 1 && body.charCodeAt(len - 2) === 61) {
+                    padding++;
+                }
+            }
+            return Math.floor((len - padding) * 3 / 4);
+        };
+        var estimatePercentDecodedBase64Bytes = body => {
+            const len = body.length;
+            let significant = 0;
+            let padding = 0;
+            let invalid = false;
+            for (let i = 0; i < len; i++) {
+                let code = body.charCodeAt(i);
+                if (code === 37 && isPercentEncodedByte(body, i, len)) {
+                    code = hexValue(body.charCodeAt(i + 1)) * 16 + hexValue(body.charCodeAt(i + 2));
+                    i += 2;
+                }
+                if (isBase64Whitespace(code)) {
+                    continue;
+                }
+                if (code === 61) {
+                    padding++;
+                    continue;
+                }
+                if (!isBase64Char(code) || padding > 0) {
+                    invalid = true;
+                    continue;
+                }
+                significant++;
+            }
+            if (invalid || padding > 2 || padding > 0 && (significant + padding) % 4 !== 0 || significant % 4 === 1) {
+                return estimateBase64BufferAllocation(body);
+            }
+            return base64Bytes(significant);
+        };
+        var estimateDataURLBytes = (url, estimateBase64) => {
             if (!url || typeof url !== "string")
                 return 0;
             if (!url.startsWith("data:"))
@@ -20990,42 +21366,7 @@ var require_axios = __commonJS({
             const body = url.slice(comma + 1);
             const isBase64 = /;base64/i.test(meta);
             if (isBase64) {
-                let effectiveLen = body.length;
-                const len = body.length;
-                for (let i = 0; i < len; i++) {
-                    if (body.charCodeAt(i) === 37 && i + 2 < len) {
-                        const a = body.charCodeAt(i + 1);
-                        const b = body.charCodeAt(i + 2);
-                        const isHex = isHexDigit(a) && isHexDigit(b);
-                        if (isHex) {
-                            effectiveLen -= 2;
-                            i += 2;
-                        }
-                    }
-                }
-                let pad = 0;
-                let idx = len - 1;
-                const tailIsPct3D = j =>
-                j >= 2 && body.charCodeAt(j - 2) === 37 && body.charCodeAt(j - 1) === 51 && (body.charCodeAt(j) === 68 || body.charCodeAt(j) === 100);
-                if (idx >= 0) {
-                    if (body.charCodeAt(idx) === 61) {
-                        pad++;
-                        idx--;
-                    } else if (tailIsPct3D(idx)) {
-                        pad++;
-                        idx -= 3;
-                    }
-                }
-                if (pad === 1 && idx >= 0) {
-                    if (body.charCodeAt(idx) === 61) {
-                        pad++;
-                    } else if (tailIsPct3D(idx)) {
-                        pad++;
-                    }
-                }
-                const groups = Math.floor(effectiveLen / 4);
-                const bytes2 = groups * 3 - (pad || 0);
-                return bytes2 > 0 ? bytes2 : 0;
+                return estimateBase64(body);
             }
             let bytes = 0;
             for (let i = 0, len = body.length; i < len; i++) {
@@ -21050,9 +21391,27 @@ var require_axios = __commonJS({
                 }
             }
             return bytes;
+        };
+        function estimateDataURLDecodedBytes(url) {
+            const fragmentIndex = typeof url === "string" ? url.indexOf("#") : -1;
+            return estimateDataURLBytes(
+                fragmentIndex === -1 ? url : url.slice(0, fragmentIndex),
+                estimatePercentDecodedBase64Bytes
+            );
         }
-        var VERSION = "1.18.1";
+        var VERSION = "1.20.0";
         var DEFAULT_CHUNK_SIZE = 64 * 1024;
+        var DEFAULT_REQUEST_OPTIONS = {
+            cache: "default",
+            redirect: "follow",
+            referrer: "about:client",
+            referrerPolicy: "",
+            mode: "cors",
+            integrity: "",
+            keepalive: false,
+            priority: "auto",
+            window: null
+        };
         var {
             isFunction
         } = utils$1;
@@ -21185,7 +21544,8 @@ var require_axios = __commonJS({
                     withCredentials = "same-origin",
                     fetchOptions,
                     maxContentLength,
-                    maxBodyLength
+                    maxBodyLength,
+                    maxRedirects
                 } = resolveConfig(config);
                 const hasMaxContentLength = utils$1.isNumber(maxContentLength) && maxContentLength > -1;
                 const hasMaxBodyLength = utils$1.isNumber(maxBodyLength) && maxBodyLength > -1;
@@ -21307,17 +21667,44 @@ var require_axios = __commonJS({
                         }
                     }
                     headers.set("User-Agent", "axios/" + VERSION, false);
-                    const resolvedOptions = {
-                        ...fetchOptions,
+                    const safeFetchOptions = fetchOptions == null ? fetchOptions : Object.assign( Object.create(null), fetchOptions);
+                    if (safeFetchOptions) {
+                        delete safeFetchOptions.body;
+                        delete safeFetchOptions.headers;
+                        delete safeFetchOptions.method;
+                        delete safeFetchOptions.signal;
+                        delete safeFetchOptions.duplex;
+                        delete safeFetchOptions.credentials;
+                    }
+                    const resolvedOptions = Object.assign( Object.create(null), safeFetchOptions, {
                         signal: composedSignal,
                         method: method.toUpperCase(),
                         headers: toByteStringHeaderObject(headers.normalize()),
                         body: data,
                         duplex: "half",
                         credentials: isCredentialsSupported ? withCredentials : void 0
-                    };
+                    });
+                    if (isRequestSupported) {
+                        utils$1.forEach(DEFAULT_REQUEST_OPTIONS, (value, key) => {
+                            if (resolvedOptions[key] === void 0) {
+                                resolvedOptions[key] = value;
+                            }
+                        });
+                        if (resolvedOptions.signal === void 0) {
+                            resolvedOptions.signal = null;
+                        }
+                        if (resolvedOptions.body === void 0) {
+                            resolvedOptions.body = null;
+                        }
+                    }
+                    if (maxRedirects === 0) {
+                        resolvedOptions.redirect = "manual";
+                        if (safeFetchOptions) {
+                            safeFetchOptions.redirect = "manual";
+                        }
+                    }
                     request = isRequestSupported && ( new Request(url, resolvedOptions));
-                    let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));
+                    let response = await (isRequestSupported ? _fetch(request, safeFetchOptions) : _fetch(url, resolvedOptions));
                     const responseHeaders = AxiosHeaders.from(response.headers);
                     if (hasMaxContentLength) {
                         const declaredLength = utils$1.toFiniteNumber(responseHeaders.getContentLength());
@@ -21529,9 +21916,10 @@ var require_axios = __commonJS({
                 throw ( new CanceledError(null, config));
             }
         }
-        function dispatchRequest(config) {
+        function dispatchRequest(_config) {
+            const config = utils$1.toSafeFlatObject(_config);
             throwIfCancellationRequested(config);
-            config.headers = AxiosHeaders.from(config.headers);
+            config.headers = AxiosHeaders.from(utils$1.getSafeProp(config, "headers"));
             config.data = transformData.call(config, config.transformRequest);
             if (["post", "put", "patch"].indexOf(config.method) !== -1) {
                 config.headers.setContentType("application/x-www-form-urlencoded", false);
@@ -21637,16 +22025,15 @@ var require_axios = __commonJS({
                     return await this._request(configOrUrl, config);
                 } catch (err) {
                     if (err instanceof Error) {
-                        let dummy = {};
-                        Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = ( new Error());
-                        const stack = (() => {
-                            if (!dummy.stack) {
-                                return "";
-                            }
-                            const firstNewlineIndex = dummy.stack.indexOf("\n");
-                            return firstNewlineIndex === -1 ? "" : dummy.stack.slice(firstNewlineIndex + 1);
-                        })();
                         try {
+                            let dummy = {};
+                            Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = ( new Error());
+                            const dummyStack = dummy.stack;
+                            let stack = "";
+                            if (typeof dummyStack === "string") {
+                                const firstNewlineIndex = dummyStack.indexOf("\n");
+                                stack = firstNewlineIndex === -1 ? "" : dummyStack.slice(firstNewlineIndex + 1);
+                            }
                             if (!err.stack) {
                                 err.stack = stack;
                             } else if (stack) {
@@ -21708,14 +22095,11 @@ var require_axios = __commonJS({
                     baseUrl: validators.spelling("baseURL"),
                     withXsrfToken: validators.spelling("withXSRFToken")
                 }, true);
-                config.method = (config.method || this.defaults.method || "get").toLowerCase();
+                config.method = (utils$1.getSafeProp(config, "method") || utils$1.getSafeProp(this.defaults, "method") || "get").toLowerCase();
                 let contextHeaders = headers && utils$1.merge(headers.common, headers[config.method]);
-                headers && utils$1.forEach(
-                    ["delete", "get", "head", "post", "put", "patch", "query", "common"],
-                    method => {
-                        delete headers[method];
-                    }
-                );
+                headers && utils$1.forEach(methodList.concat("common"), method => {
+                    delete headers[method];
+                });
                 config.headers = AxiosHeaders.concat(contextHeaders, headers);
                 const requestInterceptorChain = [];
                 let synchronousRequestInterceptors = true;
@@ -21756,16 +22140,29 @@ var require_axios = __commonJS({
                     const onFulfilled = requestInterceptorChain[i++];
                     const onRejected = requestInterceptorChain[i++];
                     try {
-                        newConfig = onFulfilled(newConfig);
+                        newConfig = onFulfilled ? onFulfilled(newConfig) : newConfig;
                     } catch (error) {
-                        onRejected.call(this, error);
+                        if (!onRejected) {
+                            promise = Promise.reject(error);
+                            break;
+                        }
+                        try {
+                            const rejectedResult = onRejected.call(this, error);
+                            if (utils$1.isThenable(rejectedResult)) {
+                                promise = Promise.resolve(rejectedResult).then(() => dispatchRequest.call(this, newConfig));
+                            }
+                        } catch (rejectedError) {
+                            promise = Promise.reject(rejectedError);
+                        }
                         break;
                     }
                 }
-                try {
-                    promise = dispatchRequest.call(this, newConfig);
-                } catch (error) {
-                    return Promise.reject(error);
+                if (!promise) {
+                    try {
+                        promise = dispatchRequest.call(this, newConfig);
+                    } catch (error) {
+                        promise = Promise.reject(error);
+                    }
                 }
                 i = 0;
                 len = responseInterceptorChain.length;
@@ -21942,6 +22339,7 @@ var require_axios = __commonJS({
             LengthRequired: 411,
             PreconditionFailed: 412,
             PayloadTooLarge: 413,
+            ContentTooLarge: 413,
             UriTooLong: 414,
             UnsupportedMediaType: 415,
             RangeNotSatisfiable: 416,
@@ -21949,6 +22347,7 @@ var require_axios = __commonJS({
             ImATeapot: 418,
             MisdirectedRequest: 421,
             UnprocessableEntity: 422,
+            UnprocessableContent: 422,
             Locked: 423,
             FailedDependency: 424,
             TooEarly: 425,
@@ -21968,6 +22367,7 @@ var require_axios = __commonJS({
             LoopDetected: 508,
             NotExtended: 510,
             NetworkAuthenticationRequired: 511,
+            WebServerReturnsAnUnknownError: 520,
             WebServerIsDown: 521,
             ConnectionTimedOut: 522,
             OriginIsUnreachable: 523,
@@ -21976,7 +22376,9 @@ var require_axios = __commonJS({
             InvalidSslCertificate: 526
         };
         Object.entries(HttpStatusCode).forEach(([key, value]) => {
-            HttpStatusCode[value] = key;
+            if (HttpStatusCode[value] === void 0) {
+                HttpStatusCode[value] = key;
+            }
         });
         function createInstance(defaultConfig) {
             const context = ( new Axios(defaultConfig));
@@ -22158,6 +22560,31 @@ var require_idGeneration = __commonJS({
         ];
     }
 });
+var require_tunnelClusterSelection = __commonJS({
+    "node_modules/@microsoft/dev-tunnels-management/tunnelClusterSelection.js"(exports) {
+        init_buffer();
+        init_process();
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.isClusterFallback = exports.TunnelClusterSource = void 0;
+        var TunnelClusterSource;
+        (function(TunnelClusterSource2) {
+            TunnelClusterSource2["explicit"] = "explicit";
+            TunnelClusterSource2["recommended"] = "recommended";
+            TunnelClusterSource2["recommendedAfterAuthRejected"] = "recommended-after-auth-rejected";
+            TunnelClusterSource2["fallbackAuthFailed"] = "fallback-auth-failed";
+            TunnelClusterSource2["fallbackEmpty"] = "fallback-empty";
+            TunnelClusterSource2["fallbackError"] = "fallback-error";
+        })(
+            TunnelClusterSource = exports.TunnelClusterSource || (exports.TunnelClusterSource = {})
+        );
+        function isClusterFallback(source) {
+            return source === TunnelClusterSource.fallbackAuthFailed || source === TunnelClusterSource.fallbackEmpty || source === TunnelClusterSource.fallbackError;
+        }
+        exports.isClusterFallback = isClusterFallback;
+    }
+});
 var require_tunnelManagementHttpClient = __commonJS({
     "node_modules/@microsoft/dev-tunnels-management/tunnelManagementHttpClient.js"(exports) {
         init_buffer();
@@ -22175,6 +22602,7 @@ var require_tunnelManagementHttpClient = __commonJS({
         var axios_1 = require_axios();
         var tunnelPlanTokenProperties_1 = require_tunnelPlanTokenProperties();
         var idGeneration_1 = require_idGeneration();
+        var tunnelClusterSelection_1 = require_tunnelClusterSelection();
         var tunnelsApiPath = "/tunnels";
         var limitsApiPath = "/userlimits";
         var endpointsApiSubPath = "/endpoints";
@@ -22182,6 +22610,7 @@ var require_tunnelManagementHttpClient = __commonJS({
         var eventsApiSubPath = "/events";
         var clustersApiPath = "/clusters";
         var recommendationsSubPath = "/recommendations";
+        var clusterSourceHeaderName = "X-Tunnel-Cluster-Source";
         var tunnelAuthentication = "Authorization";
         var checkAvailablePath = ":checkNameAvailability";
         var createNameRetries = 3;
@@ -22194,6 +22623,11 @@ var require_tunnelManagementHttpClient = __commonJS({
             var _a, _b;
             return ((_a = a.portNumber) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER) - ((_b = b.portNumber) !== null && _b !== void 0 ? _b : Number.MAX_SAFE_INTEGER);
         }
+        function isUnauthorizedError(error) {
+            var _a;
+            const status = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status;
+            return status === 401 || status === 403;
+        }
         function parseDate(value) {
             return typeof value === "string" ? ( new Date(Date.parse(value))) : value;
         }
@@ -22252,6 +22686,8 @@ var require_tunnelManagementHttpClient = __commonJS({
                 this.httpsAgent = httpsAgent;
                 this.adapter = adapter;
                 this.reportProgressEmitter = new vscode_jsonrpc_1.Emitter();
+                this.clusterSelectedEmitter = new vscode_jsonrpc_1.Emitter();
+                this.onClusterSelected = this.clusterSelectedEmitter.event;
                 this.onReportProgress = this.reportProgressEmitter.event;
                 this.trace = msg => {};
                 this.enableEventsReporting = false;
@@ -22373,17 +22809,34 @@ var require_tunnelManagementHttpClient = __commonJS({
                 const tunnelId = tunnel.tunnelId;
                 const idGenerated = tunnelId === void 0 || tunnelId === null || tunnelId === "";
                 options = options || {};
+                let clusterSource = tunnelClusterSelection_1.TunnelClusterSource.explicit;
                 if (!tunnel.clusterId) {
+                    let error;
                     try {
-                        const recommendations = await this.getClusterRecommendations(void 0, options.requiredGeo, cancellation);
-                        if (recommendations === null || recommendations === void 0 ? void 0 : recommendations.recommendedClusterId) {
-                            tunnel.clusterId = recommendations.recommendedClusterId;
+                        const {
+                            response,
+                            authRejected
+                        } = await this.getClusterRecommendationsInternal(void 0, options.requiredGeo, cancellation);
+                        if (response === null || response === void 0 ? void 0 : response.recommendedClusterId) {
+                            tunnel.clusterId = response.recommendedClusterId;
+                            clusterSource = authRejected ? tunnelClusterSelection_1.TunnelClusterSource.recommendedAfterAuthRejected : tunnelClusterSelection_1.TunnelClusterSource.recommended;
+                        } else {
+                            clusterSource = tunnelClusterSelection_1.TunnelClusterSource.fallbackEmpty;
                         }
-                    } catch (_b) {}
+                    } catch (e) {
+                        error = e;
+                        clusterSource = isUnauthorizedError(e) ? tunnelClusterSelection_1.TunnelClusterSource.fallbackAuthFailed : tunnelClusterSelection_1.TunnelClusterSource.fallbackError;
+                    }
+                    this.clusterSelectedEmitter.fire({
+                        source: clusterSource,
+                        clusterId: tunnel.clusterId,
+                        error
+                    });
                 }
                 options = Object.assign(Object.assign({}, options), {
                     additionalHeaders: Object.assign(Object.assign({}, options.additionalHeaders), {
-                        "If-None-Match": "*"
+                        "If-None-Match": "*",
+                        [clusterSourceHeaderName]: clusterSource
                     })
                 });
                 if (idGenerated) {
@@ -22654,6 +23107,9 @@ var require_tunnelManagementHttpClient = __commonJS({
                 );
             }
             async getClusterRecommendations(preferredClusterId, requiredGeo, cancellation) {
+                return (await this.getClusterRecommendationsInternal(preferredClusterId, requiredGeo, cancellation)).response;
+            }
+            async getClusterRecommendationsInternal(preferredClusterId, requiredGeo, cancellation) {
                 const queryParts = [];
                 if (preferredClusterId) {
                     queryParts.push(`preferredClusterId=${encodeURIComponent(preferredClusterId)}`);
@@ -22662,16 +23118,25 @@ var require_tunnelManagementHttpClient = __commonJS({
                     queryParts.push(`requiredGeo=${encodeURIComponent(requiredGeo)}`);
                 }
                 const query = queryParts.length > 0 ? queryParts.join("&") : void 0;
-                return await this.sendRequest(
-                    "GET",
-                    void 0,
-                    clustersApiPath + recommendationsSubPath,
-                    query,
-                    void 0,
-                    void 0,
-                    false,
-                    cancellation
-                );
+                try {
+                    return {
+                        response: await this.sendClusterRecommendationsRequest(query, false, cancellation),
+                        authRejected: false
+                    };
+                } catch (error) {
+                    if (!isUnauthorizedError(error)) {
+                        throw error;
+                    }
+                    return {
+                        response: await this.sendClusterRecommendationsRequest(query, true, cancellation),
+                        authRejected: true
+                    };
+                }
+            }
+            async sendClusterRecommendationsRequest(query, suppressUserToken, cancellation) {
+                const uri = await this.buildUri(void 0, clustersApiPath + recommendationsSubPath, query);
+                const config = await this.getAxiosRequestConfig(void 0, void 0, void 0, suppressUserToken);
+                return await this.request("GET", uri, void 0, config, false, cancellation);
             }
             async sendTunnelRequest(
                 method,
@@ -22908,12 +23373,12 @@ Request ID: ${error.response.headers[requestIdHeaderName]}`;
                 }
                 return this.buildUri(tunnel.clusterId, tunnelPath + (path ? path : ""), query, options);
             }
-            async getAxiosRequestConfig(tunnel, options, accessTokenScopes) {
+            async getAxiosRequestConfig(tunnel, options, accessTokenScopes, suppressUserToken) {
                 const headers = {};
                 if (options && options.accessToken) {
                     headers[tunnelAuthentication] = `${tunnelManagementClient_1.TunnelAuthenticationSchemes.tunnel} ${options.accessToken}`;
                 }
-                if (!(tunnelAuthentication in headers) && this.userTokenCallback) {
+                if (!(tunnelAuthentication in headers) && this.userTokenCallback && !suppressUserToken) {
                     const token = await this.userTokenCallback();
                     if (token) {
                         headers[tunnelAuthentication] = token;
@@ -23198,6 +23663,7 @@ var require_dev_tunnels_management = __commonJS({
         __exportStar(require_tunnelManagementClient(), exports);
         __exportStar(require_tunnelRequestOptions(), exports);
         __exportStar(require_tunnelAccessTokenProperties(), exports);
+        __exportStar(require_tunnelClusterSelection(), exports);
     }
 });
 var require_tunnelClient = __commonJS({
@@ -24064,11 +24530,16 @@ var require_defaultTunnelRelayStreamFactory = __commonJS({
         exports.DefaultTunnelRelayStreamFactory = void 0;
         var sshHelpers_1 = require_sshHelpers();
         var DefaultTunnelRelayStreamFactory = class {
-            async createRelayStream(relayUri, protocols, accessToken, clientConfig) {
+            async createRelayStream(relayUri, protocols, accessToken, clientConfig, additionalHeaders) {
                 if ((0, sshHelpers_1.isNode)()) {
-                    const stream = await sshHelpers_1.SshHelpers.openConnection(relayUri, protocols, Object.assign({}, accessToken && {
-                        Authorization: `tunnel ${accessToken}`
-                    }), clientConfig);
+                    const stream = await sshHelpers_1.SshHelpers.openConnection(
+                        relayUri,
+                        protocols,
+                        Object.assign(Object.assign({}, additionalHeaders), accessToken && {
+                            Authorization: `tunnel ${accessToken}`
+                        }),
+                        clientConfig
+                    );
                     return {
                         stream,
                         protocol: stream.protocol
@@ -26044,6 +26515,7 @@ var require_tunnelConnectionSession = __commonJS({
                 this.disconnectionReason = reason;
             }
             async createSessionStream(options, cancellation) {
+                var _a;
                 if (!this.relayUri) {
                     throw ( new Error(
                         "Cannot create tunnel session stream. Tunnel relay endpoint URI is missing"
@@ -26077,7 +26549,13 @@ var require_tunnelConnectionSession = __commonJS({
                         agent: this.httpAgent
                     }
                 };
-                const streamAndProtocol = await this.streamFactory.createRelayStream(this.relayUri, this.connectionProtocols, this.accessToken, clientConfig);
+                const streamAndProtocol = await this.streamFactory.createRelayStream(
+                    this.relayUri,
+                    this.connectionProtocols,
+                    this.accessToken,
+                    clientConfig,
+                    (_a = this.managementClient) === null || _a === void 0 ? void 0 : _a.additionalRequestHeaders
+                );
                 this.trace(
                     dev_tunnels_ssh_1.TraceLevel.Verbose,
                     0,
@@ -26911,7 +27389,7 @@ var require_tunnelRelayTunnelHost = __commonJS({
                 }
             }
             async onConnectingToTunnel() {
-                var _a, _b, _c, _d, _e;
+                var _a, _b, _c, _d;
                 if (!this.hostPrivateKey || !this.hostPublicKeys) {
                     if (!this.hostPrivateKeyPromise) {
                         throw ( new Error("Cannot create host keys"));
@@ -26923,8 +27401,7 @@ var require_tunnelRelayTunnelHost = __commonJS({
                     }
                     this.hostPublicKeys = [( buffer.toString("base64"))];
                 }
-                const tunnelHasSshPort = ((_a = this.tunnel) === null || _a === void 0 ? void 0 : _a.ports) != null && this.tunnel.ports.find(v => v.protocol === dev_tunnels_contracts_1.TunnelProtocol.Ssh);
-                const endpointSignature = `${(_b = this.tunnel) === null || _b === void 0 ? void 0 : _b.tunnelId}.${(_c = this.tunnel) === null || _c === void 0 ? void 0 : _c.clusterId}:${(_d = this.tunnel) === null || _d === void 0 ? void 0 : _d.name}.${(_e = this.tunnel) === null || _e === void 0 ? void 0 : _e.domain}:${tunnelHasSshPort}:${this.hostId}:${this.hostPublicKeys}`;
+                const endpointSignature = `${(_a = this.tunnel) === null || _a === void 0 ? void 0 : _a.tunnelId}.${(_b = this.tunnel) === null || _b === void 0 ? void 0 : _b.clusterId}:${(_c = this.tunnel) === null || _c === void 0 ? void 0 : _c.name}.${(_d = this.tunnel) === null || _d === void 0 ? void 0 : _d.domain}:${this.hostId}:${this.hostPublicKeys}`;
                 if (!this.relayUri || this.endpointSignature !== endpointSignature) {
                     if (!this.tunnel) {
                         throw ( new Error("Tunnel is required"));
@@ -26935,15 +27412,7 @@ var require_tunnelRelayTunnelHost = __commonJS({
                         hostPublicKeys: this.hostPublicKeys,
                         connectionMode: dev_tunnels_contracts_1.TunnelConnectionMode.TunnelRelay
                     };
-                    let additionalQueryParameters = void 0;
-                    if (tunnelHasSshPort) {
-                        additionalQueryParameters = {
-                            includeSshGatewayPublicKey: "true"
-                        };
-                    }
-                    endpoint = await this.managementClient.updateTunnelEndpoint(this.tunnel, endpoint, {
-                        additionalQueryParameters
-                    });
+                    endpoint = await this.managementClient.updateTunnelEndpoint(this.tunnel, endpoint);
                     this.relayUri = endpoint.hostRelayUri;
                     this.endpointSignature = endpointSignature;
                 }