@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/services/remote/common/remoteExplorerService.js

@@ -1,9 +1,20 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITunnelService } from '../../../../platform/tunnel/common/tunnel.js';
+import { TunnelModel } from './tunnelModel.js';
+import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
 const IRemoteExplorerService = ( createDecorator('remoteExplorerService'));
+const REMOTE_EXPLORER_TYPE_KEY = 'remote.explorerType';
 const TUNNEL_VIEW_ID = '~remote.forwardedPorts';
+const TUNNEL_VIEW_CONTAINER_ID = '~remote.forwardedPortsContainer';
 const PORT_AUTO_FORWARD_SETTING = 'remote.autoForwardPorts';
 const PORT_AUTO_SOURCE_SETTING = 'remote.autoForwardPortsSource';
+const PORT_AUTO_SOURCE_SETTING_PROCESS = 'process';
 const PORT_AUTO_SOURCE_SETTING_OUTPUT = 'output';
+const PORT_AUTO_SOURCE_SETTING_HYBRID = 'hybrid';
 var TunnelType;
 ( (function(TunnelType) {
     TunnelType["Candidate"] = "Candidate";
@@ -18,4 +29,181 @@ var TunnelEditId;
     TunnelEditId[TunnelEditId["Label"] = 2] = "Label";
     TunnelEditId[TunnelEditId["LocalPort"] = 3] = "LocalPort";
 })(TunnelEditId || (TunnelEditId = {})));
-export { IRemoteExplorerService, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT, TUNNEL_VIEW_ID, TunnelEditId, TunnelType };
+const getStartedWalkthrough = {
+    type: 'object',
+    required: ['id'],
+    properties: {
+        id: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/services/remote/common/remoteExplorerService',
+                'getStartedWalkthrough.id',
+                'The ID of a Get Started walkthrough to open.'
+            )),
+            type: 'string'
+        },
+    }
+};
+const remoteHelpExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'remoteHelp',
+    jsonSchema: {
+        description: ( nls.localizeWithPath(
+            'vs/workbench/services/remote/common/remoteExplorerService',
+            'RemoteHelpInformationExtPoint',
+            'Contributes help information for Remote'
+        )),
+        type: 'object',
+        properties: {
+            'getStarted': {
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.getStarted',
+                    "The url, or a command that returns the url, to your project's Getting Started page, or a walkthrough ID contributed by your project's extension"
+                )),
+                oneOf: [
+                    { type: 'string' },
+                    getStartedWalkthrough
+                ]
+            },
+            'documentation': {
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.documentation',
+                    "The url, or a command that returns the url, to your project's documentation page"
+                )),
+                type: 'string'
+            },
+            'feedback': {
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.feedback',
+                    "The url, or a command that returns the url, to your project's feedback reporter"
+                )),
+                type: 'string',
+                markdownDeprecationMessage: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.feedback.deprecated',
+                    "Use {0} instead",
+                    '`reportIssue`'
+                ))
+            },
+            'reportIssue': {
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.reportIssue',
+                    "The url, or a command that returns the url, to your project's issue reporter"
+                )),
+                type: 'string'
+            },
+            'issues': {
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/services/remote/common/remoteExplorerService',
+                    'RemoteHelpInformationExtPoint.issues',
+                    "The url, or a command that returns the url, to your project's issues list"
+                )),
+                type: 'string'
+            }
+        }
+    }
+}));
+let RemoteExplorerService = class RemoteExplorerService {
+    constructor(storageService, tunnelService, instantiationService) {
+        this.storageService = storageService;
+        this.tunnelService = tunnelService;
+        this._targetType = [];
+        this._onDidChangeTargetType = ( new Emitter());
+        this.onDidChangeTargetType = this._onDidChangeTargetType.event;
+        this._onDidChangeHelpInformation = ( new Emitter());
+        this.onDidChangeHelpInformation = this._onDidChangeHelpInformation.event;
+        this._helpInformation = [];
+        this._onDidChangeEditable = ( new Emitter());
+        this.onDidChangeEditable = this._onDidChangeEditable.event;
+        this._onEnabledPortsFeatures = ( new Emitter());
+        this.onEnabledPortsFeatures = this._onEnabledPortsFeatures.event;
+        this._portsFeaturesEnabled = false;
+        this.namedProcesses = ( new Map());
+        this._tunnelModel = instantiationService.createInstance(TunnelModel);
+        remoteHelpExtPoint.setHandler((extensions) => {
+            this._helpInformation.push(...extensions);
+            this._onDidChangeHelpInformation.fire(extensions);
+        });
+    }
+    get helpInformation() {
+        return this._helpInformation;
+    }
+    set targetType(name) {
+        const current = this._targetType.length > 0 ? this._targetType[0] : '';
+        const newName = name.length > 0 ? name[0] : '';
+        if (current !== newName) {
+            this._targetType = name;
+            this.storageService.store(REMOTE_EXPLORER_TYPE_KEY, ( this._targetType.toString()), 1 , 1 );
+            this.storageService.store(REMOTE_EXPLORER_TYPE_KEY, ( this._targetType.toString()), 0 , 0 );
+            this._onDidChangeTargetType.fire(this._targetType);
+        }
+    }
+    get targetType() {
+        return this._targetType;
+    }
+    get tunnelModel() {
+        return this._tunnelModel;
+    }
+    forward(tunnelProperties, attributes) {
+        return this.tunnelModel.forward(tunnelProperties, attributes);
+    }
+    close(remote, reason) {
+        return this.tunnelModel.close(remote.host, remote.port, reason);
+    }
+    setTunnelInformation(tunnelInformation) {
+        if (tunnelInformation?.features) {
+            this.tunnelService.setTunnelFeatures(tunnelInformation.features);
+        }
+        this.tunnelModel.addEnvironmentTunnels(tunnelInformation?.environmentTunnels);
+    }
+    setEditable(tunnelItem, editId, data) {
+        if (!data) {
+            this._editable = undefined;
+        }
+        else {
+            this._editable = { tunnelItem, data, editId };
+        }
+        this._onDidChangeEditable.fire(tunnelItem ? { tunnel: tunnelItem, editId } : undefined);
+    }
+    getEditableData(tunnelItem, editId) {
+        return (this._editable &&
+            ((!tunnelItem && (tunnelItem === this._editable.tunnelItem)) ||
+                (tunnelItem && (this._editable.tunnelItem?.remotePort === tunnelItem.remotePort) && (this._editable.tunnelItem.remoteHost === tunnelItem.remoteHost)
+                    && (this._editable.editId === editId)))) ?
+            this._editable.data : undefined;
+    }
+    setCandidateFilter(filter) {
+        if (!filter) {
+            return {
+                dispose: () => { }
+            };
+        }
+        this.tunnelModel.setCandidateFilter(filter);
+        return {
+            dispose: () => {
+                this.tunnelModel.setCandidateFilter(undefined);
+            }
+        };
+    }
+    onFoundNewCandidates(candidates) {
+        this.tunnelModel.setCandidates(candidates);
+    }
+    restore() {
+        return this.tunnelModel.restoreForwarded();
+    }
+    enablePortsFeatures() {
+        this._portsFeaturesEnabled = true;
+        this._onEnabledPortsFeatures.fire();
+    }
+    get portsFeaturesEnabled() {
+        return this._portsFeaturesEnabled;
+    }
+};
+RemoteExplorerService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, ITunnelService)),
+    ( __param(2, IInstantiationService))
+], RemoteExplorerService));
+export { IRemoteExplorerService, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_HYBRID, PORT_AUTO_SOURCE_SETTING_OUTPUT, PORT_AUTO_SOURCE_SETTING_PROCESS, REMOTE_EXPLORER_TYPE_KEY, RemoteExplorerService, TUNNEL_VIEW_CONTAINER_ID, TUNNEL_VIEW_ID, TunnelEditId, TunnelType };

package/vscode/src/vs/workbench/services/search/common/search.js

@@ -1,6 +1,6 @@
 import { mapArrayOrNot } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
-import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
+import * as Objects from 'monaco-editor/esm/vs/base/common/objects.js';
 import * as extpath from 'monaco-editor/esm/vs/base/common/extpath.js';
 import { getNLines } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
@@ -104,8 +104,8 @@ function getExcludes(configuration, includeSearchExcludes = true) {
         return fileExcludes || searchExcludes;
     }
     let allExcludes = Object.create(null);
-    allExcludes = objects.mixin(allExcludes, objects.deepClone(fileExcludes));
-    allExcludes = objects.mixin(allExcludes, objects.deepClone(searchExcludes), true);
+    allExcludes = Objects.mixin(allExcludes, Objects.deepClone(fileExcludes));
+    allExcludes = Objects.mixin(allExcludes, Objects.deepClone(searchExcludes), true);
     return allExcludes;
 }
 function pathIncludedInQuery(queryProps, fsPath) {

package/vscode/src/vs/workbench/services/terminal/common/embedderTerminalService.js

@@ -1,3 +1,77 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 const IEmbedderTerminalService = ( createDecorator('embedderTerminalService'));
-export { IEmbedderTerminalService };
+class EmbedderTerminalService {
+    constructor() {
+        this._onDidCreateTerminal = ( new Emitter());
+        this.onDidCreateTerminal = Event.buffer(this._onDidCreateTerminal.event);
+    }
+    createTerminal(options) {
+        const slc = {
+            name: options.name,
+            isFeatureTerminal: true,
+            customPtyImplementation(terminalId, cols, rows) {
+                return ( new EmbedderTerminalProcess(terminalId, options.pty));
+            },
+        };
+        this._onDidCreateTerminal.fire(slc);
+    }
+}
+class EmbedderTerminalProcess extends Disposable {
+    constructor(id, pty) {
+        super();
+        this.id = id;
+        this.shouldPersist = false;
+        this._onProcessReady = this._register(( new Emitter()));
+        this.onProcessReady = this._onProcessReady.event;
+        this._onDidChangeProperty = this._register(( new Emitter()));
+        this.onDidChangeProperty = this._onDidChangeProperty.event;
+        this._onProcessExit = this._register(( new Emitter()));
+        this.onProcessExit = this._onProcessExit.event;
+        this._pty = pty;
+        this.onProcessData = this._pty.onDidWrite;
+        if (this._pty.onDidClose) {
+            this._register(this._pty.onDidClose(e => this._onProcessExit.fire(e || undefined)));
+        }
+        if (this._pty.onDidChangeName) {
+            this._register(this._pty.onDidChangeName(e => this._onDidChangeProperty.fire({
+                type: "title" ,
+                value: e
+            })));
+        }
+    }
+    async start() {
+        this._onProcessReady.fire({ pid: -1, cwd: '', windowsPty: undefined });
+        this._pty.open();
+        return undefined;
+    }
+    shutdown() {
+        this._pty.close();
+    }
+    input() {
+    }
+    async processBinary() {
+    }
+    resize() {
+    }
+    clearBuffer() {
+    }
+    acknowledgeDataEvent() {
+    }
+    async setUnicodeVersion() {
+    }
+    async getInitialCwd() {
+        return '';
+    }
+    async getCwd() {
+        return '';
+    }
+    refreshProperty(property) {
+        throw new Error(`refreshProperty is not suppported in EmbedderTerminalProcess. property: ${property}`);
+    }
+    updateProperty(property, value) {
+        throw new Error(`updateProperty is not suppported in EmbedderTerminalProcess. property: ${property}, value: ${value}`);
+    }
+}
+export { EmbedderTerminalService, IEmbedderTerminalService };

package/vscode/src/vs/workbench/services/timer/browser/timerService.js

@@ -1,3 +1,242 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as performance$1 from 'monaco-editor/esm/vs/base/common/performance.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { IUpdateService } from '../../../../platform/update/common/update.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { Barrier, timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IWorkbenchLayoutService } from '../../layout/browser/layoutService.js';
+import { IPaneCompositePartService } from '../../panecomposite/browser/panecomposite.js';
+import { TelemetryTrustedValue } from '../../../../platform/telemetry/common/telemetryUtils.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { createBlobWorker } from 'monaco-editor/esm/vs/base/browser/defaultWorkerFactory.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { TerminalExtensions } from '../../../../platform/terminal/common/terminal.js';
 const ITimerService = ( createDecorator('timerService'));
-export { ITimerService };
+class PerfMarks {
+    constructor() {
+        this._entries = [];
+    }
+    setMarks(source, entries) {
+        this._entries.push([source, entries]);
+    }
+    getDuration(from, to) {
+        const fromEntry = this._findEntry(from);
+        if (!fromEntry) {
+            return 0;
+        }
+        const toEntry = this._findEntry(to);
+        if (!toEntry) {
+            return 0;
+        }
+        return toEntry.startTime - fromEntry.startTime;
+    }
+    _findEntry(name) {
+        for (const [, marks] of this._entries) {
+            for (let i = marks.length - 1; i >= 0; i--) {
+                if (marks[i].name === name) {
+                    return marks[i];
+                }
+            }
+        }
+    }
+    getEntries() {
+        return this._entries.slice(0);
+    }
+}
+let AbstractTimerService = class AbstractTimerService {
+    constructor(_lifecycleService, _contextService, _extensionService, _updateService, _paneCompositeService, _editorService, _accessibilityService, _telemetryService, layoutService) {
+        this._lifecycleService = _lifecycleService;
+        this._contextService = _contextService;
+        this._extensionService = _extensionService;
+        this._updateService = _updateService;
+        this._paneCompositeService = _paneCompositeService;
+        this._editorService = _editorService;
+        this._accessibilityService = _accessibilityService;
+        this._telemetryService = _telemetryService;
+        this._barrier = ( new Barrier());
+        this._marks = ( new PerfMarks());
+        this._rndValueShouldSendTelemetry = Math.random() < .05;
+        Promise.all([
+            this._extensionService.whenInstalledExtensionsRegistered(),
+            _lifecycleService.when(3 ),
+            layoutService.whenRestored,
+            Promise.all(( Array.from(( ( Registry.as(TerminalExtensions.Backend)).backends.values())).map(e => e.whenReady)))
+        ]).then(() => {
+            this.setPerformanceMarks('renderer', performance$1.getMarks());
+            return this._computeStartupMetrics();
+        }).then(metrics => {
+            this._startupMetrics = metrics;
+            this._reportStartupTimes(metrics);
+            this._barrier.open();
+        });
+        this.perfBaseline = this._barrier.wait()
+            .then(() => this._lifecycleService.when(4 ))
+            .then(() => timeout(this._startupMetrics.timers.ellapsedRequire))
+            .then(() => {
+            const jsSrc = ( (function () {
+                let tooSlow = false;
+                function fib(n) {
+                    if (tooSlow) {
+                        return 0;
+                    }
+                    if (performance.now() - t1 >= 1000) {
+                        tooSlow = true;
+                    }
+                    if (n <= 2) {
+                        return n;
+                    }
+                    return fib(n - 1) + fib(n - 2);
+                }
+                const t1 = performance.now();
+                fib(24);
+                const value = Math.round(performance.now() - t1);
+                postMessage({ value: tooSlow ? -1 : value });
+            }).toString());
+            const blob = ( new Blob([`(${jsSrc})();`], { type: 'application/javascript' }));
+            const blobUrl = URL.createObjectURL(blob);
+            const worker = createBlobWorker(blobUrl, { name: 'perfBaseline' });
+            return ( new Promise(resolve => {
+                worker.onmessage = e => resolve(e.data.value);
+            })).finally(() => {
+                worker.terminate();
+                URL.revokeObjectURL(blobUrl);
+            });
+        });
+    }
+    whenReady() {
+        return this._barrier.wait();
+    }
+    get startupMetrics() {
+        if (!this._startupMetrics) {
+            throw new Error('illegal state, MUST NOT access startupMetrics before whenReady has resolved');
+        }
+        return this._startupMetrics;
+    }
+    setPerformanceMarks(source, marks) {
+        const codeMarks = marks.filter(mark => mark.name.startsWith('code/'));
+        this._marks.setMarks(source, codeMarks);
+        this._reportPerformanceMarks(source, codeMarks);
+    }
+    getPerformanceMarks() {
+        return this._marks.getEntries();
+    }
+    getDuration(from, to) {
+        return this._marks.getDuration(from, to);
+    }
+    _reportStartupTimes(metrics) {
+        this._telemetryService.publicLog('startupTimeVaried', metrics);
+    }
+    _shouldReportPerfMarks() {
+        return this._rndValueShouldSendTelemetry;
+    }
+    _reportPerformanceMarks(source, marks) {
+        if (!this._shouldReportPerfMarks()) {
+            return;
+        }
+        for (const mark of marks) {
+            this._telemetryService.publicLog2('startup.timer.mark', {
+                source,
+                name: ( new TelemetryTrustedValue(mark.name)),
+                startTime: mark.startTime
+            });
+        }
+    }
+    async _computeStartupMetrics() {
+        const initialStartup = this._isInitialStartup();
+        let startMark;
+        if (isWeb) {
+            startMark = 'code/timeOrigin';
+        }
+        else {
+            startMark = initialStartup ? 'code/didStartMain' : 'code/willOpenNewWindow';
+        }
+        const activeViewlet = this._paneCompositeService.getActivePaneComposite(0 );
+        const activePanel = this._paneCompositeService.getActivePaneComposite(1 );
+        const info = {
+            version: 2,
+            ellapsed: this._marks.getDuration(startMark, 'code/didStartWorkbench'),
+            isLatestVersion: Boolean(await this._updateService.isLatestVersion()),
+            didUseCachedData: this._didUseCachedData(),
+            windowKind: this._lifecycleService.startupKind,
+            windowCount: await this._getWindowCount(),
+            viewletId: activeViewlet?.getId(),
+            editorIds: ( this._editorService.visibleEditors.map(input => input.typeId)),
+            panelId: activePanel ? activePanel.getId() : undefined,
+            timers: {
+                ellapsedAppReady: initialStartup ? this._marks.getDuration('code/didStartMain', 'code/mainAppReady') : undefined,
+                ellapsedNlsGeneration: initialStartup ? this._marks.getDuration('code/willGenerateNls', 'code/didGenerateNls') : undefined,
+                ellapsedLoadMainBundle: initialStartup ? this._marks.getDuration('code/willLoadMainBundle', 'code/didLoadMainBundle') : undefined,
+                ellapsedCrashReporter: initialStartup ? this._marks.getDuration('code/willStartCrashReporter', 'code/didStartCrashReporter') : undefined,
+                ellapsedMainServer: initialStartup ? this._marks.getDuration('code/willStartMainServer', 'code/didStartMainServer') : undefined,
+                ellapsedWindowCreate: initialStartup ? this._marks.getDuration('code/willCreateCodeWindow', 'code/didCreateCodeWindow') : undefined,
+                ellapsedWindowRestoreState: initialStartup ? this._marks.getDuration('code/willRestoreCodeWindowState', 'code/didRestoreCodeWindowState') : undefined,
+                ellapsedBrowserWindowCreate: initialStartup ? this._marks.getDuration('code/willCreateCodeBrowserWindow', 'code/didCreateCodeBrowserWindow') : undefined,
+                ellapsedWindowMaximize: initialStartup ? this._marks.getDuration('code/willMaximizeCodeWindow', 'code/didMaximizeCodeWindow') : undefined,
+                ellapsedWindowLoad: initialStartup ? this._marks.getDuration('code/mainAppReady', 'code/willOpenNewWindow') : undefined,
+                ellapsedWindowLoadToRequire: this._marks.getDuration('code/willOpenNewWindow', 'code/willLoadWorkbenchMain'),
+                ellapsedRequire: this._marks.getDuration('code/willLoadWorkbenchMain', 'code/didLoadWorkbenchMain'),
+                ellapsedWaitForWindowConfig: this._marks.getDuration('code/willWaitForWindowConfig', 'code/didWaitForWindowConfig'),
+                ellapsedStorageInit: this._marks.getDuration('code/willInitStorage', 'code/didInitStorage'),
+                ellapsedSharedProcesConnected: this._marks.getDuration('code/willConnectSharedProcess', 'code/didConnectSharedProcess'),
+                ellapsedWorkspaceServiceInit: this._marks.getDuration('code/willInitWorkspaceService', 'code/didInitWorkspaceService'),
+                ellapsedRequiredUserDataInit: this._marks.getDuration('code/willInitRequiredUserData', 'code/didInitRequiredUserData'),
+                ellapsedOtherUserDataInit: this._marks.getDuration('code/willInitOtherUserData', 'code/didInitOtherUserData'),
+                ellapsedExtensions: this._marks.getDuration('code/willLoadExtensions', 'code/didLoadExtensions'),
+                ellapsedEditorRestore: this._marks.getDuration('code/willRestoreEditors', 'code/didRestoreEditors'),
+                ellapsedViewletRestore: this._marks.getDuration('code/willRestoreViewlet', 'code/didRestoreViewlet'),
+                ellapsedPanelRestore: this._marks.getDuration('code/willRestorePanel', 'code/didRestorePanel'),
+                ellapsedWorkbench: this._marks.getDuration('code/willStartWorkbench', 'code/didStartWorkbench'),
+                ellapsedExtensionsReady: this._marks.getDuration(startMark, 'code/didLoadExtensions'),
+                ellapsedRenderer: this._marks.getDuration('code/didStartRenderer', 'code/didStartWorkbench')
+            },
+            platform: undefined,
+            release: undefined,
+            arch: undefined,
+            totalmem: undefined,
+            freemem: undefined,
+            meminfo: undefined,
+            cpus: undefined,
+            loadavg: undefined,
+            isVMLikelyhood: undefined,
+            initialStartup,
+            hasAccessibilitySupport: this._accessibilityService.isScreenReaderOptimized(),
+            emptyWorkbench: this._contextService.getWorkbenchState() === 1
+        };
+        await this._extendStartupInfo(info);
+        return info;
+    }
+};
+AbstractTimerService = ( __decorate([
+    ( __param(0, ILifecycleService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IExtensionService)),
+    ( __param(3, IUpdateService)),
+    ( __param(4, IPaneCompositePartService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IAccessibilityService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IWorkbenchLayoutService))
+], AbstractTimerService));
+class TimerService extends AbstractTimerService {
+    _isInitialStartup() {
+        return false;
+    }
+    _didUseCachedData() {
+        return false;
+    }
+    async _getWindowCount() {
+        return 1;
+    }
+    async _extendStartupInfo(info) {
+        info.isVMLikelyhood = 0;
+        info.isARM64Emulated = false;
+        info.platform = navigator.userAgent;
+        info.release = navigator.appVersion;
+    }
+}
+export { AbstractTimerService, ITimerService, TimerService };

package/vscode/src/vs/workbench/services/userData/browser/userDataInit.js

@@ -6,6 +6,36 @@ import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { IExtensionService } from '../../extensions/common/extensions.js';
 import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
 const IUserDataInitializationService = ( createDecorator('IUserDataInitializationService'));
+class UserDataInitializationService {
+    constructor(initializers = []) {
+        this.initializers = initializers;
+    }
+    async whenInitializationFinished() {
+        if (await this.requiresInitialization()) {
+            await Promise.all(( this.initializers.map(initializer => initializer.whenInitializationFinished())));
+        }
+    }
+    async requiresInitialization() {
+        return ( (await Promise.all(( this.initializers.map(initializer => initializer.requiresInitialization())))).some(result => result));
+    }
+    async initializeRequiredResources() {
+        if (await this.requiresInitialization()) {
+            await Promise.all(( this.initializers.map(initializer => initializer.initializeRequiredResources())));
+        }
+    }
+    async initializeOtherResources(instantiationService) {
+        if (await this.requiresInitialization()) {
+            await Promise.all(( this.initializers.map(initializer => initializer.initializeOtherResources(instantiationService))));
+        }
+    }
+    async initializeInstalledExtensions(instantiationService) {
+        if (await this.requiresInitialization()) {
+            await Promise.all(( this.initializers.map(
+                initializer => initializer.initializeInstalledExtensions(instantiationService)
+            )));
+        }
+    }
+}
 let InitializeOtherResourcesContribution = class InitializeOtherResourcesContribution {
     constructor(userDataInitializeService, instantiationService, extensionService) {
         extensionService.whenInstalledExtensionsRegistered().then(() => this.initializeOtherResource(userDataInitializeService, instantiationService));
@@ -27,4 +57,4 @@ if (isWeb) {
     const workbenchRegistry = ( Registry.as(Extensions.Workbench));
     workbenchRegistry.registerWorkbenchContribution(InitializeOtherResourcesContribution, 3 );
 }
-export { IUserDataInitializationService };
+export { IUserDataInitializationService, UserDataInitializationService };

package/vscode/src/vs/workbench/services/userDataProfile/common/userDataProfile.js

@@ -1,14 +1,38 @@
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 const IUserDataProfileService = ( createDecorator('IUserDataProfileService'));
+const IUserDataProfileManagementService = ( createDecorator('IUserDataProfileManagementService'));
+const PROFILE_URL_AUTHORITY = 'profile';
+function toUserDataProfileUri(path, productService) {
+    return ( URI.from({
+        scheme: productService.urlProtocol,
+        authority: PROFILE_URL_AUTHORITY,
+        path: path.startsWith('/') ? path : `/${path}`
+    }));
+}
 const IUserDataProfileImportExportService = ( createDecorator('IUserDataProfileImportExportService'));
 const defaultUserDataProfileIcon = registerIcon('defaultProfile-icon', Codicon.settings, ( localizeWithPath(
     'vs/workbench/services/userDataProfile/common/userDataProfile',
     'defaultProfileIcon',
     'Icon for Default Profile.'
 )));
+const PROFILES_TITLE = { value: ( localizeWithPath(
+    'vs/workbench/services/userDataProfile/common/userDataProfile',
+    'profiles',
+    "Profiles"
+)), original: 'Profiles' };
+const PROFILES_CATEGORY = { ...PROFILES_TITLE };
+const PROFILE_EXTENSION = 'code-profile';
+const PROFILE_FILTER = [{ name: ( localizeWithPath(
+    'vs/workbench/services/userDataProfile/common/userDataProfile',
+    'profile',
+    "Profile"
+)), extensions: [PROFILE_EXTENSION] }];
 const CURRENT_PROFILE_CONTEXT = ( new RawContextKey('currentProfile', ''));
-export { CURRENT_PROFILE_CONTEXT, IUserDataProfileImportExportService, IUserDataProfileService, defaultUserDataProfileIcon };
+const IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT = ( new RawContextKey('isProfileExportInProgress', false));
+const IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT = ( new RawContextKey('isProfileImportInProgress', false));
+export { CURRENT_PROFILE_CONTEXT, IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT, IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT, IUserDataProfileImportExportService, IUserDataProfileManagementService, IUserDataProfileService, PROFILES_CATEGORY, PROFILES_TITLE, PROFILE_EXTENSION, PROFILE_FILTER, PROFILE_URL_AUTHORITY, defaultUserDataProfileIcon, toUserDataProfileUri };