@codingame/monaco-vscode-api 4.5.0-improve-code-splitting.1 → 4.5.1

package/vscode/src/vs/workbench/contrib/terminal/common/terminal.d.ts

@@ -0,0 +1,238 @@
+import { Event } from '../../../../base/common/event.js';
+import { IDisposable } from '../../../../base/common/lifecycle.js';
+import { OperatingSystem } from '../../../../base/common/platform.js';
+import Severity from '../../../../base/common/severity.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ITerminalCapabilityStore } from '../../../../platform/terminal/common/capabilities/capabilities.js';
+import { IMergedEnvironmentVariableCollection } from '../../../../platform/terminal/common/environmentVariable.js';
+import { TitleEventSource, IFixedTerminalDimensions, IProcessProperty, IProcessReadyWindowsPty, ITerminalLaunchError, TerminalLocationString, ITerminalBackend, ITerminalProfileObject } from '../../../../platform/terminal/common/terminal.js';
+import { IEnvironmentVariableInfo } from './environmentVariable.js';
+
+type FontWeight = 'normal' | 'bold' | number;
+interface ITerminalProfiles {
+    linux: {
+        [key: string]: ITerminalProfileObject;
+    };
+    osx: {
+        [key: string]: ITerminalProfileObject;
+    };
+    windows: {
+        [key: string]: ITerminalProfileObject;
+    };
+}
+type ConfirmOnKill = 'never' | 'always' | 'editor' | 'panel';
+type ConfirmOnExit = 'never' | 'always' | 'hasChildProcesses';
+interface ITerminalConfiguration {
+    shell: {
+        linux: string | null;
+        osx: string | null;
+        windows: string | null;
+    };
+    automationShell: {
+        linux: string | null;
+        osx: string | null;
+        windows: string | null;
+    };
+    shellArgs: {
+        linux: string[];
+        osx: string[];
+        windows: string[];
+    };
+    profiles: ITerminalProfiles;
+    defaultProfile: {
+        linux: string | null;
+        osx: string | null;
+        windows: string | null;
+    };
+    useWslProfiles: boolean;
+    altClickMovesCursor: boolean;
+    macOptionIsMeta: boolean;
+    macOptionClickForcesSelection: boolean;
+    gpuAcceleration: 'auto' | 'on' | 'canvas' | 'off';
+    rightClickBehavior: 'default' | 'copyPaste' | 'paste' | 'selectWord' | 'nothing';
+    cursorBlinking: boolean;
+    cursorStyle: 'block' | 'underline' | 'line';
+    cursorStyleInactive: 'outline' | 'block' | 'underline' | 'line' | 'none';
+    cursorWidth: number;
+    drawBoldTextInBrightColors: boolean;
+    fastScrollSensitivity: number;
+    fontFamily: string;
+    fontWeight: FontWeight;
+    fontWeightBold: FontWeight;
+    minimumContrastRatio: number;
+    mouseWheelScrollSensitivity: number;
+    tabStopWidth: number;
+    sendKeybindingsToShell: boolean;
+    fontSize: number;
+    letterSpacing: number;
+    lineHeight: number;
+    detectLocale: 'auto' | 'off' | 'on';
+    scrollback: number;
+    commandsToSkipShell: string[];
+    allowChords: boolean;
+    allowMnemonics: boolean;
+    cwd: string;
+    confirmOnExit: ConfirmOnExit;
+    confirmOnKill: ConfirmOnKill;
+    enableBell: boolean;
+    env: {
+        linux: {
+            [key: string]: string;
+        };
+        osx: {
+            [key: string]: string;
+        };
+        windows: {
+            [key: string]: string;
+        };
+    };
+    environmentChangesIndicator: 'off' | 'on' | 'warnonly';
+    environmentChangesRelaunch: boolean;
+    showExitAlert: boolean;
+    splitCwd: 'workspaceRoot' | 'initial' | 'inherited';
+    windowsEnableConpty: boolean;
+    wordSeparators: string;
+    enableFileLinks: 'off' | 'on' | 'notRemote';
+    unicodeVersion: '6' | '11';
+    localEchoLatencyThreshold: number;
+    localEchoExcludePrograms: ReadonlyArray<string>;
+    localEchoEnabled: 'auto' | 'on' | 'off';
+    localEchoStyle: 'bold' | 'dim' | 'italic' | 'underlined' | 'inverted' | string;
+    enablePersistentSessions: boolean;
+    tabs: {
+        enabled: boolean;
+        hideCondition: 'never' | 'singleTerminal' | 'singleGroup';
+        showActiveTerminal: 'always' | 'singleTerminal' | 'singleTerminalOrNarrow' | 'singleGroup' | 'never';
+        location: 'left' | 'right';
+        focusMode: 'singleClick' | 'doubleClick';
+        title: string;
+        description: string;
+        separator: string;
+    };
+    bellDuration: number;
+    defaultLocation: TerminalLocationString;
+    customGlyphs: boolean;
+    persistentSessionReviveProcess: 'onExit' | 'onExitAndWindowClose' | 'never';
+    ignoreProcessNames: string[];
+    autoReplies: {
+        [key: string]: string;
+    };
+    shellIntegration?: {
+        enabled: boolean;
+        decorationsEnabled: boolean;
+    };
+    enableImages: boolean;
+    smoothScrolling: boolean;
+    ignoreBracketedPasteMode: boolean;
+    rescaleOverlappingGlyphs: boolean;
+}
+interface ITerminalFont {
+    fontFamily: string;
+    fontSize: number;
+    letterSpacing: number;
+    lineHeight: number;
+    charWidth?: number;
+    charHeight?: number;
+}
+interface IRemoteTerminalAttachTarget {
+    id: number;
+    pid: number;
+    title: string;
+    titleSource: TitleEventSource;
+    cwd: string;
+    workspaceId: string;
+    workspaceName: string;
+    isOrphan: boolean;
+    icon: URI | {
+        light: URI;
+        dark: URI;
+    } | {
+        id: string;
+        color?: {
+            id: string;
+        };
+    } | undefined;
+    color: string | undefined;
+    fixedDimensions: IFixedTerminalDimensions | undefined;
+    shellIntegrationNonce: string;
+}
+/** Read-only process information that can apply to detached terminals. */
+interface ITerminalProcessInfo {
+    readonly processState: ProcessState;
+    readonly ptyProcessReady: Promise<void>;
+    readonly shellProcessId: number | undefined;
+    readonly remoteAuthority: string | undefined;
+    readonly os: OperatingSystem | undefined;
+    readonly userHome: string | undefined;
+    readonly initialCwd: string;
+    readonly environmentVariableInfo: IEnvironmentVariableInfo | undefined;
+    readonly persistentProcessId: number | undefined;
+    readonly shouldPersist: boolean;
+    readonly hasWrittenData: boolean;
+    readonly hasChildProcesses: boolean;
+    readonly backend: ITerminalBackend | undefined;
+    readonly capabilities: ITerminalCapabilityStore;
+    readonly shellIntegrationNonce: string;
+    readonly extEnvironmentVariableCollection: IMergedEnvironmentVariableCollection | undefined;
+}
+declare const enum ProcessState {
+    Uninitialized = 1,
+    Launching = 2,
+    Running = 3,
+    KilledDuringLaunch = 4,
+    KilledByUser = 5,
+    KilledByProcess = 6
+}
+interface ITerminalProcessExtHostProxy extends IDisposable {
+    readonly instanceId: number;
+    emitData(data: string): void;
+    emitProcessProperty(property: IProcessProperty<any>): void;
+    emitReady(pid: number, cwd: string, windowsPty: IProcessReadyWindowsPty | undefined): void;
+    emitExit(exitCode: number | undefined): void;
+    onInput: Event<string>;
+    onBinary: Event<string>;
+    onResize: Event<{
+        cols: number;
+        rows: number;
+    }>;
+    onAcknowledgeDataEvent: Event<number>;
+    onShutdown: Event<boolean>;
+    onRequestInitialCwd: Event<void>;
+    onRequestCwd: Event<void>;
+}
+interface IStartExtensionTerminalRequest {
+    proxy: ITerminalProcessExtHostProxy;
+    cols: number;
+    rows: number;
+    callback: (error: ITerminalLaunchError | undefined) => void;
+}
+interface ITerminalStatus {
+    /** An internal string ID used to identify the status. */
+    id: string;
+    /**
+     * The severity of the status, this defines both the color and how likely the status is to be
+     * the "primary status".
+     */
+    severity: Severity;
+    /**
+     * An icon representing the status, if this is not specified it will not show up on the terminal
+     * tab and will use the generic `info` icon when hovering.
+     */
+    icon?: ThemeIcon;
+    /**
+     * What to show for this status in the terminal's hover.
+     */
+    tooltip?: string | undefined;
+    /**
+     * Actions to expose on hover.
+     */
+    hoverActions?: ITerminalStatusHoverAction[];
+}
+interface ITerminalStatusHoverAction {
+    label: string;
+    commandId: string;
+    run: () => void;
+}
+
+export { type ConfirmOnExit, type ConfirmOnKill, type FontWeight, type IRemoteTerminalAttachTarget, type IStartExtensionTerminalRequest, type ITerminalConfiguration, type ITerminalFont, type ITerminalProcessExtHostProxy, type ITerminalProcessInfo, type ITerminalProfiles, type ITerminalStatus, type ITerminalStatusHoverAction, ProcessState };

package/vscode/src/vs/workbench/services/activity/browser/activityService.d.ts

@@ -0,0 +1,28 @@
+import { IActivity } from '../common/activity.js';
+import { IActivityService } from '../common/activity.service.js';
+import { Disposable, IDisposable } from '../../../../base/common/lifecycle.js';
+import { ViewContainer } from '../../../common/views.js';
+import { IViewDescriptorService } from '../../../common/views.service.js';
+import { Event } from '../../../../base/common/event.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+
+declare class ActivityService extends Disposable implements IActivityService {
+    private readonly viewDescriptorService;
+    private readonly instantiationService;
+    _serviceBrand: undefined;
+    private readonly viewActivities;
+    private readonly _onDidChangeActivity;
+    readonly onDidChangeActivity: Event<string | ViewContainer>;
+    private readonly viewContainerActivities;
+    private readonly globalActivities;
+    constructor(viewDescriptorService: IViewDescriptorService, instantiationService: IInstantiationService);
+    showViewContainerActivity(viewContainerId: string, activity: IActivity): IDisposable;
+    getViewContainerActivities(viewContainerId: string): IActivity[];
+    showViewActivity(viewId: string, activity: IActivity): IDisposable;
+    showAccountsActivity(activity: IActivity): IDisposable;
+    showGlobalActivity(activity: IActivity): IDisposable;
+    getActivity(id: string): IActivity[];
+    private showActivity;
+}
+
+export { ActivityService };

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

@@ -0,0 +1,53 @@
+import { IExtensionIdentifier, IExtensionManifest, IExtension } from '../../../../platform/extensions/common/extensions.js';
+import { InstallExtensionEvent, UninstallExtensionEvent, DidUninstallExtensionEvent, Metadata, ILocalExtension } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IProfileAwareExtensionManagementService } from './extensionManagement.service.js';
+
+type DidChangeProfileEvent = {
+    readonly added: ILocalExtension[];
+    readonly removed: ILocalExtension[];
+};
+interface IExtensionManagementServer {
+    readonly id: string;
+    readonly label: string;
+    readonly extensionManagementService: IProfileAwareExtensionManagementService;
+}
+interface IResourceExtension {
+    readonly identifier: IExtensionIdentifier;
+    readonly location: URI;
+    readonly manifest: IExtensionManifest;
+    readonly readmeUri?: URI;
+    readonly changelogUri?: URI;
+}
+type InstallExtensionOnServerEvent = InstallExtensionEvent & {
+    server: IExtensionManagementServer;
+};
+type UninstallExtensionOnServerEvent = UninstallExtensionEvent & {
+    server: IExtensionManagementServer;
+};
+type DidUninstallExtensionOnServerEvent = DidUninstallExtensionEvent & {
+    server: IExtensionManagementServer;
+};
+type DidChangeProfileForServerEvent = DidChangeProfileEvent & {
+    server: IExtensionManagementServer;
+};
+declare const enum EnablementState {
+    DisabledByTrustRequirement = 0,
+    DisabledByExtensionKind = 1,
+    DisabledByEnvironment = 2,
+    EnabledByEnvironment = 3,
+    DisabledByVirtualWorkspace = 4,
+    DisabledByExtensionDependency = 5,
+    DisabledGlobally = 6,
+    DisabledWorkspace = 7,
+    EnabledGlobally = 8,
+    EnabledWorkspace = 9
+}
+interface IScannedExtension extends IExtension {
+    readonly metadata?: Metadata;
+}
+type ScanOptions = {
+    readonly skipInvalidExtensions?: boolean;
+};
+
+export { type DidChangeProfileEvent, type DidChangeProfileForServerEvent, type DidUninstallExtensionOnServerEvent, EnablementState, type IExtensionManagementServer, type IResourceExtension, type IScannedExtension, type InstallExtensionOnServerEvent, type ScanOptions, type UninstallExtensionOnServerEvent };

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

@@ -0,0 +1,106 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { Event } from '../../../../base/common/event.js';
+import { IExtensionManagementService } from '../../../../platform/extensionManagement/common/extensionManagement.service.js';
+import { InstallExtensionOnServerEvent, UninstallExtensionOnServerEvent, DidUninstallExtensionOnServerEvent, DidChangeProfileForServerEvent, IResourceExtension, EnablementState, ScanOptions, IScannedExtension, DidChangeProfileEvent } from './extensionManagement.js';
+import { IExtension, IExtensionManifest, ExtensionType } from '../../../../platform/extensions/common/extensions.js';
+import { URI } from '../../../../base/common/uri.js';
+import { InstallExtensionResult, ILocalExtension, InstallOptions, IGalleryExtension, Metadata } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+
+declare const IProfileAwareExtensionManagementService: ServiceIdentifier<IProfileAwareExtensionManagementService>;
+interface IProfileAwareExtensionManagementService extends IExtensionManagementService {
+    readonly onDidChangeProfile: Event<DidChangeProfileEvent>;
+}
+declare const IWorkbenchExtensionManagementService: ServiceIdentifier<IWorkbenchExtensionManagementService>;
+interface IWorkbenchExtensionManagementService extends IProfileAwareExtensionManagementService {
+    readonly _serviceBrand: undefined;
+    onInstallExtension: Event<InstallExtensionOnServerEvent>;
+    onDidInstallExtensions: Event<readonly InstallExtensionResult[]>;
+    onUninstallExtension: Event<UninstallExtensionOnServerEvent>;
+    onDidUninstallExtension: Event<DidUninstallExtensionOnServerEvent>;
+    onDidChangeProfile: Event<DidChangeProfileForServerEvent>;
+    onDidEnableExtensions: Event<IExtension[]>;
+    isWorkspaceExtensionsSupported(): boolean;
+    getExtensions(locations: URI[]): Promise<IResourceExtension[]>;
+    getInstalledWorkspaceExtensions(includeInvalid: boolean): Promise<ILocalExtension[]>;
+    installVSIX(location: URI, manifest: IExtensionManifest, installOptions?: InstallOptions): Promise<ILocalExtension>;
+    installFromLocation(location: URI): Promise<ILocalExtension>;
+    installResourceExtension(extension: IResourceExtension, installOptions: InstallOptions): Promise<ILocalExtension>;
+    updateFromGallery(gallery: IGalleryExtension, extension: ILocalExtension, installOptions?: InstallOptions): Promise<ILocalExtension>;
+}
+declare const IWorkbenchExtensionEnablementService: ServiceIdentifier<IWorkbenchExtensionEnablementService>;
+interface IWorkbenchExtensionEnablementService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Event to listen on for extension enablement changes
+    */
+    readonly onEnablementChanged: Event<readonly IExtension[]>;
+    /**
+    * Returns the enablement state for the given extension
+    */
+    getEnablementState(extension: IExtension): EnablementState;
+    /**
+    * Returns the enablement states for the given extensions
+    * @param extensions list of extensions
+    * @param workspaceTypeOverrides Workspace type overrides
+    */
+    getEnablementStates(extensions: IExtension[], workspaceTypeOverrides?: {
+        trusted?: boolean;
+    }): EnablementState[];
+    /**
+    * Returns the enablement states for the dependencies of the given extension
+    */
+    getDependenciesEnablementStates(extension: IExtension): [IExtension, EnablementState][];
+    /**
+    * Returns `true` if the enablement can be changed.
+    */
+    canChangeEnablement(extension: IExtension): boolean;
+    /**
+    * Returns `true` if the enablement can be changed.
+    */
+    canChangeWorkspaceEnablement(extension: IExtension): boolean;
+    /**
+    * Returns `true` if the given extension is enabled.
+    */
+    isEnabled(extension: IExtension): boolean;
+    /**
+    * Returns `true` if the given enablement state is enabled enablement state.
+    */
+    isEnabledEnablementState(enablementState: EnablementState): boolean;
+    /**
+    * Returns `true` if the given extension identifier is disabled globally.
+    * Extensions can be disabled globally or in workspace or both.
+    * If an extension is disabled in both then enablement state shows only workspace.
+    * This will
+    */
+    isDisabledGlobally(extension: IExtension): boolean;
+    /**
+    * Enable or disable the given extension.
+    * if `workspace` is `true` then enablement is done for workspace, otherwise globally.
+    *
+    * Returns a promise that resolves to boolean value.
+    * if resolves to `true` then requires restart for the change to take effect.
+    *
+    * Throws error if enablement is requested for workspace and there is no workspace
+    */
+    setEnablement(extensions: IExtension[], state: EnablementState): Promise<boolean[]>;
+    /**
+    * Updates the enablement state of the extensions when workspace trust changes.
+    */
+    updateExtensionsEnablementsWhenWorkspaceTrustChanges(): Promise<void>;
+}
+declare const IWebExtensionsScannerService: ServiceIdentifier<IWebExtensionsScannerService>;
+interface IWebExtensionsScannerService {
+    readonly _serviceBrand: undefined;
+    scanSystemExtensions(): Promise<IExtension[]>;
+    scanUserExtensions(profileLocation: URI, options?: ScanOptions): Promise<IScannedExtension[]>;
+    scanExtensionsUnderDevelopment(): Promise<IExtension[]>;
+    scanExistingExtension(extensionLocation: URI, extensionType: ExtensionType, profileLocation: URI): Promise<IScannedExtension | null>;
+    addExtension(location: URI, metadata: Metadata, profileLocation: URI): Promise<IScannedExtension>;
+    addExtensionFromGallery(galleryExtension: IGalleryExtension, metadata: Metadata, profileLocation: URI): Promise<IScannedExtension>;
+    removeExtension(extension: IScannedExtension, profileLocation: URI): Promise<void>;
+    copyExtensions(fromProfileLocation: URI, toProfileLocation: URI, filter: (extension: IScannedExtension) => boolean): Promise<void>;
+    updateMetadata(extension: IScannedExtension, metaData: Partial<Metadata>, profileLocation: URI): Promise<IScannedExtension>;
+    scanExtensionManifest(extensionLocation: URI): Promise<IExtensionManifest | null>;
+}
+
+export { IProfileAwareExtensionManagementService, IWebExtensionsScannerService, IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService };

package/vscode/src/vs/workbench/services/extensions/browser/extensionService.d.ts

@@ -0,0 +1,45 @@
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { IExtension, IExtensionDescription } from '../../../../platform/extensions/common/extensions.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { IProductService } from '../../../../platform/product/common/productService.service.js';
+import { ResolverResult } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.service.js';
+import { IRemoteExtensionsScannerService } from '../../../../platform/remote/common/remoteExtensionsScanner.service.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { IWorkspaceTrustManagementService } from '../../../../platform/workspace/common/workspaceTrust.service.js';
+import { IBrowserWorkbenchEnvironmentService } from '../../environment/browser/environmentService.service.js';
+import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, IWebExtensionsScannerService } from '../../extensionManagement/common/extensionManagement.service.js';
+import { IExtensionHostKindPicker } from '../common/extensionHostKind.js';
+import { IExtensionService } from '../common/extensions.service.js';
+import { AbstractExtensionService, IExtensionHostFactory, ResolvedExtensions } from '../common/abstractExtensionService.js';
+import { IExtensionManifestPropertiesService } from '../common/extensionManifestPropertiesService.service.js';
+import { ExtensionsProposedApi } from '../common/extensionsProposedApi.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.service.js';
+import { IRemoteAgentService } from '../../remote/common/remoteAgentService.service.js';
+import { IRemoteExplorerService } from '../../remote/common/remoteExplorerService.service.js';
+import { IUserDataInitializationService } from '../../userData/browser/userDataInit.service.js';
+import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.service.js';
+
+declare class ExtensionService extends AbstractExtensionService implements IExtensionService {
+    private readonly _browserEnvironmentService;
+    private readonly _webExtensionsScannerService;
+    private readonly _userDataInitializationService;
+    private readonly _userDataProfileService;
+    private readonly _workspaceTrustManagementService;
+    private readonly _remoteExplorerService;
+    constructor(extensionsProposedApi: ExtensionsProposedApi, extensionHostFactory: IExtensionHostFactory, extensionHostKindPicker: IExtensionHostKindPicker, instantiationService: IInstantiationService, notificationService: INotificationService, _browserEnvironmentService: IBrowserWorkbenchEnvironmentService, telemetryService: ITelemetryService, extensionEnablementService: IWorkbenchExtensionEnablementService, fileService: IFileService, productService: IProductService, extensionManagementService: IWorkbenchExtensionManagementService, contextService: IWorkspaceContextService, configurationService: IConfigurationService, extensionManifestPropertiesService: IExtensionManifestPropertiesService, _webExtensionsScannerService: IWebExtensionsScannerService, logService: ILogService, remoteAgentService: IRemoteAgentService, remoteExtensionsScannerService: IRemoteExtensionsScannerService, lifecycleService: ILifecycleService, remoteAuthorityResolverService: IRemoteAuthorityResolverService, _userDataInitializationService: IUserDataInitializationService, _userDataProfileService: IUserDataProfileService, _workspaceTrustManagementService: IWorkspaceTrustManagementService, _remoteExplorerService: IRemoteExplorerService, dialogService: IDialogService);
+    protected _scanSingleExtension(extension: IExtension): Promise<IExtensionDescription | null>;
+    private _initFetchFileSystem;
+    protected _scanWebExtensions(): Promise<IExtensionDescription[]>;
+    protected _resolveExtensionsDefault(): Promise<ResolvedExtensions>;
+    protected _resolveExtensions(): Promise<ResolvedExtensions>;
+    protected _onExtensionHostExit(code: number): Promise<void>;
+    protected _resolveAuthority(remoteAuthority: string): Promise<ResolverResult>;
+}
+
+export { ExtensionService };

package/vscode/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.d.ts

@@ -0,0 +1,11 @@
+import '../../../../editor/editor.api.js';
+import { ExtensionHostExtensions } from '../common/extensions.js';
+
+interface IWebWorkerExtensionHostInitData {
+    readonly extensions: ExtensionHostExtensions;
+}
+interface IWebWorkerExtensionHostDataProvider {
+    getInitData(): Promise<IWebWorkerExtensionHostInitData>;
+}
+
+export type { IWebWorkerExtensionHostDataProvider, IWebWorkerExtensionHostInitData };

package/vscode/src/vs/workbench/services/extensions/common/abstractExtensionService.d.ts

@@ -0,0 +1,162 @@
+import { Event } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { ExtensionIdentifier, IExtensionDescription, IExtension, IExtensionContributions } from '../../../../platform/extensions/common/extensions.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { IProductService } from '../../../../platform/product/common/productService.service.js';
+import { ResolverResult } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
+import { IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.service.js';
+import { IRemoteExtensionsScannerService } from '../../../../platform/remote/common/remoteExtensionsScanner.service.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
+import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService } from '../../extensionManagement/common/extensionManagement.service.js';
+import { ExtensionDescriptionRegistrySnapshot } from './extensionDescriptionRegistry.js';
+import { IExtensionHostKindPicker, ExtensionHostKind } from './extensionHostKind.js';
+import { IExtensionHostManager } from './extensionHostManagers.js';
+import { IExtensionManifestPropertiesService } from './extensionManifestPropertiesService.service.js';
+import { ExtensionRunningLocation } from './extensionRunningLocation.js';
+import { ExtensionRunningLocationTracker } from './extensionRunningLocationTracker.js';
+import { IWillActivateEvent, IResponsiveStateChangeEvent, WillStopExtensionHostsEvent, IExtensionHost, ActivationKind, ExtensionActivationReason, ExtensionPointContribution, IExtensionsStatus } from './extensions.js';
+import { IExtensionService } from './extensions.service.js';
+import { ExtensionsProposedApi } from './extensionsProposedApi.js';
+import { IExtensionPoint } from './extensionsRegistry.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.service.js';
+import { IRemoteAgentService } from '../../remote/common/remoteAgentService.service.js';
+
+declare abstract class AbstractExtensionService extends Disposable implements IExtensionService {
+    protected readonly _extensionsProposedApi: ExtensionsProposedApi;
+    protected readonly _extensionHostFactory: IExtensionHostFactory;
+    protected readonly _extensionHostKindPicker: IExtensionHostKindPicker;
+    protected readonly _instantiationService: IInstantiationService;
+    protected readonly _notificationService: INotificationService;
+    protected readonly _environmentService: IWorkbenchEnvironmentService;
+    protected readonly _telemetryService: ITelemetryService;
+    protected readonly _extensionEnablementService: IWorkbenchExtensionEnablementService;
+    protected readonly _fileService: IFileService;
+    protected readonly _productService: IProductService;
+    protected readonly _extensionManagementService: IWorkbenchExtensionManagementService;
+    private readonly _contextService;
+    private readonly _configurationService;
+    private readonly _extensionManifestPropertiesService;
+    protected readonly _logService: ILogService;
+    protected readonly _remoteAgentService: IRemoteAgentService;
+    protected readonly _remoteExtensionsScannerService: IRemoteExtensionsScannerService;
+    private readonly _lifecycleService;
+    protected readonly _remoteAuthorityResolverService: IRemoteAuthorityResolverService;
+    private readonly _dialogService;
+    _serviceBrand: undefined;
+    private readonly _onDidRegisterExtensions;
+    readonly onDidRegisterExtensions: Event<void>;
+    private readonly _onDidChangeExtensionsStatus;
+    readonly onDidChangeExtensionsStatus: Event<ExtensionIdentifier[]>;
+    private readonly _onDidChangeExtensions;
+    readonly onDidChangeExtensions: Event<{
+        readonly added: ReadonlyArray<IExtensionDescription>;
+        readonly removed: ReadonlyArray<IExtensionDescription>;
+    }>;
+    private readonly _onWillActivateByEvent;
+    readonly onWillActivateByEvent: Event<IWillActivateEvent>;
+    private readonly _onDidChangeResponsiveChange;
+    readonly onDidChangeResponsiveChange: Event<IResponsiveStateChangeEvent>;
+    private readonly _onWillStop;
+    readonly onWillStop: Event<WillStopExtensionHostsEvent>;
+    private readonly _activationEventReader;
+    private readonly _registry;
+    private readonly _installedExtensionsReady;
+    private readonly _extensionStatus;
+    private readonly _allRequestedActivateEvents;
+    private readonly _runningLocations;
+    private readonly _remoteCrashTracker;
+    private _deltaExtensionsQueue;
+    private _inHandleDeltaExtensions;
+    private _extensionHostManagers;
+    private _resolveAuthorityAttempt;
+    constructor(_extensionsProposedApi: ExtensionsProposedApi, _extensionHostFactory: IExtensionHostFactory, _extensionHostKindPicker: IExtensionHostKindPicker, _instantiationService: IInstantiationService, _notificationService: INotificationService, _environmentService: IWorkbenchEnvironmentService, _telemetryService: ITelemetryService, _extensionEnablementService: IWorkbenchExtensionEnablementService, _fileService: IFileService, _productService: IProductService, _extensionManagementService: IWorkbenchExtensionManagementService, _contextService: IWorkspaceContextService, _configurationService: IConfigurationService, _extensionManifestPropertiesService: IExtensionManifestPropertiesService, _logService: ILogService, _remoteAgentService: IRemoteAgentService, _remoteExtensionsScannerService: IRemoteExtensionsScannerService, _lifecycleService: ILifecycleService, _remoteAuthorityResolverService: IRemoteAuthorityResolverService, _dialogService: IDialogService);
+    protected _getExtensionHostManagers(kind: ExtensionHostKind): IExtensionHostManager[];
+    private _getExtensionHostManagerByRunningLocation;
+    protected _handleDeltaExtensions(item: DeltaExtensionsQueueItem): Promise<void>;
+    private _deltaExtensions;
+    private _updateExtensionsOnExtHosts;
+    private _updateExtensionsOnExtHost;
+    canAddExtension(extension: IExtensionDescription): boolean;
+    private _canAddExtension;
+    canRemoveExtension(extension: IExtensionDescription): boolean;
+    private _activateAddedExtensionIfNeeded;
+    protected _initialize(): Promise<void>;
+    private _processExtensions;
+    private _handleExtensionTests;
+    private findTestExtensionHost;
+    private _releaseBarrier;
+    protected _resolveAuthorityInitial(remoteAuthority: string): Promise<ResolverResult>;
+    protected _resolveAuthorityAgain(): Promise<void>;
+    private _resolveAuthorityWithLogging;
+    protected _resolveAuthorityOnExtensionHosts(kind: ExtensionHostKind, remoteAuthority: string): Promise<ResolverResult>;
+    stopExtensionHosts(reason: string): Promise<boolean>;
+    protected _doStopExtensionHosts(): void;
+    private _doStopExtensionHostsWithVeto;
+    private _startExtensionHostsIfNecessary;
+    private _createExtensionHostManager;
+    protected _doCreateExtensionHostManager(extensionHost: IExtensionHost, initialActivationEvents: string[]): IExtensionHostManager;
+    private _onExtensionHostCrashOrExit;
+    protected _onExtensionHostCrashed(extensionHost: IExtensionHostManager, code: number, signal: string | null): void;
+    private _getExtensionHostExitInfoWithTimeout;
+    private _onRemoteExtensionHostCrashed;
+    protected _logExtensionHostCrash(extensionHost: IExtensionHostManager): void;
+    startExtensionHosts(updates?: {
+        toAdd: IExtension[];
+        toRemove: string[];
+    }): Promise<void>;
+    activateByEvent(activationEvent: string, activationKind?: ActivationKind): Promise<void>;
+    private _activateByEvent;
+    activateById(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+    activationEventIsDone(activationEvent: string): boolean;
+    whenInstalledExtensionsRegistered(): Promise<boolean>;
+    get extensions(): IExtensionDescription[];
+    protected _getExtensionRegistrySnapshotWhenReady(): Promise<ExtensionDescriptionRegistrySnapshot>;
+    getExtension(id: string): Promise<IExtensionDescription | undefined>;
+    readExtensionPointContributions<T extends IExtensionContributions[keyof IExtensionContributions]>(extPoint: IExtensionPoint<T>): Promise<ExtensionPointContribution<T>[]>;
+    getExtensionsStatus(): {
+        [id: string]: IExtensionsStatus;
+    };
+    getInspectPorts(extensionHostKind: ExtensionHostKind, tryEnableInspector: boolean): Promise<number[]>;
+    setRemoteEnvironment(env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+    private _safeInvokeIsEnabled;
+    private _doHandleExtensionPoints;
+    private _getOrCreateExtensionStatus;
+    private _handleExtensionPointMessage;
+    private static _handleExtensionPoint;
+    private _acquireInternalAPI;
+    _activateById(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+    private _onWillActivateExtension;
+    private _onDidActivateExtension;
+    private _onDidActivateExtensionError;
+    private _onExtensionRuntimeError;
+    protected abstract _resolveExtensions(): Promise<ResolvedExtensions>;
+    protected abstract _scanSingleExtension(extension: IExtension): Promise<IExtensionDescription | null>;
+    protected abstract _onExtensionHostExit(code: number): void;
+    protected abstract _resolveAuthority(remoteAuthority: string): Promise<ResolverResult>;
+}
+declare class ResolvedExtensions {
+    readonly local: IExtensionDescription[];
+    readonly remote: IExtensionDescription[];
+    readonly hasLocalProcess: boolean;
+    readonly allowRemoteExtensionsInLocalWebWorker: boolean;
+    constructor(local: IExtensionDescription[], remote: IExtensionDescription[], hasLocalProcess: boolean, allowRemoteExtensionsInLocalWebWorker: boolean);
+}
+interface IExtensionHostFactory {
+    createExtensionHost(runningLocations: ExtensionRunningLocationTracker, runningLocation: ExtensionRunningLocation, isInitialStart: boolean): IExtensionHost | null;
+}
+declare class DeltaExtensionsQueueItem {
+    readonly toAdd: IExtension[];
+    readonly toRemove: string[] | IExtension[];
+    constructor(toAdd: IExtension[], toRemove: string[] | IExtension[]);
+}
+
+export { AbstractExtensionService, DeltaExtensionsQueueItem, type IExtensionHostFactory, ResolvedExtensions };