@lvce-editor/static-server 0.105.9 → 0.105.11

package/static/{b9ff48c → 74b2f22}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -95,7 +95,7 @@ const getAssetDir$2 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/b9ff48c';
+    return '/74b2f22';
   }
 };
 const assetDir = getAssetDir$2();
@@ -2560,7 +2560,7 @@ const state$w = {
   href: ''
 };
 
-const initialize$2 = href => {
+const initialize$3 = href => {
   state$w.href = href;
 };
 const getHref$1 = async () => {
@@ -6266,7 +6266,7 @@ const load$2 = async moduleId => {
   }
 };
 
-const initialize$1 = async initData => {
+const initialize$2 = async initData => {
   const uid = create$1b();
   const viewlet = {
     disposed: false,
@@ -7458,6 +7458,397 @@ const getConfig = () => {
   return state$h.shouldLaunchMultipleWorkers;
 };
 
+const transferrables = [];
+if (typeof OffscreenCanvas !== 'undefined') {
+  transferrables.push(OffscreenCanvas);
+}
+if (typeof MessagePort !== 'undefined') {
+  transferrables.push(MessagePort);
+}
+
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (value instanceof fn) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const walkValue$1 = (value, transferrables, seen) => {
+  if (!value || typeof value !== 'object' && typeof value !== 'function') {
+    return;
+  }
+  if (seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+  if (value instanceof ArrayBuffer || isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (ArrayBuffer.isView(value)) {
+    walkValue$1(value.buffer, transferrables, seen);
+    return;
+  }
+  for (const child of Array.isArray(value) ? value : Object.values(value)) {
+    walkValue$1(child, transferrables, seen);
+  }
+};
+const getIpcTraceTransferrables = value => {
+  const transferrables = [];
+  walkValue$1(value, transferrables, new WeakSet());
+  return transferrables;
+};
+
+const traceIpcFlag = '--trace-ipc';
+const traceIpcPrefix = `${traceIpcFlag}=`;
+const parseTraceIpc = argv => {
+  let value;
+  for (let index = 1; index < argv.length; index++) {
+    const argument = argv[index];
+    if (argument === traceIpcFlag) {
+      const nextArgument = argv[index + 1];
+      value = typeof nextArgument === 'string' && !nextArgument.startsWith('--') ? nextArgument : '';
+      break;
+    }
+    if (typeof argument === 'string' && argument.startsWith(traceIpcPrefix)) {
+      value = argument.slice(traceIpcPrefix.length);
+      break;
+    }
+  }
+  if (value === undefined) {
+    return {
+      error: '',
+      selectors: new Set()
+    };
+  }
+  const selectors = new Set(value.split(',').map(selector => selector.trim()).filter(Boolean));
+  if (selectors.size === 0) {
+    return {
+      error: '--trace-ipc requires a comma-separated worker id list or *',
+      selectors
+    };
+  }
+  return {
+    error: '',
+    selectors
+  };
+};
+const shouldTrace = (selectors, traceId) => {
+  return selectors.has('*') || Boolean(traceId && selectors.has(traceId));
+};
+
+const version = '0.105.11';
+const commit$1 = '74b2f22';
+const productNameLong = 'Lvce Editor - OSS';
+const getPid = () => {
+  return invoke$G('Process.getPid');
+};
+const getElectronVersion = () => {
+  return invoke$G('ElectronProcess.getElectronVersion');
+};
+const getNodeVersion = () => {
+  return invoke$G('Process.getNodeVersion');
+};
+const getChromeVersion = () => {
+  return invoke$G('ElectronProcess.getChromeVersion');
+};
+const getVersion = () => {
+  return version;
+};
+const getCommit$1 = () => {
+  return commit$1;
+};
+const getProductNameLong = () => {
+  return productNameLong;
+};
+const getV8Version = () => {
+  return invoke$G('Process.getV8Version');
+};
+const getArch = () => {
+  return invoke$G('Process.getArch');
+};
+const getArgvCommand = platform => {
+  if (platform !== Electron$1) {
+    return 'Process.getArgv';
+  }
+  return 'ElectronProcess.getArgv';
+};
+const getArgv = () => {
+  return invoke$G(getArgvCommand(getPlatform$3()));
+};
+const writeStderr = value => {
+  return invoke$G('ElectronProcess.writeStderr', value);
+};
+const writeStdout = value => {
+  return invoke$G('ElectronProcess.writeStdout', value);
+};
+
+const getConstructorName = value => {
+  return value?.constructor?.name || 'Object';
+};
+const serializeError = error => {
+  return {
+    $type: getConstructorName(error),
+    message: error.message,
+    name: error.name,
+    stack: error.stack
+  };
+};
+const serializeValue = (value, seen, nextReference) => {
+  if (value === null || typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string') {
+    return value;
+  }
+  if (typeof value === 'bigint') {
+    return {
+      $type: 'BigInt',
+      value: String(value)
+    };
+  }
+  if (typeof value === 'undefined') {
+    return {
+      $type: 'Undefined'
+    };
+  }
+  if (typeof value === 'function' || typeof value === 'symbol') {
+    return {
+      $type: getConstructorName(value),
+      value: String(value)
+    };
+  }
+  if (value instanceof Error) {
+    return serializeError(value);
+  }
+  if (typeof MessagePort !== 'undefined' && value instanceof MessagePort) {
+    return {
+      $type: 'MessagePort'
+    };
+  }
+  if (value instanceof ArrayBuffer) {
+    return {
+      $type: 'ArrayBuffer',
+      byteLength: value.byteLength
+    };
+  }
+  if (ArrayBuffer.isView(value)) {
+    const length = 'length' in value && typeof value.length === 'number' ? value.length : undefined;
+    return {
+      $type: getConstructorName(value),
+      byteLength: value.byteLength,
+      length
+    };
+  }
+  if (value instanceof Date) {
+    return {
+      $type: 'Date',
+      value: value.toISOString()
+    };
+  }
+  const existingReference = seen.get(value);
+  if (existingReference !== undefined) {
+    return {
+      $ref: existingReference
+    };
+  }
+  const reference = nextReference.value++;
+  seen.set(value, reference);
+  if (Array.isArray(value)) {
+    return value.map(item => serializeValue(item, seen, nextReference));
+  }
+  const result = {};
+  for (const key of Object.keys(value)) {
+    try {
+      result[key] = serializeValue(value[key], seen, nextReference);
+    } catch (error) {
+      result[key] = {
+        $type: 'SerializationError',
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  const constructorName = getConstructorName(value);
+  if (constructorName !== 'Object') {
+    result.$type = constructorName;
+  }
+  return result;
+};
+const serializeIpcTraceMessage = value => {
+  return serializeValue(value, new WeakMap(), {
+    value: 1
+  });
+};
+
+const flushRecordCount = 100;
+const flushDelay = 100;
+const createEmptyOptions = () => ({
+  error: '',
+  selectors: new Set()
+});
+
+/** @type {any} */
+const state$g = {
+  batches: new Map(),
+  connectionId: 0,
+  disabled: false,
+  flushTimer: undefined,
+  getArgv: getArgv,
+  getTransferrables: getIpcTraceTransferrables,
+  now: () => performance.now(),
+  options: createEmptyOptions(),
+  pendingRecordCount: 0,
+  serialize: serializeIpcTraceMessage,
+  setTimeout: (callback, delay) => globalThis.setTimeout(callback, delay),
+  timeOrigin: () => performance.timeOrigin,
+  wallTime: () => new Date().toISOString(),
+  write: (workerId, records) => invoke$G('IpcTrace.append', workerId, records),
+  writeChain: Promise.resolve(),
+  writeStderr: writeStderr
+};
+const reportError = error => {
+  if (state$g.disabled) {
+    return;
+  }
+  state$g.disabled = true;
+  if (state$g.flushTimer !== undefined) {
+    clearTimeout(state$g.flushTimer);
+    state$g.flushTimer = undefined;
+  }
+  state$g.batches.clear();
+  state$g.pendingRecordCount = 0;
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`IPC tracing disabled: ${message}`);
+  void Promise.resolve(state$g.writeStderr(`IPC tracing disabled: ${message}\n`)).catch(() => {});
+};
+const initialize$1 = async () => {
+  try {
+    const argv = await state$g.getArgv();
+    state$g.options = parseTraceIpc(argv);
+    if (state$g.options.error) {
+      reportError(new Error(state$g.options.error));
+    }
+  } catch (error) {
+    reportError(error);
+    state$g.options = createEmptyOptions();
+  }
+};
+const getWorkerId = (traceId, name, runtimeId) => {
+  if (traceId) {
+    return traceId;
+  }
+  const suffix = name ? `-${name}` : '';
+  return `runtime-${runtimeId}${suffix}`;
+};
+const writeBatches = batches => {
+  state$g.writeChain = state$g.writeChain.then(async () => {
+    for (const [workerId, records] of batches) {
+      await state$g.write(workerId, records);
+    }
+  }).catch(reportError);
+};
+const flush = async () => {
+  if (state$g.flushTimer !== undefined) {
+    clearTimeout(state$g.flushTimer);
+    state$g.flushTimer = undefined;
+  }
+  if (state$g.pendingRecordCount === 0) {
+    await state$g.writeChain;
+    return;
+  }
+  const batches = state$g.batches;
+  state$g.batches = new Map();
+  state$g.pendingRecordCount = 0;
+  writeBatches(batches);
+  await state$g.writeChain;
+};
+const queueRecord = (workerId, record) => {
+  if (state$g.disabled) {
+    return;
+  }
+  let records = state$g.batches.get(workerId);
+  if (!records) {
+    records = [];
+    state$g.batches.set(workerId, records);
+  }
+  records.push(record);
+  state$g.pendingRecordCount++;
+  if (state$g.pendingRecordCount >= flushRecordCount) {
+    void flush();
+    return;
+  }
+  state$g.flushTimer ||= state$g.setTimeout(() => {
+    state$g.flushTimer = undefined;
+    void flush();
+  }, flushDelay);
+};
+const getData$2 = event => {
+  if (typeof MessageEvent !== 'undefined' && event instanceof MessageEvent) {
+    return event.data;
+  }
+  return event?.data ?? event;
+};
+const createForwarder = (source, target, workerId, connectionId, direction, sequence) => {
+  source.onmessage = event => {
+    const message = getData$2(event);
+    const monotonicTime = state$g.now();
+    const startTime = monotonicTime;
+    let serializedMessage;
+    try {
+      serializedMessage = state$g.serialize(message);
+    } catch (error) {
+      serializedMessage = {
+        $type: 'SerializationError',
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+    const serializationDuration = state$g.now() - startTime;
+    const transferables = state$g.getTransferrables(message);
+    target.postMessage(message, transferables);
+    queueRecord(workerId, {
+      connectionId,
+      direction,
+      message: serializedMessage,
+      monotonicTime,
+      sequence: sequence.value++,
+      serializationDuration,
+      version: 1,
+      wallTime: state$g.wallTime(),
+      workerId
+    });
+  };
+  source.start?.();
+};
+const maybeCreateProxy = async ({
+  id,
+  name = '',
+  port,
+  traceId = ''
+}) => {
+  if (!port || state$g.disabled) {
+    return port;
+  }
+  if (!shouldTrace(state$g.options.selectors, traceId)) {
+    return port;
+  }
+  const workerId = getWorkerId(traceId, name, id);
+  const connectionId = `${state$g.timeOrigin()}-${state$g.connectionId++}`;
+  try {
+    const {
+      port1: proxyPort,
+      port2: workerPort
+    } = new MessageChannel();
+    const sequence = {
+      value: 1
+    };
+    createForwarder(port, proxyPort, workerId, connectionId, 'parent-to-worker', sequence);
+    createForwarder(proxyPort, port, workerId, connectionId, 'worker-to-parent', sequence);
+    return workerPort;
+  } catch (error) {
+    reportError(error);
+    return port;
+  }
+};
+
 // based on https://github.com/babel/babel/blob/6be6e04f396f03feace4431f709564a8d842163a/packages/babel-code-frame/src/index.ts (License MIT)
 
 /**
@@ -7558,7 +7949,7 @@ const create$16 = (rawLines, loc, opts = {}) => {
   return frame;
 };
 
-const state$g = {
+const state$f = {
   /**
    * @type {any[]}
    */
@@ -7585,7 +7976,7 @@ const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
   return '';
 };
 const getLanguageConfigurationFromWebExtension = async languageId => {
-  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$g.webExtensions, languageId);
+  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$f.webExtensions, languageId);
   if (!languageConfigurationPath) {
     return undefined;
   }
@@ -7640,7 +8031,7 @@ const splitLines = lines => {
 
 // TODO merge all of this with extension host languages module
 
-const state$f = {
+const state$e = {
   isHydrating: false,
   fileNameMap: Object.create(null),
   extensionMap: Object.create(null),
@@ -7655,53 +8046,53 @@ const state$f = {
   hasWarned: []
 };
 const getFirstLines = () => {
-  return state$f.firstLines;
+  return state$e.firstLines;
 };
 const hasLanguageByExtension = extension => {
-  return extension in state$f.extensionMap;
+  return extension in state$e.extensionMap;
 };
 const getLanguageByExtension = extension => {
-  return state$f.extensionMap[extension];
+  return state$e.extensionMap[extension];
 };
 const hasLanguageByFileName = fileName => {
-  return fileName in state$f.fileNameMap;
+  return fileName in state$e.fileNameMap;
 };
 const getLanguageByFileName = fileName => {
-  return state$f.fileNameMap[fileName];
+  return state$e.fileNameMap[fileName];
 };
 const getTokenizeFunctionPath$1 = languageId => {
   // TODO what if language.tokenize is not of type string? -> handle error gracefully
-  return state$f.tokenizerMap[languageId] || '';
+  return state$e.tokenizerMap[languageId] || '';
 };
 const setHydrating = value => {
-  state$f.isHydrating = value;
+  state$e.isHydrating = value;
 };
 const setLoaded = value => {
-  state$f.loaded = true;
+  state$e.loaded = true;
 };
 const addExtension = (extension, languageId) => {
-  state$f.extensionMap[extension] = languageId;
+  state$e.extensionMap[extension] = languageId;
 };
 const addFirstLine = (regex, languageId) => {
-  state$f.firstLines.push({
+  state$e.firstLines.push({
     regex,
     languageId
   });
 };
 const hasWarned = languageId => {
-  return state$f.hasWarned.includes(languageId);
+  return state$e.hasWarned.includes(languageId);
 };
 const addWarned = languageId => {
-  return state$f.hasWarned.push(languageId);
+  return state$e.hasWarned.push(languageId);
 };
 const addFileName = (fileName, languageId) => {
-  state$f.fileNameMap[fileName] = languageId;
+  state$e.fileNameMap[fileName] = languageId;
 };
 const addTokenizer = (languageId, tokenizer) => {
-  state$f.tokenizerMap[languageId] = tokenizer;
+  state$e.tokenizerMap[languageId] = tokenizer;
 };
 const hasLoaded$1 = () => {
-  return state$f.loaded;
+  return state$e.loaded;
 };
 
 // TODO merge all of this with extension host languages module
@@ -7923,18 +8314,18 @@ const Fourteen = 14;
 const Fifteen = 15;
 const Sixteen = 16;
 
-const state$e = {
+const state$d = {
   listenerMap: Object.create(null),
   phase: Zero
 };
 const mark$1 = event => {
-  const listeners = state$e.listenerMap[event] || [];
+  const listeners = state$d.listenerMap[event] || [];
   for (const listener of listeners) {
     listener();
   }
-  state$e.phase = event;
+  state$d.phase = event;
   if (event === Twelve) {
-    state$e.listenerMap = Object.create(null);
+    state$d.listenerMap = Object.create(null);
   }
 };
 
@@ -8328,59 +8719,13 @@ const LoadActivityBar = 'code/loadActivityBar';
 const LoadStatusBar = 'code/loadStatusBar';
 const LoadPreferences = 'code/loadPreferences';
 const LoadColorTheme = 'code/loadColorTheme';
-const LoadIconTheme = 'code/loadIconTheme';
-
-const exit$1 = code => {
-  if (code === undefined) {
-    return invoke$G('Exit.exit');
-  }
-  return invoke$G('Exit.exit', code);
-};
-
-const version = '0.105.9';
-const commit$1 = 'b9ff48c';
-const productNameLong = 'Lvce Editor - OSS';
-const getPid = () => {
-  return invoke$G('Process.getPid');
-};
-const getElectronVersion = () => {
-  return invoke$G('ElectronProcess.getElectronVersion');
-};
-const getNodeVersion = () => {
-  return invoke$G('Process.getNodeVersion');
-};
-const getChromeVersion = () => {
-  return invoke$G('ElectronProcess.getChromeVersion');
-};
-const getVersion = () => {
-  return version;
-};
-const getCommit$1 = () => {
-  return commit$1;
-};
-const getProductNameLong = () => {
-  return productNameLong;
-};
-const getV8Version = () => {
-  return invoke$G('Process.getV8Version');
-};
-const getArch = () => {
-  return invoke$G('Process.getArch');
-};
-const getArgvCommand = platform => {
-  if (platform !== Electron$1) {
-    return 'Process.getArgv';
+const LoadIconTheme = 'code/loadIconTheme';
+
+const exit$1 = code => {
+  if (code === undefined) {
+    return invoke$G('Exit.exit');
   }
-  return 'ElectronProcess.getArgv';
-};
-const getArgv = () => {
-  return invoke$G(getArgvCommand(getPlatform$3()));
-};
-const writeStderr = value => {
-  return invoke$G('ElectronProcess.writeStderr', value);
-};
-const writeStdout = value => {
-  return invoke$G('ElectronProcess.writeStdout', value);
+  return invoke$G('Exit.exit', code);
 };
 
 const fileSystemWorkerUrl = `${assetDir}/packages/file-system-worker/dist/fileSystemWorkerMain.js`;
@@ -8929,12 +9274,12 @@ const creareSessionId = () => {
   return `session-${new Date().toISOString()}`;
 };
 
-const state$d = {
+const state$c = {
   sessionId: ''
 };
 const getSessionId = () => {
-  state$d.sessionId ||= creareSessionId();
-  return state$d.sessionId;
+  state$c.sessionId ||= creareSessionId();
+  return state$c.sessionId;
 };
 
 const sleep = duration => {
@@ -8971,7 +9316,7 @@ const addSearchParam = (href, key, value) => {
   return parsedUrl.toString();
 };
 const replayCurrentSession = async () => {
-  if (!state$d.sessionId) {
+  if (!state$c.sessionId) {
     throw new VError('session replay is disabled in settings');
   }
   // TODO
@@ -9393,9 +9738,10 @@ const startup = async (platform, assetDir) => {
   mark(WillStartupWorkbench);
   await listen$1();
   const initData = await getInitData();
-  initialize$2(initData.Location.href);
+  initialize$3(initData.Location.href);
   if (platform !== Web$1) {
     await launchSharedProcess();
+    await initialize$1();
   }
   mark$1(One);
   setConfig(initData.Config?.shouldLaunchMultipleWorkers);
@@ -9432,7 +9778,7 @@ const startup = async (platform, assetDir) => {
   await hydrate$7(initData.Location);
   mark(DidOpenWorkspace);
   if (promptOptions !== undefined) {
-    await initialize$1(initData);
+    await initialize$2(initData);
     await execute$4('Layout.setAuthState', authState);
     await run(promptOptions, authState);
     return;
@@ -10124,7 +10470,7 @@ const main = async () => {
 };
 main();
 
-const walkValue$1 = (value, transferrables, isTransferrable) => {
+const walkValue = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
   }
@@ -10134,38 +10480,21 @@ const walkValue$1 = (value, transferrables, isTransferrable) => {
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      walkValue$1(item, transferrables, isTransferrable);
+      walkValue(item, transferrables, isTransferrable);
     }
     return;
   }
   if (typeof value === 'object') {
     for (const property of Object.values(value)) {
-      walkValue$1(property, transferrables, isTransferrable);
+      walkValue(property, transferrables, isTransferrable);
     }
     return;
   }
 };
 
-const transferrables = [];
-if (typeof OffscreenCanvas !== 'undefined') {
-  transferrables.push(OffscreenCanvas);
-}
-if (typeof MessagePort !== 'undefined') {
-  transferrables.push(MessagePort);
-}
-
-const isTransferrable = value => {
-  for (const fn of transferrables) {
-    if (value instanceof fn) {
-      return true;
-    }
-  }
-  return false;
-};
-
 const getTransferrables = value => {
   const transferrables = [];
-  walkValue$1(value, transferrables, isTransferrable);
+  walkValue(value, transferrables, isTransferrable);
   return transferrables;
 };
 
@@ -10206,7 +10535,7 @@ const fixElectronParameters = value => {
   };
 };
 
-const getData$2 = event => {
+const getData$1 = event => {
   const {
     data
   } = event;
@@ -10216,232 +10545,33 @@ const getData$2 = event => {
 const ModuleWorkerWithMessagePort = 4;
 const Electron = 5;
 
-const getPort = async ipcId => {
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  // TODO call sendMessagePortToElectron function
-  const webContentsId = await invokeAndTransfer$P('IpcParent.create', {
-    method: Electron,
-    port: port1,
-    ipcId
-  });
-  // TODO avoid side effect?
-  set$d(webContentsId);
-  return port2;
-};
-const create$14 = async options => {
-  const type = options.type;
-  const name = options.name || 'electron ipc';
-  const ipcId = options.ipcId;
-  string(type);
-  string(name);
-  const port = await getPort(ipcId);
-  return port;
-};
-const wrap$6 = port => {
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    listener: undefined,
-    get onmessage() {
-      return this.listener;
-    },
-    set onmessage(listener) {
-      this.listener = listener;
-      const wrappedListener = event => {
-        const data = getData$2(event);
-        const syntheticEvent = {
-          data,
-          target: this
-        };
-        listener(syntheticEvent);
-      };
-      this.port.onmessage = wrappedListener;
-    },
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message) {
-      const {
-        newValue,
-        transfer
-      } = fixElectronParameters(message);
-      this.port.postMessage(newValue, transfer);
-    }
-  };
-};
-
-const IpcParentWithElectronMessagePort = {
-  __proto__: null,
-  create: create$14,
-  wrap: wrap$6
-};
-
-const isMessagePort = value => {
-  return value instanceof MessagePort;
-};
-
-const create$13 = async ({
-  url
-}) => {
-  string(url);
-  const portPromise = new Promise(resolve => {
-    globalThis.acceptPort = resolve;
-  });
-  await import(url);
-  const port = await portPromise;
-  delete globalThis.acceptPort;
-  if (!port) {
-    throw new IpcError('port must be defined');
-  }
-  if (!isMessagePort(port)) {
-    throw new IpcError('port must be of type MessagePort');
-  }
-  return port;
-};
-const wrap$5 = port => {
-  return {
-    /**
-     * @type {any}
-     */
-    listener: undefined,
-    get onmessage() {
-      return this.listener;
-    },
-    set onmessage(listener) {
-      this.listener = listener;
-      const wrappedListener = event => {
-        const message = getData$2(event);
-        const syntheticEvent = {
-          data: message,
-          target: this
-        };
-        listener(syntheticEvent);
-      };
-      this.port.onmessage = wrappedListener;
-    },
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message, transfer) {
-      this.port.postMessage(message, transfer);
-    }
-  };
-};
-
-const IpcParentWithMessagePort = {
-  __proto__: null,
-  create: create$13,
-  wrap: wrap$5
-};
-
-const Message = 'message';
-const Error$2 = 'error';
-
-const getFirstWorkerEvent = async worker => {
-  const {
-    type,
-    event
-  } = await new Promise((resolve, reject) => {
-    const cleanup = value => {
-      worker.onmessage = null;
-      worker.onerror = null;
-      resolve(value);
-    };
-    const handleFirstMessage = event => {
-      cleanup({
-        type: Message,
-        event
-      });
-    };
-    const handleFirstError = event => {
-      cleanup({
-        type: Error$2,
-        event
-      });
-    };
-    worker.onmessage = handleFirstMessage;
-    worker.onerror = handleFirstError;
-  });
-  return {
-    type,
-    event
-  };
-};
-
-const getWorkerDisplayName = name => {
-  if (!name) {
-    return '<unknown> worker';
-  }
-  if (name.endsWith('Worker') || name.endsWith('worker')) {
-    return name.toLowerCase();
-  }
-  return `${name} worker`;
-};
-
-const tryToGetActualErrorMessage = async ({
-  url,
-  name
-}) => {
-  const displayName = getWorkerDisplayName(name);
-  try {
-    await import(url);
-    return `Failed to start ${displayName}: Unknown Error`;
-  } catch (error) {
-    if (error && error instanceof Error && error.message.startsWith('Failed to fetch dynamically imported module')) {
-      try {
-        const response = await fetch(url);
-        switch (response.status) {
-          case NotFound:
-            return `Failed to start ${displayName}: Not found (404)`;
-          default:
-            return `Failed to start ${displayName}: Unknown Network Error`;
-        }
-      } catch {
-        return `Failed to start ${displayName}: Unknown Network Error`;
-      }
-    }
-    return `Failed to start ${displayName}: ${error}`;
-  }
-};
-
-const Module = 'module';
-
-const create$12 = async ({
-  url,
-  name
-}) => {
-  const worker = new Worker(url, {
-    type: Module,
-    name
-  });
-  const {
-    type,
-    event
-  } = await getFirstWorkerEvent(worker);
-  switch (type) {
-    case Message:
-      if (event.data !== 'ready') {
-        throw new IpcError('unexpected first message from worker');
-      }
-      break;
-    case Error$2:
-      const actualErrorMessage = await tryToGetActualErrorMessage({
-        url,
-        name
-      });
-      throw new Error(actualErrorMessage);
-  }
-  return worker;
+const getPort = async ipcId => {
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  // TODO call sendMessagePortToElectron function
+  const webContentsId = await invokeAndTransfer$P('IpcParent.create', {
+    method: Electron,
+    port: port1,
+    ipcId
+  });
+  // TODO avoid side effect?
+  set$d(webContentsId);
+  return port2;
 };
-const getMessage$1 = event => {};
-const wrap$4 = worker => {
+const create$14 = async options => {
+  const type = options.type;
+  const name = options.name || 'electron ipc';
+  const ipcId = options.ipcId;
+  string(type);
+  string(name);
+  const port = await getPort(ipcId);
+  return port;
+};
+const wrap$6 = port => {
   return {
-    worker,
+    port,
     /**
      * @type {any}
      */
@@ -10452,47 +10582,58 @@ const wrap$4 = worker => {
     set onmessage(listener) {
       this.listener = listener;
       const wrappedListener = event => {
-        const message = getMessage$1();
+        const data = getData$1(event);
         const syntheticEvent = {
-          data: message,
+          data,
           target: this
         };
         listener(syntheticEvent);
       };
-      this.worker.onmessage = wrappedListener;
+      this.port.onmessage = wrappedListener;
     },
     send(message) {
-      this.worker.postMessage(message);
+      this.port.postMessage(message);
     },
     sendAndTransfer(message) {
-      const transfer = getFirstWorkerEvent(message);
-      this.worker.postMessage(message, transfer);
+      const {
+        newValue,
+        transfer
+      } = fixElectronParameters(message);
+      this.port.postMessage(newValue, transfer);
     }
   };
 };
 
-const IpcParentWithModuleWorker = {
+const IpcParentWithElectronMessagePort = {
   __proto__: null,
-  create: create$12,
-  wrap: wrap$4
+  create: create$14,
+  wrap: wrap$6
 };
 
-const create$11 = async ({
+const isMessagePort = value => {
+  return value instanceof MessagePort;
+};
+
+const create$13 = async ({
   url
 }) => {
-  const referencePort = await new Promise(resolve => {
-    globalThis.acceptReferencePort = resolve;
-    import(url);
+  string(url);
+  const portPromise = new Promise(resolve => {
+    globalThis.acceptPort = resolve;
   });
-  delete globalThis.acceptReferencePort;
-  return referencePort;
-};
-const getMessage = message => {
-  return message;
+  await import(url);
+  const port = await portPromise;
+  delete globalThis.acceptPort;
+  if (!port) {
+    throw new IpcError('port must be defined');
+  }
+  if (!isMessagePort(port)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  return port;
 };
-const wrap$3 = referencePort => {
+const wrap$5 = port => {
   return {
-    referencePort,
     /**
      * @type {any}
      */
@@ -10503,354 +10644,213 @@ const wrap$3 = referencePort => {
     set onmessage(listener) {
       this.listener = listener;
       const wrappedListener = event => {
-        const message = getMessage(event);
+        const message = getData$1(event);
         const syntheticEvent = {
           data: message,
           target: this
         };
         listener(syntheticEvent);
       };
-      this.referencePort.onmessage = wrappedListener;
+      this.port.onmessage = wrappedListener;
     },
     send(message) {
-      this.referencePort.postMessage(message);
+      this.port.postMessage(message);
+    },
+    sendAndTransfer(message, transfer) {
+      this.port.postMessage(message, transfer);
     }
   };
 };
 
-const IpcParentWithReferencePort = {
+const IpcParentWithMessagePort = {
   __proto__: null,
-  create: create$11,
-  wrap: wrap$3
-};
-
-const walkValue = (value, transferrables, seen) => {
-  if (!value || typeof value !== 'object' && typeof value !== 'function') {
-    return;
-  }
-  if (seen.has(value)) {
-    return;
-  }
-  seen.add(value);
-  if (value instanceof ArrayBuffer || isTransferrable(value)) {
-    transferrables.push(value);
-    return;
-  }
-  if (ArrayBuffer.isView(value)) {
-    walkValue(value.buffer, transferrables, seen);
-    return;
-  }
-  for (const child of Array.isArray(value) ? value : Object.values(value)) {
-    walkValue(child, transferrables, seen);
-  }
-};
-const getIpcTraceTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, new WeakSet());
-  return transferrables;
+  create: create$13,
+  wrap: wrap$5
 };
 
-const traceIpcFlag = '--trace-ipc';
-const traceIpcPrefix = `${traceIpcFlag}=`;
-const parseTraceIpc = argv => {
-  let value;
-  for (let index = 1; index < argv.length; index++) {
-    const argument = argv[index];
-    if (argument === traceIpcFlag) {
-      const nextArgument = argv[index + 1];
-      value = typeof nextArgument === 'string' && !nextArgument.startsWith('--') ? nextArgument : '';
-      break;
-    }
-    if (typeof argument === 'string' && argument.startsWith(traceIpcPrefix)) {
-      value = argument.slice(traceIpcPrefix.length);
-      break;
-    }
-  }
-  if (value === undefined) {
-    return {
-      error: '',
-      selectors: new Set()
-    };
-  }
-  const selectors = new Set(value.split(',').map(selector => selector.trim()).filter(Boolean));
-  if (selectors.size === 0) {
-    return {
-      error: '--trace-ipc requires a comma-separated worker id list or *',
-      selectors
-    };
-  }
-  return {
-    error: '',
-    selectors
-  };
-};
-const shouldTrace = (selectors, traceId) => {
-  return selectors.has('*') || Boolean(traceId && selectors.has(traceId));
-};
+const Message = 'message';
+const Error$2 = 'error';
 
-const getConstructorName = value => {
-  return value?.constructor?.name || 'Object';
-};
-const serializeError = error => {
-  return {
-    $type: getConstructorName(error),
-    message: error.message,
-    name: error.name,
-    stack: error.stack
-  };
-};
-const serializeValue = (value, seen, nextReference) => {
-  if (value === null || typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string') {
-    return value;
-  }
-  if (typeof value === 'bigint') {
-    return {
-      $type: 'BigInt',
-      value: String(value)
-    };
-  }
-  if (typeof value === 'undefined') {
-    return {
-      $type: 'Undefined'
-    };
-  }
-  if (typeof value === 'function' || typeof value === 'symbol') {
-    return {
-      $type: getConstructorName(value),
-      value: String(value)
-    };
-  }
-  if (value instanceof Error) {
-    return serializeError(value);
-  }
-  if (typeof MessagePort !== 'undefined' && value instanceof MessagePort) {
-    return {
-      $type: 'MessagePort'
-    };
-  }
-  if (value instanceof ArrayBuffer) {
-    return {
-      $type: 'ArrayBuffer',
-      byteLength: value.byteLength
-    };
-  }
-  if (ArrayBuffer.isView(value)) {
-    const length = 'length' in value && typeof value.length === 'number' ? value.length : undefined;
-    return {
-      $type: getConstructorName(value),
-      byteLength: value.byteLength,
-      length
-    };
-  }
-  if (value instanceof Date) {
-    return {
-      $type: 'Date',
-      value: value.toISOString()
-    };
-  }
-  const existingReference = seen.get(value);
-  if (existingReference !== undefined) {
-    return {
-      $ref: existingReference
+const getFirstWorkerEvent = async worker => {
+  const {
+    type,
+    event
+  } = await new Promise((resolve, reject) => {
+    const cleanup = value => {
+      worker.onmessage = null;
+      worker.onerror = null;
+      resolve(value);
     };
-  }
-  const reference = nextReference.value++;
-  seen.set(value, reference);
-  if (Array.isArray(value)) {
-    return value.map(item => serializeValue(item, seen, nextReference));
-  }
-  const result = {};
-  for (const key of Object.keys(value)) {
-    try {
-      result[key] = serializeValue(value[key], seen, nextReference);
-    } catch (error) {
-      result[key] = {
-        $type: 'SerializationError',
-        message: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  const constructorName = getConstructorName(value);
-  if (constructorName !== 'Object') {
-    result.$type = constructorName;
-  }
-  return result;
-};
-const serializeIpcTraceMessage = value => {
-  return serializeValue(value, new WeakMap(), {
-    value: 1
+    const handleFirstMessage = event => {
+      cleanup({
+        type: Message,
+        event
+      });
+    };
+    const handleFirstError = event => {
+      cleanup({
+        type: Error$2,
+        event
+      });
+    };
+    worker.onmessage = handleFirstMessage;
+    worker.onerror = handleFirstError;
   });
+  return {
+    type,
+    event
+  };
 };
 
-const flushRecordCount = 100;
-const flushDelay = 100;
-
-/** @type {any} */
-const state$c = {
-  batches: new Map(),
-  connectionId: 0,
-  disabled: false,
-  flushTimer: undefined,
-  getArgv: getArgv,
-  getTransferrables: getIpcTraceTransferrables,
-  now: () => performance.now(),
-  optionsPromise: undefined,
-  pendingRecordCount: 0,
-  serialize: serializeIpcTraceMessage,
-  setTimeout: (callback, delay) => globalThis.setTimeout(callback, delay),
-  timeOrigin: () => performance.timeOrigin,
-  wallTime: () => new Date().toISOString(),
-  write: (workerId, records) => invoke$G('IpcTrace.append', workerId, records),
-  writeChain: Promise.resolve(),
-  writeStderr: writeStderr
-};
-const reportError = error => {
-  if (state$c.disabled) {
-    return;
+const getWorkerDisplayName = name => {
+  if (!name) {
+    return '<unknown> worker';
   }
-  state$c.disabled = true;
-  if (state$c.flushTimer !== undefined) {
-    clearTimeout(state$c.flushTimer);
-    state$c.flushTimer = undefined;
+  if (name.endsWith('Worker') || name.endsWith('worker')) {
+    return name.toLowerCase();
   }
-  state$c.batches.clear();
-  state$c.pendingRecordCount = 0;
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(`IPC tracing disabled: ${message}`);
-  void Promise.resolve(state$c.writeStderr(`IPC tracing disabled: ${message}\n`)).catch(() => {});
+  return `${name} worker`;
 };
-const getOptions = async () => {
-  state$c.optionsPromise ||= Promise.resolve(state$c.getArgv()).then(argv => {
-    const options = parseTraceIpc(argv);
-    if (options.error) {
-      reportError(new Error(options.error));
+
+const tryToGetActualErrorMessage = async ({
+  url,
+  name
+}) => {
+  const displayName = getWorkerDisplayName(name);
+  try {
+    await import(url);
+    return `Failed to start ${displayName}: Unknown Error`;
+  } catch (error) {
+    if (error && error instanceof Error && error.message.startsWith('Failed to fetch dynamically imported module')) {
+      try {
+        const response = await fetch(url);
+        switch (response.status) {
+          case NotFound:
+            return `Failed to start ${displayName}: Not found (404)`;
+          default:
+            return `Failed to start ${displayName}: Unknown Network Error`;
+        }
+      } catch {
+        return `Failed to start ${displayName}: Unknown Network Error`;
+      }
     }
-    return options;
-  }).catch(error => {
-    reportError(error);
-    return {
-      error: '',
-      selectors: new Set()
-    };
-  });
-  return state$c.optionsPromise;
+    return `Failed to start ${displayName}: ${error}`;
+  }
 };
-const getWorkerId = (traceId, name, runtimeId) => {
-  if (traceId) {
-    return traceId;
+
+const Module = 'module';
+
+const create$12 = async ({
+  url,
+  name
+}) => {
+  const worker = new Worker(url, {
+    type: Module,
+    name
+  });
+  const {
+    type,
+    event
+  } = await getFirstWorkerEvent(worker);
+  switch (type) {
+    case Message:
+      if (event.data !== 'ready') {
+        throw new IpcError('unexpected first message from worker');
+      }
+      break;
+    case Error$2:
+      const actualErrorMessage = await tryToGetActualErrorMessage({
+        url,
+        name
+      });
+      throw new Error(actualErrorMessage);
   }
-  const suffix = name ? `-${name}` : '';
-  return `runtime-${runtimeId}${suffix}`;
+  return worker;
 };
-const writeBatches = batches => {
-  state$c.writeChain = state$c.writeChain.then(async () => {
-    for (const [workerId, records] of batches) {
-      await state$c.write(workerId, records);
+const getMessage$1 = event => {};
+const wrap$4 = worker => {
+  return {
+    worker,
+    /**
+     * @type {any}
+     */
+    listener: undefined,
+    get onmessage() {
+      return this.listener;
+    },
+    set onmessage(listener) {
+      this.listener = listener;
+      const wrappedListener = event => {
+        const message = getMessage$1();
+        const syntheticEvent = {
+          data: message,
+          target: this
+        };
+        listener(syntheticEvent);
+      };
+      this.worker.onmessage = wrappedListener;
+    },
+    send(message) {
+      this.worker.postMessage(message);
+    },
+    sendAndTransfer(message) {
+      const transfer = getFirstWorkerEvent(message);
+      this.worker.postMessage(message, transfer);
     }
-  }).catch(reportError);
+  };
 };
-const flush = async () => {
-  if (state$c.flushTimer !== undefined) {
-    clearTimeout(state$c.flushTimer);
-    state$c.flushTimer = undefined;
-  }
-  if (state$c.pendingRecordCount === 0) {
-    await state$c.writeChain;
-    return;
-  }
-  const batches = state$c.batches;
-  state$c.batches = new Map();
-  state$c.pendingRecordCount = 0;
-  writeBatches(batches);
-  await state$c.writeChain;
+
+const IpcParentWithModuleWorker = {
+  __proto__: null,
+  create: create$12,
+  wrap: wrap$4
 };
-const queueRecord = (workerId, record) => {
-  if (state$c.disabled) {
-    return;
-  }
-  let records = state$c.batches.get(workerId);
-  if (!records) {
-    records = [];
-    state$c.batches.set(workerId, records);
-  }
-  records.push(record);
-  state$c.pendingRecordCount++;
-  if (state$c.pendingRecordCount >= flushRecordCount) {
-    void flush();
-    return;
-  }
-  state$c.flushTimer ||= state$c.setTimeout(() => {
-    state$c.flushTimer = undefined;
-    void flush();
-  }, flushDelay);
+
+const create$11 = async ({
+  url
+}) => {
+  const referencePort = await new Promise(resolve => {
+    globalThis.acceptReferencePort = resolve;
+    import(url);
+  });
+  delete globalThis.acceptReferencePort;
+  return referencePort;
 };
-const getData$1 = event => {
-  if (typeof MessageEvent !== 'undefined' && event instanceof MessageEvent) {
-    return event.data;
-  }
-  return event?.data ?? event;
+const getMessage = message => {
+  return message;
 };
-const createForwarder = (source, target, workerId, connectionId, direction, sequence) => {
-  source.onmessage = event => {
-    const message = getData$1(event);
-    const monotonicTime = state$c.now();
-    const startTime = monotonicTime;
-    let serializedMessage;
-    try {
-      serializedMessage = state$c.serialize(message);
-    } catch (error) {
-      serializedMessage = {
-        $type: 'SerializationError',
-        message: error instanceof Error ? error.message : String(error)
+const wrap$3 = referencePort => {
+  return {
+    referencePort,
+    /**
+     * @type {any}
+     */
+    listener: undefined,
+    get onmessage() {
+      return this.listener;
+    },
+    set onmessage(listener) {
+      this.listener = listener;
+      const wrappedListener = event => {
+        const message = getMessage(event);
+        const syntheticEvent = {
+          data: message,
+          target: this
+        };
+        listener(syntheticEvent);
       };
+      this.referencePort.onmessage = wrappedListener;
+    },
+    send(message) {
+      this.referencePort.postMessage(message);
     }
-    const serializationDuration = state$c.now() - startTime;
-    const transferables = state$c.getTransferrables(message);
-    target.postMessage(message, transferables);
-    queueRecord(workerId, {
-      connectionId,
-      direction,
-      message: serializedMessage,
-      monotonicTime,
-      sequence: sequence.value++,
-      serializationDuration,
-      version: 1,
-      wallTime: state$c.wallTime(),
-      workerId
-    });
   };
-  source.start?.();
 };
-const maybeCreateProxy = async ({
-  id,
-  name = '',
-  port,
-  traceId = ''
-}) => {
-  if (!port || state$c.disabled) {
-    return port;
-  }
-  const options = await getOptions();
-  if (state$c.disabled || !shouldTrace(options.selectors, traceId)) {
-    return port;
-  }
-  const workerId = getWorkerId(traceId, name, id);
-  const connectionId = `${state$c.timeOrigin()}-${state$c.connectionId++}`;
-  try {
-    const {
-      port1: proxyPort,
-      port2: workerPort
-    } = new MessageChannel();
-    const sequence = {
-      value: 1
-    };
-    createForwarder(port, proxyPort, workerId, connectionId, 'parent-to-worker', sequence);
-    createForwarder(proxyPort, port, workerId, connectionId, 'worker-to-parent', sequence);
-    return workerPort;
-  } catch (error) {
-    reportError(error);
-    return port;
-  }
+
+const IpcParentWithReferencePort = {
+  __proto__: null,
+  create: create$11,
+  wrap: wrap$3
 };
 
 /** @param {any} options */
@@ -11038,7 +11038,7 @@ const wrap = port => {
     set onmessage(listener) {
       this.listener = listener;
       const wrappedListener = event => {
-        const data = getData$2(event);
+        const data = getData$1(event);
         const syntheticEvent = {
           data,
           target: this
@@ -12991,7 +12991,7 @@ const addWebExtension = async path => {
     }
   }
   manifest.status = Resolved;
-  state$g.webExtensions.push(manifest);
+  state$f.webExtensions.push(manifest);
   if (manifest.languages) {
     // TODO handle case when languages is not of type array
     await addLanguages(manifest.languages);
@@ -19380,6 +19380,7 @@ const renderMainAreaPending$1 = async uid => {
     return;
   }
   const commands = await invoke$A('MainArea.render2', uid, diffResult);
+  updateDynamicFocusContext(commands);
   if (commands.length === 0) {
     return;
   }
@@ -25055,7 +25056,7 @@ const ViewletKeyBindings_ipc = {
 
 const Deb = 'Deb';
 
-const commit = 'b9ff48c';
+const commit = '74b2f22';
 
 const getAutoUpdateType = () => {
   return invoke$G('AutoUpdater.getAutoUpdateType');