@codingame/monaco-vscode-api 20.5.0 → 21.0.1

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

@@ -12,3 +12,7 @@ export declare function getMediaMime(path: string): string | undefined;
 export declare function getExtensionForMimeType(mimeType: string): string | undefined;
 export declare function normalizeMimeType(mimeType: string): string;
 export declare function normalizeMimeType(mimeType: string, strict: true): string | undefined;
+/**
+ * Whether the provided mime type is a text stream like `stdout`, `stderr`.
+ */
+export declare function isTextStreamMime(mimeType: string): boolean;

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

@@ -104,5 +104,8 @@ function normalizeMimeType(mimeType, strict) {
     }
     return `${match[1].toLowerCase()}/${match[2].toLowerCase()}${match[3] ?? ''}`;
 }
+function isTextStreamMime(mimeType) {
+    return ['application/vnd.code.notebook.stdout', 'application/vnd.code.notebook.stderr'].includes(mimeType);
+}
 
-export { Mimes, getExtensionForMimeType, getMediaMime, getMediaOrTextMime, normalizeMimeType };
+export { Mimes, getExtensionForMimeType, getMediaMime, getMediaOrTextMime, isTextStreamMime, normalizeMimeType };

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

@@ -99,6 +99,11 @@ export declare namespace Schemas {
      * Scheme used for the accessible view
      */
     const accessibleView = "accessible-view";
+    /**
+     * Used for snapshots of chat edits
+     */
+    const chatEditingSnapshotScheme = "chat-editing-snapshot-text-model";
+    const chatEditingModel = "chat-editing-text-model";
 }
 export declare function matchesScheme(target: URI | string, scheme: string): boolean;
 export declare function matchesSomeScheme(target: URI | string, ...schemes: string[]): boolean;

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

@@ -52,6 +52,8 @@ var Schemas;
     Schemas.codeSetting = 'code-setting';
     Schemas.outputChannel = 'output';
     Schemas.accessibleView = 'accessible-view';
+    Schemas.chatEditingSnapshotScheme = 'chat-editing-snapshot-text-model';
+    Schemas.chatEditingModel = 'chat-editing-text-model';
 })(Schemas || (Schemas = {}));
 function matchesScheme(target, scheme) {
     if (URI.isUri(target)) {

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

@@ -529,8 +529,24 @@ export declare function getDefaultMetadataForUrl(authorizationServer: URL): IAut
  */
 export declare const DEFAULT_AUTH_FLOW_PORT = 33418;
 export declare function fetchDynamicRegistration(serverMetadata: IAuthorizationServerMetadata, clientName: string, scopes?: string[]): Promise<IAuthorizationDynamicClientRegistrationResponse>;
-export declare function parseWWWAuthenticateHeader(wwwAuthenticateHeaderValue: string): {
+export interface IAuthenticationChallenge {
     scheme: string;
     params: Record<string, string>;
-};
+}
+export declare function parseWWWAuthenticateHeader(wwwAuthenticateHeaderValue: string): IAuthenticationChallenge[];
 export declare function getClaimsFromJWT(token: string): IAuthorizationJWTClaims;
+/**
+ * Checks if two scope lists are equivalent, regardless of order.
+ * This is useful for comparing OAuth scopes where the order should not matter.
+ *
+ * @param scopes1 First list of scopes to compare
+ * @param scopes2 Second list of scopes to compare
+ * @returns true if the scope lists contain the same scopes (order-independent), false otherwise
+ *
+ * @example
+ * ```typescript
+ * scopesMatch(['read', 'write'], ['write', 'read']) // Returns: true
+ * scopesMatch(['read'], ['write']) // Returns: false
+ * ```
+ */
+export declare function scopesMatch(scopes1: readonly string[], scopes2: readonly string[]): boolean;

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

@@ -33,14 +33,43 @@ function isAuthorizationProtectedResourceMetadata(obj) {
         return false;
     }
     const metadata = obj;
-    return metadata.resource !== undefined;
+    if (!metadata.resource) {
+        return false;
+    }
+    if (metadata.scopes_supported !== undefined && !Array.isArray(metadata.scopes_supported)) {
+        return false;
+    }
+    return true;
 }
+const urisToCheck = [
+    'issuer',
+    'authorization_endpoint',
+    'token_endpoint',
+    'registration_endpoint',
+    'jwks_uri'
+];
 function isAuthorizationServerMetadata(obj) {
     if (typeof obj !== 'object' || obj === null) {
         return false;
     }
     const metadata = obj;
-    return metadata.issuer !== undefined;
+    if (!metadata.issuer) {
+        throw ( new Error('Authorization server metadata must have an issuer'));
+    }
+    for (const uri of urisToCheck) {
+        if (!metadata[uri]) {
+            continue;
+        }
+        if (typeof metadata[uri] !== 'string') {
+            throw ( new Error(`Authorization server metadata '${uri}' must be a string`));
+        }
+        if (!metadata[uri].startsWith('https://') && !metadata[uri].startsWith('http://')) {
+            throw ( new Error(
+                `Authorization server metadata '${uri}' must start with http:// or https://`
+            ));
+        }
+    }
+    return true;
 }
 function isAuthorizationDynamicClientRegistrationResponse(obj) {
     if (typeof obj !== 'object' || obj === null) {
@@ -100,10 +129,10 @@ 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}`
+                '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),
             token_endpoint_auth_method: 'none',
@@ -134,24 +163,82 @@ async function fetchDynamicRegistration(serverMetadata, clientName, scopes) {
     ));
 }
 function parseWWWAuthenticateHeader(wwwAuthenticateHeaderValue) {
-    const parts = wwwAuthenticateHeaderValue.split(' ');
-    const scheme = parts[0];
-    const params = {};
-    if (parts.length > 1) {
-        const attributes = parts.slice(1).join(' ').split(',');
-        attributes.forEach(attr => {
-            const [key, value] = ( attr.split('=').map(s => s.trim().replace(/"/g, '')));
-            params[key] = value;
-        });
-    }
-    return { scheme, params };
+    const challenges = [];
+    const tokens = [];
+    let current = '';
+    let inQuotes = false;
+    for (let i = 0; i < wwwAuthenticateHeaderValue.length; i++) {
+        const char = wwwAuthenticateHeaderValue[i];
+        if (char === '"') {
+            inQuotes = !inQuotes;
+            current += char;
+        }
+        else if (char === ',' && !inQuotes) {
+            if (current.trim()) {
+                tokens.push(current.trim());
+            }
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim()) {
+        tokens.push(current.trim());
+    }
+    let currentChallenge;
+    for (const token of tokens) {
+        const hasEquals = token.includes('=');
+        if (!hasEquals) {
+            if (currentChallenge) {
+                challenges.push(currentChallenge);
+            }
+            currentChallenge = { scheme: token.trim(), params: {} };
+        }
+        else {
+            const spaceIndex = token.indexOf(' ');
+            if (spaceIndex > 0) {
+                const beforeSpace = token.substring(0, spaceIndex);
+                const afterSpace = token.substring(spaceIndex + 1);
+                if (!beforeSpace.includes('=') && afterSpace.includes('=')) {
+                    if (currentChallenge) {
+                        challenges.push(currentChallenge);
+                    }
+                    currentChallenge = { scheme: beforeSpace.trim(), params: {} };
+                    const equalIndex = afterSpace.indexOf('=');
+                    if (equalIndex > 0) {
+                        const key = afterSpace.substring(0, equalIndex).trim();
+                        const value = afterSpace.substring(equalIndex + 1).trim().replace(/^"|"$/g, '');
+                        if (key && value !== undefined) {
+                            currentChallenge.params[key] = value;
+                        }
+                    }
+                    continue;
+                }
+            }
+            if (currentChallenge) {
+                const equalIndex = token.indexOf('=');
+                if (equalIndex > 0) {
+                    const key = token.substring(0, equalIndex).trim();
+                    const value = token.substring(equalIndex + 1).trim().replace(/^"|"$/g, '');
+                    if (key && value !== undefined) {
+                        currentChallenge.params[key] = value;
+                    }
+                }
+            }
+        }
+    }
+    if (currentChallenge) {
+        challenges.push(currentChallenge);
+    }
+    return challenges;
 }
 function getClaimsFromJWT(token) {
     const parts = token.split('.');
     if (parts.length !== 3) {
         throw ( new Error('Invalid JWT token format: token must have three parts separated by dots'));
     }
-    const [header, payload, _signature] = parts;
+    const [header, payload] = parts;
     try {
         const decodedHeader = JSON.parse(( decodeBase64(header).toString()));
         if (typeof decodedHeader !== 'object') {
@@ -170,5 +257,13 @@ function getClaimsFromJWT(token) {
         throw ( new Error('Failed to parse JWT token'));
     }
 }
+function scopesMatch(scopes1, scopes2) {
+    if (scopes1.length !== scopes2.length) {
+        return false;
+    }
+    const sortedScopes1 = [...scopes1].sort();
+    const sortedScopes2 = [...scopes2].sort();
+    return sortedScopes1.every((scope, index) => scope === sortedScopes2[index]);
+}
 
-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 };
+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 };

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

@@ -0,0 +1,20 @@
+export type DebugLocation = DebugLocationImpl | undefined;
+export declare namespace DebugLocation {
+    function enable(): void;
+    function ofCaller(): DebugLocation;
+}
+declare class DebugLocationImpl implements ILocation {
+    readonly fileName: string;
+    readonly line: number;
+    readonly column: number;
+    readonly id: string;
+    static fromStack(stack: string, parentIdx: number): DebugLocationImpl | undefined;
+    constructor(fileName: string, line: number, column: number, id: string);
+}
+export interface ILocation {
+    fileName: string;
+    line: number;
+    column: number;
+    id: string;
+}
+export {};

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

@@ -0,0 +1,63 @@
+
+
+var DebugLocation;
+(function (DebugLocation) {
+    let enabled = false;
+    function enable() {
+        enabled = true;
+    }
+    DebugLocation.enable = enable;
+    function ofCaller() {
+        if (!enabled) {
+            return undefined;
+        }
+        const Err = Error;
+        const l = Err.stackTraceLimit;
+        Err.stackTraceLimit = 3;
+        const stack = ( new Error()).stack;
+        Err.stackTraceLimit = l;
+        return DebugLocationImpl.fromStack(stack, 2);
+    }
+    DebugLocation.ofCaller = ofCaller;
+})(DebugLocation || (DebugLocation = {}));
+class DebugLocationImpl {
+    static fromStack(stack, parentIdx) {
+        const lines = stack.split('\n');
+        const location = parseLine(lines[parentIdx + 1]);
+        if (location) {
+            return ( new DebugLocationImpl(location.fileName, location.line, location.column, location.id));
+        }
+        else {
+            return undefined;
+        }
+    }
+    constructor(fileName, line, column, id) {
+        this.fileName = fileName;
+        this.line = line;
+        this.column = column;
+        this.id = id;
+    }
+}
+function parseLine(stackLine) {
+    const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);
+    if (match) {
+        return {
+            fileName: match[1],
+            line: parseInt(match[2]),
+            column: parseInt(match[3]),
+            id: stackLine,
+        };
+    }
+    const match2 = stackLine.match(/at ([^\(\)]*):(\d+):(\d+)/);
+    if (match2) {
+        return {
+            fileName: match2[1],
+            line: parseInt(match2[2]),
+            column: parseInt(match2[3]),
+            id: stackLine,
+        };
+    }
+    return undefined;
+}
+
+export { DebugLocation };

package/vscode/src/vs/base/common/observableInternal/experimental/reducer.js

@@ -6,6 +6,7 @@ import '../../lifecycle.js';
 import { subtransaction } from '../transaction.js';
 import { DebugNameData } from '../debugName.js';
 import { DerivedWithSetter } from '../observables/derivedImpl.js';
+import { DebugLocation } from '../debugLocation.js';
 
 function observableReducerSettable(owner, options) {
     let prevValue = undefined;
@@ -31,7 +32,7 @@ function observableReducerSettable(owner, options) {
             prevValue = value;
             d.setValue(value, tx, change);
         });
-    }));
+    }, DebugLocation.ofCaller()));
     return d;
 }
 

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

@@ -1,5 +1,5 @@
 export { observableValueOpts } from "./observables/observableValueOpts.js";
-export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges, autorunIterableDelta } from "./reactions/autorun.js";
+export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges, autorunIterableDelta, autorunSelfDisposable } from "./reactions/autorun.js";
 export { type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type ISettableObservable, type ITransaction } from "./base.js";
 export { disposableObservableValue } from "./observables/observableValue.js";
 export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from "./observables/derived.js";
@@ -21,3 +21,4 @@ export { observableFromEvent } from "./observables/observableFromEvent.js";
 export { observableValue } from "./observables/observableValue.js";
 export { ObservableSet } from "./set.js";
 export { ObservableMap } from "./map.js";
+export { DebugLocation } from "./debugLocation.js";

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';
+export { DebugLocation } from './debugLocation.js';
 import './reactions/autorunImpl.js';
 export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter } from './observables/derived.js';
 import '../cancellation.js';
@@ -15,6 +16,6 @@ import { DevToolsLogger } from './logging/debugger/devToolsLogger.js';
 import { env } from '../process.js';
 
 setLogObservableFn(logObservableToConsole);
-if (env && env['VSCODE_DEV_DEBUG']) {
+if (env && env['VSCODE_DEV_DEBUG_OBSERVABLES']) {
     addLogger(DevToolsLogger.getInstance());
 }

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

@@ -3,6 +3,7 @@ import { TransactionImpl } from "../../transaction.js";
 import { IChangeInformation, IObservableLogger } from "../logging.js";
 import { IObservable } from "../../base.js";
 import { Derived } from "../../observables/derivedImpl.js";
+import { DebugLocation } from "../../debugLocation.js";
 export declare class DevToolsLogger implements IObservableLogger {
     private static _instance;
     static getInstance(): DevToolsLogger;
@@ -26,10 +27,10 @@ export declare class DevToolsLogger implements IObservableLogger {
     private _handleChange;
     private readonly _flushUpdates;
     private _getDeclarationId;
-    handleObservableCreated(observable: IObservable<any>): void;
+    handleObservableCreated(observable: IObservable<any>, location: DebugLocation): void;
     handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void;
     handleObservableUpdated(observable: IObservable<any>, changeInfo: IChangeInformation): void;
-    handleAutorunCreated(autorun: AutorunObserver): void;
+    handleAutorunCreated(autorun: AutorunObserver, location: DebugLocation): void;
     handleAutorunDisposed(autorun: AutorunObserver): void;
     handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void;
     handleAutorunStarted(autorun: AutorunObserver): void;

package/vscode/src/vs/base/common/observableInternal/logging/debugger/devToolsLogger.js

@@ -2,12 +2,13 @@
 import { AutorunObserver, AutorunState } from '../../reactions/autorunImpl.js';
 import { formatValue } from '../consoleObservableLogger.js';
 import { registerDebugChannel } from './debuggerRpc.js';
-import { Throttler, deepAssignDeleteNulls, deepAssign, getFirstStackFrameOutsideOf } from './utils.js';
+import { Throttler, deepAssignDeleteNulls, deepAssign } from './utils.js';
 import { isDefined } from '../../../types.js';
 import { FromEventObservable } from '../../observables/observableFromEvent.js';
 import { onUnexpectedError, BugIndicatingError } from '../../../errors.js';
 import { Derived, DerivedState } from '../../observables/derivedImpl.js';
 import { ObservableValue } from '../../observables/observableValue.js';
+import { DebugLocation } from '../../debugLocation.js';
 
 class DevToolsLogger {
     static { this._instance = undefined; }
@@ -247,6 +248,7 @@ class DevToolsLogger {
                 this._pendingChanges = null;
             }
         };
+        DebugLocation.enable();
     }
     _handleChange(update) {
         deepAssignDeleteNulls(this._fullState, update);
@@ -258,46 +260,26 @@ class DevToolsLogger {
         }
         this._changeThrottler.throttle(this._flushUpdates, 10);
     }
-    _getDeclarationId(type) {
-        let shallow = true;
-        let loc;
-        const Err = Error;
-        while (true) {
-            const l = Err.stackTraceLimit;
-            Err.stackTraceLimit = shallow ? 6 : 20;
-            const stack = ( new Error()).stack;
-            Err.stackTraceLimit = l;
-            let result = getFirstStackFrameOutsideOf(stack, /[/\\]observableInternal[/\\]|\.observe|[/\\]util(s)?\./);
-            if (!shallow && !result) {
-                result = getFirstStackFrameOutsideOf(stack, /[/\\]observableInternal[/\\]|\.observe/);
-            }
-            if (result) {
-                loc = result;
-                break;
-            }
-            if (!shallow) {
-                console.error('Could not find location for declaration', ( new Error()).stack);
-                loc = { fileName: 'unknown', line: 0, column: 0, id: 'unknown' };
-                break;
-            }
-            shallow = false;
+    _getDeclarationId(type, location) {
+        if (!location) {
+            return -1;
         }
-        let decInfo = this._declarations.get(loc.id);
+        let decInfo = this._declarations.get(location.id);
         if (decInfo === undefined) {
             decInfo = {
                 id: this._declarationId++,
                 type,
-                url: loc.fileName,
-                line: loc.line,
-                column: loc.column,
+                url: location.fileName,
+                line: location.line,
+                column: location.column,
             };
-            this._declarations.set(loc.id, decInfo);
+            this._declarations.set(location.id, decInfo);
             this._handleChange({ decls: { [decInfo.id]: decInfo } });
         }
         return decInfo.id;
     }
-    handleObservableCreated(observable) {
-        const declarationId = this._getDeclarationId('observable/value');
+    handleObservableCreated(observable, location) {
+        const declarationId = this._getDeclarationId('observable/value', location);
         const info = {
             declarationId,
             instanceId: this._instanceId++,
@@ -353,8 +335,8 @@ class DevToolsLogger {
             }
         }
     }
-    handleAutorunCreated(autorun) {
-        const declarationId = this._getDeclarationId('autorun');
+    handleAutorunCreated(autorun, location) {
+        const declarationId = this._getDeclarationId('autorun', location);
         const info = {
             declarationId,
             instanceId: this._instanceId++,

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

@@ -1,11 +1,4 @@
 import { IDisposable } from "../../../lifecycle.js";
-export declare function getFirstStackFrameOutsideOf(stack: string, pattern?: RegExp): ILocation | undefined;
-export interface ILocation {
-    fileName: string;
-    line: number;
-    column: number;
-    id: string;
-}
 export declare class Debouncer implements IDisposable {
     private _timeout;
     debounce(fn: () => void, timeoutMs: number): void;

package/vscode/src/vs/base/common/observableInternal/logging/debugger/utils.js

@@ -1,46 +1,5 @@
 
 
-function getFirstStackFrameOutsideOf(stack, pattern) {
-    const lines = stack.split('\n');
-    for (let i = 1; i < lines.length; i++) {
-        const line = lines[i];
-        if (pattern && pattern.test(line)) {
-            continue;
-        }
-        const showFramesUpMatch = line.match(/\$show(\d+)FramesUp/);
-        if (showFramesUpMatch) {
-            const n = parseInt(showFramesUpMatch[1], 10);
-            i += (n - 1);
-            continue;
-        }
-        const result = parseLine(line);
-        if (result) {
-            return result;
-        }
-    }
-    return undefined;
-}
-function parseLine(stackLine) {
-    const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);
-    if (match) {
-        return {
-            fileName: match[1],
-            line: parseInt(match[2]),
-            column: parseInt(match[3]),
-            id: stackLine,
-        };
-    }
-    const match2 = stackLine.match(/at ([^\(\)]*):(\d+):(\d+)/);
-    if (match2) {
-        return {
-            fileName: match2[1],
-            line: parseInt(match2[2]),
-            column: parseInt(match2[3]),
-            id: stackLine,
-        };
-    }
-    return undefined;
-}
 class Throttler {
     constructor() {
         this._timeout = undefined;
@@ -83,4 +42,4 @@ function deepAssignDeleteNulls(target, source) {
     }
 }
 
-export { Throttler, deepAssign, deepAssignDeleteNulls, getFirstStackFrameOutsideOf };
+export { Throttler, deepAssign, deepAssignDeleteNulls };

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

@@ -2,6 +2,7 @@ import { AutorunObserver } from "../reactions/autorunImpl.js";
 import { IObservable } from "../base.js";
 import { TransactionImpl } from "../transaction.js";
 import type { Derived } from "../observables/derivedImpl.js";
+import { DebugLocation } from "../debugLocation.js";
 export declare function addLogger(logger: IObservableLogger): void;
 export declare function getLogger(): IObservableLogger | undefined;
 export declare function setLogObservableFn(fn: (obs: IObservable<any>) => void): void;
@@ -14,10 +15,10 @@ export interface IChangeInformation {
     hadValue: boolean;
 }
 export interface IObservableLogger {
-    handleObservableCreated(observable: IObservable<any>): void;
+    handleObservableCreated(observable: IObservable<any>, location: DebugLocation): void;
     handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void;
     handleObservableUpdated(observable: IObservable<any>, info: IChangeInformation): void;
-    handleAutorunCreated(autorun: AutorunObserver): void;
+    handleAutorunCreated(autorun: AutorunObserver, location: DebugLocation): void;
     handleAutorunDisposed(autorun: AutorunObserver): void;
     handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void;
     handleAutorunStarted(autorun: AutorunObserver): void;

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

@@ -28,9 +28,9 @@ class ComposedLogger {
     constructor(loggers) {
         this.loggers = loggers;
     }
-    handleObservableCreated(observable) {
+    handleObservableCreated(observable, location) {
         for (const logger of this.loggers) {
-            logger.handleObservableCreated(observable);
+            logger.handleObservableCreated(observable, location);
         }
     }
     handleOnListenerCountChanged(observable, newCount) {
@@ -43,9 +43,9 @@ class ComposedLogger {
             logger.handleObservableUpdated(observable, info);
         }
     }
-    handleAutorunCreated(autorun) {
+    handleAutorunCreated(autorun, location) {
         for (const logger of this.loggers) {
-            logger.handleAutorunCreated(autorun);
+            logger.handleAutorunCreated(autorun, location);
         }
     }
     handleAutorunDisposed(autorun) {

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

@@ -1,5 +1,6 @@
 import { IObservableWithChange, IObserver, IReader, IObservable } from "../base.js";
 import { DisposableStore } from "../commonFacade/deps.js";
+import { DebugLocation } from "../debugLocation.js";
 import { DebugOwner } from "../debugName.js";
 import type { keepObserved, recomputeInitiallyAndOnChange } from "../utils/utils.js";
 import { derivedOpts } from "./derived.js";
@@ -42,7 +43,7 @@ export declare abstract class ConvenientObservable<T, TChange> implements IObser
 }
 export declare abstract class BaseObservable<T, TChange = void> extends ConvenientObservable<T, TChange> {
     protected readonly _observers: Set<IObserver>;
-    constructor();
+    constructor(debugLocation: DebugLocation);
     addObserver(observer: IObserver): void;
     removeObserver(observer: IObserver): void;
     protected onFirstObserverAdded(): void;

package/vscode/src/vs/base/common/observableInternal/observables/baseObservable.js

@@ -1,4 +1,5 @@
 
+import { DebugLocation } from '../debugLocation.js';
 import { getFunctionName } from '../debugName.js';
 import { getLogger, logObservable } from '../logging/logging.js';
 
@@ -27,7 +28,7 @@ class ConvenientObservable {
             return this.get();
         }
     }
-    map(fnOrOwner, fnOrUndefined) {
+    map(fnOrOwner, fnOrUndefined, debugLocation = DebugLocation.ofCaller()) {
         const owner = fnOrUndefined === undefined ? undefined : fnOrOwner;
         const fn = fnOrUndefined === undefined ? fnOrOwner : fnOrUndefined;
         return _derived({
@@ -48,7 +49,7 @@ class ConvenientObservable {
                 return undefined;
             },
             debugReferenceFn: fn,
-        }, (reader) => fn(this.read(reader), reader));
+        }, (reader) => fn(this.read(reader), reader), debugLocation);
     }
     flatten() {
         return _derived({
@@ -69,10 +70,10 @@ class ConvenientObservable {
     }
 }
 class BaseObservable extends ConvenientObservable {
-    constructor() {
+    constructor(debugLocation) {
         super();
         this._observers = ( new Set());
-        getLogger()?.handleObservableCreated(this);
+        getLogger()?.handleObservableCreated(this, debugLocation);
     }
     addObserver(observer) {
         const len = this._observers.size;
@@ -99,7 +100,7 @@ class BaseObservable extends ConvenientObservable {
         const hadLogger = !!getLogger();
         logObservable(this);
         if (!hadLogger) {
-            getLogger()?.handleObservableCreated(this);
+            getLogger()?.handleObservableCreated(this, DebugLocation.ofCaller());
         }
         return this;
     }