@codingame/monaco-vscode-api 20.5.0 → 21.0.1

package/vscode/src/vs/base/browser/ui/selectBox/selectBoxCustom.js

@@ -1,8 +1,15 @@
 
 import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { localize } from '../../../../nls.js';
+import { equals } from '../../../common/arrays.js';
+import { Emitter, Event } from '../../../common/event.js';
+import { KeyCode, KeyCodeUtils } from '../../../common/keyCodes.js';
+import { Disposable } from '../../../common/lifecycle.js';
+import { isMacintosh } from '../../../common/platform.js';
+import { ScrollbarVisibility } from '../../../common/scrollable.js';
+import { asCssValueWithDefault } from '../../cssValue.js';
 import { $ as $$1, append, createElement, addDisposableListener, EventType, EventHelper, addStandardDisposableListener, getWindow, getDomNodePagePosition, getTotalWidth, isAncestor } from '../../dom.js';
 import { createStyleSheet } from '../../domStylesheets.js';
-import { asCssValueWithDefault } from '../../cssValue.js';
 import { DomEmitter } from '../../event.js';
 import { StandardKeyboardEvent } from '../../keyboardEvent.js';
 import { renderMarkdown } from '../../markdownRenderer.js';
@@ -10,14 +17,7 @@ import { AnchorPosition } from '../contextview/contextview.js';
 import { getBaseLayerHoverDelegate } from '../hover/hoverDelegate2.js';
 import { getDefaultHoverDelegate } from '../hover/hoverDelegateFactory.js';
 import { List } from '../list/listWidget.js';
-import { equals } from '../../../common/arrays.js';
-import { Emitter, Event } from '../../../common/event.js';
-import { KeyCode, KeyCodeUtils } from '../../../common/keyCodes.js';
-import { Disposable } from '../../../common/lifecycle.js';
-import { isMacintosh } from '../../../common/platform.js';
-import { ScrollbarVisibility } from '../../../common/scrollable.js';
 import * as selectBoxCustom from './selectBoxCustom.css';
-import { localize } from '../../../../nls.js';
 
 registerCss(selectBoxCustom);
 const $ = $$1;
@@ -40,7 +40,7 @@ class SelectListRenderer {
         const isDisabled = element.isDisabled;
         data.text.textContent = text;
         data.detail.textContent = !!detail ? detail : '';
-        data.decoratorRight.innerText = !!decoratorRight ? decoratorRight : '';
+        data.decoratorRight.textContent = !!decoratorRight ? decoratorRight : '';
         if (isDisabled) {
             data.root.classList.add('option-disabled');
         }
@@ -304,7 +304,7 @@ class SelectBoxList extends Disposable {
         return option;
     }
     showSelectDropDown() {
-        this.selectionDetailsPane.innerText = '';
+        this.selectionDetailsPane.textContent = '';
         if (!this.contextViewProvider || this._isVisible) {
             return;
         }
@@ -621,7 +621,7 @@ class SelectBoxList extends Disposable {
         this.updateDetail(e.indexes[0]);
     }
     updateDetail(selectedIndex) {
-        this.selectionDetailsPane.innerText = '';
+        this.selectionDetailsPane.textContent = '';
         const option = this.options[selectedIndex];
         const description = option?.description ?? '';
         const descriptionIsMarkdown = option?.descriptionIsMarkdown ?? false;
@@ -631,7 +631,7 @@ class SelectBoxList extends Disposable {
                 this.selectionDetailsPane.appendChild(this.renderDescriptionMarkdown(description, actionHandler));
             }
             else {
-                this.selectionDetailsPane.innerText = description;
+                this.selectionDetailsPane.textContent = description;
             }
             this.selectionDetailsPane.style.display = 'block';
         }

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

@@ -45,9 +45,9 @@ export declare class ToggleActionViewItem extends BaseActionViewItem {
 }
 export declare class Toggle extends Widget {
     private readonly _onChange;
-    readonly onChange: Event<boolean>;
+    get onChange(): Event<boolean>;
     private readonly _onKeyDown;
-    readonly onKeyDown: Event<IKeyboardEvent>;
+    get onKeyDown(): Event<IKeyboardEvent>;
     private readonly _opts;
     private _icon;
     readonly domNode: HTMLElement;

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

@@ -75,12 +75,12 @@ class ToggleActionViewItem extends BaseActionViewItem {
     }
 }
 class Toggle extends Widget {
+    get onChange() { return this._onChange.event; }
+    get onKeyDown() { return this._onKeyDown.event; }
     constructor(opts) {
         super();
         this._onChange = this._register(( new Emitter()));
-        this.onChange = this._onChange.event;
         this._onKeyDown = this._register(( new Emitter()));
-        this.onKeyDown = this._onKeyDown.event;
         this._opts = opts;
         this._checked = this._opts.isChecked;
         const classes = ['monaco-custom-toggle'];

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

@@ -44,7 +44,7 @@ export declare class ToolBar extends Disposable {
     private hasSecondaryActions;
     private readonly element;
     private _onDidChangeDropdownVisibility;
-    readonly onDidChangeDropdownVisibility: import("../../../common/event.js").Event<boolean>;
+    get onDidChangeDropdownVisibility(): import("../../../common/event.js").Event<boolean>;
     private readonly disposables;
     constructor(container: HTMLElement, contextMenuProvider: IContextMenuProvider, options?: IToolBarOptions);
     set actionRunner(actionRunner: IActionRunner);

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

@@ -14,12 +14,12 @@ import { createElement } from '../../dom.js';
 
 registerCss(toolbar);
 class ToolBar extends Disposable {
+    get onDidChangeDropdownVisibility() { return this._onDidChangeDropdownVisibility.event; }
     constructor(container, contextMenuProvider, options = { orientation: ActionsOrientation.HORIZONTAL }) {
         super();
         this.submenuActionViewItems = [];
         this.hasSecondaryActions = false;
         this._onDidChangeDropdownVisibility = this._register(( new EventMultiplexer()));
-        this.onDidChangeDropdownVisibility = this._onDidChangeDropdownVisibility.event;
         this.disposables = this._register(( new DisposableStore()));
         options.hoverDelegate = options.hoverDelegate ?? this._register(createInstantHoverDelegate());
         this.options = options;

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

@@ -52,7 +52,7 @@ export interface IActionChangeEvent {
 }
 export declare class Action extends Disposable implements IAction {
     protected _onDidChange: Emitter<IActionChangeEvent>;
-    readonly onDidChange: Event<IActionChangeEvent>;
+    get onDidChange(): Event<IActionChangeEvent>;
     protected readonly _id: string;
     protected _label: string;
     protected _tooltip: string | undefined;
@@ -85,9 +85,9 @@ export interface IRunEvent {
 }
 export declare class ActionRunner extends Disposable implements IActionRunner {
     private readonly _onWillRun;
-    readonly onWillRun: Event<IRunEvent>;
+    get onWillRun(): Event<IRunEvent>;
     private readonly _onDidRun;
-    readonly onDidRun: Event<IRunEvent>;
+    get onDidRun(): Event<IRunEvent>;
     run(action: IAction, context?: unknown): Promise<void>;
     protected runAction(action: IAction, context?: unknown): Promise<void>;
 }

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

@@ -4,10 +4,10 @@ import { Disposable } from './lifecycle.js';
 import { localize } from '../../nls.js';
 
 class Action extends Disposable {
+    get onDidChange() { return this._onDidChange.event; }
     constructor(id, label = '', cssClass = '', enabled = true, actionCallback) {
         super();
         this._onDidChange = this._register(( new Emitter()));
-        this.onDidChange = this._onDidChange.event;
         this._enabled = true;
         this._id = id;
         this._label = label;
@@ -88,10 +88,10 @@ class ActionRunner extends Disposable {
     constructor() {
         super(...arguments);
         this._onWillRun = this._register(( new Emitter()));
-        this.onWillRun = this._onWillRun.event;
         this._onDidRun = this._register(( new Emitter()));
-        this.onDidRun = this._onDidRun.event;
     }
+    get onWillRun() { return this._onWillRun.event; }
+    get onDidRun() { return this._onDidRun.event; }
     async run(action, context) {
         if (!action.enabled) {
             return;

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

@@ -45,7 +45,6 @@ export declare function notCancellablePromise<T>(promise: CancelablePromise<T>):
  */
 export declare function raceCancellablePromises<T>(cancellablePromises: (CancelablePromise<T> | Promise<T>)[]): CancelablePromise<T>;
 export declare function raceTimeout<T>(promise: Promise<T>, timeout: number, onTimeout?: () => void): Promise<T | undefined>;
-export declare function raceFilter<T>(promises: Promise<T>[], filter: (result: T) => boolean): Promise<T | undefined>;
 export declare function asPromise<T>(callback: () => T | Thenable<T>): Promise<T>;
 /**
  * Creates and returns a new promise, plus its `resolve` and `reject` callbacks.
@@ -693,12 +692,7 @@ export declare class AsyncIterableObject<T> implements AsyncIterable<T> {
      */
     private reject;
 }
-export declare class CancelableAsyncIterableObject<T> extends AsyncIterableObject<T> {
-    private readonly _source;
-    constructor(_source: CancellationTokenSource, executor: AsyncIterableExecutor<T>);
-    cancel(): void;
-}
-export declare function createCancelableAsyncIterable<T>(callback: (token: CancellationToken) => AsyncIterable<T>): CancelableAsyncIterableObject<T>;
+export declare function createCancelableAsyncIterableProducer<T>(callback: (token: CancellationToken) => AsyncIterable<T>): CancelableAsyncIterableProducer<T>;
 export declare class AsyncIterableSource<T> {
     private readonly _deferred;
     private readonly _asyncIterable;
@@ -727,11 +721,28 @@ export declare class AsyncIterableProducer<T> implements AsyncIterable<T> {
     private readonly _onReturn?;
     private readonly _producerConsumer;
     constructor(executor: AsyncIterableExecutor<T>, _onReturn?: (() => void) | undefined);
+    static fromArray<T>(items: T[]): AsyncIterableProducer<T>;
+    static fromPromise<T>(promise: Promise<T[]>): AsyncIterableProducer<T>;
+    static fromPromisesResolveOrder<T>(promises: Promise<T>[]): AsyncIterableProducer<T>;
+    static merge<T>(iterables: AsyncIterable<T>[]): AsyncIterableProducer<T>;
+    static EMPTY: AsyncIterableProducer<any>;
+    static map<T, R>(iterable: AsyncIterable<T>, mapFn: (item: T) => R): AsyncIterableProducer<R>;
+    map<R>(mapFn: (item: T) => R): AsyncIterableProducer<R>;
+    static coalesce<T>(iterable: AsyncIterable<T | undefined | null>): AsyncIterableProducer<T>;
+    coalesce(): AsyncIterableProducer<NonNullable<T>>;
+    static filter<T>(iterable: AsyncIterable<T>, filterFn: (item: T) => boolean): AsyncIterableProducer<T>;
+    filter<T2 extends T>(filterFn: (item: T) => item is T2): AsyncIterableProducer<T2>;
+    filter(filterFn: (item: T) => boolean): AsyncIterableProducer<T>;
     private _finishOk;
     private _finishError;
     private readonly _iterator;
     [Symbol.asyncIterator](): AsyncIterator<T, void, void>;
 }
+export declare class CancelableAsyncIterableProducer<T> extends AsyncIterableProducer<T> {
+    private readonly _source;
+    constructor(_source: CancellationTokenSource, executor: AsyncIterableExecutor<T>);
+    cancel(): void;
+}
 export declare const AsyncReaderEndOfStream: unique symbol;
 export declare class AsyncReader<T> {
     private readonly _source;

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

@@ -1161,19 +1161,10 @@ class AsyncIterableObject {
         this._onStateChanged.fire();
     }
 }
-class CancelableAsyncIterableObject extends AsyncIterableObject {
-    constructor(_source, executor) {
-        super(executor);
-        this._source = _source;
-    }
-    cancel() {
-        this._source.cancel();
-    }
-}
-function createCancelableAsyncIterable(callback) {
+function createCancelableAsyncIterableProducer(callback) {
     const source = ( new CancellationTokenSource());
     const innerIterable = callback(source.token);
-    return ( new CancelableAsyncIterableObject(source, async (emitter) => {
+    return ( new CancelableAsyncIterableProducer(source, async (emitter) => {
         const subscription = source.token.onCancellationRequested(() => {
             subscription.dispose();
             source.dispose();
@@ -1343,15 +1334,81 @@ class AsyncIterableProducer {
             }
         });
     }
+    static fromArray(items) {
+        return ( new AsyncIterableProducer((writer) => {
+            writer.emitMany(items);
+        }));
+    }
+    static fromPromise(promise) {
+        return ( new AsyncIterableProducer(async (emitter) => {
+            emitter.emitMany(await promise);
+        }));
+    }
+    static fromPromisesResolveOrder(promises) {
+        return ( new AsyncIterableProducer(async (emitter) => {
+            await Promise.all(( promises.map(async (p) => emitter.emitOne(await p))));
+        }));
+    }
+    static merge(iterables) {
+        return ( new AsyncIterableProducer(async (emitter) => {
+            await Promise.all(( iterables.map(async (iterable) => {
+                for await (const item of iterable) {
+                    emitter.emitOne(item);
+                }
+            })));
+        }));
+    }
+    static { this.EMPTY = AsyncIterableProducer.fromArray([]); }
+    static map(iterable, mapFn) {
+        return ( new AsyncIterableProducer(async (emitter) => {
+            for await (const item of iterable) {
+                emitter.emitOne(mapFn(item));
+            }
+        }));
+    }
+    map(mapFn) {
+        return ( AsyncIterableProducer.map(this, mapFn));
+    }
+    static coalesce(iterable) {
+        return AsyncIterableProducer.filter(iterable, item => !!item);
+    }
+    coalesce() {
+        return AsyncIterableProducer.coalesce(this);
+    }
+    static filter(iterable, filterFn) {
+        return ( new AsyncIterableProducer(async (emitter) => {
+            for await (const item of iterable) {
+                if (filterFn(item)) {
+                    emitter.emitOne(item);
+                }
+            }
+        }));
+    }
+    filter(filterFn) {
+        return AsyncIterableProducer.filter(this, filterFn);
+    }
     _finishOk() {
-        this._producerConsumer.produceFinal({ ok: true, value: { done: true, value: undefined } });
+        if (!this._producerConsumer.hasFinalValue) {
+            this._producerConsumer.produceFinal({ ok: true, value: { done: true, value: undefined } });
+        }
     }
     _finishError(error) {
-        this._producerConsumer.produceFinal({ ok: false, error: error });
+        if (!this._producerConsumer.hasFinalValue) {
+            this._producerConsumer.produceFinal({ ok: false, error: error });
+        }
     }
     [Symbol.asyncIterator]() {
         return this._iterator;
     }
 }
+class CancelableAsyncIterableProducer extends AsyncIterableProducer {
+    constructor(_source, executor) {
+        super(executor);
+        this._source = _source;
+    }
+    cancel() {
+        this._source.cancel();
+    }
+}
 
-export { AbstractIdleValue, AsyncIterableObject, AsyncIterableProducer, AsyncIterableSource, AutoOpenBarrier, Barrier, CancelableAsyncIterableObject, DeferredPromise, Delayer, GlobalIdleValue, IntervalCounter, IntervalTimer, LazyStatefulPromise, Limiter, Promises, Queue, ResourceQueue, RunOnceScheduler, RunOnceWorker, Sequencer, SequencerByKey, StatefulPromise, TaskQueue, TaskSequentializer, ThrottledDelayer, Throttler, TimeoutTimer, _runWhenIdle, asPromise, createCancelableAsyncIterable, createCancelablePromise, disposableTimeout, first, isThenable, notCancellablePromise, promiseWithResolvers, raceCancellablePromises, raceCancellation, raceCancellationError, raceTimeout, retry, runWhenGlobalIdle, sequence, timeout };
+export { AbstractIdleValue, AsyncIterableObject, AsyncIterableProducer, AsyncIterableSource, AutoOpenBarrier, Barrier, CancelableAsyncIterableProducer, DeferredPromise, Delayer, GlobalIdleValue, IntervalCounter, IntervalTimer, LazyStatefulPromise, Limiter, Promises, Queue, ResourceQueue, RunOnceScheduler, RunOnceWorker, Sequencer, SequencerByKey, StatefulPromise, TaskQueue, TaskSequentializer, ThrottledDelayer, Throttler, TimeoutTimer, _runWhenIdle, asPromise, createCancelableAsyncIterableProducer, createCancelablePromise, disposableTimeout, first, isThenable, notCancellablePromise, promiseWithResolvers, raceCancellablePromises, raceCancellation, raceCancellationError, raceTimeout, retry, runWhenGlobalIdle, sequence, timeout };

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

@@ -674,4 +674,7 @@ export declare const Codicon: {
     readonly editSparkle: ThemeIcon;
     readonly copilotSnooze: ThemeIcon;
     readonly sendToRemoteAgent: ThemeIcon;
+    readonly commentDiscussionSparkle: ThemeIcon;
+    readonly chatSparkleWarning: ThemeIcon;
+    readonly chatSparkleError: ThemeIcon;
 };

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

@@ -600,4 +600,7 @@ export declare const codiconsLibrary: {
     readonly editSparkle: import("./themables.js").ThemeIcon;
     readonly copilotSnooze: import("./themables.js").ThemeIcon;
     readonly sendToRemoteAgent: import("./themables.js").ThemeIcon;
+    readonly commentDiscussionSparkle: import("./themables.js").ThemeIcon;
+    readonly chatSparkleWarning: import("./themables.js").ThemeIcon;
+    readonly chatSparkleError: import("./themables.js").ThemeIcon;
 };

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

@@ -603,6 +603,9 @@ const codiconsLibrary = {
     editSparkle: register('edit-sparkle', 0xec51),
     copilotSnooze: register('copilot-snooze', 0xec52),
     sendToRemoteAgent: register('send-to-remote-agent', 0xec53),
+    commentDiscussionSparkle: register('comment-discussion-sparkle', 0xec54),
+    chatSparkleWarning: register('chat-sparkle-warning', 0xec55),
+    chatSparkleError: register('chat-sparkle-error', 0xec56),
 };
 
 export { codiconsLibrary };

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

@@ -0,0 +1,23 @@
+export interface IDefaultAccount {
+    readonly sessionId: string;
+    readonly enterprise: boolean;
+    readonly access_type_sku?: string;
+    readonly assigned_date?: string;
+    readonly can_signup_for_limited?: boolean;
+    readonly chat_enabled?: boolean;
+    readonly chat_preview_features_enabled?: boolean;
+    readonly mcp?: boolean;
+    readonly mcpRegistryUrl?: string;
+    readonly mcpAccess?: "allow_all" | "registry_only";
+    readonly analytics_tracking_id?: string;
+    readonly limited_user_quotas?: {
+        readonly chat: number;
+        readonly completions: number;
+    };
+    readonly monthly_quotas?: {
+        readonly chat: number;
+        readonly completions: number;
+    };
+    readonly limited_user_reset_date?: string;
+    readonly chat_agent_enabled?: boolean;
+}

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

@@ -231,11 +231,6 @@ export declare namespace Event {
      * Creates a promise out of an event, using the {@link Event.once} helper.
      */
     function toPromise<T>(event: Event<T>, disposables?: IDisposable[] | DisposableStore): CancelablePromise<T>;
-    /**
-     * Creates an event out of a promise that fires once when the promise is
-     * resolved with the result of the promise or `undefined`.
-     */
-    function fromPromise<T>(promise: Promise<T>): Event<T | undefined>;
     /**
      * A convenience function for forwarding an event to another emitter which
      * improves readability.

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

@@ -317,18 +317,6 @@ var Event;
         return promise;
     }
     Event.toPromise = toPromise;
-    function fromPromise(promise) {
-        const result = ( new Emitter());
-        promise.then(res => {
-            result.fire(res);
-        }, () => {
-            result.fire(undefined);
-        }).finally(() => {
-            result.dispose();
-        });
-        return result.event;
-    }
-    Event.fromPromise = fromPromise;
     function forward(from, to) {
         return from(e => to.fire(e));
     }

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

@@ -1,45 +1,14 @@
 
-import { isHotReloadEnabled, registerHotReloadHandler } from './hotReload.js';
 import './observableInternal/index.js';
-import { observableSignalFromEvent } from './observableInternal/observables/observableSignalFromEvent.js';
 import { constObservable } from './observableInternal/observables/constObservable.js';
-import { observableValue } from './observableInternal/observables/observableValue.js';
 
 function readHotReloadableExport(value, reader) {
-    observeHotReloadableExports([value], reader);
     return value;
 }
-function observeHotReloadableExports(values, reader) {
-    if (isHotReloadEnabled()) {
-        const o = observableSignalFromEvent('reload', event => registerHotReloadHandler(({ oldExports }) => {
-            if (!( [...( Object.values(oldExports))].some(v => values.includes(v)))) {
-                return undefined;
-            }
-            return (_newExports) => {
-                event(undefined);
-                return true;
-            };
-        }));
-        o.read(reader);
-    }
-}
-const classes = ( new Map());
 function createHotClass(clazz) {
-    if (!isHotReloadEnabled()) {
+    {
         return constObservable(clazz);
     }
-    const id = clazz.name;
-    let existing = classes.get(id);
-    if (!existing) {
-        existing = observableValue(id, clazz);
-        classes.set(id, existing);
-    }
-    else {
-        setTimeout(() => {
-            existing.set(clazz, undefined);
-        }, 0);
-    }
-    return existing;
 }
 
-export { createHotClass, observeHotReloadableExports, readHotReloadableExport };
+export { createHotClass, readHotReloadableExport };

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

@@ -55,4 +55,4 @@ export declare function markdownCommandLink(command: {
     title: string;
     id: string;
     arguments?: unknown[];
-}): string;
+}, escapeTokens?: boolean): string;

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

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

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

@@ -1,6 +1,6 @@
 export declare class Lazy<T> {
     private readonly executor;
-    private _didRun;
+    private _state;
     private _value?;
     private _error;
     constructor(executor: () => T);

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

@@ -1,13 +1,20 @@
 
 
+var LazyValueState;
+(function (LazyValueState) {
+    LazyValueState[LazyValueState["Uninitialized"] = 0] = "Uninitialized";
+    LazyValueState[LazyValueState["Running"] = 1] = "Running";
+    LazyValueState[LazyValueState["Completed"] = 2] = "Completed";
+})(LazyValueState || (LazyValueState = {}));
 class Lazy {
     constructor(executor) {
         this.executor = executor;
-        this._didRun = false;
+        this._state = LazyValueState.Uninitialized;
     }
-    get hasValue() { return this._didRun; }
+    get hasValue() { return this._state === LazyValueState.Completed; }
     get value() {
-        if (!this._didRun) {
+        if (this._state === LazyValueState.Uninitialized) {
+            this._state = LazyValueState.Running;
             try {
                 this._value = this.executor();
             }
@@ -15,9 +22,12 @@ class Lazy {
                 this._error = err;
             }
             finally {
-                this._didRun = true;
+                this._state = LazyValueState.Completed;
             }
         }
+        else if (this._state === LazyValueState.Running) {
+            throw ( new Error('Cannot read the value of a lazy that is being initialized'));
+        }
         if (this._error) {
             throw this._error;
         }

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

@@ -127,6 +127,7 @@ export declare class DisposableStore implements IDisposable {
      * Deletes the value from the store, but does not dispose it.
      */
     deleteAndLeak<T extends IDisposable>(o: T): void;
+    assertNotDisposed(): void;
 }
 /**
  * Abstract base class for a {@link IDisposable disposable} object.
@@ -190,17 +191,6 @@ export declare class RefCountedDisposable {
     acquire(): this;
     release(): this;
 }
-/**
- * A safe disposable can be `unset` so that a leaked reference (listener)
- * can be cut-off.
- */
-export declare class SafeDisposable implements IDisposable {
-    dispose: () => void;
-    unset: () => void;
-    isset: () => boolean;
-    constructor();
-    set(fn: Function): this;
-}
 export interface IReference<T> extends IDisposable {
     readonly object: T;
 }
@@ -266,3 +256,9 @@ export declare class DisposableMap<K, V extends IDisposable = IDisposable> imple
  * Call `then` on a Promise, unless the returned disposable is disposed.
  */
 export declare function thenIfNotDisposed<T>(promise: Promise<T>, then: (result: T) => void): IDisposable;
+/**
+ * Call `then` on a promise that resolves to a {@link IDisposable}, then either register the
+ * disposable or register it to the {@link DisposableStore}, depending on whether the store is
+ * disposed or not.
+ */
+export declare function thenRegisterOrDispose<T extends IDisposable>(promise: Promise<T>, store: DisposableStore): Promise<T>;

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

@@ -4,6 +4,7 @@ import { groupBy } from './collections.js';
 import { SetMap } from './map.js';
 import { createSingleCallFunction } from './functional.js';
 import { Iterable } from './iterator.js';
+import { onUnexpectedError, BugIndicatingError } from './errors.js';
 
 let disposableTracker = null;
 class GCBasedDisposableTracker {
@@ -252,7 +253,7 @@ class DisposableStore {
         }
     }
     add(o) {
-        if (!o) {
+        if (!o || o === Disposable.None) {
             return o;
         }
         if (o === this) {
@@ -290,6 +291,11 @@ class DisposableStore {
             setParentOfDisposable(o, null);
         }
     }
+    assertNotDisposed() {
+        if (this._isDisposed) {
+            onUnexpectedError(( new BugIndicatingError('Object disposed')));
+        }
+    }
 }
 class Disposable {
     static { this.None = ( Object.freeze({ dispose() { } })); }
@@ -504,5 +510,16 @@ function thenIfNotDisposed(promise, then) {
         disposed = true;
     });
 }
+function thenRegisterOrDispose(promise, store) {
+    return promise.then(disposable => {
+        if (store.isDisposed) {
+            disposable.dispose();
+        }
+        else {
+            store.add(disposable);
+        }
+        return disposable;
+    });
+}
 
-export { AsyncReferenceCollection, Disposable, DisposableMap, DisposableStore, DisposableTracker, GCBasedDisposableTracker, ImmortalReference, MandatoryMutableDisposable, MutableDisposable, RefCountedDisposable, ReferenceCollection, combinedDisposable, dispose, disposeIfDisposable, isDisposable, markAsDisposed, markAsSingleton, setDisposableTracker, thenIfNotDisposed, toDisposable, trackDisposable };
+export { AsyncReferenceCollection, Disposable, DisposableMap, DisposableStore, DisposableTracker, GCBasedDisposableTracker, ImmortalReference, MandatoryMutableDisposable, MutableDisposable, RefCountedDisposable, ReferenceCollection, combinedDisposable, dispose, disposeIfDisposable, isDisposable, markAsDisposed, markAsSingleton, setDisposableTracker, thenIfNotDisposed, thenRegisterOrDispose, toDisposable, trackDisposable };

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

@@ -20,8 +20,9 @@ export declare enum MarshalledId {
     ChatViewContext = 19,
     LanguageModelToolResult = 20,
     LanguageModelTextPart = 21,
-    LanguageModelPromptTsxPart = 22,
-    LanguageModelDataPart = 23,
-    ChatSessionContext = 24,
-    ChatResponsePullRequestPart = 25
+    LanguageModelThinkingPart = 22,
+    LanguageModelPromptTsxPart = 23,
+    LanguageModelDataPart = 24,
+    ChatSessionContext = 25,
+    ChatResponsePullRequestPart = 26
 }

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

@@ -23,10 +23,11 @@ var MarshalledId;
     MarshalledId[MarshalledId["ChatViewContext"] = 19] = "ChatViewContext";
     MarshalledId[MarshalledId["LanguageModelToolResult"] = 20] = "LanguageModelToolResult";
     MarshalledId[MarshalledId["LanguageModelTextPart"] = 21] = "LanguageModelTextPart";
-    MarshalledId[MarshalledId["LanguageModelPromptTsxPart"] = 22] = "LanguageModelPromptTsxPart";
-    MarshalledId[MarshalledId["LanguageModelDataPart"] = 23] = "LanguageModelDataPart";
-    MarshalledId[MarshalledId["ChatSessionContext"] = 24] = "ChatSessionContext";
-    MarshalledId[MarshalledId["ChatResponsePullRequestPart"] = 25] = "ChatResponsePullRequestPart";
+    MarshalledId[MarshalledId["LanguageModelThinkingPart"] = 22] = "LanguageModelThinkingPart";
+    MarshalledId[MarshalledId["LanguageModelPromptTsxPart"] = 23] = "LanguageModelPromptTsxPart";
+    MarshalledId[MarshalledId["LanguageModelDataPart"] = 24] = "LanguageModelDataPart";
+    MarshalledId[MarshalledId["ChatSessionContext"] = 25] = "ChatSessionContext";
+    MarshalledId[MarshalledId["ChatResponsePullRequestPart"] = 26] = "ChatResponsePullRequestPart";
 })(MarshalledId || (MarshalledId = {}));
 
 export { MarshalledId };