@codingame/monaco-vscode-api 21.6.0 → 22.0.0

package/vscode/src/vs/base/browser/domStylesheets.js

@@ -1,6 +1,7 @@
 
 import { toDisposable, DisposableStore } from '../common/lifecycle.js';
 import '../common/observableInternal/index.js';
+import { isFirefox } from './browser.js';
 import { isShadowRoot, createElement, getWindows, sharedMutationObserver } from './dom.js';
 import { mainWindow } from './window.js';
 import { autorun } from '../common/observableInternal/reactions/autorun.js';
@@ -56,6 +57,9 @@ function createStyleSheet(container = mainWindow.document.head, beforeAppend, di
     if (container === mainWindow.document.head) {
         const globalStylesheetClones = ( new Set());
         globalStylesheets.set(style, globalStylesheetClones);
+        if (disposableStore) {
+            disposableStore.add(toDisposable(() => globalStylesheets.delete(style)));
+        }
         for (const { window: targetWindow, disposables } of getWindows()) {
             if (targetWindow === mainWindow) {
                 continue;
@@ -85,7 +89,7 @@ function cloneGlobalStyleSheet(globalStylesheet, globalStylesheetClones, windowE
     for (const rule of getDynamicStyleSheetRules(globalStylesheet)) {
         clone.sheet?.insertRule(rule.cssText, clone.sheet?.cssRules.length);
     }
-    disposables.add(sharedMutationObserver.observe(globalStylesheet, disposables, { childList: true, subtree: true, characterData: true })(() => {
+    disposables.add(sharedMutationObserver.observe(globalStylesheet, disposables, { childList: true, subtree: isFirefox, characterData: isFirefox })(() => {
         clone.textContent = globalStylesheet.textContent;
     }));
     globalStylesheetClones.add(clone);

package/vscode/src/vs/base/browser/markdownRenderer.js

@@ -84,7 +84,7 @@ function renderMarkdown(markdown, options = {}, target) {
         renderedMarkdown = ( elements.map(e => typeof e === 'string' ? e : e.outerHTML)).join('');
     }
     const renderedContent = createElement('div');
-    const sanitizerConfig = getDomSanitizerConfig(markdown.isTrusted ?? false, options.sanitizerConfig ?? {});
+    const sanitizerConfig = getDomSanitizerConfig(markdown, options.sanitizerConfig ?? {});
     safeSetInnerHtml(renderedContent, renderedMarkdown, sanitizerConfig);
     rewriteRenderedLinks(markdown, options, renderedContent);
     let outElement;
@@ -337,8 +337,8 @@ function resolveWithBaseUri(baseUri, href) {
         return ( resolvePath(dirname(baseUri), href).toString());
     }
 }
-function sanitizeRenderedMarkdown(renderedMarkdown, isTrusted, options = {}) {
-    const sanitizerConfig = getDomSanitizerConfig(isTrusted, options);
+function sanitizeRenderedMarkdown(renderedMarkdown, originalMdStrConfig, options = {}) {
+    const sanitizerConfig = getDomSanitizerConfig(originalMdStrConfig, options);
     return sanitizeHtml(renderedMarkdown, sanitizerConfig);
 }
 const allowedMarkdownHtmlTags = ( Object.freeze([
@@ -393,7 +393,8 @@ const allowedMarkdownHtmlAttributes = ( Object.freeze([
         },
     },
 ]));
-function getDomSanitizerConfig(isTrusted, options) {
+function getDomSanitizerConfig(mdStrConfig, options) {
+    const isTrusted = mdStrConfig.isTrusted ?? false;
     const allowedLinkSchemes = [
         Schemas.http,
         Schemas.https,
@@ -420,6 +421,7 @@ function getDomSanitizerConfig(isTrusted, options) {
         allowedLinkProtocols: {
             override: allowedLinkSchemes,
         },
+        allowRelativeLinkPaths: !!mdStrConfig.baseUri,
         allowedMediaProtocols: {
             override: [
                 Schemas.http,
@@ -443,7 +445,7 @@ function renderAsPlaintext(str, options) {
         value = `${value.substr(0, 100_000)}…`;
     }
     const html = parse$1(value, { async: false, renderer: options?.includeCodeBlocksFences ? plainTextWithCodeBlocksRenderer.value : plainTextRenderer.value });
-    return ( sanitizeRenderedMarkdown(html,  false, {})
+    return ( sanitizeRenderedMarkdown(html, { isTrusted: false }, {})
         .toString())
         .replace(/&(#\d+|[a-zA-Z]+);/g, m => unescapeInfo.get(m) ?? m)
         .trim();

package/vscode/src/vs/base/browser/ui/contextview/contextview.js

@@ -1,7 +1,7 @@
 
 import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { BrowserFeatures } from '../../canIUse.js';
-import { $, hide, createElement, addStandardDisposableListener, clearNode, show, isHTMLElement, getDomNodePagePosition, getDomNodeZoomLevel, getTotalWidth, getTotalHeight, getActiveWindow, getWindow, isAncestor } from '../../dom.js';
+import { $, hide, createElement, addStandardDisposableListener, clearNode, show, isHTMLElement, getDomNodePagePosition, getDomNodeZoomLevel, getTotalWidth, getTotalHeight, getActiveWindow, getActiveElement, getWindow, isAncestor } from '../../dom.js';
 import { Disposable, toDisposable, DisposableStore } from '../../../common/lifecycle.js';
 import { isIOS } from '../../../common/platform.js';
 import { Range } from '../../../common/range.js';
@@ -243,7 +243,7 @@ class ContextView extends Disposable {
     onDOMEvent(e, onCapture) {
         if (this.delegate) {
             if (this.delegate.onDOMEvent) {
-                this.delegate.onDOMEvent(e, getWindow(e).document.activeElement);
+                this.delegate.onDOMEvent(e, getActiveElement(getWindow(e).document));
             }
             else if (onCapture && !isAncestor(e.target, this.container)) {
                 this.hide();

package/vscode/src/vs/base/browser/ui/dropdown/dropdown.js

@@ -31,7 +31,7 @@ class BaseDropdown extends ActionRunner {
         }
         for (const event of [EventType.MOUSE_DOWN, EventType$1.Tap]) {
             this._register(addDisposableListener(this._label, event, e => {
-                if (isMouseEvent(e) && (e.detail > 1 || e.button !== 0)) {
+                if (isMouseEvent(e) && e.button !== 0) {
                     return;
                 }
                 if (this.visible) {

package/vscode/src/vs/base/browser/ui/menu/menu.js

@@ -645,6 +645,7 @@ class SubmenuMenuActionViewItem extends BaseMenuActionViewItem {
             this.submenuContainer.style.position = 'fixed';
             this.submenuContainer.style.top = '0';
             this.submenuContainer.style.left = '0';
+            this.submenuContainer.style.zIndex = '1';
             this.parentData.submenu = ( new Menu(
                 this.submenuContainer,
                 this.submenuActions.length ? this.submenuActions : [( new EmptySubmenuAction())],

package/vscode/src/vs/base/browser/ui/progressbar/progressbar.d.ts

@@ -57,7 +57,7 @@ export declare class ProgressBar extends Disposable {
      */
     worked(value: number): ProgressBar;
     /**
-     * Tells the progress bar the total amount of work that has been completed.
+     * Tells the progress bar the total amount of work (0 to 100) that has been completed.
      */
     setWorked(value: number): ProgressBar;
     private doSetWorked;

package/vscode/src/vs/base/common/async.js

@@ -921,6 +921,9 @@ class DeferredPromise {
         }));
     }
     complete(value) {
+        if (this.isSettled) {
+            return Promise.resolve();
+        }
         return ( new Promise(resolve => {
             this.completeCallback(value);
             this.outcome = { outcome: DeferredOutcome.Resolved, value };
@@ -928,6 +931,9 @@ class DeferredPromise {
         }));
     }
     error(err) {
+        if (this.isSettled) {
+            return Promise.resolve();
+        }
         return ( new Promise(resolve => {
             this.errorCallback(err);
             this.outcome = { outcome: DeferredOutcome.Rejected, value: err };

package/vscode/src/vs/base/common/cancellation.d.ts

@@ -28,3 +28,24 @@ export declare class CancellationTokenSource {
     dispose(cancel?: boolean): void;
 }
 export declare function cancelOnDispose(store: DisposableStore): CancellationToken;
+/**
+ * A pool that aggregates multiple cancellation tokens. The pool's own token
+ * (accessible via `pool.token`) is cancelled only after every token added
+ * to the pool has been cancelled. Adding tokens after the pool token has
+ * been cancelled has no effect.
+ */
+export declare class CancellationTokenPool {
+    private readonly _source;
+    private readonly _listeners;
+    private _total;
+    private _cancelled;
+    private _isDone;
+    get token(): CancellationToken;
+    /**
+     * Add a token to the pool. If the token is already cancelled it is counted
+     * immediately. Tokens added after the pool token has been cancelled are ignored.
+     */
+    add(token: CancellationToken): void;
+    private _check;
+    dispose(): void;
+}

package/vscode/src/vs/base/common/cancellation.js

@@ -1,5 +1,6 @@
 
 import { Event, Emitter } from './event.js';
+import { DisposableStore } from './lifecycle.js';
 
 const shortcutEvent = ( Object.freeze(function (callback, context) {
     const handle = setTimeout(callback.bind(context), 0);
@@ -101,5 +102,45 @@ function cancelOnDispose(store) {
     store.add({ dispose() { source.cancel(); } });
     return source.token;
 }
+class CancellationTokenPool {
+    constructor() {
+        this._source = ( new CancellationTokenSource());
+        this._listeners = ( new DisposableStore());
+        this._total = 0;
+        this._cancelled = 0;
+        this._isDone = false;
+    }
+    get token() {
+        return this._source.token;
+    }
+    add(token) {
+        if (this._isDone) {
+            return;
+        }
+        this._total++;
+        if (token.isCancellationRequested) {
+            this._cancelled++;
+            this._check();
+            return;
+        }
+        const d = token.onCancellationRequested(() => {
+            d.dispose();
+            this._cancelled++;
+            this._check();
+        });
+        this._listeners.add(d);
+    }
+    _check() {
+        if (!this._isDone && this._total > 0 && this._total === this._cancelled) {
+            this._isDone = true;
+            this._listeners.dispose();
+            this._source.cancel();
+        }
+    }
+    dispose() {
+        this._listeners.dispose();
+        this._source.dispose();
+    }
+}
 
-export { CancellationToken, CancellationTokenSource, cancelOnDispose };
+export { CancellationToken, CancellationTokenPool, CancellationTokenSource, cancelOnDispose };

package/vscode/src/vs/base/common/codicons.d.ts

@@ -677,4 +677,7 @@ export declare const Codicon: {
     readonly commentDiscussionSparkle: ThemeIcon;
     readonly chatSparkleWarning: ThemeIcon;
     readonly chatSparkleError: ThemeIcon;
+    readonly collection: ThemeIcon;
+    readonly newCollection: ThemeIcon;
+    readonly thinking: ThemeIcon;
 };

package/vscode/src/vs/base/common/codiconsLibrary.d.ts

@@ -603,4 +603,7 @@ export declare const codiconsLibrary: {
     readonly commentDiscussionSparkle: import("./themables.js").ThemeIcon;
     readonly chatSparkleWarning: import("./themables.js").ThemeIcon;
     readonly chatSparkleError: import("./themables.js").ThemeIcon;
+    readonly collection: import("./themables.js").ThemeIcon;
+    readonly newCollection: import("./themables.js").ThemeIcon;
+    readonly thinking: import("./themables.js").ThemeIcon;
 };

package/vscode/src/vs/base/common/codiconsLibrary.js

@@ -606,6 +606,9 @@ const codiconsLibrary = {
     commentDiscussionSparkle: register('comment-discussion-sparkle', 0xec54),
     chatSparkleWarning: register('chat-sparkle-warning', 0xec55),
     chatSparkleError: register('chat-sparkle-error', 0xec56),
+    collection: register('collection', 0xec57),
+    newCollection: register('new-collection', 0xec58),
+    thinking: register('thinking', 0xec59),
 };
 
 export { codiconsLibrary };

package/vscode/src/vs/base/common/decorators/cancelPreviousCalls.d.ts

@@ -0,0 +1,84 @@
+import { Disposable } from "../lifecycle.js";
+import { CancellationToken } from "../cancellation.js";
+/**
+ * Helper type that represents a function that has an optional {@linkcode CancellationToken}
+ * argument argument at the end of the arguments list.
+ *
+ * @typeparam `TFunction` - Type of the function arguments list of which will be extended
+ * 							with an optional {@linkcode CancellationToken} argument.
+ */
+type TWithOptionalCancellationToken<TFunction extends Function> = TFunction extends (...args: infer TArgs) => infer TReturn ? (...args: [
+    ...TArgs,
+    cancellatioNToken?: CancellationToken
+]) => TReturn : never;
+/**
+ * Decorator that provides a mechanism to cancel previous calls of the decorated method
+ * by providing a `cancellation token` as the last argument of the method, which gets
+ * cancelled immediately on subsequent call of the decorated method.
+ *
+ * Therefore to use this decorator, the two conditions must be met:
+ *
+ * - the decorated method must have an *optional* {@linkcode CancellationToken} argument at
+ * 	 the end of the arguments list
+ * - the object that the decorated method belongs to must implement the {@linkcode Disposable};
+ *   this requirement comes from the internal implementation of the decorator that
+ *   creates new resources that need to be eventually disposed by someone
+ *
+ * @typeparam `TObject` - Object type that the decorated method belongs to.
+ * @typeparam `TArgs` - Argument list of the decorated method.
+ * @typeparam `TReturn` - Return value type of the decorated method.
+ *
+ * ### Examples
+ *
+ * ```typescript
+ * // let's say we have a class that implements the `Disposable` interface that we want
+ * // to use the decorator on
+ * class Example extends Disposable {
+ * 		async doSomethingAsync(arg1: number, arg2: string): Promise<void> {
+ * 			// do something async..
+ * 			await new Promise(resolve => setTimeout(resolve, 1000));
+ * 		}
+ * }
+ * ```
+ *
+ * ```typescript
+ * // to do that we need to add the `CancellationToken` argument to the end of args list
+ * class Example extends Disposable {
+ * 		@cancelPreviousCalls
+ * 		async doSomethingAsync(arg1: number, arg2: string, cancellationToken?: CancellationToken): Promise<void> {
+ * 			console.log(`call with args ${arg1} and ${arg2} initiated`);
+ *
+ * 			// the decorator will create the cancellation token automatically
+ * 			assertDefined(
+ * 				cancellationToken,
+ * 				`The method must now have the `CancellationToken` passed to it.`,
+ * 			);
+ *
+ * 			cancellationToken.onCancellationRequested(() => {
+ * 				console.log(`call with args ${arg1} and ${arg2} was cancelled`);
+ * 			});
+ *
+ * 			// do something async..
+ * 			await new Promise(resolve => setTimeout(resolve, 1000));
+ *
+ * 			// check cancellation token state after the async operations
+ * 			console.log(
+ * 				`call with args ${arg1} and ${arg2} completed, canceled?: ${cancellationToken.isCancellationRequested}`,
+ * 			);
+ * 		}
+ * }
+ *
+ * const example = new Example();
+ * // call the decorate method first time
+ * example.doSomethingAsync(1, 'foo');
+ * // wait for 500ms which is less than 1000ms of the async operation in the first call
+ * await new Promise(resolve => setTimeout(resolve, 500));
+ * // calling the decorate method second time cancels the token passed to the first call
+ * example.doSomethingAsync(2, 'bar');
+ * ```
+ */
+export declare function cancelPreviousCalls<TObject extends Disposable, TArgs extends unknown[], TReturn extends unknown>(_proto: TObject, methodName: string, descriptor: TypedPropertyDescriptor<TWithOptionalCancellationToken<(...args: TArgs) => TReturn>>): TypedPropertyDescriptor<(...args: [
+    ...TArgs,
+    cancellatioNToken?: CancellationToken | undefined
+]) => TReturn>;
+export {};

package/vscode/src/vs/base/common/decorators.d.ts

@@ -4,4 +4,4 @@ export interface IDebounceReducer<T> {
 }
 export declare function debounce<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): MethodDecorator;
 export declare function throttle<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): MethodDecorator;
-export { cancelPreviousCalls } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/base/common/decorators/cancelPreviousCalls";
+export { cancelPreviousCalls } from "./decorators/cancelPreviousCalls.js";

package/vscode/src/vs/base/common/htmlContent.d.ts

@@ -55,4 +55,6 @@ export declare function markdownCommandLink(command: {
     title: string;
     id: string;
     arguments?: unknown[];
+    tooltip?: string;
 }, escapeTokens?: boolean): string;
+export declare function createCommandUri(commandId: string, ...commandArgs: unknown[]): URI;

package/vscode/src/vs/base/common/htmlContent.js

@@ -153,12 +153,15 @@ function parseHrefAndDimensions(href) {
     return { href, dimensions };
 }
 function markdownCommandLink(command, escapeTokens = true) {
-    const uri = ( ( URI.from({
+    const uri = ( createCommandUri(command.id, ...(command.arguments || [])).toString());
+    return `[${escapeTokens ? escapeMarkdownSyntaxTokens(command.title) : command.title}](${uri}${command.tooltip ? ` "${escapeMarkdownSyntaxTokens(command.tooltip)}"` : ''})`;
+}
+function createCommandUri(commandId, ...commandArgs) {
+    return ( URI.from({
         scheme: Schemas.command,
-        path: command.id,
-        query: command.arguments?.length ? encodeURIComponent(JSON.stringify(command.arguments)) : undefined,
-    })).toString());
-    return `[${escapeTokens ? escapeMarkdownSyntaxTokens(command.title) : command.title}](${uri})`;
+        path: commandId,
+        query: commandArgs.length ? encodeURIComponent(JSON.stringify(commandArgs)) : undefined,
+    }));
 }
 
-export { MarkdownString, MarkdownStringTextNewlineStyle, appendEscapedMarkdownCodeBlockFence, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownCommandLink, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };
+export { MarkdownString, MarkdownStringTextNewlineStyle, appendEscapedMarkdownCodeBlockFence, createCommandUri, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownCommandLink, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };

package/vscode/src/vs/base/common/lifecycle.js

@@ -214,14 +214,28 @@ function combinedDisposable(...disposables) {
     setParentOfDisposables(disposables, parent);
     return parent;
 }
+class FunctionDisposable {
+    constructor(fn) {
+        this._isDisposed = false;
+        this._fn = fn;
+        trackDisposable(this);
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        if (!this._fn) {
+            throw ( new Error(
+                `Unbound disposable context: Need to use an arrow function to preserve the value of this`
+            ));
+        }
+        this._isDisposed = true;
+        markAsDisposed(this);
+        this._fn();
+    }
+}
 function toDisposable(fn) {
-    const self = trackDisposable({
-        dispose: createSingleCallFunction(() => {
-            markAsDisposed(self);
-            fn();
-        })
-    });
-    return self;
+    return ( new FunctionDisposable(fn));
 }
 class DisposableStore {
     static { this.DISABLE_DISPOSED_WARNING = false; }

package/vscode/src/vs/base/common/numbers.d.ts

@@ -22,49 +22,4 @@ export declare class SlidingWindowAverage {
 }
 /** Returns whether the point is within the triangle formed by the following 6 x/y point pairs */
 export declare function isPointWithinTriangle(x: number, y: number, ax: number, ay: number, bx: number, by: number, cx: number, cy: number): boolean;
-/**
- * Function to get a (pseudo)random integer from a provided `max`...[`min`] range.
- * Both `min` and `max` values are inclusive. The `min` value is optional (defaults to `0`).
- *
- * @throws in the next cases:
- * 	- if provided `min` or `max` is not a number
- *  - if provided `min` or `max` is not finite
- *  - if provided `min` is larger than `max` value
- *
- * ## Examples
- *
- * Specifying a `max` value only uses `0` as the `min` value by default:
- *
- * ```typescript
- * // get a random integer between 0 and 10
- * const randomInt = randomInt(10);
- *
- * assert(
- *   randomInt >= 0,
- *   'Should be greater than or equal to 0.',
- * );
- *
- * assert(
- *   randomInt <= 10,
- *   'Should be less than or equal to 10.',
- * );
- * ```
- * * Specifying both `max` and `min` values:
- *
- * ```typescript
- * // get a random integer between 5 and 8
- * const randomInt = randomInt(8, 5);
- *
- * assert(
- *   randomInt >= 5,
- *   'Should be greater than or equal to 5.',
- * );
- *
- * assert(
- *   randomInt <= 8,
- *   'Should be less than or equal to 8.',
- * );
- * ```
- */
-export declare function randomInt(max: number, min?: number): number;
 export declare function randomChance(p: number): boolean;

package/vscode/src/vs/base/common/oauth.d.ts

@@ -550,3 +550,36 @@ export declare function getClaimsFromJWT(token: string): IAuthorizationJWTClaims
  * ```
  */
 export declare function scopesMatch(scopes1: readonly string[], scopes2: readonly string[]): boolean;
+interface CommonResponse {
+    status: number;
+    statusText: string;
+    json(): Promise<any>;
+    text(): Promise<string>;
+}
+interface IFetcher {
+    (input: string, init: {
+        method: string;
+        headers: Record<string, string>;
+    }): Promise<CommonResponse>;
+}
+export interface IFetchResourceMetadataOptions {
+    /**
+     * Headers to include only when the resource metadata URL has the same origin as the target resource
+     */
+    sameOriginHeaders?: Record<string, string>;
+    /**
+     * Optional custom fetch implementation (defaults to global fetch)
+     */
+    fetch?: IFetcher;
+}
+/**
+ * Fetches and validates OAuth 2.0 protected resource metadata from the given URL.
+ *
+ * @param targetResource The target resource URL to compare origins with (e.g., the MCP server URL)
+ * @param resourceMetadataUrl Optional URL to fetch the resource metadata from. If not provided, will try well-known URIs.
+ * @param options Configuration options for the fetch operation
+ * @returns Promise that resolves to the validated resource metadata
+ * @throws Error if the fetch fails, returns non-200 status, or the response is invalid
+ */
+export declare function fetchResourceMetadata(targetResource: string, resourceMetadataUrl: string | undefined, options?: IFetchResourceMetadataOptions): Promise<IAuthorizationProtectedResourceMetadata>;
+export {};

package/vscode/src/vs/base/common/oauth.js

@@ -2,6 +2,7 @@
 import { decodeBase64 } from './buffer.js';
 
 const WELL_KNOWN_ROUTE = '/.well-known';
+const AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH = `${WELL_KNOWN_ROUTE}/oauth-protected-resource`;
 const AUTH_SERVER_METADATA_DISCOVERY_PATH = `${WELL_KNOWN_ROUTE}/oauth-authorization-server`;
 const OPENID_CONNECT_DISCOVERY_PATH = `${WELL_KNOWN_ROUTE}/openid-configuration`;
 const AUTH_SCOPE_SEPARATOR = ' ';
@@ -129,9 +130,7 @@ async function fetchDynamicRegistration(serverMetadata, clientName, scopes) {
             redirect_uris: [
                 'https://insiders.vscode.dev/redirect',
                 'https://vscode.dev/redirect',
-                'http://localhost/',
                 'http://127.0.0.1/',
-                `http://localhost:${DEFAULT_AUTH_FLOW_PORT}/`,
                 `http://127.0.0.1:${DEFAULT_AUTH_FLOW_PORT}/`
             ],
             scope: scopes?.join(AUTH_SCOPE_SEPARATOR),
@@ -265,5 +264,82 @@ function scopesMatch(scopes1, scopes2) {
     const sortedScopes2 = [...scopes2].sort();
     return sortedScopes1.every((scope, index) => scope === sortedScopes2[index]);
 }
+async function fetchResourceMetadata(targetResource, resourceMetadataUrl, options = {}) {
+    const { sameOriginHeaders = {}, fetch: fetchImpl = fetch } = options;
+    const targetResourceUrlObj = ( new URL(targetResource));
+    let urlsToTry;
+    if (!resourceMetadataUrl) {
+        const pathComponent = targetResourceUrlObj.pathname === '/' ? undefined : targetResourceUrlObj.pathname;
+        const rootUrl = `${targetResourceUrlObj.origin}${AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH}`;
+        if (pathComponent) {
+            urlsToTry = [
+                `${rootUrl}${pathComponent}`,
+                rootUrl
+            ];
+        }
+        else {
+            urlsToTry = [rootUrl];
+        }
+    }
+    else {
+        urlsToTry = [resourceMetadataUrl];
+    }
+    const errors = [];
+    for (const urlToTry of urlsToTry) {
+        try {
+            let headers = {
+                'Accept': 'application/json'
+            };
+            const resourceMetadataUrlObj = ( new URL(urlToTry));
+            if (resourceMetadataUrlObj.origin === targetResourceUrlObj.origin) {
+                headers = {
+                    ...headers,
+                    ...sameOriginHeaders
+                };
+            }
+            const response = await fetchImpl(urlToTry, { method: 'GET', headers });
+            if (response.status !== 200) {
+                let errorText;
+                try {
+                    errorText = await response.text();
+                }
+                catch {
+                    errorText = response.statusText;
+                }
+                errors.push(( new Error(
+                    `Failed to fetch resource metadata from ${urlToTry}: ${response.status} ${errorText}`
+                )));
+                continue;
+            }
+            const body = await response.json();
+            if (isAuthorizationProtectedResourceMetadata(body)) {
+                const prmValue = ( ( new URL(body.resource)).toString());
+                const targetValue = ( targetResourceUrlObj.toString());
+                if (prmValue !== targetValue) {
+                    throw ( new Error(
+                        `Protected Resource Metadata resource property value "${prmValue}" (length: ${prmValue.length}) does not match target server url "${targetValue}" (length: ${targetValue.length}). These MUST match to follow OAuth spec https://datatracker.ietf.org/doc/html/rfc9728#PRConfigurationValidation`
+                    ));
+                }
+                return body;
+            }
+            else {
+                errors.push(( new Error(
+                    `Invalid resource metadata from ${urlToTry}. Expected to follow shape of https://datatracker.ietf.org/doc/html/rfc9728#name-protected-resource-metadata (Hints: is scopes_supported an array? Is resource a string?). Current payload: ${JSON.stringify(body)}`
+                )));
+                continue;
+            }
+        }
+        catch (e) {
+            errors.push(e instanceof Error ? e : ( new Error(String(e))));
+            continue;
+        }
+    }
+    if (errors.length === 1) {
+        throw errors[0];
+    }
+    else {
+        throw ( new AggregateError(errors, 'Failed to fetch resource metadata from all attempted URLs'));
+    }
+}
 
-export { AUTH_SCOPE_SEPARATOR, AUTH_SERVER_METADATA_DISCOVERY_PATH, AuthorizationDeviceCodeErrorType, AuthorizationErrorType, AuthorizationRegistrationErrorType, DEFAULT_AUTH_FLOW_PORT, OPENID_CONNECT_DISCOVERY_PATH, fetchDynamicRegistration, getClaimsFromJWT, getDefaultMetadataForUrl, isAuthorizationDynamicClientRegistrationResponse, isAuthorizationErrorResponse, isAuthorizationProtectedResourceMetadata, isAuthorizationRegistrationErrorResponse, isAuthorizationServerMetadata, isAuthorizationTokenResponse, parseWWWAuthenticateHeader, scopesMatch };
+export { AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH, AUTH_SCOPE_SEPARATOR, AUTH_SERVER_METADATA_DISCOVERY_PATH, AuthorizationDeviceCodeErrorType, AuthorizationErrorType, AuthorizationRegistrationErrorType, DEFAULT_AUTH_FLOW_PORT, OPENID_CONNECT_DISCOVERY_PATH, fetchDynamicRegistration, fetchResourceMetadata, getClaimsFromJWT, getDefaultMetadataForUrl, isAuthorizationDynamicClientRegistrationResponse, isAuthorizationErrorResponse, isAuthorizationProtectedResourceMetadata, isAuthorizationRegistrationErrorResponse, isAuthorizationServerMetadata, isAuthorizationTokenResponse, parseWWWAuthenticateHeader, scopesMatch };

package/vscode/src/vs/base/common/observableInternal/base.d.ts

@@ -74,6 +74,10 @@ export interface IObservableWithChange<T, TChange = unknown> {
      * A human-readable name for debugging purposes.
      */
     readonly debugName: string;
+    /**
+     * ONLY FOR DEBUGGING!
+    */
+    debugGetDependencyGraph(): string;
     /**
      * This property captures the type of the change object. Do not use it at runtime!
      */

package/vscode/src/vs/base/common/observableInternal/index.js

@@ -4,6 +4,7 @@ import '../arrays.js';
 import '../event.js';
 import '../lifecycle.js';
 import { setLogObservableFn, addLogger } from './logging/logging.js';
+import { _setDebugGetDependencyGraph } from './observables/baseObservable.js';
 export { DebugLocation } from './debugLocation.js';
 import './reactions/autorunImpl.js';
 export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter } from './observables/derived.js';
@@ -14,7 +15,9 @@ export { observableFromEvent, observableFromEventOpts } from './observables/obse
 import { logObservableToConsole } from './logging/consoleObservableLogger.js';
 import { DevToolsLogger } from './logging/debugger/devToolsLogger.js';
 import { env } from '../process.js';
+import { debugGetDependencyGraph } from './logging/debugGetDependencyGraph.js';
 
+_setDebugGetDependencyGraph(debugGetDependencyGraph);
 setLogObservableFn(logObservableToConsole);
 if (env && env['VSCODE_DEV_DEBUG_OBSERVABLES']) {
     addLogger(DevToolsLogger.getInstance());

package/vscode/src/vs/base/common/observableInternal/logging/debugGetDependencyGraph.d.ts

@@ -0,0 +1,4 @@
+import { IObservable, IObserver } from "../base.js";
+export declare function debugGetDependencyGraph(obs: IObservable<any> | IObserver, options?: {
+    debugNamePostProcessor?: (name: string) => string;
+}): string;