@codingame/monaco-vscode-api 36.2.6 → 37.0.0

package/vscode/src/vs/workbench/services/editor/common/editorGroupsService.d.ts

@@ -101,6 +101,10 @@ export interface IMergeGroupOptions {
 }
 export interface ICloseEditorOptions {
     readonly preserveFocus?: boolean;
+    /**
+     * Forces editors to close even when they declare `EditorInputCapabilities.CannotClose`.
+     */
+    readonly force?: boolean;
 }
 export type ICloseEditorsFilter = {
     readonly except?: EditorInput;
@@ -111,6 +115,7 @@ export type ICloseEditorsFilter = {
 export interface ICloseAllEditorsOptions {
     readonly excludeSticky?: boolean;
     readonly excludeConfirming?: boolean;
+    readonly force?: boolean;
 }
 export interface IEditorReplacement {
     readonly editor: EditorInput;
@@ -151,6 +156,10 @@ export interface IEditorDropTargetDelegate {
      * A helper to figure out if the drop target contains the provided group.
      */
     containsGroup?(groupView: IEditorGroup): boolean;
+    /**
+     * Whether the drop target supports creating editor groups.
+     */
+    readonly supportsSplitting?: boolean;
 }
 /**
  * The basic primitive to work with editor groups. This interface is both implemented
@@ -771,6 +780,7 @@ export interface IEditorGroup {
      */
     closeAllEditors(options: {
         excludeConfirming: true;
+        force?: boolean;
     }): boolean;
     closeAllEditors(options?: ICloseAllEditorsOptions): Promise<boolean>;
     /**

package/vscode/src/vs/workbench/services/editor/common/editorResolverService.d.ts

@@ -11,10 +11,11 @@ export type EditorAssociation = {
 export type EditorAssociations = readonly EditorAssociation[];
 export declare const editorsAssociationsSettingId = "workbench.editorAssociations";
 export declare const diffEditorsAssociationsSettingId = "workbench.diffEditorAssociations";
+export declare const hiddenEditorTypesSettingId = "workbench.editor.hiddenEditorTypes";
 /**
  * Setting that controls whether the Markdown editor is the default editor for
  * `*.md` files in the Agents window. Gated behind an experiment so it can be
- * rolled out gradually. Defaults to off.
+ * rolled out gradually. Defaults to on.
  */
 export declare const markdownDefaultEditorAgentsWindowSettingId = "workbench.editor.markdownDefaultEditorInAgentsWindow";
 /**
@@ -29,6 +30,9 @@ export declare const markdownDefaultEditorAgentsWindowSettingId = "workbench.edi
 export declare function editorsAssociationsAgentsWindowDefault(options?: {
     markdownDefaultEditor?: boolean;
 }): Record<string, string>;
+export declare function diffEditorsAssociationsAgentsWindowDefault(options?: {
+    markdownDefaultEditor?: boolean;
+}): Record<string, string>;
 export interface IEditorType {
     readonly id: string;
     readonly displayName: string;
@@ -38,7 +42,12 @@ export declare enum RegisteredEditorPriority {
     builtin = "builtin",
     option = "option",
     exclusive = "exclusive",
-    default = "default"
+    default = "default",
+    /**
+     * The editor is not automatically used for this kind of input or opted into by an association
+     * from another input kind. It requires an association for this input kind or an explicit open.
+     */
+    explicit = "explicit"
 }
 /**
  * If we didn't resolve an editor dictates what to do with the opening state
@@ -61,11 +70,66 @@ export type RegisteredEditorOptions = {
      */
     canSupportResource?: (resource: URI) => boolean;
 };
+export interface IEditorResolverServiceGetEditorsOptions {
+    /**
+     * Excludes optional editors registered for `*`, unless they are configured or currently active.
+     */
+    readonly excludeUnconfiguredUniversalOptionalEditors?: boolean;
+    readonly currentEditorId?: string;
+    readonly isDiffEditor?: boolean;
+}
+export interface IEditorResolverServiceGetEditorMatchesOptions {
+    readonly isDiffEditor?: boolean;
+}
+export interface IEditorResolverServiceGetAllEditorsOptions {
+    /**
+     * Excludes registrations whose editor priority is exclusive.
+     */
+    readonly excludeExclusiveEditors?: boolean;
+}
+export declare enum EditorMatchRuleSource {
+    UserAssociation = 0,
+    EditorRegistration = 1,
+    Fallback = 2
+}
+/**
+ * The effective rule that makes one editor choice available for a resource.
+ */
+export type EditorMatchRule = {
+    readonly editor: RegisteredEditorInfo;
+    readonly priority: RegisteredEditorPriority;
+    readonly associationPattern: string;
+} & ({
+    readonly source: EditorMatchRuleSource.UserAssociation;
+    readonly association: EditorAssociation;
+} | {
+    readonly source: EditorMatchRuleSource.EditorRegistration;
+    readonly globPattern: string | glob.IRelativePattern;
+} | {
+    readonly source: EditorMatchRuleSource.Fallback;
+});
+export declare function isUnconfiguredUniversalOptionalEditorMatch(rule: EditorMatchRule): boolean;
+/**
+ * An immutable snapshot containing one effective rule per matching editor and the rule selecting its default.
+ */
+export declare class EditorMatches {
+    readonly matches: readonly EditorMatchRule[];
+    readonly defaultRuleIndex: number;
+    readonly defaultRule: EditorMatchRule;
+    readonly naturalDefaultRuleIndex: number;
+    readonly naturalDefaultRule: EditorMatchRule;
+    readonly conflictingDefault: boolean;
+    readonly hasExclusiveMatch: boolean;
+    constructor(matches: readonly EditorMatchRule[], defaultRuleIndex: number, naturalDefaultRuleIndex: number, conflictingDefault: boolean);
+}
 export type RegisteredEditorPriorityInfo = {
     readonly editor: RegisteredEditorPriority;
     readonly diff: RegisteredEditorPriority;
     readonly merge: RegisteredEditorPriority;
 };
+export type RegisteredEditorPriorityConfiguration = Omit<RegisteredEditorPriorityInfo, "merge"> & {
+    readonly merge?: RegisteredEditorPriority;
+};
 export type RegisteredEditorInfo = {
     readonly id: string;
     readonly label: string;
@@ -73,9 +137,9 @@ export type RegisteredEditorInfo = {
     readonly priority: RegisteredEditorPriorityInfo;
 };
 export type RegisteredEditorRegistrationInfo = Omit<RegisteredEditorInfo, "priority"> & {
-    readonly priority: RegisteredEditorPriority | RegisteredEditorPriorityInfo;
+    readonly priority: RegisteredEditorPriority | RegisteredEditorPriorityConfiguration;
 };
-export declare function toRegisteredEditorPriorityInfo(priority: RegisteredEditorPriority | RegisteredEditorPriorityInfo): RegisteredEditorPriorityInfo;
+export declare function toRegisteredEditorPriorityInfo(priority: RegisteredEditorPriority | RegisteredEditorPriorityConfiguration): RegisteredEditorPriorityInfo;
 type EditorInputFactoryResult = EditorInputWithOptions | Promise<EditorInputWithOptions>;
 export type EditorInputFactoryFunction = (editorInput: IResourceEditorInput | ITextResourceEditorInput, group: IEditorGroup) => EditorInputFactoryResult;
 export type UntitledEditorInputFactoryFunction = (untitledEditorInput: IUntitledTextResourceEditorInput, group: IEditorGroup) => EditorInputFactoryResult;

package/vscode/src/vs/workbench/services/editor/common/editorResolverService.js

@@ -10,32 +10,36 @@ import { Registry } from '../../../../platform/registry/common/platform.js';
 
 const editorsAssociationsSettingId = "workbench.editorAssociations";
 const diffEditorsAssociationsSettingId = "workbench.diffEditorAssociations";
+const hiddenEditorTypesSettingId = "workbench.editor.hiddenEditorTypes";
 const markdownDefaultEditorAgentsWindowSettingId = "workbench.editor.markdownDefaultEditorInAgentsWindow";
 function editorsAssociationsAgentsWindowDefault(options) {
     return {
         "*.md": options?.markdownDefaultEditor === true ? "vscode.markdown.editor" : "vscode.markdown.preview.editor"
     };
 }
+function diffEditorsAssociationsAgentsWindowDefault(options) {
+    return editorsAssociationsAgentsWindowDefault(options);
+}
 const configurationRegistry = ( Registry.as(Extensions.Configuration));
 const editorAssociationsConfigurationNode = {
     ...workbenchConfigurationNodeBase,
     properties: {
         [markdownDefaultEditorAgentsWindowSettingId]: {
             type: "boolean",
-            default: false,
+            default: true,
             tags: ["experimental"],
             experiment: {
                 mode: "startup"
             },
             markdownDescription: ( localize(
-                17537,
+                19303,
                 "Controls whether the Markdown editor is used as the default editor for Markdown files in the Agents window."
             ))
         },
         [editorsAssociationsSettingId]: {
             type: "object",
             markdownDescription: ( localize(
-                17538,
+                19304,
                 "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."
             )),
             additionalProperties: {
@@ -48,11 +52,28 @@ const editorAssociationsConfigurationNode = {
         [diffEditorsAssociationsSettingId]: {
             type: "object",
             markdownDescription: ( localize(
-                17539,
+                19305,
                 "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors for diff views (for example `\"*.md\": \"vscode.markdown.preview.editor\"`). These override `workbench.editorAssociations` for diffs."
             )),
             additionalProperties: {
                 type: "string"
+            },
+            agentsWindow: {
+                default: diffEditorsAssociationsAgentsWindowDefault()
+            }
+        },
+        [hiddenEditorTypesSettingId]: {
+            type: "array",
+            default: [],
+            items: {
+                type: "string"
+            },
+            markdownDescription: ( localize(
+                19306,
+                "Configure editor types that are hidden from the editor type picker. The active editor type remains visible."
+            )),
+            agentsWindow: {
+                default: ["vscode.markdown.preview.editor"]
             }
         }
     }
@@ -64,15 +85,88 @@ var RegisteredEditorPriority;
     RegisteredEditorPriority["option"] = "option";
     RegisteredEditorPriority["exclusive"] = "exclusive";
     RegisteredEditorPriority["default"] = "default";
+    RegisteredEditorPriority["explicit"] = "explicit";
 })(RegisteredEditorPriority || (RegisteredEditorPriority = {}));
 var ResolvedStatus;
 (function(ResolvedStatus) {
     ResolvedStatus[ResolvedStatus["ABORT"] = 1] = "ABORT";
     ResolvedStatus[ResolvedStatus["NONE"] = 2] = "NONE";
 })(ResolvedStatus || (ResolvedStatus = {}));
+var EditorMatchRuleSource;
+(function(EditorMatchRuleSource) {
+    EditorMatchRuleSource[EditorMatchRuleSource["UserAssociation"] = 0] = "UserAssociation";
+    EditorMatchRuleSource[EditorMatchRuleSource["EditorRegistration"] = 1] = "EditorRegistration";
+    EditorMatchRuleSource[EditorMatchRuleSource["Fallback"] = 2] = "Fallback";
+})(EditorMatchRuleSource || (EditorMatchRuleSource = {}));
+function isUnconfiguredUniversalOptionalEditorMatch(rule) {
+    return rule.source === EditorMatchRuleSource.EditorRegistration && rule.globPattern === "*" && rule.priority === RegisteredEditorPriority.option;
+}
+function freezeEditorMatchRule(rule) {
+    const editor = ( Object.freeze({
+        ...rule.editor,
+        priority: ( Object.freeze({
+            ...rule.editor.priority
+        }))
+    }));
+    switch (rule.source) {
+    case EditorMatchRuleSource.UserAssociation:
+        return ( Object.freeze({
+            ...rule,
+            editor,
+            association: ( Object.freeze({
+                ...rule.association
+            }))
+        }));
+    case EditorMatchRuleSource.EditorRegistration:
+        return ( Object.freeze({
+            ...rule,
+            editor,
+            globPattern: typeof rule.globPattern === "string" ? rule.globPattern : ( Object.freeze({
+                ...rule.globPattern
+            }))
+        }));
+    case EditorMatchRuleSource.Fallback:
+        return ( Object.freeze({
+            ...rule,
+            editor
+        }));
+    }
+}
+class EditorMatches {
+    constructor(matches, defaultRuleIndex, naturalDefaultRuleIndex, conflictingDefault) {
+        if (defaultRuleIndex < 0 || defaultRuleIndex >= matches.length) {
+            throw ( new RangeError("The default editor rule must be an item in the matches array."));
+        }
+        if (naturalDefaultRuleIndex < 0 || naturalDefaultRuleIndex >= matches.length) {
+            throw ( new RangeError("The natural default editor rule must be an item in the matches array."));
+        }
+        if (( new Set(( matches.map(match => match.editor.id)))).size !== matches.length) {
+            throw ( new RangeError("Each editor must have exactly one effective match rule."));
+        }
+        if (conflictingDefault && matches[defaultRuleIndex].source !== EditorMatchRuleSource.EditorRegistration) {
+            throw ( new RangeError("Only a registered editor default can conflict with another default."));
+        }
+        if (( matches.some(
+            (match, index) => match.source === EditorMatchRuleSource.Fallback && index !== defaultRuleIndex && index !== naturalDefaultRuleIndex
+        ))) {
+            throw ( new RangeError("A fallback rule must select the effective or natural default editor."));
+        }
+        this.matches = ( Object.freeze(( matches.map(freezeEditorMatchRule))));
+        this.defaultRuleIndex = defaultRuleIndex;
+        this.defaultRule = this.matches[defaultRuleIndex];
+        this.naturalDefaultRuleIndex = naturalDefaultRuleIndex;
+        this.naturalDefaultRule = this.matches[naturalDefaultRuleIndex];
+        this.conflictingDefault = conflictingDefault;
+        this.hasExclusiveMatch = ( this.matches.some(match => match.priority === RegisteredEditorPriority.exclusive));
+    }
+}
 function toRegisteredEditorPriorityInfo(priority) {
     if (typeof priority !== "string") {
-        return priority;
+        return {
+            editor: priority.editor,
+            diff: priority.diff,
+            merge: priority.merge ?? priority.editor
+        };
     }
     return {
         editor: priority,
@@ -89,6 +183,9 @@ function priorityToRank(priority) {
     case RegisteredEditorPriority.builtin:
         return 3;
     case RegisteredEditorPriority.option:
+        return 1;
+    case RegisteredEditorPriority.explicit:
+        return 0;
     default:
         return 1;
     }
@@ -110,4 +207,4 @@ function globMatchesResource(globPattern, resource) {
     });
 }
 
-export { RegisteredEditorPriority, ResolvedStatus, diffEditorsAssociationsSettingId, editorsAssociationsAgentsWindowDefault, editorsAssociationsSettingId, globMatchesResource, markdownDefaultEditorAgentsWindowSettingId, priorityToRank, toRegisteredEditorPriorityInfo };
+export { EditorMatchRuleSource, EditorMatches, RegisteredEditorPriority, ResolvedStatus, diffEditorsAssociationsAgentsWindowDefault, diffEditorsAssociationsSettingId, editorsAssociationsAgentsWindowDefault, editorsAssociationsSettingId, globMatchesResource, hiddenEditorTypesSettingId, isUnconfiguredUniversalOptionalEditorMatch, markdownDefaultEditorAgentsWindowSettingId, priorityToRank, toRegisteredEditorPriorityInfo };

package/vscode/src/vs/workbench/services/editor/common/editorResolverService.service.d.ts

@@ -3,7 +3,7 @@ import * as glob from "../../../../base/common/glob.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
 import { IUntypedEditorInput } from "../../../common/editor.js";
-import { EditorAssociations, RegisteredEditorRegistrationInfo, RegisteredEditorOptions, EditorInputFactoryObject, ResolvedEditor, RegisteredEditorInfo } from "./editorResolverService.js";
+import { EditorAssociations, IEditorResolverServiceGetEditorMatchesOptions, EditorMatches, RegisteredEditorRegistrationInfo, RegisteredEditorOptions, EditorInputFactoryObject, ResolvedEditor, IEditorResolverServiceGetEditorsOptions, RegisteredEditorInfo, IEditorResolverServiceGetAllEditorsOptions } from "./editorResolverService.js";
 import { PreferredGroup } from "./editorService.js";
 export declare const IEditorResolverService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IEditorResolverService>;
 export interface IEditorResolverService {
@@ -15,11 +15,18 @@ export interface IEditorResolverService {
     */
     getAssociationsForResource(resource: URI): EditorAssociations;
     /**
-    * Updates the user's association to include a specific editor ID as a default for the given glob pattern
-    * @param globPattern The glob pattern (must be a string as settings don't support relative glob)
-    * @param editorID The ID of the editor to make a user default
+    * Returns an immutable snapshot of the editors matching a resource and the rule selecting its default.
     */
-    updateUserAssociations(globPattern: string, editorID: string): void;
+    getEditorMatches(resource: URI, options?: IEditorResolverServiceGetEditorMatchesOptions): EditorMatches;
+    /**
+    * Sets an editor as the default for a resource, removing a redundant association when restoring
+    * the natural default supplied by editor registrations or the Text Editor fallback.
+    * @param resource The resource whose editor default is changing.
+    * @param editorID The ID of the editor to make the default.
+    * @param forDiffEditor When `true`, the diff editor association (`workbench.diffEditorAssociations`)
+    * is updated instead of the general editor association (`workbench.editorAssociations`).
+    */
+    setDefaultEditor(resource: URI, editorID: string, forDiffEditor?: boolean): void;
     /**
     * Emitted when an editor is registered or unregistered.
     */
@@ -49,11 +56,20 @@ export interface IEditorResolverService {
     * @param resource The resource
     * @returns A list of editor ids
     */
-    getEditors(resource: URI): RegisteredEditorInfo[];
+    getEditors(resource: URI, options?: IEditorResolverServiceGetEditorsOptions): RegisteredEditorInfo[];
     /**
     * A set of all the editors that are registered to the editor resolver.
     */
-    getEditors(): RegisteredEditorInfo[];
+    getEditors(options?: IEditorResolverServiceGetAllEditorsOptions): RegisteredEditorInfo[];
+    /**
+    * Returns the id of the best editor that can render a *diff* for the resource, excluding the
+    * built-in default text editor. This intentionally includes editors that opted out of diffs via a
+    * `explicit` priority: such editors opt out for text files, but when the default text diff editor
+    * cannot render the content (e.g. it is binary) a custom diff editor is preferable to the generic
+    * "cannot display" fallback. Returns `undefined` when no such (diff-capable) editor exists.
+    * @param resource The resource being diffed
+    */
+    getBinaryDiffFallbackEditor(resource: URI): string | undefined;
     /**
     * Get a complete list of editor associations.
     */

package/vscode/src/vs/workbench/services/editor/common/editorService.d.ts

@@ -30,7 +30,7 @@ export declare const USE_MODAL_EDITOR_SETTING = "workbench.editor.useModal";
  * Possible values for the `workbench.editor.useModal` setting:
  * - `'off'`: never open editors modal (user opt-out, honored over `RequiresModal`)
  * - `'some'`: open modal only for editors that request it (e.g. `RequiresModal`)
- * - `'all'`: open all editors modal (the default in the Agents window)
+ * - `'all'`: open all editors modal
  */
 export type UseModalEditorMode = "off" | "some" | "all";
 export type PreferredGroup = IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE | MODAL_GROUP_TYPE;

package/vscode/src/vs/workbench/services/editor/common/editorService.service.d.ts

@@ -3,7 +3,7 @@ import { DisposableStore } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
 import { IEditor, IDiffEditor } from "../../../../editor/common/editorCommon.js";
 import { IResourceEditorInput, ITextResourceEditorInput, IEditorOptions, IResourceEditorInputIdentifier } from "../../../../platform/editor/common/editor.js";
-import { IEditorWillOpenEvent, IEditorCloseEvent, IVisibleEditorPane, EditorsOrder, IEditorIdentifier, IEditorPane, IUntitledTextResourceEditorInput, ITextResourceDiffEditorInput, IResourceDiffEditorInput, ITextDiffEditorPane, IUntypedEditorInput, GroupIdentifier, IFindEditorOptions, IRevertOptions } from "../../../common/editor.js";
+import { IEditorWillOpenEvent, IEditorCloseEvent, IVisibleEditorPane, EditorsOrder, IEditorIdentifier, IEditorPane, IUntitledTextResourceEditorInput, ITextResourceDiffEditorInput, IResourceDiffEditorInput, ITextDiffEditorPane, IUntypedEditorInput, EditorInputWithOptions, GroupIdentifier, IFindEditorOptions, IRevertOptions } from "../../../common/editor.js";
 import { EditorInput } from "../../../common/editor/editorInput.js";
 import { IEditorGroup, ICloseEditorOptions, IEditorGroupsContainer } from "./editorGroupsService.js";
 import { IVisibleEditorsChangeEvent, IEditorsChangeEvent, PreferredGroup, IOpenEditorsOptions, IUntypedEditorReplacement, ISaveEditorsOptions, ISaveEditorsResult, ISaveAllEditorsOptions, IRevertAllEditorsOptions } from "./editorService.js";
@@ -151,6 +151,7 @@ export interface IEditorService {
     * @returns the editors that opened. The array can be empty or have less elements for editors
     * that failed to open or were instructed to open as inactive.
     */
+    openEditors(editors: EditorInputWithOptions[], group?: PreferredGroup, options?: IOpenEditorsOptions): Promise<readonly IEditorPane[]>;
     openEditors(editors: IUntypedEditorInput[], group?: PreferredGroup, options?: IOpenEditorsOptions): Promise<readonly IEditorPane[]>;
     /**
     * Replaces editors in an editor group with the provided replacement.

package/vscode/src/vs/workbench/services/environment/browser/environmentService.d.ts

@@ -64,6 +64,7 @@ export declare class BrowserWorkbenchEnvironmentService implements IBrowserWorkb
     get skipWelcome(): boolean;
     get disableWorkspaceTrust(): boolean;
     get isSessionsWindow(): boolean;
+    get sessionTitle(): string | undefined;
     get profile(): string | undefined;
     get editSessionId(): string | undefined;
     private payload;

package/vscode/src/vs/workbench/services/environment/browser/environmentService.js

@@ -136,7 +136,13 @@ class BrowserWorkbenchEnvironmentService {
         if (!this.extensionHostDebugEnvironment) {
             this.extensionHostDebugEnvironment = this.resolveExtensionHostDebugEnvironment();
         }
-        return this.extensionHostDebugEnvironment.extensionEnabledProposedApi;
+        if (this.extensionHostDebugEnvironment.extensionEnabledProposedApi !== undefined) {
+            return this.extensionHostDebugEnvironment.extensionEnabledProposedApi;
+        }
+        if (this.options.enabledExtensionProposedApi !== undefined) {
+            return [...this.options.enabledExtensionProposedApi];
+        }
+        return undefined;
     }
     get debugRenderer() {
         if (!this.extensionHostDebugEnvironment) {
@@ -191,6 +197,9 @@ class BrowserWorkbenchEnvironmentService {
     get isSessionsWindow() {
         return this.payload?.get("isSessionsWindow") === "true";
     }
+    get sessionTitle() {
+        return this.payload?.get("sessionTitle");
+    }
     get profile() {
         return this.payload?.get("profile");
     }
@@ -222,7 +231,7 @@ class BrowserWorkbenchEnvironmentService {
             extensionDevelopmentLocationURI: undefined,
             extensionDevelopmentKind: undefined
         };
-        if (this.payload) {
+        if (this.payload && (!this.isBuilt || this.enableSmokeTestDriver)) {
             for (const [key, value] of this.payload) {
                 switch (key) {
                 case "extensionDevelopmentPath":
@@ -547,6 +556,12 @@ BrowserWorkbenchEnvironmentService.__decorator = ( __decorate(
     "isSessionsWindow",
     null
 ));
+BrowserWorkbenchEnvironmentService.__decorator = ( __decorate(
+    [memoize],
+    BrowserWorkbenchEnvironmentService.prototype,
+    "sessionTitle",
+    null
+));
 BrowserWorkbenchEnvironmentService.__decorator = ( __decorate([memoize], BrowserWorkbenchEnvironmentService.prototype, "profile", null));
 BrowserWorkbenchEnvironmentService.__decorator = ( __decorate(
     [memoize],

package/vscode/src/vs/workbench/services/environment/browser/environmentService.service.d.ts

@@ -11,6 +11,10 @@ export interface IBrowserWorkbenchEnvironmentService extends IWorkbenchEnvironme
     */
     readonly options?: IWorkbenchConstructionOptions;
     /**
+    * Title of the agent session that launched this workbench.
+    */
+    readonly sessionTitle?: string;
+    /**
     * Gets whether a resolver extension is expected for the environment.
     */
     readonly expectsResolverExtension: boolean;

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionGalleryAccount.d.ts

@@ -0,0 +1,27 @@
+import { Event } from "../../../../base/common/event.js";
+/** `accessToken` is only carried when the provider authenticates with a bearer. */
+export interface IExtensionGalleryAccount {
+    readonly accessToken?: string;
+}
+export declare enum ExtensionGalleryAccountStatus {
+    /** None signed in, or several with no choice made. */
+    SignedOut = "signedOut",
+    Ineligible = "ineligible",
+    Eligible = "eligible",
+    /** Could not be resolved — a transient auth failure, not a sign-out. */
+    Unknown = "unknown"
+}
+/**
+ * The authentication half of marketplace access. Implementations live in the Electron layer and
+ * are supplied through {@link IExtensionGalleryAccountService.setAccountProvider}, so the service
+ * itself never depends on authentication.
+ */
+export interface IExtensionGalleryAccountProvider {
+    readonly accountStatus: ExtensionGalleryAccountStatus;
+    readonly onDidChangeAccountStatus: Event<ExtensionGalleryAccountStatus>;
+    readonly onDidChangeAccount: Event<void>;
+    /** Never prompts. Check {@link accountStatus} for whether the account may actually be used. */
+    getAccount(): Promise<IExtensionGalleryAccount | undefined>;
+    /** Interactive. The provider owns account selection and how the session is obtained. */
+    signIn(): Promise<void>;
+}

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionGalleryAccount.service.d.ts

@@ -0,0 +1,15 @@
+import { Event } from "../../../../base/common/event.js";
+import { ExtensionGalleryAccountStatus, IExtensionGalleryAccount, IExtensionGalleryAccountProvider } from "./extensionGalleryAccount.js";
+export declare const IExtensionGalleryAccountService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtensionGalleryAccountService>;
+/** Identity and entitlement for the Private Marketplace. Knows nothing about URLs or HTTP. */
+export interface IExtensionGalleryAccountService {
+    readonly _serviceBrand: undefined;
+    readonly accountStatus: ExtensionGalleryAccountStatus;
+    readonly onDidChangeAccountStatus: Event<ExtensionGalleryAccountStatus>;
+    readonly onDidChangeAccount: Event<void>;
+    /** Never prompts. Check {@link accountStatus} for whether the account may actually be used. */
+    getAccount(): Promise<IExtensionGalleryAccount | undefined>;
+    /** Interactive sign-in for whichever provider the deployment configured. */
+    signIn(): Promise<void>;
+    setAccountProvider(provider: IExtensionGalleryAccountProvider): void;
+}

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionGalleryAccount.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const IExtensionGalleryAccountService = ( createDecorator("extensionGalleryAccountService"));
+
+export { IExtensionGalleryAccountService };

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionsIcons.js

@@ -15,13 +15,13 @@ import '../../../../platform/theme/common/colors/searchColors.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
 
 const extensionDefaultIcon = registerIcon("extension-default-icon", Codicon.extensionsLarge, ( localize(
-    17626,
+    19393,
     "Icon used for the default extension in the extensions view and editor."
 )));
 const verifiedPublisherIcon = registerIcon("extensions-verified-publisher", Codicon.verifiedFilled, ( localize(
-    17627,
+    19394,
     "Icon used for the verified extension publisher in the extensions view and editor."
 )));
-const extensionVerifiedPublisherIconColor = registerColor("extensionIcon.verifiedForeground", textLinkForeground, ( localize(17628, "The icon color for extension verified publisher.")), false);
+const extensionVerifiedPublisherIconColor = registerColor("extensionIcon.verifiedForeground", textLinkForeground, ( localize(19395, "The icon color for extension verified publisher.")), false);
 
 export { extensionDefaultIcon, extensionVerifiedPublisherIconColor, verifiedPublisherIcon };

package/vscode/src/vs/workbench/services/extensionRecommendations/common/workspaceExtensionsConfig.js

@@ -84,11 +84,11 @@ let WorkspaceExtensionsConfigService = class WorkspaceExtensionsConfigService ex
         const workspaceOrFolders = isRecommended ? await this.pickWorkspaceOrFolders(
             recommendedWorksapceFolders,
             isWorkspaceRecommended ? workspace : undefined,
-            ( localize(17629, "Remove extension recommendation from"))
+            ( localize(19396, "Remove extension recommendation from"))
         ) : await this.pickWorkspaceOrFolders(
             workspace.folders,
             workspace.configuration ? workspace : undefined,
-            ( localize(17630, "Add extension recommendation to"))
+            ( localize(19397, "Add extension recommendation to"))
         );
         for (const workspaceOrWorkspaceFolder of workspaceOrFolders) {
             if (isWorkspace(workspaceOrWorkspaceFolder)) {
@@ -124,11 +124,11 @@ let WorkspaceExtensionsConfigService = class WorkspaceExtensionsConfigService ex
         const workspaceOrFolders = isUnwanted ? await this.pickWorkspaceOrFolders(
             unWantedWorksapceFolders,
             isWorkspaceUnwanted ? workspace : undefined,
-            ( localize(17629, "Remove extension recommendation from"))
+            ( localize(19396, "Remove extension recommendation from"))
         ) : await this.pickWorkspaceOrFolders(
             workspace.folders,
             workspace.configuration ? workspace : undefined,
-            ( localize(17630, "Add extension recommendation to"))
+            ( localize(19397, "Add extension recommendation to"))
         );
         for (const workspaceOrWorkspaceFolder of workspaceOrFolders) {
             if (isWorkspace(workspaceOrWorkspaceFolder)) {
@@ -313,7 +313,7 @@ let WorkspaceExtensionsConfigService = class WorkspaceExtensionsConfigService ex
         const folderPicks = ( workspaceFolders.map(workspaceFolder => {
             return {
                 label: workspaceFolder.name,
-                description: ( localize(17631, "Workspace Folder")),
+                description: ( localize(19398, "Workspace Folder")),
                 workspaceOrFolder: workspaceFolder,
                 iconClasses: getIconClasses(
                     this.modelService,
@@ -328,7 +328,7 @@ let WorkspaceExtensionsConfigService = class WorkspaceExtensionsConfigService ex
                 type: "separator"
             });
             folderPicks.push({
-                label: ( localize(17632, "Workspace")),
+                label: ( localize(19399, "Workspace")),
                 workspaceOrFolder: workspace
             });
         }