@lvce-editor/extension-host-worker 3.0.0 → 3.2.0

package/dist/extensionHostWorkerMain.js

@@ -89,7 +89,7 @@ const fn = value => {
   }
 };
 
-const state$a = {
+const state$b = {
   /** @type{any[]} */
   onDidOpenEditorListeners: [],
   /** @type{any[]} */
@@ -101,19 +101,19 @@ const state$a = {
   textDocuments: Object.create(null)
 };
 const setDocument = (textDocumentId, textDocument) => {
-  state$a.textDocuments[textDocumentId] = textDocument;
+  state$b.textDocuments[textDocumentId] = textDocument;
 };
 const getDidOpenListeners = () => {
-  return state$a.onDidSaveTextDocumentListeners;
+  return state$b.onDidSaveTextDocumentListeners;
 };
 const getWillChangeListeners = () => {
-  return state$a.onWillChangeEditorListeners;
+  return state$b.onWillChangeEditorListeners;
 };
 const getDidChangeListeners = () => {
-  return state$a.onDidChangeTextDocumentListeners;
+  return state$b.onDidChangeTextDocumentListeners;
 };
 const getDocument = textDocumentId => {
-  return state$a.textDocuments[textDocumentId];
+  return state$b.textDocuments[textDocumentId];
 };
 
 const getOffset$1 = (textDocument, position) => {
@@ -303,7 +303,7 @@ const syncIncremental = (textDocumentId, changes) => {
   textDocument.text = before + syntheticChange.inserted + after;
   runListenersSafe(getDidChangeListeners(), textDocument, syntheticChanges);
 };
-const get$5 = textDocumentId => {
+const get$6 = textDocumentId => {
   const textDocument = getDocument(textDocumentId);
   return textDocument;
 };
@@ -535,7 +535,7 @@ const registerMethod = ({
 }) => {
   context[`execute${name}Provider`] = async function (textDocumentId, ...params) {
     try {
-      const textDocument = get$5(textDocumentId);
+      const textDocument = get$6(textDocumentId);
       if (!textDocument) {
         throw new Error(`textDocument with id ${textDocumentId} not found`);
       }
@@ -571,7 +571,7 @@ const registerMethod = ({
     }
   };
 };
-const create$c = ({
+const create$a = ({
   name,
   resultShape,
   executeKey = '',
@@ -623,7 +623,7 @@ const {
   registerBraceCompletionProvider,
   executeBraceCompletionProvider,
   reset: reset$9
-} = create$c({
+} = create$a({
   name: 'BraceCompletion',
   resultShape: {
     type: Boolean
@@ -633,7 +633,7 @@ const {
 const {
   registerClosingTagProvider,
   executeClosingTagProvider
-} = create$c({
+} = create$a({
   name: 'ClosingTag',
   returnUndefinedWhenNoProviderFound: true,
   resultShape: {
@@ -645,7 +645,7 @@ const {
 const {
   registerCodeActionProvider,
   executeCodeActionProvider
-} = create$c({
+} = create$a({
   name: 'CodeAction',
   resultShape: {
     type: Array$1,
@@ -670,12 +670,12 @@ const executeOrganizeImports = async uid => {
   if (!organizeImportsAction) {
     return [];
   }
-  const textDocument = get$5(uid);
+  const textDocument = get$6(uid);
   const edits = await organizeImportsAction.execute(textDocument);
   return edits;
 };
 
-const state$9 = {
+const state$a = {
   commands: Object.create(null)
 };
 const getCommandDisplay = command => {
@@ -698,10 +698,10 @@ const registerCommand = command => {
     if (!command.execute) {
       throw new Error('command is missing execute function');
     }
-    if (command.id in state$9.commands) {
+    if (command.id in state$a.commands) {
       throw new Error(`command cannot be registered multiple times`);
     }
-    state$9.commands[command.id] = command;
+    state$a.commands[command.id] = command;
   } catch (error) {
     const commandDisplayId = getCommandDisplay(command);
     throw new VError(error, `Failed to register command${commandDisplayId}`);
@@ -709,7 +709,7 @@ const registerCommand = command => {
 };
 const executeCommand = async (id, ...args) => {
   try {
-    const command = state$9.commands[id];
+    const command = state$a.commands[id];
     if (!command) {
       throw new Error(`command ${id} not found`);
     }
@@ -728,7 +728,7 @@ const {
   registerCompletionProvider,
   executeCompletionProvider,
   executeresolveCompletionItemProvider
-} = create$c({
+} = create$a({
   name: 'Completion',
   resultShape: {
     type: Array$1,
@@ -748,40 +748,40 @@ const {
   }]
 });
 
-const state$8 = {
+const state$9 = {
   configuration: Object.create(null)
 };
 const getConfiguration = key => {
-  return state$8.configuration[key] ?? '';
+  return state$9.configuration[key] ?? '';
 };
 const setConfigurations = preferences => {
-  state$8.configuration = preferences;
+  state$9.configuration = preferences;
 };
 
-const state$7 = {
+const state$8 = {
   rpc: undefined
 };
-const invoke$1 = (method, ...params) => {
-  const rpc = state$7.rpc;
+const invoke$2 = (method, ...params) => {
+  const rpc = state$8.rpc;
   return rpc.invoke(method, ...params);
 };
 const send$1 = (method, ...params) => {
-  const rpc = state$7.rpc;
+  const rpc = state$8.rpc;
   return rpc.send(method, ...params);
 };
 const invokeAndTransfer$1 = (method, ...params) => {
-  const rpc = state$7.rpc;
+  const rpc = state$8.rpc;
   return rpc.invokeAndTransfer(method, ...params);
 };
 const setRpc = rpc => {
-  state$7.rpc = rpc;
+  state$8.rpc = rpc;
 };
 
-const state$6 = {
+const state$7 = {
   debugProviderMap: Object.create(null)
 };
 const getDebugProvider = id => {
-  const provider = state$6.debugProviderMap[id];
+  const provider = state$7.debugProviderMap[id];
   if (!provider) {
     // @ts-ignore
     throw new VError(`no debug provider "${id}" found`);
@@ -792,7 +792,7 @@ const registerDebugProvider = debugProvider => {
   if (!debugProvider.id) {
     throw new Error('Failed to register debug system provider: missing id');
   }
-  state$6.debugProviderMap[debugProvider.id] = debugProvider;
+  state$7.debugProviderMap[debugProvider.id] = debugProvider;
 };
 const start = async (protocol, path) => {
   try {
@@ -903,7 +903,7 @@ const {
   registerDefinitionProvider,
   executeDefinitionProvider,
   reset: reset$8
-} = create$c({
+} = create$a({
   name: 'Definition',
   resultShape: {
     allowUndefined: true,
@@ -925,7 +925,7 @@ const {
 const {
   registerDiagnosticProvider,
   executeDiagnosticProvider
-} = create$c({
+} = create$a({
   name: 'Diagnostic',
   resultShape: {
     type: Array$1,
@@ -937,7 +937,7 @@ const {
 
 const showInformationMessage = message => {
   string(message);
-  const result = invoke$1('ExtensionHostDialog.showInformationMessage', message);
+  const result = invoke$2('ExtensionHostDialog.showInformationMessage', message);
   return result;
 };
 
@@ -948,7 +948,7 @@ const exec = async (command, args, options) => {
 };
 
 const fileSystemProviderMap = Object.create(null);
-const get$4 = protocol => {
+const get$5 = protocol => {
   const provider = fileSystemProviderMap[protocol];
   if (!provider) {
     // @ts-ignore
@@ -971,7 +971,7 @@ const registerFileSystemProvider = fileSystemProvider => {
 };
 const readDirWithFileTypes = async (protocol, path) => {
   try {
-    const provider = get$4(protocol);
+    const provider = get$5(protocol);
     return await provider.readDirWithFileTypes(path);
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -979,7 +979,7 @@ const readDirWithFileTypes = async (protocol, path) => {
 };
 const readFile = async (protocol, path) => {
   try {
-    const provider = get$4(protocol);
+    const provider = get$5(protocol);
     return await provider.readFile(path);
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -992,7 +992,7 @@ const readFileExternal = async path => {
   // this avoid parsing the potentially large message
   // and improve performance by not blocking the renderer worker
   // when reading / writing large files
-  const content = await invoke$1('FileSystem.readFile', path);
+  const content = await invoke$2('FileSystem.readFile', path);
   return content;
 };
 const readDirWithFileTypesExternal = async path => {
@@ -1002,12 +1002,12 @@ const readDirWithFileTypesExternal = async path => {
   // this avoid parsing the potentially large message
   // and improve performance by not blocking the renderer worker
   // when reading / writing large files
-  const content = await invoke$1('FileSystem.readDirWithFileTypes', path);
+  const content = await invoke$2('FileSystem.readDirWithFileTypes', path);
   return content;
 };
 const writeFile = async (protocol, uri, content) => {
   try {
-    const provider = get$4(protocol);
+    const provider = get$5(protocol);
     return await provider.writeFile(uri, content);
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -1015,7 +1015,7 @@ const writeFile = async (protocol, uri, content) => {
 };
 const getPathSeparator = protocol => {
   try {
-    const provider = get$4(protocol);
+    const provider = get$5(protocol);
     return provider.pathSeparator;
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -1026,7 +1026,7 @@ const {
   registerFormattingProvider,
   executeFormattingProvider,
   reset: reset$7
-} = create$c({
+} = create$a({
   name: 'Formatting',
   executeKey: 'format',
   resultShape: {
@@ -1088,7 +1088,7 @@ const {
   registerHoverProvider,
   executeHoverProvider,
   reset: reset$6
-} = create$c({
+} = create$a({
   name: 'Hover',
   resultShape: {
     allowUndefined: true,
@@ -1101,7 +1101,7 @@ const {
   registerImplementationProvider,
   executeImplementationProvider,
   reset: reset$5
-} = create$c({
+} = create$a({
   name: 'Implementation',
   resultShape: {
     type: Array$1,
@@ -1115,131 +1115,6 @@ const WebSocket$1 = 5;
 const ElectronMessagePort = 6;
 const ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1 = 7;
 
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
-};
-
-const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
-
-const create$b = async ({
-  url,
-  name
-}) => {
-  string(url);
-  string(name);
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  await invokeAndTransfer$1('IpcParent.create', {
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    url,
-    name,
-    raw: true,
-    port: port1
-  });
-  return port2;
-};
-const wrap$5 = port => {
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    handleMessage: undefined,
-    get onmessage() {
-      return this.handleMessage;
-    },
-    set onmessage(listener) {
-      if (listener) {
-        // @ts-ignore
-        this.handleMessage = event => {
-          // TODO why are some events not instance of message event?
-          if (event instanceof MessageEvent) {
-            const message = event.data;
-            // @ts-ignore
-            listener(message, event);
-          } else {
-            // @ts-ignore
-
-            listener(event);
-          }
-        };
-      } else {
-        // @ts-ignore
-        this.handleMessage = null;
-      }
-      this.port.onmessage = this.handleMessage;
-    },
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message, transfer) {
-      this.port.postMessage(message, transfer);
-    }
-  };
-};
-
-const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
-  __proto__: null,
-  create: create$b,
-  wrap: wrap$5
-};
-
-const sendMessagePortToElectron = async (port, initialCommand) => {
-  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
-};
-
-const getPort = async type => {
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  await sendMessagePortToElectron(port1, 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess');
-  return port2;
-};
-const create$a = async ({
-  type
-}) => {
-  const port = await getPort();
-  return port;
-};
-const wrap$4 = port => {
-  let handleMessage;
-  return {
-    get onmessage() {
-      return handleMessage;
-    },
-    set onmessage(listener) {
-      let handleMessage;
-      if (listener) {
-        handleMessage = event => {
-          listener(event.data);
-        };
-      } else {
-        handleMessage = null;
-      }
-      port.onmessage = handleMessage;
-    },
-    send(message) {
-      port.postMessage(message);
-    }
-  };
-};
-
-const IpcParentWithElectronMessagePort = {
-  __proto__: null,
-  create: create$a,
-  wrap: wrap$4
-};
-
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -1528,12 +1403,6 @@ class IpcChildWithModuleWorker extends Ipc {
 const wrap$f = global => {
   return new IpcChildWithModuleWorker(global);
 };
-const IpcChildWithModuleWorker$1 = {
-  __proto__: null,
-  listen: listen$7,
-  signal: signal$8,
-  wrap: wrap$f
-};
 const withResolvers = () => {
   let _resolve;
   const promise = new Promise(resolve => {
@@ -1545,7 +1414,7 @@ const withResolvers = () => {
     promise
   };
 };
-const waitForFirstMessage$1 = async port => {
+const waitForFirstMessage = async port => {
   const {
     resolve,
     promise
@@ -1561,7 +1430,7 @@ const listen$6 = async () => {
   const parentIpcRaw = listen$7();
   signal$8(parentIpcRaw);
   const parentIpc = wrap$f(parentIpcRaw);
-  const firstMessage = await waitForFirstMessage$1(parentIpc);
+  const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError('unexpected first message');
   }
@@ -1651,6 +1520,61 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   }
   return promise;
 };
+const Message$1 = 3;
+const create$5$2 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    type,
+    event
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    throw new Error('not implemented');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$2,
+  signal: signal$1,
+  wrap: wrap$5
+};
 const stringifyCompact = value => {
   return JSON.stringify(value);
 };
@@ -1703,139 +1627,17 @@ let IpcParentWithWebSocket$1 = class IpcParentWithWebSocket extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
 };
-const wrap$3 = webSocket => {
+const wrap$1 = webSocket => {
   return new IpcParentWithWebSocket$1(webSocket);
 };
 const IpcParentWithWebSocket$1$1 = {
   __proto__: null,
   create: create$9,
-  wrap: wrap$3
-};
-
-const getWebSocketProtocol = () => {
-  return location.protocol === 'https:' ? 'wss:' : 'ws:';
-};
-
-const getWebSocketUrl = type => {
-  const wsProtocol = getWebSocketProtocol();
-  return `${wsProtocol}//${location.host}/websocket/${type}`;
-};
-
-const create$8 = async ({
-  type
-}) => {
-  string(type);
-  const wsUrl = getWebSocketUrl(type);
-  const webSocket = new WebSocket(wsUrl);
-  return IpcParentWithWebSocket$1$1.create({
-    webSocket
-  });
-};
-const wrap$2 = webSocket => {
-  return IpcParentWithWebSocket$1$1.wrap(webSocket);
-};
-
-const IpcParentWithWebSocket = {
-  __proto__: null,
-  create: create$8,
-  wrap: wrap$2
-};
-
-const Electron = 'electron';
-const Remote = 'remote';
-const Web = 'web';
-const Test = 'test';
-
-const getPlatform = () => {
-  // @ts-ignore
-  if (typeof PLATFORM !== 'undefined') {
-    // @ts-ignore
-    return PLATFORM;
-  }
-  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-    return Test;
-  }
-  // TODO find a better way to pass runtime environment
-  if (typeof name !== 'undefined' && name.endsWith('(Electron)')) {
-    return Electron;
-  }
-  if (typeof name !== 'undefined' && name.endsWith('(Web)')) {
-    return Web;
-  }
-  return Remote;
-};
-const platform = getPlatform(); // TODO tree-shake this out in production
-
-const getModule$3 = () => {
-  switch (platform) {
-    case Remote:
-      return IpcParentWithWebSocket;
-    default:
-      return IpcParentWithElectronMessagePort;
-  }
-};
-const create$7 = async ({
-  type,
-  raw
-}) => {
-  const module = getModule$3();
-  const rawIpc = await module.create({
-    type
-  });
-  if (raw) {
-    return rawIpc;
-  }
-  return {
-    module,
-    rawIpc
-  };
-};
-const wrap$1 = ({
-  module,
-  rawIpc
-}) => {
-  return module.wrap(rawIpc);
-};
-
-const IpcParentWithNode = {
-  __proto__: null,
-  create: create$7,
   wrap: wrap$1
 };
 
-const getModule$2 = method => {
-  switch (method) {
-    case WebSocket$1:
-      return IpcParentWithWebSocket;
-    case ElectronMessagePort:
-      return IpcParentWithNode;
-    case ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1:
-      return IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug;
-    default:
-      throw new Error('unexpected ipc type');
-  }
-};
-
-const create$6 = async ({
-  method,
-  ...options
-}) => {
-  try {
-    const module = getModule$2(method);
-    // @ts-ignore
-    const rawIpc = await module.create(options);
-    // @ts-ignore
-    const ipc = module.wrap(rawIpc);
-    return ipc;
-  } catch (error) {
-    throw new VError(error, `Failed to create ipc`);
-  }
-};
-
-const JsonRpc = 1;
-
 const Two = '2.0';
-const create$4 = (method, params) => {
+const create$4$1 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -1846,7 +1648,7 @@ const callbacks = Object.create(null);
 const set$3 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get$3 = id => {
+const get$4 = id => {
   return callbacks[id];
 };
 const remove = id => {
@@ -2019,7 +1821,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$3(id);
+  const fn = get$4(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -2058,7 +1860,7 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$1 = (message, error) => {
+const create$1$2 = (message, error) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -2069,9 +1871,9 @@ const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(message, errorProperty);
+  return create$1$2(message, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$8 = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -2080,7 +1882,7 @@ const create$5 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$8(message, resultProperty);
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
@@ -2170,87 +1972,356 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   return unwrapJsonRpcResult(responseMessage);
 };
 const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
+  const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke = (ipc, method, ...params) => {
+const invoke$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
-const preparePrettyError$2 = error => {
-  return error;
+const commands = Object.create(null);
+const register$1 = commandMap => {
+  Object.assign(commands, commandMap);
 };
-const logError$2 = error => {
-  // handled by renderer worker
+const getCommand = key => {
+  return commands[key];
 };
-const requiresSocket$2 = () => {
-  return false;
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new Error(`command not found ${command}`);
+  }
+  return fn(...args);
 };
-const create$3 = ({
-  ipc,
-  execute
-}) => {
-  object(ipc);
-  fn(execute);
-  const handleMessage = async message => {
-    return handleJsonRpcMessage(ipc, message, execute, resolve, preparePrettyError$2, logError$2, requiresSocket$2);
-  };
-  ipc.onmessage = handleMessage;
-  return {
+
+const createRpc$1 = ipc => {
+  const rpc = {
+    // @ts-ignore
     ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      send(ipc, method, ...params);
+    },
     invoke(method, ...params) {
-      return invoke(this.ipc, method, ...params);
+      return invoke$1(ipc, method, ...params);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeAndTransfer(ipc, method, ...params);
     }
   };
+  return rpc;
 };
-
-const RpcParentWithJsonRpc = {
-  __proto__: null,
-  create: create$3
+const requiresSocket = () => {
+  return false;
 };
-
-const getModule$1 = method => {
-  switch (method) {
-    case JsonRpc:
-      return RpcParentWithJsonRpc;
-    default:
-      throw new Error('unexpected rpc type');
-  }
+const preparePrettyError = error => {
+  return error;
 };
-
-const create$2 = async ({
-  method,
-  ...options
+const logError = () => {
+  // handled by renderer worker
+};
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+};
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+const listen$1 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+const create$6$1 = async ({
+  commandMap,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$1(commandMap);
+  const ipc = await listen$1(IpcChildWithMessagePort$1, {
+    port: messagePort
+  });
+  handleIpc(ipc);
+  const rpc = createRpc$1(ipc);
+  return rpc;
+};
+const MessagePortRpcClient = {
+  __proto__: null,
+  create: create$6$1
+};
+const create$5$1 = async ({
+  commandMap,
+  messagePort,
+  isMessagePortOpen
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$1(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc$1(ipc);
+  return rpc;
+};
+const MessagePortRpcParent = {
+  __proto__: null,
+  create: create$5$1
+};
+const create$1$1 = async ({
+  commandMap,
+  webSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$1(commandMap);
+  const rawIpc = await IpcParentWithWebSocket$1$1.create({
+    webSocket
+  });
+  const ipc = IpcParentWithWebSocket$1$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc$1(ipc);
+  return rpc;
+};
+const WebSocketRpcParent = {
+  __proto__: null,
+  create: create$1$1
+};
+const create$7 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$1(commandMap);
+  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
+  handleIpc(ipc);
+  const rpc = createRpc$1(ipc);
+  return rpc;
+};
+const WebWorkerRpcClient = {
+  __proto__: null,
+  create: create$7
+};
+
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
+
+const sendPort = async ({
+  url,
+  name,
+  port
+}) => {
+  await invokeAndTransfer$1('IpcParent.create', {
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    url,
+    name,
+    raw: true,
+    port
+  });
+};
+const create$6 = async ({
+  url,
+  name,
+  commandMap
+}) => {
+  string(url);
+  string(name);
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  const rpcPromise = MessagePortRpcParent.create({
+    messagePort: port2,
+    isMessagePortOpen: true,
+    commandMap
+  });
+  // TODO rpc module should start port
+  port2.start();
+  await sendPort({
+    url,
+    name,
+    port: port1
+  });
+  const rpc = await rpcPromise;
+  return rpc;
+};
+
+const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
+  __proto__: null,
+  create: create$6
+};
+
+const sendMessagePortToElectron = async (port, initialCommand) => {
+  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
+};
+
+const getPort = async type => {
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  await sendMessagePortToElectron(port1, 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess');
+  return port2;
+};
+const create$5 = async ({
+  type
 }) => {
-  const module = await getModule$1(method);
+  const port = await getPort();
+  const rpc = await MessagePortRpcParent.create({
+    messagePort: port,
+    isMessagePortOpen: true,
+    commandMap: {}
+  });
+  return rpc;
+};
+
+const IpcParentWithElectronMessagePort = {
+  __proto__: null,
+  create: create$5
+};
+
+const getWebSocketProtocol = () => {
+  return location.protocol === 'https:' ? 'wss:' : 'ws:';
+};
+
+const getWebSocketUrl = type => {
+  const wsProtocol = getWebSocketProtocol();
+  return `${wsProtocol}//${location.host}/websocket/${type}`;
+};
+
+const create$4 = async ({
+  type
+}) => {
+  string(type);
+  const wsUrl = getWebSocketUrl(type);
+  const webSocket = new WebSocket(wsUrl);
+  const rpc = await WebSocketRpcParent.create({
+    webSocket,
+    commandMap: {}
+  });
+  return rpc;
+};
+
+const IpcParentWithWebSocket = {
+  __proto__: null,
+  create: create$4
+};
+
+const Electron = 'electron';
+const Remote = 'remote';
+const Web = 'web';
+const Test = 'test';
+
+const getPlatform = () => {
   // @ts-ignore
-  const rpc = module.create(options);
+  if (typeof PLATFORM !== 'undefined') {
+    // @ts-ignore
+    return PLATFORM;
+  }
+  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+    return Test;
+  }
+  // TODO find a better way to pass runtime environment
+  if (typeof name !== 'undefined' && name.endsWith('(Electron)')) {
+    return Electron;
+  }
+  if (typeof name !== 'undefined' && name.endsWith('(Web)')) {
+    return Web;
+  }
+  return Remote;
+};
+const platform = getPlatform(); // TODO tree-shake this out in production
+
+const getModule$1 = platform => {
+  switch (platform) {
+    case Remote:
+      return IpcParentWithWebSocket;
+    default:
+      return IpcParentWithElectronMessagePort;
+  }
+};
+const create$3 = async ({
+  type,
+  raw
+}) => {
+  const module = getModule$1(platform);
+  const rpc = await module.create({
+    type
+  });
   return rpc;
 };
 
-const defaultExecute$2 = () => {
+const IpcParentWithNode = {
+  __proto__: null,
+  create: create$3
+};
+
+const getModule = method => {
+  switch (method) {
+    case WebSocket$1:
+      return IpcParentWithWebSocket;
+    case ElectronMessagePort:
+      return IpcParentWithNode;
+    case ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1:
+      return IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug;
+    default:
+      throw new Error('unexpected ipc type');
+  }
+};
+
+const create$2 = async ({
+  method,
+  ...options
+}) => {
+  try {
+    const module = getModule(method);
+    // @ts-ignore
+    const rpc = await module.create(options);
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create rpc`);
+  }
+};
+
+const defaultExecute = () => {
   throw new Error('not implemented');
 };
 const createNodeRpc = async ({
   path,
-  execute = defaultExecute$2,
+  execute = defaultExecute,
   name = ''
 }) => {
   try {
     string(path);
     fn(execute);
-    const ipc = await create$6({
+    const rpc = await create$2({
       method: ElectronMessagePort,
       type: 'extension-host-helper-process',
-      name
-    });
-    const rpc = await create$2({
-      ipc,
-      method: JsonRpc,
-      execute
+      name,
+      commandMap: {}
     });
     await rpc.invoke('LoadFile.loadFile', path);
     return rpc;
@@ -2261,7 +2332,7 @@ const createNodeRpc = async ({
 
 const confirm = message => {
   string(message);
-  const result = invoke$1('ConfirmPrompt.prompt', message);
+  const result = invoke$2('ConfirmPrompt.prompt', message);
   return result;
 };
 
@@ -2273,7 +2344,7 @@ const showQuickPick = async ({
 }) => {
   const rawPicks = await getPicks();
   const picks = rawPicks.map(toPick);
-  return invoke$1(ExtensionHostQuickPickShow, picks);
+  return invoke$2(ExtensionHostQuickPickShow, picks);
 };
 
 const {
@@ -2281,7 +2352,7 @@ const {
   executeReferenceProvider,
   executefileReferenceProvider,
   reset: reset$4
-} = create$c({
+} = create$a({
   name: 'Reference',
   resultShape: {
     type: Array$1,
@@ -2308,7 +2379,7 @@ const {
   executeRenameProvider,
   executeprepareRenameProvider,
   reset: reset$3
-} = create$c({
+} = create$a({
   name: 'Rename',
   resultShape: {
     type: Object$1,
@@ -2333,11 +2404,7 @@ const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
 const set$2 = async (url, contentSecurityPolicy) => {
   const pathName = new URL(url).pathname;
-  await invoke$1('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
-};
-
-const defaultExecute$1 = () => {
-  throw new Error('not implemented');
+  await invoke$2('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
 };
 
 /**
@@ -2347,25 +2414,27 @@ const defaultExecute$1 = () => {
 const createLegacyRpc = async ({
   url,
   name,
-  execute = defaultExecute$1,
+  execute,
+  commandMap = {},
   contentSecurityPolicy
 }) => {
   string(url);
   string(name);
-  fn(execute);
+  object(commandMap);
   if (contentSecurityPolicy) {
     await set$2(url, contentSecurityPolicy);
   }
-  const ipc = await create$6({
+  const rpc = await create$2({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     url: extensionHostSubWorkerUrl,
-    name
-  });
-  const rpc = await create$2({
-    ipc,
-    method: JsonRpc,
-    execute
+    name,
+    commandMap
   });
+  if (execute) {
+    // deprecated
+    // @ts-ignore
+    rpc.ipc.execute = execute;
+  }
   await rpc.invoke('LoadFile.loadFile', url);
   return rpc;
 };
@@ -2374,92 +2443,92 @@ const rpcs$1 = Object.create(null);
 const add$1 = (id, rpc) => {
   rpcs$1[id] = rpc;
 };
-const get$2 = id => {
+const get$3 = id => {
   return rpcs$1[id];
 };
 
 const registry = Object.create(null);
 const rpcs = Object.create(null);
-const register$1 = (id, execute) => {
+const register = (id, execute) => {
   registry[id] = execute;
 };
-const acquire = id => {
-  const fn = registry[id];
-  delete registry[id];
-  return fn;
-};
-const get$1 = id => {
+const get$2 = id => {
   return rpcs[id];
 };
 const set$1 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 
-const createRpcWithId$1 = async id => {
-  const fn = acquire(id);
-  const info = get$2(id);
+const createRpcWithId$1 = async (id, commandMap, execute) => {
+  const info = get$3(id);
   if (!info) {
     throw new Error(`rpc with id ${id} not found`);
   }
-  const ipc = await create$6({
+  const rpc = await create$2({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     url: extensionHostSubWorkerUrl,
-    name: info.name
+    name: info.name,
+    commandMap,
+    isMessagePortOpen: true
   });
-  const newRpc = await create$2({
-    ipc,
-    method: JsonRpc,
-    execute: fn
-  });
-  await newRpc.invoke('LoadFile.loadFile', info.url);
-  set$1(id, newRpc);
-  return newRpc;
+  if (execute) {
+    // @ts-ignore
+    rpc.ipc.execute = execute;
+  }
+  await rpc.invoke('LoadFile.loadFile', info.url);
+  set$1(id, rpc);
+  return rpc;
 };
 
-const getOrCreateRpc = async id => {
-  const rpc = get$1(id);
+const getOrCreateRpc = async (id, commandMap, execute) => {
+  const rpc = get$2(id);
   if (!rpc) {
-    set$1(id, createRpcWithId$1(id));
+    set$1(id, createRpcWithId$1(id, commandMap, execute));
   }
-  return get$1(id);
+  return get$2(id);
 };
 const createRpcWithId = ({
   id,
+  commandMap,
   execute
 }) => {
   string(id);
-  register$1(id, execute);
+  register(id, commandMap);
   const lazyRpc = {
     async invoke(method, ...params) {
-      const rpc = await getOrCreateRpc(id);
+      const rpc = await getOrCreateRpc(id, commandMap, execute);
       return rpc.invoke(method, ...params);
     }
   };
   return lazyRpc;
 };
 
-const defaultExecute = () => {
-  throw new Error('not implemented');
-};
-const createRpc$1 = ({
+const createRpc = ({
   id,
   url,
   name,
-  execute = defaultExecute,
-  contentSecurityPolicy
+  commandMap,
+  contentSecurityPolicy,
+  execute
 }) => {
   try {
+    if (execute && !commandMap) {
+      console.info(`[extension-host-worker] The rpc execute function is deprecated. Use the commandMap property instead.`);
+    }
+    commandMap ||= {};
     if (id) {
       string(id);
       return createRpcWithId({
         id,
-        execute
+        execute,
+        commandMap
       });
     }
     return createLegacyRpc({
       url,
       name,
       execute,
+      commandMap,
       contentSecurityPolicy
     });
   } catch (error) {
@@ -2471,7 +2540,7 @@ const {
   registerSelectionProvider,
   executeSelectionProvider,
   reset: reset$2
-} = create$c({
+} = create$a({
   name: 'Selection',
   resultShape: {
     allowUndefined: true,
@@ -2482,17 +2551,17 @@ const {
   }
 });
 
-const state$5 = {
+const state$6 = {
   providers: Object.create(null)
 };
 const registerSourceControlProvider = provider => {
-  state$5.providers[provider.id] = provider;
+  state$6.providers[provider.id] = provider;
 };
 const getFilesFromProvider = provider => {
   return provider.getChangedFiles();
 };
 const getChangedFiles = async providerId => {
-  const provider = state$5.providers[providerId];
+  const provider = state$6.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -2503,7 +2572,7 @@ const getChangedFiles = async providerId => {
 const getFileBefore = async (providerId, uri) => {
   string(providerId);
   string(uri);
-  const provider = state$5.providers[providerId];
+  const provider = state$6.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -2525,7 +2594,7 @@ const getGroupsFromProvider = async (provider, cwd) => {
   throw new Error('source control provider is missing required function getGroups');
 };
 const getGroups = async (providerId, cwd) => {
-  const provider = state$5.providers[providerId];
+  const provider = state$6.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -2533,14 +2602,14 @@ const getGroups = async (providerId, cwd) => {
   return groups;
 };
 const acceptInput = async (providerId, value) => {
-  const provider = state$5.providers[providerId];
+  const provider = state$6.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
   await provider.acceptInput(value);
 };
 const add = async path => {
-  const provider = Object.values(state$5.providers)[0];
+  const provider = Object.values(state$6.providers)[0];
   if (!provider) {
     return;
   }
@@ -2548,7 +2617,7 @@ const add = async path => {
   await provider.add(path);
 };
 const discard = async path => {
-  const provider = Object.values(state$5.providers)[0];
+  const provider = Object.values(state$6.providers)[0];
   if (!provider) {
     return;
   }
@@ -2558,7 +2627,7 @@ const discard = async path => {
 const getEnabledProviderIds = async (scheme, root) => {
   string(scheme);
   string(root);
-  const providers = Object.values(state$5.providers);
+  const providers = Object.values(state$6.providers);
   const enabledIds = [];
   for (const provider of providers) {
     // @ts-ignore
@@ -2579,7 +2648,7 @@ const {
   registerTabCompletionProvider,
   executeTabCompletionProvider,
   reset: reset$1
-} = create$c({
+} = create$a({
   name: 'TabCompletion',
   resultShape: {
     type: Object$1,
@@ -2587,7 +2656,7 @@ const {
   }
 });
 
-const state$4 = {
+const state$5 = {
   textSearchProviders: Object.create(null)
 };
 const registerTextSearchProvider = textSearchProvider => {
@@ -2598,14 +2667,14 @@ const registerTextSearchProvider = textSearchProvider => {
     if (!textSearchProvider.scheme) {
       throw new Error('textSearchProvider is missing scheme');
     }
-    state$4.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
+    state$5.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
   } catch (error) {
     throw new VError(error, 'Failed to register text search provider');
   }
 };
 const executeTextSearchProvider = async (scheme, query) => {
   try {
-    const textSearchProvider = state$4.textSearchProviders[scheme];
+    const textSearchProvider = state$5.textSearchProviders[scheme];
     if (!textSearchProvider) {
       throw new Error(`No text search provider for ${scheme} found`);
     }
@@ -2620,7 +2689,7 @@ const {
   registerTypeDefinitionProvider,
   executeTypeDefinitionProvider,
   reset
-} = create$c({
+} = create$a({
   name: 'TypeDefinition',
   resultShape: {
     allowUndefined: true,
@@ -2648,38 +2717,6 @@ const getProtocol = uri => {
   return '';
 };
 
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`command not found ${command}`);
-  }
-  return fn(...args);
-};
-
-const requiresSocket$1 = () => {
-  return false;
-};
-const preparePrettyError$1 = error => {
-  return error;
-};
-const logError$1 = error => {
-  // handled by renderer worker
-};
-const handleMessage$1 = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError$1, logError$1, requiresSocket$1);
-};
-
-const handleIpc$1 = ipc => {
-  ipc.addEventListener('message', handleMessage$1);
-};
-
 const createWebViewIpc = async webView => {
   const {
     uid,
@@ -2689,39 +2726,17 @@ const createWebViewIpc = async webView => {
     port1,
     port2
   } = getPortTuple();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  port2.onmessage = resolve;
+  const rpcPromise = MessagePortRpcParent.create({
+    messagePort: port2,
+    isMessagePortOpen: false,
+    commandMap: {}
+  });
   const portType = 'test';
   await invokeAndTransfer$1('WebView.setPort', uid, port1, origin, portType);
-  const event = await promise;
-  // @ts-ignore
-  if (event.data !== 'ready') {
-    throw new Error('unexpected first message');
-  }
-  const ipc = {
-    addEventListener(type, listener) {
-      const that = this;
-      const wrapped = event => {
-        const actualEvent = {
-          target: that,
-          data: event.data
-        };
-        listener(actualEvent);
-      };
-      port2.addEventListener(type, wrapped);
-    },
-    dispose() {},
-    send(message) {
-      port2.postMessage(message);
-    }
-  };
   // TODO maybe don't send a message port only to get object url?
-  // TODO dispose ipc to avoid memory leak
-  handleIpc$1(ipc);
-  return ipc;
+  // TODO dispose rpc to avoid memory leak
+  const rpc = await rpcPromise;
+  return rpc;
 };
 
 const webViews = Object.create(null);
@@ -2754,8 +2769,8 @@ const getRemoteUrlForWebView = async (uri, options = {}) => {
   if (!webView) {
     throw new Error(`webview ${options.webViewId} not found`);
   }
-  const [ipc, blob] = await Promise.all([createWebViewIpc(webView), invoke$1('FileSystem.getBlob', uri)]);
-  const objectUrl = await invoke(ipc, 'createObjectUrl', blob);
+  const [rpc, blob] = await Promise.all([createWebViewIpc(webView), invoke$2('FileSystem.getBlob', uri)]);
+  const objectUrl = await rpc.invoke('createObjectUrl', blob);
   return objectUrl;
 };
 
@@ -2779,22 +2794,12 @@ const getRemoteUrl = async (uri, options = {}) => {
     return getRemoteUrlForWebView(uri, options);
   }
   if (uri.startsWith('html://')) {
-    const url = await invoke$1('Blob.getSrc', uri);
+    const url = await invoke$2('Blob.getSrc', uri);
     return url;
   }
   throw new Error(`unsupported platform for remote url`);
 };
 
-const waitForFirstMessage = async port => {
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  port.onmessage = resolve;
-  const firstMessage = await promise;
-  return firstMessage;
-};
-
 // TODO pass uuid to allow having multiple webviews open at the same time
 const createWebView = async (providerId, port, uri, uid, origin, webView) => {
   const provider = getProvider(providerId);
@@ -2804,63 +2809,24 @@ const createWebView = async (providerId, port, uri, uid, origin, webView) => {
 
   // TODO cancel promise when webview is disposed before sending message
   // TODO handle case when webview doesn't send ready message
-  // TODO handle error
-  await waitForFirstMessage(port);
 
-  // TODO use ipc module
-  const handlePortMessage = async event => {
-    const {
-      data,
-      target
-    } = event;
-    const {
-      method,
-      params,
-      id
-    } = data;
-    if (id && !method) {
-      resolve(id, data);
-      return;
-    }
-    if (provider && provider.commands && provider.commands[method]) {
-      const fn = provider.commands[method];
-      const result = await fn(...params);
-      if (id && method) {
-        target.postMessage({
-          jsonrpc: '2.0',
-          id,
-          result
-        });
-      }
-    }
-  };
-  port.onmessage = handlePortMessage;
-  const rpc = {
+  const rpc = await MessagePortRpcParent.create({
+    messagePort: port,
+    isMessagePortOpen: false,
+    commandMap: provider.commands || {}
+  });
+  const outer = {
     uri,
     provider,
     uid,
     origin,
     webView,
     async invoke(method, ...params) {
-      const {
-        id,
-        promise
-      } = registerPromise();
-      port.postMessage({
-        jsonrpc: '2.0',
-        id,
-        method,
-        params
-      });
-      const result = await promise;
-      if (result.error) {
-        throw new Error(`Error: ${result.error.message}`);
-      }
-      return result.result;
+      return rpc.invoke(method, ...params);
     }
   };
   // TODO allow creating multiple webviews per provider
-  setWebView(providerId, rpc);
+  setWebView(providerId, outer);
 };
 const disposeWebView = id => {
   // TODO race condition
@@ -2886,22 +2852,22 @@ const createWorker = async ({
   string(method);
   string(url);
   string(name);
-  const ipc = create$6({
+  const rpc = create$2({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     url,
     name
   });
-  return ipc;
+  return rpc;
 };
 
-const state$3 = {
+const state$4 = {
   workspacePath: ''
 };
 const setWorkspacePath = path => {
-  state$3.workspacePath = path;
+  state$4.workspacePath = path;
 };
 const getWorkspaceFolder = path => {
-  return state$3.workspacePath;
+  return state$4.workspacePath;
 };
 
 class FormattingError extends Error {
@@ -2974,7 +2940,7 @@ const api = {
   registerHoverProvider: registerHoverProvider,
   executeHoverProvider: executeHoverProvider,
   // Rpc
-  createRpc: createRpc$1,
+  createRpc: createRpc,
   createNodeRpc: createNodeRpc,
   // Implementation
   registerImplementationProvider: registerImplementationProvider,
@@ -3054,7 +3020,7 @@ const handleUnhandledRejection = event => {
   console.error(output);
 };
 
-const state$2 = {
+const state$3 = {
   /**
    * @type {any[]}
    */
@@ -3062,10 +3028,10 @@ const state$2 = {
 };
 const addError = error => {
   // @ts-ignore
-  state$2.errors.push(error);
+  state$3.errors.push(error);
 };
 const hasRecentErrors = () => {
-  return state$2.errors.length > 0;
+  return state$3.errors.length > 0;
 };
 const getRecentError = () => {
 };
@@ -3105,65 +3071,95 @@ const setup = ({
   global.vscode = api;
 };
 
-const createRpc = ipc => {
-  const rpc = {
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
-    }
-  };
-  return rpc;
-};
-const requiresSocket = () => {
-  return false;
+const getAssetDir = () => {
+  // @ts-ignore
+  if (typeof ASSET_DIR !== 'undefined') {
+    // @ts-ignore
+    return ASSET_DIR;
+  }
+  if (platform === Electron) {
+    return '../../../../..';
+  }
+  return '';
 };
-const preparePrettyError = error => {
-  return error;
+const assetDir = getAssetDir();
+
+const iframeWorkerUrl = `${assetDir}/packages/renderer-worker/node_modules/@lvce-editor/iframe-worker/dist/iframeWorkerMain.js`;
+
+const get$1 = key => {
+  return invoke$2('Preferences.get', key);
 };
-const logError = () => {
-  // handled by renderer worker
+
+const getConfiguredIframeWorkerUrl = async () => {
+  let configuredWorkerUrl = (await get$1('develop.iframeWorkerPath')) || '';
+  if (configuredWorkerUrl) {
+    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
+  }
+  configuredWorkerUrl = configuredWorkerUrl || iframeWorkerUrl;
+  return configuredWorkerUrl;
 };
-const handleMessage = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, actualRequiresSocket);
+
+const state$2 = {
+  id: 0
+};
+const create$1 = () => {
+  return ++state$2.id;
+};
+
+const commandMap$1 = {
+  'WebView.compatExtensionHostWorkerInvoke': (...args) => invoke$2('WebView.compatExtensionHostWorkerInvoke', ...args),
+  'WebView.compatExtensionHostWorkerInvokeAndTransfer': (...args) => invokeAndTransfer$1('WebView.compatExtensionHostWorkerInvokeAndTransfer', ...args),
+  'WebView.compatRendererProcessInvoke': (...args) => invoke$2('WebView.compatRendererProcessInvoke', ...args),
+  'WebView.compatRendererProcessInvokeAndTransfer': (...args) => invokeAndTransfer$1('WebView.compatRendererProcessInvokeAndTransfer', ...args),
+  'WebView.compatSharedProcessInvoke': (...args) => invoke$2('WebView.compatSharedProcessInvoke', ...args),
+  'WebView.getSavedState': (...args) => invoke$2('WebView.getSavedState', ...args),
+  'WebView.getWebViewInfo': (...args) => invoke$2('WebView.getWebViewInfo', ...args),
+  'WebView.getWebViews': (...args) => invoke$2('WebView.getWebViews', ...args),
+  'WebView.setPort': (...args) => invoke$2('WebView.setPort', ...args),
+  'ExtensionHostManagement.activateByEvent': (...args) => invoke$2('ExtensionHostManagement.activateByEvent', ...args)
+};
+const launchIframeWorker = async () => {
+  const configuredWorkerUrl = await getConfiguredIframeWorkerUrl();
+  const name = 'Iframe Worker';
+  const id = create$1();
+  const rpc = await create$2({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    name,
+    url: configuredWorkerUrl,
+    id,
+    commandMap: commandMap$1
+  });
+  return rpc;
 };
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
+
+let workerPromise;
+const ensureWorker = () => {
+  if (!workerPromise) {
+    workerPromise = launchIframeWorker();
   }
+  return workerPromise;
 };
-const listen$1 = async (module, options) => {
-  const rawIpc = await module.listen(options);
-  if (module.signal) {
-    module.signal(rawIpc);
-  }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
+const invoke = async (method, ...params) => {
+  const rpc = await ensureWorker();
+  return rpc.invoke(method, ...params);
 };
-const create$1 = async ({
-  commandMap
+
+const createWebView3 = async ({
+  id,
+  uri,
+  isGitpod,
+  platform,
+  assetDir,
+  webViewScheme
 }) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
-};
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$1
+  await invoke('WebView.create3', {
+    id,
+    uri,
+    isGitpod,
+    platform,
+    assetDir,
+    webViewScheme
+  });
 };
 
 const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
@@ -3231,7 +3227,7 @@ const getExtensionId = extension => {
   return '<unknown>';
 };
 
-const getUrlPrefix = extensionPath => {
+const getUrlPrefix = (platform, extensionPath) => {
   if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
     return extensionPath;
   }
@@ -3250,7 +3246,7 @@ const handleRpcInfos = extension => {
       return;
     }
     const rpcs = extension.rpc;
-    const urlPrefix = getUrlPrefix(extension.path);
+    const urlPrefix = getUrlPrefix(platform, extension.path);
     if (!rpcs) {
       return;
     }
@@ -3327,19 +3323,6 @@ class BabelParseError extends SyntaxError {
   }
 }
 
-const getAssetDir = () => {
-  // @ts-ignore
-  if (typeof ASSET_DIR !== 'undefined') {
-    // @ts-ignore
-    return ASSET_DIR;
-  }
-  if (platform === Electron) {
-    return '../../../../..';
-  }
-  return '';
-};
-const assetDir = getAssetDir();
-
 const loadBabelParser = () => {
   const url = `${assetDir}/js/babel-parser.js`;
   return import(url);
@@ -3666,7 +3649,7 @@ const mockExec = () => {
   try {
     // @ts-ignore
     api.exec = async (command, args, options) => {
-      const result = await invoke$1('Test.executeMockExecFunction', command, args, options);
+      const result = await invoke$2('Test.executeMockExecFunction', command, args, options);
       const {
         stdout,
         stderr,
@@ -3692,7 +3675,7 @@ const mockRpc = () => {
     try {
       return {
         async invoke(method, ...params) {
-          const result = await invoke$1('Test.executeMockRpcFunction', options.name, method, ...params);
+          const result = await invoke$2('Test.executeMockRpcFunction', options.name, method, ...params);
           return result;
         }
       };
@@ -3703,7 +3686,7 @@ const mockRpc = () => {
 };
 
 const getStatusBarItems = async () => {
-  const providers = Object.values(state$5.providers);
+  const providers = Object.values(state$6.providers);
   const statusBarItems = [];
   for (const provider of providers) {
     // @ts-ignore
@@ -3724,29 +3707,11 @@ const handleBeforeUnload = () => {
   console.log('before unload');
 };
 
-const MessagePort$1 = 1;
-const ModuleWorker = 2;
-const ModuleWorkerWithMessagePort = 4;
-
-const getModule = method => {
-  switch (method) {
-    case ModuleWorker:
-      return IpcChildWithModuleWorker$1;
-    case ModuleWorkerWithMessagePort:
-      return IpcChildWithModuleWorkerAndMessagePort$1;
-    case MessagePort$1:
-      return IpcChildWithMessagePort$1;
-    default:
-      throw new Error('unexpected ipc type');
-  }
-};
-
-const handleMessagePort = port => {
-  const module = getModule(MessagePort$1);
-  // @ts-ignore
-  const ipc = module.wrap(port);
-  handleIpc$1(ipc);
-  ipc.send('ready');
+const handleMessagePort = async port => {
+  await MessagePortRpcClient.create({
+    messagePort: port,
+    commandMap: {}
+  });
 };
 
 const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);
@@ -4457,6 +4422,8 @@ const textSearch = async (scheme, root, query) => {
 };
 
 const commandMap = {
+  'WebView.create3': createWebView3,
+  'ExtensionHost.launchIframeWorker': launchIframeWorker,
   'ExtensionHostRename.executeprepareRenameProvider': executeprepareRenameProvider,
   'ExtensionHostRename.executeRenameProvider': executeRenameProvider,
   'IndexedDb.addHandle': addHandle,