@codingame/monaco-vscode-api 19.1.3 → 20.0.0

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

@@ -362,4 +362,30 @@ export declare class AsyncIterableSource<T> {
     emitMany(items: T[]): void;
 }
 export declare function cancellableIterable<T>(iterableOrIterator: AsyncIterator<T> | AsyncIterable<T>, token: CancellationToken): AsyncIterableIterator<T>;
+export declare class AsyncIterableProducer<T> implements AsyncIterable<T> {
+    private readonly _onReturn?;
+    private readonly _producerConsumer;
+    constructor(executor: AsyncIterableExecutor<T>, _onReturn?: (() => void) | undefined);
+    private _finishOk;
+    private _finishError;
+    private readonly _iterator;
+    [Symbol.asyncIterator](): AsyncIterator<T, void, void>;
+}
+export declare const AsyncReaderEndOfStream: unique symbol;
+export declare class AsyncReader<T> {
+    private readonly _source;
+    private _buffer;
+    private _atEnd;
+    get endOfStream(): boolean;
+    private _extendBufferPromise;
+    constructor(_source: AsyncIterator<T>);
+    read(): Promise<T | typeof AsyncReaderEndOfStream>;
+    readWhile(predicate: (value: T) => boolean, callback: (element: T) => unknown): Promise<void>;
+    readBufferedOrThrow(): T | typeof AsyncReaderEndOfStream;
+    consumeToEnd(): Promise<void>;
+    peek(): Promise<T | typeof AsyncReaderEndOfStream>;
+    peekBufferedOrThrow(): T | typeof AsyncReaderEndOfStream;
+    peekTimeout(timeoutMs: number): Promise<T | typeof AsyncReaderEndOfStream | undefined>;
+    private _extendBuffer;
+}
 export {};

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

@@ -1251,5 +1251,107 @@ class AsyncIterableSource {
         this._emitManyFn(items);
     }
 }
+class ProducerConsumer {
+    constructor() {
+        this._unsatisfiedConsumers = [];
+        this._unconsumedValues = [];
+    }
+    get hasFinalValue() {
+        return !!this._finalValue;
+    }
+    produce(value) {
+        this._ensureNoFinalValue();
+        if (this._unsatisfiedConsumers.length > 0) {
+            const deferred = this._unsatisfiedConsumers.shift();
+            this._resolveOrRejectDeferred(deferred, value);
+        }
+        else {
+            this._unconsumedValues.push(value);
+        }
+    }
+    produceFinal(value) {
+        this._ensureNoFinalValue();
+        this._finalValue = value;
+        for (const deferred of this._unsatisfiedConsumers) {
+            this._resolveOrRejectDeferred(deferred, value);
+        }
+        this._unsatisfiedConsumers.length = 0;
+    }
+    _ensureNoFinalValue() {
+        if (this._finalValue) {
+            throw ( new BugIndicatingError('ProducerConsumer: cannot produce after final value has been set'));
+        }
+    }
+    _resolveOrRejectDeferred(deferred, value) {
+        if (value.ok) {
+            deferred.complete(value.value);
+        }
+        else {
+            deferred.error(value.error);
+        }
+    }
+    consume() {
+        if (this._unconsumedValues.length > 0 || this._finalValue) {
+            const value = this._unconsumedValues.length > 0 ? this._unconsumedValues.shift() : this._finalValue;
+            if (value.ok) {
+                return Promise.resolve(value.value);
+            }
+            else {
+                return Promise.reject(value.error);
+            }
+        }
+        else {
+            const deferred = ( new DeferredPromise());
+            this._unsatisfiedConsumers.push(deferred);
+            return deferred.p;
+        }
+    }
+}
+class AsyncIterableProducer {
+    constructor(executor, _onReturn) {
+        this._onReturn = _onReturn;
+        this._producerConsumer = ( new ProducerConsumer());
+        this._iterator = {
+            next: () => this._producerConsumer.consume(),
+            return: () => {
+                this._onReturn?.();
+                return Promise.resolve({ done: true, value: undefined });
+            },
+            throw: async (e) => {
+                this._finishError(e);
+                return { done: true, value: undefined };
+            },
+        };
+        queueMicrotask(async () => {
+            const p = executor({
+                emitOne: value => this._producerConsumer.produce({ ok: true, value: { done: false, value: value } }),
+                emitMany: values => {
+                    for (const value of values) {
+                        this._producerConsumer.produce({ ok: true, value: { done: false, value: value } });
+                    }
+                },
+                reject: error => this._finishError(error),
+            });
+            if (!this._producerConsumer.hasFinalValue) {
+                try {
+                    await p;
+                    this._finishOk();
+                }
+                catch (error) {
+                    this._finishError(error);
+                }
+            }
+        });
+    }
+    _finishOk() {
+        this._producerConsumer.produceFinal({ ok: true, value: { done: true, value: undefined } });
+    }
+    _finishError(error) {
+        this._producerConsumer.produceFinal({ ok: false, error: error });
+    }
+    [Symbol.asyncIterator]() {
+        return this._iterator;
+    }
+}
 
-export { AbstractIdleValue, AsyncIterableObject, 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, 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 };

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

@@ -659,4 +659,5 @@ export declare const Codicon: {
     readonly searchSparkle: ThemeIcon;
     readonly editSparkle: ThemeIcon;
     readonly copilotSnooze: ThemeIcon;
+    readonly sendToRemoteAgent: ThemeIcon;
 };

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

@@ -599,4 +599,5 @@ export declare const codiconsLibrary: {
     readonly searchSparkle: import("./themables.js").ThemeIcon;
     readonly editSparkle: import("./themables.js").ThemeIcon;
     readonly copilotSnooze: import("./themables.js").ThemeIcon;
+    readonly sendToRemoteAgent: import("./themables.js").ThemeIcon;
 };

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

@@ -602,6 +602,7 @@ const codiconsLibrary = {
     searchSparkle: register('search-sparkle', 0xec50),
     editSparkle: register('edit-sparkle', 0xec51),
     copilotSnooze: register('copilot-snooze', 0xec52),
+    sendToRemoteAgent: register('send-to-remote-agent', 0xec53),
 };
 
 export { codiconsLibrary };

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

@@ -468,6 +468,7 @@ class DisposableMap {
             this._store.get(key)?.dispose();
         }
         this._store.set(key, value);
+        setParentOfDisposable(value, this);
     }
     deleteAndDispose(key) {
         this._store.get(key)?.dispose();
@@ -475,6 +476,9 @@ class DisposableMap {
     }
     deleteAndLeak(key) {
         const value = this._store.get(key);
+        if (value) {
+            setParentOfDisposable(value, null);
+        }
         this._store.delete(key);
         return value;
     }

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

@@ -21,5 +21,7 @@ export declare enum MarshalledId {
     LanguageModelToolResult = 20,
     LanguageModelTextPart = 21,
     LanguageModelPromptTsxPart = 22,
-    LanguageModelDataPart = 23
+    LanguageModelDataPart = 23,
+    ChatSessionContext = 24,
+    ChatResponsePullRequestPart = 25
 }

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

@@ -25,6 +25,8 @@ var MarshalledId;
     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 = {}));
 
 export { MarshalledId };

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

@@ -30,8 +30,9 @@ export declare namespace Schemas {
     const vscodeTerminal = "vscode-terminal";
     const vscodeChatCodeBlock = "vscode-chat-code-block";
     const vscodeChatCodeCompareBlock = "vscode-chat-code-compare-block";
-    const vscodeChatSesssion = "vscode-chat-editor";
+    const vscodeChatEditor = "vscode-chat-editor";
     const vscodeChatInput = "chatSessionInput";
+    const vscodeChatSession = "vscode-chat-session";
     const webviewPanel = "webview-panel";
     const vscodeWebview = "vscode-webview";
     const extension = "extension";

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

@@ -38,8 +38,9 @@ var Schemas;
     Schemas.vscodeTerminal = 'vscode-terminal';
     Schemas.vscodeChatCodeBlock = 'vscode-chat-code-block';
     Schemas.vscodeChatCodeCompareBlock = 'vscode-chat-code-compare-block';
-    Schemas.vscodeChatSesssion = 'vscode-chat-editor';
+    Schemas.vscodeChatEditor = 'vscode-chat-editor';
     Schemas.vscodeChatInput = 'chatSessionInput';
+    Schemas.vscodeChatSession = 'vscode-chat-session';
     Schemas.webviewPanel = 'webview-panel';
     Schemas.vscodeWebview = 'vscode-webview';
     Schemas.extension = 'extension';

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

@@ -1,5 +1,6 @@
 export declare const AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH = "/.well-known/oauth-protected-resource";
 export declare const AUTH_SERVER_METADATA_DISCOVERY_PATH = "/.well-known/oauth-authorization-server";
+export declare const OPENID_CONNECT_DISCOVERY_PATH = "/.well-known/openid-configuration";
 export declare const AUTH_SCOPE_SEPARATOR = " ";
 export declare enum AuthorizationErrorType {
     InvalidRequest = "invalid_request",
@@ -60,11 +61,6 @@ export interface IAuthorizationServerMetadata {
     introspection_endpoint_auth_signing_alg_values_supported?: string[];
     code_challenge_methods_supported?: string[];
 }
-export interface IRequiredAuthorizationServerMetadata extends IAuthorizationServerMetadata {
-    authorization_endpoint: string;
-    token_endpoint: string;
-    registration_endpoint: string;
-}
 export interface IAuthorizationDynamicClientRegistrationResponse {
     client_id: string;
     client_secret?: string;
@@ -161,8 +157,7 @@ export declare function isAuthorizationTokenResponse(obj: unknown): obj is IAuth
 export declare function isAuthorizationDeviceResponse(obj: unknown): obj is IAuthorizationDeviceResponse;
 export declare function isAuthorizationErrorResponse(obj: unknown): obj is IAuthorizationErrorResponse;
 export declare function isAuthorizationRegistrationErrorResponse(obj: unknown): obj is IAuthorizationRegistrationErrorResponse;
-export declare function getDefaultMetadataForUrl(authorizationServer: URL): IRequiredAuthorizationServerMetadata & IRequiredAuthorizationServerMetadata;
-export declare function getMetadataWithDefaultValues(metadata: IAuthorizationServerMetadata): IAuthorizationServerMetadata & IRequiredAuthorizationServerMetadata;
+export declare function getDefaultMetadataForUrl(authorizationServer: URL): IAuthorizationServerMetadata;
 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): {
@@ -170,4 +165,3 @@ export declare function parseWWWAuthenticateHeader(wwwAuthenticateHeaderValue: s
     params: Record<string, string>;
 };
 export declare function getClaimsFromJWT(token: string): IAuthorizationJWTClaims;
-export declare function getResourceServerBaseUrlFromDiscoveryUrl(discoveryUrl: string): string;

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

@@ -2,8 +2,8 @@
 import { decodeBase64 } from './buffer.js';
 
 const WELL_KNOWN_ROUTE = '/.well-known';
-const AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH = `${WELL_KNOWN_ROUTE}/oauth-protected-resource`;
 const AUTH_SERVER_METADATA_DISCOVERY_PATH = `${WELL_KNOWN_ROUTE}/oauth-authorization-server`;
+const OPENID_CONNECT_DISCOVERY_PATH = `${WELL_KNOWN_ROUTE}/openid-configuration`;
 const AUTH_SCOPE_SEPARATOR = ' ';
 var AuthorizationErrorType;
 (function (AuthorizationErrorType) {
@@ -79,15 +79,6 @@ function getDefaultMetadataForUrl(authorizationServer) {
         response_types_supported: ['code', 'id_token', 'id_token token'],
     };
 }
-function getMetadataWithDefaultValues(metadata) {
-    const issuer = ( new URL(metadata.issuer));
-    return {
-        ...metadata,
-        authorization_endpoint: metadata.authorization_endpoint ?? ( ( new URL('/authorize', issuer)).toString()),
-        token_endpoint: metadata.token_endpoint ?? ( ( new URL('/token', issuer)).toString()),
-        registration_endpoint: metadata.registration_endpoint ?? ( ( new URL('/register', issuer)).toString()),
-    };
-}
 const grantTypesSupported = ['authorization_code', 'refresh_token', 'urn:ietf:params:oauth:grant-type:device_code'];
 const DEFAULT_AUTH_FLOW_PORT = 33418;
 async function fetchDynamicRegistration(serverMetadata, clientName, scopes) {
@@ -109,10 +100,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',
@@ -179,17 +170,5 @@ function getClaimsFromJWT(token) {
         throw ( new Error('Failed to parse JWT token'));
     }
 }
-function getResourceServerBaseUrlFromDiscoveryUrl(discoveryUrl) {
-    const url = ( new URL(discoveryUrl));
-    if (!url.pathname.startsWith(AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH)) {
-        throw ( new Error(
-            `Invalid discovery URL: expected path to start with ${AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH}`
-        ));
-    }
-    const pathWithoutDiscovery = url.pathname.substring(AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH.length);
-    const baseUrl = ( new URL(url.origin));
-    baseUrl.pathname = pathWithoutDiscovery || '/';
-    return ( baseUrl.toString());
-}
 
-export { AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH, AUTH_SCOPE_SEPARATOR, AUTH_SERVER_METADATA_DISCOVERY_PATH, AuthorizationDeviceCodeErrorType, AuthorizationErrorType, AuthorizationRegistrationErrorType, DEFAULT_AUTH_FLOW_PORT, fetchDynamicRegistration, getClaimsFromJWT, getDefaultMetadataForUrl, getMetadataWithDefaultValues, getResourceServerBaseUrlFromDiscoveryUrl, 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 };

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

@@ -21,3 +21,13 @@ export declare function recordChanges<TObs extends Record<any, IObservableWithCh
         };
     }[keyof TObs])[];
 }>;
+export declare function recordChangesLazy<TObs extends Record<any, IObservableWithChange<any, any>>>(getObs: () => TObs): IChangeTracker<{
+    [TKey in keyof TObs]: ReturnType<TObs[TKey]["get"]>;
+} & {
+    changes: readonly ({
+        [TKey in keyof TObs]: {
+            key: TKey;
+            change: TObs[TKey]["TChange"];
+        };
+    }[keyof TObs])[];
+}>;

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

@@ -29,5 +29,37 @@ function recordChanges(obs) {
         }
     };
 }
+function recordChangesLazy(getObs) {
+    let obs = undefined;
+    return {
+        createChangeSummary: (_previousChangeSummary) => {
+            return {
+                changes: [],
+            };
+        },
+        handleChange(ctx, changeSummary) {
+            if (!obs) {
+                obs = getObs();
+            }
+            for (const key in obs) {
+                if (ctx.didChange(obs[key])) {
+                    changeSummary.changes.push({ key, change: ctx.change });
+                }
+            }
+            return true;
+        },
+        beforeUpdate(reader, changeSummary) {
+            if (!obs) {
+                obs = getObs();
+            }
+            for (const key in obs) {
+                if (key === 'changes') {
+                    throw ( new BugIndicatingError('property name "changes" is reserved for change tracking'));
+                }
+                changeSummary[key] = obs[key].read(reader);
+            }
+        }
+    };
+}
 
-export { recordChanges };
+export { recordChanges, recordChangesLazy };

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

@@ -8,7 +8,7 @@ export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult
 export { derivedWithCancellationToken, waitForState } from "./utils/utilsCancellation.js";
 export { debouncedObservableDeprecated, debouncedObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, signalFromObservable, wasEventTriggeredRecently, } from "./utils/utils.js";
 export { type DebugOwner } from "./debugName.js";
-export { type IChangeContext, type IChangeTracker, recordChanges } from "./changeTracker.js";
+export { type IChangeContext, type IChangeTracker, recordChanges, recordChangesLazy } from "./changeTracker.js";
 export { constObservable } from "./observables/constObservable.js";
 export { type IObservableSignal, observableSignal } from "./observables/observableSignal.js";
 export { observableFromEventOpts } from "./observables/observableFromEvent.js";
@@ -20,4 +20,4 @@ export { derivedConstOnceDefined, latestChangedValue } from "./experimental/util
 export { observableFromEvent } from "./observables/observableFromEvent.js";
 export { observableValue } from "./observables/observableValue.js";
 export { ObservableSet } from "./set.js";
-export { ObservableMap } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/base/common/observableInternal/map";
+export { ObservableMap } from "./map.js";

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

@@ -213,7 +213,28 @@ class DevToolsLogger {
                             return formatValue(obs.debugGetState().value, 200);
                         }
                         return undefined;
-                    }
+                    },
+                    logValue: (instanceId) => {
+                        const obs = this._aliveInstances.get(instanceId);
+                        if (obs && 'get' in obs) {
+                            console.log('Logged Value:', obs.get());
+                        }
+                        else {
+                            throw ( new BugIndicatingError('Observable is not supported'));
+                        }
+                    },
+                    rerun: (instanceId) => {
+                        const obs = this._aliveInstances.get(instanceId);
+                        if (obs instanceof Derived) {
+                            obs.debugRecompute();
+                        }
+                        else if (obs instanceof AutorunObserver) {
+                            obs.debugRerun();
+                        }
+                        else {
+                            throw ( new BugIndicatingError('Observable is not supported'));
+                        }
+                    },
                 }
             };
         });

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

@@ -0,0 +1,24 @@
+import { IObservable, ITransaction } from "../observable.js";
+export declare class ObservableMap<K, V> implements Map<K, V> {
+    private readonly _data;
+    private readonly _obs;
+    readonly observable: IObservable<Map<K, V>>;
+    get size(): number;
+    has(key: K): boolean;
+    get(key: K): V | undefined;
+    set(key: K, value: V, tx?: ITransaction): this;
+    delete(key: K, tx?: ITransaction): boolean;
+    clear(tx?: ITransaction): void;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    entries(): IterableIterator<[
+        K,
+        V
+    ]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    [Symbol.iterator](): IterableIterator<[
+        K,
+        V
+    ]>;
+    get [Symbol.toStringTag](): string;
+}

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

@@ -0,0 +1,63 @@
+
+import { observableValueOpts } from './observables/observableValueOpts.js';
+
+class ObservableMap {
+    constructor() {
+        this._data = ( new Map());
+        this._obs = observableValueOpts({ equalsFn: () => false }, this);
+        this.observable = this._obs;
+    }
+    get size() {
+        return this._data.size;
+    }
+    has(key) {
+        return ( this._data.has(key));
+    }
+    get(key) {
+        return this._data.get(key);
+    }
+    set(key, value, tx) {
+        const hadKey = ( this._data.has(key));
+        const oldValue = this._data.get(key);
+        if (!hadKey || oldValue !== value) {
+            this._data.set(key, value);
+            this._obs.set(this, tx);
+        }
+        return this;
+    }
+    delete(key, tx) {
+        const result = this._data.delete(key);
+        if (result) {
+            this._obs.set(this, tx);
+        }
+        return result;
+    }
+    clear(tx) {
+        if (this._data.size > 0) {
+            this._data.clear();
+            this._obs.set(this, tx);
+        }
+    }
+    forEach(callbackfn, thisArg) {
+        this._data.forEach((value, key, _map) => {
+            callbackfn.call(thisArg, value, key, this);
+        });
+    }
+    *entries() {
+        yield* this._data.entries();
+    }
+    *keys() {
+        yield* ( this._data.keys());
+    }
+    *values() {
+        yield* ( this._data.values());
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    get [Symbol.toStringTag]() {
+        return 'ObservableMap';
+    }
+}
+
+export { ObservableMap };

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

@@ -57,6 +57,7 @@ export declare class Derived<T, TChangeSummary = any, TChange = void> extends Ba
         value: T | undefined;
     };
     debugSetValue(newValue: unknown): void;
+    debugRecompute(): void;
     setValue(newValue: T, tx: ITransaction, change: TChange): void;
 }
 export declare class DerivedWithSetter<T, TChangeSummary = any, TOutChanges = any> extends Derived<T, TChangeSummary, TOutChanges> implements ISettableObservable<T, TOutChanges> {

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

@@ -305,6 +305,14 @@ class Derived extends BaseObservable {
     debugSetValue(newValue) {
         this._value = newValue;
     }
+    debugRecompute() {
+        if (!this._isComputing) {
+            this._recompute();
+        }
+        else {
+            this._state = DerivedState.stale;
+        }
+    }
     setValue(newValue, tx, change) {
         this._value = newValue;
         const observers = this._observers;

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

@@ -34,7 +34,7 @@ if (typeof nodeProcess === 'object') {
     _isLinux = (nodeProcess.platform === 'linux');
     _isLinuxSnap = _isLinux && !!nodeProcess.env['SNAP'] && !!nodeProcess.env['SNAP_REVISION'];
     _isElectron = isElectronProcess;
-    _isCI = !!nodeProcess.env['CI'] || !!nodeProcess.env['BUILD_ARTIFACTSTAGINGDIRECTORY'];
+    _isCI = !!nodeProcess.env['CI'] || !!nodeProcess.env['BUILD_ARTIFACTSTAGINGDIRECTORY'] || !!nodeProcess.env['GITHUB_WORKSPACE'];
     _locale = LANGUAGE_DEFAULT;
     _language = LANGUAGE_DEFAULT;
     const rawNlsConfig = nodeProcess.env['VSCODE_NLS_CONFIG'];

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 "./policy.js";
+import { IPolicy } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/base/common/policy";
 export interface IBuiltInExtension {
     readonly name: string;
     readonly version: string;
@@ -316,12 +316,24 @@ export interface IDefaultChatAgent {
     readonly manageOverageUrl: string;
     readonly upgradePlanUrl: string;
     readonly signUpUrl: string;
-    readonly providerId: string;
-    readonly providerName: string;
-    readonly enterpriseProviderId: string;
-    readonly enterpriseProviderName: string;
-    readonly alternativeProviderId: string;
-    readonly alternativeProviderName: string;
+    readonly provider: {
+        default: {
+            id: string;
+            name: string;
+        };
+        enterprise: {
+            id: string;
+            name: string;
+        };
+        google: {
+            id: string;
+            name: string;
+        };
+        apple: {
+            id: string;
+            name: string;
+        };
+    };
     readonly providerUriSetting: string;
     readonly providerScopes: string[][];
     readonly entitlementUrl: string;

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

@@ -135,3 +135,4 @@ export declare class InvisibleCharacters {
     static get codePoints(): ReadonlySet<number>;
 }
 export declare const Ellipsis = "\u2026";
+export declare function multibyteAwareBtoa(str: string): string;

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

@@ -818,5 +818,20 @@ class InvisibleCharacters {
     }
 }
 const Ellipsis = '\u2026';
+function toBinary(str) {
+    const codeUnits = ( new Uint16Array(str.length));
+    for (let i = 0; i < codeUnits.length; i++) {
+        codeUnits[i] = str.charCodeAt(i);
+    }
+    let binary = '';
+    const uint8array = ( new Uint8Array(codeUnits.buffer));
+    for (let i = 0; i < uint8array.length; i++) {
+        binary += String.fromCharCode(uint8array[i]);
+    }
+    return binary;
+}
+function multibyteAwareBtoa(str) {
+    return btoa(toBinary(str));
+}
 
-export { AmbiguousCharacters, CodePointIterator, Ellipsis, GraphemeBreakType, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, forAnsiStringParts, format, format2, fuzzyContains, getCharContainingOffset, getIndentationLength, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, nextCharLength, noBreakWhitespace, prevCharLength, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, rtrim, singleLetterHash, splitLines, startsWithIgnoreCase, startsWithUTF8BOM, stripWildcards, trim, truncate, truncateMiddle, uppercaseFirstLetter };
+export { AmbiguousCharacters, CodePointIterator, Ellipsis, GraphemeBreakType, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, forAnsiStringParts, format, format2, fuzzyContains, getCharContainingOffset, getIndentationLength, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, multibyteAwareBtoa, nextCharLength, noBreakWhitespace, prevCharLength, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, rtrim, singleLetterHash, splitLines, startsWithIgnoreCase, startsWithUTF8BOM, stripWildcards, trim, truncate, truncateMiddle, uppercaseFirstLetter };

package/vscode/src/vs/editor/browser/config/editorConfiguration.js

@@ -166,13 +166,13 @@ function digitCount(n) {
 }
 function getExtraEditorClassName(isStandaloneEditor) {
     let extra = '';
-    if (!isSafari && !isWebkitWebView) {
-        extra += 'no-user-select ';
-    }
-    if (isSafari) {
+    if (isSafari || isWebkitWebView) {
         extra += 'no-minimap-shadow ';
         extra += 'enable-user-select ';
     }
+    else {
+        extra += 'no-user-select ';
+    }
     if (isMacintosh) {
         extra += 'mac ';
     }

package/vscode/src/vs/editor/browser/config/migrateOptions.js

@@ -68,6 +68,7 @@ registerSimpleEditorSettingMigration('cursorSmoothCaretAnimation', [[true, 'on']
 registerSimpleEditorSettingMigration('occurrencesHighlight', [[true, 'singleFile'], [false, 'off']]);
 registerSimpleEditorSettingMigration('wordBasedSuggestions', [[true, 'matchingDocuments'], [false, 'off']]);
 registerSimpleEditorSettingMigration('defaultColorDecorators', [[true, 'auto'], [false, 'never']]);
+registerSimpleEditorSettingMigration('minimap.autohide', [[true, 'mouseover'], [false, 'none']]);
 registerEditorSettingMigration('autoClosingBrackets', (value, read, write) => {
     if (value === false) {
         write('autoClosingBrackets', 'never');