@codingame/monaco-vscode-extensions-service-override 1.82.4 → 1.82.5-next.0

package/extensions.d.ts

@@ -0,0 +1,51 @@
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IExtension, IRelaxedExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { AbstractExtensionService, ResolvedExtensions } from 'vscode/vscode/vs/workbench/services/extensions/common/abstractExtensionService';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+import { IRemoteAuthorityResolverService, ResolverResult } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { IRemoteExtensionsScannerService } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+import { IUserDataInitializationService } from 'vscode/vscode/vs/workbench/services/userData/browser/userDataInit';
+import { ExtensionHostKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
+export { ExtensionHostKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
+import { ExtHostExtensionService } from './vscode/src/vs/workbench/api/worker/extHostExtensionService.js';
+import * as vscode from 'vscode';
+
+declare class LocalExtHostExtensionService extends ExtHostExtensionService {
+    private _defaultApiImpl?;
+    private readonly _extApiImpl;
+    getApi(extensionId?: string): Promise<typeof vscode>;
+}
+interface WorkerConfig {
+    url: string;
+    options?: WorkerOptions;
+}
+interface IExtensionWithExtHostKind extends IExtension {
+    extHostKind?: ExtensionHostKind;
+}
+declare class SimpleExtensionService extends AbstractExtensionService implements IExtensionService {
+    constructor(workerConfig: WorkerConfig | undefined, instantiationService: IInstantiationService, notificationService: INotificationService, browserEnvironmentService: IBrowserWorkbenchEnvironmentService, 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, userDataInitializationService: IUserDataInitializationService, dialogService: IDialogService);
+    private _initFetchFileSystem;
+    deltaExtensions(toAdd: IExtensionWithExtHostKind[], toRemove: IExtension[]): Promise<void>;
+    protected _resolveExtensions(): Promise<ResolvedExtensions>;
+    protected _scanSingleExtension(extension: IExtension): Promise<Readonly<IRelaxedExtensionDescription> | null>;
+    protected _onExtensionHostExit(): void;
+    protected _resolveAuthority(remoteAuthority: string): Promise<ResolverResult>;
+}
+declare function getServiceOverride(workerConfig?: WorkerConfig, _iframeAlternateDomains?: string): IEditorOverrideServices;
+declare function getLocalExtHostExtensionService(): Promise<LocalExtHostExtensionService>;
+
+export { type IExtensionWithExtHostKind, LocalExtHostExtensionService, SimpleExtensionService, type WorkerConfig, getServiceOverride as default, getLocalExtHostExtensionService };

package/index.d.ts

@@ -1,2 +1,2 @@
-export { default } from 'vscode/service-override/extensions'
-export * from 'vscode/service-override/extensions'
+export { IExtensionWithExtHostKind, LocalExtHostExtensionService, SimpleExtensionService, WorkerConfig, default, getLocalExtHostExtensionService } from './extensions.js';
+export { ExtensionHostKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';

package/index.js

@@ -1,2 +1,2 @@
-export { default } from 'vscode/service-override/extensions'
-export * from 'vscode/service-override/extensions'
+export * from 'vscode/service-override/extensions';
+export { default } from 'vscode/service-override/extensions';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-extensions-service-override",
-  "version": "1.82.4",
+  "version": "1.82.5-next.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.82.4",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.82.5-next.0",
     "monaco-editor": "0.43.0"
   }
 }

package/vscode/src/vs/workbench/api/common/extHost.api.impl.d.ts

@@ -0,0 +1,14 @@
+import { ExtHostConfigProvider } from './extHostConfiguration.js';
+import { ExtensionDescriptionRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry';
+import * as vscode from 'vscode';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+
+interface IExtensionRegistries {
+    mine: ExtensionDescriptionRegistry;
+    all: ExtensionDescriptionRegistry;
+}
+interface IExtensionApiFactory {
+    (extension: IExtensionDescription, extensionInfo: IExtensionRegistries, configProvider: ExtHostConfigProvider): typeof vscode;
+}
+
+export type { IExtensionApiFactory, IExtensionRegistries };

package/vscode/src/vs/workbench/api/common/extHost.protocol.d.ts

@@ -0,0 +1,236 @@
+import { Dto } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { UriComponents, URI } from 'vscode/vscode/vs/base/common/uri';
+import { SerializedError } from 'vscode/vscode/vs/base/common/errors';
+import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { PerformanceMark } from 'vscode/vscode/vs/base/common/performance';
+import { Command } from 'vscode/vscode/vs/editor/common/languages';
+import { IConfigurationData, ConfigurationTarget, IConfigurationOverrides, IConfigurationChange } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ConfigurationScope } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { IExtensionDescription, ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { IRemoteConnectionData } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { ClassifiedEvent, OmitMetadata, IGDPRProperty, StrictPropertyCheck } from 'vscode/vscode/vs/platform/telemetry/common/gdprTypings';
+import { ISerializableEnvironmentVariableCollection } from 'vscode/vscode/vs/platform/terminal/common/environmentVariable';
+import { TerminalExitReason, IShellLaunchConfigDto, ITerminalLaunchError, ITerminalProfile, ICreateContributedTerminalProfileOptions } from 'vscode/vscode/vs/platform/terminal/common/terminal';
+import { TunnelOptions, TunnelCreationOptions, ProvidedPortAttributes, TunnelPrivacyId } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
+import { EditSessionIdentityMatch } from 'vscode/vscode/vs/platform/workspace/common/editSessions';
+import { WorkspaceTrustRequestOptions } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
+import { ExtensionActivationReason, MissingExtensionDependency, ActivationKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IPatternInfo, IRawFileMatch2 } from 'vscode/vscode/vs/workbench/services/search/common/search';
+import { IExtensionDescriptionDelta, IStaticWorkspaceData } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
+import { IResolveAuthorityResult } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProxy';
+import { CandidatePort } from 'vscode/vscode/vs/workbench/services/remote/common/tunnelModel';
+import { ITextQueryBuilderOptions } from '../../services/search/common/queryBuilder.js';
+
+interface IWorkspaceData extends IStaticWorkspaceData {
+    folders: {
+        uri: UriComponents;
+        name: string;
+        index: number;
+    }[];
+}
+interface IConfigurationInitData extends IConfigurationData {
+    configurationScopes: [string, ConfigurationScope | undefined][];
+}
+interface MainThreadConfigurationShape extends IDisposable {
+    $updateConfigurationOption(target: ConfigurationTarget | null, key: string, value: any, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void>;
+    $removeConfigurationOption(target: ConfigurationTarget | null, key: string, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void>;
+}
+/**
+ * A terminal that is created on the extension host side is temporarily assigned
+ * a UUID by the extension host that created it. Once the renderer side has assigned
+ * a real numeric id, the numeric id will be used.
+ *
+ * All other terminals (that are not created on the extension host side) always
+ * use the numeric id.
+ */
+type ExtHostTerminalIdentifier = number | string;
+interface MainThreadTelemetryShape extends IDisposable {
+    $publicLog(eventName: string, data?: any): void;
+    $publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
+}
+interface ExtHostManagedSocketsShape {
+    $openRemoteSocket(socketFactoryId: number): Promise<number>;
+    $remoteSocketWrite(socketId: number, buffer: VSBuffer): void;
+    $remoteSocketEnd(socketId: number): void;
+    $remoteSocketDrain(socketId: number): Promise<void>;
+}
+interface ITextSearchComplete {
+    limitHit?: boolean;
+}
+interface MainThreadWorkspaceShape extends IDisposable {
+    $startFileSearch(includePattern: string | null, includeFolder: UriComponents | null, excludePatternOrDisregardExcludes: string | false | null, maxResults: number | null, token: CancellationToken): Promise<UriComponents[] | null>;
+    $startTextSearch(query: IPatternInfo, folder: UriComponents | null, options: ITextQueryBuilderOptions, requestId: number, token: CancellationToken): Promise<ITextSearchComplete | null>;
+    $checkExists(folders: readonly UriComponents[], includes: string[], token: CancellationToken): Promise<boolean>;
+    $save(uri: UriComponents, options: {
+        saveAs: boolean;
+    }): Promise<UriComponents | undefined>;
+    $saveAll(includeUntitled?: boolean): Promise<boolean>;
+    $updateWorkspaceFolders(extensionName: string, index: number, deleteCount: number, workspaceFoldersToAdd: {
+        uri: UriComponents;
+        name?: string;
+    }[]): Promise<void>;
+    $resolveProxy(url: string): Promise<string | undefined>;
+    $requestWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Promise<boolean | undefined>;
+    $registerEditSessionIdentityProvider(handle: number, scheme: string): void;
+    $unregisterEditSessionIdentityProvider(handle: number): void;
+    $registerCanonicalUriProvider(handle: number, scheme: string): void;
+    $unregisterCanonicalUriProvider(handle: number): void;
+}
+interface MainThreadExtensionServiceShape extends IDisposable {
+    $getExtension(extensionId: string): Promise<Dto<IExtensionDescription> | undefined>;
+    $activateExtension(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+    $onWillActivateExtension(extensionId: ExtensionIdentifier): Promise<void>;
+    $onDidActivateExtension(extensionId: ExtensionIdentifier, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number, activationReason: ExtensionActivationReason): void;
+    $onExtensionActivationError(extensionId: ExtensionIdentifier, error: SerializedError, missingExtensionDependency: MissingExtensionDependency | null): Promise<void>;
+    $onExtensionRuntimeError(extensionId: ExtensionIdentifier, error: SerializedError): void;
+    $setPerformanceMarks(marks: PerformanceMark[]): Promise<void>;
+    $asBrowserUri(uri: UriComponents): Promise<UriComponents>;
+    $getAllStaticBrowserUris(): Promise<[UriComponents, UriComponents][]>;
+}
+interface PortAttributesSelector {
+    portRange?: [number, number] | number;
+    commandPattern?: RegExp;
+}
+interface ExtHostConfigurationShape {
+    $initializeConfiguration(data: IConfigurationInitData): void;
+    $acceptConfigurationChanged(data: IConfigurationInitData, change: IConfigurationChange): void;
+}
+interface ExtHostWorkspaceShape {
+    $initializeWorkspace(workspace: IWorkspaceData | null, trusted: boolean): void;
+    $acceptWorkspaceData(workspace: IWorkspaceData | null): void;
+    $handleTextSearchResult(result: IRawFileMatch2, requestId: number): void;
+    $onDidGrantWorkspaceTrust(): void;
+    $getEditSessionIdentifier(folder: UriComponents, token: CancellationToken): Promise<string | undefined>;
+    $provideEditSessionIdentityMatch(folder: UriComponents, identity1: string, identity2: string, token: CancellationToken): Promise<EditSessionIdentityMatch | undefined>;
+    $onWillCreateEditSessionIdentity(folder: UriComponents, token: CancellationToken, timeout: number): Promise<void>;
+    $provideCanonicalUri(uri: UriComponents, targetScheme: string, token: CancellationToken): Promise<UriComponents | undefined>;
+}
+interface ExtHostFileSystemInfoShape {
+    $acceptProviderInfos(uri: UriComponents, capabilities: number | null): void;
+}
+interface ExtHostExtensionServiceShape {
+    $resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<Dto<IResolveAuthorityResult>>;
+    /**
+     * Returns `null` if no resolver for `remoteAuthority` is found.
+     */
+    $getCanonicalURI(remoteAuthority: string, uri: UriComponents): Promise<UriComponents | null>;
+    $startExtensionHost(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    $extensionTestsExecute(): Promise<number>;
+    $activateByEvent(activationEvent: string, activationKind: ActivationKind): Promise<void>;
+    $activate(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<boolean>;
+    $setRemoteEnvironment(env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+    $updateRemoteConnectionData(connectionData: IRemoteConnectionData): Promise<void>;
+    $deltaExtensions(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    $test_latency(n: number): Promise<number>;
+    $test_up(b: VSBuffer): Promise<number>;
+    $test_down(size: number): Promise<VSBuffer>;
+}
+type ICommandDto = {
+    $ident?: string;
+} & Command;
+interface ITerminalLinkDto {
+    /** The ID of the link to enable activation and disposal. */
+    id: number;
+    /** The startIndex of the link in the line. */
+    startIndex: number;
+    /** The length of the link in the line. */
+    length: number;
+    /** The descriptive label for what the link does when activated. */
+    label?: string;
+}
+interface ITerminalDimensionsDto {
+    columns: number;
+    rows: number;
+}
+type SingleOrMany<T> = T[] | T;
+interface ITerminalQuickFixExecuteTerminalCommandDto {
+    terminalCommand: string;
+}
+interface ITerminalQuickFixOpenerDto {
+    uri: UriComponents;
+}
+type TerminalQuickFix = ITerminalQuickFixExecuteTerminalCommandDto | ITerminalQuickFixOpenerDto | ICommandDto;
+interface TerminalCommandMatchResultDto {
+    commandLine: string;
+    commandLineMatch: RegExpMatchArray;
+    outputMatch?: {
+        regexMatch: RegExpMatchArray;
+        outputLines: string[];
+    };
+}
+interface ITerminalCommandDto {
+    commandLine: string | undefined;
+    cwd: URI | string | undefined;
+    exitCode: number | undefined;
+    output: string | undefined;
+}
+interface ExtHostTerminalServiceShape {
+    $acceptTerminalClosed(id: number, exitCode: number | undefined, exitReason: TerminalExitReason): void;
+    $acceptTerminalOpened(id: number, extHostTerminalId: string | undefined, name: string, shellLaunchConfig: IShellLaunchConfigDto): void;
+    $acceptActiveTerminalChanged(id: number | null): void;
+    $acceptTerminalProcessId(id: number, processId: number): void;
+    $acceptTerminalProcessData(id: number, data: string): void;
+    $acceptDidExecuteCommand(id: number, command: ITerminalCommandDto): void;
+    $acceptTerminalTitleChange(id: number, name: string): void;
+    $acceptTerminalDimensions(id: number, cols: number, rows: number): void;
+    $acceptTerminalMaximumDimensions(id: number, cols: number, rows: number): void;
+    $acceptTerminalInteraction(id: number): void;
+    $acceptTerminalSelection(id: number, selection: string | undefined): void;
+    $startExtensionTerminal(id: number, initialDimensions: ITerminalDimensionsDto | undefined): Promise<ITerminalLaunchError | undefined>;
+    $acceptProcessAckDataEvent(id: number, charCount: number): void;
+    $acceptProcessInput(id: number, data: string): void;
+    $acceptProcessResize(id: number, cols: number, rows: number): void;
+    $acceptProcessShutdown(id: number, immediate: boolean): void;
+    $acceptProcessRequestInitialCwd(id: number): void;
+    $acceptProcessRequestCwd(id: number): void;
+    $acceptProcessRequestLatency(id: number): Promise<number>;
+    $provideLinks(id: number, line: string): Promise<ITerminalLinkDto[]>;
+    $activateLink(id: number, linkId: number): void;
+    $initEnvironmentVariableCollections(collections: [string, ISerializableEnvironmentVariableCollection][]): void;
+    $acceptDefaultProfile(profile: ITerminalProfile, automationProfile: ITerminalProfile): void;
+    $createContributedProfileTerminal(id: string, options: ICreateContributedTerminalProfileOptions): Promise<void>;
+    $provideTerminalQuickFixes(id: string, matchResult: TerminalCommandMatchResultDto, token: CancellationToken): Promise<SingleOrMany<TerminalQuickFix> | undefined>;
+}
+interface TunnelDto {
+    remoteAddress: {
+        port: number;
+        host: string;
+    };
+    localAddress: {
+        port: number;
+        host: string;
+    } | string;
+    public: boolean;
+    privacy: TunnelPrivacyId | string;
+    protocol: string | undefined;
+}
+interface ExtHostTunnelServiceShape {
+    $forwardPort(tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions): Promise<TunnelDto | string | undefined>;
+    $closeTunnel(remote: {
+        host: string;
+        port: number;
+    }, silent?: boolean): Promise<void>;
+    $onDidTunnelsChange(): Promise<void>;
+    $registerCandidateFinder(enable: boolean): Promise<void>;
+    $applyCandidateFilter(candidates: CandidatePort[]): Promise<CandidatePort[]>;
+    $providePortAttributes(handles: number[], ports: number[], pid: number | undefined, commandline: string | undefined, cancellationToken: CancellationToken): Promise<ProvidedPortAttributes[]>;
+}
+interface ExtHostLocalizationShape {
+    getMessage(extensionId: string, details: IStringDetails): string;
+    getBundle(extensionId: string): {
+        [key: string]: string;
+    } | undefined;
+    getBundleUri(extensionId: string): URI | undefined;
+    initializeLocalizedMessages(extension: IExtensionDescription): Promise<void>;
+}
+interface IStringDetails {
+    message: string;
+    args?: Record<string | number, any>;
+    comment?: string | string[];
+}
+
+export type { ExtHostConfigurationShape, ExtHostExtensionServiceShape, ExtHostFileSystemInfoShape, ExtHostLocalizationShape, ExtHostManagedSocketsShape, ExtHostTerminalIdentifier, ExtHostTerminalServiceShape, ExtHostTunnelServiceShape, ExtHostWorkspaceShape, ICommandDto, IConfigurationInitData, IStringDetails, ITerminalCommandDto, ITerminalDimensionsDto, ITerminalLinkDto, ITerminalQuickFixExecuteTerminalCommandDto, ITerminalQuickFixOpenerDto, ITextSearchComplete, IWorkspaceData, MainThreadConfigurationShape, MainThreadExtensionServiceShape, MainThreadTelemetryShape, MainThreadWorkspaceShape, PortAttributesSelector, TerminalCommandMatchResultDto, TerminalQuickFix, TunnelDto };

package/vscode/src/vs/workbench/api/common/extHostConfiguration.d.ts

@@ -0,0 +1,43 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import * as vscode from 'vscode';
+import { IExtHostWorkspace, ExtHostWorkspace } from './extHostWorkspace.js';
+import { ExtHostConfigurationShape, IConfigurationInitData, MainThreadConfigurationShape } from './extHost.protocol.js';
+import { IConfigurationChange } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+
+declare class ExtHostConfiguration implements ExtHostConfigurationShape {
+    readonly _serviceBrand: undefined;
+    private readonly _proxy;
+    private readonly _logService;
+    private readonly _extHostWorkspace;
+    private readonly _barrier;
+    private _actual;
+    constructor(extHostRpc: IExtHostRpcService, extHostWorkspace: IExtHostWorkspace, logService: ILogService);
+    getConfigProvider(): Promise<ExtHostConfigProvider>;
+    $initializeConfiguration(data: IConfigurationInitData): void;
+    $acceptConfigurationChanged(data: IConfigurationInitData, change: IConfigurationChange): void;
+}
+declare class ExtHostConfigProvider {
+    private readonly _onDidChangeConfiguration;
+    private readonly _proxy;
+    private readonly _extHostWorkspace;
+    private _configurationScopes;
+    private _configuration;
+    private _logService;
+    constructor(proxy: MainThreadConfigurationShape, extHostWorkspace: ExtHostWorkspace, data: IConfigurationInitData, logService: ILogService);
+    get onDidChangeConfiguration(): Event<vscode.ConfigurationChangeEvent>;
+    $acceptConfigurationChanged(data: IConfigurationInitData, change: IConfigurationChange): void;
+    getConfiguration(section?: string, scope?: vscode.ConfigurationScope | null, extensionDescription?: IExtensionDescription): vscode.WorkspaceConfiguration;
+    private _toReadonlyValue;
+    private _validateConfigurationAccess;
+    private _toConfigurationChangeEvent;
+    private _toMap;
+}
+declare const IExtHostConfiguration: ServiceIdentifier<IExtHostConfiguration>;
+interface IExtHostConfiguration extends ExtHostConfiguration {
+}
+
+export { ExtHostConfigProvider, ExtHostConfiguration, IExtHostConfiguration };

package/vscode/src/vs/workbench/api/common/extHostExtensionActivator.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Represents the API of an extension (return value of `activate`).
+ */
+interface IExtensionAPI {
+}
+declare class ExtensionActivationTimes {
+    static readonly NONE: ExtensionActivationTimes;
+    readonly startup: boolean;
+    readonly codeLoadingTime: number;
+    readonly activateCallTime: number;
+    readonly activateResolvedTime: number;
+    constructor(startup: boolean, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number);
+}
+declare class ExtensionActivationTimesBuilder {
+    private readonly _startup;
+    private _codeLoadingStart;
+    private _codeLoadingStop;
+    private _activateCallStart;
+    private _activateCallStop;
+    private _activateResolveStart;
+    private _activateResolveStop;
+    constructor(startup: boolean);
+    private _delta;
+    build(): ExtensionActivationTimes;
+    codeLoadingStart(): void;
+    codeLoadingStop(): void;
+    activateCallStart(): void;
+    activateCallStop(): void;
+    activateResolveStart(): void;
+    activateResolveStop(): void;
+}
+
+export { ExtensionActivationTimes, ExtensionActivationTimesBuilder, type IExtensionAPI };

package/vscode/src/vs/workbench/api/common/extHostExtensionService.d.ts

@@ -0,0 +1,138 @@
+import { IInstantiationService, ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { TernarySearchTree } from 'vscode/vscode/vs/base/common/ternarySearchTree';
+import { UriComponents, URI } from 'vscode/vscode/vs/base/common/uri';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { ExtHostExtensionServiceShape, MainThreadWorkspaceShape, MainThreadTelemetryShape, MainThreadExtensionServiceShape } from './extHost.protocol.js';
+import { IExtensionHostInitData, IExtensionDescriptionDelta } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
+import { ExtHostConfiguration, IExtHostConfiguration } from './extHostConfiguration.js';
+import { IExtensionAPI, ExtensionActivationTimesBuilder } from './extHostExtensionActivator.js';
+import { ExtHostWorkspace, IExtHostWorkspace } from './extHostWorkspace.js';
+import { ExtensionActivationReason, ActivationKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { ExtensionDescriptionRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry';
+import * as vscode from 'vscode';
+import { ExtensionIdentifier, IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { ExtensionRuntime } from './extHostTypes.js';
+import { IRemoteConnectionData } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { IExtensionStoragePaths } from './extHostStoragePaths.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { IExtHostTunnelService } from './extHostTunnelService.js';
+import { IExtHostTerminalService } from './extHostTerminalService.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { IResolveAuthorityResult } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProxy';
+import { IExtHostLocalizationService } from './extHostLocalizationService.js';
+import { IExtHostManagedSockets } from './extHostManagedSockets.js';
+import { Dto } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+
+declare const IHostUtils: ServiceIdentifier<IHostUtils>;
+interface IHostUtils {
+    readonly _serviceBrand: undefined;
+    readonly pid: number | undefined;
+    exit(code: number): void;
+    fsExists?(path: string): Promise<boolean>;
+    fsRealpath?(path: string): Promise<string>;
+}
+declare abstract class AbstractExtHostExtensionService extends Disposable implements ExtHostExtensionServiceShape {
+    private readonly _extHostManagedSockets;
+    readonly _serviceBrand: undefined;
+    abstract readonly extensionRuntime: ExtensionRuntime;
+    private readonly _onDidChangeRemoteConnectionData;
+    readonly onDidChangeRemoteConnectionData: Event<void>;
+    protected readonly _hostUtils: IHostUtils;
+    protected readonly _initData: IExtensionHostInitData;
+    protected readonly _extHostContext: IExtHostRpcService;
+    protected readonly _instaService: IInstantiationService;
+    protected readonly _extHostWorkspace: ExtHostWorkspace;
+    protected readonly _extHostConfiguration: ExtHostConfiguration;
+    protected readonly _logService: ILogService;
+    protected readonly _extHostTunnelService: IExtHostTunnelService;
+    protected readonly _extHostTerminalService: IExtHostTerminalService;
+    protected readonly _extHostLocalizationService: IExtHostLocalizationService;
+    protected readonly _mainThreadWorkspaceProxy: MainThreadWorkspaceShape;
+    protected readonly _mainThreadTelemetryProxy: MainThreadTelemetryShape;
+    protected readonly _mainThreadExtensionsProxy: MainThreadExtensionServiceShape;
+    private readonly _almostReadyToRunExtensions;
+    private readonly _readyToStartExtensionHost;
+    private readonly _readyToRunExtensions;
+    private readonly _eagerExtensionsActivated;
+    private readonly _activationEventsReader;
+    protected readonly _myRegistry: ExtensionDescriptionRegistry;
+    protected readonly _globalRegistry: ExtensionDescriptionRegistry;
+    private readonly _storage;
+    private readonly _secretState;
+    private readonly _storagePath;
+    private readonly _activator;
+    private _extensionPathIndex;
+    private readonly _resolvers;
+    private _started;
+    private _isTerminating;
+    private _remoteConnectionData;
+    constructor(instaService: IInstantiationService, hostUtils: IHostUtils, extHostContext: IExtHostRpcService, extHostWorkspace: IExtHostWorkspace, extHostConfiguration: IExtHostConfiguration, logService: ILogService, initData: IExtHostInitDataService, storagePath: IExtensionStoragePaths, extHostTunnelService: IExtHostTunnelService, extHostTerminalService: IExtHostTerminalService, extHostLocalizationService: IExtHostLocalizationService, _extHostManagedSockets: IExtHostManagedSockets);
+    getRemoteConnectionData(): IRemoteConnectionData | null;
+    initialize(): Promise<void>;
+    private _deactivateAll;
+    terminate(reason: string, code?: number): void;
+    isActivated(extensionId: ExtensionIdentifier): boolean;
+    getExtension(extensionId: string): Promise<IExtensionDescription | undefined>;
+    private _activateByEvent;
+    private _activateById;
+    activateByIdWithErrors(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+    getExtensionRegistry(): Promise<ExtensionDescriptionRegistry>;
+    getExtensionExports(extensionId: ExtensionIdentifier): IExtensionAPI | null | undefined;
+    /**
+     * Applies realpath to file-uris and returns all others uris unmodified
+     */
+    private _realPathExtensionUri;
+    getExtensionPathIndex(): Promise<ExtensionPaths>;
+    /**
+     * create trie to enable fast 'filename -> extension id' look up
+     */
+    private _createExtensionPathIndex;
+    private _deactivate;
+    private _activateExtension;
+    private _logExtensionActivationTimes;
+    private _doActivateExtension;
+    private _loadExtensionContext;
+    private static _callActivate;
+    private static _callActivateOptional;
+    private _activateOneStartupFinished;
+    private _activateAllStartupFinishedDeferred;
+    private _activateAllStartupFinished;
+    private _handleEagerExtensions;
+    private _handleWorkspaceContainsEagerExtensions;
+    private _handleWorkspaceContainsEagerExtension;
+    private _handleRemoteResolverEagerExtensions;
+    $extensionTestsExecute(): Promise<number>;
+    private _doHandleExtensionTests;
+    private _startExtensionHost;
+    registerRemoteAuthorityResolver(authorityPrefix: string, resolver: vscode.RemoteAuthorityResolver): vscode.Disposable;
+    getRemoteExecServer(remoteAuthority: string): Promise<vscode.ExecServer | undefined>;
+    private _activateAndGetResolver;
+    $resolveAuthority(remoteAuthorityChain: string, resolveAttempt: number): Promise<Dto<IResolveAuthorityResult>>;
+    $getCanonicalURI(remoteAuthority: string, uriComponents: UriComponents): Promise<UriComponents | null>;
+    $startExtensionHost(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    $activateByEvent(activationEvent: string, activationKind: ActivationKind): Promise<void>;
+    $activate(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<boolean>;
+    $deltaExtensions(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
+    $test_latency(n: number): Promise<number>;
+    $test_up(b: VSBuffer): Promise<number>;
+    $test_down(size: number): Promise<VSBuffer>;
+    $updateRemoteConnectionData(connectionData: IRemoteConnectionData): Promise<void>;
+    protected abstract _beforeAlmostReadyToRunExtensions(): Promise<void>;
+    protected abstract _getEntryPoint(extensionDescription: IExtensionDescription): string | undefined;
+    protected abstract _loadCommonJSModule<T extends object | undefined>(extensionId: IExtensionDescription | null, module: URI, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<T>;
+    abstract $setRemoteEnvironment(env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+}
+declare class ExtensionPaths {
+    private _searchTree;
+    constructor(_searchTree: TernarySearchTree<URI, IExtensionDescription>);
+    setSearchTree(searchTree: TernarySearchTree<URI, IExtensionDescription>): void;
+    findSubstr(key: URI): IExtensionDescription | undefined;
+    forEach(callback: (value: IExtensionDescription, index: URI) => any): void;
+}
+
+export { AbstractExtHostExtensionService, ExtensionPaths, IHostUtils };

package/vscode/src/vs/workbench/api/common/extHostFileSystemInfo.d.ts

@@ -0,0 +1,21 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IExtUri } from 'vscode/vscode/vs/base/common/resources';
+import { UriComponents } from 'vscode/vscode/vs/base/common/uri';
+import { ExtHostFileSystemInfoShape } from './extHost.protocol.js';
+
+declare class ExtHostFileSystemInfo implements ExtHostFileSystemInfoShape {
+    readonly _serviceBrand: undefined;
+    private readonly _systemSchemes;
+    private readonly _providerInfo;
+    readonly extUri: IExtUri;
+    constructor();
+    $acceptProviderInfos(uri: UriComponents, capabilities: number | null): void;
+    isFreeScheme(scheme: string): boolean;
+    getCapabilities(scheme: string): number | undefined;
+}
+interface IExtHostFileSystemInfo extends ExtHostFileSystemInfo {
+    readonly extUri: IExtUri;
+}
+declare const IExtHostFileSystemInfo: ServiceIdentifier<IExtHostFileSystemInfo>;
+
+export { ExtHostFileSystemInfo, IExtHostFileSystemInfo };

package/vscode/src/vs/workbench/api/common/extHostInitDataService.d.ts

@@ -0,0 +1,9 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IExtensionHostInitData } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
+
+declare const IExtHostInitDataService: ServiceIdentifier<IExtHostInitDataService>;
+interface IExtHostInitDataService extends Readonly<IExtensionHostInitData> {
+    readonly _serviceBrand: undefined;
+}
+
+export { IExtHostInitDataService };

package/vscode/src/vs/workbench/api/common/extHostLocalizationService.d.ts

@@ -0,0 +1,29 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { ExtHostLocalizationShape, IStringDetails } from './extHost.protocol.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+
+declare class ExtHostLocalizationService implements ExtHostLocalizationShape {
+    private readonly logService;
+    readonly _serviceBrand: undefined;
+    private readonly _proxy;
+    private readonly currentLanguage;
+    private readonly isDefaultLanguage;
+    private readonly bundleCache;
+    constructor(initData: IExtHostInitDataService, rpc: IExtHostRpcService, logService: ILogService);
+    getMessage(extensionId: string, details: IStringDetails): string;
+    getBundle(extensionId: string): {
+        [key: string]: string;
+    } | undefined;
+    getBundleUri(extensionId: string): URI | undefined;
+    initializeLocalizedMessages(extension: IExtensionDescription): Promise<void>;
+    private getBundleLocation;
+}
+declare const IExtHostLocalizationService: ServiceIdentifier<IExtHostLocalizationService>;
+interface IExtHostLocalizationService extends ExtHostLocalizationService {
+}
+
+export { ExtHostLocalizationService, IExtHostLocalizationService };

package/vscode/src/vs/workbench/api/common/extHostManagedSockets.d.ts

@@ -0,0 +1,11 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ExtHostManagedSocketsShape } from './extHost.protocol.js';
+import * as vscode from 'vscode';
+
+interface IExtHostManagedSockets extends ExtHostManagedSocketsShape {
+    setFactory(socketFactoryId: number, makeConnection: () => Thenable<vscode.ManagedMessagePassing>): void;
+    readonly _serviceBrand: undefined;
+}
+declare const IExtHostManagedSockets: ServiceIdentifier<IExtHostManagedSockets>;
+
+export { IExtHostManagedSockets };

package/vscode/src/vs/workbench/api/common/extHostRpcService.d.ts

@@ -0,0 +1,9 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IRPCProtocol } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+
+declare const IExtHostRpcService: ServiceIdentifier<IExtHostRpcService>;
+interface IExtHostRpcService extends IRPCProtocol {
+    readonly _serviceBrand: undefined;
+}
+
+export { IExtHostRpcService };

package/vscode/src/vs/workbench/api/common/extHostStoragePaths.d.ts

@@ -0,0 +1,14 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+
+declare const IExtensionStoragePaths: ServiceIdentifier<IExtensionStoragePaths>;
+interface IExtensionStoragePaths {
+    readonly _serviceBrand: undefined;
+    whenReady: Promise<any>;
+    workspaceValue(extension: IExtensionDescription): URI | undefined;
+    globalValue(extension: IExtensionDescription): URI;
+    onWillDeactivateAll(): void;
+}
+
+export { IExtensionStoragePaths };

package/vscode/src/vs/workbench/api/common/extHostTerminalService.d.ts

@@ -0,0 +1,53 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import * as vscode from 'vscode';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { ExtHostTerminalServiceShape, ExtHostTerminalIdentifier } from './extHost.protocol.js';
+import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { TerminalLocation } from 'vscode/vscode/vs/platform/terminal/common/terminal';
+
+interface IEnvironmentVariableCollection extends vscode.EnvironmentVariableCollection {
+    getScoped(scope: vscode.EnvironmentVariableScope): vscode.EnvironmentVariableCollection;
+}
+interface ITerminalInternalOptions {
+    isFeatureTerminal?: boolean;
+    useShellEnvironment?: boolean;
+    resolvedExtHostIdentifier?: ExtHostTerminalIdentifier;
+    /**
+     * This location is different from the API location because it can include splitActiveTerminal,
+     * a property we resolve internally
+     */
+    location?: TerminalLocation | {
+        viewColumn: number;
+        preserveState?: boolean;
+    } | {
+        splitActiveTerminal: boolean;
+    };
+}
+
+interface IExtHostTerminalService extends ExtHostTerminalServiceShape, IDisposable {
+    readonly _serviceBrand: undefined;
+    activeTerminal: vscode.Terminal | undefined;
+    terminals: vscode.Terminal[];
+    readonly onDidCloseTerminal: Event<vscode.Terminal>;
+    readonly onDidOpenTerminal: Event<vscode.Terminal>;
+    readonly onDidChangeActiveTerminal: Event<vscode.Terminal | undefined>;
+    readonly onDidChangeTerminalDimensions: Event<vscode.TerminalDimensionsChangeEvent>;
+    readonly onDidChangeTerminalState: Event<vscode.Terminal>;
+    readonly onDidWriteTerminalData: Event<vscode.TerminalDataWriteEvent>;
+    readonly onDidExecuteTerminalCommand: Event<vscode.TerminalExecutedCommand>;
+    readonly onDidChangeShell: Event<string>;
+    createTerminal(name?: string, shellPath?: string, shellArgs?: readonly string[] | string): vscode.Terminal;
+    createTerminalFromOptions(options: vscode.TerminalOptions, internalOptions?: ITerminalInternalOptions): vscode.Terminal;
+    createExtensionTerminal(options: vscode.ExtensionTerminalOptions): vscode.Terminal;
+    attachPtyToTerminal(id: number, pty: vscode.Pseudoterminal): void;
+    getDefaultShell(useAutomationShell: boolean): string;
+    getDefaultShellArgs(useAutomationShell: boolean): string[] | string;
+    registerLinkProvider(provider: vscode.TerminalLinkProvider): vscode.Disposable;
+    registerProfileProvider(extension: IExtensionDescription, id: string, provider: vscode.TerminalProfileProvider): vscode.Disposable;
+    registerTerminalQuickFixProvider(id: string, extensionId: string, provider: vscode.TerminalQuickFixProvider): vscode.Disposable;
+    getEnvironmentVariableCollection(extension: IExtensionDescription): IEnvironmentVariableCollection;
+}
+declare const IExtHostTerminalService: ServiceIdentifier<IExtHostTerminalService>;
+
+export { IExtHostTerminalService, type ITerminalInternalOptions };

package/vscode/src/vs/workbench/api/common/extHostTunnelService.d.ts

@@ -0,0 +1,19 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import * as vscode from 'vscode';
+import { TunnelOptions } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
+import { ExtHostTunnelServiceShape, PortAttributesSelector } from './extHost.protocol.js';
+
+interface IExtHostTunnelService extends ExtHostTunnelServiceShape {
+    readonly _serviceBrand: undefined;
+    openTunnel(extension: IExtensionDescription, forward: TunnelOptions): Promise<vscode.Tunnel | undefined>;
+    getTunnels(): Promise<vscode.TunnelDescription[]>;
+    onDidChangeTunnels: vscode.Event<void>;
+    setTunnelFactory(provider: vscode.RemoteAuthorityResolver | undefined, managedRemoteAuthority: vscode.ManagedResolvedAuthority | undefined): Promise<IDisposable>;
+    registerPortsAttributesProvider(portSelector: PortAttributesSelector, provider: vscode.PortAttributesProvider): IDisposable;
+    registerTunnelProvider(provider: vscode.TunnelProvider, information: vscode.TunnelInformation): Promise<IDisposable>;
+}
+declare const IExtHostTunnelService: ServiceIdentifier<IExtHostTunnelService>;
+
+export { IExtHostTunnelService };

package/vscode/src/vs/workbench/api/common/extHostTypes.d.ts

@@ -0,0 +1,12 @@
+declare enum ExtensionRuntime {
+    /**
+     * The extension is running in a NodeJS extension host. Runtime access to NodeJS APIs is available.
+     */
+    Node = 1,
+    /**
+     * The extension is running in a Webworker extension host. Runtime access is limited to Webworker APIs.
+     */
+    Webworker = 2
+}
+
+export { ExtensionRuntime };

package/vscode/src/vs/workbench/api/common/extHostUriTransformerService.d.ts

@@ -0,0 +1,9 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IURITransformer } from 'vscode/vscode/vs/base/common/uriIpc';
+
+interface IURITransformerService extends IURITransformer {
+    readonly _serviceBrand: undefined;
+}
+declare const IURITransformerService: ServiceIdentifier<IURITransformerService>;
+
+export { IURITransformerService };

package/vscode/src/vs/workbench/api/common/extHostWorkspace.d.ts

@@ -0,0 +1,91 @@
+import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { URI, UriComponents } from 'vscode/vscode/vs/base/common/uri';
+import { IExtensionDescription, ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { EditSessionIdentityMatch } from 'vscode/vscode/vs/platform/workspace/common/editSessions';
+import { Workspace } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IExtHostFileSystemInfo } from './extHostFileSystemInfo.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { IURITransformerService } from './extHostUriTransformerService.js';
+import { IRawFileMatch2 } from 'vscode/vscode/vs/workbench/services/search/common/search';
+import * as vscode from 'vscode';
+import { ExtHostWorkspaceShape, IWorkspaceData } from './extHost.protocol.js';
+
+interface IExtHostWorkspaceProvider {
+    getWorkspaceFolder2(uri: vscode.Uri, resolveParent?: boolean): Promise<vscode.WorkspaceFolder | undefined>;
+    resolveWorkspaceFolder(uri: vscode.Uri): Promise<vscode.WorkspaceFolder | undefined>;
+    getWorkspaceFolders2(): Promise<vscode.WorkspaceFolder[] | undefined>;
+    resolveProxy(url: string): Promise<string | undefined>;
+}
+declare class ExtHostWorkspace implements ExtHostWorkspaceShape, IExtHostWorkspaceProvider {
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChangeWorkspace;
+    readonly onDidChangeWorkspace: Event<vscode.WorkspaceFoldersChangeEvent>;
+    private readonly _onDidGrantWorkspaceTrust;
+    readonly onDidGrantWorkspaceTrust: Event<void>;
+    private readonly _logService;
+    private readonly _requestIdProvider;
+    private readonly _barrier;
+    private _confirmedWorkspace?;
+    private _unconfirmedWorkspace?;
+    private readonly _proxy;
+    private readonly _messageService;
+    private readonly _extHostFileSystemInfo;
+    private readonly _uriTransformerService;
+    private readonly _activeSearchCallbacks;
+    private _trusted;
+    private readonly _editSessionIdentityProviders;
+    constructor(extHostRpc: IExtHostRpcService, initData: IExtHostInitDataService, extHostFileSystemInfo: IExtHostFileSystemInfo, logService: ILogService, uriTransformerService: IURITransformerService);
+    $initializeWorkspace(data: IWorkspaceData | null, trusted: boolean): void;
+    waitForInitializeCall(): Promise<boolean>;
+    get workspace(): Workspace | undefined;
+    get name(): string | undefined;
+    get workspaceFile(): vscode.Uri | undefined;
+    private get _actualWorkspace();
+    getWorkspaceFolders(): vscode.WorkspaceFolder[] | undefined;
+    getWorkspaceFolders2(): Promise<vscode.WorkspaceFolder[] | undefined>;
+    updateWorkspaceFolders(extension: IExtensionDescription, index: number, deleteCount: number, ...workspaceFoldersToAdd: {
+        uri: vscode.Uri;
+        name?: string;
+    }[]): boolean;
+    getWorkspaceFolder(uri: vscode.Uri, resolveParent?: boolean): vscode.WorkspaceFolder | undefined;
+    getWorkspaceFolder2(uri: vscode.Uri, resolveParent?: boolean): Promise<vscode.WorkspaceFolder | undefined>;
+    resolveWorkspaceFolder(uri: vscode.Uri): Promise<vscode.WorkspaceFolder | undefined>;
+    getPath(): string | undefined;
+    getRelativePath(pathOrUri: string | vscode.Uri, includeWorkspace?: boolean): string;
+    private trySetWorkspaceFolders;
+    $acceptWorkspaceData(data: IWorkspaceData | null): void;
+    /**
+     * Note, null/undefined have different and important meanings for "exclude"
+     */
+    findFiles(include: vscode.GlobPattern | undefined, exclude: vscode.GlobPattern | null | undefined, maxResults: number | undefined, extensionId: ExtensionIdentifier, token?: vscode.CancellationToken): Promise<vscode.Uri[]>;
+    findTextInFiles(query: vscode.TextSearchQuery, options: vscode.FindTextInFilesOptions, callback: (result: vscode.TextSearchResult) => void, extensionId: ExtensionIdentifier, token?: vscode.CancellationToken): Promise<vscode.TextSearchComplete>;
+    $handleTextSearchResult(result: IRawFileMatch2, requestId: number): void;
+    save(uri: URI): Promise<URI | undefined>;
+    saveAs(uri: URI): Promise<URI | undefined>;
+    saveAll(includeUntitled?: boolean): Promise<boolean>;
+    resolveProxy(url: string): Promise<string | undefined>;
+    get trusted(): boolean;
+    requestWorkspaceTrust(options?: vscode.WorkspaceTrustRequestOptions): Promise<boolean | undefined>;
+    $onDidGrantWorkspaceTrust(): void;
+    private _providerHandlePool;
+    registerEditSessionIdentityProvider(scheme: string, provider: vscode.EditSessionIdentityProvider): IDisposable;
+    $getEditSessionIdentifier(workspaceFolder: UriComponents, cancellationToken: CancellationToken): Promise<string | undefined>;
+    $provideEditSessionIdentityMatch(workspaceFolder: UriComponents, identity1: string, identity2: string, cancellationToken: CancellationToken): Promise<EditSessionIdentityMatch | undefined>;
+    private readonly _onWillCreateEditSessionIdentityEvent;
+    getOnWillCreateEditSessionIdentityEvent(extension: IExtensionDescription): Event<vscode.EditSessionIdentityWillCreateEvent>;
+    $onWillCreateEditSessionIdentity(workspaceFolder: UriComponents, token: CancellationToken, timeout: number): Promise<void>;
+    private readonly _canonicalUriProviders;
+    registerCanonicalUriProvider(scheme: string, provider: vscode.CanonicalUriProvider): IDisposable;
+    provideCanonicalUri(uri: URI, options: vscode.CanonicalUriRequestOptions, cancellationToken: CancellationToken): Promise<URI | undefined>;
+    $provideCanonicalUri(uri: UriComponents, targetScheme: string, cancellationToken: CancellationToken): Promise<UriComponents | undefined>;
+}
+declare const IExtHostWorkspace: ServiceIdentifier<IExtHostWorkspace>;
+interface IExtHostWorkspace extends ExtHostWorkspace, ExtHostWorkspaceShape, IExtHostWorkspaceProvider {
+}
+
+export { ExtHostWorkspace, IExtHostWorkspace, type IExtHostWorkspaceProvider };

package/vscode/src/vs/workbench/api/worker/extHostExtensionService.d.ts

@@ -0,0 +1,21 @@
+import { IExtensionApiFactory } from '../common/extHost.api.impl.js';
+import { ExtensionActivationTimesBuilder } from '../common/extHostExtensionActivator.js';
+import { AbstractExtHostExtensionService } from '../common/extHostExtensionService.js';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { ExtensionRuntime } from '../common/extHostTypes.js';
+
+declare class ExtHostExtensionService extends AbstractExtHostExtensionService {
+    readonly extensionRuntime = ExtensionRuntime.Webworker;
+    private _fakeModules?;
+    protected _apiFactory?: IExtensionApiFactory;
+    protected _beforeAlmostReadyToRunExtensions(): Promise<void>;
+    protected _getEntryPoint(extensionDescription: IExtensionDescription): string | undefined;
+    protected _loadCommonJSModule<T extends object | undefined>(extension: IExtensionDescription | null, module: URI, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<T>;
+    $setRemoteEnvironment(_env: {
+        [key: string]: string | null;
+    }): Promise<void>;
+    private _waitForDebuggerAttachment;
+}
+
+export { ExtHostExtensionService };

package/vscode/src/vs/workbench/services/search/common/queryBuilder.d.ts

@@ -0,0 +1,35 @@
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { ITextSearchPreviewOptions } from 'vscode/vscode/vs/workbench/services/search/common/search';
+
+interface ICommonQueryBuilderOptions {
+    _reason?: string;
+    excludePattern?: string | string[];
+    includePattern?: string | string[];
+    extraFileResources?: URI[];
+    /** Parse the special ./ syntax supported by the searchview, and expand foo to ** /foo */
+    expandPatterns?: boolean;
+    maxResults?: number;
+    maxFileSize?: number;
+    disregardIgnoreFiles?: boolean;
+    disregardGlobalIgnoreFiles?: boolean;
+    disregardParentIgnoreFiles?: boolean;
+    disregardExcludeSettings?: boolean;
+    disregardSearchExcludeSettings?: boolean;
+    ignoreSymlinks?: boolean;
+    onlyOpenEditors?: boolean;
+}
+interface ITextQueryBuilderOptions extends ICommonQueryBuilderOptions {
+    previewOptions?: ITextSearchPreviewOptions;
+    fileEncoding?: string;
+    beforeContext?: number;
+    afterContext?: number;
+    isSmartCase?: boolean;
+    notebookSearchConfig?: {
+        includeMarkupInput: boolean;
+        includeMarkupPreview: boolean;
+        includeCodeInput: boolean;
+        includeOutput: boolean;
+    };
+}
+
+export type { ITextQueryBuilderOptions };