@codingame/monaco-vscode-api 31.0.1 → 32.0.1

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

@@ -598,11 +598,12 @@ class LeakageMonitor {
         if (this._warnCountdown <= 0) {
             this._warnCountdown = threshold * 0.5;
             const [topStack, topCount] = this.getMostFrequentStack();
+            const emitterName = /^[0-9a-f]+$/i.test(this.name) ? undefined : this.name;
             const message = `[${this.name}] potential listener LEAK detected, having ${listenerCount} listeners already. MOST frequent listener (${topCount}):`;
             console.warn(message);
             console.warn(topStack);
             const kind = topCount / listenerCount > 0.3 ? "dominated" : "popular";
-            const error = ( new ListenerLeakError(kind, message, topStack, listenerCount));
+            const error = ( new ListenerLeakError(kind, message, topStack, listenerCount, emitterName));
             this._errorHandler(error);
         }
         return () => {
@@ -638,8 +639,10 @@ class Stacktrace {
     }
 }
 class ListenerLeakError extends Error {
-    constructor(kind, details, stack, listenerCount) {
-        super(`potential listener LEAK detected, ${kind}`);
+    constructor(kind, details, stack, listenerCount, emitterName) {
+        super(
+            emitterName ? `[${emitterName}] potential listener LEAK detected, ${kind}` : `potential listener LEAK detected, ${kind}`
+        );
         this.name = "ListenerLeakError";
         this.kind = kind;
         this.listenerCount = listenerCount;
@@ -651,8 +654,8 @@ class ListenerLeakError extends Error {
     }
 }
 class ListenerRefusalError extends ListenerLeakError {
-    constructor(kind, details, stack, listenerCount) {
-        super(kind, details, stack, listenerCount);
+    constructor(kind, details, stack, listenerCount, emitterName) {
+        super(kind, details, stack, listenerCount, emitterName);
         this.name = "ListenerRefusalError";
     }
 }
@@ -682,7 +685,8 @@ class Emitter {
         this._options = options;
         this._leakageMon = (_globalLeakWarningThreshold > 0 || this._options?.leakWarningThreshold) ? ( new LeakageMonitor(
             options?.onListenerError ?? onUnexpectedError,
-            this._options?.leakWarningThreshold ?? _globalLeakWarningThreshold
+            this._options?.leakWarningThreshold ?? _globalLeakWarningThreshold,
+            this._options?.leakWarningName
         )) : undefined;
         this._perfMon = this._options?._profName ? ( new EventProfiling(this._options._profName)) : undefined;
         this._deliveryQueue = this._options?.deliveryQueue;
@@ -712,7 +716,8 @@ class Emitter {
                     kind,
                     `${message}. HINT: Stack shows most frequent listener (${tuple[1]}-times)`,
                     tuple[0],
-                    this._size
+                    this._size,
+                    this._options?.leakWarningName
                 ));
                 const errorHandler = this._options?.onListenerError || onUnexpectedError;
                 errorHandler(error);

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

@@ -266,8 +266,9 @@ function matchesWords(word, target, contiguous = false) {
     let targetIndex = 0;
     word = tryNormalizeToBase(word);
     target = tryNormalizeToBase(target);
+    const memo = ( new Map());
     while (targetIndex < target.length) {
-        result = _matchesWords(word, target, 0, targetIndex, contiguous);
+        result = _matchesWords(word, target, 0, targetIndex, contiguous, memo);
         if (result !== null) {
             break;
         }
@@ -275,13 +276,37 @@ function matchesWords(word, target, contiguous = false) {
     }
     return result;
 }
-function _matchesWords(word, target, wordIndex, targetIndex, contiguous) {
-    let targetIndexOffset = 0;
+function cloneMatches(matches) {
+    if (matches === null) {
+        return null;
+    }
+    const result = [];
+    for (const m of matches) {
+        result.push({
+            start: m.start,
+            end: m.end
+        });
+    }
+    return result;
+}
+function _matchesWords(word, target, wordIndex, targetIndex, contiguous, memo) {
     if (wordIndex === word.length) {
         return [];
     } else if (targetIndex === target.length) {
         return null;
-    } else if (!charactersMatch(word.charCodeAt(wordIndex), target.charCodeAt(targetIndex))) {
+    }
+    const memoKey = wordIndex * (target.length + 1) + targetIndex;
+    const cached = memo.get(memoKey);
+    if (cached !== undefined) {
+        return cloneMatches(cached);
+    }
+    const computed = _matchesWordsCompute(word, target, wordIndex, targetIndex, contiguous, memo);
+    memo.set(memoKey, cloneMatches(computed));
+    return computed;
+}
+function _matchesWordsCompute(word, target, wordIndex, targetIndex, contiguous, memo) {
+    let targetIndexOffset = 0;
+    if (!charactersMatch(word.charCodeAt(wordIndex), target.charCodeAt(targetIndex))) {
         const altChars = getAlternateCodes(word.charCodeAt(wordIndex));
         if (!altChars) {
             return null;
@@ -295,10 +320,10 @@ function _matchesWords(word, target, wordIndex, targetIndex, contiguous) {
     }
     let result = null;
     let nextWordIndex = targetIndex + targetIndexOffset + 1;
-    result = _matchesWords(word, target, wordIndex + 1, nextWordIndex, contiguous);
+    result = _matchesWords(word, target, wordIndex + 1, nextWordIndex, contiguous, memo);
     if (!contiguous) {
         while (!result && (nextWordIndex = nextWord(target, nextWordIndex)) < target.length) {
-            result = _matchesWords(word, target, wordIndex + 1, nextWordIndex, contiguous);
+            result = _matchesWords(word, target, wordIndex + 1, nextWordIndex, contiguous, memo);
             nextWordIndex++;
         }
     }

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

@@ -45,6 +45,15 @@ export declare function isEmptyMarkdownString(oneOrMany: IMarkdownString | IMark
 export declare function isMarkdownString(thing: unknown): thing is IMarkdownString;
 export declare function markdownStringEqual(a: IMarkdownString, b: IMarkdownString): boolean;
 export declare function escapeMarkdownSyntaxTokens(text: string): string;
+/**
+ * Escapes only the characters that would break out of markdown link text
+ * (`[label](url)`) syntax: `\` and `]`. Use this when the escaped string is
+ * displayed as the visible label of a link, since renderers that extract the
+ * link text without re-parsing markdown (e.g. the chat inline anchor / skill
+ * pill) would otherwise show full `escapeMarkdownSyntaxTokens` backslashes
+ * (`\-`, `\.`, ...) verbatim.
+ */
+export declare function escapeMarkdownLinkLabel(text: string): string;
 /**
  * @see https://github.com/microsoft/vscode/issues/193746
  */

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

@@ -1,5 +1,5 @@
 
-import { onUnexpectedError } from './errors.js';
+import { onUnexpectedExternalError } from './errors.js';
 import { isWeb, isNative, webWorkerOrigin } from './platform.js';
 import { equalsIgnoreCase, startsWithIgnoreCase } from './strings.js';
 import { URI } from './uri.js';
@@ -108,7 +108,7 @@ class RemoteAuthoritiesImpl {
             try {
                 return this._delegate(uri);
             } catch (err) {
-                onUnexpectedError(err);
+                onUnexpectedExternalError(err);
                 return uri;
             }
         }

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

@@ -13,6 +13,19 @@ export declare function equals(one: any, other: any): boolean;
  *  "Uncaught TypeError: Converting circular structure to JSON"
  */
 export declare function safeStringify(obj: any): string;
+/**
+ * Like `JSON.stringify`, but with deterministic ordering of object keys so that
+ * structurally equal inputs always produce the same string. Useful for cache
+ * keys derived from arbitrary object payloads.
+ *
+ * - Object keys are sorted at every level of nesting.
+ * - Properties whose value is `undefined` are omitted (matching `JSON.stringify`).
+ * - Circular references are replaced with the string `"[Circular]"` to avoid
+ *   throwing.
+ * - A top-level `undefined` returns the string `'undefined'`; any other
+ *   stringification failure returns the empty string.
+ */
+export declare function stableStringify(value: unknown): string;
 type obj = {
     [key: string]: any;
 };

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

@@ -153,6 +153,38 @@ function safeStringify(obj) {
         return value;
     });
 }
+function stableStringify(value) {
+    if (value === undefined) {
+        return "undefined";
+    }
+    try {
+        return _stableStringify(value, ( new WeakSet()));
+    } catch {
+        return "";
+    }
+}
+function _stableStringify(value, seen) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value) ?? "null";
+    }
+    if (( seen.has(value))) {
+        return "\"[Circular]\"";
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return "[" + ( value.map(v => _stableStringify(v, seen))).join(",") + "]";
+    }
+    const keys = ( Object.keys(value)).sort();
+    const parts = [];
+    for (const k of keys) {
+        const v = value[k];
+        if (v === undefined) {
+            continue;
+        }
+        parts.push(JSON.stringify(k) + ":" + _stableStringify(v, seen));
+    }
+    return "{" + parts.join(",") + "}";
+}
 function distinct(base, target) {
     const result = Object.create(null);
     if (!base || !target) {
@@ -185,4 +217,4 @@ function mapValues(obj, fn) {
     return result;
 }
 
-export { cloneAndChange, deepClone, deepFreeze, distinct, equals, filter, mapValues, mixin, safeStringify };
+export { cloneAndChange, deepClone, deepFreeze, distinct, equals, filter, mapValues, mixin, safeStringify, stableStringify };

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

@@ -1,10 +1,10 @@
 export { observableValueOpts } from "./observables/observableValueOpts.js";
-export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges, autorunIterableDelta, autorunSelfDisposable } from "./reactions/autorun.js";
+export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges, autorunIterableDelta, autorunPerKeyedItem, autorunSelfDisposable, registerAutorunSelfDisposable } from "./reactions/autorun.js";
 export { type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type IReaderWithStore, type ISettableObservable, type ITransaction } from "./base.js";
 export { disposableObservableValue } from "./observables/observableValue.js";
 export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from "./observables/derived.js";
 export { type IDerivedReader } from "./observables/derivedImpl.js";
-export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from "./utils/promise.js";
+export { ObservableLazy, ObservableLazyPromise, ObservablePromise, ObservableResolvedPromise, PromiseResult, } from "./utils/promise.js";
 export { derivedWithCancellationToken, waitForState } from "./utils/utilsCancellation.js";
 export { debouncedObservable, debouncedObservable2, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, signalFromObservable, throttledObservable, wasEventTriggeredRecently, isObservable, } from "./utils/utils.js";
 export { type DebugOwner } from "./debugName.js";

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

@@ -47,10 +47,36 @@ export declare function autorunIterableDelta<T>(getValue: (reader: IReader) => I
     addedValues: T[];
     removedValues: T[];
 }) => void, getUniqueIdentifier?: (value: T) => unknown): IDisposable;
+/**
+ * For each key-stable item in {@link items}, runs {@link setup} once when the
+ * key is first observed and disposes the per-key {@link DisposableStore} when
+ * the key is no longer present in the array (or when the returned disposable
+ * is disposed).
+ *
+ * The {@link IObservable} handed to {@link setup} fires whenever the array
+ * still contains an item with the same key but the item value itself has
+ * changed (e.g. because the upstream state is immutable and produced a new
+ * object with the same id). All per-key value updates triggered by a single
+ * change to {@link items} are batched into one transaction, so dependent
+ * autoruns observe a consistent snapshot.
+ *
+ * Per-key state should be stored in closures or in disposables registered
+ * against the per-key {@link DisposableStore}. {@link setup} should not call
+ * `.read()` on the outer {@link items} observable from its body (use the
+ * provided per-key value observable, or create inner autoruns).
+ */
+export declare function autorunPerKeyedItem<TIn, TKey>(items: IObservable<readonly TIn[]>, keyFn: (input: TIn) => TKey, setup: (key: TKey, value: IObservable<TIn>, store: DisposableStore) => void, debugLocation?: DebugLocation): 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.
+ * @deprecated Use autorunSelfDisposable2
  */
 export declare function autorunSelfDisposable(fn: (reader: IReaderWithDispose) => void, debugLocation?: DebugLocation): IDisposable;
+/**
+ * An autorun with a `dispose()` method on its `reader` which cancels the autorun.
+ * It it safe to call `dispose()` synchronously.
+ * TODO@hediet/copilot: rename to delete autorunSelfDisposable, and rename autorunSelfDisposable2 to autorunSelfDisposable.
+ */
+export declare function registerAutorunSelfDisposable(store: DisposableStore, fn: (reader: IReaderWithDispose) => void, debugLocation?: DebugLocation): void;

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

@@ -107,5 +107,28 @@ function autorunSelfDisposable(fn, debugLocation = DebugLocation.ofCaller()) {
     }
     return ar;
 }
+function registerAutorunSelfDisposable(store, fn, debugLocation = DebugLocation.ofCaller()) {
+    let ar;
+    let disposeSync = false;
+    ar = autorun(reader => {
+        fn({
+            delayedStore: reader.delayedStore,
+            store: reader.store,
+            readObservable: reader.readObservable.bind(reader),
+            dispose: () => {
+                if (!ar) {
+                    disposeSync = true;
+                } else {
+                    store.delete(ar);
+                }
+            }
+        });
+    }, debugLocation);
+    if (disposeSync) {
+        ar.dispose();
+    } else {
+        store.add(ar);
+    }
+}
 
-export { autorun, autorunDelta, autorunHandleChanges, autorunIterableDelta, autorunOpts, autorunSelfDisposable, autorunWithStore, autorunWithStoreHandleChanges };
+export { autorun, autorunDelta, autorunHandleChanges, autorunIterableDelta, autorunOpts, autorunSelfDisposable, autorunWithStore, autorunWithStoreHandleChanges, registerAutorunSelfDisposable };

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

@@ -1,3 +1,4 @@
+import { DisposableStore } from "../../lifecycle.js";
 import { IObservable } from "../base.js";
 export declare class ObservableLazy<T> {
     private readonly _computeValue;
@@ -60,6 +61,18 @@ export declare class PromiseResult<T> {
      */
     getDataOrThrow(): T;
 }
+/**
+ * Tracks a changing {@link ObservablePromise}, exposing the last resolved value
+ * and whether a newer promise is still pending.
+ */
+export declare class ObservableResolvedPromise<T> {
+    private readonly _lastResolved;
+    readonly lastResolved: IObservable<T>;
+    private readonly _isResolving;
+    readonly isResolving: IObservable<boolean>;
+    private _runningPromise;
+    constructor(source: IObservable<ObservablePromise<T>>, initialValue: T, store: DisposableStore);
+}
 /**
  * A lazy promise whose state is observable.
  */

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

@@ -1,4 +1,5 @@
 
+import { autorun } from '../reactions/autorun.js';
 import { transaction } from '../transaction.js';
 import { derived } from '../observables/derived.js';
 import { observableValue } from '../observables/observableValue.js';
@@ -65,6 +66,27 @@ class PromiseResult {
         return this.data;
     }
 }
+class ObservableResolvedPromise {
+    constructor(source, initialValue, store) {
+        this._isResolving = observableValue(this, false);
+        this.isResolving = this._isResolving;
+        this._lastResolved = observableValue(this, initialValue);
+        this.lastResolved = this._lastResolved;
+        store.add(autorun(reader => {
+            const current = source.read(reader);
+            this._runningPromise = current;
+            const result = current.promiseResult.read(reader);
+            if (result) {
+                if (current === this._runningPromise) {
+                    this._isResolving.set(false, undefined);
+                    this._lastResolved.set(result.getDataOrThrow(), undefined);
+                }
+            } else {
+                this._isResolving.set(true, undefined);
+            }
+        }));
+    }
+}
 class ObservableLazyPromise {
     constructor(_computePromise) {
         this._computePromise = _computePromise;
@@ -79,4 +101,4 @@ class ObservableLazyPromise {
     }
 }
 
-export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult };
+export { ObservableLazy, ObservableLazyPromise, ObservablePromise, ObservableResolvedPromise, PromiseResult };

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

@@ -19,7 +19,6 @@ export interface INodeProcess {
         chrome?: string;
     };
     type?: string;
-    isEmbeddedApp?: boolean;
     cwd: () => string;
 }
 export declare enum Platform {

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

@@ -1,4 +1,4 @@
-import { IPolicyData } from "./defaultAccount.js";
+import { IPolicyData } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/base/common/defaultAccount";
 /**
  * System-wide policy file path for Linux systems.
  */
@@ -57,4 +57,15 @@ export interface IPolicy {
      * If `undefined`, the feature's setting is not locked and can be overridden by other means.
      */
     readonly value?: (policyData: IPolicyData) => string | number | boolean | undefined;
+    /**
+     * The most-restrictive value that should be applied when the user is subject to the
+     * "Require Approved Account" gate but the gate is not yet satisfied (i.e. no approved
+     * GitHub account is signed in or the account-side policy data has not yet resolved).
+     *
+     * If omitted, the gate falls back to a type-driven safe default
+     * (`false` for boolean, `0` for number, `''` for string).
+     *
+     * Only consulted while the gate is active and unsatisfied; ignored otherwise.
+     */
+    readonly restrictedValue?: string | number | boolean;
 }

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

@@ -78,12 +78,17 @@ export interface IProductConfiguration {
     readonly win32RegValueName?: string;
     readonly win32NameVersion?: string;
     readonly win32VersionedUpdate?: boolean;
-    readonly win32SiblingExeBasename?: string;
+    readonly win32ContextMenu?: {
+        readonly [arch: string]: {
+            readonly clsid: string;
+        };
+    };
     readonly applicationName: string;
     readonly embedderIdentifier?: string;
-    readonly telemetryAppName?: string;
+    readonly agentsTelemetryAppName?: string;
     readonly urlProtocol: string;
     readonly dataFolderName: string;
+    readonly sharedDataFolderName: string;
     readonly builtInExtensions?: IBuiltInExtension[];
     readonly walkthroughMetadata?: IProductWalkthrough[];
     readonly featuredExtensions?: IFeaturedExtension[];
@@ -206,6 +211,7 @@ export interface IProductConfiguration {
     }>;
     readonly extensionsForceVersionByQuality?: readonly string[];
     readonly builtInExtensionsEnabledWithAutoUpdates: readonly string[];
+    readonly sessionsWindowAllowedExtensions?: readonly string[];
     readonly msftInternalDomains?: string[];
     readonly linkProtectionTrustedDomains?: readonly string[];
     readonly authClientIdMetadataUrl?: string;
@@ -213,7 +219,6 @@ export interface IProductConfiguration {
     readonly "editSessions.store"?: Omit<ConfigurationSyncStore, "insidersUrl" | "stableUrl">;
     readonly darwinUniversalAssetId?: string;
     readonly darwinBundleIdentifier?: string;
-    readonly darwinSiblingBundleIdentifier?: string;
     readonly profileTemplatesUrl?: string;
     readonly commonlyUsedSettings?: string[];
     readonly aiGeneratedWorkspaceTrust?: IAiGeneratedWorkspaceTrust;
@@ -225,7 +230,6 @@ export interface IProductConfiguration {
     readonly extensionConfigurationPolicy?: IStringDictionary<IPolicy>;
     readonly onboardingKeymaps?: readonly IProductOnboardingKeymap[];
     readonly onboardingThemes?: readonly IProductOnboardingTheme[];
-    readonly embedded?: IEmbeddedProductConfiguration;
     /**
      * When running as an embedded app, the parent VS Code's policy
      * identity (win32RegValueName / darwinBundleIdentifier) so that
@@ -249,7 +253,6 @@ export interface IProductOnboardingTheme {
     readonly themeId: string;
     readonly type: "dark" | "light" | "hcDark" | "hcLight";
 }
-export type IEmbeddedProductConfiguration = Pick<IProductConfiguration, "nameShort" | "nameLong" | "applicationName" | "dataFolderName" | "darwinBundleIdentifier" | "darwinSiblingBundleIdentifier" | "urlProtocol" | "win32AppUserModelId" | "win32MutexName" | "win32RegValueName" | "win32NameVersion" | "win32VersionedUpdate" | "win32SiblingExeBasename">;
 export interface ITunnelApplicationConfig {
     authenticationProviders: IStringDictionary<{
         scopes: string[];
@@ -391,7 +394,6 @@ export interface IDefaultChatAgent {
     readonly completionsQuotaExceededContext: string;
     readonly walkthroughCommand: string;
     readonly completionsMenuCommand: string;
-    readonly completionsRefreshTokenCommand: string;
     readonly chatRefreshTokenCommand: string;
     readonly generateCommitMessageCommand: string;
     readonly resolveMergeConflictsCommand: string;

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

@@ -184,7 +184,7 @@ const extUriBiasedIgnorePathCase = ( new ExtUri(uri => {
 const extUriIgnorePathCase = ( new ExtUri(_ => true));
 const isEqual = extUri.isEqual.bind(extUri);
 const isEqualOrParent = extUri.isEqualOrParent.bind(extUri);
-extUri.getComparisonKey.bind(extUri);
+const getComparisonKey = extUri.getComparisonKey.bind(extUri);
 const basenameOrAuthority = extUri.basenameOrAuthority.bind(extUri);
 const basename = extUri.basename.bind(extUri);
 const extname = extUri.extname.bind(extUri);
@@ -254,4 +254,4 @@ function toLocalResource(resource, authority, localScheme) {
     });
 }
 
-export { DataUri, ExtUri, addTrailingPathSeparator, basename, basenameOrAuthority, dirname, distinctParents, extUri, extUriBiasedIgnorePathCase, extUriIgnorePathCase, extname, hasTrailingPathSeparator, isAbsolutePath, isEqual, isEqualAuthority, isEqualOrParent, joinPath, normalizePath, originalFSPath, relativePath, removeTrailingPathSeparator, resolvePath, toLocalResource };
+export { DataUri, ExtUri, addTrailingPathSeparator, basename, basenameOrAuthority, dirname, distinctParents, extUri, extUriBiasedIgnorePathCase, extUriIgnorePathCase, extname, getComparisonKey, hasTrailingPathSeparator, isAbsolutePath, isEqual, isEqualAuthority, isEqualOrParent, joinPath, normalizePath, originalFSPath, relativePath, removeTrailingPathSeparator, resolvePath, toLocalResource };

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

@@ -13,6 +13,30 @@
  * @returns The parsed representation (YamlMapNode, YamlSequenceNode, or YamlScalarNode)
  */
 export declare function parse(input: string, errors?: YamlParseError[], options?: ParseOptions): YamlNode | undefined;
+/**
+ * Helper to parse a Markdown with YAML frontmatter document
+ * @returns
+ */
+export declare function parseFrontMatter(input: string, errors?: YamlParseError[], options?: ParseOptions): MarkdownNode | undefined;
+export declare class MarkdownNode {
+    readonly header: YamlNode | undefined;
+    readonly body: string;
+    constructor(header: YamlNode | undefined, body: string);
+    getStringValue(name: string): string | undefined;
+    getStringArrayValue(name: string): string[] | undefined;
+}
+/**
+ * Parses a comma-separated list from a scalar node's value into an array of scalars.
+ * Handles single-quoted and double-quoted items, trimming surrounding whitespace for
+ * unquoted items. Offsets on each produced scalar node are relative to the original
+ * document that the input scalar was parsed from.
+ *
+ * Internally wraps the scalar value in `[…]` and delegates to the full YAML parser so
+ * that quoting, whitespace, and escape handling are consistent with the rest of the parser.
+ *
+ * @param scalar A scalar node whose value contains a comma-separated list.
+ */
+export declare function parseCommaSeparatedList(value: string, offset?: number): YamlScalarNode[];
 export interface YamlScalarNode {
     readonly type: "scalar";
     readonly value: string;

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

@@ -42,10 +42,14 @@ class YamlScanner {
         this.tokens = [];
         this.flowDepth = 0;
         this.seenBlockColon = false;
+        this.seenDocumentStart = 0;
     }
-    scan() {
+    scan(maxDocuments = 1) {
         while (this.pos < this.input.length) {
             this.scanLine();
+            if (this.seenDocumentStart > maxDocuments) {
+                break;
+            }
         }
         this.tokens.push(makeToken(TokenType.EOF, this.pos, this.pos));
         return this.tokens;
@@ -94,6 +98,7 @@ class YamlScanner {
                 this.pos += 3;
                 this.scanLineContent();
                 this.scanNewline();
+                this.seenDocumentStart++;
                 return;
             }
             if (c0 === "." && c1 === "." && c2 === "." && isTerminator) {

package/vscode/src/vs/base/parts/ipc/common/ipc.net.d.ts

@@ -91,9 +91,14 @@ export interface WebSocketCloseEvent {
     readonly event: any | undefined;
 }
 export type SocketCloseEvent = NodeSocketCloseEvent | WebSocketCloseEvent | undefined;
+export declare enum SocketTimeoutReason {
+    UNACKNOWLEDGED_MESSAGE = "unacknowledgedMessage",
+    KEEP_ALIVE = "keepAlive"
+}
 export interface SocketTimeoutEvent {
+    readonly reason: SocketTimeoutReason;
     readonly unacknowledgedMsgCount: number;
-    readonly timeSinceOldestUnacknowledgedMsg: number;
+    readonly timeSinceOldestUnacknowledgedMsg?: number;
     readonly timeSinceLastReceivedSomeData: number;
 }
 export interface ISocket extends IDisposable {
@@ -271,6 +276,14 @@ export declare class PersistentProtocol implements IMessagePassingProtocol {
     sendControl(buffer: VSBuffer): void;
     private _sendAckCheck;
     private _recvAckCheck;
+    /**
+     * Called after sending a keepalive. Both sides of this protocol send
+     * keepalives every KeepAliveSendTime (5s), so receiving no data for
+     * TimeoutTime (20s) means the connection is dead. This catches silent
+     * connection deaths that _recvAckCheck cannot detect because there are
+     * no unacknowledged regular messages.
+     */
+    private _keepAliveTimeoutCheck;
     private _sendAck;
     private _sendKeepAlive;
 }

package/vscode/src/vs/base/parts/ipc/common/ipc.net.js

@@ -85,6 +85,11 @@ var SocketCloseEventType;
     SocketCloseEventType[SocketCloseEventType["NodeSocketCloseEvent"] = 0] = "NodeSocketCloseEvent";
     SocketCloseEventType[SocketCloseEventType["WebSocketCloseEvent"] = 1] = "WebSocketCloseEvent";
 })(SocketCloseEventType || (SocketCloseEventType = {}));
+var SocketTimeoutReason;
+(function(SocketTimeoutReason) {
+    SocketTimeoutReason["UNACKNOWLEDGED_MESSAGE"] = "unacknowledgedMessage";
+    SocketTimeoutReason["KEEP_ALIVE"] = "keepAlive";
+})(SocketTimeoutReason || (SocketTimeoutReason = {}));
 let emptyBuffer = null;
 function getEmptyBuffer() {
     if (!emptyBuffer) {
@@ -801,6 +806,7 @@ class PersistentProtocol {
             if (!this._loadEstimator.hasHighLoad()) {
                 this._lastSocketTimeoutTime = Date.now();
                 this._onSocketTimeout.fire({
+                    reason: SocketTimeoutReason.UNACKNOWLEDGED_MESSAGE,
                     unacknowledgedMsgCount: this._outgoingUnackMsg.length(),
                     timeSinceOldestUnacknowledgedMsg,
                     timeSinceLastReceivedSomeData
@@ -819,6 +825,27 @@ class PersistentProtocol {
             this._recvAckCheck();
         }, minimumTimeUntilTimeout);
     }
+    _keepAliveTimeoutCheck() {
+        if (this._isReconnecting) {
+            return;
+        }
+        const now = Date.now();
+        const timeSinceLastReceivedSomeData = now - this._socketReader.lastReadTime;
+        const timeSinceLastTimeout = now - this._lastSocketTimeoutTime;
+        if (timeSinceLastReceivedSomeData >= ProtocolConstants.TimeoutTime && timeSinceLastTimeout >= ProtocolConstants.TimeoutTime) {
+            if (!this._loadEstimator.hasHighLoad()) {
+                this._lastSocketTimeoutTime = now;
+                const unacknowledgedMsgCount = this._outgoingUnackMsg.length();
+                const oldestUnacknowledgedMsg = this._outgoingUnackMsg.peek();
+                this._onSocketTimeout.fire({
+                    reason: SocketTimeoutReason.KEEP_ALIVE,
+                    unacknowledgedMsgCount,
+                    timeSinceOldestUnacknowledgedMsg: oldestUnacknowledgedMsg ? now - oldestUnacknowledgedMsg.writtenTime : undefined,
+                    timeSinceLastReceivedSomeData
+                });
+            }
+        }
+    }
     _sendAck() {
         if (this._incomingMsgId <= this._incomingAckId) {
             return;
@@ -831,7 +858,8 @@ class PersistentProtocol {
         this._incomingAckId = this._incomingMsgId;
         const msg = ( new ProtocolMessage(ProtocolMessageType.KeepAlive, 0, this._incomingAckId, getEmptyBuffer()));
         this._socketWriter.write(msg);
+        this._keepAliveTimeoutCheck();
     }
 }
 
-export { BufferedEmitter, ChunkStream, Client, PersistentProtocol, Protocol, ProtocolConstants, SocketCloseEventType, SocketDiagnostics, SocketDiagnosticsEventType };
+export { BufferedEmitter, ChunkStream, Client, PersistentProtocol, Protocol, ProtocolConstants, SocketCloseEventType, SocketDiagnostics, SocketDiagnosticsEventType, SocketTimeoutReason };

package/vscode/src/vs/base/parts/storage/common/storage.d.ts

@@ -112,3 +112,16 @@ export declare class InMemoryStorageDatabase implements IStorageDatabase {
     optimize(): Promise<void>;
     close(): Promise<void>;
 }
+export declare const MIGRATED_KEY = "__$__migratedStorageMarker";
+export declare class MigratingStorage extends Storage {
+    private migratedKeys;
+    private fallbackStorage;
+    private isFallbackStorageReadonly;
+    init(): Promise<void>;
+    setFallbackStorage(storage: IStorage, isReadonly: boolean): void;
+    private static readonly INTERNAL_KEY_PREFIX;
+    get(key: string, fallbackValue: string): string;
+    get(key: string, fallbackValue?: string): string | undefined;
+    private loadMigratedKeys;
+    private persistMigratedKeys;
+}