@codingame/monaco-vscode-api 21.0.1 → 21.2.0

package/extensions.d.ts

@@ -34,7 +34,7 @@ export interface RegisterLocalProcessExtensionResult extends RegisterLocalExtens
     setAsDefaultApi(): Promise<void>;
 }
 export declare function registerRemoteExtension(directory: string): Promise<RegisterRemoteExtensionResult>;
-export declare function getExtensionManifests(): IExtension[];
+export declare function getBuiltinExtensions(): IExtension[];
 export declare function getForcedExtensionHostKind(id: string): ExtensionHostKind | undefined;
 export declare function registerExtension(manifest: IExtensionManifest, extHostKind: ExtensionHostKind.LocalProcess, params?: RegisterExtensionParams): RegisterLocalProcessExtensionResult;
 export declare function registerExtension(manifest: IExtensionManifest, extHostKind: ExtensionHostKind.LocalWebWorker, params?: RegisterExtensionParams): RegisterLocalExtensionResult;

package/extensions.js

@@ -17,9 +17,10 @@ import { ExtensionManifestTranslator } from './vscode/src/vs/platform/extensionM
 import { language } from './vscode/src/vs/base/common/platform.js';
 import '@codingame/monaco-vscode-extensions-service-override';
 import { registerExtensionFile, RegisteredUriFile, CustomSchemas } from '@codingame/monaco-vscode-files-service-override';
-import { waitServicesReady } from './lifecycle.js';
+import { waitServicesReady, servicesInitialized } from './lifecycle.js';
 import { throttle } from './tools.js';
 import { getBuiltInExtensionTranslationsUris, getLocalizationManifest } from './l10n.js';
+import { toExtensionDescription } from './vscode/src/vs/workbench/services/extensions/common/extensions.js';
 
 let apiFactory;
 function registerLocalApiFactory(_apiFactory) {
@@ -50,9 +51,9 @@ async function registerRemoteExtension(directory) {
     return registerExtension(manifest, ExtensionHostKind.Remote, { path: directory });
 }
 const forcedExtensionHostKinds = new Map();
-const extensions = [];
-function getExtensionManifests() {
-    return extensions;
+const builtinExtensions = [];
+function getBuiltinExtensions() {
+    return builtinExtensions;
 }
 function getForcedExtensionHostKind(id) {
     return forcedExtensionHostKinds.get(id);
@@ -60,48 +61,57 @@ function getForcedExtensionHostKind(id) {
 function registerExtension(manifest, extHostKind, { path = '/extension', system = false, readmePath, changelogPath } = {}) {
     const id = getExtensionId(manifest.publisher, manifest.name);
     const location = URI.from({ scheme: CustomSchemas.extensionFile, authority: id, path });
-    const addExtensionPromise = (async () => {
-        await waitServicesReady();
-        const remoteAuthority = StandaloneServices.get(IWorkbenchEnvironmentService).remoteAuthority;
-        let realLocation = location;
-        if (extHostKind === ExtensionHostKind.Remote) {
-            realLocation = URI.from({ scheme: Schemas.vscodeRemote, authority: remoteAuthority, path });
-        }
-        const instantiationService = StandaloneServices.get(IInstantiationService);
-        const translator = instantiationService.createInstance(ExtensionManifestTranslator);
-        const nlsConfiguration = {
-            devMode: false,
-            language: language,
-            pseudo: language === 'pseudo',
-            translations: getBuiltInExtensionTranslationsUris(language) ?? {}
-        };
-        const localizedManifest = await translator.translateManifest(realLocation, manifest, nlsConfiguration);
-        const extension = {
-            manifest: localizedManifest,
-            type: system ? ExtensionType.System : ExtensionType.User,
-            isBuiltin: true,
-            identifier: { id },
-            location: realLocation,
-            targetPlatform: TargetPlatform.WEB,
-            isValid: true,
-            validations: [],
-            extHostKind,
-            readmeUrl: readmePath != null ? URI.joinPath(realLocation, readmePath) : undefined,
-            changelogUrl: changelogPath != null ? URI.joinPath(realLocation, changelogPath) : undefined,
-            preRelease: false
-        };
-        if (extHostKind != null) {
-            forcedExtensionHostKinds.set(id, extHostKind);
-        }
-        if (extHostKind !== ExtensionHostKind.Remote) {
-            extensions.push(extension);
-        }
-        const extensionEnablementService = StandaloneServices.get(IWorkbenchExtensionEnablementService);
-        if (extensionEnablementService.isEnabled(extension)) {
-            await deltaExtensions({ toAdd: [extension], toRemove: [] });
-        }
-        return extension;
-    })();
+    let addExtensionPromise = waitServicesReady();
+    const extension = {
+        manifest,
+        type: system ? ExtensionType.System : ExtensionType.User,
+        isBuiltin: true,
+        identifier: { id },
+        location,
+        targetPlatform: TargetPlatform.WEB,
+        isValid: true,
+        validations: [],
+        readmeUrl: readmePath != null ? URI.joinPath(location, readmePath) : undefined,
+        changelogUrl: changelogPath != null ? URI.joinPath(location, changelogPath) : undefined,
+        preRelease: false
+    };
+    if (extHostKind != null) {
+        forcedExtensionHostKinds.set(id, extHostKind);
+    }
+    if (!servicesInitialized && extHostKind !== ExtensionHostKind.Remote) {
+        builtinExtensions.push(extension);
+    }
+    else {
+        addExtensionPromise = addExtensionPromise.then(async () => {
+            const instantiationService = StandaloneServices.get(IInstantiationService);
+            const extensionEnablementService = StandaloneServices.get(IWorkbenchExtensionEnablementService);
+            const extensionService = StandaloneServices.get(IExtensionService);
+            if (extensionEnablementService.isEnabled(extension) &&
+                extensionService.canAddExtension(toExtensionDescription(extension, false))) {
+                const remoteAuthority = StandaloneServices.get(IWorkbenchEnvironmentService).remoteAuthority;
+                let realLocation = location;
+                if (extHostKind === ExtensionHostKind.Remote) {
+                    realLocation = URI.from({
+                        scheme: Schemas.vscodeRemote,
+                        authority: remoteAuthority,
+                        path
+                    });
+                }
+                const translator = instantiationService.createInstance(ExtensionManifestTranslator);
+                const nlsConfiguration = {
+                    devMode: false,
+                    language: language,
+                    pseudo: language === 'pseudo',
+                    translations: getBuiltInExtensionTranslationsUris(language) ?? {}
+                };
+                const localizedExtension = {
+                    ...extension,
+                    manifest: await translator.translateManifest(realLocation, manifest, nlsConfiguration)
+                };
+                await deltaExtensions({ toAdd: [localizedExtension], toRemove: [] });
+            }
+        });
+    }
     let api = {
         id,
         async whenReady() {
@@ -110,14 +120,14 @@ function registerExtension(manifest, extHostKind, { path = '/extension', system
         async isEnabled() {
             await waitServicesReady();
             const extensionEnablementService = StandaloneServices.get(IWorkbenchExtensionEnablementService);
-            const extension = await addExtensionPromise;
+            await addExtensionPromise;
             return extensionEnablementService.isEnabled(extension);
         },
         async dispose() {
-            const extension = await addExtensionPromise;
-            const index = extensions.indexOf(extension);
+            await addExtensionPromise;
+            const index = builtinExtensions.indexOf(extension);
             if (index >= 0) {
-                extensions.splice(extensions.indexOf(extension), 1);
+                builtinExtensions.splice(builtinExtensions.indexOf(extension), 1);
             }
             forcedExtensionHostKinds.delete(id);
             await deltaExtensions({ toAdd: [], toRemove: [extension] });
@@ -155,4 +165,4 @@ if (localizationManifest != null) {
     registerExtension(localizationManifest, ExtensionHostKind.LocalWebWorker, { system: true });
 }
 
-export { ExtensionHostKind, getExtensionManifests, getForcedExtensionHostKind, registerDefaultApiHandler, registerExtension, registerLocalApiFactory, registerRemoteExtension };
+export { ExtensionHostKind, getBuiltinExtensions, getForcedExtensionHostKind, registerDefaultApiHandler, registerExtension, registerLocalApiFactory, registerRemoteExtension };

package/lifecycle.d.ts

@@ -12,6 +12,7 @@ export declare function registerServiceInitializePreParticipant(participant: Ser
 export declare function registerServiceInitializeParticipant(participant: ServiceInitializeParticipant): void;
 export declare function registerServiceInitializePostParticipant(participant: ServiceInitializeParticipant): void;
 export declare function startup(instantiationService: IInstantiationService): Promise<void>;
+export declare let servicesInitialized: boolean;
 export declare function waitServicesReady(): Promise<void>;
 export declare function checkServicesReady(): void;
 export declare function checkServicesNotInitialized(): void;

package/lifecycle.js

@@ -90,4 +90,4 @@ function checkServicesNotInitialized() {
     }
 }
 
-export { checkServicesNotInitialized, checkServicesReady, onLayout, onRenderWorkbench, registerServiceInitializeParticipant, registerServiceInitializePostParticipant, registerServiceInitializePreParticipant, serviceInitializedBarrier, serviceInitializedEmitter, startup, waitServicesReady };
+export { checkServicesNotInitialized, checkServicesReady, onLayout, onRenderWorkbench, registerServiceInitializeParticipant, registerServiceInitializePostParticipant, registerServiceInitializePreParticipant, serviceInitializedBarrier, serviceInitializedEmitter, servicesInitialized, startup, waitServicesReady };

package/missing-services.js

@@ -2421,9 +2421,9 @@ registerSingleton(IWebExtensionsScannerService, WebExtensionsScannerService, Ins
 class ExtensionsScannerService {
     constructor() {
         this.onDidChangeCache = Event.None;
-        this.scanAllExtensions = unsupported;
-        this.scanSystemExtensions = unsupported;
-        this.scanUserExtensions = unsupported;
+        this.scanAllExtensions = async () => [];
+        this.scanSystemExtensions = async () => [];
+        this.scanUserExtensions = async () => [];
         this.scanExtensionsUnderDevelopment = unsupported;
         this.scanExistingExtension = unsupported;
         this.scanOneOrMultipleExtensions = unsupported;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "21.0.1",
+  "version": "21.2.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
@@ -15,13 +15,13 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-base-service-override": "21.0.1",
-    "@codingame/monaco-vscode-environment-service-override": "21.0.1",
-    "@codingame/monaco-vscode-extensions-service-override": "21.0.1",
-    "@codingame/monaco-vscode-files-service-override": "21.0.1",
-    "@codingame/monaco-vscode-host-service-override": "21.0.1",
-    "@codingame/monaco-vscode-layout-service-override": "21.0.1",
-    "@codingame/monaco-vscode-quickaccess-service-override": "21.0.1",
+    "@codingame/monaco-vscode-base-service-override": "21.2.0",
+    "@codingame/monaco-vscode-environment-service-override": "21.2.0",
+    "@codingame/monaco-vscode-extensions-service-override": "21.2.0",
+    "@codingame/monaco-vscode-files-service-override": "21.2.0",
+    "@codingame/monaco-vscode-host-service-override": "21.2.0",
+    "@codingame/monaco-vscode-layout-service-override": "21.2.0",
+    "@codingame/monaco-vscode-quickaccess-service-override": "21.2.0",
     "@vscode/iconv-lite-umd": "0.7.0",
     "dompurify": "3.2.6",
     "jschardet": "3.1.4",

package/services.d.ts

@@ -5,7 +5,7 @@ import { type IEditorOverrideServices } from "./vscode/src/vs/editor/standalone/
 import { type GetLeadingNonServiceArgs, type ServiceIdentifier, type ServicesAccessor } from "./vscode/src/vs/platform/instantiation/common/instantiation.js";
 import type { IAction } from "./vscode/src/vs/base/common/actions.js";
 import { type IDisposable } from "./vscode/src/vs/base/common/lifecycle.js";
-import type { IWorkbenchConstructionOptions, IWorkspaceProvider } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/browser/web.api";
+import type { IWorkbenchConstructionOptions, IWorkspaceProvider } from "./vscode/src/vs/workbench/browser/web.api.js";
 import { type ILazyWorkbenchContributionInstantiation, type IOnEditorWorkbenchContributionInstantiation, type WorkbenchContributionInstantiation, WorkbenchPhase } from "./vscode/src/vs/workbench/common/contributions.js";
 import { IProductService } from "./vscode/src/vs/platform/product/common/productService.service.js";
 import type { IConfigurationChangeEvent } from "./vscode/src/vs/platform/configuration/common/configuration.js";

package/services.js

@@ -110,6 +110,10 @@ import getServiceOverride from '@codingame/monaco-vscode-base-service-override';
 import { injectCss } from './css.js';
 import product from './vscode/src/vs/platform/product/common/product.js';
 import { mixin } from './vscode/src/vs/base/common/objects.js';
+import { CommandsRegistry } from './vscode/src/vs/platform/commands/common/commands.js';
+import { asArray } from './vscode/src/vs/base/common/arrays.js';
+import { MenuId, MenuRegistry } from './vscode/src/vs/platform/actions/common/actions.js';
+import { Menu } from './vscode/src/vs/workbench/browser/web.api.js';
 export { SyncDescriptor } from './vscode/src/vs/platform/instantiation/common/descriptors.js';
 export { ICommandService } from './vscode/src/vs/platform/commands/common/commands.service.js';
 export { INotificationService } from './vscode/src/vs/platform/notification/common/notification.service.js';
@@ -396,13 +400,38 @@ export { IInlineCompletionsUnificationService } from './vscode/src/vs/workbench/
 export { IMcpGalleryManifestService } from './vscode/src/vs/platform/mcp/common/mcpGalleryManifest.service.js';
 export { IDataChannelService } from './vscode/src/vs/platform/dataChannel/common/dataChannel.service.js';
 
-if (window.monacoVscodeApiBuildId != null && window.monacoVscodeApiBuildId !== "1.104.0-eda71d57-3503-4259-a8db-a8d5c3ea0616") {
-    throw new Error(`Another version of monaco-vscode-api has already been loaded. Trying to load ${"1.104.0-eda71d57-3503-4259-a8db-a8d5c3ea0616"}, ${window.monacoVscodeApiBuildId} is already loaded`);
+if (window.monacoVscodeApiBuildId != null && window.monacoVscodeApiBuildId !== "1.104.1-49b6ad53-ed25-4c36-80e9-5733bcd9f61d") {
+    throw new Error(`Another version of monaco-vscode-api has already been loaded. Trying to load ${"1.104.1-49b6ad53-ed25-4c36-80e9-5733bcd9f61d"}, ${window.monacoVscodeApiBuildId} is already loaded`);
+}
+window.monacoVscodeApiBuildId = "1.104.1-49b6ad53-ed25-4c36-80e9-5733bcd9f61d";
+function registerCommands(options) {
+    function asMenuId(menu) {
+        switch (menu) {
+            case Menu.CommandPalette:
+                return MenuId.CommandPalette;
+            case Menu.StatusBarWindowIndicatorMenu:
+                return MenuId.StatusBarWindowIndicatorMenu;
+        }
+    }
+    if (Array.isArray(options.commands)) {
+        for (const command of options.commands) {
+            CommandsRegistry.registerCommand(command.id, (accessor, ...args) => {
+                return command.handler(...args);
+            });
+            if (command.label) {
+                for (const menu of asArray(command.menu ?? Menu.CommandPalette)) {
+                    MenuRegistry.appendMenuItem(asMenuId(menu), {
+                        command: { id: command.id, title: command.label }
+                    });
+                }
+            }
+        }
+    }
 }
-window.monacoVscodeApiBuildId = "1.104.0-eda71d57-3503-4259-a8db-a8d5c3ea0616";
 async function initialize(overrides, container = document.body, configuration = {}, env) {
     checkServicesNotInitialized();
     injectCss(container);
+    registerCommands(configuration);
     initialize$1(container, configuration, env);
     const productService = mixin({ _serviceBrand: undefined, ...product }, configuration.productConfiguration);
     const instantiationService = StandaloneServices.initialize({

package/vscode/src/vs/platform/extensionManagement/common/extensionsScannerService.d.ts

@@ -13,6 +13,7 @@ import { IExtensionsProfileScannerService } from "./extensionsProfileScannerServ
 import { IUserDataProfile } from "../../userDataProfile/common/userDataProfile.js";
 import { IUserDataProfilesService } from "../../userDataProfile/common/userDataProfile.service.js";
 import { IUriIdentityService } from "../../uriIdentity/common/uriIdentity.service.js";
+import { IExtensionResourceLoaderService } from "../../extensionResourceLoader/common/extensionResourceLoader.service.js";
 import { IExtensionsScannerService } from "./extensionsScannerService.service.js";
 export type ManifestMetadata = Partial<{
     targetPlatform: TargetPlatform;
@@ -68,6 +69,7 @@ export declare abstract class AbstractExtensionsScannerService extends Disposabl
     private readonly extensionsControlLocation;
     private readonly userDataProfilesService;
     protected readonly extensionsProfileScannerService: IExtensionsProfileScannerService;
+    protected readonly extensionResourceLoaderService: IExtensionResourceLoaderService;
     protected readonly fileService: IFileService;
     protected readonly logService: ILogService;
     private readonly environmentService;
@@ -81,7 +83,7 @@ export declare abstract class AbstractExtensionsScannerService extends Disposabl
     private readonly systemExtensionsCachedScanner;
     private readonly userExtensionsCachedScanner;
     private readonly extensionsScanner;
-    constructor(systemExtensionsLocation: URI, userExtensionsLocation: URI, extensionsControlLocation: URI, currentProfile: IUserDataProfile, userDataProfilesService: IUserDataProfilesService, extensionsProfileScannerService: IExtensionsProfileScannerService, fileService: IFileService, logService: ILogService, environmentService: IEnvironmentService, productService: IProductService, uriIdentityService: IUriIdentityService, instantiationService: IInstantiationService);
+    constructor(systemExtensionsLocation: URI, userExtensionsLocation: URI, extensionsControlLocation: URI, currentProfile: IUserDataProfile, userDataProfilesService: IUserDataProfilesService, extensionsProfileScannerService: IExtensionsProfileScannerService, extensionResourceLoaderService: IExtensionResourceLoaderService, fileService: IFileService, logService: ILogService, environmentService: IEnvironmentService, productService: IProductService, uriIdentityService: IUriIdentityService, instantiationService: IInstantiationService);
     private _targetPlatformPromise;
     private getTargetPlatform;
     scanAllExtensions(systemScanOptions: SystemExtensionsScanOptions, userScanOptions: UserExtensionsScanOptions): Promise<IScannedExtension[]>;
@@ -134,9 +136,10 @@ export type NlsConfiguration = {
     translations: Translations;
 };
 export declare class ExtensionManifestTranslator extends Disposable {
+    protected readonly extensionResourceLoaderService: IExtensionResourceLoaderService;
     protected readonly fileService: IFileService;
     protected readonly logService: ILogService;
-    constructor(fileService: IFileService, logService: ILogService);
+    constructor(extensionResourceLoaderService: IExtensionResourceLoaderService, fileService: IFileService, logService: ILogService);
     private getLocalizedMessages;
     translateManifest(extensionLocation: URI, extensionManifest: IExtensionManifest, nlsConfiguration: NlsConfiguration): Promise<IExtensionManifest>;
     /**
@@ -153,7 +156,7 @@ export declare class ExtensionManifestTranslator extends Disposable {
 export declare function toExtensionDescription(extension: IScannedExtension, isUnderDevelopment: boolean): IExtensionDescription;
 export declare class NativeExtensionsScannerService extends AbstractExtensionsScannerService implements IExtensionsScannerService {
     private readonly translationsPromise;
-    constructor(systemExtensionsLocation: URI, userExtensionsLocation: URI, userHome: URI, currentProfile: IUserDataProfile, userDataProfilesService: IUserDataProfilesService, extensionsProfileScannerService: IExtensionsProfileScannerService, fileService: IFileService, logService: ILogService, environmentService: IEnvironmentService, productService: IProductService, uriIdentityService: IUriIdentityService, instantiationService: IInstantiationService);
+    constructor(systemExtensionsLocation: URI, userExtensionsLocation: URI, userHome: URI, currentProfile: IUserDataProfile, userDataProfilesService: IUserDataProfilesService, extensionsProfileScannerService: IExtensionsProfileScannerService, extensionResourceLoaderService: IExtensionResourceLoaderService, fileService: IFileService, logService: ILogService, environmentService: IEnvironmentService, productService: IProductService, uriIdentityService: IUriIdentityService, instantiationService: IInstantiationService);
     protected getTranslations(language: string): Promise<Translations>;
 }
 export {};

package/vscode/src/vs/platform/extensionManagement/common/extensionsScannerService.js

@@ -32,6 +32,7 @@ import { IExtensionsProfileScannerService } from './extensionsProfileScannerServ
 import { IUserDataProfilesService } from '../../userDataProfile/common/userDataProfile.service.js';
 import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.service.js';
 import { localizeManifest } from './extensionNls.js';
+import { IExtensionResourceLoaderService } from '../../extensionResourceLoader/common/extensionResourceLoader.service.js';
 
 var Translations;
 (function (Translations) {
@@ -58,13 +59,14 @@ var Translations;
     Translations.equals = equals;
 })(Translations || (Translations = {}));
 let AbstractExtensionsScannerService = class AbstractExtensionsScannerService extends Disposable {
-    constructor(systemExtensionsLocation, userExtensionsLocation, extensionsControlLocation, currentProfile, userDataProfilesService, extensionsProfileScannerService, fileService, logService, environmentService, productService, uriIdentityService, instantiationService) {
+    constructor(systemExtensionsLocation, userExtensionsLocation, extensionsControlLocation, currentProfile, userDataProfilesService, extensionsProfileScannerService, extensionResourceLoaderService, fileService, logService, environmentService, productService, uriIdentityService, instantiationService) {
         super();
         this.systemExtensionsLocation = systemExtensionsLocation;
         this.userExtensionsLocation = userExtensionsLocation;
         this.extensionsControlLocation = extensionsControlLocation;
         this.userDataProfilesService = userDataProfilesService;
         this.extensionsProfileScannerService = extensionsProfileScannerService;
+        this.extensionResourceLoaderService = extensionResourceLoaderService;
         this.fileService = fileService;
         this.logService = logService;
         this.environmentService = environmentService;
@@ -169,7 +171,7 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
     }
     async updateManifestMetadata(extensionLocation, metaData) {
         const manifestLocation = joinPath(extensionLocation, 'package.json');
-        const content = ( (await this.fileService.readFile(manifestLocation)).value.toString());
+        const content = await this.extensionResourceLoaderService.readExtensionResource(manifestLocation);
         const manifest = JSON.parse(content);
         manifest.__metadata = { ...manifest.__metadata, ...metaData };
         await this.fileService.writeFile(joinPath(extensionLocation, 'package.json'), VSBuffer.fromString(JSON.stringify(manifest, null, '\t')));
@@ -388,12 +390,13 @@ let AbstractExtensionsScannerService = class AbstractExtensionsScannerService ex
 AbstractExtensionsScannerService = ( __decorate([
     ( __param(4, IUserDataProfilesService)),
     ( __param(5, IExtensionsProfileScannerService)),
-    ( __param(6, IFileService)),
-    ( __param(7, ILogService)),
-    ( __param(8, IEnvironmentService)),
-    ( __param(9, IProductService)),
-    ( __param(10, IUriIdentityService)),
-    ( __param(11, IInstantiationService))
+    ( __param(6, IExtensionResourceLoaderService)),
+    ( __param(7, IFileService)),
+    ( __param(8, ILogService)),
+    ( __param(9, IEnvironmentService)),
+    ( __param(10, IProductService)),
+    ( __param(11, IUriIdentityService)),
+    ( __param(12, IInstantiationService))
 ], AbstractExtensionsScannerService));
 class ExtensionScannerInput {
     constructor(location, mtime, applicationExtensionslocation, applicationExtensionslocationMtime, profile, profileScanOptions, type, validate, productVersion, productDate, productCommit, devMode, language, translations) {
@@ -438,8 +441,9 @@ class ExtensionScannerInput {
     }
 }
 let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disposable {
-    constructor(fileService, logService) {
+    constructor(extensionResourceLoaderService, fileService, logService) {
         super();
+        this.extensionResourceLoaderService = extensionResourceLoaderService;
         this.fileService = fileService;
         this.logService = logService;
     }
@@ -463,7 +467,7 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
         if (translationPath) {
             try {
                 const translationResource = ( URI.parse(translationPath));
-                const content = ( (await this.fileService.readFile(translationResource)).value.toString());
+                const content = await this.extensionResourceLoaderService.readExtensionResource(translationResource);
                 const errors = [];
                 const translationBundle = parse(content, errors);
                 if (errors.length > 0) {
@@ -499,7 +503,7 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
                 return { values: undefined, default: messageBundle.original };
             }
             try {
-                const messageBundleContent = ( (await this.fileService.readFile(messageBundle.localized)).value.toString());
+                const messageBundleContent = (await this.extensionResourceLoaderService.readExtensionResource(messageBundle.localized));
                 const errors = [];
                 const messages = parse(messageBundleContent, errors);
                 if (errors.length > 0) {
@@ -553,7 +557,7 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
     async resolveOriginalMessageBundle(originalMessageBundle, errors) {
         if (originalMessageBundle) {
             try {
-                const originalBundleContent = ( (await this.fileService.readFile(originalMessageBundle)).value.toString());
+                const originalBundleContent = await this.extensionResourceLoaderService.readExtensionResource(originalMessageBundle);
                 return parse(originalBundleContent, errors);
             }
             catch (error) {
@@ -590,12 +594,13 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
     }
 };
 ExtensionManifestTranslator = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, ILogService))
+    ( __param(0, IExtensionResourceLoaderService)),
+    ( __param(1, IFileService)),
+    ( __param(2, ILogService))
 ], ExtensionManifestTranslator));
 let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTranslator {
-    constructor(extensionsProfileScannerService, uriIdentityService, fileService, productService, environmentService, logService) {
-        super(fileService, logService);
+    constructor(extensionsProfileScannerService, uriIdentityService, extensionResourceLoaderService, fileService, productService, environmentService, logService) {
+        super(extensionResourceLoaderService, fileService, logService);
         this.extensionsProfileScannerService = extensionsProfileScannerService;
         this.uriIdentityService = uriIdentityService;
         this.environmentService = environmentService;
@@ -786,7 +791,7 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
         const manifestLocation = joinPath(extensionLocation, 'package.json');
         let content;
         try {
-            content = ( (await this.fileService.readFile(manifestLocation)).value.toString());
+            content = await this.extensionResourceLoaderService.readExtensionResource(manifestLocation);
         }
         catch (error) {
             if (toFileOperationResult(error) !== FileOperationResult.FILE_NOT_FOUND) {
@@ -828,14 +833,15 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
 ExtensionsScanner = ( __decorate([
     ( __param(0, IExtensionsProfileScannerService)),
     ( __param(1, IUriIdentityService)),
-    ( __param(2, IFileService)),
-    ( __param(3, IProductService)),
-    ( __param(4, IEnvironmentService)),
-    ( __param(5, ILogService))
+    ( __param(2, IExtensionResourceLoaderService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IProductService)),
+    ( __param(5, IEnvironmentService)),
+    ( __param(6, ILogService))
 ], ExtensionsScanner));
 let CachedExtensionsScanner = class CachedExtensionsScanner extends ExtensionsScanner {
-    constructor(currentProfile, userDataProfilesService, extensionsProfileScannerService, uriIdentityService, fileService, productService, environmentService, logService) {
-        super(extensionsProfileScannerService, uriIdentityService, fileService, productService, environmentService, logService);
+    constructor(currentProfile, userDataProfilesService, extensionsProfileScannerService, uriIdentityService, extensionResourceLoaderService, fileService, productService, environmentService, logService) {
+        super(extensionsProfileScannerService, uriIdentityService, extensionResourceLoaderService, fileService, productService, environmentService, logService);
         this.currentProfile = currentProfile;
         this.userDataProfilesService = userDataProfilesService;
         this.cacheValidatorThrottler = this._register(( new ThrottledDelayer(3000)));
@@ -921,10 +927,11 @@ CachedExtensionsScanner = ( __decorate([
     ( __param(1, IUserDataProfilesService)),
     ( __param(2, IExtensionsProfileScannerService)),
     ( __param(3, IUriIdentityService)),
-    ( __param(4, IFileService)),
-    ( __param(5, IProductService)),
-    ( __param(6, IEnvironmentService)),
-    ( __param(7, ILogService))
+    ( __param(4, IExtensionResourceLoaderService)),
+    ( __param(5, IFileService)),
+    ( __param(6, IProductService)),
+    ( __param(7, IEnvironmentService)),
+    ( __param(8, ILogService))
 ], CachedExtensionsScanner));
 
 export { AbstractExtensionsScannerService, ExtensionManifestTranslator, ExtensionScannerInput, Translations };

package/vscode/src/vs/platform/product/common/product.js

@@ -4,9 +4,9 @@ import productJson from '../../../../../product.json.js';
 var product = {
   ...productJson,
   quality: 'stable',
-  version: '1.104.0',
-  commit: 'f220831ea2d946c0dcb0f3eaa480eb435a2c1260',
-  date: '2025-09-15T13:51:06.751Z',
+  version: '1.104.1',
+  commit: '0f0d87fa9e96c856c5212fc86db137ac0d783365',
+  date: '2025-09-23T17:07:04.592Z',
   ...(globalThis._VSCODE_PRODUCT_JSON ?? {})
 };
 

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

@@ -188,6 +188,7 @@ export interface AuthenticationConstraint {
 export interface MainThreadAuthenticationShape extends IDisposable {
     $registerAuthenticationProvider(id: string, label: string, supportsMultipleAccounts: boolean, supportedAuthorizationServers?: UriComponents[], supportsChallenges?: boolean): Promise<void>;
     $unregisterAuthenticationProvider(id: string): Promise<void>;
+    $ensureProvider(id: string): Promise<void>;
     $sendDidChangeSessions(providerId: string, event: AuthenticationSessionsChangeEvent): Promise<void>;
     $getSession(providerId: string, scopeListOrRequest: ReadonlyArray<string> | AuthenticationWWWAuthenticateRequest, extensionId: string, extensionName: string, options: AuthenticationGetSessionOptions): Promise<AuthenticationSession | undefined>;
     $getAccounts(providerId: string): Promise<ReadonlyArray<AuthenticationSessionAccount>>;

package/vscode/src/vs/workbench/api/common/extHostAuthentication.js

@@ -73,11 +73,13 @@ let ExtHostAuthentication = class ExtHostAuthentication {
             singlerKey = `${extensionId} ${providerId} ${sortedScopes} ${optionsStr}`;
         }
         return await this._getSessionTaskSingler.getOrCreate(singlerKey, async () => {
+            await this._proxy.$ensureProvider(providerId);
             const extensionName = requestingExtension.displayName || requestingExtension.name;
             return this._proxy.$getSession(providerId, scopesOrRequest, extensionId, extensionName, options);
         });
     }
     async getAccounts(providerId) {
+        await this._proxy.$ensureProvider(providerId);
         return await this._proxy.$getAccounts(providerId);
     }
     registerAuthenticationProvider(id, label, provider, options) {

package/vscode/src/vs/workbench/browser/web.api.d.ts

@@ -0,0 +1,674 @@
+import type { PerformanceMark } from "../../base/common/performance.js";
+import type { UriComponents, URI } from "../../base/common/uri.js";
+import type { IWebSocketFactory } from "@codingame/monaco-vscode-remote-agent-service-override/vscode/vs/platform/remote/browser/browserSocketFactory";
+import type { IURLCallbackProvider } from "@codingame/monaco-vscode-base-service-override/vscode/vs/workbench/services/url/browser/urlService";
+import type { LogLevel } from "../../platform/log/common/log.js";
+import type { IUpdateProvider } from "@codingame/monaco-vscode-update-service-override/vscode/vs/workbench/services/update/browser/updateService";
+import type { Event } from "../../base/common/event.js";
+import type { IProductConfiguration } from "../../base/common/product.js";
+import type { ISecretStorageProvider } from "@codingame/monaco-vscode-secret-storage-service-override/vscode/vs/platform/secrets/common/secrets";
+import type { TunnelProviderFeatures } from "../../platform/tunnel/common/tunnel.js";
+import type { IProgress, IProgressCompositeOptions, IProgressDialogOptions, IProgressNotificationOptions, IProgressOptions, IProgressStep, IProgressWindowOptions } from "../../platform/progress/common/progress.js";
+import type { ITextEditorOptions } from "../../platform/editor/common/editor.js";
+import type { IFolderToOpen, IWorkspaceToOpen } from "../../platform/window/common/window.js";
+import type { EditorGroupLayout } from "../services/editor/common/editorGroupsService.js";
+import type { IEmbedderTerminalOptions } from "@codingame/monaco-vscode-terminal-service-override/vscode/vs/workbench/services/terminal/common/embedderTerminalService";
+import type { IAuthenticationProvider } from "../services/authentication/common/authentication.js";
+/**
+ * The `IWorkbench` interface is the API facade for web embedders
+ * to call into the workbench.
+ *
+ * Note: Changes to this interface need to be announced and adopted.
+ */
+export interface IWorkbench {
+    commands: {
+        /**
+         * Allows to execute any command if known with the provided arguments.
+         *
+         * @param command Identifier of the command to execute.
+         * @param rest Parameters passed to the command function.
+         * @return A promise that resolves to the returned value of the given command.
+         */
+        executeCommand(command: string, ...args: any[]): Promise<unknown>;
+    };
+    logger: {
+        /**
+         * Logging for embedder.
+         *
+         * @param level The log level of the message to be printed.
+         * @param message Message to be printed.
+         */
+        log(level: LogLevel, message: string): void;
+    };
+    env: {
+        /**
+         * @returns the scheme to use for opening the associated desktop
+         * experience via protocol handler.
+         */
+        getUriScheme(): Promise<string>;
+        /**
+         * Retrieve performance marks that have been collected during startup. This function
+         * returns tuples of source and marks. A source is a dedicated context, like
+         * the renderer or an extension host.
+         *
+         * *Note* that marks can be collected on different machines and in different processes
+         * and that therefore "different clocks" are used. So, comparing `startTime`-properties
+         * across contexts should be taken with a grain of salt.
+         *
+         * @returns A promise that resolves to tuples of source and marks.
+         */
+        retrievePerformanceMarks(): Promise<[
+            string,
+            readonly PerformanceMark[]
+        ][]>;
+        /**
+         * Allows to open a target Uri with the standard opener service of the
+         * workbench.
+         */
+        openUri(target: URI | UriComponents): Promise<boolean>;
+    };
+    window: {
+        /**
+         * Show progress in the editor. Progress is shown while running the given callback
+         * and while the promise it returned isn't resolved nor rejected.
+         *
+         * @param task A callback returning a promise.
+         * @return A promise that resolves to the returned value of the given task result.
+         */
+        withProgress<R>(options: IProgressOptions | IProgressDialogOptions | IProgressNotificationOptions | IProgressWindowOptions | IProgressCompositeOptions, task: (progress: IProgress<IProgressStep>) => Promise<R>): Promise<R>;
+        /**
+         * Creates a terminal with limited capabilities that is intended for
+         * writing output from the embedder before the workbench has finished
+         * loading. When an embedder terminal is created it will automatically
+         * show to the user.
+         *
+         * @param options The definition of the terminal, this is similar to
+         * `ExtensionTerminalOptions` in the extension API.
+         */
+        createTerminal(options: IEmbedderTerminalOptions): Promise<void>;
+        /**
+         * Show an information message to users. Optionally provide an array of items which will be presented as
+         * clickable buttons.
+         *
+         * @param message The message to show.
+         * @param items A set of items that will be rendered as actions in the message.
+         * @returns A thenable that resolves to the selected item or `undefined` when being dismissed.
+         */
+        showInformationMessage<T extends string>(message: string, ...items: T[]): Promise<T | undefined>;
+    };
+    workspace: {
+        /**
+         * Resolves once the remote authority has been resolved.
+         */
+        didResolveRemoteAuthority(): Promise<void>;
+        /**
+         * Forwards a port. If the current embedder implements a tunnelFactory then that will be used to make the tunnel.
+         * By default, openTunnel only support localhost; however, a tunnelFactory can be used to support other ips.
+         *
+         * @throws When run in an environment without a remote.
+         *
+         * @param tunnelOptions The `localPort` is a suggestion only. If that port is not available another will be chosen.
+         */
+        openTunnel(tunnelOptions: ITunnelOptions): Promise<ITunnel>;
+    };
+    /**
+     * Triggers shutdown of the workbench programmatically. After this method is
+     * called, the workbench is not usable anymore and the page needs to reload
+     * or closed.
+     *
+     * This will also remove any `beforeUnload` handlers that would bring up a
+     * confirmation dialog.
+     *
+     * The returned promise should be awaited on to ensure any data to persist
+     * has been persisted.
+     */
+    shutdown: () => Promise<void>;
+}
+export interface IWorkbenchConstructionOptions {
+    /**
+     * The remote authority is the IP:PORT from where the workbench is served
+     * from. It is for example being used for the websocket connections as address.
+     */
+    readonly remoteAuthority?: string;
+    /**
+     * The server base path is the path where the workbench is served from.
+     * The path must be absolute (start with a slash).
+     * Corresponds to option `server-base-path` on the server side.
+     */
+    readonly serverBasePath?: string;
+    /**
+     * The connection token to send to the server.
+     */
+    readonly connectionToken?: string | Promise<string>;
+    /**
+     * An endpoint to serve iframe content ("webview") from. This is required
+     * to provide full security isolation from the workbench host.
+     */
+    readonly webviewEndpoint?: string;
+    /**
+     * A factory for web sockets.
+     */
+    readonly webSocketFactory?: IWebSocketFactory;
+    /**
+     * A provider for resource URIs.
+     *
+     * *Note*: This will only be invoked after the `connectionToken` is resolved.
+     */
+    readonly resourceUriProvider?: IResourceUriProvider;
+    /**
+     * Resolves an external uri before it is opened.
+     */
+    readonly resolveExternalUri?: IExternalUriResolver;
+    /**
+     * A provider for supplying tunneling functionality,
+     * such as creating tunnels and showing candidate ports to forward.
+     */
+    readonly tunnelProvider?: ITunnelProvider;
+    /**
+     * Endpoints to be used for proxying authentication code exchange calls in the browser.
+     */
+    readonly codeExchangeProxyEndpoints?: {
+        [providerId: string]: string;
+    };
+    /**
+     * The identifier of an edit session associated with the current workspace.
+     */
+    readonly editSessionId?: string;
+    /**
+     * Resource delegation handler that allows for loading of resources when
+     * using remote resolvers.
+     *
+     * This is exclusive with {@link resourceUriProvider}. `resourceUriProvider`
+     * should be used if a {@link webSocketFactory} is used, and will be preferred.
+     */
+    readonly remoteResourceProvider?: IRemoteResourceProvider;
+    /**
+     * A handler for opening workspaces and providing the initial workspace.
+     */
+    readonly workspaceProvider?: IWorkspaceProvider;
+    /**
+     * Settings sync options
+     */
+    readonly settingsSyncOptions?: ISettingsSyncOptions;
+    /**
+     * The secret storage provider to store and retrieve secrets.
+     */
+    readonly secretStorageProvider?: ISecretStorageProvider;
+    /**
+     * Additional builtin extensions those cannot be uninstalled but only be disabled.
+     * It can be one of the following:
+     * 	- an extension in the Marketplace
+     * 	- location of the extension where it is hosted.
+     */
+    readonly additionalBuiltinExtensions?: readonly (MarketplaceExtension | UriComponents)[];
+    /**
+     * List of extensions to be enabled if they are installed.
+     * Note: This will not install extensions if not installed.
+     */
+    readonly enabledExtensions?: readonly ExtensionId[];
+    /**
+     * Additional domains allowed to open from the workbench without the
+     * link protection popup.
+     */
+    readonly additionalTrustedDomains?: string[];
+    /**
+     * Enable workspace trust feature for the current window
+     */
+    readonly enableWorkspaceTrust?: boolean;
+    /**
+     * Urls that will be opened externally that are allowed access
+     * to the opener window. This is primarily used to allow
+     * `window.close()` to be called from the newly opened window.
+     */
+    readonly openerAllowedExternalUrlPrefixes?: string[];
+    /**
+     * Support for URL callbacks.
+     */
+    readonly urlCallbackProvider?: IURLCallbackProvider;
+    /**
+     * Support adding additional properties to telemetry.
+     */
+    readonly resolveCommonTelemetryProperties?: ICommonTelemetryPropertiesResolver;
+    /**
+     * A set of optional commands that should be registered with the commands
+     * registry.
+     *
+     * Note: commands can be called from extensions if the identifier is known!
+     */
+    readonly commands?: readonly ICommand[];
+    /**
+     * Optional default layout to apply on first time the workspace is opened
+     * (unless `force` is specified). This includes visibility of views and
+     * editors including editor grid layout.
+     */
+    readonly defaultLayout?: IDefaultLayout;
+    /**
+     * Optional configuration default overrides contributed to the workbench.
+     */
+    readonly configurationDefaults?: Record<string, any>;
+    /**
+     * Profile to use for the workbench.
+     */
+    readonly profile?: {
+        readonly name: string;
+        readonly contents?: string | UriComponents;
+    };
+    /**
+     * URI of the profile to preview.
+     */
+    readonly profileToPreview?: UriComponents;
+    /**
+     * Support for update reporting
+     */
+    readonly updateProvider?: IUpdateProvider;
+    /**
+     * Support for product quality switching
+     */
+    readonly productQualityChangeHandler?: IProductQualityChangeHandler;
+    /**
+     * Optional welcome banner to appear above the workbench. Can be dismissed by the
+     * user.
+     */
+    readonly welcomeBanner?: IWelcomeBanner;
+    /**
+     * Optional override for the product configuration properties.
+     */
+    readonly productConfiguration?: Partial<IProductConfiguration>;
+    /**
+     * Optional override for properties of the window indicator in the status bar.
+     */
+    readonly windowIndicator?: IWindowIndicator;
+    /**
+     * Specifies the default theme type (LIGHT, DARK..) and allows to provide initial colors that are shown
+     * until the color theme that is specified in the settings (`editor.colorTheme`) is loaded and applied.
+     * Once there are persisted colors from a last run these will be used.
+     *
+     * The idea is that the colors match the main colors from the theme defined in the `configurationDefaults`.
+     */
+    readonly initialColorTheme?: IInitialColorTheme;
+    readonly messagePorts?: ReadonlyMap<ExtensionId, MessagePort>;
+    /**
+     * Optional authentication provider contributions. These take precedence over
+     * any authentication providers contributed via extensions.
+     */
+    readonly authenticationProviders?: readonly IAuthenticationProvider[];
+    readonly developmentOptions?: IDevelopmentOptions;
+}
+/**
+ * A workspace to open in the workbench can either be:
+ * - a workspace file with 0-N folders (via `workspaceUri`)
+ * - a single folder (via `folderUri`)
+ * - empty (via `undefined`)
+ */
+export type IWorkspace = IWorkspaceToOpen | IFolderToOpen | undefined;
+export interface IWorkspaceProvider {
+    /**
+     * The initial workspace to open.
+     */
+    readonly workspace: IWorkspace;
+    /**
+     * Arbitrary payload from the `IWorkspaceProvider.open` call.
+     */
+    readonly payload?: object;
+    /**
+     * Return `true` if the provided [workspace](#IWorkspaceProvider.workspace) is trusted, `false` if not trusted, `undefined` if unknown.
+     */
+    readonly trusted: boolean | undefined;
+    /**
+     * Asks to open a workspace in the current or a new window.
+     *
+     * @param workspace the workspace to open.
+     * @param options optional options for the workspace to open.
+     * - `reuse`: whether to open inside the current window or a new window
+     * - `payload`: arbitrary payload that should be made available
+     * to the opening window via the `IWorkspaceProvider.payload` property.
+     * @param payload optional payload to send to the workspace to open.
+     *
+     * @returns true if successfully opened, false otherwise.
+     */
+    open(workspace: IWorkspace, options?: {
+        reuse?: boolean;
+        payload?: object;
+    }): Promise<boolean>;
+}
+export interface IResourceUriProvider {
+    (uri: URI): URI;
+}
+/**
+ * The identifier of an extension in the format: `PUBLISHER.NAME`. For example: `vscode.csharp`
+ */
+export type ExtensionId = string;
+export type MarketplaceExtension = ExtensionId | {
+    readonly id: ExtensionId;
+    preRelease?: boolean;
+    migrateStorageFrom?: ExtensionId;
+};
+export interface ICommonTelemetryPropertiesResolver {
+    (): {
+        [key: string]: any;
+    };
+}
+export interface IExternalUriResolver {
+    (uri: URI): Promise<URI>;
+}
+export interface IExternalURLOpener {
+    /**
+     * Overrides the behavior when an external URL is about to be opened.
+     * Returning false means that the URL wasn't handled, and the default
+     * handling behavior should be used: `window.open(href, '_blank', 'noopener');`
+     *
+     * @returns true if URL was handled, false otherwise.
+     */
+    openExternal(href: string): boolean | Promise<boolean>;
+}
+export interface ITunnelProvider {
+    /**
+     * Support for creating tunnels.
+     */
+    tunnelFactory?: ITunnelFactory;
+    /**
+     * Support for filtering candidate ports.
+     */
+    showPortCandidate?: IShowPortCandidate;
+    /**
+     * The features that the tunnel provider supports.
+     */
+    features?: TunnelProviderFeatures;
+}
+export interface ITunnelFactory {
+    (tunnelOptions: ITunnelOptions, tunnelCreationOptions: TunnelCreationOptions): Promise<ITunnel> | undefined;
+}
+export interface ITunnelOptions {
+    remoteAddress: {
+        port: number;
+        host: string;
+    };
+    /**
+     * The desired local port. If this port can't be used, then another will be chosen.
+     */
+    localAddressPort?: number;
+    label?: string;
+    privacy?: string;
+    protocol?: string;
+}
+export interface TunnelCreationOptions {
+    /**
+     * True when the local operating system will require elevation to use the requested local port.
+     */
+    elevationRequired?: boolean;
+}
+export interface ITunnel {
+    remoteAddress: {
+        port: number;
+        host: string;
+    };
+    /**
+     * The complete local address(ex. localhost:1234)
+     */
+    localAddress: string;
+    privacy?: string;
+    /**
+     * If protocol is not provided, it is assumed to be http, regardless of the localAddress
+     */
+    protocol?: string;
+    /**
+     * Implementers of Tunnel should fire onDidDispose when dispose is called.
+     */
+    onDidDispose: Event<void>;
+    dispose(): Promise<void> | void;
+}
+export interface IShowPortCandidate {
+    (host: string, port: number, detail: string): Promise<boolean>;
+}
+export declare enum Menu {
+    CommandPalette = 0,
+    StatusBarWindowIndicatorMenu = 1
+}
+export interface ICommand {
+    /**
+     * An identifier for the command. Commands can be executed from extensions
+     * using the `vscode.commands.executeCommand` API using that command ID.
+     */
+    id: string;
+    /**
+     * The optional label of the command. If provided, the command will appear
+     * in the command palette.
+     */
+    label?: string;
+    /**
+     * The optional menus to append this command to. Only valid if `label` is
+     * provided as well.
+     * @default Menu.CommandPalette
+     */
+    menu?: Menu | Menu[];
+    /**
+     * A function that is being executed with any arguments passed over. The
+     * return type will be send back to the caller.
+     *
+     * Note: arguments and return type should be serializable so that they can
+     * be exchanged across processes boundaries.
+     */
+    handler: (...args: any[]) => unknown;
+}
+export interface IWelcomeBanner {
+    /**
+     * Welcome banner message to appear as text.
+     */
+    message: string;
+    /**
+     * Optional icon for the banner. This is either the URL to an icon to use
+     * or the name of one of the existing icons from our Codicon icon set.
+     *
+     * If not provided a default icon will be used.
+     */
+    icon?: string | UriComponents;
+    /**
+     * Optional actions to appear as links after the welcome banner message.
+     */
+    actions?: IWelcomeLinkAction[];
+}
+export interface IWelcomeLinkAction {
+    /**
+     * The link to open when clicking. Supports command invocation when
+     * using the `command:<commandId>` value.
+     */
+    href: string;
+    /**
+     * The label to show for the action link.
+     */
+    label: string;
+    /**
+     * A tooltip that will appear while hovering over the action link.
+     */
+    title?: string;
+}
+export interface IWindowIndicator {
+    /**
+     * Triggering this event will cause the window indicator to update.
+     */
+    readonly onDidChange?: Event<void>;
+    /**
+     * Label of the window indicator may include octicons
+     * e.g. `$(remote) label`
+     */
+    label: string;
+    /**
+     * Tooltip of the window indicator should not include
+     * octicons and be descriptive.
+     */
+    tooltip: string;
+    /**
+     * If provided, overrides the default command that
+     * is executed when clicking on the window indicator.
+     */
+    command?: string;
+}
+export declare enum ColorScheme {
+    DARK = "dark",
+    LIGHT = "light",
+    HIGH_CONTRAST_LIGHT = "hcLight",
+    HIGH_CONTRAST_DARK = "hcDark"
+}
+export interface IInitialColorTheme {
+    /**
+     * Initial color theme type.
+     */
+    readonly themeType: ColorScheme;
+    /**
+     * A list of workbench colors to apply initially.
+     */
+    readonly colors?: {
+        [colorId: string]: string;
+    };
+}
+export interface IDefaultView {
+    /**
+     * The identifier of the view to show by default.
+     */
+    readonly id: string;
+}
+export interface IDefaultEditor {
+    /**
+     * The location of the editor in the editor grid layout.
+     * Editors are layed out in editor groups and the view
+     * column is counted from top left to bottom right in
+     * the order of appearance beginning with `1`.
+     *
+     * If not provided, the editor will open in the active
+     * group.
+     */
+    readonly viewColumn?: number;
+    /**
+     * The resource of the editor to open.
+     */
+    readonly uri: UriComponents;
+    /**
+     * Optional extra options like which editor
+     * to use or which text to select.
+     */
+    readonly options?: ITextEditorOptions;
+    /**
+     * Will not open an untitled editor in case
+     * the resource does not exist.
+     */
+    readonly openOnlyIfExists?: boolean;
+}
+export interface IDefaultLayout {
+    /**
+     * A list of views to show by default.
+     */
+    readonly views?: IDefaultView[];
+    /**
+     * A list of editors to show by default.
+     */
+    readonly editors?: IDefaultEditor[];
+    /**
+     * The layout to use for the workbench.
+     */
+    readonly layout?: {
+        /**
+         * The layout of the editor area.
+         */
+        readonly editors?: EditorGroupLayout;
+    };
+    /**
+     * Forces this layout to be applied even if this isn't
+     * the first time the workspace has been opened
+     */
+    readonly force?: boolean;
+}
+export interface IProductQualityChangeHandler {
+    /**
+     * Handler is being called when the user wants to switch between
+     * `insider` or `stable` product qualities.
+     */
+    (newQuality: "insider" | "stable"): void;
+}
+/**
+ * Settings sync options
+ */
+export interface ISettingsSyncOptions {
+    /**
+     * Is settings sync enabled
+     */
+    readonly enabled: boolean;
+    /**
+     * Version of extensions sync state.
+     * Extensions sync state will be reset if version is provided and different from previous version.
+     */
+    readonly extensionsSyncStateVersion?: string;
+    /**
+     * Handler is being called when the user changes Settings Sync enablement.
+     */
+    enablementHandler?(enablement: boolean, authenticationProvider: string): void;
+    /**
+     * Authentication provider
+     */
+    readonly authenticationProvider?: {
+        /**
+         * Unique identifier of the authentication provider.
+         */
+        readonly id: string;
+        /**
+         * Called when the user wants to signin to Settings Sync using the given authentication provider.
+         * The returned promise should resolve to the authentication session id.
+         */
+        signIn(): Promise<string>;
+    };
+}
+export interface IDevelopmentOptions {
+    /**
+     * Current logging level. Default is `LogLevel.Info`.
+     */
+    readonly logLevel?: LogLevel;
+    /**
+     * Extension log level.
+     */
+    readonly extensionLogLevel?: [
+        string,
+        LogLevel
+    ][];
+    /**
+     * Location of a module containing extension tests to run once the workbench is open.
+     */
+    readonly extensionTestsPath?: UriComponents;
+    /**
+     * Add extensions under development.
+     */
+    readonly extensions?: readonly UriComponents[];
+    /**
+     * Whether to enable the smoke test driver.
+     */
+    readonly enableSmokeTestDriver?: boolean;
+}
+/**
+ * Utility provided in the {@link WorkbenchOptions} which allows loading resources
+ * when remote resolvers are used in the web.
+ */
+export interface IRemoteResourceProvider {
+    /**
+     * Path the workbench should delegate requests to. The embedder should
+     * install a service worker on this path and emit {@link onDidReceiveRequest}
+     * events when requests come in for that path.
+     */
+    readonly path: string;
+    /**
+     * Event that should fire when requests are made on the {@link pathPrefix}.
+     */
+    readonly onDidReceiveRequest: Event<IRemoteResourceRequest>;
+}
+/**
+ * todo@connor4312: this may eventually gain more properties like method and
+ * headers, but for now we only deal with GET requests.
+ */
+export interface IRemoteResourceRequest {
+    /**
+     * Request URI. Generally will begin with the current
+     * origin and {@link IRemoteResourceProvider.pathPrefix}.
+     */
+    uri: URI;
+    /**
+     * A method called by the editor to issue a response to the request.
+     */
+    respondWith(statusCode: number, body: Uint8Array, headers: Record<string, string>): void;
+}

package/vscode/src/vs/workbench/browser/web.api.js

@@ -0,0 +1,16 @@
+
+
+var Menu;
+(function (Menu) {
+    Menu[Menu["CommandPalette"] = 0] = "CommandPalette";
+    Menu[Menu["StatusBarWindowIndicatorMenu"] = 1] = "StatusBarWindowIndicatorMenu";
+})(Menu || (Menu = {}));
+var ColorScheme;
+(function (ColorScheme) {
+    ColorScheme["DARK"] = "dark";
+    ColorScheme["LIGHT"] = "light";
+    ColorScheme["HIGH_CONTRAST_LIGHT"] = "hcLight";
+    ColorScheme["HIGH_CONTRAST_DARK"] = "hcDark";
+})(ColorScheme || (ColorScheme = {}));
+
+export { ColorScheme, Menu };

package/workbench.d.ts

@@ -1,5 +1,5 @@
 import { type IAnyWorkspaceIdentifier } from "./vscode/src/vs/platform/workspace/common/workspace.js";
-import type { IWorkbenchConstructionOptions } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/browser/web.api";
+import type { IWorkbenchConstructionOptions } from "./vscode/src/vs/workbench/browser/web.api.js";
 import { URI } from "./vscode/src/vs/base/common/uri.js";
 export interface EnvironmentOverride {
     userHome?: URI;