@lvce-editor/renderer-process 30.40.0 → 30.41.1

package/dist/rendererProcessMain.js

@@ -118,25 +118,25 @@ const confirm = message => {
   return window.confirm(message);
 };
 
-const state$e = {
+const state$f = {
   styleSheets: Object.create(null),
   texts: Object.create(null)
 };
 const set$b = (id, sheet) => {
-  state$e.styleSheets[id] = sheet;
+  state$f.styleSheets[id] = sheet;
 };
 const get$b = id => {
-  return state$e.styleSheets[id];
+  return state$f.styleSheets[id];
 };
 const setText$2 = (id, text) => {
-  state$e.texts[id] = text;
+  state$f.texts[id] = text;
 };
 const getText = id => {
-  return state$e.texts[id];
+  return state$f.texts[id];
 };
 const remove$5 = id => {
-  delete state$e.styleSheets[id];
-  delete state$e.texts[id];
+  delete state$f.styleSheets[id];
+  delete state$f.texts[id];
 };
 
 const addCssStyleSheet = (id, text) => {
@@ -331,7 +331,7 @@ const createIdGenerator = () => {
 };
 const create$J = createIdGenerator();
 
-const state$d = Object.create(null);
+const state$e = Object.create(null);
 const retainString = (item, index) => {
   const value = new Promise(resolve => {
     item.getAsString(resolve);
@@ -382,22 +382,22 @@ const retainItems = dataTransfer => {
 };
 const add$2 = dataTransfer => {
   const id = create$J();
-  state$d[id] = retainItems(dataTransfer);
+  state$e[id] = retainItems(dataTransfer);
   return id;
 };
 const acquire$2 = id => {
-  const items = state$d[id];
+  const items = state$e[id];
   if (!items) {
     throw new Error(`Drop data not found: ${id}`);
   }
-  delete state$d[id];
+  delete state$e[id];
   return items;
 };
 
-const state$c = Object.create(null);
+const state$d = Object.create(null);
 const acquire$1 = id => {
-  const promise = state$c[id];
-  delete state$c[id];
+  const promise = state$d[id];
+  delete state$d[id];
   return promise;
 };
 const getFileHandles$1 = async ids => {
@@ -407,7 +407,7 @@ const getFileHandles$1 = async ids => {
 };
 const add$1 = promise => {
   const id = create$J();
-  state$c[id] = promise;
+  state$d[id] = promise;
   return id;
 };
 const addFileHandle$1 = fileHandle => {
@@ -609,14 +609,14 @@ const getEventListenerArgs = (params, event) => {
   return serialized;
 };
 
-const state$b = {
+const state$c = {
   ipc: undefined
 };
 const getIpc = () => {
-  return state$b.ipc;
+  return state$c.ipc;
 };
 const setIpc = value => {
-  state$b.ipc = value;
+  state$c.ipc = value;
 };
 
 const nameAnonymousFunction$1 = (fn, name) => {
@@ -2039,238 +2039,389 @@ const unregisterView = uid => {
   viewRpcIds.delete(uid);
 };
 
-const downloadFile = (fileName, url) => {
-  const a = document.createElement('a');
-  a.href = url;
-  a.download = fileName;
-  a.click();
-};
-
-const isFile = value => {
-  return value instanceof File;
-};
-
-const getFilePathElectron = async file => {
-  if (!isFile(file)) {
-    throw new TypeError(`file must be of type File`);
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
   }
-  if (!globalThis.electronGlobals) {
-    throw new Error(`electron globals are not available`);
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
   }
-  const filePath = globalThis.electronGlobals.getPathForFile(file);
-  return filePath;
+  return line;
 };
-
-const validFormats = new Set(['file', 'fileSystemHandle', 'string']);
-const validateOptions = options => {
-  if (!options || !Array.isArray(options.formats) || typeof options.includeElectronFilePaths !== 'boolean') {
-    throw new TypeError('Invalid drop data options');
-  }
-  for (const format of options.formats) {
-    if (!validFormats.has(format)) {
-      throw new TypeError(`Invalid drop data format: ${format}`);
-    }
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
   }
+  return stringifiedError;
 };
-const resolveString = async item => {
-  return {
-    index: item.index,
-    kind: 'string',
-    type: item.type,
-    value: await item.value
-  };
+const NewLine$3 = '\n';
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$3, startIndex);
 };
-const resolveFile = async (item, formats, includeElectronFilePaths) => {
-  const includeFile = formats.has('file');
-  const includeFileSystemHandle = formats.has('fileSystemHandle');
-  const fileSystemHandle = includeFileSystemHandle ? await item.fileSystemHandle : undefined;
-  const electronFilePath = includeElectronFilePaths && globalThis.electronGlobals && item.file ? await getFilePathElectron(item.file) : undefined;
-  if ((!includeFile || !item.file) && !fileSystemHandle && electronFilePath === undefined) {
-    return undefined;
+const mergeStacks$1 = (parent, child) => {
+  if (!child) {
+    return parent;
   }
-  return {
-    ...(electronFilePath !== undefined && {
-      electronFilePath
-    }),
-    ...(includeFile && item.file && {
-      file: item.file
-    }),
-    ...(fileSystemHandle && {
-      fileSystemHandle
-    }),
-    index: item.index,
-    kind: 'file',
-    name: fileSystemHandle?.name || item.file?.name || '',
-    type: item.type
-  };
+  const parentNewLineIndex = getNewLineIndex$1(parent);
+  const childNewLineIndex = getNewLineIndex$1(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
 };
-const get$6 = async (dropId, options) => {
-  validateOptions(options);
-  const retainedItems = acquire$2(dropId);
-  const formats = new Set(options.formats);
-  const items = [];
-  for (const retainedItem of retainedItems) {
-    if (retainedItem.kind === 'string') {
-      if (formats.has('string')) {
-        items.push(await resolveString(retainedItem));
-      }
-      continue;
+let VError$1 = class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks$1(this.stack, error.stack);
     }
-    const item = await resolveFile(retainedItem, formats, options.includeElectronFilePaths);
-    if (item) {
-      items.push(item);
+    if (error.codeFrame) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
     }
   }
-  return items;
 };
 
-const isFileSystemFileHandle = value => {
-  if (!value || typeof value !== 'object') {
-    return false;
+const isMessagePort$1 = value => {
+  return value && value instanceof MessagePort;
+};
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+const transferrables$1 = [isMessagePort$1, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable$1 = value => {
+  for (const fn of transferrables$1) {
+    if (fn(value)) {
+      return true;
+    }
   }
-  const candidate = value;
-  return candidate.kind === 'file' && typeof candidate.getFile === 'function';
+  return false;
 };
-const getNativeFile = async item => {
-  if (item.kind === 'file-legacy') {
-    return item.value instanceof File ? item.value : undefined;
+const walkValue$1 = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
   }
-  if (item.file instanceof File) {
-    return item.file;
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
   }
-  if (isFileSystemFileHandle(item.value)) {
-    return item.value.getFile();
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue$1(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue$1(property, transferrables, isTransferrable);
+    }
   }
-  return undefined;
 };
-const addElectronPath = async item => {
-  if (!globalThis.electronGlobals) {
-    return item;
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue$1(value, transferrables, isTransferrable$1);
+  return transferrables;
+};
+const removeValues = (value, toRemove) => {
+  if (!value) {
+    return value;
   }
-  const file = await getNativeFile(item);
-  if (!file) {
-    return item;
+  if (Array.isArray(value)) {
+    const newItems = [];
+    for (const item of value) {
+      if (!toRemove.includes(item)) {
+        newItems.push(removeValues(item, toRemove));
+      }
+    }
+    return newItems;
   }
-  const path = await getFilePathElectron(file);
-  return {
-    ...item,
-    path
-  };
-};
-const get$5 = async ids => {
-  const items = await getFileHandles$1(ids);
-  return Promise.all(items.map(addElectronPath));
+  if (typeof value === 'object') {
+    const newObject = Object.create(null);
+    for (const [key, property] of Object.entries(value)) {
+      if (!toRemove.includes(property)) {
+        newObject[key] = removeValues(property, toRemove);
+      }
+    }
+    return newObject;
+  }
+  return value;
 };
 
-const showDirectoryPicker = options => {
-  // @ts-expect-error
-  return window.showDirectoryPicker(options);
+// workaround for electron not supporting transferrable objects
+// as parameters. If the transferrable object is a parameter, in electron
+// only an empty objected is received in the main process
+const fixElectronParameters = value => {
+  const transfer = getTransferrables(value);
+  const newValue = removeValues(value, transfer);
+  return {
+    newValue,
+    transfer
+  };
 };
-const showFilePicker = options => {
-  // @ts-expect-error
-  return window.showOpenFilePicker(options);
+const attachEvents$8 = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
 };
-const showSaveFilePicker = options => {
-  // @ts-expect-error
-  return window.showSaveFilePicker(options);
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents$8(this);
+  }
+}
+const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
+const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
+const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
+const NewLine$2 = '\n';
+const joinLines$2 = lines => {
+  return lines.join(NewLine$2);
 };
-
-const requestPermission = (handle, options) => {
-  return handle.requestPermission(options);
+const RE_AT$1 = /^\s+at/;
+const RE_AT_PROMISE_INDEX$1 = /^\s*at async Promise.all \(index \d+\)$/;
+const isNormalStackLine$1 = line => {
+  return RE_AT$1.test(line) && !RE_AT_PROMISE_INDEX$1.test(line);
 };
-const getFileHandles = ids => {
-  return getFileHandles$1(ids);
+const getDetails$1 = lines => {
+  const index = lines.findIndex(isNormalStackLine$1);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines$2(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine$1(lines[lastIndex])) {
+      break;
+    }
+  }
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
+  };
 };
-const addFileHandle = fileHandle => {
-  return addFileHandle$1(fileHandle);
+const splitLines$2 = lines => {
+  return lines.split(NewLine$2);
 };
-
-const getTitleBarHeight = () => {
-  if (
-  // @ts-expect-error
-  globalThis.navigator.windowControlsOverlay?.getTitlebarAreaRect) {
-    // @ts-expect-error
-    const titleBarRect = globalThis.navigator.windowControlsOverlay.getTitlebarAreaRect();
-    return titleBarRect.height;
-  }
-  return 0;
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+const isMessageCodeBlockStartIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line);
 };
-const getBounds = () => {
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+};
+const getMessageCodeBlock = stderr => {
+  const lines = splitLines$2(stderr);
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
+  const relevantLines = lines.slice(startIndex, endIndex);
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
+  return relevantMessage;
+};
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
+};
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines$2(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
   return {
-    titleBarHeight: getTitleBarHeight(),
-    windowHeight: window.innerHeight,
-    windowWidth: window.innerWidth
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
-
-const getPathName = () => {
-  return location.pathname;
+const isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
 };
-const getHref = () => {
-  return location.href;
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
 };
-const matchesPathName = (currentPathName, pathName) => {
-  const resolvedPathName = new URL(pathName, getHref()).pathname;
-  return currentPathName === resolvedPathName;
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
 };
-const setPathName = pathName => {
-  const currentPathName = getPathName();
-  if (matchesPathName(currentPathName, pathName)) {
-    return;
-  }
-  history.pushState(null, '', pathName);
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
+  };
 };
-const hydrate$3 = () => {
-  // addEventListener('popstate', handlePopState)
+const getModuleSyntaxError = () => {
+  return {
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
+  };
 };
-
-const shouldLaunchMultipleWorkers = true;
-
-const getConfig = () => {
-  const configElement = document.getElementById('Config');
-  if (!configElement?.textContent) {
-    return {};
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
   }
-  return JSON.parse(configElement.textContent);
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines$2(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails$1(lines);
+  return {
+    code: '',
+    message: actualMessage,
+    stack: rest
+  };
 };
-const getInitData = () => {
-  const initData = {
-    Config: {
-      ...getConfig(),
-      shouldLaunchMultipleWorkers: shouldLaunchMultipleWorkers
-    },
-    Layout: {
-      bounds: getBounds()
-    },
-    Location: {
-      href: getHref()
+let IpcError$1 = class IpcError extends VError$1 {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
+    if (stdout || stderr) {
+      // @ts-ignore
+      const {
+        code,
+        message,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
+      // @ts-ignore
+      cause.code = code;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
     }
-  };
-  return initData;
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
+    this.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
+  }
 };
-
-const MessagePort$1 = 1;
-const ModuleWorker = 2;
-const ReferencePort = 3;
-const ModuleWorkerWithMessagePort = 4;
-const Electron$1 = 5;
-
-const Message$2 = 'message';
-const Error$3 = 'error';
-
-const withResolvers = () => {
-  return Promise.withResolvers();
+const readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
 };
-
-const getFirstEvent$1 = (eventTarget, eventMap) => {
+const listen$9 = () => {
+  return globalThis;
+};
+const signal$a = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithElectronWindow extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, location.origin, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    const wrapped = event => {
+      const {
+        ports
+      } = event;
+      if (ports.length > 0) {
+        return;
+      }
+      callback(event);
+      this._rawIpc.removeEventListener('message', wrapped);
+    };
+    this._rawIpc.addEventListener('message', wrapped);
+  }
+}
+const wrap$h = window => {
+  return new IpcChildWithElectronWindow(window);
+};
+const IpcChildWithElectronWindow$1 = {
+  __proto__: null,
+  listen: listen$9,
+  signal: signal$a,
+  wrap: wrap$h
+};
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent$1 = (eventEmitter, eventMap) => {
   const {
     promise,
     resolve
-  } = withResolvers();
+  } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
     for (const event of Object.keys(eventMap)) {
-      eventTarget.removeEventListener(event, listenerMap[event]);
+      removeListener(eventEmitter, event, listenerMap[event]);
     }
     resolve(value);
   };
@@ -2281,93 +2432,97 @@ const getFirstEvent$1 = (eventTarget, eventMap) => {
         type
       });
     };
-    eventTarget.addEventListener(event, listener);
+    addListener(eventEmitter, event, listener);
     listenerMap[event] = listener;
   }
   return promise;
 };
-
-/**
- *
- * @param {Worker} worker
- * @returns
- */
-const getFirstWorkerEvent$1 = worker => {
-  return getFirstEvent$1(worker, {
-    error: Error$3,
-    message: Message$2
+const Message$1 = 3;
+const create$5$1 = async ({
+  isMessagePortOpen,
+  messagePort
+}) => {
+  if (!isMessagePort$1(messagePort)) {
+    throw new IpcError$1('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent$1(messagePort, {
+    message: Message$1
   });
-};
-
-const transferrables$1 = [];
-if (typeof MessagePort !== 'undefined') {
-  transferrables$1.push(MessagePort);
-}
-if (typeof OffscreenCanvas !== 'undefined') {
-  transferrables$1.push(OffscreenCanvas);
-}
-
-const isTransferrable$1 = value => {
-  for (const fn of transferrables$1) {
-    if (value instanceof fn) {
-      return true;
-    }
+  messagePort.start();
+  const {
+    event,
+    type
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError$1('Failed to wait for ipc message');
   }
-  return false;
+  if (event.data !== readyMessage) {
+    throw new IpcError$1('unexpected first message');
+  }
+  return messagePort;
 };
-
-const walkValue$1 = (value, transferrables) => {
-  if (!value) {
-    return;
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+let IpcParentWithMessagePort$1 = class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
   }
-  if (isTransferrable$1(value)) {
-    transferrables.push(value);
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
   }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue$1(item, transferrables);
-    }
-    return;
+  dispose() {
+    this._rawIpc.close();
   }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue$1(property, transferrables);
-    }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
   }
+  onClose(callback) {}
 };
-
-const getTransfer = value => {
-  const transferrables = [];
-  walkValue$1(value, transferrables);
-  return transferrables;
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort$1(messagePort);
 };
-
-let IpcError$1 = class IpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'IpcError';
-  }
+const IpcParentWithMessagePort$1$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
+const Message$2 = 'message';
+const Error$1$1 = 'error';
+const getFirstWorkerEvent$1 = worker => {
+  return getFirstEvent$1(worker, {
+    error: Error$1$1,
+    message: Message$2
+  });
 };
-
 const isErrorEvent$1 = event => {
   return event instanceof ErrorEvent;
 };
-
-const NewLine$3 = '\n';
-
-const joinLines$2 = lines => {
-  return lines.join(NewLine$3);
+const getWorkerDisplayName$1 = name => {
+  if (!name) {
+    return '<unknown> worker';
+  }
+  if (name.endsWith('Worker') || name.endsWith('worker')) {
+    return name.toLowerCase();
+  }
+  return `${name} Worker`;
 };
-
-const splitLines$2 = lines => {
-  string(lines);
-  return lines.split(NewLine$3);
+const tryToGetActualErrorMessage = async ({
+  name
+}) => {
+  const displayName = getWorkerDisplayName$1(name);
+  return `Failed to start ${displayName}: Worker Launch Error`;
 };
-
 let WorkerError$1 = class WorkerError extends Error {
   constructor(event) {
     super(event.message);
-    const stackLines = splitLines$2(this.stack);
+    const stackLines = splitLines$2(this.stack || '');
     const relevantLines = stackLines.slice(1);
     const relevant = joinLines$2(relevantLines);
     this.stack = `${event.message}
@@ -2375,16 +2530,8 @@ let WorkerError$1 = class WorkerError extends Error {
 ${relevant}`;
   }
 };
-
 const Module$1 = 'module';
-
-const getWorkerDisplayName$1 = name => {
-  if (name && name.endsWith('Worker')) {
-    return name;
-  }
-  return `${name} worker`;
-};
-const create$I = async ({
+const create$4$1 = async ({
   name,
   url
 }) => {
@@ -2392,23 +2539,24 @@ const create$I = async ({
     name,
     type: Module$1
   });
-  // @ts-expect-error
   const {
     event,
     type
   } = await getFirstWorkerEvent$1(worker);
   switch (type) {
     case Message$2:
-      if (event.data !== 'ready') {
+      if (event.data !== readyMessage) {
         throw new IpcError$1('unexpected first message from worker');
       }
       break;
-    case Error$3:
+    case Error$1$1:
       if (isErrorEvent$1(event)) {
         throw new WorkerError$1(event);
       }
-      const displayName = getWorkerDisplayName$1(name);
-      throw new IpcError$1(`Failed to start ${displayName}`);
+      const actualErrorMessage = await tryToGetActualErrorMessage({
+        name
+      });
+      throw new Error(actualErrorMessage);
   }
   return worker;
 };
@@ -2419,1229 +2567,1379 @@ const getData$1 = event => {
   }
   return event;
 };
-const wrap = worker => {
-  let handleMessage;
-  const wrapped = {
-    get onmessage() {
-      return handleMessage;
-    },
-    set onmessage(listener) {
-      if (listener) {
-        handleMessage = event => {
-          const data = getData$1(event);
-          listener({
-            data,
-            target: wrapped
-          });
-        };
-      } else {
-        handleMessage = null;
-      }
-      worker.onmessage = handleMessage;
-    },
-    send(message) {
-      worker.postMessage(message);
-    },
-    sendAndTransfer(message) {
-      const transfer = getTransfer(message);
-      worker.postMessage(message, transfer);
-    }
-  };
-  return wrapped;
-};
-
-const IpcParentWithModuleWorker$2 = {
-  __proto__: null,
-  create: create$I,
-  wrap
-};
-
-const isMessagePort$1 = value => {
-  return value instanceof MessagePort;
-};
-
-const create$H = async ({
-  url
-}) => {
-  string(url);
-  const portPromise = await new Promise(resolve => {
-    Object.defineProperty(globalThis, 'acceptPort', {
-      configurable: true,
-      value: resolve
-    });
-  });
-  await import(url);
-  const port = await portPromise;
-  delete globalThis.acceptPort;
-  if (!port) {
-    throw new IpcError$1('port must be defined');
+let IpcParentWithModuleWorker$1 = class IpcParentWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$1(event);
   }
-  if (!isMessagePort$1(port)) {
-    throw new IpcError$1('port must be of type MessagePort');
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
   }
-  return port;
-};
-
-const IpcParentWithMessagePort$2 = {
-  __proto__: null,
-  create: create$H
 };
-
-const create$G = async url => {
-  const referencePort = await new Promise(resolve => {
-    Object.defineProperty(globalThis, 'acceptReferencePort', {
-      configurable: true,
-      value: resolve
-    });
-    import(url);
-  });
-  delete globalThis.acceptReferencePort;
-  return referencePort;
+const wrap$4 = worker => {
+  return new IpcParentWithModuleWorker$1(worker);
 };
-
-const IpcParentWithReferencePort = {
+const IpcParentWithModuleWorker$1$1 = {
   __proto__: null,
-  create: create$G
+  create: create$4$1,
+  wrap: wrap$4
 };
 
-const normalizeLine = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice('Error: '.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice('VError: '.length);
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
   }
-  return line;
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
 };
-const getCombinedMessage = (error, message) => {
-  const stringifiedError = normalizeLine(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
   }
-  return stringifiedError;
+  return fn(...args);
 };
-const NewLine$2 = '\n';
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
+
+const Two$1 = '2.0';
+const callbacks = Object.create(null);
+const get$6 = id => {
+  return callbacks[id];
 };
-const mergeStacks$1 = (parent, child) => {
-  if (!child) {
-    return parent;
+const remove$4 = id => {
+  delete callbacks[id];
+};
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
   }
-  const parentNewLineIndex = getNewLineIndex$1(parent);
-  const childNewLineIndex = getNewLineIndex$1(child);
-  if (childNewLineIndex === -1) {
-    return parent;
+}
+const NewLine$1 = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case ReferenceError$1:
+        return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
+      default:
+        return Error;
+    }
   }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
   }
-  return child;
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
 };
-let VError$1 = class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks$1(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
-      // @ts-ignore
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      // @ts-ignore
-      this.code = error.code;
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      Object.defineProperty(error, 'name', {
+        configurable: true,
+        value: name
+      });
     }
+    return error;
   }
+  return new ErrorConstructor(message);
 };
-
-const isMessagePort = value => {
-  return value && value instanceof MessagePort;
+const joinLines$1 = lines => {
+  return lines.join(NewLine$1);
 };
-const isMessagePortMain = value => {
-  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+const splitLines$1 = lines => {
+  return lines.split(NewLine$1);
 };
-const isOffscreenCanvas = value => {
-  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+const getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(stackLinesToSkip));
+  return currentStack;
 };
-const isInstanceOf = (value, constructorName) => {
-  return value?.constructor?.name === constructorName;
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine$1);
+  }
 };
-const isSocket = value => {
-  return isInstanceOf(value, 'Socket');
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine$1 + parentStack;
+  }
+  return parentStack;
 };
-const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
-const isTransferrable = value => {
-  for (const fn of transferrables) {
-    if (fn(value)) {
-      return true;
+const MethodNotFound = -32601;
+const Custom = -32001;
+const setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
+  if (descriptor) {
+    if (!descriptor.configurable && !descriptor.writable) {
+      return;
+    }
+    if (!descriptor.configurable && descriptor.writable) {
+      error.stack = stack;
+      return;
     }
   }
-  return false;
+  Object.defineProperty(error, 'stack', {
+    configurable: true,
+    value: stack,
+    writable: true
+  });
 };
-const walkValue = (value, transferrables, isTransferrable) => {
-  if (!value) {
-    return;
-  }
-  if (isTransferrable(value)) {
-    transferrables.push(value);
-    return;
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    setStack(error, `${error.stack}${NewLine$1}${currentStack}`);
   }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
-    }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  setStack(restoredError, `${parentStack}${NewLine$1}${currentStack}`);
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine$1}${error.data.stack}${NewLine$1}${currentStack}`);
     return;
   }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
-    }
+  if (error.data.stack) {
+    setStack(restoredError, error.data.stack);
   }
 };
-const getTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
-  return transferrables;
-};
-const removeValues = (value, toRemove) => {
-  if (!value) {
-    return value;
+const applyDataProperties = (restoredError, error) => {
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame;
   }
-  if (Array.isArray(value)) {
-    const newItems = [];
-    for (const item of value) {
-      if (!toRemove.includes(item)) {
-        newItems.push(removeValues(item, toRemove));
-      }
-    }
-    return newItems;
+  if (error.data.code) {
+    // @ts-ignore
+    restoredError.code = error.data.code;
   }
-  if (typeof value === 'object') {
-    const newObject = Object.create(null);
-    for (const [key, property] of Object.entries(value)) {
-      if (!toRemove.includes(property)) {
-        newObject[key] = removeValues(property, toRemove);
-      }
-    }
-    return newObject;
+  if (error.data.type) {
+    // @ts-ignore
+    restoredError.name = error.data.type;
   }
-  return value;
-};
-
-// workaround for electron not supporting transferrable objects
-// as parameters. If the transferrable object is a parameter, in electron
-// only an empty objected is received in the main process
-const fixElectronParameters = value => {
-  const transfer = getTransferrables(value);
-  const newValue = removeValues(value, transfer);
-  return {
-    newValue,
-    transfer
-  };
-};
-const attachEvents$8 = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent('message', {
-      data
-    }));
-  };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event('close'));
-  };
-  that.onClose(handleClose);
 };
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents$8(this);
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
   }
-}
-const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
-const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
-const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
-const NewLine$1 = '\n';
-const joinLines$1 = lines => {
-  return lines.join(NewLine$1);
 };
-const RE_AT$1 = /^\s+at/;
-const RE_AT_PROMISE_INDEX$1 = /^\s*at async Promise.all \(index \d+\)$/;
-const isNormalStackLine$1 = line => {
-  return RE_AT$1.test(line) && !RE_AT_PROMISE_INDEX$1.test(line);
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
 };
-const getDetails$1 = lines => {
-  const index = lines.findIndex(isNormalStackLine$1);
-  if (index === -1) {
-    return {
-      actualMessage: joinLines$1(lines),
-      rest: []
-    };
+const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
+  if (error && error instanceof Error) {
+    return restoreExistingError(error, currentStack);
   }
-  let lastIndex = index - 1;
-  while (++lastIndex < lines.length) {
-    if (!isNormalStackLine$1(lines[lastIndex])) {
-      break;
-    }
+  if (error && error.code && error.code === MethodNotFound) {
+    return restoreMethodNotFoundError(error, currentStack);
   }
-  return {
-    actualMessage: lines[index - 1],
-    rest: lines.slice(index, lastIndex)
-  };
-};
-const splitLines$1 = lines => {
-  return lines.split(NewLine$1);
+  if (error && error.message) {
+    return restoreMessageError(error);
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
 };
-const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
-const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
-const isMessageCodeBlockStartIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError('unexpected response message');
 };
-const isMessageCodeBlockEndIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+const warn = (...args) => {
+  console.warn(...args);
 };
-const getMessageCodeBlock = stderr => {
-  const lines = splitLines$1(stderr);
-  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
-  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
-  const relevantLines = lines.slice(startIndex, endIndex);
-  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
-  return relevantMessage;
+const resolve = (id, response) => {
+  const fn = get$6(id);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id} may already be disposed`);
+    return;
+  }
+  fn(response);
+  remove$4(id);
 };
-const isModuleNotFoundMessage = line => {
-  return line.includes('[ERR_MODULE_NOT_FOUND]');
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
 };
-const getModuleNotFoundError = stderr => {
-  const lines = splitLines$1(stderr);
-  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
-  const message = lines[messageIndex];
-  return {
-    code: ERR_MODULE_NOT_FOUND,
-    message
-  };
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
 };
-const isModuleNotFoundError = stderr => {
-  if (!stderr) {
-    return false;
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
   }
-  return stderr.includes('ERR_MODULE_NOT_FOUND');
+  return stackString;
 };
-const isModulesSyntaxError = stderr => {
-  if (!stderr) {
-    return false;
+const getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      data: error.stack,
+      message: error.message
+    };
   }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
-};
-const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
-const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
-const isUnhelpfulNativeModuleError = stderr => {
-  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
-};
-const getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
   return {
-    code: E_INCOMPATIBLE_NATIVE_MODULE,
-    message: `Incompatible native node module: ${message}`
+    code: Custom,
+    data: {
+      code: prettyError.code,
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
-const getModuleSyntaxError = () => {
+const create$1$1 = (id, error) => {
   return {
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
-    message: `ES Modules are not supported in electron`
+    error,
+    id,
+    jsonrpc: Two$1
   };
 };
-const getHelpfulChildProcessError = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError(stderr)) {
-    return getNativeModuleErrorMessage(stderr);
-  }
-  if (isModulesSyntaxError(stderr)) {
-    return getModuleSyntaxError();
-  }
-  if (isModuleNotFoundError(stderr)) {
-    return getModuleNotFoundError(stderr);
-  }
-  const lines = splitLines$1(stderr);
-  const {
-    actualMessage,
-    rest
-  } = getDetails$1(lines);
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1$1(id, errorProperty);
+};
+const create$I = (message, result) => {
   return {
-    code: '',
-    message: actualMessage,
-    stack: rest
+    id: message.id,
+    jsonrpc: Two$1,
+    result: result ?? null
   };
 };
-class IpcError extends VError$1 {
-  // @ts-ignore
-  constructor(betterMessage, stdout = '', stderr = '') {
-    if (stdout || stderr) {
-      // @ts-ignore
-      const {
-        code,
-        message,
-        stack
-      } = getHelpfulChildProcessError(stdout, stderr);
-      const cause = new Error(message);
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$I(message, resultProperty);
+};
+const getErrorResponseSimple = (id, error) => {
+  return {
+    error: {
+      code: Custom,
+      data: error,
       // @ts-ignore
-      cause.code = code;
-      if (stack) {
-        Object.defineProperty(cause, 'stack', {
-          configurable: true,
-          enumerable: false,
-          value: stack,
-          writable: true
-        });
-      }
-      super(cause, betterMessage);
-    } else {
-      super(betterMessage);
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
+  };
+};
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
     }
-    // @ts-ignore
-    this.name = 'IpcError';
-    // @ts-ignore
-    this.stdout = stdout;
-    // @ts-ignore
-    this.stderr = stderr;
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
   }
-}
-const readyMessage = 'ready';
-const getData$2 = event => {
-  return event.data;
 };
-const listen$9 = () => {
-  return globalThis;
+const defaultPreparePrettyError = error => {
+  return error;
 };
-const signal$a = global => {
-  global.postMessage(readyMessage);
+const defaultLogError = () => {
+  // ignore
 };
-class IpcChildWithElectronWindow extends Ipc {
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixElectronParameters(message);
-    this._rawIpc.postMessage(newValue, location.origin, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    const wrapped = event => {
-      const {
-        ports
-      } = event;
-      if (ports.length > 0) {
-        return;
-      }
-      callback(event);
-      this._rawIpc.removeEventListener('message', wrapped);
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      execute: options.execute,
+      ipc: options.ipc,
+      logError: options.logError || defaultLogError,
+      message: options.message,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
-    this._rawIpc.addEventListener('message', wrapped);
   }
-}
-const wrap$h = window => {
-  return new IpcChildWithElectronWindow(window);
+  return {
+    execute: args[2],
+    ipc: args[0],
+    logError: args[5],
+    message: args[1],
+    preparePrettyError: args[4],
+    requiresSocket: args[6],
+    resolve: args[3]
+  };
 };
-const IpcChildWithElectronWindow$1 = {
-  __proto__: null,
-  listen: listen$9,
-  signal: signal$a,
-  wrap: wrap$h
-};
-const addListener = (emitter, type, callback) => {
-  if ('addEventListener' in emitter) {
-    emitter.addEventListener(type, callback);
-  } else {
-    emitter.on(type, callback);
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    execute,
+    ipc,
+    logError,
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
   }
-};
-const removeListener = (emitter, type, callback) => {
-  if ('removeEventListener' in emitter) {
-    emitter.removeEventListener(type, callback);
-  } else {
-    emitter.off(type, callback);
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
   }
+  throw new JsonRpcError('unexpected message');
+};
+
+const Two = '2.0';
+
+const create$H = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+
+const create$G = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+
+let id = 0;
+const create$F = () => {
+  return ++id;
 };
-const getFirstEvent = (eventEmitter, eventMap) => {
+
+const registerPromise = map => {
+  const id = create$F();
   const {
     promise,
     resolve
   } = Promise.withResolvers();
-  const listenerMap = Object.create(null);
-  const cleanup = value => {
-    for (const event of Object.keys(eventMap)) {
-      removeListener(eventEmitter, event, listenerMap[event]);
-    }
-    resolve(value);
+  map[id] = resolve;
+  return {
+    id,
+    promise
   };
-  for (const [event, type] of Object.entries(eventMap)) {
-    const listener = event => {
-      cleanup({
-        event,
-        type
-      });
-    };
-    addListener(eventEmitter, event, listener);
-    listenerMap[event] = listener;
-  }
-  return promise;
 };
-const Message$1 = 3;
-const create$5$1 = async ({
-  isMessagePortOpen,
-  messagePort
-}) => {
-  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 invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
   const {
-    event,
-    type
-  } = 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');
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$G(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
   }
-  return messagePort;
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
 };
-const signal$1 = messagePort => {
-  messagePort.start();
+const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
+  const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create$H(method, params);
+      ipc.send(message);
+    }
+  };
+  return rpc;
 };
-class IpcParentWithMessagePort extends Ipc {
-  getData = getData$2;
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    this._rawIpc.close();
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-  }
-  onClose(callback) {}
-}
-const wrap$5 = messagePort => {
-  return new IpcParentWithMessagePort(messagePort);
+
+const requiresSocket = () => {
+  return false;
 };
-const IpcParentWithMessagePort$1 = {
-  __proto__: null,
-  create: create$5$1,
-  signal: signal$1,
-  wrap: wrap$5
+const preparePrettyError = error => {
+  return error;
 };
-const Message = 'message';
-const Error$1$1 = 'error';
-const getFirstWorkerEvent = worker => {
-  return getFirstEvent(worker, {
-    error: Error$1$1,
-    message: Message
-  });
+const logError$1 = () => {
+  // handled by renderer worker
 };
-const isErrorEvent = event => {
-  return event instanceof ErrorEvent;
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
 };
-const getWorkerDisplayName = name => {
-  if (!name) {
-    return '<unknown> worker';
+
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
   }
-  if (name.endsWith('Worker') || name.endsWith('worker')) {
-    return name.toLowerCase();
+};
+const unhandleIpc = ipc => {
+  if ('removeEventListener' in ipc) {
+    ipc.removeEventListener('message', handleMessage);
+  } else {
+    // deprecated
+    ipc.onmessage = null;
   }
-  return `${name} Worker`;
 };
-const tryToGetActualErrorMessage = async ({
-  name
+
+const create$E = async ({
+  commandMap,
+  window
 }) => {
-  const displayName = getWorkerDisplayName(name);
-  return `Failed to start ${displayName}: Worker Launch Error`;
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = IpcChildWithElectronWindow$1.wrap(window);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
 };
-class WorkerError extends Error {
-  constructor(event) {
-    super(event.message);
-    const stackLines = splitLines$1(this.stack || '');
-    const relevantLines = stackLines.slice(1);
-    const relevant = joinLines$1(relevantLines);
-    this.stack = `${event.message}
-    at Module (${event.filename}:${event.lineno}:${event.colno})
-${relevant}`;
-  }
-}
-const Module = 'module';
-const create$4$1 = async ({
+
+const create$D = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+
+const isWorker = value => {
+  return value instanceof Worker;
+};
+
+const create$C = async ({
+  commandMap,
   name,
   url
 }) => {
-  const worker = new Worker(url, {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const worker = await IpcParentWithModuleWorker$1$1.create({
     name,
-    type: Module
+    url
   });
-  const {
-    event,
-    type
-  } = await getFirstWorkerEvent(worker);
-  switch (type) {
-    case Message:
-      if (event.data !== readyMessage) {
-        throw new IpcError('unexpected first message from worker');
-      }
-      break;
-    case Error$1$1:
-      if (isErrorEvent(event)) {
-        throw new WorkerError(event);
-      }
-      const actualErrorMessage = await tryToGetActualErrorMessage({
-        name
-      });
-      throw new Error(actualErrorMessage);
+  if (!isWorker(worker)) {
+    throw new Error(`worker must be of type Worker`);
   }
-  return worker;
+  const ipc = IpcParentWithModuleWorker$1$1.wrap(worker);
+  handleIpc(ipc);
+  const workerRpc = createRpc(ipc);
+  return workerRpc;
 };
-const getData = event => {
-  // TODO why are some events not instance of message event?
-  if (event instanceof MessageEvent) {
-    return event.data;
+
+const create$B = async ({
+  commandMap,
+  name,
+  port,
+  url
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const worker = await IpcParentWithModuleWorker$1$1.create({
+    name,
+    url
+  });
+  if (!isWorker(worker)) {
+    throw new Error(`worker must be of type Worker`);
   }
-  return event;
+  const ipc = IpcParentWithModuleWorker$1$1.wrap(worker);
+  handleIpc(ipc);
+  const workerRpc = createRpc(ipc);
+  await workerRpc.invokeAndTransfer('initialize', 'message-port', port);
+  unhandleIpc(ipc);
+  return workerRpc;
 };
-class IpcParentWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData(event);
+
+const create$A = async ({
+  commandMap,
+  messagePort
+}) => {
+  return create$D({
+    commandMap,
+    messagePort
+  });
+};
+
+const commandMapRef = {};
+
+const Web = 1;
+const Electron$1 = 2;
+const Remote = 3;
+
+/**
+ * @returns {number}
+ */
+const getPlatform = () => {
+  // @ts-expect-error
+  if (typeof PLATFORM !== 'undefined') {
+    // @ts-expect-error
+    return PLATFORM;
   }
-  send(message) {
-    this._rawIpc.postMessage(message);
+  // @ts-ignore
+  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+    return Remote;
   }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
+  if (globalThis.isElectron) {
+    return Electron$1;
   }
-  dispose() {
-    // ignore
+  if (typeof location !== 'undefined' && location.search === '?web') {
+    return Web;
   }
-  onClose(callback) {
-    // ignore
+  return Remote;
+};
+const platform = getPlatform();
+
+const getAssetDir = () => {
+  // @ts-expect-error
+  if (typeof ASSET_DIR !== 'undefined') {
+    // @ts-expect-error
+    return ASSET_DIR;
   }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
+  if (platform === Electron$1) {
+    return '../../../../..';
   }
-}
-const wrap$4 = worker => {
-  return new IpcParentWithModuleWorker(worker);
-};
-const IpcParentWithModuleWorker$1 = {
-  __proto__: null,
-  create: create$4$1,
-  wrap: wrap$4
+  return '';
 };
+const assetDir = getAssetDir();
 
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
+const getConfiguredWorkerUrl = key => {
+  if (typeof location === 'undefined' || typeof document === 'undefined') {
+    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 CommandNotFoundError(command);
+  const configElement = document.getElementById('Config');
+  if (!configElement) {
+    return '';
   }
-  return fn(...args);
+  const text = configElement.textContent;
+  if (!text) {
+    return '';
+  }
+  const config = JSON.parse(text);
+  return config[key] || '';
 };
 
-const Two$1 = '2.0';
-const callbacks = Object.create(null);
-const get$4 = id => {
-  return callbacks[id];
+const getConfiguredDragAndDropWorkerUrl = () => {
+  const workerUrls = getConfiguredWorkerUrl('workerUrls');
+  return workerUrls?.['develop.dragAndDropWorkerPath'] || '';
 };
-const remove$4 = id => {
-  delete callbacks[id];
+
+const dragAndDropWorkerUrl = getConfiguredDragAndDropWorkerUrl() || `${assetDir}/packages/renderer-worker/node_modules/@lvce-editor/drag-and-drop-worker/dist/dragAndDropWorkerMain.js`;
+
+const success = value => {
+  return {
+    ok: true,
+    value
+  };
 };
-class JsonRpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'JsonRpcError';
+const error = error => {
+  return {
+    error,
+    ok: false
+  };
+};
+const isError = result => {
+  return !result.ok;
+};
+
+const launchDragAndDropWorker = async () => {
+  try {
+    const {
+      port1,
+      port2
+    } = new MessageChannel();
+    await create$B({
+      commandMap: {},
+      name: 'Drag And Drop Worker',
+      port: port1,
+      url: dragAndDropWorkerUrl
+    });
+    const rpc = await create$D({
+      commandMap: commandMapRef,
+      messagePort: port2
+    });
+    return success(rpc);
+  } catch (error$1) {
+    return error(error$1);
   }
-}
-const NewLine = '\n';
-const DomException = 'DOMException';
-const ReferenceError$1 = 'ReferenceError';
-const SyntaxError$1 = 'SyntaxError';
-const TypeError$1 = 'TypeError';
-const getErrorConstructor = (message, type) => {
-  if (type) {
-    switch (type) {
-      case DomException:
-        return DOMException;
-      case ReferenceError$1:
-        return ReferenceError;
-      case SyntaxError$1:
-        return SyntaxError;
-      case TypeError$1:
-        return TypeError;
-      default:
-        return Error;
-    }
+};
+
+const state$b = {
+  rpc: undefined
+};
+const hydrate$4 = async () => {
+  const result = await launchDragAndDropWorker();
+  if (isError(result)) {
+    state$b.rpc = undefined;
+    return result;
   }
-  if (message.startsWith('TypeError: ')) {
-    return TypeError;
+  state$b.rpc = result.value;
+  return success(undefined);
+};
+const handleMessagePort$1 = async port => {
+  if (!state$b.rpc) {
+    throw new Error('Drag And Drop Worker is not initialized');
   }
-  if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError;
+  await state$b.rpc.invokeAndTransfer('DragAndDrop.handleMessagePort', port);
+};
+
+const downloadFile = (fileName, url) => {
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = fileName;
+  a.click();
+};
+
+const isFile = value => {
+  return value instanceof File;
+};
+
+const getFilePathElectron = async file => {
+  if (!isFile(file)) {
+    throw new TypeError(`file must be of type File`);
   }
-  if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError;
+  if (!globalThis.electronGlobals) {
+    throw new Error(`electron globals are not available`);
   }
-  return Error;
+  const filePath = globalThis.electronGlobals.getPathForFile(file);
+  return filePath;
 };
-const constructError = (message, type, name) => {
-  const ErrorConstructor = getErrorConstructor(message, type);
-  if (ErrorConstructor === DOMException && name) {
-    return new ErrorConstructor(message, name);
+
+const validFormats = new Set(['file', 'fileSystemHandle', 'string']);
+const validateOptions = options => {
+  if (!options || !Array.isArray(options.formats) || typeof options.includeElectronFilePaths !== 'boolean') {
+    throw new TypeError('Invalid drop data options');
   }
-  if (ErrorConstructor === Error) {
-    const error = new Error(message);
-    if (name && name !== 'VError') {
-      Object.defineProperty(error, 'name', {
-        configurable: true,
-        value: name
-      });
+  for (const format of options.formats) {
+    if (!validFormats.has(format)) {
+      throw new TypeError(`Invalid drop data format: ${format}`);
     }
-    return error;
   }
-  return new ErrorConstructor(message);
 };
-const joinLines = lines => {
-  return lines.join(NewLine);
-};
-const splitLines = lines => {
-  return lines.split(NewLine);
-};
-const getCurrentStack = () => {
-  const stackLinesToSkip = 3;
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
-  return currentStack;
-};
-const getNewLineIndex = (string, startIndex) => {
-  {
-    return string.indexOf(NewLine);
-  }
+const resolveString = async item => {
+  return {
+    index: item.index,
+    kind: 'string',
+    type: item.type,
+    value: await item.value
+  };
 };
-const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine + parentStack;
+const resolveFile = async (item, formats, includeElectronFilePaths) => {
+  const includeFile = formats.has('file');
+  const includeFileSystemHandle = formats.has('fileSystemHandle');
+  const fileSystemHandle = includeFileSystemHandle ? await item.fileSystemHandle : undefined;
+  const electronFilePath = includeElectronFilePaths && globalThis.electronGlobals && item.file ? await getFilePathElectron(item.file) : undefined;
+  if ((!includeFile || !item.file) && !fileSystemHandle && electronFilePath === undefined) {
+    return undefined;
   }
-  return parentStack;
+  return {
+    ...(electronFilePath !== undefined && {
+      electronFilePath
+    }),
+    ...(includeFile && item.file && {
+      file: item.file
+    }),
+    ...(fileSystemHandle && {
+      fileSystemHandle
+    }),
+    index: item.index,
+    kind: 'file',
+    name: fileSystemHandle?.name || item.file?.name || '',
+    type: item.type
+  };
 };
-const MethodNotFound = -32601;
-const Custom = -32001;
-const setStack = (error, stack) => {
-  const descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
-  if (descriptor) {
-    if (!descriptor.configurable && !descriptor.writable) {
-      return;
+const get$5 = async (dropId, options) => {
+  validateOptions(options);
+  const retainedItems = acquire$2(dropId);
+  const formats = new Set(options.formats);
+  const items = [];
+  for (const retainedItem of retainedItems) {
+    if (retainedItem.kind === 'string') {
+      if (formats.has('string')) {
+        items.push(await resolveString(retainedItem));
+      }
+      continue;
     }
-    if (!descriptor.configurable && descriptor.writable) {
-      error.stack = stack;
-      return;
+    const item = await resolveFile(retainedItem, formats, options.includeElectronFilePaths);
+    if (item) {
+      items.push(item);
     }
   }
-  Object.defineProperty(error, 'stack', {
-    configurable: true,
-    value: stack,
-    writable: true
-  });
-};
-const restoreExistingError = (error, currentStack) => {
-  if (typeof error.stack === 'string') {
-    setStack(error, `${error.stack}${NewLine}${currentStack}`);
-  }
-  return error;
-};
-const restoreMethodNotFoundError = (error, currentStack) => {
-  const restoredError = new JsonRpcError(error.message);
-  const parentStack = getParentStack(error);
-  setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
-  return restoredError;
+  return items;
 };
-const restoreStackFromData = (restoredError, error, currentStack) => {
-  if (error.data.stack && error.data.type && error.message) {
-    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
-    return;
-  }
-  if (error.data.stack) {
-    setStack(restoredError, error.data.stack);
+
+const isFileSystemFileHandle = value => {
+  if (!value || typeof value !== 'object') {
+    return false;
   }
+  const candidate = value;
+  return candidate.kind === 'file' && typeof candidate.getFile === 'function';
 };
-const applyDataProperties = (restoredError, error) => {
-  restoreStackFromData(restoredError, error, getCurrentStack());
-  if (error.data.codeFrame) {
-    // @ts-ignore
-    restoredError.codeFrame = error.data.codeFrame;
+const getNativeFile = async item => {
+  if (item.kind === 'file-legacy') {
+    return item.value instanceof File ? item.value : undefined;
   }
-  if (error.data.code) {
-    // @ts-ignore
-    restoredError.code = error.data.code;
+  if (item.file instanceof File) {
+    return item.file;
   }
-  if (error.data.type) {
-    // @ts-ignore
-    restoredError.name = error.data.type;
+  if (isFileSystemFileHandle(item.value)) {
+    return item.value.getFile();
   }
+  return undefined;
 };
-const applyDirectProperties = (restoredError, error) => {
-  if (error.stack) {
-    const lowerStack = restoredError.stack || '';
-    const indexNewLine = getNewLineIndex(lowerStack);
-    const parentStack = getParentStack(error);
-    // @ts-ignore
-    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
+const addElectronPath = async item => {
+  if (!globalThis.electronGlobals) {
+    return item;
   }
-  if (error.codeFrame) {
-    // @ts-ignore
-    restoredError.codeFrame = error.codeFrame;
+  const file = await getNativeFile(item);
+  if (!file) {
+    return item;
   }
+  const path = await getFilePathElectron(file);
+  return {
+    ...item,
+    path
+  };
 };
-const restoreMessageError = (error, _currentStack) => {
-  const restoredError = constructError(error.message, error.type, error.name);
-  if (error.data) {
-    applyDataProperties(restoredError, error);
-  } else {
-    applyDirectProperties(restoredError, error);
-  }
-  return restoredError;
+const get$4 = async ids => {
+  const items = await getFileHandles$1(ids);
+  return Promise.all(items.map(addElectronPath));
 };
-const restoreJsonRpcError = error => {
-  const currentStack = getCurrentStack();
-  if (error && error instanceof Error) {
-    return restoreExistingError(error, currentStack);
-  }
-  if (error && error.code && error.code === MethodNotFound) {
-    return restoreMethodNotFoundError(error, currentStack);
-  }
-  if (error && error.message) {
-    return restoreMessageError(error);
-  }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
-  }
-  return new Error(`JsonRpc Error: ${error}`);
+
+const showDirectoryPicker = options => {
+  // @ts-expect-error
+  return window.showDirectoryPicker(options);
 };
-const unwrapJsonRpcResult = responseMessage => {
-  if ('error' in responseMessage) {
-    const restoredError = restoreJsonRpcError(responseMessage.error);
-    throw restoredError;
+const showFilePicker = options => {
+  // @ts-expect-error
+  return window.showOpenFilePicker(options);
+};
+const showSaveFilePicker = options => {
+  // @ts-expect-error
+  return window.showSaveFilePicker(options);
+};
+
+const launchWorker = async ({
+  name,
+  url
+}) => {
+  try {
+    const rpc = await create$C({
+      commandMap: commandMapRef,
+      name,
+      url
+    });
+    return success(rpc);
+  } catch (error$1) {
+    return error(error$1);
   }
-  if ('result' in responseMessage) {
-    return responseMessage.result;
+};
+
+const getConfiguredRendererWorkerUrl = () => {
+  return getConfiguredWorkerUrl('rendererWorkerUrl');
+};
+
+const rendererWorkerUrl = getConfiguredRendererWorkerUrl() || `${assetDir}/packages/renderer-worker/src/rendererWorkerMain.ts`;
+
+const getName = platform => {
+  switch (platform) {
+    case Electron$1:
+      return 'Renderer Worker (Electron)';
+    case Web:
+      return 'Renderer Worker (Web)';
+    default:
+      return 'Renderer Worker';
   }
-  throw new JsonRpcError('unexpected response message');
 };
-const warn = (...args) => {
-  console.warn(...args);
+const launchRendererWorker = async () => {
+  const name = getName(platform);
+  return launchWorker({
+    name,
+    url: rendererWorkerUrl
+  });
 };
-const resolve = (id, response) => {
-  const fn = get$4(id);
-  if (!fn) {
-    console.log(response);
-    warn(`callback ${id} may already be disposed`);
+
+const selector = 'script.RendererWorkerTrace';
+const state$a = {
+  enabled: false,
+  entries: []
+};
+const serialize = value => {
+  const seen = new WeakSet();
+  const text = JSON.stringify(value, (_key, currentValue) => {
+    if (typeof currentValue === 'bigint') {
+      return `${currentValue}n`;
+    }
+    if (typeof currentValue !== 'object' || currentValue === null) {
+      return currentValue;
+    }
+    if (seen.has(currentValue)) {
+      return '[Circular]';
+    }
+    seen.add(currentValue);
+    if (currentValue instanceof ArrayBuffer) {
+      return {
+        byteLength: currentValue.byteLength,
+        type: 'ArrayBuffer'
+      };
+    }
+    if (ArrayBuffer.isView(currentValue)) {
+      return {
+        byteLength: currentValue.byteLength,
+        type: currentValue.constructor.name
+      };
+    }
+    if (currentValue instanceof Error) {
+      return {
+        message: currentValue.message,
+        name: currentValue.name,
+        stack: currentValue.stack
+      };
+    }
+    if (currentValue.constructor?.name === 'MessagePort') {
+      return {
+        type: 'MessagePort'
+      };
+    }
+    return currentValue;
+  });
+  return JSON.parse(text);
+};
+const isCommand = value => {
+  return typeof value === 'object' && value !== null && 'method' in value && typeof value.method === 'string';
+};
+const initialize = search => {
+  const searchParams = new URLSearchParams(search);
+  state$a.enabled = searchParams.has('traceRendererWorker');
+  state$a.entries = [];
+};
+const record = (direction, method, params) => {
+  if (!state$a.enabled) {
     return;
   }
-  fn(response);
-  remove$4(id);
+  state$a.entries.push({
+    direction,
+    method,
+    params: serialize(params),
+    timestamp: performance.now()
+  });
 };
-const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const getErrorType = prettyError => {
-  if (prettyError && prettyError.type) {
-    return prettyError.type;
+const listen = rpc => {
+  if (!state$a.enabled) {
+    return;
   }
-  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
-    return prettyError.constructor.name;
+  const ipc = rpc.ipc;
+  if (!ipc) {
+    return;
   }
-  return undefined;
-};
-const isAlreadyStack = line => {
-  return line.trim().startsWith('at ');
+  ipc.addEventListener('message', event => {
+    const message = ipc.getData(event);
+    if (isCommand(message)) {
+      record('received', message.method, message.params || []);
+    }
+  });
 };
-const getStack = prettyError => {
-  const stackString = prettyError.stack || '';
-  const newLineIndex = stackString.indexOf('\n');
-  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
-    return stackString.slice(newLineIndex + 1);
+const exportToDom = () => {
+  if (!state$a.enabled) {
+    return;
   }
-  return stackString;
-};
-const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND) {
-    return {
-      code: MethodNotFound,
-      data: error.stack,
-      message: error.message
-    };
+  const existing = document.querySelector(selector);
+  const script = existing || document.createElement('script');
+  script.className = 'RendererWorkerTrace';
+  script.type = 'application/json';
+  script.textContent = JSON.stringify({
+    entries: state$a.entries,
+    version: 1
+  });
+  if (!existing) {
+    document.body.append(script);
   }
-  return {
-    code: Custom,
-    data: {
-      code: prettyError.code,
-      codeFrame: prettyError.codeFrame,
-      name: prettyError.name,
-      stack: getStack(prettyError),
-      type: getErrorType(prettyError)
-    },
-    message: prettyError.message
-  };
 };
-const create$1$1 = (id, error) => {
-  return {
-    error,
-    id,
-    jsonrpc: Two$1
-  };
+const scheduleExport = () => {
+  if (!state$a.enabled) {
+    return;
+  }
+  queueMicrotask(exportToDom);
 };
-const getErrorResponse = (id, error, preparePrettyError, logError) => {
-  const prettyError = preparePrettyError(error);
-  logError(error, prettyError);
-  const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(id, errorProperty);
+
+const state$9 = {
+  rpc: undefined
 };
-const create$F = (message, result) => {
-  return {
-    id: message.id,
-    jsonrpc: Two$1,
-    result: result ?? null
-  };
+const hydrate$3 = async () => {
+  const result = await launchRendererWorker();
+  if (isError(result)) {
+    state$9.rpc = undefined;
+    return result;
+  }
+  state$9.rpc = result.value;
+  listen(result.value);
+  return success(undefined);
 };
-const getSuccessResponse = (message, result) => {
-  const resultProperty = result ?? null;
-  return create$F(message, resultProperty);
+const send$1 = (method, ...params) => {
+  record('sent', method, params);
+  // @ts-ignore
+  state$9.rpc.send(method, ...params);
 };
-const getErrorResponseSimple = (id, error) => {
-  return {
-    error: {
-      code: Custom,
-      data: error,
-      // @ts-ignore
-      message: error.message
-    },
-    id,
-    jsonrpc: Two$1
-  };
+const invoke$1 = (method, ...params) => {
+  record('sent', method, params);
+  // @ts-ignore
+  return state$9.rpc.invoke(method, ...params);
 };
-const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
-  try {
-    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
-    return getSuccessResponse(message, result);
-  } catch (error) {
-    if (ipc.canUseSimpleErrorResponse) {
-      return getErrorResponseSimple(message.id, error);
-    }
-    return getErrorResponse(message.id, error, preparePrettyError, logError);
-  }
+const invokeAndTransfer = (method, ...params) => {
+  record('sent', method, params);
+  // @ts-ignore
+  return state$9.rpc.invokeAndTransfer(method, ...params);
 };
-const defaultPreparePrettyError = error => {
-  return error;
+
+const writeFile = (uri, content) => {
+  return invoke$1('FileSystem.writeFile', uri, content);
 };
-const defaultLogError = () => {
-  // ignore
+
+const requestPermission = (handle, options) => {
+  return handle.requestPermission(options);
 };
-const defaultRequiresSocket = () => {
-  return false;
+const getFileHandles = ids => {
+  return getFileHandles$1(ids);
+};
+const addFileHandle = fileHandle => {
+  return addFileHandle$1(fileHandle);
 };
-const defaultResolve = resolve;
 
-// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
-const normalizeParams = args => {
-  if (args.length === 1) {
-    const options = args[0];
-    return {
-      execute: options.execute,
-      ipc: options.ipc,
-      logError: options.logError || defaultLogError,
-      message: options.message,
-      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket,
-      resolve: options.resolve || defaultResolve
-    };
+const getTitleBarHeight = () => {
+  if (
+  // @ts-expect-error
+  globalThis.navigator.windowControlsOverlay?.getTitlebarAreaRect) {
+    // @ts-expect-error
+    const titleBarRect = globalThis.navigator.windowControlsOverlay.getTitlebarAreaRect();
+    return titleBarRect.height;
   }
+  return 0;
+};
+const getBounds = () => {
   return {
-    execute: args[2],
-    ipc: args[0],
-    logError: args[5],
-    message: args[1],
-    preparePrettyError: args[4],
-    requiresSocket: args[6],
-    resolve: args[3]
+    titleBarHeight: getTitleBarHeight(),
+    windowHeight: window.innerHeight,
+    windowWidth: window.innerWidth
   };
 };
-const handleJsonRpcMessage = async (...args) => {
-  const options = normalizeParams(args);
-  const {
-    execute,
-    ipc,
-    logError,
-    message,
-    preparePrettyError,
-    requiresSocket,
-    resolve
-  } = options;
-  if ('id' in message) {
-    if ('method' in message) {
-      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-      try {
-        ipc.send(response);
-      } catch (error) {
-        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
-        ipc.send(errorResponse);
-      }
-      return;
-    }
-    resolve(message.id, message);
-    return;
-  }
-  if ('method' in message) {
-    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+
+const getPathName = () => {
+  return location.pathname;
+};
+const getHref = () => {
+  return location.href;
+};
+const matchesPathName = (currentPathName, pathName) => {
+  const resolvedPathName = new URL(pathName, getHref()).pathname;
+  return currentPathName === resolvedPathName;
+};
+const setPathName = pathName => {
+  const currentPathName = getPathName();
+  if (matchesPathName(currentPathName, pathName)) {
     return;
   }
-  throw new JsonRpcError('unexpected message');
+  history.pushState(null, '', pathName);
+};
+const hydrate$2 = () => {
+  // addEventListener('popstate', handlePopState)
 };
 
-const Two = '2.0';
+const shouldLaunchMultipleWorkers = true;
 
-const create$E = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
+const getConfig = () => {
+  const configElement = document.getElementById('Config');
+  if (!configElement?.textContent) {
+    return {};
+  }
+  return JSON.parse(configElement.textContent);
 };
-
-const create$D = (id, method, params) => {
-  const message = {
-    id,
-    jsonrpc: Two,
-    method,
-    params
+const getInitData = () => {
+  const initData = {
+    Config: {
+      ...getConfig(),
+      shouldLaunchMultipleWorkers: shouldLaunchMultipleWorkers
+    },
+    Layout: {
+      bounds: getBounds()
+    },
+    Location: {
+      href: getHref()
+    }
   };
-  return message;
+  return initData;
 };
 
-let id = 0;
-const create$C = () => {
-  return ++id;
-};
+const MessagePort$1 = 1;
+const ModuleWorker = 2;
+const ReferencePort = 3;
+const ModuleWorkerWithMessagePort = 4;
+const Electron = 5;
 
-const registerPromise = map => {
-  const id = create$C();
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  map[id] = resolve;
-  return {
-    id,
-    promise
-  };
+const Message = 'message';
+const Error$3 = 'error';
+
+const withResolvers = () => {
+  return Promise.withResolvers();
 };
 
-const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+const getFirstEvent = (eventTarget, eventMap) => {
   const {
-    id,
-    promise
-  } = registerPromise(callbacks);
-  const message = create$D(id, method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const createRpc = ipc => {
-  const callbacks = Object.create(null);
-  ipc._resolve = (id, response) => {
-    const fn = callbacks[id];
-    if (!fn) {
-      console.warn(`callback ${id} may already be disposed`);
-      return;
-    }
-    fn(response);
-    delete callbacks[id];
-  };
-  const rpc = {
-    async dispose() {
-      await ipc?.dispose();
-    },
-    invoke(method, ...params) {
-      return invokeHelper(callbacks, ipc, method, params, false);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeHelper(callbacks, ipc, method, params, true);
-    },
-    // @ts-ignore
-    ipc,
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      const message = create$E(method, params);
-      ipc.send(message);
+    promise,
+    resolve
+  } = withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      eventTarget.removeEventListener(event, listenerMap[event]);
     }
+    resolve(value);
   };
-  return rpc;
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        event,
+        type
+      });
+    };
+    eventTarget.addEventListener(event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
 };
 
-const requiresSocket = () => {
-  return false;
-};
-const preparePrettyError = error => {
-  return error;
-};
-const logError$1 = () => {
-  // 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, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
+/**
+ *
+ * @param {Worker} worker
+ * @returns
+ */
+const getFirstWorkerEvent = worker => {
+  return getFirstEvent(worker, {
+    error: Error$3,
+    message: Message
+  });
 };
 
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
+const transferrables = [];
+if (typeof MessagePort !== 'undefined') {
+  transferrables.push(MessagePort);
+}
+if (typeof OffscreenCanvas !== 'undefined') {
+  transferrables.push(OffscreenCanvas);
+}
+
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (value instanceof fn) {
+      return true;
+    }
   }
+  return false;
 };
-const unhandleIpc = ipc => {
-  if ('removeEventListener' in ipc) {
-    ipc.removeEventListener('message', handleMessage);
-  } else {
-    // deprecated
-    ipc.onmessage = null;
+
+const walkValue = (value, transferrables) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables);
+    }
   }
 };
 
-const create$B = async ({
-  commandMap,
-  window
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = IpcChildWithElectronWindow$1.wrap(window);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
+const getTransfer = value => {
+  const transferrables = [];
+  walkValue(value, transferrables);
+  return transferrables;
 };
 
-const create$A = async ({
-  commandMap,
-  isMessagePortOpen = true,
-  messagePort
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const rawIpc = await IpcParentWithMessagePort$1.create({
-    isMessagePortOpen,
-    messagePort
-  });
-  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  messagePort.start();
-  return rpc;
+class IpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'IpcError';
+  }
+}
+
+const isErrorEvent = event => {
+  return event instanceof ErrorEvent;
 };
 
-const isWorker = value => {
-  return value instanceof Worker;
+const NewLine = '\n';
+
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+
+const splitLines = lines => {
+  string(lines);
+  return lines.split(NewLine);
 };
 
+class WorkerError extends Error {
+  constructor(event) {
+    super(event.message);
+    const stackLines = splitLines(this.stack);
+    const relevantLines = stackLines.slice(1);
+    const relevant = joinLines(relevantLines);
+    this.stack = `${event.message}
+    at Module (${event.filename}:${event.lineno}:${event.colno})
+${relevant}`;
+  }
+}
+
+const Module = 'module';
+
+const getWorkerDisplayName = name => {
+  if (name && name.endsWith('Worker')) {
+    return name;
+  }
+  return `${name} worker`;
+};
 const create$z = async ({
-  commandMap,
   name,
   url
 }) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const worker = await IpcParentWithModuleWorker$1.create({
+  const worker = new Worker(url, {
     name,
-    url
+    type: Module
   });
-  if (!isWorker(worker)) {
-    throw new Error(`worker must be of type Worker`);
+  // @ts-expect-error
+  const {
+    event,
+    type
+  } = await getFirstWorkerEvent(worker);
+  switch (type) {
+    case Message:
+      if (event.data !== 'ready') {
+        throw new IpcError('unexpected first message from worker');
+      }
+      break;
+    case Error$3:
+      if (isErrorEvent(event)) {
+        throw new WorkerError(event);
+      }
+      const displayName = getWorkerDisplayName(name);
+      throw new IpcError(`Failed to start ${displayName}`);
   }
-  const ipc = IpcParentWithModuleWorker$1.wrap(worker);
-  handleIpc(ipc);
-  const workerRpc = createRpc(ipc);
-  return workerRpc;
+  return worker;
+};
+const getData = event => {
+  // TODO why are some events not instance of message event?
+  if (event instanceof MessageEvent) {
+    return event.data;
+  }
+  return event;
+};
+const wrap = worker => {
+  let handleMessage;
+  const wrapped = {
+    get onmessage() {
+      return handleMessage;
+    },
+    set onmessage(listener) {
+      if (listener) {
+        handleMessage = event => {
+          const data = getData(event);
+          listener({
+            data,
+            target: wrapped
+          });
+        };
+      } else {
+        handleMessage = null;
+      }
+      worker.onmessage = handleMessage;
+    },
+    send(message) {
+      worker.postMessage(message);
+    },
+    sendAndTransfer(message) {
+      const transfer = getTransfer(message);
+      worker.postMessage(message, transfer);
+    }
+  };
+  return wrapped;
+};
+
+const IpcParentWithModuleWorker = {
+  __proto__: null,
+  create: create$z,
+  wrap
+};
+
+const isMessagePort = value => {
+  return value instanceof MessagePort;
 };
 
 const create$y = async ({
-  commandMap,
-  name,
-  port,
   url
 }) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const worker = await IpcParentWithModuleWorker$1.create({
-    name,
-    url
+  string(url);
+  const portPromise = await new Promise(resolve => {
+    Object.defineProperty(globalThis, 'acceptPort', {
+      configurable: true,
+      value: resolve
+    });
   });
-  if (!isWorker(worker)) {
-    throw new Error(`worker must be of type Worker`);
+  await import(url);
+  const port = await portPromise;
+  delete globalThis.acceptPort;
+  if (!port) {
+    throw new IpcError('port must be defined');
   }
-  const ipc = IpcParentWithModuleWorker$1.wrap(worker);
-  handleIpc(ipc);
-  const workerRpc = createRpc(ipc);
-  await workerRpc.invokeAndTransfer('initialize', 'message-port', port);
-  unhandleIpc(ipc);
-  return workerRpc;
+  if (!isMessagePort(port)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  return port;
 };
 
-const create$x = async ({
-  commandMap,
-  messagePort
-}) => {
-  return create$A({
-    commandMap,
-    messagePort
+const IpcParentWithMessagePort = {
+  __proto__: null,
+  create: create$y
+};
+
+const create$x = async url => {
+  const referencePort = await new Promise(resolve => {
+    Object.defineProperty(globalThis, 'acceptReferencePort', {
+      configurable: true,
+      value: resolve
+    });
+    import(url);
   });
+  delete globalThis.acceptReferencePort;
+  return referencePort;
+};
+
+const IpcParentWithReferencePort = {
+  __proto__: null,
+  create: create$x
 };
 
 const workers = Object.create(null);
@@ -3661,7 +3959,7 @@ const create$w = async ({
   raw,
   rpcId,
   url
-}, createTransferredRpc = create$y, createNativeRpc = create$z) => {
+}, createTransferredRpc = create$B, createNativeRpc = create$C) => {
   const rpc = await (rpcId === undefined ? createTransferredRpc({
     commandMap: {},
     name,
@@ -3688,34 +3986,7 @@ const IpcParentWithModuleWorkerWithMessagePort = {
   create: create$w
 };
 
-const Web = 1;
-const Electron = 2;
-const Remote = 3;
-
-/**
- * @returns {number}
- */
-const getPlatform = () => {
-  // @ts-expect-error
-  if (typeof PLATFORM !== 'undefined') {
-    // @ts-expect-error
-    return PLATFORM;
-  }
-  // @ts-ignore
-  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-    return Remote;
-  }
-  if (globalThis.isElectron) {
-    return Electron;
-  }
-  if (typeof location !== 'undefined' && location.search === '?web') {
-    return Web;
-  }
-  return Remote;
-};
-const platform = getPlatform();
-
-const isElectron = platform === Electron;
+const isElectron = platform === Electron$1;
 
 // TODO use handleIncomingIpc function
 const create$v = async ({
@@ -3726,7 +3997,7 @@ const create$v = async ({
   if (!isElectron) {
     throw new Error('Electron api was requested but is not available');
   }
-  const rpc = await create$B({
+  const rpc = await create$E({
     commandMap: {},
     window
   });
@@ -3741,12 +4012,12 @@ const IpcParentWithElectron = {
 
 const getModule = method => {
   switch (method) {
-    case Electron$1:
+    case Electron:
       return IpcParentWithElectron;
     case MessagePort$1:
-      return IpcParentWithMessagePort$2;
+      return IpcParentWithMessagePort;
     case ModuleWorker:
-      return IpcParentWithModuleWorker$2;
+      return IpcParentWithModuleWorker;
     case ModuleWorkerWithMessagePort:
       return IpcParentWithModuleWorkerWithMessagePort;
     case ReferencePort:
@@ -3770,225 +4041,6 @@ const has = name => {
   return ipcs[name];
 };
 
-const commandMapRef = {};
-
-const success = value => {
-  return {
-    ok: true,
-    value
-  };
-};
-const error = error => {
-  return {
-    error,
-    ok: false
-  };
-};
-const isError = result => {
-  return !result.ok;
-};
-
-const launchWorker = async ({
-  name,
-  url
-}) => {
-  try {
-    const rpc = await create$z({
-      commandMap: commandMapRef,
-      name,
-      url
-    });
-    return success(rpc);
-  } catch (error$1) {
-    return error(error$1);
-  }
-};
-
-const getAssetDir = () => {
-  // @ts-expect-error
-  if (typeof ASSET_DIR !== 'undefined') {
-    // @ts-expect-error
-    return ASSET_DIR;
-  }
-  if (platform === Electron) {
-    return '../../../../..';
-  }
-  return '';
-};
-const assetDir = getAssetDir();
-
-const getConfiguredWorkerUrl = key => {
-  if (typeof location === 'undefined' || typeof document === 'undefined') {
-    return '';
-  }
-  const configElement = document.getElementById('Config');
-  if (!configElement) {
-    return '';
-  }
-  const text = configElement.textContent;
-  if (!text) {
-    return '';
-  }
-  const config = JSON.parse(text);
-  return config[key] || '';
-};
-
-const getConfiguredRendererWorkerUrl = () => {
-  return getConfiguredWorkerUrl('rendererWorkerUrl');
-};
-
-const rendererWorkerUrl = getConfiguredRendererWorkerUrl() || `${assetDir}/packages/renderer-worker/src/rendererWorkerMain.ts`;
-
-const getName = platform => {
-  switch (platform) {
-    case Electron:
-      return 'Renderer Worker (Electron)';
-    case Web:
-      return 'Renderer Worker (Web)';
-    default:
-      return 'Renderer Worker';
-  }
-};
-const launchRendererWorker = async () => {
-  const name = getName(platform);
-  return launchWorker({
-    name,
-    url: rendererWorkerUrl
-  });
-};
-
-const selector = 'script.RendererWorkerTrace';
-const state$a = {
-  enabled: false,
-  entries: []
-};
-const serialize = value => {
-  const seen = new WeakSet();
-  const text = JSON.stringify(value, (_key, currentValue) => {
-    if (typeof currentValue === 'bigint') {
-      return `${currentValue}n`;
-    }
-    if (typeof currentValue !== 'object' || currentValue === null) {
-      return currentValue;
-    }
-    if (seen.has(currentValue)) {
-      return '[Circular]';
-    }
-    seen.add(currentValue);
-    if (currentValue instanceof ArrayBuffer) {
-      return {
-        byteLength: currentValue.byteLength,
-        type: 'ArrayBuffer'
-      };
-    }
-    if (ArrayBuffer.isView(currentValue)) {
-      return {
-        byteLength: currentValue.byteLength,
-        type: currentValue.constructor.name
-      };
-    }
-    if (currentValue instanceof Error) {
-      return {
-        message: currentValue.message,
-        name: currentValue.name,
-        stack: currentValue.stack
-      };
-    }
-    if (currentValue.constructor?.name === 'MessagePort') {
-      return {
-        type: 'MessagePort'
-      };
-    }
-    return currentValue;
-  });
-  return JSON.parse(text);
-};
-const isCommand = value => {
-  return typeof value === 'object' && value !== null && 'method' in value && typeof value.method === 'string';
-};
-const initialize = search => {
-  const searchParams = new URLSearchParams(search);
-  state$a.enabled = searchParams.has('traceRendererWorker');
-  state$a.entries = [];
-};
-const record = (direction, method, params) => {
-  if (!state$a.enabled) {
-    return;
-  }
-  state$a.entries.push({
-    direction,
-    method,
-    params: serialize(params),
-    timestamp: performance.now()
-  });
-};
-const listen = rpc => {
-  if (!state$a.enabled) {
-    return;
-  }
-  const ipc = rpc.ipc;
-  if (!ipc) {
-    return;
-  }
-  ipc.addEventListener('message', event => {
-    const message = ipc.getData(event);
-    if (isCommand(message)) {
-      record('received', message.method, message.params || []);
-    }
-  });
-};
-const exportToDom = () => {
-  if (!state$a.enabled) {
-    return;
-  }
-  const existing = document.querySelector(selector);
-  const script = existing || document.createElement('script');
-  script.className = 'RendererWorkerTrace';
-  script.type = 'application/json';
-  script.textContent = JSON.stringify({
-    entries: state$a.entries,
-    version: 1
-  });
-  if (!existing) {
-    document.body.append(script);
-  }
-};
-const scheduleExport = () => {
-  if (!state$a.enabled) {
-    return;
-  }
-  queueMicrotask(exportToDom);
-};
-
-const state$9 = {
-  rpc: undefined
-};
-const hydrate$2 = async () => {
-  const result = await launchRendererWorker();
-  if (isError(result)) {
-    state$9.rpc = undefined;
-    return result;
-  }
-  state$9.rpc = result.value;
-  listen(result.value);
-  return success(undefined);
-};
-const send$1 = (method, ...params) => {
-  record('sent', method, params);
-  // @ts-ignore
-  state$9.rpc.send(method, ...params);
-};
-const invoke$1 = (method, ...params) => {
-  record('sent', method, params);
-  // @ts-ignore
-  return state$9.rpc.invoke(method, ...params);
-};
-const invokeAndTransfer = (method, ...params) => {
-  record('sent', method, params);
-  // @ts-ignore
-  return state$9.rpc.invokeAndTransfer(method, ...params);
-};
-
 const create$u = async ({
   method,
   ...options
@@ -4684,7 +4736,7 @@ const openUrl = (url, useRedirect = false) => {
 };
 
 const isElectronUserAgentSpecificMemoryError = error => {
-  if (platform !== Electron) {
+  if (platform !== Electron$1) {
     return;
   }
   return error.message === `Failed to execute 'measureUserAgentSpecificMemory' on 'Performance': performance.measureUserAgentSpecificMemory is not available.`;
@@ -9873,11 +9925,15 @@ const unmock = () => {
   Element.prototype.releasePointerCapture = originalPointerCapture.releasePointerCapture;
 };
 
+const addHandle = (uri, handle) => {
+  return invoke$1('PersistentFileHandle.addHandle', uri, handle);
+};
+
 const forwardRendererWorkerCommand = (method, ...params) => {
   send$1(method, ...params);
 };
 const handleMessagePort = async (port, rpcId) => {
-  const rpc = await create$x({
+  const rpc = await create$A({
     commandMap: {
       'Viewlet.forwardRendererWorkerCommand': forwardRendererWorkerCommand,
       'Viewlet.queueCommands': queueCommands
@@ -10157,13 +10213,16 @@ const commandMap = {
   'DirectView.getFocusedUid': getFocusedViewUid,
   'DirectView.getUid': getViewUid,
   'Download.downloadFile': downloadFile,
-  'DropData.get': get$6,
-  'FileHandles.get': get$5,
+  'DragAndDrop.handleMessagePort': handleMessagePort$1,
+  'DropData.get': get$5,
+  'FileHandles.get': get$4,
   'FilePicker.showDirectoryPicker': showDirectoryPicker,
   'FilePicker.showFilePicker': showFilePicker,
   'FilePicker.showSaveFilePicker': showSaveFilePicker,
+  'FileSystem.writeFile': writeFile,
   'FileSystemHandle.addFileHandle': addFileHandle,
   'FileSystemHandle.getFileHandles': getFileHandles,
+  'FileSystemHandle.getFilePathElectron': getFilePathElectron,
   'FileSystemHandle.requestPermission': requestPermission,
   'GetFilePathElectron.getFilePathElectron': getFilePathElectron,
   'HandleMessagePort.handleMessagePort': handleMessagePort,
@@ -10174,7 +10233,7 @@ const commandMap = {
   'Layout.getBounds': getBounds,
   'Location.getHref': getHref,
   'Location.getPathName': getPathName,
-  'Location.hydrate': hydrate$3,
+  'Location.hydrate': hydrate$2,
   'Location.setPathName': setPathName,
   'MeasureTextBlockHeight.measureTextBlockHeight': measureTextBlockHeight,
   'MeasureTextHeight.measureTextHeight': measureTextHeight,
@@ -10193,6 +10252,7 @@ const commandMap = {
   'Open.redirectToUrl': redirectToUrl,
   'Performance.getMemory': getMemory,
   'Performance.measureUserAgentSpecificMemory': measureUserAgentSpecificMemory,
+  'PersistentFileHandle.addHandle': addHandle,
   'PointerCapture.mock': mock,
   'PointerCapture.unmock': unmock,
   'Prompt.prompt': prompt,
@@ -10330,7 +10390,7 @@ const mergeCustom = (custom, relevantStack) => {
 };
 const cleanStack = stack => {
   string(stack);
-  const lines = splitLines$2(stack);
+  const lines = splitLines(stack);
   const {
     actualStack,
     custom
@@ -10380,7 +10440,7 @@ const prepareErrorMessageWithCodeFrame = error => {
   }
   const message = getErrorMessage(error);
   const lines = cleanStack(error.stack);
-  const relevantStack = joinLines$2(lines);
+  const relevantStack = joinLines(lines);
   if (error.codeFrame) {
     return {
       _error: error,
@@ -10599,19 +10659,19 @@ const hydrate = async () => {
   return success(undefined);
 };
 
-const workerFns = [hydrate$2, hydrate$1, hydrate];
+const requiredWorkerFns = [hydrate$3, hydrate$4];
+const additionalWorkerFns = [hydrate$1, hydrate];
 const call = fn => {
   return fn();
 };
 const launchWorkers = async () => {
-  {
-    const results = await Promise.all(workerFns.map(call));
-    const firstError = results.find(isError);
-    if (firstError) {
-      return firstError;
-    }
-    return success(undefined);
+  const workerFns = [...requiredWorkerFns, ...additionalWorkerFns] ;
+  const results = await Promise.all(workerFns.map(call));
+  const firstError = results.find(isError);
+  if (firstError) {
+    return firstError;
   }
+  return success(undefined);
 };
 
 const handleFocusIn = event => {