@codingame/monaco-vscode-api 3.2.3 → 4.1.0

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

@@ -0,0 +1,1197 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { Extensions as Extensions$2 } from '../../../common/contributions.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { registerAction2, MenuRegistry, MenuId, Action2 } from '../../../../platform/actions/common/actions.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
+import { EDIT_SESSIONS_SHOW_VIEW, EDIT_SESSIONS_PENDING, EDIT_SESSIONS_CONTAINER_ID, EDIT_SESSIONS_TITLE, EDIT_SESSIONS_VIEW_ICON, EditSessionSchemaVersion, hashedEditSessionId, ChangeType, decodeEditSessionFileContent, EDIT_SESSION_SYNC_CATEGORY, FileType, editSessionsLogId, EDIT_SESSIONS_DATA_VIEW_ID, IEditSessionsStorageService, IEditSessionsLogService } from '../common/editSessions.js';
+import { ISCMService } from '../../scm/common/scm.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { URI } from '../../../../base/common/uri.js';
+import { basename, joinPath, relativePath } from '../../../../base/common/resources.js';
+import { encodeBase64 } from '../../../../base/common/buffer.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import './editSessionsStorageService.js';
+import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
+import { UserDataSyncStoreError } from '../../../../platform/userDataSync/common/userDataSync.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { Severity, INotificationService } from '../../../../platform/notification/common/notification.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IProductService } from '../../../../platform/product/common/productService.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { IEnvironmentService } from '../../../../platform/environment/common/environment.js';
+import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
+import { Extensions as Extensions$1 } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+import { ContextKeyExpr, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { getVirtualWorkspaceLocation } from '../../../../platform/workspace/common/virtualWorkspace.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { IsWebContext } from '../../../../platform/contextkey/common/contextkeys.js';
+import { isProposedApiEnabled, IExtensionService } from '../../../services/extensions/common/extensions.js';
+import '../common/editSessionsLogService.js';
+import { Extensions } from '../../../common/views.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
+import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { EditSessionsDataViews } from './editSessionsViews.js';
+import { EditSessionsFileSystemProvider } from './editSessionsFileSystemProvider.js';
+import { isWeb, isNative } from '../../../../base/common/platform.js';
+import { VirtualWorkspaceContext, WorkspaceFolderCountContext } from '../../../common/contextkeys.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { equals } from '../../../../base/common/objects.js';
+import { EditSessionIdentityMatch, IEditSessionIdentityService } from '../../../../platform/workspace/common/editSessions.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { IOutputService } from '../../../services/output/common/output.js';
+import { sha1Hex } from '../../../../base/browser/hash.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { NumberBadge, IActivityService } from '../../../services/activity/common/activity.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { CancellationError } from '../../../../base/common/errors.js';
+import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
+import { VIEWLET_ID } from '../../extensions/common/extensions.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+import { WorkspaceStateSynchroniser } from '../common/workspaceStateSync.js';
+import { IUserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfile.js';
+import { IRequestService } from '../../../../platform/request/common/request.js';
+import { EditSessionsStoreClient } from '../common/editSessionsStorageClient.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { IWorkspaceIdentityService } from '../../../services/workspaces/common/workspaceIdentityService.js';
+import { getFileNamesMessage, IDialogService, IFileDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var EditSessionsContribution_1;
+const continueWorkingOnCommand = {
+    id: '_workbench.editSessions.actions.continueEditSession',
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+        'continue working on',
+        'Continue Working On...'
+    )),
+    precondition: ( WorkspaceFolderCountContext.notEqualsTo('0')),
+    f1: true
+};
+const openLocalFolderCommand = {
+    id: '_workbench.editSessions.actions.continueEditSession.openLocalFolder',
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+        'continue edit session in local folder',
+        'Open In Local Folder'
+    )),
+    category: EDIT_SESSION_SYNC_CATEGORY,
+    precondition: ( ContextKeyExpr.and(( IsWebContext.toNegated()), VirtualWorkspaceContext))
+};
+const showOutputChannelCommand = {
+    id: 'workbench.editSessions.actions.showOutputChannel',
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+        'show log',
+        "Show Log"
+    )),
+    category: EDIT_SESSION_SYNC_CATEGORY
+};
+const installAdditionalContinueOnOptionsCommand = {
+    id: 'workbench.action.continueOn.extensions',
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+        'continueOn.installAdditional',
+        'Install additional development environment options'
+    )),
+};
+registerAction2(class extends Action2 {
+    constructor() {
+        super({ ...installAdditionalContinueOnOptionsCommand, f1: false });
+    }
+    async run(accessor) {
+        const paneCompositePartService = accessor.get(IPaneCompositePartService);
+        const viewlet = await paneCompositePartService.openPaneComposite(VIEWLET_ID, 0 , true);
+        const view = viewlet?.getViewPaneContainer();
+        view?.search('@tag:continueOn');
+    }
+});
+const resumeProgressOptionsTitle = `[${( localizeWithPath(
+    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+    'resuming working changes window',
+    'Resuming working changes...'
+))}](command:${showOutputChannelCommand.id})`;
+const resumeProgressOptions = {
+    location: 10 ,
+    type: 'syncing',
+};
+const queryParamName = 'editSessionId';
+const useEditSessionsWithContinueOn = 'workbench.editSessions.continueOn';
+let EditSessionsContribution = class EditSessionsContribution extends Disposable {
+    static { EditSessionsContribution_1 = this; }
+    static { this.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY = 'applicationLaunchedViaContinueOn'; }
+    constructor(editSessionsStorageService, fileService, progressService, openerService, telemetryService, scmService, notificationService, dialogService, logService, environmentService, instantiationService, productService, configurationService, contextService, editSessionIdentityService, quickInputService, commandService, contextKeyService, fileDialogService, lifecycleService, storageService, activityService, editorService, remoteAgentService, extensionService, requestService, userDataProfilesService, uriIdentityService, workspaceIdentityService) {
+        super();
+        this.editSessionsStorageService = editSessionsStorageService;
+        this.fileService = fileService;
+        this.progressService = progressService;
+        this.openerService = openerService;
+        this.telemetryService = telemetryService;
+        this.scmService = scmService;
+        this.notificationService = notificationService;
+        this.dialogService = dialogService;
+        this.logService = logService;
+        this.environmentService = environmentService;
+        this.instantiationService = instantiationService;
+        this.productService = productService;
+        this.configurationService = configurationService;
+        this.contextService = contextService;
+        this.editSessionIdentityService = editSessionIdentityService;
+        this.quickInputService = quickInputService;
+        this.commandService = commandService;
+        this.contextKeyService = contextKeyService;
+        this.fileDialogService = fileDialogService;
+        this.lifecycleService = lifecycleService;
+        this.storageService = storageService;
+        this.activityService = activityService;
+        this.editorService = editorService;
+        this.remoteAgentService = remoteAgentService;
+        this.extensionService = extensionService;
+        this.requestService = requestService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.uriIdentityService = uriIdentityService;
+        this.workspaceIdentityService = workspaceIdentityService;
+        this.continueEditSessionOptions = [];
+        this.accountsMenuBadgeDisposable = this._register(( new MutableDisposable()));
+        this.registeredCommands = ( new Set());
+        this.shouldShowViewsContext = EDIT_SESSIONS_SHOW_VIEW.bindTo(this.contextKeyService);
+        this.pendingEditSessionsContext = EDIT_SESSIONS_PENDING.bindTo(this.contextKeyService);
+        this.pendingEditSessionsContext.set(false);
+        if (!this.productService['editSessions.store']?.url) {
+            return;
+        }
+        this.editSessionsStorageClient = ( new EditSessionsStoreClient(( URI.parse(this.productService['editSessions.store'].url)), this.productService, this.requestService, this.logService, this.environmentService, this.fileService, this.storageService));
+        this.editSessionsStorageService.storeClient = this.editSessionsStorageClient;
+        this.workspaceStateSynchronizer = ( new WorkspaceStateSynchroniser(
+            this.userDataProfilesService.defaultProfile,
+            undefined,
+            this.editSessionsStorageClient,
+            this.logService,
+            this.fileService,
+            this.environmentService,
+            this.telemetryService,
+            this.configurationService,
+            this.storageService,
+            this.uriIdentityService,
+            this.workspaceIdentityService,
+            this.editSessionsStorageService
+        ));
+        this.autoResumeEditSession();
+        this.registerActions();
+        this.registerViews();
+        this.registerContributedEditSessionOptions();
+        this._register(this.fileService.registerProvider(EditSessionsFileSystemProvider.SCHEMA, ( new EditSessionsFileSystemProvider(this.editSessionsStorageService))));
+        this.lifecycleService.onWillShutdown((e) => {
+            if (e.reason !== 3  && this.editSessionsStorageService.isSignedIn && this.configurationService.getValue('workbench.experimental.cloudChanges.autoStore') === 'onShutdown' && !isWeb) {
+                e.join(this.autoStoreEditSession(), { id: 'autoStoreWorkingChanges', label: ( localizeWithPath(
+                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                    'autoStoreWorkingChanges',
+                    'Storing current working changes...'
+                )) });
+            }
+        });
+        this._register(this.editSessionsStorageService.onDidSignIn(() => this.updateAccountsMenuBadge()));
+        this._register(this.editSessionsStorageService.onDidSignOut(() => this.updateAccountsMenuBadge()));
+    }
+    async autoResumeEditSession() {
+        const shouldAutoResumeOnReload = this.configurationService.getValue('workbench.cloudChanges.autoResume') === 'onReload';
+        if (this.environmentService.editSessionId !== undefined) {
+            this.logService.info(`Resuming cloud changes, reason: found editSessionId ${this.environmentService.editSessionId} in environment service...`);
+            await this.progressService.withProgress(resumeProgressOptions, async (progress) => await this.resumeEditSession(this.environmentService.editSessionId, undefined, undefined, undefined, progress).finally(() => this.environmentService.editSessionId = undefined));
+        }
+        else if (shouldAutoResumeOnReload && this.editSessionsStorageService.isSignedIn) {
+            this.logService.info('Resuming cloud changes, reason: cloud changes enabled...');
+            await this.progressService.withProgress(resumeProgressOptions, async (progress) => await this.resumeEditSession(undefined, true, undefined, undefined, progress));
+        }
+        else if (shouldAutoResumeOnReload) {
+            const hasApplicationLaunchedFromContinueOnFlow = this.storageService.getBoolean(EditSessionsContribution_1.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY, -1 , false);
+            this.logService.info(`Prompting to enable cloud changes, has application previously launched from Continue On flow: ${hasApplicationLaunchedFromContinueOnFlow}`);
+            const handlePendingEditSessions = () => {
+                this.logService.info('Showing badge to enable cloud changes in accounts menu...');
+                this.updateAccountsMenuBadge();
+                this.pendingEditSessionsContext.set(true);
+                const disposable = this.editSessionsStorageService.onDidSignIn(async () => {
+                    disposable.dispose();
+                    this.logService.info('Showing badge to enable cloud changes in accounts menu succeeded, resuming cloud changes...');
+                    await this.progressService.withProgress(resumeProgressOptions, async (progress) => await this.resumeEditSession(undefined, true, undefined, undefined, progress));
+                    this.storageService.remove(EditSessionsContribution_1.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY, -1 );
+                    this.environmentService.continueOn = undefined;
+                });
+            };
+            if ((this.environmentService.continueOn !== undefined) &&
+                !this.editSessionsStorageService.isSignedIn &&
+                hasApplicationLaunchedFromContinueOnFlow === false) {
+                this.storageService.store(EditSessionsContribution_1.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY, true, -1 , 1 );
+                this.logService.info('Prompting to enable cloud changes...');
+                await this.editSessionsStorageService.initialize('read');
+                if (this.editSessionsStorageService.isSignedIn) {
+                    this.logService.info('Prompting to enable cloud changes succeeded, resuming cloud changes...');
+                    await this.progressService.withProgress(resumeProgressOptions, async (progress) => await this.resumeEditSession(undefined, true, undefined, undefined, progress));
+                }
+                else {
+                    handlePendingEditSessions();
+                }
+            }
+            else if (!this.editSessionsStorageService.isSignedIn &&
+                hasApplicationLaunchedFromContinueOnFlow === true) {
+                handlePendingEditSessions();
+            }
+        }
+        else {
+            this.logService.debug('Auto resuming cloud changes disabled.');
+        }
+    }
+    updateAccountsMenuBadge() {
+        if (this.editSessionsStorageService.isSignedIn) {
+            return this.accountsMenuBadgeDisposable.clear();
+        }
+        const badge = ( new NumberBadge(1, () => ( localizeWithPath(
+            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+            'check for pending cloud changes',
+            'Check for pending cloud changes'
+        ))));
+        this.accountsMenuBadgeDisposable.value = this.activityService.showAccountsActivity({ badge });
+    }
+    async autoStoreEditSession() {
+        const cancellationTokenSource = ( new CancellationTokenSource());
+        await this.progressService.withProgress({
+            location: 10 ,
+            type: 'syncing',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'store working changes',
+                'Storing working changes...'
+            ))
+        }, async () => this.storeEditSession(false, cancellationTokenSource.token), () => {
+            cancellationTokenSource.cancel();
+            cancellationTokenSource.dispose();
+        });
+    }
+    registerViews() {
+        const container = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+            id: EDIT_SESSIONS_CONTAINER_ID,
+            title: EDIT_SESSIONS_TITLE,
+            ctorDescriptor: ( new SyncDescriptor(
+                ViewPaneContainer,
+                [EDIT_SESSIONS_CONTAINER_ID, { mergeViewWithContainerWhenSingleView: true }]
+            )),
+            icon: EDIT_SESSIONS_VIEW_ICON,
+            hideIfEmpty: true
+        }, 0 , { doNotRegisterOpenCommand: true });
+        this._register(this.instantiationService.createInstance(EditSessionsDataViews, container));
+    }
+    registerActions() {
+        this.registerContinueEditSessionAction();
+        this.registerResumeLatestEditSessionAction();
+        this.registerStoreLatestEditSessionAction();
+        this.registerContinueInLocalFolderAction();
+        this.registerShowEditSessionViewAction();
+        this.registerShowEditSessionOutputChannelAction();
+    }
+    registerShowEditSessionOutputChannelAction() {
+        this._register(registerAction2(class ShowEditSessionOutput extends Action2 {
+            constructor() {
+                super(showOutputChannelCommand);
+            }
+            run(accessor, ...args) {
+                const outputChannel = accessor.get(IOutputService);
+                void outputChannel.showChannel(editSessionsLogId);
+            }
+        }));
+    }
+    registerShowEditSessionViewAction() {
+        const that = this;
+        this._register(registerAction2(class ShowEditSessionView extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.editSessions.actions.showEditSessions',
+                    title: ( localize2WithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'show cloud changes',
+                        'Show Cloud Changes'
+                    )),
+                    category: EDIT_SESSION_SYNC_CATEGORY,
+                    f1: true
+                });
+            }
+            async run(accessor) {
+                that.shouldShowViewsContext.set(true);
+                const viewsService = accessor.get(IViewsService);
+                await viewsService.openView(EDIT_SESSIONS_DATA_VIEW_ID);
+            }
+        }));
+    }
+    registerContinueEditSessionAction() {
+        const that = this;
+        this._register(registerAction2(class ContinueEditSessionAction extends Action2 {
+            constructor() {
+                super(continueWorkingOnCommand);
+            }
+            async run(accessor, workspaceUri, destination) {
+                let uri = workspaceUri;
+                if (!destination && !uri) {
+                    destination = await that.pickContinueEditSessionDestination();
+                    if (!destination) {
+                        that.telemetryService.publicLog2('continueOn.editSessions.pick.outcome', { outcome: 'noSelection' });
+                        return;
+                    }
+                }
+                const shouldStoreEditSession = await that.shouldContinueOnWithEditSession();
+                let ref;
+                if (shouldStoreEditSession) {
+                    that.telemetryService.publicLog2('continueOn.editSessions.store');
+                    const cancellationTokenSource = ( new CancellationTokenSource());
+                    try {
+                        ref = await that.progressService.withProgress({
+                            location: 15 ,
+                            cancellable: true,
+                            type: 'syncing',
+                            title: ( localizeWithPath(
+                                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                                'store your working changes',
+                                'Storing your working changes...'
+                            ))
+                        }, async () => {
+                            const ref = await that.storeEditSession(false, cancellationTokenSource.token);
+                            if (ref !== undefined) {
+                                that.telemetryService.publicLog2('continueOn.editSessions.store.outcome', { outcome: 'storeSucceeded', hashedId: hashedEditSessionId(ref) });
+                            }
+                            else {
+                                that.telemetryService.publicLog2('continueOn.editSessions.store.outcome', { outcome: 'storeSkipped' });
+                            }
+                            return ref;
+                        }, () => {
+                            cancellationTokenSource.cancel();
+                            cancellationTokenSource.dispose();
+                            that.telemetryService.publicLog2('continueOn.editSessions.store.outcome', { outcome: 'storeCancelledByUser' });
+                        });
+                    }
+                    catch (ex) {
+                        that.telemetryService.publicLog2('continueOn.editSessions.store.outcome', { outcome: 'storeFailed' });
+                        throw ex;
+                    }
+                }
+                uri = destination ? await that.resolveDestination(destination) : uri;
+                if (uri === undefined) {
+                    return;
+                }
+                if (ref !== undefined && uri !== 'noDestinationUri') {
+                    const encodedRef = encodeURIComponent(ref);
+                    uri = uri.with({
+                        query: uri.query.length > 0 ? (uri.query + `&${queryParamName}=${encodedRef}&continueOn=1`) : `${queryParamName}=${encodedRef}&continueOn=1`
+                    });
+                    that.logService.info(`Opening ${( uri.toString())}`);
+                    await that.openerService.open(uri, { openExternal: true });
+                }
+                else if (!shouldStoreEditSession && uri !== 'noDestinationUri') {
+                    that.logService.info(`Opening ${( uri.toString())}`);
+                    await that.openerService.open(uri, { openExternal: true });
+                }
+                else if (ref === undefined && shouldStoreEditSession) {
+                    that.logService.warn(`Failed to store working changes when invoking ${continueWorkingOnCommand.id}.`);
+                }
+            }
+        }));
+    }
+    registerResumeLatestEditSessionAction() {
+        const that = this;
+        this._register(registerAction2(class ResumeLatestEditSessionAction extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.editSessions.actions.resumeLatest',
+                    title: ( localize2WithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'resume latest cloud changes',
+                        'Resume Latest Changes from Cloud'
+                    )),
+                    category: EDIT_SESSION_SYNC_CATEGORY,
+                    f1: true,
+                });
+            }
+            async run(accessor, editSessionId, forceApplyUnrelatedChange) {
+                await that.progressService.withProgress({ ...resumeProgressOptions, title: resumeProgressOptionsTitle }, async () => await that.resumeEditSession(editSessionId, undefined, forceApplyUnrelatedChange));
+            }
+        }));
+        this._register(registerAction2(class ResumeLatestEditSessionAction extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.editSessions.actions.resumeFromSerializedPayload',
+                    title: ( localize2WithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'resume cloud changes',
+                        'Resume Changes from Serialized Data'
+                    )),
+                    category: 'Developer',
+                    f1: true,
+                });
+            }
+            async run(accessor, editSessionId) {
+                const data = await that.quickInputService.input({ prompt: 'Enter serialized data' });
+                if (data) {
+                    that.editSessionsStorageService.lastReadResources.set('editSessions', { content: data, ref: '' });
+                }
+                await that.progressService.withProgress({ ...resumeProgressOptions, title: resumeProgressOptionsTitle }, async () => await that.resumeEditSession(editSessionId, undefined, undefined, undefined, undefined, data));
+            }
+        }));
+    }
+    registerStoreLatestEditSessionAction() {
+        const that = this;
+        this._register(registerAction2(class StoreLatestEditSessionAction extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.editSessions.actions.storeCurrent',
+                    title: ( localize2WithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'store working changes in cloud',
+                        'Store Working Changes in Cloud'
+                    )),
+                    category: EDIT_SESSION_SYNC_CATEGORY,
+                    f1: true,
+                });
+            }
+            async run(accessor) {
+                const cancellationTokenSource = ( new CancellationTokenSource());
+                await that.progressService.withProgress({
+                    location: 15 ,
+                    title: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'storing working changes',
+                        'Storing working changes...'
+                    ))
+                }, async () => {
+                    that.telemetryService.publicLog2('editSessions.store');
+                    await that.storeEditSession(true, cancellationTokenSource.token);
+                }, () => {
+                    cancellationTokenSource.cancel();
+                    cancellationTokenSource.dispose();
+                });
+            }
+        }));
+    }
+    async resumeEditSession(ref, silent, forceApplyUnrelatedChange, applyPartialMatch, progress, serializedData) {
+        await this.remoteAgentService.getEnvironment();
+        if (this.contextService.getWorkbenchState() === 1 ) {
+            return;
+        }
+        this.logService.info(ref !== undefined ? `Resuming changes from cloud with ref ${ref}...` : 'Checking for pending cloud changes...');
+        if (silent && !(await this.editSessionsStorageService.initialize('read', true))) {
+            return;
+        }
+        this.telemetryService.publicLog2('editSessions.resume');
+        performance.mark('code/willResumeEditSessionFromIdentifier');
+        progress?.report({ message: ( localizeWithPath(
+            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+            'checkingForWorkingChanges',
+            'Checking for pending cloud changes...'
+        )) });
+        const data = serializedData ? { content: serializedData, ref: '' } : await this.editSessionsStorageService.read('editSessions', ref);
+        if (!data) {
+            if (ref === undefined && !silent) {
+                this.notificationService.info(( localizeWithPath(
+                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                    'no cloud changes',
+                    'There are no changes to resume from the cloud.'
+                )));
+            }
+            else if (ref !== undefined) {
+                this.notificationService.warn(( localizeWithPath(
+                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                    'no cloud changes for ref',
+                    'Could not resume changes from the cloud for ID {0}.',
+                    ref
+                )));
+            }
+            this.logService.info(ref !== undefined ? `Aborting resuming changes from cloud as no edit session content is available to be applied from ref ${ref}.` : `Aborting resuming edit session as no edit session content is available to be applied`);
+            return;
+        }
+        progress?.report({ message: resumeProgressOptionsTitle });
+        const editSession = JSON.parse(data.content);
+        ref = data.ref;
+        if (editSession.version > EditSessionSchemaVersion) {
+            this.notificationService.error(( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'client too old',
+                "Please upgrade to a newer version of {0} to resume your working changes from the cloud.",
+                this.productService.nameLong
+            )));
+            this.telemetryService.publicLog2('editSessions.resume.outcome', { hashedId: hashedEditSessionId(ref), outcome: 'clientUpdateNeeded' });
+            return;
+        }
+        try {
+            const { changes, conflictingChanges } = await this.generateChanges(editSession, ref, forceApplyUnrelatedChange, applyPartialMatch);
+            if (changes.length === 0) {
+                return;
+            }
+            if (conflictingChanges.length > 0) {
+                const { confirmed } = await this.dialogService.confirm({
+                    type: Severity.Warning,
+                    message: conflictingChanges.length > 1 ?
+                        ( localizeWithPath(
+                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                            'resume edit session warning many',
+                            'Resuming your working changes from the cloud will overwrite the following {0} files. Do you want to proceed?',
+                            conflictingChanges.length
+                        )) :
+                        ( localizeWithPath(
+                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                            'resume edit session warning 1',
+                            'Resuming your working changes from the cloud will overwrite {0}. Do you want to proceed?',
+                            basename(conflictingChanges[0].uri)
+                        )),
+                    detail: conflictingChanges.length > 1 ? getFileNamesMessage(( conflictingChanges.map((c) => c.uri))) : undefined
+                });
+                if (!confirmed) {
+                    return;
+                }
+            }
+            for (const { uri, type, contents } of changes) {
+                if (type === ChangeType.Addition) {
+                    await this.fileService.writeFile(uri, decodeEditSessionFileContent(editSession.version, contents));
+                }
+                else if (type === ChangeType.Deletion && (await this.fileService.exists(uri))) {
+                    await this.fileService.del(uri);
+                }
+            }
+            await this.workspaceStateSynchronizer?.apply(false, {});
+            this.logService.info(`Deleting edit session with ref ${ref} after successfully applying it to current workspace...`);
+            await this.editSessionsStorageService.delete('editSessions', ref);
+            this.logService.info(`Deleted edit session with ref ${ref}.`);
+            this.telemetryService.publicLog2('editSessions.resume.outcome', { hashedId: hashedEditSessionId(ref), outcome: 'resumeSucceeded' });
+        }
+        catch (ex) {
+            this.logService.error('Failed to resume edit session, reason: ', ( ex.toString()));
+            this.notificationService.error(( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'resume failed',
+                "Failed to resume your working changes from the cloud."
+            )));
+        }
+        performance.mark('code/didResumeEditSessionFromIdentifier');
+    }
+    async generateChanges(editSession, ref, forceApplyUnrelatedChange = false, applyPartialMatch = false) {
+        const changes = [];
+        const conflictingChanges = [];
+        const workspaceFolders = this.contextService.getWorkspace().folders;
+        const cancellationTokenSource = ( new CancellationTokenSource());
+        for (const folder of editSession.folders) {
+            let folderRoot;
+            if (folder.canonicalIdentity) {
+                for (const f of workspaceFolders) {
+                    const identity = await this.editSessionIdentityService.getEditSessionIdentifier(f, cancellationTokenSource.token);
+                    this.logService.info(`Matching identity ${identity} against edit session folder identity ${folder.canonicalIdentity}...`);
+                    if (equals(identity, folder.canonicalIdentity) || forceApplyUnrelatedChange) {
+                        folderRoot = f;
+                        break;
+                    }
+                    if (identity !== undefined) {
+                        const match = await this.editSessionIdentityService.provideEditSessionIdentityMatch(f, identity, folder.canonicalIdentity, cancellationTokenSource.token);
+                        if (match === EditSessionIdentityMatch.Complete) {
+                            folderRoot = f;
+                            break;
+                        }
+                        else if (match === EditSessionIdentityMatch.Partial &&
+                            this.configurationService.getValue('workbench.experimental.cloudChanges.partialMatches.enabled') === true) {
+                            if (!applyPartialMatch) {
+                                this.notificationService.prompt(Severity.Info, ( localizeWithPath(
+                                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                                    'editSessionPartialMatch',
+                                    'You have pending working changes in the cloud for this workspace. Would you like to resume them?'
+                                )), [{ label: ( localizeWithPath(
+                                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                                    'resume',
+                                    'Resume'
+                                )), run: () => this.resumeEditSession(ref, false, undefined, true) }]);
+                            }
+                            else {
+                                folderRoot = f;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                folderRoot = workspaceFolders.find((f) => f.name === folder.name);
+            }
+            if (!folderRoot) {
+                this.logService.info(`Skipping applying ${folder.workingChanges.length} changes from edit session with ref ${ref} as no matching workspace folder was found.`);
+                return { changes: [], conflictingChanges: [], contributedStateHandlers: [] };
+            }
+            const localChanges = ( new Set());
+            for (const repository of this.scmService.repositories) {
+                if (repository.provider.rootUri !== undefined &&
+                    this.contextService.getWorkspaceFolder(repository.provider.rootUri)?.name === folder.name) {
+                    const repositoryChanges = this.getChangedResources(repository);
+                    repositoryChanges.forEach((change) => localChanges.add(( change.toString())));
+                }
+            }
+            for (const change of folder.workingChanges) {
+                const uri = joinPath(folderRoot.uri, change.relativeFilePath);
+                changes.push({ uri, type: change.type, contents: change.contents });
+                if (await this.willChangeLocalContents(localChanges, uri, change)) {
+                    conflictingChanges.push({ uri, type: change.type, contents: change.contents });
+                }
+            }
+        }
+        return { changes, conflictingChanges };
+    }
+    async willChangeLocalContents(localChanges, uriWithIncomingChanges, incomingChange) {
+        if (!( localChanges.has(( uriWithIncomingChanges.toString())))) {
+            return false;
+        }
+        const { contents, type } = incomingChange;
+        switch (type) {
+            case (ChangeType.Addition): {
+                const [originalContents, incomingContents] = await Promise.all([sha1Hex(contents), sha1Hex(encodeBase64((await this.fileService.readFile(uriWithIncomingChanges)).value))]);
+                return originalContents !== incomingContents;
+            }
+            case (ChangeType.Deletion): {
+                return await this.fileService.exists(uriWithIncomingChanges);
+            }
+            default:
+                throw new Error('Unhandled change type.');
+        }
+    }
+    async storeEditSession(fromStoreCommand, cancellationToken) {
+        const folders = [];
+        let editSessionSize = 0;
+        let hasEdits = false;
+        await this.editorService.saveAll();
+        for (const repository of this.scmService.repositories) {
+            const trackedUris = this.getChangedResources(repository);
+            const workingChanges = [];
+            const { rootUri } = repository.provider;
+            const workspaceFolder = rootUri ? this.contextService.getWorkspaceFolder(rootUri) : undefined;
+            let name = workspaceFolder?.name;
+            for (const uri of trackedUris) {
+                const workspaceFolder = this.contextService.getWorkspaceFolder(uri);
+                if (!workspaceFolder) {
+                    this.logService.info(`Skipping working change ${( uri.toString())} as no associated workspace folder was found.`);
+                    continue;
+                }
+                await this.editSessionIdentityService.onWillCreateEditSessionIdentity(workspaceFolder, cancellationToken);
+                name = name ?? workspaceFolder.name;
+                const relativeFilePath = relativePath(workspaceFolder.uri, uri) ?? uri.path;
+                try {
+                    if (!(await this.fileService.stat(uri)).isFile) {
+                        continue;
+                    }
+                }
+                catch { }
+                hasEdits = true;
+                if (await this.fileService.exists(uri)) {
+                    const contents = encodeBase64((await this.fileService.readFile(uri)).value);
+                    editSessionSize += contents.length;
+                    if (editSessionSize > this.editSessionsStorageService.SIZE_LIMIT) {
+                        this.notificationService.error(( localizeWithPath(
+                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                            'payload too large',
+                            'Your working changes exceed the size limit and cannot be stored.'
+                        )));
+                        return undefined;
+                    }
+                    workingChanges.push({ type: ChangeType.Addition, fileType: FileType.File, contents: contents, relativeFilePath: relativeFilePath });
+                }
+                else {
+                    workingChanges.push({ type: ChangeType.Deletion, fileType: FileType.File, contents: undefined, relativeFilePath: relativeFilePath });
+                }
+            }
+            let canonicalIdentity = undefined;
+            if (workspaceFolder !== null && workspaceFolder !== undefined) {
+                canonicalIdentity = await this.editSessionIdentityService.getEditSessionIdentifier(workspaceFolder, cancellationToken);
+            }
+            folders.push({ workingChanges, name: name ?? '', canonicalIdentity: canonicalIdentity ?? undefined, absoluteUri: workspaceFolder?.uri.toString() });
+        }
+        await this.workspaceStateSynchronizer?.sync(null, {});
+        if (!hasEdits) {
+            this.logService.info('Skipped storing working changes in the cloud as there are no edits to store.');
+            if (fromStoreCommand) {
+                this.notificationService.info(( localizeWithPath(
+                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                    'no working changes to store',
+                    'Skipped storing working changes in the cloud as there are no edits to store.'
+                )));
+            }
+            return undefined;
+        }
+        const data = { folders, version: 2, workspaceStateId: this.editSessionsStorageService.lastWrittenResources.get('workspaceState')?.ref };
+        try {
+            this.logService.info(`Storing edit session...`);
+            const ref = await this.editSessionsStorageService.write('editSessions', data);
+            this.logService.info(`Stored edit session with ref ${ref}.`);
+            return ref;
+        }
+        catch (ex) {
+            this.logService.error(`Failed to store edit session, reason: `, ( ex.toString()));
+            if (ex instanceof UserDataSyncStoreError) {
+                switch (ex.code) {
+                    case "TooLarge" :
+                        this.telemetryService.publicLog2('editSessions.upload.failed', { reason: 'TooLarge' });
+                        this.notificationService.error(( localizeWithPath(
+                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                            'payload too large',
+                            'Your working changes exceed the size limit and cannot be stored.'
+                        )));
+                        break;
+                    default:
+                        this.telemetryService.publicLog2('editSessions.upload.failed', { reason: 'unknown' });
+                        this.notificationService.error(( localizeWithPath(
+                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                            'payload failed',
+                            'Your working changes cannot be stored.'
+                        )));
+                        break;
+                }
+            }
+        }
+        return undefined;
+    }
+    getChangedResources(repository) {
+        return repository.provider.groups.reduce((resources, resourceGroups) => {
+            resourceGroups.resources.forEach((resource) => resources.add(resource.sourceUri));
+            return resources;
+        }, ( new Set()));
+    }
+    hasEditSession() {
+        for (const repository of this.scmService.repositories) {
+            if (this.getChangedResources(repository).size > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async shouldContinueOnWithEditSession() {
+        if (this.editSessionsStorageService.isSignedIn) {
+            return this.hasEditSession();
+        }
+        if (this.configurationService.getValue(useEditSessionsWithContinueOn) === 'off') {
+            this.telemetryService.publicLog2('continueOn.editSessions.canStore.outcome', { outcome: 'disabledEditSessionsViaSetting' });
+            return false;
+        }
+        if (this.hasEditSession()) {
+            const quickpick = this.quickInputService.createQuickPick();
+            quickpick.placeholder = ( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'continue with cloud changes',
+                "Select whether to bring your working changes with you"
+            ));
+            quickpick.ok = false;
+            quickpick.ignoreFocusOut = true;
+            const withCloudChanges = { label: ( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'with cloud changes',
+                "Yes, continue with my working changes"
+            )) };
+            const withoutCloudChanges = { label: ( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'without cloud changes',
+                "No, continue without my working changes"
+            )) };
+            quickpick.items = [withCloudChanges, withoutCloudChanges];
+            const continueWithCloudChanges = await ( new Promise((resolve, reject) => {
+                quickpick.onDidAccept(() => {
+                    resolve(quickpick.selectedItems[0] === withCloudChanges);
+                    quickpick.hide();
+                });
+                quickpick.onDidHide(() => {
+                    reject(( new CancellationError()));
+                    quickpick.hide();
+                });
+                quickpick.show();
+            }));
+            if (!continueWithCloudChanges) {
+                this.telemetryService.publicLog2('continueOn.editSessions.canStore.outcome', { outcome: 'didNotEnableEditSessionsWhenPrompted' });
+                return continueWithCloudChanges;
+            }
+            const initialized = await this.editSessionsStorageService.initialize('write');
+            if (!initialized) {
+                this.telemetryService.publicLog2('continueOn.editSessions.canStore.outcome', { outcome: 'didNotEnableEditSessionsWhenPrompted' });
+            }
+            return initialized;
+        }
+        return false;
+    }
+    registerContributedEditSessionOptions() {
+        continueEditSessionExtPoint.setHandler(extensions => {
+            const continueEditSessionOptions = [];
+            for (const extension of extensions) {
+                if (!isProposedApiEnabled(extension.description, 'contribEditSessions')) {
+                    continue;
+                }
+                if (!Array.isArray(extension.value)) {
+                    continue;
+                }
+                for (const contribution of extension.value) {
+                    const command = MenuRegistry.getCommand(contribution.command);
+                    if (!command) {
+                        return;
+                    }
+                    const icon = command.icon;
+                    const title = typeof command.title === 'string' ? command.title : command.title.value;
+                    const when = ContextKeyExpr.deserialize(contribution.when);
+                    continueEditSessionOptions.push(( new ContinueEditSessionItem(
+                        ThemeIcon.isThemeIcon(icon) ? `$(${icon.id}) ${title}` : title,
+                        command.id,
+                        command.source?.title,
+                        when,
+                        contribution.documentation
+                    )));
+                    if (contribution.qualifiedName) {
+                        this.generateStandaloneOptionCommand(command.id, contribution.qualifiedName, contribution.category ?? command.category, when, contribution.remoteGroup);
+                    }
+                }
+            }
+            this.continueEditSessionOptions = continueEditSessionOptions;
+        });
+    }
+    generateStandaloneOptionCommand(commandId, qualifiedName, category, when, remoteGroup) {
+        const command = {
+            id: `${continueWorkingOnCommand.id}.${commandId}`,
+            title: { original: qualifiedName, value: qualifiedName },
+            category: typeof category === 'string' ? { original: category, value: category } : category,
+            precondition: when,
+            f1: true
+        };
+        if (!( this.registeredCommands.has(command.id))) {
+            this.registeredCommands.add(command.id);
+            this._register(registerAction2(class StandaloneContinueOnOption extends Action2 {
+                constructor() {
+                    super(command);
+                }
+                async run(accessor) {
+                    return accessor.get(ICommandService).executeCommand(continueWorkingOnCommand.id, undefined, commandId);
+                }
+            }));
+            if (remoteGroup !== undefined) {
+                MenuRegistry.appendMenuItem(MenuId.StatusBarRemoteIndicatorMenu, {
+                    group: remoteGroup,
+                    command: command,
+                    when: command.precondition
+                });
+            }
+        }
+    }
+    registerContinueInLocalFolderAction() {
+        const that = this;
+        this._register(registerAction2(class ContinueInLocalFolderAction extends Action2 {
+            constructor() {
+                super(openLocalFolderCommand);
+            }
+            async run(accessor) {
+                const selection = await that.fileDialogService.showOpenDialog({
+                    title: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'continueEditSession.openLocalFolder.title.v2',
+                        'Select a local folder to continue working in'
+                    )),
+                    canSelectFolders: true,
+                    canSelectMany: false,
+                    canSelectFiles: false,
+                    availableFileSystems: [Schemas.file]
+                });
+                return selection?.length !== 1 ? undefined : ( URI.from({
+                    scheme: that.productService.urlProtocol,
+                    authority: Schemas.file,
+                    path: selection[0].path
+                }));
+            }
+        }));
+        if (getVirtualWorkspaceLocation(this.contextService.getWorkspace()) !== undefined && isNative) {
+            this.generateStandaloneOptionCommand(openLocalFolderCommand.id, ( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'continueWorkingOn.existingLocalFolder',
+                'Continue Working in Existing Local Folder'
+            )), undefined, openLocalFolderCommand.precondition, undefined);
+        }
+    }
+    async pickContinueEditSessionDestination() {
+        const quickPick = this.quickInputService.createQuickPick();
+        const workspaceContext = this.contextService.getWorkbenchState() === 2
+            ? this.contextService.getWorkspace().folders[0].name
+            : ( this.contextService.getWorkspace().folders.map((folder) => folder.name)).join(', ');
+        quickPick.placeholder = ( localizeWithPath(
+            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+            'continueEditSessionPick.title.v2',
+            "Select a development environment to continue working on {0} in",
+            `'${workspaceContext}'`
+        ));
+        quickPick.items = this.createPickItems();
+        this.extensionService.onDidChangeExtensions(() => {
+            quickPick.items = this.createPickItems();
+        });
+        const command = await ( new Promise((resolve, reject) => {
+            quickPick.onDidHide(() => resolve(undefined));
+            quickPick.onDidAccept((e) => {
+                const selection = quickPick.activeItems[0].command;
+                if (selection === installAdditionalContinueOnOptionsCommand.id) {
+                    void this.commandService.executeCommand(installAdditionalContinueOnOptionsCommand.id);
+                }
+                else {
+                    resolve(selection);
+                    quickPick.hide();
+                }
+            });
+            quickPick.show();
+            quickPick.onDidTriggerItemButton(async (e) => {
+                if (e.item.documentation !== undefined) {
+                    const uri = URI.isUri(e.item.documentation) ? ( URI.parse(e.item.documentation)) : await this.commandService.executeCommand(e.item.documentation);
+                    void this.openerService.open(uri, { openExternal: true });
+                }
+            });
+        }));
+        quickPick.dispose();
+        return command;
+    }
+    async resolveDestination(command) {
+        try {
+            const uri = await this.commandService.executeCommand(command);
+            if (uri === undefined) {
+                this.telemetryService.publicLog2('continueOn.openDestination.outcome', { selection: command, outcome: 'noDestinationUri' });
+                return 'noDestinationUri';
+            }
+            if (URI.isUri(uri)) {
+                this.telemetryService.publicLog2('continueOn.openDestination.outcome', { selection: command, outcome: 'resolvedUri' });
+                return uri;
+            }
+            this.telemetryService.publicLog2('continueOn.openDestination.outcome', { selection: command, outcome: 'invalidDestination' });
+            return undefined;
+        }
+        catch (ex) {
+            if (ex instanceof CancellationError) {
+                this.telemetryService.publicLog2('continueOn.openDestination.outcome', { selection: command, outcome: 'cancelled' });
+            }
+            else {
+                this.telemetryService.publicLog2('continueOn.openDestination.outcome', { selection: command, outcome: 'unknownError' });
+            }
+            return undefined;
+        }
+    }
+    createPickItems() {
+        const items = [...this.continueEditSessionOptions].filter((option) => option.when === undefined || this.contextKeyService.contextMatchesRules(option.when));
+        if (getVirtualWorkspaceLocation(this.contextService.getWorkspace()) !== undefined && isNative) {
+            items.push(( new ContinueEditSessionItem('$(folder) ' + ( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'continueEditSessionItem.openInLocalFolder.v2',
+                'Open in Local Folder'
+            )), openLocalFolderCommand.id, ( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'continueEditSessionItem.builtin',
+                'Built-in'
+            )))));
+        }
+        const sortedItems = items.sort((item1, item2) => item1.label.localeCompare(item2.label));
+        return sortedItems.concat({ type: 'separator' }, ( new ContinueEditSessionItem(
+            installAdditionalContinueOnOptionsCommand.title,
+            installAdditionalContinueOnOptionsCommand.id
+        )));
+    }
+};
+EditSessionsContribution = EditSessionsContribution_1 = ( __decorate([
+    ( __param(0, IEditSessionsStorageService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IProgressService)),
+    ( __param(3, IOpenerService)),
+    ( __param(4, ITelemetryService)),
+    ( __param(5, ISCMService)),
+    ( __param(6, INotificationService)),
+    ( __param(7, IDialogService)),
+    ( __param(8, IEditSessionsLogService)),
+    ( __param(9, IEnvironmentService)),
+    ( __param(10, IInstantiationService)),
+    ( __param(11, IProductService)),
+    ( __param(12, IConfigurationService)),
+    ( __param(13, IWorkspaceContextService)),
+    ( __param(14, IEditSessionIdentityService)),
+    ( __param(15, IQuickInputService)),
+    ( __param(16, ICommandService)),
+    ( __param(17, IContextKeyService)),
+    ( __param(18, IFileDialogService)),
+    ( __param(19, ILifecycleService)),
+    ( __param(20, IStorageService)),
+    ( __param(21, IActivityService)),
+    ( __param(22, IEditorService)),
+    ( __param(23, IRemoteAgentService)),
+    ( __param(24, IExtensionService)),
+    ( __param(25, IRequestService)),
+    ( __param(26, IUserDataProfilesService)),
+    ( __param(27, IUriIdentityService)),
+    ( __param(28, IWorkspaceIdentityService))
+], EditSessionsContribution));
+const infoButtonClass = ThemeIcon.asClassName(Codicon.info);
+class ContinueEditSessionItem {
+    constructor(label, command, description, when, documentation) {
+        this.label = label;
+        this.command = command;
+        this.description = description;
+        this.when = when;
+        this.documentation = documentation;
+        if (documentation !== undefined) {
+            this.buttons = [{
+                    iconClass: infoButtonClass,
+                    tooltip: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'learnMoreTooltip',
+                        'Learn More'
+                    )),
+                }];
+        }
+    }
+}
+const continueEditSessionExtPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'continueEditSession',
+    jsonSchema: {
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+            'continueEditSessionExtPoint',
+            'Contributes options for continuing the current edit session in a different environment'
+        )),
+        type: 'array',
+        items: {
+            type: 'object',
+            properties: {
+                command: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'continueEditSessionExtPoint.command',
+                        'Identifier of the command to execute. The command must be declared in the \'commands\'-section and return a URI representing a different environment where the current edit session can be continued.'
+                    )),
+                    type: 'string'
+                },
+                group: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'continueEditSessionExtPoint.group',
+                        'Group into which this item belongs.'
+                    )),
+                    type: 'string'
+                },
+                qualifiedName: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'continueEditSessionExtPoint.qualifiedName',
+                        'A fully qualified name for this item which is used for display in menus.'
+                    )),
+                    type: 'string'
+                },
+                description: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'continueEditSessionExtPoint.description',
+                        "The url, or a command that returns the url, to the option's documentation page."
+                    )),
+                    type: 'string'
+                },
+                remoteGroup: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'continueEditSessionExtPoint.remoteGroup',
+                        'Group into which this item belongs in the remote indicator.'
+                    )),
+                    type: 'string'
+                },
+                when: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                        'continueEditSessionExtPoint.when',
+                        'Condition which must be true to show this item.'
+                    )),
+                    type: 'string'
+                }
+            },
+            required: ['command']
+        }
+    }
+});
+const workbenchRegistry = ( Registry.as(Extensions$2.Workbench));
+workbenchRegistry.registerWorkbenchContribution(EditSessionsContribution, 3 );
+( Registry.as(Extensions$1.Configuration)).registerConfiguration({
+    ...workbenchConfigurationNodeBase,
+    'properties': {
+        'workbench.experimental.cloudChanges.autoStore': {
+            enum: ['onShutdown', 'off'],
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                    'autoStoreWorkingChanges.onShutdown',
+                    "Automatically store current working changes in the cloud on window close."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                    'autoStoreWorkingChanges.off',
+                    "Never attempt to automatically store working changes in the cloud."
+                ))
+            ],
+            'type': 'string',
+            'tags': ['experimental', 'usesOnlineServices'],
+            'default': 'off',
+            'markdownDescription': ( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'autoStoreWorkingChangesDescription',
+                "Controls whether to automatically store available working changes in the cloud for the current workspace. This setting has no effect in the web."
+            )),
+        },
+        'workbench.cloudChanges.autoResume': {
+            enum: ['onReload', 'off'],
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                    'autoResumeWorkingChanges.onReload',
+                    "Automatically resume available working changes from the cloud on window reload."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                    'autoResumeWorkingChanges.off',
+                    "Never attempt to resume working changes from the cloud."
+                ))
+            ],
+            'type': 'string',
+            'tags': ['usesOnlineServices'],
+            'default': 'onReload',
+            'markdownDescription': ( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'autoResumeWorkingChanges',
+                "Controls whether to automatically resume available working changes stored in the cloud for the current workspace."
+            )),
+        },
+        'workbench.cloudChanges.continueOn': {
+            enum: ['prompt', 'off'],
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                    'continueOnCloudChanges.promptForAuth',
+                    'Prompt the user to sign in to store working changes in the cloud with Continue Working On.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                    'continueOnCloudChanges.off',
+                    'Do not store working changes in the cloud with Continue Working On unless the user has already turned on Cloud Changes.'
+                ))
+            ],
+            type: 'string',
+            tags: ['usesOnlineServices'],
+            default: 'prompt',
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'continueOnCloudChanges',
+                'Controls whether to prompt the user to store working changes in the cloud when using Continue Working On.'
+            ))
+        },
+        'workbench.experimental.cloudChanges.partialMatches.enabled': {
+            'type': 'boolean',
+            'tags': ['experimental', 'usesOnlineServices'],
+            'default': false,
+            'markdownDescription': ( localizeWithPath(
+                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
+                'cloudChangesPartialMatchesEnabled',
+                "Controls whether to surface cloud changes which partially match the current session."
+            ))
+        }
+    }
+});
+export { EditSessionsContribution };