@codingame/monaco-vscode-api 2.2.1 → 3.0.0

package/vscode/src/vs/workbench/browser/workbench.contribution.js

@@ -1,13 +1,15 @@
 import { Registry } from '../../platform/registry/common/platform.js';
 import { localizeWithPath } from '../../nls.js';
-import { Extensions as Extensions$2 } from '../../platform/configuration/common/configurationRegistry.js';
-import { isMacintosh, isWeb, isNative, isWindows, isLinux } from '../../base/common/platform.js';
-import { DynamicWorkbenchConfigurationWorkbenchContribution, workbenchConfigurationNodeBase, problemsConfigurationNodeBase, Extensions as Extensions$1 } from '../common/configuration.js';
+import { Extensions as Extensions$1 } from '../../platform/configuration/common/configurationRegistry.js';
+import { isMacintosh, isWeb, isWindows, isLinux } from '../../base/common/platform.js';
+import { ConfigurationMigrationWorkbenchContribution, DynamicWorkbenchSecurityConfiguration, workbenchConfigurationNodeBase, problemsConfigurationNodeBase, Extensions } from '../common/configuration.js';
 import { isStandalone } from '../../base/browser/browser.js';
-import { Extensions } from '../common/contributions.js';
-const registry = ( Registry.as(Extensions$2.Configuration));
+import { registerWorkbenchContribution2 } from '../common/contributions.js';
+import { defaultWindowTitle, defaultWindowTitleSeparator } from './parts/titlebar/windowTitle.js';
+const registry = ( Registry.as(Extensions$1.Configuration));
 (function registerConfiguration() {
-    ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(DynamicWorkbenchConfigurationWorkbenchContribution, 2 );
+    registerWorkbenchContribution2(ConfigurationMigrationWorkbenchContribution.ID, ConfigurationMigrationWorkbenchContribution, 4 );
+    registerWorkbenchContribution2(DynamicWorkbenchSecurityConfiguration.ID, DynamicWorkbenchSecurityConfiguration, 3 );
     registry.registerConfiguration({
         ...workbenchConfigurationNodeBase,
         'properties': {
@@ -1251,6 +1253,16 @@ const registry = ( Registry.as(Extensions$2.Configuration));
             'focusedView',
             "`${focusedView}`: the name of the view that is currently focused."
         )),
+        ( localizeWithPath(
+            'vs/workbench/browser/workbench.contribution',
+            'activeRepositoryName',
+            "`${activeRepositoryName}`: the name of the active repository (e.g. vscode)."
+        )),
+        ( localizeWithPath(
+            'vs/workbench/browser/workbench.contribution',
+            'activeRepositoryBranchName',
+            "`${activeRepositoryBranchName}`: the name of the active branch in the active repository (e.g. main)."
+        )),
         ( localizeWithPath(
             'vs/workbench/browser/workbench.contribution',
             'separator',
@@ -1269,21 +1281,12 @@ const registry = ( Registry.as(Extensions$2.Configuration));
         'properties': {
             'window.title': {
                 'type': 'string',
-                'default': (() => {
-                    if (isMacintosh && isNative) {
-                        return '${activeEditorShort}${separator}${rootName}${separator}${profileName}';
-                    }
-                    const base = '${dirty}${activeEditorShort}${separator}${rootName}${separator}${profileName}${separator}${appName}';
-                    if (isWeb) {
-                        return base + '${separator}${remoteName}';
-                    }
-                    return base;
-                })(),
+                'default': defaultWindowTitle,
                 'markdownDescription': windowTitleDescription
             },
             'window.titleSeparator': {
                 'type': 'string',
-                'default': isMacintosh ? ' \u2014 ' : ' - ',
+                'default': defaultWindowTitleSeparator,
                 'markdownDescription': ( localizeWithPath(
                     'vs/workbench/browser/workbench.contribution',
                     "window.titleSeparator",
@@ -1517,7 +1520,6 @@ const registry = ( Registry.as(Extensions$2.Configuration));
             'problems.visibility': {
                 'type': 'boolean',
                 'default': true,
-                'tags': ['experimental'],
                 'description': ( localizeWithPath(
                     'vs/workbench/browser/workbench.contribution',
                     'problems.visibility',
@@ -1629,7 +1631,7 @@ const registry = ( Registry.as(Extensions$2.Configuration));
         }
     });
 })();
-( Registry.as(Extensions$1.ConfigurationMigration))
+( Registry.as(Extensions.ConfigurationMigration))
     .registerConfigurationMigrations([{
         key: 'workbench.activityBar.visible', migrateFn: (value) => {
             const result = [];
@@ -1642,7 +1644,7 @@ const registry = ( Registry.as(Extensions$2.Configuration));
             return result;
         }
     }]);
-( Registry.as(Extensions$1.ConfigurationMigration))
+( Registry.as(Extensions.ConfigurationMigration))
     .registerConfigurationMigrations([{
         key: 'workbench.editor.doubleClickTabToToggleEditorGroupSizes', migrateFn: (value) => {
             const results = [];

package/vscode/src/vs/workbench/common/configuration.js

@@ -2,10 +2,14 @@ import { __decorate, __param } from '../../../../../external/tslib/tslib.es6.js'
 import { localizeWithPath } from '../../nls.js';
 import { Extensions as Extensions$1 } from '../../platform/configuration/common/configurationRegistry.js';
 import { Registry } from '../../platform/registry/common/platform.js';
+import { IWorkspaceContextService } from '../../platform/workspace/common/workspace.js';
+import { IConfigurationService } from '../../platform/configuration/common/configuration.js';
 import { Disposable } from '../../base/common/lifecycle.js';
 import { Emitter } from '../../base/common/event.js';
 import { IRemoteAgentService } from '../services/remote/common/remoteAgentService.js';
 import { isWindows } from '../../base/common/platform.js';
+import { equals } from '../../base/common/objects.js';
+import { DeferredPromise } from '../../base/common/async.js';
 const applicationConfigurationNodeBase = ( Object.freeze({
     'id': 'application',
     'order': 100,
@@ -62,55 +66,154 @@ class ConfigurationMigrationRegistry {
 }
 const configurationMigrationRegistry = ( new ConfigurationMigrationRegistry());
 Registry.add(Extensions.ConfigurationMigration, configurationMigrationRegistry);
-let DynamicWorkbenchConfigurationWorkbenchContribution = class DynamicWorkbenchConfigurationWorkbenchContribution extends Disposable {
-    constructor(remoteAgentService) {
+let ConfigurationMigrationWorkbenchContribution = class ConfigurationMigrationWorkbenchContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.configurationMigration'; }
+    constructor(configurationService, workspaceService) {
         super();
-        (async () => {
-            if (!isWindows) {
-                const remoteEnvironment = await remoteAgentService.getEnvironment();
-                if (remoteEnvironment?.os !== 1 ) {
-                    return;
+        this.configurationService = configurationService;
+        this.workspaceService = workspaceService;
+        this._register(this.workspaceService.onDidChangeWorkspaceFolders(async (e) => {
+            for (const folder of e.added) {
+                await this.migrateConfigurationsForFolder(folder, configurationMigrationRegistry.migrations);
+            }
+        }));
+        this.migrateConfigurations(configurationMigrationRegistry.migrations);
+        this._register(configurationMigrationRegistry.onDidRegisterConfigurationMigration(migration => this.migrateConfigurations(migration)));
+    }
+    async migrateConfigurations(migrations) {
+        await this.migrateConfigurationsForFolder(undefined, migrations);
+        for (const folder of this.workspaceService.getWorkspace().folders) {
+            await this.migrateConfigurationsForFolder(folder, migrations);
+        }
+    }
+    async migrateConfigurationsForFolder(folder, migrations) {
+        await Promise.all([( migrations.map(
+            migration => this.migrateConfigurationsForFolderAndOverride(migration, folder?.uri)
+        ))]);
+    }
+    async migrateConfigurationsForFolderAndOverride(migration, resource) {
+        const inspectData = this.configurationService.inspect(migration.key, { resource });
+        const targetPairs = this.workspaceService.getWorkbenchState() === 3  ? [
+            ['user', 2 ],
+            ['userLocal', 3 ],
+            ['userRemote', 4 ],
+            ['workspace', 5 ],
+            ['workspaceFolder', 6 ],
+        ] : [
+            ['user', 2 ],
+            ['userLocal', 3 ],
+            ['userRemote', 4 ],
+            ['workspace', 5 ],
+        ];
+        for (const [dataKey, target] of targetPairs) {
+            const inspectValue = inspectData[dataKey];
+            if (!inspectValue) {
+                continue;
+            }
+            const migrationValues = [];
+            if (inspectValue.value !== undefined) {
+                const keyValuePairs = await this.runMigration(migration, dataKey, inspectValue.value, resource, undefined);
+                for (const keyValuePair of keyValuePairs ?? []) {
+                    migrationValues.push([keyValuePair, []]);
                 }
             }
-            const registry = ( Registry.as(Extensions$1.Configuration));
-            registry.registerConfiguration({
-                ...securityConfigurationNodeBase,
-                'properties': {
-                    'security.allowedUNCHosts': {
-                        'type': 'array',
-                        'items': {
-                            'type': 'string',
-                            'pattern': '^[^\\\\]+$',
-                            'patternErrorMessage': ( localizeWithPath(
-                                'vs/workbench/common/configuration',
-                                'security.allowedUNCHosts.patternErrorMessage',
-                                'UNC host names must not contain backslashes.'
-                            ))
-                        },
-                        'default': [],
-                        'markdownDescription': ( localizeWithPath(
+            for (const { identifiers, value } of inspectValue.overrides ?? []) {
+                if (value !== undefined) {
+                    const keyValuePairs = await this.runMigration(migration, dataKey, value, resource, identifiers);
+                    for (const keyValuePair of keyValuePairs ?? []) {
+                        migrationValues.push([keyValuePair, identifiers]);
+                    }
+                }
+            }
+            if (migrationValues.length) {
+                await Promise.allSettled(( migrationValues.map(
+                    async ([[key, value], overrideIdentifiers]) => this.configurationService.updateValue(key, value.value, { resource, overrideIdentifiers }, target)
+                )));
+            }
+        }
+    }
+    async runMigration(migration, dataKey, value, resource, overrideIdentifiers) {
+        const valueAccessor = (key) => {
+            const inspectData = this.configurationService.inspect(key, { resource });
+            const inspectValue = inspectData[dataKey];
+            if (!inspectValue) {
+                return undefined;
+            }
+            if (!overrideIdentifiers) {
+                return inspectValue.value;
+            }
+            return inspectValue.overrides?.find(({ identifiers }) => equals(identifiers, overrideIdentifiers))?.value;
+        };
+        const result = await migration.migrateFn(value, valueAccessor);
+        return Array.isArray(result) ? result : [[migration.key, result]];
+    }
+};
+ConfigurationMigrationWorkbenchContribution = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IWorkspaceContextService))
+], ConfigurationMigrationWorkbenchContribution));
+let DynamicWorkbenchSecurityConfiguration = class DynamicWorkbenchSecurityConfiguration extends Disposable {
+    static { this.ID = 'workbench.contrib.dynamicWorkbenchSecurityConfiguration'; }
+    constructor(remoteAgentService) {
+        super();
+        this.remoteAgentService = remoteAgentService;
+        this._ready = ( new DeferredPromise());
+        this.ready = this._ready.p;
+        this.create();
+    }
+    async create() {
+        try {
+            await this.doCreate();
+        }
+        finally {
+            this._ready.complete();
+        }
+    }
+    async doCreate() {
+        if (!isWindows) {
+            const remoteEnvironment = await this.remoteAgentService.getEnvironment();
+            if (remoteEnvironment?.os !== 1 ) {
+                return;
+            }
+        }
+        const registry = ( Registry.as(Extensions$1.Configuration));
+        registry.registerConfiguration({
+            ...securityConfigurationNodeBase,
+            'properties': {
+                'security.allowedUNCHosts': {
+                    'type': 'array',
+                    'items': {
+                        'type': 'string',
+                        'pattern': '^[^\\\\]+$',
+                        'patternErrorMessage': ( localizeWithPath(
                             'vs/workbench/common/configuration',
-                            'security.allowedUNCHosts',
-                            'A set of UNC host names (without leading or trailing backslash, for example `192.168.0.1` or `my-server`) to allow without user confirmation. If a UNC host is being accessed that is not allowed via this setting or has not been acknowledged via user confirmation, an error will occur and the operation stopped. A restart is required when changing this setting. Find out more about this setting at https://aka.ms/vscode-windows-unc.'
-                        )),
-                        'scope': 2
+                            'security.allowedUNCHosts.patternErrorMessage',
+                            'UNC host names must not contain backslashes.'
+                        ))
                     },
-                    'security.restrictUNCAccess': {
-                        'type': 'boolean',
-                        'default': true,
-                        'markdownDescription': ( localizeWithPath(
-                            'vs/workbench/common/configuration',
-                            'security.restrictUNCAccess',
-                            'If enabled, only allows access to UNC host names that are allowed by the `#security.allowedUNCHosts#` setting or after user confirmation. Find out more about this setting at https://aka.ms/vscode-windows-unc.'
-                        )),
-                        'scope': 2
-                    }
+                    'default': [],
+                    'markdownDescription': ( localizeWithPath(
+                        'vs/workbench/common/configuration',
+                        'security.allowedUNCHosts',
+                        'A set of UNC host names (without leading or trailing backslash, for example `192.168.0.1` or `my-server`) to allow without user confirmation. If a UNC host is being accessed that is not allowed via this setting or has not been acknowledged via user confirmation, an error will occur and the operation stopped. A restart is required when changing this setting. Find out more about this setting at https://aka.ms/vscode-windows-unc.'
+                    )),
+                    'scope': 2
+                },
+                'security.restrictUNCAccess': {
+                    'type': 'boolean',
+                    'default': true,
+                    'markdownDescription': ( localizeWithPath(
+                        'vs/workbench/common/configuration',
+                        'security.restrictUNCAccess',
+                        'If enabled, only allows access to UNC host names that are allowed by the `#security.allowedUNCHosts#` setting or after user confirmation. Find out more about this setting at https://aka.ms/vscode-windows-unc.'
+                    )),
+                    'scope': 2
                 }
-            });
-        })();
+            }
+        });
     }
 };
-DynamicWorkbenchConfigurationWorkbenchContribution = ( __decorate([
+DynamicWorkbenchSecurityConfiguration = ( __decorate([
     ( __param(0, IRemoteAgentService))
-], DynamicWorkbenchConfigurationWorkbenchContribution));
-export { DynamicWorkbenchConfigurationWorkbenchContribution, Extensions, applicationConfigurationNodeBase, problemsConfigurationNodeBase, securityConfigurationNodeBase, workbenchConfigurationNodeBase };
+], DynamicWorkbenchSecurityConfiguration));
+export { ConfigurationMigrationWorkbenchContribution, DynamicWorkbenchSecurityConfiguration, Extensions, applicationConfigurationNodeBase, problemsConfigurationNodeBase, securityConfigurationNodeBase, workbenchConfigurationNodeBase };

package/vscode/src/vs/workbench/common/contextkeys.js

@@ -185,10 +185,10 @@ const InEditorZenModeContext = ( new RawContextKey('inZenMode', false, ( localiz
     'inZenMode',
     "Whether Zen mode is enabled"
 ))));
-const IsCenteredLayoutContext = ( new RawContextKey('isCenteredLayout', false, ( localizeWithPath(
+const IsMainEditorCenteredLayoutContext = ( new RawContextKey('isCenteredLayout', false, ( localizeWithPath(
     'vs/workbench/common/contextkeys',
-    'isCenteredLayout',
-    "Whether centered layout is enabled"
+    'isMainEditorCenteredLayout',
+    "Whether centered layout is enabled for the main editor"
 ))));
 const SplitEditorsVertically = ( new RawContextKey('splitEditorsVertically', false, ( localizeWithPath(
     'vs/workbench/common/contextkeys',
@@ -473,4 +473,4 @@ function applyAvailableEditorIds(contextKey, editor, editorResolverService) {
         contextKey.set(editors.join(','));
     }
 }
-export { ActiveAuxiliaryContext, ActiveCompareEditorOriginalWriteableContext, ActiveEditorAvailableEditorIdsContext, ActiveEditorCanRevertContext, ActiveEditorCanSplitInGroupContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorContext, ActiveEditorDirtyContext, ActiveEditorFirstInGroupContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorReadonlyContext, ActiveEditorStickyContext, ActivePanelContext, ActiveViewletContext, AuxiliaryBarFocusContext, AuxiliaryBarVisibleContext, BannerFocused, DirtyWorkingCopiesContext, EditorGroupEditorsCountContext, EditorPartMaximizedEditorGroupContext, EditorPartMultipleEditorGroupsContext, EditorTabsVisibleContext, EditorsVisibleContext, EmbedderIdentifierContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, FocusedViewContext, HasWebFileSystemAccess, InEditorZenModeContext, IsAuxiliaryEditorPartContext, IsAuxiliaryWindowFocusedContext, IsCenteredLayoutContext, IsMainWindowFullscreenContext, MainEditorAreaVisibleContext, MultipleEditorGroupsContext, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, OpenFolderWorkspaceSupportContext, PanelAlignmentContext, PanelFocusContext, PanelMaximizedContext, PanelPositionContext, PanelVisibleContext, RemoteNameContext, ResourceContextKey, SideBarVisibleContext, SideBySideEditorActiveContext, SidebarFocusContext, SplitEditorsVertically, StatusBarFocused, TemporaryWorkspaceContext, TextCompareEditorActiveContext, TextCompareEditorVisibleContext, TitleBarStyleContext, TitleBarVisibleContext, VirtualWorkspaceContext, WorkbenchStateContext, WorkspaceFolderCountContext, applyAvailableEditorIds, getVisbileViewContextKey };
+export { ActiveAuxiliaryContext, ActiveCompareEditorOriginalWriteableContext, ActiveEditorAvailableEditorIdsContext, ActiveEditorCanRevertContext, ActiveEditorCanSplitInGroupContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorContext, ActiveEditorDirtyContext, ActiveEditorFirstInGroupContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorReadonlyContext, ActiveEditorStickyContext, ActivePanelContext, ActiveViewletContext, AuxiliaryBarFocusContext, AuxiliaryBarVisibleContext, BannerFocused, DirtyWorkingCopiesContext, EditorGroupEditorsCountContext, EditorPartMaximizedEditorGroupContext, EditorPartMultipleEditorGroupsContext, EditorTabsVisibleContext, EditorsVisibleContext, EmbedderIdentifierContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, FocusedViewContext, HasWebFileSystemAccess, InEditorZenModeContext, IsAuxiliaryEditorPartContext, IsAuxiliaryWindowFocusedContext, IsMainEditorCenteredLayoutContext, IsMainWindowFullscreenContext, MainEditorAreaVisibleContext, MultipleEditorGroupsContext, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, OpenFolderWorkspaceSupportContext, PanelAlignmentContext, PanelFocusContext, PanelMaximizedContext, PanelPositionContext, PanelVisibleContext, RemoteNameContext, ResourceContextKey, SideBarVisibleContext, SideBySideEditorActiveContext, SidebarFocusContext, SplitEditorsVertically, StatusBarFocused, TemporaryWorkspaceContext, TextCompareEditorActiveContext, TextCompareEditorVisibleContext, TitleBarStyleContext, TitleBarVisibleContext, VirtualWorkspaceContext, WorkbenchStateContext, WorkspaceFolderCountContext, applyAvailableEditorIds, getVisbileViewContextKey };

package/vscode/src/vs/workbench/common/contributions.js

@@ -5,37 +5,128 @@ import { DeferredPromise, runWhenGlobalIdle } from '../../base/common/async.js';
 import { mark } from '../../base/common/performance.js';
 import { ILogService } from '../../platform/log/common/log.js';
 import { IEnvironmentService } from '../../platform/environment/common/environment.js';
+import { getOrSet } from '../../base/common/map.js';
+import { Disposable } from '../../base/common/lifecycle.js';
+import { IEditorPaneService } from '../services/editor/common/editorPaneService.js';
 var Extensions;
 ( (function(Extensions) {
     Extensions.Workbench = 'workbench.contributions.kind';
 })(Extensions || (Extensions = {})));
-class WorkbenchContributionsRegistry {
+function isOnEditorWorkbenchContributionInstantiation(obj) {
+    const candidate = obj;
+    return !!candidate && typeof candidate.editorTypeId === 'string';
+}
+function toWorkbenchPhase(phase) {
+    switch (phase) {
+        case 3 :
+            return 3 ;
+        case 4 :
+            return 4 ;
+    }
+}
+function toLifecyclePhase(instantiation) {
+    switch (instantiation) {
+        case 1 :
+            return 1 ;
+        case 2 :
+            return 2 ;
+        case 3 :
+            return 3 ;
+        case 4 :
+            return 4 ;
+    }
+}
+class WorkbenchContributionsRegistry extends Disposable {
     constructor() {
-        this.contributions = ( new Map());
+        super(...arguments);
+        this.contributionsByPhase = ( new Map());
+        this.contributionsByEditor = ( new Map());
+        this.contributionsById = ( new Map());
+        this.instancesById = ( new Map());
+        this.timingsByPhase = ( new Map());
         this.pendingRestoredContributions = ( new DeferredPromise());
         this.whenRestored = this.pendingRestoredContributions.p;
     }
-    registerWorkbenchContribution(contribution, phase = 1 ) {
-        if (this.instantiationService && this.lifecycleService && this.logService && this.environmentService && this.lifecycleService.phase >= phase) {
-            this.safeCreateContribution(this.instantiationService, this.logService, this.environmentService, contribution, phase);
+    static { this.INSTANCE = ( new WorkbenchContributionsRegistry()); }
+    static { this.BLOCK_BEFORE_RESTORE_WARN_THRESHOLD = 20; }
+    static { this.BLOCK_AFTER_RESTORE_WARN_THRESHOLD = 100; }
+    get timings() { return this.timingsByPhase; }
+    registerWorkbenchContribution2(id, ctor, instantiation) {
+        const contribution = { id, ctor };
+        if (this.instantiationService && this.lifecycleService && this.logService && this.environmentService && this.editorPaneService &&
+            ((typeof instantiation === 'number' && this.lifecycleService.phase >= instantiation) ||
+                (typeof id === 'string' && isOnEditorWorkbenchContributionInstantiation(instantiation) && this.editorPaneService.didInstantiateEditorPane(instantiation.editorTypeId)))) {
+            this.safeCreateContribution(this.instantiationService, this.logService, this.environmentService, contribution, typeof instantiation === 'number' ? toLifecyclePhase(instantiation) : this.lifecycleService.phase);
         }
         else {
-            let contributions = this.contributions.get(phase);
-            if (!contributions) {
-                contributions = [];
-                this.contributions.set(phase, contributions);
+            if (typeof instantiation === 'number') {
+                getOrSet(this.contributionsByPhase, toLifecyclePhase(instantiation), []).push(contribution);
+            }
+            if (typeof id === 'string') {
+                if (!( this.contributionsById.has(id))) {
+                    this.contributionsById.set(id, contribution);
+                }
+                else {
+                    console.error(`IWorkbenchContributionsRegistry#registerWorkbenchContribution(): Can't register multiple contributions with same id '${id}'`);
+                }
+                if (isOnEditorWorkbenchContributionInstantiation(instantiation)) {
+                    getOrSet(this.contributionsByEditor, instantiation.editorTypeId, []).push(contribution);
+                }
             }
-            contributions.push(contribution);
         }
     }
+    registerWorkbenchContribution(ctor, phase) {
+        this.registerWorkbenchContribution2(undefined, ctor, toWorkbenchPhase(phase));
+    }
+    getWorkbenchContribution(id) {
+        if (( this.instancesById.has(id))) {
+            return this.instancesById.get(id);
+        }
+        const instantiationService = this.instantiationService;
+        const lifecycleService = this.lifecycleService;
+        const logService = this.logService;
+        const environmentService = this.environmentService;
+        if (!instantiationService || !lifecycleService || !logService || !environmentService) {
+            throw new Error(`IWorkbenchContributionsRegistry#getContribution('${id}'): cannot be called before registry started`);
+        }
+        const contribution = this.contributionsById.get(id);
+        if (!contribution) {
+            throw new Error(`IWorkbenchContributionsRegistry#getContribution('${id}'): contribution with that identifier is unknown.`);
+        }
+        if (lifecycleService.phase < 3 ) {
+            logService.warn(`IWorkbenchContributionsRegistry#getContribution('${id}'): contribution instantiated before LifecyclePhase.Restored!`);
+        }
+        this.safeCreateContribution(instantiationService, logService, environmentService, contribution, lifecycleService.phase);
+        const instance = this.instancesById.get(id);
+        if (!instance) {
+            throw new Error(`IWorkbenchContributionsRegistry#getContribution('${id}'): failed to create contribution.`);
+        }
+        return instance;
+    }
     start(accessor) {
         const instantiationService = this.instantiationService = accessor.get(IInstantiationService);
         const lifecycleService = this.lifecycleService = accessor.get(ILifecycleService);
         const logService = this.logService = accessor.get(ILogService);
         const environmentService = this.environmentService = accessor.get(IEnvironmentService);
+        const editorPaneService = this.editorPaneService = accessor.get(IEditorPaneService);
         for (const phase of [1 , 2 , 3 , 4 ]) {
             this.instantiateByPhase(instantiationService, lifecycleService, logService, environmentService, phase);
         }
+        for (const editorTypeId of ( this.contributionsByEditor.keys())) {
+            if (editorPaneService.didInstantiateEditorPane(editorTypeId)) {
+                this.onEditor(editorTypeId, instantiationService, lifecycleService, logService, environmentService);
+            }
+        }
+        this._register(editorPaneService.onWillInstantiateEditorPane(e => this.onEditor(e.typeId, instantiationService, lifecycleService, logService, environmentService)));
+    }
+    onEditor(editorTypeId, instantiationService, lifecycleService, logService, environmentService) {
+        const contributions = this.contributionsByEditor.get(editorTypeId);
+        if (contributions) {
+            this.contributionsByEditor.delete(editorTypeId);
+            for (const contribution of contributions) {
+                this.safeCreateContribution(instantiationService, logService, environmentService, contribution, lifecycleService.phase);
+            }
+        }
     }
     instantiateByPhase(instantiationService, lifecycleService, logService, environmentService, phase) {
         if (lifecycleService.phase >= phase) {
@@ -46,9 +137,9 @@ class WorkbenchContributionsRegistry {
         }
     }
     async doInstantiateByPhase(instantiationService, logService, environmentService, phase) {
-        const contributions = this.contributions.get(phase);
+        const contributions = this.contributionsByPhase.get(phase);
         if (contributions) {
-            this.contributions.delete(phase);
+            this.contributionsByPhase.delete(phase);
             switch (phase) {
                 case 1 :
                 case 2 : {
@@ -93,20 +184,45 @@ class WorkbenchContributionsRegistry {
         runWhenGlobalIdle(instantiateSome, forcedTimeout);
     }
     safeCreateContribution(instantiationService, logService, environmentService, contribution, phase) {
-        const now = phase < 3  ? Date.now() : undefined;
+        if (typeof contribution.id === 'string' && ( this.instancesById.has(contribution.id))) {
+            return;
+        }
+        const now = Date.now();
         try {
-            instantiationService.createInstance(contribution);
+            if (typeof contribution.id === 'string') {
+                mark(`code/willCreateWorkbenchContribution/${phase}/${contribution.id}`);
+            }
+            const instance = instantiationService.createInstance(contribution.ctor);
+            if (typeof contribution.id === 'string') {
+                this.instancesById.set(contribution.id, instance);
+                this.contributionsById.delete(contribution.id);
+            }
         }
         catch (error) {
-            logService.error(`Unable to create workbench contribution ${contribution.name}.`, error);
+            logService.error(`Unable to create workbench contribution '${contribution.id ?? contribution.ctor.name}'.`, error);
         }
-        if (typeof now === 'number' && !environmentService.isBuilt ) {
+        finally {
+            if (typeof contribution.id === 'string') {
+                mark(`code/didCreateWorkbenchContribution/${phase}/${contribution.id}`);
+            }
+        }
+        if (typeof contribution.id === 'string' || !environmentService.isBuilt ) {
             const time = Date.now() - now;
-            if (time > 20) {
-                logService.warn(`Workbench contribution ${contribution.name} blocked restore phase by ${time}ms.`);
+            if (time > (phase < 3  ? WorkbenchContributionsRegistry.BLOCK_BEFORE_RESTORE_WARN_THRESHOLD : WorkbenchContributionsRegistry.BLOCK_AFTER_RESTORE_WARN_THRESHOLD)) {
+                logService.warn(`Creation of workbench contribution '${contribution.id ?? contribution.ctor.name}' took ${time}ms.`);
+            }
+            if (typeof contribution.id === 'string') {
+                let timingsForPhase = this.timingsByPhase.get(phase);
+                if (!timingsForPhase) {
+                    timingsForPhase = [];
+                    this.timingsByPhase.set(phase, timingsForPhase);
+                }
+                timingsForPhase.push([contribution.id, time]);
             }
         }
     }
 }
-Registry.add(Extensions.Workbench, ( new WorkbenchContributionsRegistry()));
-export { Extensions };
+const registerWorkbenchContribution2 = WorkbenchContributionsRegistry.INSTANCE.registerWorkbenchContribution2.bind(WorkbenchContributionsRegistry.INSTANCE);
+const getWorkbenchContribution = WorkbenchContributionsRegistry.INSTANCE.getWorkbenchContribution.bind(WorkbenchContributionsRegistry.INSTANCE);
+Registry.add(Extensions.Workbench, WorkbenchContributionsRegistry.INSTANCE);
+export { Extensions, WorkbenchContributionsRegistry, getWorkbenchContribution, registerWorkbenchContribution2 };

package/vscode/src/vs/workbench/common/editor/diffEditorInput.js

@@ -116,8 +116,8 @@ let DiffEditorInput = class DiffEditorInput extends SideBySideEditorInput {
                 return this.labels.mediumTitle;
         }
     }
-    async resolve(options) {
-        const resolvedModel = await this.createModel(options);
+    async resolve() {
+        const resolvedModel = await this.createModel();
         this.cachedModel?.dispose();
         this.cachedModel = resolvedModel;
         return this.cachedModel;
@@ -128,10 +128,10 @@ let DiffEditorInput = class DiffEditorInput extends SideBySideEditorInput {
         }
         return editorPanes.find(editorPane => editorPane.typeId === TEXT_DIFF_EDITOR_ID);
     }
-    async createModel(options) {
+    async createModel() {
         const [originalEditorModel, modifiedEditorModel] = await Promise.all([
-            this.original.resolve(options),
-            this.modified.resolve(options)
+            this.original.resolve(),
+            this.modified.resolve()
         ]);
         if (modifiedEditorModel instanceof BaseTextEditorModel && originalEditorModel instanceof BaseTextEditorModel) {
             return ( new TextDiffEditorModel(originalEditorModel, modifiedEditorModel));

package/vscode/src/vs/workbench/common/editor/editorGroupModel.js

@@ -609,7 +609,7 @@ let EditorGroupModel = class EditorGroupModel extends Disposable {
             let canSerializeEditor = false;
             const editorSerializer = registry.getEditorSerializer(editor);
             if (editorSerializer) {
-                const value = editorSerializer.serialize(editor);
+                const value = editorSerializer.canSerialize(editor) ? editorSerializer.serialize(editor) : undefined;
                 if (typeof value === 'string') {
                     canSerializeEditor = true;
                     serializedEditors.push({ id: editor.typeId, value });

package/vscode/src/vs/workbench/common/editor/editorInput.d.ts

@@ -1,6 +1,5 @@
 import { Emitter, Event } from '../../../base/common/event.js';
 import { URI } from '../../../base/common/uri.js';
-import { IEditorOptions } from '../../../platform/editor/common/editor.js';
 import { IEditorIdentifier, AbstractEditorInput, EditorInputCapabilities, Verbosity, GroupIdentifier, ISaveOptions, IUntypedEditorInput, IRevertOptions, IMoveResult, IEditorDescriptor, IEditorPane } from '../editor.js';
 import { ConfirmResult } from '../../../platform/dialogs/common/dialogs.js';
 import { IMarkdownString } from '../../../base/common/htmlContent.js';
@@ -29,6 +28,20 @@ interface IEditorCloseHandler {
      */
     confirm(editors: ReadonlyArray<IEditorIdentifier>): Promise<ConfirmResult>;
 }
+interface IUntypedEditorOptions {
+    /**
+     * Implementations should try to preserve as much
+     * view state as possible from the typed input based
+     * on the group the editor is opened.
+     */
+    readonly preserveViewState?: GroupIdentifier;
+    /**
+     * Implementations should preserve the original
+     * resource of the typed input and not alter
+     * it.
+     */
+    readonly preserveResource?: boolean;
+}
 /**
  * Editor inputs are lightweight objects that can be passed to the workbench API to open inside the editor part.
  * Each editor input is mapped to an editor that is capable of opening it through the Platform facade.
@@ -149,7 +162,7 @@ declare abstract class EditorInput extends AbstractEditorInput {
      * The `options` parameter are passed down from the editor when the
      * input is resolved as part of it.
      */
-    resolve(options?: IEditorOptions): Promise<IDisposable | null>;
+    resolve(): Promise<IDisposable | null>;
     /**
      * Saves the editor. The provided groupId helps implementors
      * to e.g. preserve view state of the editor and re-open it
@@ -205,15 +218,8 @@ declare abstract class EditorInput extends AbstractEditorInput {
      * editor input into a form that it can be restored.
      *
      * May return `undefined` if an untyped representation is not supported.
-     *
-     * @param options additional configuration for the expected return type.
-     * When `preserveViewState` is provided, implementations should try to
-     * preserve as much view state as possible from the typed input based on
-     * the group the editor is opened.
      */
-    toUntyped(options?: {
-        preserveViewState: GroupIdentifier;
-    }): IUntypedEditorInput | undefined;
+    toUntyped(options?: IUntypedEditorOptions): IUntypedEditorInput | undefined;
     /**
      * Returns if this editor is disposed.
      */
@@ -221,4 +227,4 @@ declare abstract class EditorInput extends AbstractEditorInput {
     dispose(): void;
 }
 
-export { EditorInput, type IEditorCloseHandler };
+export { EditorInput, type IEditorCloseHandler, type IUntypedEditorOptions };

package/vscode/src/vs/workbench/common/editor/editorInput.js

@@ -59,7 +59,7 @@ class EditorInput extends AbstractEditorInput {
     isSaving() {
         return false;
     }
-    async resolve(options) {
+    async resolve() {
         return null;
     }
     async save(group, options) {