@codingame/monaco-vscode-api 8.0.4 → 9.0.2

package/vscode/src/vs/base/common/keybindingLabels.js

@@ -30,35 +30,35 @@ const UILabelProvider = ( (new ModifierLabelProvider({
     metaKey: '⌘',
     separator: '',
 }, {
-    ctrlKey: ( localize(8528, "Ctrl")),
-    shiftKey: ( localize(8529, "Shift")),
-    altKey: ( localize(8530, "Alt")),
-    metaKey: ( localize(8531, "Windows")),
+    ctrlKey: ( localize(8575, "Ctrl")),
+    shiftKey: ( localize(8576, "Shift")),
+    altKey: ( localize(8577, "Alt")),
+    metaKey: ( localize(8578, "Windows")),
     separator: '+',
 }, {
-    ctrlKey: ( localize(8528, "Ctrl")),
-    shiftKey: ( localize(8529, "Shift")),
-    altKey: ( localize(8530, "Alt")),
-    metaKey: ( localize(8532, "Super")),
+    ctrlKey: ( localize(8575, "Ctrl")),
+    shiftKey: ( localize(8576, "Shift")),
+    altKey: ( localize(8577, "Alt")),
+    metaKey: ( localize(8579, "Super")),
     separator: '+',
 })));
 const AriaLabelProvider = ( (new ModifierLabelProvider({
-    ctrlKey: ( localize(8533, "Control")),
-    shiftKey: ( localize(8534, "Shift")),
-    altKey: ( localize(8535, "Option")),
-    metaKey: ( localize(8536, "Command")),
+    ctrlKey: ( localize(8580, "Control")),
+    shiftKey: ( localize(8581, "Shift")),
+    altKey: ( localize(8582, "Option")),
+    metaKey: ( localize(8583, "Command")),
     separator: '+',
 }, {
-    ctrlKey: ( localize(8533, "Control")),
-    shiftKey: ( localize(8534, "Shift")),
-    altKey: ( localize(8537, "Alt")),
-    metaKey: ( localize(8538, "Windows")),
+    ctrlKey: ( localize(8580, "Control")),
+    shiftKey: ( localize(8581, "Shift")),
+    altKey: ( localize(8584, "Alt")),
+    metaKey: ( localize(8585, "Windows")),
     separator: '+',
 }, {
-    ctrlKey: ( localize(8533, "Control")),
-    shiftKey: ( localize(8534, "Shift")),
-    altKey: ( localize(8537, "Alt")),
-    metaKey: ( localize(8539, "Super")),
+    ctrlKey: ( localize(8580, "Control")),
+    shiftKey: ( localize(8581, "Shift")),
+    altKey: ( localize(8584, "Alt")),
+    metaKey: ( localize(8586, "Super")),
     separator: '+',
 })));
 const ElectronAcceleratorLabelProvider = ( (new ModifierLabelProvider({

package/vscode/src/vs/base/common/network.js

@@ -1,10 +1,10 @@
 import { onUnexpectedError } from './errors.js';
 import { toDisposable } from './lifecycle.js';
 import { ResourceMap } from './map.js';
-import { isWeb, isNative, webWorkerOrigin } from './platform.js';
+import { isNative, webWorkerOrigin, isWeb } from './platform.js';
 import { equalsIgnoreCase, startsWithIgnoreCase } from './strings.js';
 import { URI } from './uri.js';
-import { posix } from './path.js';
+import { join, posix } from './path.js';
 var Schemas;
 ( (function(Schemas) {
     Schemas.inMemory = 'inmemory';
@@ -26,13 +26,15 @@ var Schemas;
     Schemas.vscodeCustomEditor = 'vscode-custom-editor';
     Schemas.vscodeNotebookCell = 'vscode-notebook-cell';
     Schemas.vscodeNotebookCellMetadata = 'vscode-notebook-cell-metadata';
+    Schemas.vscodeNotebookCellMetadataDiff = 'vscode-notebook-cell-metadata-diff';
     Schemas.vscodeNotebookCellOutput = 'vscode-notebook-cell-output';
+    Schemas.vscodeNotebookCellOutputDiff = 'vscode-notebook-cell-output-diff';
+    Schemas.vscodeNotebookMetadata = 'vscode-notebook-metadata';
     Schemas.vscodeInteractiveInput = 'vscode-interactive-input';
     Schemas.vscodeSettings = 'vscode-settings';
     Schemas.vscodeWorkspaceTrust = 'vscode-workspace-trust';
     Schemas.vscodeTerminal = 'vscode-terminal';
     Schemas.vscodeChatCodeBlock = 'vscode-chat-code-block';
-    Schemas.vscodeCopilotBackingChatCodeBlock = 'vscode-copilot-chat-code-block';
     Schemas.vscodeChatCodeCompareBlock = 'vscode-chat-code-compare-block';
     Schemas.vscodeChatSesssion = 'vscode-chat-editor';
     Schemas.webviewPanel = 'webview-panel';
@@ -44,6 +46,7 @@ var Schemas;
     Schemas.vscodeSourceControl = 'vscode-scm';
     Schemas.commentsInput = 'comment';
     Schemas.codeSetting = 'code-setting';
+    Schemas.outputChannel = 'output';
 })(Schemas || (Schemas = {})));
 function matchesScheme(target, scheme) {
     if (URI.isUri(target)) {
@@ -125,22 +128,13 @@ function getServerRootPath(product, basePath) {
     return posix.join(basePath ?? '/', `${product.quality ?? 'oss'}-${product.commit ?? 'dev'}`);
 }
 const nodeModulesPath = 'vs/../../node_modules';
-const nodeModulesAsarPath = 'vs/../../node_modules.asar';
-const nodeModulesAsarUnpackedPath = 'vs/../../node_modules.asar.unpacked';
 const VSCODE_AUTHORITY = 'vscode-app';
 class FileAccessImpl {
     constructor() {
         this.staticBrowserUris = ( new ResourceMap());
         this.appResourcePathUrls = ( new Map());
-        this.moduleContentProvider = ( new Map());
     }
     static { this.FALLBACK_AUTHORITY = VSCODE_AUTHORITY; }
-    registerModuleContentProvider(moduleId, contentLoader) {
-        this.moduleContentProvider.set(moduleId, contentLoader);
-    }
-    toModuleContent(moduleId) {
-        return this.moduleContentProvider.get(moduleId)();
-    }
     registerAppResourcePathUrl(moduleId, url) {
         this.appResourcePathUrls.set(moduleId, url);
     }
@@ -192,6 +186,14 @@ class FileAccessImpl {
         if (URI.isUri(uriOrModule)) {
             return uriOrModule;
         }
+        if (globalThis._VSCODE_FILE_ROOT) {
+            const rootUriOrPath = globalThis._VSCODE_FILE_ROOT;
+            if (/^\w[\w\d+.-]*:\/\//.test(rootUriOrPath)) {
+                return URI.joinPath(( URI.parse(rootUriOrPath, true)), uriOrModule);
+            }
+            const modulePath = join(rootUriOrPath, uriOrModule);
+            return URI.file(modulePath);
+        }
         return ( URI.parse(moduleIdToUrl.toUrl(uriOrModule)));
     }
     registerStaticBrowserUri(uri, browserUri) {
@@ -248,4 +250,4 @@ var COI;
     }
     COI.addSearchParam = addSearchParam;
 })(COI || (COI = {})));
-export { COI, FileAccess, RemoteAuthorities, Schemas, VSCODE_AUTHORITY, connectionTokenQueryName, getServerRootPath, matchesScheme, matchesSomeScheme, nodeModulesAsarPath, nodeModulesAsarUnpackedPath, nodeModulesPath };
+export { COI, FileAccess, RemoteAuthorities, Schemas, VSCODE_AUTHORITY, connectionTokenQueryName, getServerRootPath, matchesScheme, matchesSomeScheme, nodeModulesPath };

package/vscode/src/vs/base/common/performance.js

@@ -46,7 +46,7 @@ const module = { exports: {} };
 				};
 			}
 		} else if (typeof process === 'object') {
-			const timeOrigin = performance?.timeOrigin ?? Math.round((require.__$__nodeRequire || require)('perf_hooks').performance.timeOrigin);
+			const timeOrigin = performance?.timeOrigin;
 			return _definePolyfillMarks(timeOrigin);
 		} else {
 			console.trace('perf-util loaded in UNKNOWN environment');

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

@@ -1,3 +1,5 @@
+import '../../nls.js';
+import { getNLSLanguage } from '../../nls.messages.js';
 const LANGUAGE_DEFAULT = 'en';
 let _isWindows = false;
 let _isMacintosh = false;
@@ -53,7 +55,7 @@ else if (typeof navigator === 'object' && !isElectronRenderer) {
     _isLinux = _userAgent.indexOf('Linux') >= 0;
     _isMobile = _userAgent?.indexOf('Mobi') >= 0;
     _isWeb = true;
-    _language = globalThis._VSCODE_NLS_LANGUAGE || LANGUAGE_DEFAULT;
+    _language = getNLSLanguage() || LANGUAGE_DEFAULT;
     _locale = navigator.language.toLowerCase();
     _platformLocale = _locale;
 }

package/vscode/src/vs/base/common/product.d.ts

@@ -150,7 +150,6 @@ interface IProductConfiguration {
     readonly tunnelApplicationName?: string;
     readonly tunnelApplicationConfig?: ITunnelApplicationConfig;
     readonly npsSurveyUrl?: string;
-    readonly cesSurveyUrl?: string;
     readonly surveys?: readonly ISurveyData[];
     readonly checksums?: {
         [path: string]: string;

package/vscode/src/vs/base/common/worker/simpleWorker.js

@@ -1,9 +1,10 @@
-import { transformErrorForSerialization } from '../errors.js';
+import { CharCode } from '../charCode.js';
+import { onUnexpectedError, transformErrorForSerialization } from '../errors.js';
 import { Emitter } from '../event.js';
 import { Disposable } from '../lifecycle.js';
-import { getAllMethodNames } from '../objects.js';
 import { isWeb } from '../platform.js';
 import { isUpperAsciiLetter } from '../strings.js';
+const DEFAULT_CHANNEL = 'default';
 const INITIALIZE = '$initialize';
 let webWorkerWarningLogged = false;
 function logOnceWebWorkerWarning(err) {
@@ -25,9 +26,10 @@ var MessageType;
     MessageType[MessageType["UnsubscribeEvent"] = 4] = "UnsubscribeEvent";
 })(MessageType || (MessageType = {})));
 class RequestMessage {
-    constructor(vsWorker, req, method, args) {
+    constructor(vsWorker, req, channel, method, args) {
         this.vsWorker = vsWorker;
         this.req = req;
+        this.channel = channel;
         this.method = method;
         this.args = args;
         this.type = MessageType.Request;
@@ -43,9 +45,10 @@ class ReplyMessage {
     }
 }
 class SubscribeEventMessage {
-    constructor(vsWorker, req, eventName, arg) {
+    constructor(vsWorker, req, channel, eventName, arg) {
         this.vsWorker = vsWorker;
         this.req = req;
+        this.channel = channel;
         this.eventName = eventName;
         this.arg = arg;
         this.type = MessageType.SubscribeEvent;
@@ -78,23 +81,23 @@ class SimpleWorkerProtocol {
     setWorkerId(workerId) {
         this._workerId = workerId;
     }
-    sendMessage(method, args) {
+    sendMessage(channel, method, args) {
         const req = String(++this._lastSentReq);
         return ( new Promise((resolve, reject) => {
             this._pendingReplies[req] = {
                 resolve: resolve,
                 reject: reject
             };
-            this._send(( new RequestMessage(this._workerId, req, method, args)));
+            this._send(( new RequestMessage(this._workerId, req, channel, method, args)));
         }));
     }
-    listen(eventName, arg) {
+    listen(channel, eventName, arg) {
         let req = null;
         const emitter = ( new Emitter({
             onWillAddFirstListener: () => {
                 req = String(++this._lastSentReq);
                 this._pendingEmitters.set(req, emitter);
-                this._send(( new SubscribeEventMessage(this._workerId, req, eventName, arg)));
+                this._send(( new SubscribeEventMessage(this._workerId, req, channel, eventName, arg)));
             },
             onDidRemoveLastListener: () => {
                 this._pendingEmitters.delete(req);
@@ -113,6 +116,30 @@ class SimpleWorkerProtocol {
         }
         this._handleMessage(message);
     }
+    createProxyToRemoteChannel(channel, sendMessageBarrier) {
+        const handler = {
+            get: (target, name) => {
+                if (typeof name === 'string' && !target[name]) {
+                    if (propertyIsDynamicEvent(name)) {
+                        target[name] = (arg) => {
+                            return this.listen(channel, name, arg);
+                        };
+                    }
+                    else if (propertyIsEvent(name)) {
+                        target[name] = this.listen(channel, name, undefined);
+                    }
+                    else if (name.charCodeAt(0) === CharCode.DollarSign) {
+                        target[name] = async (...myArgs) => {
+                            await sendMessageBarrier?.();
+                            return this.sendMessage(channel, name, myArgs);
+                        };
+                    }
+                }
+                return target[name];
+            }
+        };
+        return ( new Proxy(Object.create(null), handler));
+    }
     _handleMessage(msg) {
         switch (msg.type) {
             case MessageType.Reply:
@@ -149,7 +176,7 @@ class SimpleWorkerProtocol {
     }
     _handleRequestMessage(requestMessage) {
         const req = requestMessage.req;
-        const result = this._handler.handleMessage(requestMessage.method, requestMessage.args);
+        const result = this._handler.handleMessage(requestMessage.channel, requestMessage.method, requestMessage.args);
         result.then((r) => {
             this._send(( new ReplyMessage(this._workerId, req, r, undefined)));
         }, (e) => {
@@ -161,7 +188,7 @@ class SimpleWorkerProtocol {
     }
     _handleSubscribeEventMessage(msg) {
         const req = msg.req;
-        const disposable = this._handler.handleEvent(msg.eventName, msg.arg)((event) => {
+        const disposable = this._handler.handleEvent(msg.channel, msg.eventName, msg.arg)((event) => {
             this._send(( new EventMessage(this._workerId, req, event)));
         });
         this._pendingEvents.set(req, disposable);
@@ -199,45 +226,28 @@ class SimpleWorkerProtocol {
     }
 }
 class SimpleWorkerClient extends Disposable {
-    constructor(workerFactory, moduleId, host) {
+    constructor(workerFactory, workerDescriptor) {
         super();
-        let lazyProxyReject = null;
-        this._worker = this._register(workerFactory.create('vs/base/common/worker/simpleWorker', (msg) => {
+        this._localChannels = ( new Map());
+        this._remoteChannels = ( new Map());
+        this._worker = this._register(workerFactory.create({
+            amdModuleId: 'vs/base/common/worker/simpleWorker',
+            esmModuleLocation: workerDescriptor.esmModuleLocation,
+            label: workerDescriptor.label
+        }, (msg) => {
             this._protocol.handleMessage(msg);
         }, (err) => {
-            lazyProxyReject?.(err);
+            onUnexpectedError(err);
         }));
         this._protocol = ( new SimpleWorkerProtocol({
             sendMessage: (msg, transfer) => {
                 this._worker.postMessage(msg, transfer);
             },
-            handleMessage: (method, args) => {
-                if (typeof host[method] !== 'function') {
-                    return Promise.reject(( new Error('Missing method ' + method + ' on main thread host.')));
-                }
-                try {
-                    return Promise.resolve(host[method].apply(host, args));
-                }
-                catch (e) {
-                    return Promise.reject(e);
-                }
+            handleMessage: (channel, method, args) => {
+                return this._handleMessage(channel, method, args);
             },
-            handleEvent: (eventName, arg) => {
-                if (propertyIsDynamicEvent(eventName)) {
-                    const event = host[eventName].call(host, arg);
-                    if (typeof event !== 'function') {
-                        throw ( new Error(`Missing dynamic event ${eventName} on main thread host.`));
-                    }
-                    return event;
-                }
-                if (propertyIsEvent(eventName)) {
-                    const event = host[eventName];
-                    if (typeof event !== 'function') {
-                        throw ( new Error(`Missing event ${eventName} on main thread host.`));
-                    }
-                    return event;
-                }
-                throw ( new Error(`Malformed event name ${eventName}`));
+            handleEvent: (channel, eventName, arg) => {
+                return this._handleEvent(channel, eventName, arg);
             }
         }));
         this._protocol.setWorkerId(this._worker.getId());
@@ -245,38 +255,63 @@ class SimpleWorkerClient extends Disposable {
         if (typeof globalThis.requirejs !== 'undefined') {
             loaderConfiguration = globalThis.requirejs.s.contexts._.config;
         }
-        const hostMethods = getAllMethodNames(host);
-        this._onModuleLoaded = this._protocol.sendMessage(INITIALIZE, [
+        this._onModuleLoaded = this._protocol.sendMessage(DEFAULT_CHANNEL, INITIALIZE, [
             this._worker.getId(),
             JSON.parse(JSON.stringify(loaderConfiguration)),
-            moduleId,
-            hostMethods,
+            workerDescriptor.amdModuleId,
         ]);
-        const proxyMethodRequest = (method, args) => {
-            return this._request(method, args);
-        };
-        const proxyListen = (eventName, arg) => {
-            return this._protocol.listen(eventName, arg);
-        };
-        this._lazyProxy = ( new Promise((resolve, reject) => {
-            lazyProxyReject = reject;
-            this._onModuleLoaded.then((availableMethods) => {
-                resolve(createProxyObject(availableMethods, proxyMethodRequest, proxyListen));
-            }, (e) => {
-                reject(e);
-                this._onError('Worker failed to load ' + moduleId, e);
-            });
-        }));
+        this.proxy = this._protocol.createProxyToRemoteChannel(DEFAULT_CHANNEL, async () => { await this._onModuleLoaded; });
+        this._onModuleLoaded.catch((e) => {
+            this._onError('Worker failed to load ' + workerDescriptor.amdModuleId, e);
+        });
     }
-    getProxyObject() {
-        return this._lazyProxy;
+    _handleMessage(channelName, method, args) {
+        const channel = this._localChannels.get(channelName);
+        if (!channel) {
+            return Promise.reject(( new Error(`Missing channel ${channelName} on main thread`)));
+        }
+        if (typeof channel[method] !== 'function') {
+            return Promise.reject(( new Error(`Missing method ${method} on main thread channel ${channelName}`)));
+        }
+        try {
+            return Promise.resolve(channel[method].apply(channel, args));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
     }
-    _request(method, args) {
-        return ( new Promise((resolve, reject) => {
-            this._onModuleLoaded.then(() => {
-                this._protocol.sendMessage(method, args).then(resolve, reject);
-            }, reject);
-        }));
+    _handleEvent(channelName, eventName, arg) {
+        const channel = this._localChannels.get(channelName);
+        if (!channel) {
+            throw ( new Error(`Missing channel ${channelName} on main thread`));
+        }
+        if (propertyIsDynamicEvent(eventName)) {
+            const event = channel[eventName].call(channel, arg);
+            if (typeof event !== 'function') {
+                throw ( new Error(
+                    `Missing dynamic event ${eventName} on main thread channel ${channelName}.`
+                ));
+            }
+            return event;
+        }
+        if (propertyIsEvent(eventName)) {
+            const event = channel[eventName];
+            if (typeof event !== 'function') {
+                throw ( new Error(`Missing event ${eventName} on main thread channel ${channelName}.`));
+            }
+            return event;
+        }
+        throw ( new Error(`Malformed event name ${eventName}`));
+    }
+    setChannel(channel, handler) {
+        this._localChannels.set(channel, handler);
+    }
+    getChannel(channel) {
+        if (!( this._remoteChannels.has(channel))) {
+            const inst = this._protocol.createProxyToRemoteChannel(channel, async () => { await this._onModuleLoaded; });
+            this._remoteChannels.set(channel, inst);
+        }
+        return this._remoteChannels.get(channel);
     }
     _onError(message, error) {
         console.error(message);
@@ -289,74 +324,55 @@ function propertyIsEvent(name) {
 function propertyIsDynamicEvent(name) {
     return /^onDynamic/.test(name) && isUpperAsciiLetter(name.charCodeAt(9));
 }
-function createProxyObject(methodNames, invoke, proxyListen) {
-    const createProxyMethod = (method) => {
-        return function () {
-            const args = Array.prototype.slice.call(arguments, 0);
-            return invoke(method, args);
-        };
-    };
-    const createProxyDynamicEvent = (eventName) => {
-        return function (arg) {
-            return proxyListen(eventName, arg);
-        };
-    };
-    const result = {};
-    for (const methodName of methodNames) {
-        if (propertyIsDynamicEvent(methodName)) {
-            result[methodName] = createProxyDynamicEvent(methodName);
-            continue;
-        }
-        if (propertyIsEvent(methodName)) {
-            result[methodName] = proxyListen(methodName, undefined);
-            continue;
-        }
-        result[methodName] = createProxyMethod(methodName);
-    }
-    return result;
-}
 class SimpleWorkerServer {
     constructor(postMessage, requestHandlerFactory) {
+        this._localChannels = ( new Map());
+        this._remoteChannels = ( new Map());
         this._requestHandlerFactory = requestHandlerFactory;
         this._requestHandler = null;
         this._protocol = ( new SimpleWorkerProtocol({
             sendMessage: (msg, transfer) => {
                 postMessage(msg, transfer);
             },
-            handleMessage: (method, args) => this._handleMessage(method, args),
-            handleEvent: (eventName, arg) => this._handleEvent(eventName, arg)
+            handleMessage: (channel, method, args) => this._handleMessage(channel, method, args),
+            handleEvent: (channel, eventName, arg) => this._handleEvent(channel, eventName, arg)
         }));
     }
     onmessage(msg) {
         this._protocol.handleMessage(msg);
     }
-    _handleMessage(method, args) {
-        if (method === INITIALIZE) {
-            return this.initialize(args[0], args[1], args[2], args[3]);
+    _handleMessage(channel, method, args) {
+        if (channel === DEFAULT_CHANNEL && method === INITIALIZE) {
+            return this.initialize(args[0], args[1], args[2]);
         }
-        if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {
-            return Promise.reject(( new Error('Missing requestHandler or method: ' + method)));
+        const requestHandler = (channel === DEFAULT_CHANNEL ? this._requestHandler : this._localChannels.get(channel));
+        if (!requestHandler) {
+            return Promise.reject(( new Error(`Missing channel ${channel} on worker thread`)));
+        }
+        if (typeof requestHandler[method] !== 'function') {
+            return Promise.reject(( new Error(`Missing method ${method} on worker thread channel ${channel}`)));
         }
         try {
-            return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args));
+            return Promise.resolve(requestHandler[method].apply(requestHandler, args));
         }
         catch (e) {
             return Promise.reject(e);
         }
     }
-    _handleEvent(eventName, arg) {
-        if (!this._requestHandler) {
-            throw ( new Error(`Missing requestHandler`));
+    _handleEvent(channel, eventName, arg) {
+        const requestHandler = (channel === DEFAULT_CHANNEL ? this._requestHandler : this._localChannels.get(channel));
+        if (!requestHandler) {
+            throw ( new Error(`Missing channel ${channel} on worker thread`));
         }
         if (propertyIsDynamicEvent(eventName)) {
-            const event = this._requestHandler[eventName].call(this._requestHandler, arg);
+            const event = requestHandler[eventName].call(requestHandler, arg);
             if (typeof event !== 'function') {
                 throw ( new Error(`Missing dynamic event ${eventName} on request handler.`));
             }
             return event;
         }
         if (propertyIsEvent(eventName)) {
-            const event = this._requestHandler[eventName];
+            const event = requestHandler[eventName];
             if (typeof event !== 'function') {
                 throw ( new Error(`Missing event ${eventName} on request handler.`));
             }
@@ -364,18 +380,21 @@ class SimpleWorkerServer {
         }
         throw ( new Error(`Malformed event name ${eventName}`));
     }
-    initialize(workerId, loaderConfig, moduleId, hostMethods) {
+    setChannel(channel, handler) {
+        this._localChannels.set(channel, handler);
+    }
+    getChannel(channel) {
+        if (!( this._remoteChannels.has(channel))) {
+            const inst = this._protocol.createProxyToRemoteChannel(channel);
+            this._remoteChannels.set(channel, inst);
+        }
+        return this._remoteChannels.get(channel);
+    }
+    async initialize(workerId, loaderConfig, moduleId) {
         this._protocol.setWorkerId(workerId);
-        const proxyMethodRequest = (method, args) => {
-            return this._protocol.sendMessage(method, args);
-        };
-        const proxyListen = (eventName, arg) => {
-            return this._protocol.listen(eventName, arg);
-        };
-        const hostProxy = createProxyObject(hostMethods, proxyMethodRequest, proxyListen);
         if (this._requestHandlerFactory) {
-            this._requestHandler = this._requestHandlerFactory(hostProxy);
-            return Promise.resolve(getAllMethodNames(this._requestHandler));
+            this._requestHandler = this._requestHandlerFactory(this);
+            return;
         }
         if (loaderConfig) {
             if (typeof loaderConfig.baseUrl !== 'undefined') {
@@ -392,17 +411,7 @@ class SimpleWorkerServer {
             loaderConfig.catchError = true;
             globalThis.require.config(loaderConfig);
         }
-        return ( new Promise((resolve, reject) => {
-            const req = undefined;
-            req([moduleId], (module) => {
-                this._requestHandler = module.create(hostProxy);
-                if (!this._requestHandler) {
-                    reject(( new Error(`No RequestHandler!`)));
-                    return;
-                }
-                resolve(getAllMethodNames(this._requestHandler));
-            }, reject);
-        }));
+        return Promise.reject(( new Error(`Unexpected usage`)));
     }
 }
 export { SimpleWorkerClient, SimpleWorkerServer, logOnceWebWorkerWarning };