@codingame/monaco-vscode-api 20.5.0 → 21.0.0

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

@@ -1,6 +1,7 @@
 import { IObservable, IReader, ITransaction, ISettableObservable, IObservableWithChange } from "../base.js";
 import { IChangeTracker } from "../changeTracker.js";
 import { DisposableStore, EqualityComparer, IDisposable } from "../commonFacade/deps.js";
+import { DebugLocation } from "../debugLocation.js";
 import { DebugOwner, IDebugNameData } from "../debugName.js";
 import { IDerivedReader } from "./derivedImpl.js";
 /**
@@ -11,11 +12,11 @@ import { IDerivedReader } from "./derivedImpl.js";
  */
 export declare function derived<T, TChange = void>(computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
 export declare function derived<T, TChange = void>(owner: DebugOwner, computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
-export declare function derivedWithSetter<T>(owner: DebugOwner | undefined, computeFn: (reader: IReader) => T, setter: (value: T, transaction: ITransaction | undefined) => void): ISettableObservable<T>;
+export declare function derivedWithSetter<T>(owner: DebugOwner | undefined, computeFn: (reader: IReader) => T, setter: (value: T, transaction: ITransaction | undefined) => void, debugLocation?: DebugLocation): ISettableObservable<T>;
 export declare function derivedOpts<T>(options: IDebugNameData & {
     equalsFn?: EqualityComparer<T>;
     onLastObserverRemoved?: (() => void);
-}, computeFn: (reader: IReader) => T): IObservable<T>;
+}, computeFn: (reader: IReader) => T, debugLocation?: DebugLocation): IObservable<T>;
 /**
  * Represents an observable that is derived from other observables.
  * The value is only recomputed when absolutely needed.
@@ -32,7 +33,7 @@ export declare function derivedOpts<T>(options: IDebugNameData & {
 export declare function derivedHandleChanges<T, TDelta, TChangeSummary>(options: IDebugNameData & {
     changeTracker: IChangeTracker<TChangeSummary>;
     equalityComparer?: EqualityComparer<T>;
-}, computeFn: (reader: IDerivedReader<TDelta>, changeSummary: TChangeSummary) => T): IObservableWithChange<T, TDelta>;
+}, computeFn: (reader: IDerivedReader<TDelta>, changeSummary: TChangeSummary) => T, debugLocation?: DebugLocation): IObservableWithChange<T, TDelta>;
 /**
  * @deprecated Use `derived(reader => { reader.store.add(...) })` instead!
 */

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

@@ -3,27 +3,28 @@ import '../../errors.js';
 import { strictEquals } from '../../equals.js';
 import '../../event.js';
 import { DisposableStore } from '../../lifecycle.js';
+import { DebugLocation } from '../debugLocation.js';
 import { DebugNameData } from '../debugName.js';
 import { _setDerivedOpts } from './baseObservable.js';
 import { Derived, DerivedWithSetter } from './derivedImpl.js';
 
-function derived(computeFnOrOwner, computeFn) {
+function derived(computeFnOrOwner, computeFn, debugLocation = DebugLocation.ofCaller()) {
     if (computeFn !== undefined) {
-        return ( new Derived(( new DebugNameData(computeFnOrOwner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals));
+        return ( new Derived(( new DebugNameData(computeFnOrOwner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals, debugLocation));
     }
-    return ( new Derived(( new DebugNameData(undefined, undefined, computeFnOrOwner)), computeFnOrOwner, undefined, undefined, strictEquals));
+    return ( new Derived(( new DebugNameData(undefined, undefined, computeFnOrOwner)), computeFnOrOwner, undefined, undefined, strictEquals, debugLocation));
 }
-function derivedWithSetter(owner, computeFn, setter) {
-    return ( new DerivedWithSetter(( new DebugNameData(owner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals, setter));
+function derivedWithSetter(owner, computeFn, setter, debugLocation = DebugLocation.ofCaller()) {
+    return ( new DerivedWithSetter(( new DebugNameData(owner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals, setter, debugLocation));
 }
-function derivedOpts(options, computeFn) {
-    return ( new Derived(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn)), computeFn, undefined, options.onLastObserverRemoved, options.equalsFn ?? strictEquals));
+function derivedOpts(options, computeFn, debugLocation = DebugLocation.ofCaller()) {
+    return ( new Derived(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn)), computeFn, undefined, options.onLastObserverRemoved, options.equalsFn ?? strictEquals, debugLocation));
 }
 _setDerivedOpts(derivedOpts);
-function derivedHandleChanges(options, computeFn) {
-    return ( new Derived(( new DebugNameData(options.owner, options.debugName, undefined)), computeFn, options.changeTracker, undefined, options.equalityComparer ?? strictEquals));
+function derivedHandleChanges(options, computeFn, debugLocation = DebugLocation.ofCaller()) {
+    return ( new Derived(( new DebugNameData(options.owner, options.debugName, undefined)), computeFn, options.changeTracker, undefined, options.equalityComparer ?? strictEquals, debugLocation));
 }
-function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
+function derivedDisposable(computeFnOrOwner, computeFnOrUndefined, debugLocation = DebugLocation.ofCaller()) {
     let computeFn;
     let owner;
     if (computeFnOrUndefined === undefined) {
@@ -52,7 +53,7 @@ function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
             store.dispose();
             store = undefined;
         }
-    }, strictEquals));
+    }, strictEquals, debugLocation));
 }
 
 export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter };

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

@@ -3,6 +3,7 @@ import { BaseObservable } from "./baseObservable.js";
 import { DebugNameData } from "../debugName.js";
 import { DisposableStore, EqualityComparer } from "../commonFacade/deps.js";
 import { IChangeTracker } from "../changeTracker.js";
+import { DebugLocation } from "../debugLocation.js";
 export interface IDerivedReader<TChange = void> extends IReaderWithStore {
     /**
      * Call this to report a change delta or to force report a change, even if the new value is the same as the old value.
@@ -48,7 +49,7 @@ export declare class Derived<T, TChangeSummary = any, TChange = void> extends Ba
     private _delayedStore;
     private _removedObserverToCallEndUpdateOn;
     get debugName(): string;
-    constructor(_debugNameData: DebugNameData, _computeFn: (reader: IDerivedReader<TChange>, changeSummary: TChangeSummary) => T, _changeTracker: IChangeTracker<TChangeSummary> | undefined, _handleLastObserverRemoved: (() => void) | undefined, _equalityComparator: EqualityComparer<T>);
+    constructor(_debugNameData: DebugNameData, _computeFn: (reader: IDerivedReader<TChange>, changeSummary: TChangeSummary) => T, _changeTracker: IChangeTracker<TChangeSummary> | undefined, _handleLastObserverRemoved: (() => void) | undefined, _equalityComparator: EqualityComparer<T>, debugLocation: DebugLocation);
     protected onLastObserverRemoved(): void;
     get(): T;
     private _recompute;
@@ -77,5 +78,5 @@ export declare class Derived<T, TChangeSummary = any, TChange = void> extends Ba
 }
 export declare class DerivedWithSetter<T, TChangeSummary = any, TOutChanges = any> extends Derived<T, TChangeSummary, TOutChanges> implements ISettableObservable<T, TOutChanges> {
     readonly set: (value: T, tx: ITransaction | undefined, change: TOutChanges) => void;
-    constructor(debugNameData: DebugNameData, computeFn: (reader: IDerivedReader<TOutChanges>, changeSummary: TChangeSummary) => T, changeTracker: IChangeTracker<TChangeSummary> | undefined, handleLastObserverRemoved: (() => void) | undefined, equalityComparator: EqualityComparer<T>, set: (value: T, tx: ITransaction | undefined, change: TOutChanges) => void);
+    constructor(debugNameData: DebugNameData, computeFn: (reader: IDerivedReader<TOutChanges>, changeSummary: TChangeSummary) => T, changeTracker: IChangeTracker<TChangeSummary> | undefined, handleLastObserverRemoved: (() => void) | undefined, equalityComparator: EqualityComparer<T>, set: (value: T, tx: ITransaction | undefined, change: TOutChanges) => void, debugLocation: DebugLocation);
 }

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

@@ -18,8 +18,8 @@ class Derived extends BaseObservable {
     get debugName() {
         return this._debugNameData.getDebugName(this) ?? '(anonymous)';
     }
-    constructor(_debugNameData, _computeFn, _changeTracker, _handleLastObserverRemoved = undefined, _equalityComparator) {
-        super();
+    constructor(_debugNameData, _computeFn, _changeTracker, _handleLastObserverRemoved = undefined, _equalityComparator, debugLocation) {
+        super(debugLocation);
         this._debugNameData = _debugNameData;
         this._computeFn = _computeFn;
         this._changeTracker = _changeTracker;
@@ -323,8 +323,8 @@ class Derived extends BaseObservable {
     }
 }
 class DerivedWithSetter extends Derived {
-    constructor(debugNameData, computeFn, changeTracker, handleLastObserverRemoved = undefined, equalityComparator, set) {
-        super(debugNameData, computeFn, changeTracker, handleLastObserverRemoved, equalityComparator);
+    constructor(debugNameData, computeFn, changeTracker, handleLastObserverRemoved = undefined, equalityComparator, set, debugLocation) {
+        super(debugNameData, computeFn, changeTracker, handleLastObserverRemoved, equalityComparator, debugLocation);
         this.set = set;
     }
 }

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

@@ -2,6 +2,7 @@ import { EqualityComparer } from "../commonFacade/deps.js";
 import { IObserver, ISettableObservable, ITransaction } from "../base.js";
 import { DebugNameData } from "../debugName.js";
 import { BaseObservable } from "./baseObservable.js";
+import { DebugLocation } from "../debugLocation.js";
 /**
  * Holds off updating observers until the value is actually read.
 */
@@ -12,7 +13,7 @@ export declare class LazyObservableValue<T, TChange = void> extends BaseObservab
     private _isUpToDate;
     private readonly _deltas;
     get debugName(): string;
-    constructor(_debugNameData: DebugNameData, initialValue: T, _equalityComparator: EqualityComparer<T>);
+    constructor(_debugNameData: DebugNameData, initialValue: T, _equalityComparator: EqualityComparer<T>, debugLocation: DebugLocation);
     get(): T;
     private _update;
     private _updateCounter;

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

@@ -7,8 +7,8 @@ class LazyObservableValue extends BaseObservable {
     get debugName() {
         return this._debugNameData.getDebugName(this) ?? 'LazyObservableValue';
     }
-    constructor(_debugNameData, initialValue, _equalityComparator) {
-        super();
+    constructor(_debugNameData, initialValue, _equalityComparator, debugLocation) {
+        super(debugLocation);
         this._debugNameData = _debugNameData;
         this._equalityComparator = _equalityComparator;
         this._isUpToDate = true;

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

@@ -2,11 +2,12 @@ import { IObservable, ITransaction } from "../base.js";
 import { EqualityComparer, Event } from "../commonFacade/deps.js";
 import { DebugOwner, DebugNameData, IDebugNameData } from "../debugName.js";
 import { BaseObservable } from "./baseObservable.js";
-export declare function observableFromEvent<T, TArgs = unknown>(owner: DebugOwner, event: Event<TArgs>, getValue: (args: TArgs | undefined) => T): IObservable<T>;
+import { DebugLocation } from "../debugLocation.js";
+export declare function observableFromEvent<T, TArgs = unknown>(owner: DebugOwner, event: Event<TArgs>, getValue: (args: TArgs | undefined) => T, debugLocation?: DebugLocation): IObservable<T>;
 export declare function observableFromEvent<T, TArgs = unknown>(event: Event<TArgs>, getValue: (args: TArgs | undefined) => T): IObservable<T>;
 export declare function observableFromEventOpts<T, TArgs = unknown>(options: IDebugNameData & {
     equalsFn?: EqualityComparer<T>;
-}, event: Event<TArgs>, getValue: (args: TArgs | undefined) => T): IObservable<T>;
+}, event: Event<TArgs>, getValue: (args: TArgs | undefined) => T, debugLocation?: DebugLocation): IObservable<T>;
 export declare class FromEventObservable<TArgs, T> extends BaseObservable<T> {
     private readonly _debugNameData;
     private readonly event;
@@ -17,7 +18,7 @@ export declare class FromEventObservable<TArgs, T> extends BaseObservable<T> {
     private _value;
     private _hasValue;
     private _subscription;
-    constructor(_debugNameData: DebugNameData, event: Event<TArgs>, _getValue: (args: TArgs | undefined) => T, _getTransaction: () => ITransaction | undefined, _equalityComparator: EqualityComparer<T>);
+    constructor(_debugNameData: DebugNameData, event: Event<TArgs>, _getValue: (args: TArgs | undefined) => T, _getTransaction: () => ITransaction | undefined, _equalityComparator: EqualityComparer<T>, debugLocation: DebugLocation);
     private getDebugName;
     get debugName(): string;
     protected onFirstObserverAdded(): void;

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

@@ -7,25 +7,27 @@ import '../../lifecycle.js';
 import { DebugNameData } from '../debugName.js';
 import { getLogger } from '../logging/logging.js';
 import { BaseObservable } from './baseObservable.js';
+import { DebugLocation } from '../debugLocation.js';
 
 function observableFromEvent(...args) {
     let owner;
     let event;
     let getValue;
-    if (args.length === 3) {
-        [owner, event, getValue] = args;
+    let debugLocation;
+    if (args.length === 2) {
+        [event, getValue] = args;
     }
     else {
-        [event, getValue] = args;
+        [owner, event, getValue, debugLocation] = args;
     }
-    return ( new FromEventObservable(( new DebugNameData(owner, undefined, getValue)), event, getValue, () => FromEventObservable.globalTransaction, strictEquals));
+    return ( new FromEventObservable(( new DebugNameData(owner, undefined, getValue)), event, getValue, () => FromEventObservable.globalTransaction, strictEquals, debugLocation ?? DebugLocation.ofCaller()));
 }
-function observableFromEventOpts(options, event, getValue) {
-    return ( new FromEventObservable(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? getValue)), event, getValue, () => FromEventObservable.globalTransaction, options.equalsFn ?? strictEquals));
+function observableFromEventOpts(options, event, getValue, debugLocation = DebugLocation.ofCaller()) {
+    return ( new FromEventObservable(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? getValue)), event, getValue, () => FromEventObservable.globalTransaction, options.equalsFn ?? strictEquals, debugLocation));
 }
 class FromEventObservable extends BaseObservable {
-    constructor(_debugNameData, event, _getValue, _getTransaction, _equalityComparator) {
-        super();
+    constructor(_debugNameData, event, _getValue, _getTransaction, _equalityComparator, debugLocation) {
+        super(debugLocation);
         this._debugNameData = _debugNameData;
         this.event = event;
         this._getValue = _getValue;

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

@@ -2,13 +2,14 @@
 import { transaction } from '../transaction.js';
 import { DebugNameData } from '../debugName.js';
 import { BaseObservable } from './baseObservable.js';
+import { DebugLocation } from '../debugLocation.js';
 
-function observableSignal(debugNameOrOwner) {
+function observableSignal(debugNameOrOwner, debugLocation = DebugLocation.ofCaller()) {
     if (typeof debugNameOrOwner === 'string') {
-        return ( new ObservableSignal(debugNameOrOwner));
+        return ( new ObservableSignal(debugNameOrOwner, undefined, debugLocation));
     }
     else {
-        return ( new ObservableSignal(undefined, debugNameOrOwner));
+        return ( new ObservableSignal(undefined, debugNameOrOwner, debugLocation));
     }
 }
 class ObservableSignal extends BaseObservable {
@@ -18,8 +19,8 @@ class ObservableSignal extends BaseObservable {
     toString() {
         return this.debugName;
     }
-    constructor(_debugName, _owner) {
-        super();
+    constructor(_debugName, _owner, debugLocation) {
+        super(debugLocation);
         this._debugName = _debugName;
         this._owner = _owner;
     }

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

@@ -1,4 +1,5 @@
 import { IObservable } from "../base.js";
 import { Event } from "../commonFacade/deps.js";
 import { DebugOwner } from "../debugName.js";
-export declare function observableSignalFromEvent(owner: DebugOwner | string, event: Event<any>): IObservable<void>;
+import { DebugLocation } from "../debugLocation.js";
+export declare function observableSignalFromEvent(owner: DebugOwner | string, event: Event<any>, debugLocation?: DebugLocation): IObservable<void>;

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

@@ -2,13 +2,14 @@
 import { transaction } from '../transaction.js';
 import { DebugNameData } from '../debugName.js';
 import { BaseObservable } from './baseObservable.js';
+import { DebugLocation } from '../debugLocation.js';
 
-function observableSignalFromEvent(owner, event) {
-    return ( new FromEventObservableSignal(typeof owner === 'string' ? owner : ( new DebugNameData(owner, undefined, undefined)), event));
+function observableSignalFromEvent(owner, event, debugLocation = DebugLocation.ofCaller()) {
+    return ( new FromEventObservableSignal(typeof owner === 'string' ? owner : ( new DebugNameData(owner, undefined, undefined)), event, debugLocation));
 }
 class FromEventObservableSignal extends BaseObservable {
-    constructor(debugNameDataOrName, event) {
-        super();
+    constructor(debugNameDataOrName, event, debugLocation) {
+        super(debugLocation);
         this.event = event;
         this.handleEvent = () => {
             transaction((tx) => {

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

@@ -2,6 +2,7 @@ import { ISettableObservable, ITransaction } from "../base.js";
 import { BaseObservable } from "./baseObservable.js";
 import { EqualityComparer, IDisposable } from "../commonFacade/deps.js";
 import { DebugNameData } from "../debugName.js";
+import { DebugLocation } from "../debugLocation.js";
 /**
  * Creates an observable value.
  * Observers get informed when the value changes.
@@ -15,7 +16,7 @@ export declare class ObservableValue<T, TChange = void> extends BaseObservable<T
     private readonly _equalityComparator;
     protected _value: T;
     get debugName(): string;
-    constructor(_debugNameData: DebugNameData, initialValue: T, _equalityComparator: EqualityComparer<T>);
+    constructor(_debugNameData: DebugNameData, initialValue: T, _equalityComparator: EqualityComparer<T>, debugLocation: DebugLocation);
     get(): T;
     set(value: T, tx: ITransaction | undefined, change: TChange): void;
     toString(): string;
@@ -29,7 +30,7 @@ export declare class ObservableValue<T, TChange = void> extends BaseObservable<T
  * A disposable observable. When disposed, its value is also disposed.
  * When a new value is set, the previous value is disposed.
  */
-export declare function disposableObservableValue<T extends IDisposable | undefined, TChange = void>(nameOrOwner: string | object, initialValue: T): ISettableObservable<T, TChange> & IDisposable;
+export declare function disposableObservableValue<T extends IDisposable | undefined, TChange = void>(nameOrOwner: string | object, initialValue: T, debugLocation?: DebugLocation): ISettableObservable<T, TChange> & IDisposable;
 export declare class DisposableObservableValue<T extends IDisposable | undefined, TChange = void> extends ObservableValue<T, TChange> implements IDisposable {
     protected _setValue(newValue: T): void;
     dispose(): void;

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

@@ -7,8 +7,9 @@ import '../../event.js';
 import '../../lifecycle.js';
 import { DebugNameData } from '../debugName.js';
 import { getLogger } from '../logging/logging.js';
+import { DebugLocation } from '../debugLocation.js';
 
-function observableValue(nameOrOwner, initialValue) {
+function observableValue(nameOrOwner, initialValue, debugLocation = DebugLocation.ofCaller()) {
     let debugNameData;
     if (typeof nameOrOwner === 'string') {
         debugNameData = ( new DebugNameData(undefined, nameOrOwner, undefined));
@@ -16,14 +17,14 @@ function observableValue(nameOrOwner, initialValue) {
     else {
         debugNameData = ( new DebugNameData(nameOrOwner, undefined, undefined));
     }
-    return ( new ObservableValue(debugNameData, initialValue, strictEquals));
+    return ( new ObservableValue(debugNameData, initialValue, strictEquals, debugLocation));
 }
 class ObservableValue extends BaseObservable {
     get debugName() {
         return this._debugNameData.getDebugName(this) ?? 'ObservableValue';
     }
-    constructor(_debugNameData, initialValue, _equalityComparator) {
-        super();
+    constructor(_debugNameData, initialValue, _equalityComparator, debugLocation) {
+        super(debugLocation);
         this._debugNameData = _debugNameData;
         this._equalityComparator = _equalityComparator;
         this._value = initialValue;
@@ -70,7 +71,7 @@ class ObservableValue extends BaseObservable {
         this._value = value;
     }
 }
-function disposableObservableValue(nameOrOwner, initialValue) {
+function disposableObservableValue(nameOrOwner, initialValue, debugLocation = DebugLocation.ofCaller()) {
     let debugNameData;
     if (typeof nameOrOwner === 'string') {
         debugNameData = ( new DebugNameData(undefined, nameOrOwner, undefined));
@@ -78,7 +79,7 @@ function disposableObservableValue(nameOrOwner, initialValue) {
     else {
         debugNameData = ( new DebugNameData(nameOrOwner, undefined, undefined));
     }
-    return ( new DisposableObservableValue(debugNameData, initialValue, strictEquals));
+    return ( new DisposableObservableValue(debugNameData, initialValue, strictEquals, debugLocation));
 }
 class DisposableObservableValue extends ObservableValue {
     _setValue(newValue) {

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

@@ -1,7 +1,8 @@
 import { ISettableObservable } from "../base.js";
 import { IDebugNameData } from "../debugName.js";
 import { EqualityComparer } from "../commonFacade/deps.js";
+import { DebugLocation } from "../debugLocation.js";
 export declare function observableValueOpts<T, TChange = void>(options: IDebugNameData & {
     equalsFn?: EqualityComparer<T>;
     lazy?: boolean;
-}, initialValue: T): ISettableObservable<T, TChange>;
+}, initialValue: T, debugLocation?: DebugLocation): ISettableObservable<T, TChange>;

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

@@ -6,12 +6,13 @@ import '../../event.js';
 import '../../lifecycle.js';
 import { ObservableValue } from './observableValue.js';
 import { LazyObservableValue } from './lazyObservableValue.js';
+import { DebugLocation } from '../debugLocation.js';
 
-function observableValueOpts(options, initialValue) {
+function observableValueOpts(options, initialValue, debugLocation = DebugLocation.ofCaller()) {
     if (options.lazy) {
-        return ( new LazyObservableValue(( new DebugNameData(options.owner, options.debugName, undefined)), initialValue, options.equalsFn ?? strictEquals));
+        return ( new LazyObservableValue(( new DebugNameData(options.owner, options.debugName, undefined)), initialValue, options.equalsFn ?? strictEquals, debugLocation));
     }
-    return ( new ObservableValue(( new DebugNameData(options.owner, options.debugName, undefined)), initialValue, options.equalsFn ?? strictEquals));
+    return ( new ObservableValue(( new DebugNameData(options.owner, options.debugName, undefined)), initialValue, options.equalsFn ?? strictEquals, debugLocation));
 }
 
 export { observableValueOpts };

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

@@ -2,16 +2,17 @@ import { IReaderWithStore, IReader, IObservable } from "../base.js";
 import { IChangeTracker } from "../changeTracker.js";
 import { DisposableStore, IDisposable } from "../commonFacade/deps.js";
 import { IDebugNameData } from "../debugName.js";
+import { DebugLocation } from "../debugLocation.js";
 /**
  * Runs immediately and whenever a transaction ends and an observed observable changed.
  * {@link fn} should start with a JS Doc using `@description` to name the autorun.
  */
-export declare function autorun(fn: (reader: IReaderWithStore) => void): IDisposable;
+export declare function autorun(fn: (reader: IReaderWithStore) => void, debugLocation?: DebugLocation): IDisposable;
 /**
  * Runs immediately and whenever a transaction ends and an observed observable changed.
  * {@link fn} should start with a JS Doc using `@description` to name the autorun.
  */
-export declare function autorunOpts(options: IDebugNameData & {}, fn: (reader: IReaderWithStore) => void): IDisposable;
+export declare function autorunOpts(options: IDebugNameData & {}, fn: (reader: IReaderWithStore) => void, debugLocation?: DebugLocation): IDisposable;
 /**
  * Runs immediately and whenever a transaction ends and an observed observable changed.
  * {@link fn} should start with a JS Doc using `@description` to name the autorun.
@@ -25,7 +26,7 @@ export declare function autorunOpts(options: IDebugNameData & {}, fn: (reader: I
  */
 export declare function autorunHandleChanges<TChangeSummary>(options: IDebugNameData & {
     changeTracker: IChangeTracker<TChangeSummary>;
-}, fn: (reader: IReader, changeSummary: TChangeSummary) => void): IDisposable;
+}, fn: (reader: IReader, changeSummary: TChangeSummary) => void, debugLocation?: DebugLocation): IDisposable;
 /**
  * @see autorunHandleChanges (but with a disposable store that is cleared before the next run or on dispose)
  */
@@ -46,3 +47,10 @@ export declare function autorunIterableDelta<T>(getValue: (reader: IReader) => I
     addedValues: T[];
     removedValues: T[];
 }) => void, getUniqueIdentifier?: (value: T) => unknown): IDisposable;
+export interface IReaderWithDispose extends IReaderWithStore, IDisposable {
+}
+/**
+ * An autorun with a `dispose()` method on its `reader` which cancels the autorun.
+ * It it safe to call `dispose()` synchronously.
+ */
+export declare function autorunSelfDisposable(fn: (reader: IReaderWithDispose) => void, debugLocation?: DebugLocation): IDisposable;

package/vscode/src/vs/base/common/observableInternal/reactions/autorun.js

@@ -5,15 +5,16 @@ import '../../event.js';
 import { DisposableStore, toDisposable } from '../../lifecycle.js';
 import { DebugNameData } from '../debugName.js';
 import { AutorunObserver } from './autorunImpl.js';
+import { DebugLocation } from '../debugLocation.js';
 
-function autorun(fn) {
-    return ( new AutorunObserver(( new DebugNameData(undefined, undefined, fn)), fn, undefined));
+function autorun(fn, debugLocation = DebugLocation.ofCaller()) {
+    return ( new AutorunObserver(( new DebugNameData(undefined, undefined, fn)), fn, undefined, debugLocation));
 }
-function autorunOpts(options, fn) {
-    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, undefined));
+function autorunOpts(options, fn, debugLocation = DebugLocation.ofCaller()) {
+    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, undefined, debugLocation));
 }
-function autorunHandleChanges(options, fn) {
-    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, options.changeTracker));
+function autorunHandleChanges(options, fn, debugLocation = DebugLocation.ofCaller()) {
+    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, options.changeTracker, debugLocation));
 }
 function autorunWithStoreHandleChanges(options, fn) {
     const store = ( new DisposableStore());
@@ -78,5 +79,24 @@ function autorunIterableDelta(getValue, handler, getUniqueIdentifier = v => v) {
         }
     });
 }
+function autorunSelfDisposable(fn, debugLocation = DebugLocation.ofCaller()) {
+    let ar;
+    let disposed = false;
+    ar = autorun(reader => {
+        fn({
+            delayedStore: reader.delayedStore,
+            store: reader.store,
+            readObservable: reader.readObservable.bind(reader),
+            dispose: () => {
+                ar?.dispose();
+                disposed = true;
+            }
+        });
+    }, debugLocation);
+    if (disposed) {
+        ar.dispose();
+    }
+    return ar;
+}
 
-export { autorun, autorunDelta, autorunHandleChanges, autorunIterableDelta, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges };
+export { autorun, autorunDelta, autorunHandleChanges, autorunIterableDelta, autorunOpts, autorunSelfDisposable, autorunWithStore, autorunWithStoreHandleChanges };

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

@@ -2,6 +2,7 @@ import { IObservable, IObservableWithChange, IObserver, IReaderWithStore } from
 import { DebugNameData } from "../debugName.js";
 import { DisposableStore, IDisposable } from "../commonFacade/deps.js";
 import { IChangeTracker } from "../changeTracker.js";
+import { DebugLocation } from "../debugLocation.js";
 export declare enum AutorunState {
     /**
      * A dependency could have changed.
@@ -26,7 +27,7 @@ export declare class AutorunObserver<TChangeSummary = any> implements IObserver,
     private _changeSummary;
     private _isRunning;
     get debugName(): string;
-    constructor(_debugNameData: DebugNameData, _runFn: (reader: IReaderWithStore, changeSummary: TChangeSummary) => void, _changeTracker: IChangeTracker<TChangeSummary> | undefined);
+    constructor(_debugNameData: DebugNameData, _runFn: (reader: IReaderWithStore, changeSummary: TChangeSummary) => void, _changeTracker: IChangeTracker<TChangeSummary> | undefined, debugLocation: DebugLocation);
     dispose(): void;
     private _run;
     toString(): string;

package/vscode/src/vs/base/common/observableInternal/reactions/autorunImpl.js

@@ -16,7 +16,7 @@ class AutorunObserver {
     get debugName() {
         return this._debugNameData.getDebugName(this) ?? '(anonymous)';
     }
-    constructor(_debugNameData, _runFn, _changeTracker) {
+    constructor(_debugNameData, _runFn, _changeTracker, debugLocation) {
         this._debugNameData = _debugNameData;
         this._runFn = _runFn;
         this._changeTracker = _changeTracker;
@@ -29,7 +29,7 @@ class AutorunObserver {
         this._store = undefined;
         this._delayedStore = undefined;
         this._changeSummary = this._changeTracker?.createChangeSummary(undefined);
-        getLogger()?.handleAutorunCreated(this);
+        getLogger()?.handleAutorunCreated(this, debugLocation);
         this._run();
         trackDisposable(this);
     }

package/vscode/src/vs/base/common/observableInternal/utils/utilsCancellation.js

@@ -6,6 +6,7 @@ import '../../event.js';
 import '../../lifecycle.js';
 import { autorun } from '../reactions/autorun.js';
 import '../observables/derivedImpl.js';
+import '../debugLocation.js';
 
 function waitForState(observable, predicate, isError, cancellationToken) {
     if (!predicate) {

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

@@ -0,0 +1,29 @@
+import { IDefaultAccount } from "./defaultAccount.js";
+export type PolicyName = string;
+export interface IPolicy {
+    /**
+     * The policy name.
+     */
+    readonly name: PolicyName;
+    /**
+     * The Code version in which this policy was introduced.
+    */
+    readonly minimumVersion: `${number}.${number}`;
+    /**
+     * The policy description (optional).
+     */
+    readonly description?: string;
+    /**
+     * The value that an ACCOUNT-based feature will use when its corresponding policy is active.
+     *
+     * Only applicable when policy is tagged with ACCOUNT. When an account-based feature's policy is enabled,
+     * this value determines what value the feature receives.
+     *
+     * For example:
+     * - If evaluated value is `true`,  the feature's setting is locked to `true` WHEN the policy is in effect.
+     * - If evaluated value is `foo`, the feature's setting is locked to 'foo'  WHEN the policy is in effect.
+     *
+     * If `undefined`, the feature's setting is not locked and can be overridden by other means.
+     */
+    readonly value?: (account: IDefaultAccount) => string | number | boolean | undefined;
+}

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

@@ -1,6 +1,6 @@
 import { IStringDictionary } from "./collections.js";
 import { PlatformName } from "./platform.js";
-import { IPolicy } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/base/common/policy";
+import { IPolicy } from "./policy.js";
 export interface IBuiltInExtension {
     readonly name: string;
     readonly version: string;
@@ -40,6 +40,13 @@ export interface IFeaturedExtension {
     readonly description: string;
     readonly imagePath: string;
 }
+export interface IChatSessionRecommendation {
+    readonly extensionId: string;
+    readonly extensionName: string;
+    readonly displayName: string;
+    readonly name: string;
+    readonly description: string;
+}
 export type ConfigurationSyncStore = {
     url: string;
     insidersUrl: string;
@@ -97,6 +104,9 @@ export interface IProductConfiguration {
         readonly nlsBaseUrl: string;
         readonly accessSKUs?: string[];
     };
+    readonly mcpGallery?: {
+        readonly serviceUrl: string;
+    };
     readonly extensionPublisherOrgs?: readonly string[];
     readonly trustedExtensionPublishers?: readonly string[];
     readonly extensionRecommendations?: IStringDictionary<IExtensionRecommendations>;
@@ -194,6 +204,7 @@ export interface IProductConfiguration {
         };
         readonly tokenEntitlementUrl: string;
         readonly chatEntitlementUrl: string;
+        readonly mcpRegistryDataUrl: string;
     };
     readonly "configurationSync.store"?: ConfigurationSyncStore;
     readonly "editSessions.store"?: Omit<ConfigurationSyncStore, "insidersUrl" | "stableUrl">;
@@ -204,6 +215,7 @@ export interface IProductConfiguration {
     readonly aiGeneratedWorkspaceTrust?: IAiGeneratedWorkspaceTrust;
     readonly defaultChatAgent?: IDefaultChatAgent;
     readonly chatParticipantRegistry?: string;
+    readonly chatSessionRecommendations?: IChatSessionRecommendation[];
     readonly emergencyAlertUrl?: string;
     readonly remoteDefaultExtensionsIfInstalledLocally?: string[];
     readonly extensionConfigurationPolicy?: IStringDictionary<IPolicy>;
@@ -316,6 +328,8 @@ export interface IDefaultChatAgent {
     readonly manageOverageUrl: string;
     readonly upgradePlanUrl: string;
     readonly signUpUrl: string;
+    readonly termsStatementUrl: string;
+    readonly privacyStatementUrl: string;
     readonly provider: {
         default: {
             id: string;

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

@@ -171,12 +171,6 @@ export declare function isEmojiImprecise(x: number): boolean;
  * The return value can be longer than the given value of `n`. Leading whitespace is always trimmed.
  */
 export declare function lcut(text: string, n: number, prefix?: string): string;
-/**
- * Given a string and a max length returns a shorted version. Shorting
- * happens at favorable positions - such as whitespace or punctuation characters.
- * The return value can be longer than the given value of `n`. Trailing whitespace is always trimmed.
- */
-export declare function rcut(text: string, n: number, suffix?: string): string;
 /** Iterates over parts of a string with CSI sequences */
 export declare function forAnsiStringParts(str: string): Generator<{
     isCode: boolean;