monaco-languageclient 10.0.0-next.0 → 10.0.0-next.2

package/src/editorApp/editorApp.ts

@@ -8,12 +8,13 @@ import { createModelReference, type ITextFileEditorModel } from '@codingame/mona
 import * as monaco from '@codingame/monaco-vscode-editor-api';
 import type { IReference } from '@codingame/monaco-vscode-editor-service-override';
 import { ConsoleLogger, type Logger } from 'monaco-languageclient/common';
-import { getEnhancedMonacoEnvironment, type OverallConfigType } from 'monaco-languageclient/vscodeApiWrapper';
+import { getEnhancedMonacoEnvironment } from 'monaco-languageclient/vscodeApiWrapper';
 import * as vscode from 'vscode';
-import { ModelRefs, type CallbackDisposeable, type CodeContent, type CodeResources, type DisposableModelRefs, type EditorAppConfig, type TextContents, type TextModels } from './config.js';
+import type { CallbackDisposeable, CodeContent, CodeResources, DisposableModelRefs, EditorAppConfig, TextContents, TextModels } from './config.js';
+import { ModelRefs } from './config.js';
 
 /**
- * This is the base class for both Monaco Ediotor Apps:
+ * This is the base class for both Monaco Editor Apps:
  * - EditorAppClassic
  * - EditorAppExtended
  *
@@ -21,7 +22,6 @@ import { ModelRefs, type CallbackDisposeable, type CodeContent, type CodeResourc
  */
 export class EditorApp {
 
-    private $type: OverallConfigType;
     private id: string;
     private config: EditorAppConfig;
 
@@ -33,19 +33,16 @@ export class EditorApp {
     private modelRefs: ModelRefs = new ModelRefs();
 
     private onTextChanged?: (textChanges: TextContents) => void;
-    private textChangedDiposeables: CallbackDisposeable = {};
+    private textChangedDisposables: CallbackDisposeable = {};
     private modelDisposables: DisposableModelRefs = {};
 
     private modelRefDisposeTimeout = -1;
 
     private startingAwait?: Promise<void>;
-    private startingResolve: (value: void | PromiseLike<void>) => void;
 
     private disposingAwait?: Promise<void>;
-    private disposingResolve: (value: void | PromiseLike<void>) => void;
 
     constructor(userAppConfig?: EditorAppConfig) {
-        this.$type = userAppConfig?.$type ?? 'extended';
         this.id = userAppConfig?.id ?? Math.floor(Math.random() * 1000001).toString();
         if ((userAppConfig?.useDiffEditor ?? false) && !userAppConfig?.codeResources?.original) {
             throw new Error(`Use diff editor was used without a valid config. code: ${userAppConfig?.codeResources?.modified} codeOriginal: ${userAppConfig?.codeResources?.original}`);
@@ -105,17 +102,6 @@ export class EditorApp {
         this.modelRefDisposeTimeout = modelRefDisposeTimeout;
     }
 
-    private markStarting() {
-        this.startingAwait = new Promise<void>((resolve) => {
-            this.startingResolve = resolve;
-        });
-    }
-
-    private markStarted() {
-        this.startingResolve();
-        this.startingAwait = undefined;
-    }
-
     isStarting() {
         return this.startingAwait !== undefined;
     }
@@ -135,44 +121,71 @@ export class EditorApp {
         if (this.isStarting()) {
             await this.getStartingAwait();
         }
-        this.markStarting();
 
-        if (!this.isDisposed()) {
-            throw new Error('You called start without properly disposing the EditorApp.');
-        }
+        let startingResolve: (value: void | PromiseLike<void>) => void = () => { };
+        this.startingAwait = new Promise<void>((resolve) => {
+            startingResolve = resolve;
+        });
+
+        try {
+            const envEnhanced = getEnhancedMonacoEnvironment();
+            const viewServiceType = envEnhanced.viewServiceType;
 
-        const languageDef = this.config.languageDef;
-        if (languageDef) {
-            if (this.$type === 'extended') {
-                throw new Error('Language definition is not supported for extended editor apps where textmate is used.');
+            // check general error case first
+            if (!(envEnhanced.vscodeApiInitialised ?? false)) {
+                return Promise.reject('monaco-vscode-api was not initialized. Aborting.');
             }
-            // register own language first
-            monaco.languages.register(languageDef.languageExtensionConfig);
-
-            const languageRegistered = monaco.languages.getLanguages().filter(x => x.id === languageDef.languageExtensionConfig.id);
-            if (languageRegistered.length === 0) {
-                // this is only meaningful for languages supported by monaco out of the box
-                monaco.languages.register({
-                    id: languageDef.languageExtensionConfig.id
-                });
+            if (viewServiceType !== 'EditorService' && viewServiceType !== undefined) {
+                return Promise.reject('No EditorService configured. monaco-editor will not be started.');
+            }
+            if (!this.isDisposed()) {
+                return Promise.reject('Start was called without properly disposing the EditorApp first.');
             }
 
-            // apply monarch definitions
-            if (languageDef.monarchLanguage) {
-                monaco.languages.setMonarchTokensProvider(languageDef.languageExtensionConfig.id, languageDef.monarchLanguage);
+            const languageDef = this.config.languageDef;
+            if (languageDef) {
+                // register own language first
+                monaco.languages.register(languageDef.languageExtensionConfig);
+
+                const languageRegistered = monaco.languages.getLanguages().filter(x => x.id === languageDef.languageExtensionConfig.id);
+                if (languageRegistered.length === 0) {
+                    // this is only meaningful for languages supported by monaco out of the box
+                    monaco.languages.register({
+                        id: languageDef.languageExtensionConfig.id
+                    });
+                }
+
+                // apply monarch definitions
+                if (languageDef.monarchLanguage) {
+                    monaco.languages.setMonarchTokensProvider(languageDef.languageExtensionConfig.id, languageDef.monarchLanguage);
+                }
+
+                if (languageDef.theme) {
+                    monaco.editor.defineTheme(languageDef.theme.name, languageDef.theme.data);
+                    monaco.editor.setTheme(languageDef.theme.name);
+                }
             }
 
-            if (languageDef.theme) {
-                monaco.editor.defineTheme(languageDef.theme.name, languageDef.theme.data);
-                monaco.editor.setTheme(languageDef.theme.name);
+            if (this.config.editorOptions?.['semanticHighlighting.enabled'] !== undefined) {
+                StandaloneServices.get(IConfigurationService).updateValue('editor.semanticHighlighting.enabled',
+                    this.config.editorOptions['semanticHighlighting.enabled'], ConfigurationTarget.USER);
             }
-        }
 
-        if (this.config.editorOptions?.['semanticHighlighting.enabled'] !== undefined) {
-            StandaloneServices.get(IConfigurationService).updateValue('editor.semanticHighlighting.enabled',
-                this.config.editorOptions['semanticHighlighting.enabled'], ConfigurationTarget.USER);
+            await this.createEditors(htmlContainer);
+
+            // everything is fine at this point
+            startingResolve();
+            this.logger.info('EditorApp start completed successfully.');
+        } catch (e) {
+            // in case of further errors (after general ones above)
+            // take the error and build a new rejection to complete the promise
+            return Promise.reject(e);
+        } finally {
+            this.startingAwait = undefined;
         }
+    }
 
+    async createEditors(htmlContainer: HTMLElement): Promise<void> {
         // ensure proper default resources are initialized, uris have to be unique
         const modified = {
             text: this.config.codeResources?.modified?.text ?? '',
@@ -190,30 +203,10 @@ export class EditorApp {
             this.modelRefs.original = await this.buildModelReference(original, this.logger);
         }
 
-        try {
-            const envEnhanced = getEnhancedMonacoEnvironment();
-            const viewServiceType = envEnhanced.viewServiceType;
-            if (viewServiceType === 'EditorService' || viewServiceType === undefined) {
-                this.logger.info(`Starting monaco-editor (${this.id})`);
-                await this.createEditors(htmlContainer!);
-            } else {
-                this.logger.info('No EditorService configured. monaco-editor will not be started.');
-            }
-
-            this.logger.info('EditorApp start completed successfully.');
-            // eslint-disable-next-line no-useless-catch
-        } catch (e) {
-            throw e;
-        } finally {
-            // in case of rejection, mark as started, otherwise the promise will never resolve
-            this.markStarted();
-        }
-    }
-
-    async createEditors(htmlContainer: HTMLElement): Promise<void> {
+        this.logger.info(`Starting monaco-editor (${this.id})`);
         if (this.isDiffEditor()) {
             this.diffEditor = monaco.editor.createDiffEditor(htmlContainer, this.config.diffEditorOptions);
-            const modified = this.modelRefs.modified?.object.textEditorModel ?? undefined;
+            const modified = this.modelRefs.modified.object.textEditorModel ?? undefined;
             const original = this.modelRefs.original?.object.textEditorModel ?? undefined;
             if (modified !== undefined && original !== undefined) {
                 const model = {
@@ -225,7 +218,7 @@ export class EditorApp {
             }
         } else {
             const model = {
-                modified: this.modelRefs.modified?.object.textEditorModel
+                modified: this.modelRefs.modified.object.textEditorModel
             };
             this.editor = monaco.editor.create(htmlContainer, {
                 ...this.config.editorOptions,
@@ -318,8 +311,8 @@ export class EditorApp {
         if (this.onTextChanged !== undefined) {
             let changed = false;
             if (textModels.modified !== undefined && textModels.modified !== null) {
-                const old = this.textChangedDiposeables.modified;
-                this.textChangedDiposeables.modified = textModels.modified.onDidChangeContent(() => {
+                const old = this.textChangedDisposables.modified;
+                this.textChangedDisposables.modified = textModels.modified.onDidChangeContent(() => {
                     didModelContentChange(textModels, this.onTextChanged);
                 });
                 old?.dispose();
@@ -327,8 +320,8 @@ export class EditorApp {
             }
 
             if (textModels.original !== undefined && textModels.original !== null) {
-                const old = this.textChangedDiposeables.original;
-                this.textChangedDiposeables.original = textModels.original.onDidChangeContent(() => {
+                const old = this.textChangedDisposables.original;
+                this.textChangedDisposables.original = textModels.original.onDidChangeContent(() => {
                     didModelContentChange(textModels, this.onTextChanged);
                 });
                 old?.dispose();
@@ -346,7 +339,10 @@ export class EditorApp {
         if (this.isDisposing()) {
             await this.getDisposingAwait();
         }
-        this.markDisposing();
+        let disposingResolve: (value: void | PromiseLike<void>) => void = () => { };
+        this.disposingAwait = new Promise<void>((resolve) => {
+            disposingResolve = resolve;
+        });
 
         if (this.editor) {
             this.editor.dispose();
@@ -357,33 +353,22 @@ export class EditorApp {
             this.diffEditor = undefined;
         }
 
-        this.textChangedDiposeables.modified?.dispose();
-        this.textChangedDiposeables.original?.dispose();
-        this.textChangedDiposeables.modified = undefined;
-        this.textChangedDiposeables.original = undefined;
+        this.textChangedDisposables.modified?.dispose();
+        this.textChangedDisposables.original?.dispose();
+        this.textChangedDisposables.modified = undefined;
+        this.textChangedDisposables.original = undefined;
 
         await this.disposeModelRefs();
 
-        this.markDisposed();
+        disposingResolve();
+        this.disposingAwait = undefined;
     }
 
     isDisposed(): boolean {
         return this.editor === undefined && this.diffEditor === undefined &&
-            // this.textChangedDiposeables.modified === undefined && this.textChangedDiposeables.original === undefined &&
             this.modelDisposables.original === undefined && this.modelDisposables.modified === undefined;
     }
 
-    private markDisposing() {
-        this.disposingAwait = new Promise<void>((resolve) => {
-            this.disposingResolve = resolve;
-        });
-    }
-
-    private markDisposed() {
-        this.disposingResolve();
-        this.disposingAwait = undefined;
-    }
-
     isDisposing() {
         return this.disposingAwait !== undefined;
     }
@@ -393,7 +378,7 @@ export class EditorApp {
     }
 
     async disposeModelRefs() {
-        const diposeRefs = () => {
+        const disposeRefs = () => {
             if (this.logger.getLevel() === LogLevel.Debug) {
                 const models = monaco.editor.getModels();
                 this.logger.debug('Current model URIs:');
@@ -402,11 +387,11 @@ export class EditorApp {
                 });
             }
 
-            if (this.modelDisposables.modified !== undefined && !(this.modelDisposables.modified.object.isDisposed() === true)) {
+            if (this.modelDisposables.modified !== undefined && !this.modelDisposables.modified.object.isDisposed()) {
                 this.modelDisposables.modified.dispose();
                 this.modelDisposables.modified = undefined;
             }
-            if (this.modelDisposables.original !== undefined && !(this.modelDisposables.original.object.isDisposed() === true)) {
+            if (this.modelDisposables.original !== undefined && !this.modelDisposables.original.object.isDisposed()) {
                 this.modelDisposables.original.dispose();
                 this.modelDisposables.original = undefined;
             }
@@ -423,11 +408,11 @@ export class EditorApp {
         if (this.modelRefDisposeTimeout > 0) {
             this.logger.debug('Using async dispose of model references');
             await new Promise<void>(resolve => setTimeout(() => {
-                diposeRefs();
+                disposeRefs();
                 resolve();
             }, this.modelRefDisposeTimeout));
         } else {
-            diposeRefs();
+            disposeRefs();
         }
     }
 

package/src/fs/definitions.ts

@@ -13,12 +13,12 @@ export type FileReadResultStatus = 'success' | 'denied';
 
 export interface FileReadRequestResult {
     status: FileReadResultStatus
-    content: string | ArrayBuffer
+    content: string | ArrayBuffer | ArrayBufferLike | BlobPart
 }
 
 export interface FileUpdate {
     resourceUri: string
-    content: string | ArrayBuffer
+    content: string | ArrayBuffer | ArrayBufferLike | BlobPart
 }
 
 export type FileUpdateResultStatus = 'equal' | 'updated' | 'created' | 'denied';

package/src/vscode/apiWrapper.ts

@@ -1,5 +1,5 @@
 /* --------------------------------------------------------------------------------------------
- * Copyright (c) 2024 TypeFox and others.
+ * Copyright (c) 2025 TypeFox and others.
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
@@ -7,20 +7,29 @@ import { initialize, LogLevel } from '@codingame/monaco-vscode-api';
 import { ExtensionHostKind, getExtensionManifests, registerExtension, type IExtensionManifest, type RegisterExtensionResult } from '@codingame/monaco-vscode-api/extensions';
 import { DisposableStore, setUnexpectedErrorHandler } from '@codingame/monaco-vscode-api/monaco';
 import getConfigurationServiceOverride, { initUserConfiguration } from '@codingame/monaco-vscode-configuration-service-override';
-import getLanguagesServiceOverride from '@codingame/monaco-vscode-languages-service-override';
+import * as monaco from '@codingame/monaco-vscode-editor-api';
 import getLogServiceOverride from '@codingame/monaco-vscode-log-service-override';
 import getModelServiceOverride from '@codingame/monaco-vscode-model-service-override';
-import { ConsoleLogger, verifyUrlOrCreateDataUrl, type Logger } from 'monaco-languageclient/common';
+import { ConsoleLogger, encodeStringOrUrlToDataUrl, type Logger } from 'monaco-languageclient/common';
 import { useWorkerFactory } from 'monaco-languageclient/workerFactory';
 import * as vscode from 'vscode';
 import 'vscode/localExtensionHost';
-import type { MonacoVscodeApiConfig } from './config.js';
+import type { ExtensionConfig, MonacoVscodeApiConfig, ViewsConfig } from './config.js';
 import { configureExtHostWorker, getEnhancedMonacoEnvironment, mergeServices, reportServiceLoading, useOpenEditorStub } from './utils.js';
 
-export interface InitServicesInstructions {
+export interface ViewsConfigRuntime extends ViewsConfig {
+    htmlContainer: HTMLElement;
+}
+
+export interface MonacoVscodeApiConfigRuntime extends MonacoVscodeApiConfig {
+    serviceOverrides: monaco.editor.IEditorOverrideServices;
+    logLevel: LogLevel | number;
+    viewsConfig: ViewsConfigRuntime;
+}
+
+export interface StartInstructions {
     caller?: string;
     performServiceConsistencyChecks?: boolean;
-    htmlContainer?: HTMLElement | null;
 }
 
 export class MonacoVscodeApiWrapper {
@@ -28,11 +37,20 @@ export class MonacoVscodeApiWrapper {
     private logger: Logger = new ConsoleLogger();
     private extensionRegisterResults: Map<string, | RegisterExtensionResult> = new Map();
     private disposableStore: DisposableStore = new DisposableStore();
-    private apiConfig: MonacoVscodeApiConfig;
+    private apiConfig: MonacoVscodeApiConfigRuntime;
 
     constructor(apiConfig: MonacoVscodeApiConfig) {
-        this.apiConfig = apiConfig;
-        this.apiConfig.logLevel = this.apiConfig.logLevel ?? LogLevel.Off;
+        const intermediate = {
+            ...apiConfig,
+            serviceOverrides: apiConfig.serviceOverrides ?? {},
+            logLevel: apiConfig.logLevel ?? LogLevel.Off,
+        };
+        if (intermediate.viewsConfig.htmlContainer === 'ReactPlaceholder') {
+            // this is temporary and must be overriden at start by react component with
+            // correct react dom element
+            intermediate.viewsConfig.htmlContainer = document.body;
+        }
+        this.apiConfig = intermediate as MonacoVscodeApiConfigRuntime;
         this.logger.setLevel(this.apiConfig.logLevel);
     }
 
@@ -48,6 +66,10 @@ export class MonacoVscodeApiWrapper {
         return this.apiConfig;
     }
 
+    getHtmlContainer() {
+        return this.apiConfig.viewsConfig.htmlContainer;
+    }
+
     protected configureMonacoWorkers() {
         if (typeof this.apiConfig.monacoWorkerFactory === 'function') {
             this.apiConfig.monacoWorkerFactory(this.logger);
@@ -62,7 +84,9 @@ export class MonacoVscodeApiWrapper {
         if (this.apiConfig.$type === 'extended') {
             const getTextmateServiceOverride = (await import('@codingame/monaco-vscode-textmate-service-override')).default;
             const getThemeServiceOverride = (await import('@codingame/monaco-vscode-theme-service-override')).default;
+            const getLanguagesServiceOverride = (await import('@codingame/monaco-vscode-languages-service-override')).default;
             mergeServices(this.apiConfig.serviceOverrides, {
+                ...getLanguagesServiceOverride(),
                 ...getTextmateServiceOverride(),
                 ...getThemeServiceOverride()
             });
@@ -75,19 +99,19 @@ export class MonacoVscodeApiWrapper {
     }
 
     protected async configureViewsServices() {
-        const viewServiceType = this.apiConfig.viewsConfig?.viewServiceType ?? 'EditorService';
-        if (this.apiConfig.$type === 'classic' && (viewServiceType === 'ViewsService' || viewServiceType === 'WorkspaceService')) {
-            throw new Error(`View Service Type "${viewServiceType}" cannot be used with classic configuration.`);
+        const viewsConfigType = this.apiConfig.viewsConfig.$type;
+        if (this.apiConfig.$type === 'classic' && (viewsConfigType === 'ViewsService' || viewsConfigType === 'WorkspaceService')) {
+            throw new Error(`View Service Type "${viewsConfigType}" cannot be used with classic configuration.`);
         }
 
         const envEnhanced = getEnhancedMonacoEnvironment();
-        if (this.apiConfig.viewsConfig?.viewServiceType === 'ViewsService') {
+        if (viewsConfigType === 'ViewsService') {
             const getViewsServiceOverride = (await import('@codingame/monaco-vscode-views-service-override')).default;
             mergeServices(this.apiConfig.serviceOverrides, {
                 ...getViewsServiceOverride(this.apiConfig.viewsConfig.openEditorFunc ?? useOpenEditorStub)
             });
             envEnhanced.viewServiceType = 'ViewsService';
-        } else if (this.apiConfig.viewsConfig?.viewServiceType === 'WorkspaceService') {
+        } else if (viewsConfigType === 'WorkspaceService') {
             const getWorkbenchServiceOverride = (await import('@codingame/monaco-vscode-workbench-service-override')).default;
             mergeServices(this.apiConfig.serviceOverrides, {
                 ...getWorkbenchServiceOverride()
@@ -96,15 +120,15 @@ export class MonacoVscodeApiWrapper {
         } else {
             const getEditorServiceOverride = (await import('@codingame/monaco-vscode-editor-service-override')).default;
             mergeServices(this.apiConfig.serviceOverrides, {
-                ...getEditorServiceOverride(this.apiConfig.viewsConfig?.openEditorFunc ?? useOpenEditorStub)
+                ...getEditorServiceOverride(this.apiConfig.viewsConfig.openEditorFunc ?? useOpenEditorStub)
             });
             envEnhanced.viewServiceType = 'EditorService';
         }
     }
 
     protected async applyViewsPostConfig() {
-        this.apiConfig.viewsConfig?.htmlAugmentationInstructions?.(this.apiConfig.htmlContainer);
-        await this.apiConfig.viewsConfig?.viewsInitFunc?.();
+        this.apiConfig.viewsConfig.htmlAugmentationInstructions?.(this.apiConfig.viewsConfig.htmlContainer);
+        await this.apiConfig.viewsConfig.viewsInitFunc?.();
     }
 
     /**
@@ -128,13 +152,13 @@ export class MonacoVscodeApiWrapper {
     }
 
     /**
-     * set the log-level via the development settings
+     * Set the log-level via the development settings.
+     * VSCode developmentOptions are read-only. There are no functions exposed to set options directly.
+     * Therefore the Object properties need to be manipulated directly via Object.assign.
      */
     protected configureDevLogLevel() {
         const devLogLevel = this.apiConfig.workspaceConfig?.developmentOptions?.logLevel;
         if (devLogLevel === undefined) {
-
-            // this needs to be done so complicated, because developmentOptions is read-only
             const devOptions: Record<string, unknown> = {
                 ...this.apiConfig.workspaceConfig!.developmentOptions
             };
@@ -169,7 +193,6 @@ export class MonacoVscodeApiWrapper {
     protected async supplyRequiredServices() {
         return {
             ...getConfigurationServiceOverride(),
-            ...getLanguagesServiceOverride(),
             ...getLogServiceOverride(),
             ...getModelServiceOverride()
         };
@@ -204,8 +227,9 @@ export class MonacoVscodeApiWrapper {
      *   - languages
      *   - log
      *   - model
+     *   - configuration services
      */
-    protected async importAllServices(instructions?: InitServicesInstructions) {
+    protected async initAllServices(performServiceConsistencyChecks?: boolean) {
         const services = await this.supplyRequiredServices();
 
         mergeServices(services, this.apiConfig.serviceOverrides);
@@ -213,12 +237,12 @@ export class MonacoVscodeApiWrapper {
 
         reportServiceLoading(services, this.logger);
 
-        if (instructions?.performServiceConsistencyChecks === true) {
+        if (performServiceConsistencyChecks ?? true) {
             this.checkServiceConsistency();
         }
 
-        if (this.apiConfig.viewsConfig?.viewServiceType === 'ViewsService' || this.apiConfig.viewsConfig?.viewServiceType === 'WorkspaceService') {
-            await initialize(services, this.apiConfig.htmlContainer, this.apiConfig.workspaceConfig, this.apiConfig.envOptions);
+        if (this.apiConfig.viewsConfig.$type === 'ViewsService' || this.apiConfig.viewsConfig.$type === 'WorkspaceService') {
+            await initialize(services, this.apiConfig.viewsConfig.htmlContainer, this.apiConfig.workspaceConfig, this.apiConfig.envOptions);
         } else {
             await initialize(services, undefined, this.apiConfig.workspaceConfig, this.apiConfig.envOptions);
         }
@@ -242,21 +266,29 @@ export class MonacoVscodeApiWrapper {
             });
             for (const extensionConfig of extensions ?? []) {
                 if (!extensionIds.includes(`${extensionConfig.config.publisher}.${extensionConfig.config.name}`)) {
-                    const manifest = extensionConfig.config as IExtensionManifest;
-                    const extRegResult = registerExtension(manifest, ExtensionHostKind.LocalProcess);
-                    this.extensionRegisterResults.set(manifest.name, extRegResult);
-                    if (extensionConfig.filesOrContents && Object.hasOwn(extRegResult, 'registerFileUrl')) {
-                        for (const entry of extensionConfig.filesOrContents) {
-                            this.disposableStore.add(extRegResult.registerFileUrl(entry[0], verifyUrlOrCreateDataUrl(entry[1])));
-                        }
-                    }
-                    allPromises.push(extRegResult.whenReady());
+                    allPromises.push(this.initExtension(extensionConfig, extensionIds));
                 }
             }
             await Promise.all(allPromises);
         }
     }
 
+    protected initExtension(extensionConfig: ExtensionConfig, extensionIds: string[]): Promise<void> {
+        if (!extensionIds.includes(`${extensionConfig.config.publisher}.${extensionConfig.config.name}`)) {
+            const manifest = extensionConfig.config as IExtensionManifest;
+            const extRegResult = registerExtension(manifest, ExtensionHostKind.LocalProcess);
+            this.extensionRegisterResults.set(manifest.name, extRegResult);
+            if (extensionConfig.filesOrContents && Object.hasOwn(extRegResult, 'registerFileUrl')) {
+                for (const entry of extensionConfig.filesOrContents) {
+                    this.disposableStore.add(extRegResult.registerFileUrl(entry[0], encodeStringOrUrlToDataUrl(entry[1])));
+                }
+            }
+            return extRegResult.whenReady();
+        } else {
+            return Promise.resolve();
+        }
+    }
+
     protected markGlobalInit() {
         this.logger.debug('markGlobalInit');
 
@@ -268,33 +300,41 @@ export class MonacoVscodeApiWrapper {
 
     protected markGlobalInitDone() {
         const envEnhanced = getEnhancedMonacoEnvironment();
-        if (typeof envEnhanced.vscodeApiGlobalInitResolve === 'function') {
-            envEnhanced.vscodeApiGlobalInitResolve();
-        }
+        envEnhanced.vscodeApiGlobalInitResolve?.();
+
         envEnhanced.vscodeApiInitialised = true;
         envEnhanced.vscodeApiGlobalInitAwait = undefined;
         envEnhanced.vscodeApiGlobalInitResolve = undefined;
         this.logger.debug('markGlobalInitDone');
     }
 
-    async init(instructions?: InitServicesInstructions): Promise<void> {
+    overrideViewsConfig(viewsConfigOverride: ViewsConfigRuntime) {
+        const orgViewsConfig = this.apiConfig.viewsConfig;
+        this.apiConfig.viewsConfig = {
+            $type: viewsConfigOverride.$type,
+            htmlContainer: viewsConfigOverride.htmlContainer,
+            htmlAugmentationInstructions: viewsConfigOverride.htmlAugmentationInstructions ?? orgViewsConfig.htmlAugmentationInstructions,
+            openEditorFunc: viewsConfigOverride.openEditorFunc ?? orgViewsConfig.openEditorFunc,
+            viewsInitFunc: viewsConfigOverride.viewsInitFunc ?? orgViewsConfig.viewsInitFunc
+        };
+    }
+
+    async start(startInstructions?: StartInstructions): Promise<void> {
         const envEnhanced = getEnhancedMonacoEnvironment();
         if (envEnhanced.vscodeApiInitialised === true) {
             this.logger.warn('Initialization of monaco-vscode api can only performed once!');
         } else {
             if (!(envEnhanced.vscodeApiInitialising === true)) {
+
                 envEnhanced.vscodeApiInitialising = true;
                 this.markGlobalInit();
-                if (instructions?.htmlContainer !== undefined && instructions.htmlContainer !== null) {
-                    this.apiConfig.htmlContainer = instructions.htmlContainer;
-                }
 
                 // ensures "vscodeApiConfig.workspaceConfig" is available
                 this.configureWorkspaceConfig();
 
                 // ensure logging and development logging options are in-line
                 this.configureDevLogLevel();
-                this.logger.info(`Initializing monaco-vscode api. Caller: ${instructions?.caller ?? 'unknown'}`);
+                this.logger.info(`Initializing monaco-vscode api. Caller: ${startInstructions?.caller ?? 'unknown'}`);
 
                 await this.configureMonacoWorkers();
 
@@ -304,12 +344,12 @@ export class MonacoVscodeApiWrapper {
                 // ensure one of the three potential view services are configured
                 await this.configureViewsServices();
 
-                // enforece semantic highlighting if configured
+                // enforce semantic highlighting if configured
                 this.configureSemanticHighlighting();
 
                 await this.initUserConfiguration();
 
-                await this.importAllServices(instructions);
+                await this.initAllServices(startInstructions?.performServiceConsistencyChecks);
 
                 await this.applyViewsPostConfig();
 

package/src/vscode/config.ts

@@ -1,5 +1,5 @@
 /* --------------------------------------------------------------------------------------------
- * Copyright (c) 2024 TypeFox and others.
+ * Copyright (c) 2025 TypeFox and others.
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
@@ -11,21 +11,27 @@ import type { EnvironmentOverride } from '@codingame/monaco-vscode-api/workbench
 import type { OpenEditor } from '@codingame/monaco-vscode-editor-service-override';
 import type { Logger } from 'monaco-languageclient/common';
 
+export type OverallConfigType = 'extended' | 'classic';
+
+export type ViewsConfigTypes = 'EditorService' | 'ViewsService' | 'WorkspaceService';
+
+export type HtmlContainerConfig = HTMLElement | 'ReactPlaceholder';
+
 export interface MonacoEnvironmentEnhanced extends monaco.Environment {
     vscodeApiInitialising?: boolean;
     vscodeApiInitialised?: boolean;
     vscodeApiGlobalInitAwait?: Promise<void>;
     vscodeApiGlobalInitResolve?: ((value: void | PromiseLike<void>) => void);
-    viewServiceType?: 'EditorService' | 'ViewsService' | 'WorkspaceService';
+    viewServiceType?: ViewsConfigTypes;
 }
 
-export type OverallConfigType = 'extended' | 'classic';
-
 export interface UserConfiguration {
     json?: string;
 }
+
 export interface ViewsConfig {
-    viewServiceType: 'EditorService' | 'ViewsService' | 'WorkspaceService';
+    $type: ViewsConfigTypes;
+    htmlContainer: HtmlContainerConfig;
     openEditorFunc?: OpenEditor;
     htmlAugmentationInstructions?: (htmlContainer: HTMLElement | null | undefined) => void;
     viewsInitFunc?: () => Promise<void>;
@@ -38,12 +44,11 @@ export interface ExtensionConfig {
 
 export interface MonacoVscodeApiConfig {
     $type: OverallConfigType;
-    htmlContainer?: HTMLElement;
-    serviceOverrides: monaco.editor.IEditorOverrideServices;
+    viewsConfig: ViewsConfig,
+    serviceOverrides?: monaco.editor.IEditorOverrideServices;
     logLevel?: LogLevel | number;
     workspaceConfig?: IWorkbenchConstructionOptions;
     userConfiguration?: UserConfiguration;
-    viewsConfig?: ViewsConfig,
     envOptions?: EnvironmentOverride;
     extensions?: ExtensionConfig[];
     monacoWorkerFactory?: (logger?: Logger) => void;