@lvce-editor/static-server 0.101.15 → 0.102.0

package/static/{0ae7736 → dbe3eca}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -95,7 +95,7 @@ const getAssetDir$2 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/0ae7736';
+    return '/dbe3eca';
   }
 };
 const assetDir = getAssetDir$2();
@@ -559,7 +559,7 @@ class VError extends Error {
   }
 }
 
-const state$E = {
+const state$F = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -582,20 +582,20 @@ const initializeModule = module => {
 };
 const loadModule$4 = async moduleId => {
   try {
-    const module = await state$E.load(moduleId);
+    const module = await state$F.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`);
   }
 };
 const getOrLoadModule = moduleId => {
-  if (!state$E.pendingModules[moduleId]) {
-    state$E.pendingModules[moduleId] = loadModule$4(moduleId);
+  if (!state$F.pendingModules[moduleId]) {
+    state$F.pendingModules[moduleId] = loadModule$4(moduleId);
   }
-  return state$E.pendingModules[moduleId];
+  return state$F.pendingModules[moduleId];
 };
 const loadCommand = async command => {
-  if (command in state$E.commands) {
+  if (command in state$F.commands) {
     return;
   }
   await getOrLoadModule(getModuleId$3(command));
@@ -604,12 +604,12 @@ const register$2 = (commandId, listener) => {
   if (commandId.split('.').length >= 3) {
     debugger;
   }
-  state$E.commands[commandId] = listener;
+  state$F.commands[commandId] = listener;
 };
 const hasThrown = new Set();
 const execute$4 = (command, ...args) => {
-  if (command in state$E.commands) {
-    const fn = state$E.commands[command];
+  if (command in state$F.commands) {
+    const fn = state$F.commands[command];
     if (typeof fn !== 'function') {
       throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
     }
@@ -618,7 +618,7 @@ const execute$4 = (command, ...args) => {
   return loadCommand(command)
   // TODO can skip then block in prod (only to prevent endless loop in dev)
   .then(() => {
-    if (!(command in state$E.commands)) {
+    if (!(command in state$F.commands)) {
       if (hasThrown.has(command)) {
         return;
       }
@@ -629,20 +629,20 @@ const execute$4 = (command, ...args) => {
   });
 };
 const setLoad = load => {
-  state$E.load = load;
+  state$F.load = load;
 };
 
-const state$D = {
+const state$E = {
   pending: Object.create(null)
 };
 const get$j = id => {
-  return state$D.pending[id];
+  return state$E.pending[id];
 };
 const has$2 = id => {
-  return id in state$D.pending;
+  return id in state$E.pending;
 };
 const set$i = (id, value) => {
-  state$D.pending[id] = value;
+  state$E.pending[id] = value;
 };
 
 const NotFound = 404;
@@ -703,7 +703,7 @@ const isTransferrable$1 = value => {
   }
   return false;
 };
-const walkValue$1 = (value, transferrables, isTransferrable) => {
+const walkValue$2 = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
   }
@@ -713,20 +713,20 @@ const walkValue$1 = (value, transferrables, isTransferrable) => {
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      walkValue$1(item, transferrables, isTransferrable);
+      walkValue$2(item, transferrables, isTransferrable);
     }
     return;
   }
   if (typeof value === 'object') {
     for (const property of Object.values(value)) {
-      walkValue$1(property, transferrables, isTransferrable);
+      walkValue$2(property, transferrables, isTransferrable);
     }
     return;
   }
 };
 const getTransferrables$1 = value => {
   const transferrables = [];
-  walkValue$1(value, transferrables, isTransferrable$1);
+  walkValue$2(value, transferrables, isTransferrable$1);
   return transferrables;
 };
 const attachEvents = that => {
@@ -750,7 +750,7 @@ class Ipc extends EventTarget {
   }
 }
 const readyMessage = 'ready';
-const getData$2 = event => {
+const getData$2$1 = event => {
   return event.data;
 };
 const listen$7 = () => {
@@ -765,7 +765,7 @@ const signal$8 = global => {
 };
 class IpcChildWithModuleWorker extends Ipc {
   getData(event) {
-    return getData$2(event);
+    return getData$2$1(event);
   }
   send(message) {
     // @ts-ignore
@@ -1261,17 +1261,17 @@ const WebWorkerRpcClient2 = {
 
 const commandMapRef = {};
 
-const state$C = {
+const state$D = {
   isTest: false
 };
 const isTest = () => {
-  return state$C.isTest;
+  return state$D.isTest;
 };
 
 const kDispose$1 = 'Viewlet.dispose';
 const kSetCss$1 = 'Viewlet.setCss';
 const kSetPatches$1 = 'Viewlet.setPatches';
-const state$B = {
+const state$C = {
   /** @type {Map<string | number, string>} */
   cssTexts: new Map()
 };
@@ -1281,11 +1281,11 @@ const normalizeSetCss = command => {
   if (typeof id !== 'string' && typeof id !== 'number' || typeof newText !== 'string') {
     return command;
   }
-  const oldText = state$B.cssTexts.get(id);
+  const oldText = state$C.cssTexts.get(id);
   if (oldText === newText) {
     return undefined;
   }
-  state$B.cssTexts.set(id, newText);
+  state$C.cssTexts.set(id, newText);
   return command;
 };
 const normalizeCommand = command => {
@@ -1299,7 +1299,7 @@ const normalizeCommand = command => {
     return normalizeSetCss(command);
   }
   if (command[0] === kDispose$1) {
-    state$B.cssTexts.delete(command[1]);
+    state$C.cssTexts.delete(command[1]);
   }
   return command;
 };
@@ -1314,13 +1314,13 @@ const normalizeCommands = commands => {
   return normalized;
 };
 const getCssText = id => {
-  return state$B.cssTexts.get(id);
+  return state$C.cssTexts.get(id);
 };
 const setCssText = (id, text) => {
-  state$B.cssTexts.set(id, text);
+  state$C.cssTexts.set(id, text);
 };
 const reset$3 = () => {
-  state$B.cssTexts.clear();
+  state$C.cssTexts.clear();
 };
 
 const requestAnimationFrame = fn => {
@@ -1337,7 +1337,7 @@ const kSendMultiple$1 = 'Viewlet.sendMultiple';
 const kSetCss = 'Viewlet.setCss';
 const kSetPatches = 'Viewlet.setPatches';
 const minimumFrameDuration = 16;
-const state$A = {
+const state$B = {
   frameCount: 0,
   lastFrameTime: Number.NEGATIVE_INFINITY,
   /** @type {{commands: any[], promise: Promise<any>} | undefined} */
@@ -1347,8 +1347,8 @@ const state$A = {
   tail: Promise.resolve()
 };
 const enqueue = operation => {
-  const promise = state$A.tail.then(operation);
-  state$A.tail = promise.catch(() => {});
+  const promise = state$B.tail.then(operation);
+  state$B.tail = promise.catch(() => {});
   return promise;
 };
 const waitForEligibleFrame = () => {
@@ -1357,7 +1357,7 @@ const waitForEligibleFrame = () => {
   }
   return new Promise(resolve => {
     const handleFrame = timestamp => {
-      if (timestamp - state$A.lastFrameTime < minimumFrameDuration) {
+      if (timestamp - state$B.lastFrameTime < minimumFrameDuration) {
         requestAnimationFrame(handleFrame);
         return;
       }
@@ -1368,7 +1368,7 @@ const waitForEligibleFrame = () => {
 };
 const invokeWithCacheRecovery = async (method, ...params) => {
   try {
-    return await state$A.rpc.invoke(method, ...params);
+    return await state$B.rpc.invoke(method, ...params);
   } catch (error) {
     reset$3();
     throw error;
@@ -1376,22 +1376,22 @@ const invokeWithCacheRecovery = async (method, ...params) => {
 };
 const runFrame = async frame => {
   const timestamp = await waitForEligibleFrame();
-  if (state$A.pendingFrame === frame) {
-    state$A.pendingFrame = undefined;
+  if (state$B.pendingFrame === frame) {
+    state$B.pendingFrame = undefined;
   }
   const commands = normalizeCommands(frame.commands);
   if (commands.length === 0) {
     return;
   }
-  state$A.frameCount++;
+  state$B.frameCount++;
   try {
     return await invokeWithCacheRecovery(kSendMultiple$1, commands);
   } finally {
-    state$A.lastFrameTime = Math.max(timestamp, now());
+    state$B.lastFrameTime = Math.max(timestamp, now());
   }
 };
 const sealPendingFrame = () => {
-  state$A.pendingFrame = undefined;
+  state$B.pendingFrame = undefined;
 };
 const invokeDirectRendererCommand = async (method, params) => {
   const commands = normalizeCommands([[method, ...params]]);
@@ -1410,23 +1410,23 @@ const invokeCssStyleSheet = async (id, text) => {
 };
 const reset$2 = rpc => {
   reset$3();
-  state$A.frameCount = 0;
-  state$A.lastFrameTime = Number.NEGATIVE_INFINITY;
-  state$A.pendingFrame = undefined;
-  state$A.rpc = rpc;
-  state$A.tail = Promise.resolve();
+  state$B.frameCount = 0;
+  state$B.lastFrameTime = Number.NEGATIVE_INFINITY;
+  state$B.pendingFrame = undefined;
+  state$B.rpc = rpc;
+  state$B.tail = Promise.resolve();
 };
 const sendMultiple = commands => {
-  if (state$A.pendingFrame) {
-    state$A.pendingFrame.commands.push(...commands);
-    return state$A.pendingFrame.promise;
+  if (state$B.pendingFrame) {
+    state$B.pendingFrame.commands.push(...commands);
+    return state$B.pendingFrame.promise;
   }
   /** @type {{commands: any[], promise: Promise<any>}} */
   const frame = {
     commands: [...commands],
     promise: Promise.resolve()
   };
-  state$A.pendingFrame = frame;
+  state$B.pendingFrame = frame;
   frame.promise = enqueue(() => runFrame(frame));
   return frame.promise;
 };
@@ -1449,7 +1449,7 @@ const invokeAndTransfer$F = (method, ...params) => {
   sealPendingFrame();
   return enqueue(async () => {
     try {
-      return await state$A.rpc.invokeAndTransfer(method, ...params);
+      return await state$B.rpc.invokeAndTransfer(method, ...params);
     } catch (error) {
       reset$3();
       throw error;
@@ -1458,7 +1458,7 @@ const invokeAndTransfer$F = (method, ...params) => {
 };
 
 // @ts-ignore
-const state$z = {
+const state$A = {
   pendingMessages: [],
   /**
    * @type {any}
@@ -1474,9 +1474,9 @@ const getRpc$1 = async () => {
   return rpc;
 };
 const listen$1 = async () => {
-  console.assert(state$z.pendingMessages.length === 0);
+  console.assert(state$A.pendingMessages.length === 0);
   const rpc = await getRpc$1();
-  state$z.rpc = rpc;
+  state$A.rpc = rpc;
   reset$2(rpc);
 };
 const invoke$J = (method, ...params) => {
@@ -1883,18 +1883,18 @@ const create$1b = async ({
 
 const isProduction = true;
 
-const state$y = Object.create(null);
+const state$z = Object.create(null);
 const setAll = preferences => {
-  Object.assign(state$y, preferences);
+  Object.assign(state$z, preferences);
 };
 const get$g = key => {
-  return state$y[key];
+  return state$z[key];
 };
 const getAll$3 = () => {
-  return state$y;
+  return state$z;
 };
 const set$g = (key, value) => {
-  state$y[key] = value;
+  state$z[key] = value;
 };
 
 const getConfiguredWorkerUrl$2 = () => {
@@ -1924,7 +1924,7 @@ const {
   invokeAndTransfer: invokeAndTransfer$C
 } = getOrCreateWorker(launchErrorWorker);
 
-const serializeError = error => {
+const serializeError$1 = error => {
   if (!error) {
     return error;
   }
@@ -1941,7 +1941,7 @@ const serializeError = error => {
 };
 const prepare = async error => {
   try {
-    const serialized = serializeError(error);
+    const serialized = serializeError$1(error);
     const prepared = await invoke$H('Errors.prepare', serialized);
     return prepared;
   } catch {
@@ -2212,24 +2212,24 @@ const canBeRestored$5 = async uri => {
 // 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
 
 // TODO use normal event target
-const state$x = {
+const state$y = {
   listenerMap: Object.create(null)
 };
 const emitEvent = async (event, ...args) => {
-  const listeners = state$x.listenerMap[event] || [];
+  const listeners = state$y.listenerMap[event] || [];
   for (const listener of listeners) {
     await listener(...args);
   }
 };
 const addListener = (event, fn, options = {}) => {
-  state$x.listenerMap[event] ||= [];
-  if (state$x.listenerMap[event].includes(fn)) {
+  state$y.listenerMap[event] ||= [];
+  if (state$y.listenerMap[event].includes(fn)) {
     return;
   }
   if (options.prepend) {
-    state$x.listenerMap[event].unshift(fn);
+    state$y.listenerMap[event].unshift(fn);
   } else {
-    state$x.listenerMap[event].push(fn);
+    state$y.listenerMap[event].push(fn);
   }
 };
 
@@ -2255,7 +2255,7 @@ const openUri$1 = async (path, focus = true, props = {}) => {
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
 
-const state$w = {
+const state$x = {
   /**
    * @type {any}
    */
@@ -2266,14 +2266,14 @@ const state$w = {
 const invoke$G = async (method, ...params) => {
   const {
     ipc
-  } = state$w;
+  } = state$x;
   const result = await invoke$I(ipc, method, ...params);
   return result;
 };
 const invokeAndTransfer$B = async (method, ...params) => {
   const {
     ipc
-  } = state$w;
+  } = state$x;
   const result = await invokeAndTransfer$D(ipc, method, ...params);
   return result;
 };
@@ -2459,7 +2459,7 @@ const setThemeColor = async themeColor => {
 // TODO by default color theme should come from local storage, session storage, cache storage, indexeddb or blob url -> fast initial load
 // actual color theme can be computed after workbench has loaded (most times will be the same and doesn't need to be computed)
 
-const state$v = {
+const state$w = {
   watchedTheme: ''
 };
 const FALLBACK_COLOR_THEME_ID = 'slime';
@@ -2470,7 +2470,7 @@ const FALLBACK_COLOR_THEME_ID = 'slime';
 const applyColorTheme = async colorThemeId => {
   try {
     string(colorThemeId);
-    state$v.colorTheme = colorThemeId;
+    state$w.colorTheme = colorThemeId;
     const colorThemeCss = await getColorThemeCss(colorThemeId);
     if (!colorThemeCss) {
       return new Error(`Color theme is empty`);
@@ -2499,10 +2499,10 @@ const setColorTheme = async colorThemeId => {
   return undefined;
 };
 const watch$2 = async id => {
-  if (state$v.watchedTheme === id) {
+  if (state$w.watchedTheme === id) {
     return;
   }
-  state$v.watchedTheme = id;
+  state$w.watchedTheme = id;
   await invoke$G('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
@@ -2543,22 +2543,22 @@ const hydrate$b = async () => {
   await applyPreferredColorTheme();
 };
 
-const state$u = {
+const state$v = {
   href: ''
 };
 
 const initialize$2 = href => {
-  state$u.href = href;
+  state$v.href = href;
 };
 const getHref$1 = async () => {
   const href = await invoke$J(/* Location.getHref */'Location.getHref');
-  state$u.href = href;
+  state$v.href = href;
   return href;
 };
 const setPathName = async pathName => {
   const {
     href
-  } = state$u;
+  } = state$v;
   if (!href) {
     return invoke$J(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
   }
@@ -2568,7 +2568,7 @@ const setPathName = async pathName => {
     return;
   }
   await invoke$J(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
-  state$u.href = resolvedUrl.href;
+  state$v.href = resolvedUrl.href;
 };
 const hydrate$a = () => {
   return invoke$J(/* Location.hydrate */'Location.hydrate');
@@ -2883,7 +2883,7 @@ const ViewletModuleId = {
 // to allow having multiple instances of the same
 // type. for example multiple editors
 
-const state$t = {
+const state$u = {
   instances: Object.create(null),
   /**
    * Track focused instance by module ID/type
@@ -2917,10 +2917,10 @@ const set$e = (key, value) => {
   object(value.factory);
   object(value.state);
   object(value.renderedState);
-  state$t.instances[key] = value;
+  state$u.instances[key] = value;
 };
 const getByUid = uid => {
-  for (const value of Object.values(state$t.instances)) {
+  for (const value of Object.values(state$u.instances)) {
     if (value.renderedState.uid === uid) {
       return value;
     }
@@ -2928,7 +2928,7 @@ const getByUid = uid => {
   return undefined;
 };
 const getInstance = key => {
-  const fast = state$t.instances[key];
+  const fast = state$u.instances[key];
   if (fast) {
     return fast;
   }
@@ -2940,7 +2940,7 @@ const getInstance = key => {
   }
   const normalizedKey = normalizeModuleId(key);
   if (normalizedKey !== key) {
-    const normalizedFast = state$t.instances[normalizedKey];
+    const normalizedFast = state$u.instances[normalizedKey];
     if (normalizedFast) {
       return normalizedFast;
     }
@@ -2949,7 +2949,7 @@ const getInstance = key => {
   if (focusedInstance) {
     return focusedInstance;
   }
-  for (const value of Object.values(state$t.instances)) {
+  for (const value of Object.values(state$u.instances)) {
     if (value.moduleId === key || value.moduleId === normalizedKey) {
       return value;
     }
@@ -2957,17 +2957,17 @@ const getInstance = key => {
   return undefined;
 };
 const hasInstance = key => {
-  return key in state$t.instances;
+  return key in state$u.instances;
 };
 const remove$a = key => {
-  const instance = state$t.instances[key];
+  const instance = state$u.instances[key];
   if (instance) {
     clearFocusedInstanceByType(instance.renderedState?.uid, instance.moduleId);
   }
-  delete state$t.instances[key];
+  delete state$u.instances[key];
 };
 const getAllInstances = () => {
-  return state$t.instances;
+  return state$u.instances;
 };
 const getState$1 = key => {
   const instance = getInstance(key);
@@ -3009,7 +3009,7 @@ const setFocusedInstanceByType = (uid, moduleId) => {
   if (typeof moduleId !== 'string') {
     return;
   }
-  state$t.focusedInstanceByType[moduleId] = uid;
+  state$u.focusedInstanceByType[moduleId] = uid;
 };
 
 /**
@@ -3018,7 +3018,7 @@ const setFocusedInstanceByType = (uid, moduleId) => {
  * @returns {number|undefined} The UID of the focused instance, or undefined
  */
 const getFocusedInstanceByType = moduleId => {
-  return state$t.focusedInstanceByType[moduleId];
+  return state$u.focusedInstanceByType[moduleId];
 };
 
 /**
@@ -3027,8 +3027,8 @@ const getFocusedInstanceByType = moduleId => {
  * @param {string} moduleId - The module ID/type
  */
 const clearFocusedInstanceByType = (uid, moduleId) => {
-  if (state$t.focusedInstanceByType[moduleId] === uid) {
-    delete state$t.focusedInstanceByType[moduleId];
+  if (state$u.focusedInstanceByType[moduleId] === uid) {
+    delete state$u.focusedInstanceByType[moduleId];
   }
 };
 
@@ -3052,14 +3052,14 @@ const cleanUpWorkersAfterLoad = async () => {
   await Promise.all(promises);
 };
 
-const state$s = {
+const state$t = {
   id: 0
 };
 const create$1a = () => {
-  return ++state$s.id;
+  return ++state$t.id;
 };
 
-const state$r = {
+const state$s = {
   ipc: undefined
 };
 
@@ -3068,10 +3068,10 @@ const state$r = {
  * @returns {any}
  */
 const get$d = () => {
-  return state$r.ipc;
+  return state$s.ipc;
 };
 const set$d = ipc => {
-  state$r.ipc = ipc;
+  state$s.ipc = ipc;
 };
 
 const map$3 = Object.create(null);
@@ -3124,14 +3124,14 @@ const watchFile = async (rpcId, callBackCommandId, uri) => {
   return map$3[id];
 };
 
-const state$q = {
+const state$r = {
   id: 0
 };
 const set$c = value => {
-  state$q.id = value;
+  state$r.id = value;
 };
 const get$c = () => {
-  return state$q.id;
+  return state$r.id;
 };
 
 // TODO cache window id
@@ -3347,18 +3347,18 @@ const createTestWorker = async () => {
   await invoke$I(ipc, 'RendererProcess.initialize');
   return ipc;
 };
-const state$p = {
+const state$q = {
   launchPromise: undefined
 };
 const getOrCreateLaunchPromise = () => {
   const {
     launchPromise
-  } = state$p;
+  } = state$q;
   if (launchPromise) {
     return launchPromise;
   }
   const promise = createTestWorker();
-  state$p.launchPromise = promise;
+  state$q.launchPromise = promise;
   return promise;
 };
 const shouldPreloadTestWorker = (href, isPromptMode) => {
@@ -3382,9 +3382,9 @@ const launchTestWorker = async () => {
   } catch (error) {
     const {
       launchPromise
-    } = state$p;
+    } = state$q;
     if (launchPromise === promise) {
-      state$p.launchPromise = undefined;
+      state$q.launchPromise = undefined;
     }
     throw error;
   }
@@ -3572,7 +3572,7 @@ const error = (...args) => {
   console.error(...args);
 };
 
-const state$o = {
+const state$p = {
   keyBindingSets: Object.create(null),
   keyBindingSetCounts: Object.create(null),
   /**
@@ -3585,7 +3585,7 @@ const state$o = {
   matchingKeyBindings: []
 };
 const getKeyBinding = identifier => {
-  for (const keyBinding of state$o.matchingKeyBindings) {
+  for (const keyBinding of state$p.matchingKeyBindings) {
     if (keyBinding.key === identifier) {
       return keyBinding;
     }
@@ -3611,39 +3611,39 @@ const update = () => {
   const {
     keyBindingIdentifiers: oldKeyBindingIdentifiers,
     keyBindingSets
-  } = state$o;
+  } = state$p;
   const matchingKeyBindings = getMatchingKeyBindings(keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
-  state$o.matchingKeyBindings = matchingKeyBindings;
+  state$p.matchingKeyBindings = matchingKeyBindings;
   if (isEqualUint32Array(oldKeyBindingIdentifiers, keyBindingIdentifiers)) {
     return;
   }
   invoke$J('KeyBindings.setIdentifiers', keyBindingIdentifiers);
-  state$o.keyBindingIdentifiers = keyBindingIdentifiers;
+  state$p.keyBindingIdentifiers = keyBindingIdentifiers;
 };
 const addKeyBindings = (id, keyBindings) => {
   string(id);
   array(keyBindings);
-  if (id in state$o.keyBindingSets) {
-    state$o.keyBindingSetCounts[id]++;
+  if (id in state$p.keyBindingSets) {
+    state$p.keyBindingSetCounts[id]++;
     return;
   }
-  state$o.keyBindingSets[id] = keyBindings;
-  state$o.keyBindingSetCounts[id] = 1;
+  state$p.keyBindingSets[id] = keyBindings;
+  state$p.keyBindingSetCounts[id] = 1;
   update();
 };
 const setKeyBindings = (id, keyBindings) => {
   string(id);
   array(keyBindings);
-  state$o.keyBindingSets[id] = keyBindings;
-  state$o.keyBindingSetCounts[id] = 1;
+  state$p.keyBindingSets[id] = keyBindings;
+  state$p.keyBindingSetCounts[id] = 1;
   update();
 };
 const removeKeyBindings = id => {
   const {
     keyBindingSets,
     keyBindingSetCounts
-  } = state$o;
+  } = state$p;
   if (!(id in keyBindingSets)) {
     warn(`cannot remove keybindings that are not registered: ${id}`);
     return;
@@ -3696,14 +3696,14 @@ const handleViewContextChange$1 = (uid, viewId, context) => {
   update();
 };
 
-const state$n = {
+const state$o = {
   currentFocus: 0
 };
 const get$a = () => {
-  return state$n.currentFocus;
+  return state$o.currentFocus;
 };
 const set$a = value => {
-  state$n.currentFocus = value;
+  state$o.currentFocus = value;
 };
 
 /**
@@ -4523,7 +4523,7 @@ const declareWidget = (parentUid, uid, commands) => {
   return reconcile([...commands, [setWidgetsCommand, parentUid, revision, [uid]]]);
 };
 
-const state$m = {
+const state$n = {
   idMap: Object.create(null),
   idMapByModuleId: Object.create(null)
 };
@@ -4531,7 +4531,7 @@ const register = (id, module, moduleId) => {
   const {
     idMap,
     idMapByModuleId
-  } = state$m;
+  } = state$n;
   idMap[id] = module;
   if (moduleId) {
     idMapByModuleId[id] ||= Object.create(null);
@@ -4541,13 +4541,13 @@ const register = (id, module, moduleId) => {
 const get$9 = id => {
   const {
     idMap
-  } = state$m;
+  } = state$n;
   return idMap[id];
 };
 const getForModuleId = (id, moduleId) => {
   const {
     idMapByModuleId
-  } = state$m;
+  } = state$n;
   return idMapByModuleId[id]?.[moduleId] || get$9(id);
 };
 
@@ -4722,7 +4722,7 @@ const getResolveRootFromSessionStorage = async () => {
 const getResolvedRootFromRendererProcess = async href => {
   const url = new URL(href);
   if (href.includes('tests/')) {
-    state$C.isTest = true;
+    state$D.isTest = true;
     return {
       path: href,
       homeDir: '',
@@ -4779,7 +4779,7 @@ const set$9 = title => {
   return invoke$J('WindowTitle.set', title);
 };
 
-const state$l = {
+const state$m = {
   workspacePath: '',
   homeDir: '',
   pathSeparator: '',
@@ -4797,14 +4797,14 @@ const setPath = async path => {
   // TODO not in electron
   const pathSeparator = await getPathSeparator$9(path);
   await updateWindowTitle(path, pathSeparator);
-  if (path !== state$l.workspacePath) {
-    await emitEvent('workspace.beforeChange', state$l.workspacePath, path);
+  if (path !== state$m.workspacePath) {
+    await emitEvent('workspace.beforeChange', state$m.workspacePath, path);
   }
   // @ts-ignore
-  state$l.workspacePath = path;
+  state$m.workspacePath = path;
   // @ts-ignore
-  state$l.workspaceUri = path;
-  state$l.pathSeparator = pathSeparator;
+  state$m.workspaceUri = path;
+  state$m.pathSeparator = pathSeparator;
   await onWorkspaceChange();
 };
 const setUri = async (uri, providedPathSeparator) => {
@@ -4812,19 +4812,19 @@ const setUri = async (uri, providedPathSeparator) => {
   const path = protocol === 'file' ? decodeURIComponent(uri.slice('file://'.length)) : uri;
   const pathSeparator = providedPathSeparator ?? (await getPathSeparator$9(uri));
   await updateWindowTitle(path, pathSeparator);
-  if (path !== state$l.workspacePath) {
-    await emitEvent('workspace.beforeChange', state$l.workspacePath, path);
+  if (path !== state$m.workspacePath) {
+    await emitEvent('workspace.beforeChange', state$m.workspacePath, path);
   }
-  state$l.workspacePath = path;
-  state$l.workspaceUri = uri;
-  state$l.pathSeparator = pathSeparator;
+  state$m.workspacePath = path;
+  state$m.workspaceUri = uri;
+  state$m.pathSeparator = pathSeparator;
   await onWorkspaceChange();
 };
 const getPath$4 = () => {
-  return state$l.workspacePath;
+  return state$m.workspacePath;
 };
 const getUri$1 = () => {
-  return state$l.workspaceUri;
+  return state$m.workspaceUri;
 };
 const close$3 = () => {
   return setPath('');
@@ -4851,46 +4851,46 @@ const getPathName$1 = workspacePath => {
 };
 const onWorkspaceChange = async () => {
   if (getPlatform$2() === Web$1 || getPlatform$2() === Remote) {
-    const pathName = getPathName$1(state$l.workspacePath);
+    const pathName = getPathName$1(state$m.workspacePath);
     await setPathName(pathName);
   }
-  await emitEvent('workspace.change', state$l.workspacePath);
+  await emitEvent('workspace.change', state$m.workspacePath);
 };
 const hydrate$7 = async ({
   href
 }) => {
-  if (state$l.workspacePath) {
+  if (state$m.workspacePath) {
     return;
   }
   const resolvedRoot = await getResolvedRoot(href);
-  if (state$l.workspacePath) {
+  if (state$m.workspacePath) {
     return;
   }
   // TODO why is this if statement here?
-  if (state$l.homeDir !== resolvedRoot.homeDir) {
-    state$l.homeDir = resolvedRoot.homeDir;
+  if (state$m.homeDir !== resolvedRoot.homeDir) {
+    state$m.homeDir = resolvedRoot.homeDir;
   }
   if (!canBeRestored$5(resolvedRoot.path)) {
     return;
   }
   // TODO how to check that path from renderer process is valid?
   // TODO also need to check whether it is a folder or file
-  state$l.workspacePath = resolvedRoot.path;
-  state$l.homeDir = resolvedRoot.homeDir;
-  state$l.pathSeparator = resolvedRoot.pathSeparator;
-  state$l.workspaceUri = resolvedRoot.uri;
-  state$l.source = resolvedRoot.source;
-  if (state$l.workspaceUri && state$l.workspaceUri.startsWith('/')) {
-    state$l.workspaceUri = `file://${state$l.workspaceUri}`;
-  }
-  await updateWindowTitle(state$l.workspacePath, state$l.pathSeparator);
+  state$m.workspacePath = resolvedRoot.path;
+  state$m.homeDir = resolvedRoot.homeDir;
+  state$m.pathSeparator = resolvedRoot.pathSeparator;
+  state$m.workspaceUri = resolvedRoot.uri;
+  state$m.source = resolvedRoot.source;
+  if (state$m.workspaceUri && state$m.workspaceUri.startsWith('/')) {
+    state$m.workspaceUri = `file://${state$m.workspaceUri}`;
+  }
+  await updateWindowTitle(state$m.workspacePath, state$m.pathSeparator);
   await onWorkspaceChange();
 };
 const getWorkspaceUri = () => {
-  return state$l.workspaceUri;
+  return state$m.workspaceUri;
 };
 const getHomeDir = () => {
-  return state$l.homeDir;
+  return state$m.homeDir;
 };
 
 // TODO this should be in FileSystem module
@@ -4909,10 +4909,10 @@ const getStateToSave = async () => {
     instances: getWorkspaceScopedViewletStates(savedInstances, workspaceUri),
     mainEditors: [],
     workspace: {
-      path: state$l.workspacePath,
-      homeDir: state$l.homeDir,
-      pathSeparator: state$l.pathSeparator,
-      uri: state$l.workspaceUri
+      path: state$m.workspacePath,
+      homeDir: state$m.homeDir,
+      pathSeparator: state$m.pathSeparator,
+      uri: state$m.workspaceUri
     }
   };
 };
@@ -5085,7 +5085,7 @@ const loadModule$3 = async (id, module) => {
     await (Array.isArray(module.Css) ? loadCssStyleSheets(module.Css) : loadCssStyleSheet(module.Css));
   }
   if (module.getDynamicCss) {
-    await addDynamicCss(id, module.getDynamicCss, state$y);
+    await addDynamicCss(id, module.getDynamicCss, state$z);
   }
 };
 
@@ -5125,17 +5125,17 @@ const QuickPickWorker = {
   restart: restart$k
 };
 
-const state$k = {
+const state$l = {
   /**
    * @type {any[]}
    */
   menuEntries: []
 };
 const getAll = () => {
-  return state$k.menuEntries;
+  return state$l.menuEntries;
 };
 const add$1 = async menuEntries => {
-  state$k.menuEntries = [...state$k.menuEntries, ...menuEntries];
+  state$l.menuEntries = [...state$l.menuEntries, ...menuEntries];
   // TODO store menu entries here or in file search worker?
   // Usually don't want to start worker for the menu entries
   // But also quickpick menu entries would be better stored there
@@ -5162,7 +5162,7 @@ const loadModule$1 = async (id, module) => {
 };
 
 // @ts-nocheck
-const state$j = {
+const state$k = {
   pendingModules: Object.create(null)
 };
 const runLoadContentLaterWithErrorHandling = async (loadContentLater, viewletState) => {
@@ -5603,10 +5603,10 @@ const actuallyLoadModule = async (getModule, id) => {
   return module;
 };
 const loadModule = (getModule, id) => {
-  if (!(id in state$j.pendingModules)) {
-    state$j.pendingModules[id] = actuallyLoadModule(getModule, id);
+  if (!(id in state$k.pendingModules)) {
+    state$k.pendingModules[id] = actuallyLoadModule(getModule, id);
   }
-  return state$j.pendingModules[id];
+  return state$k.pendingModules[id];
 };
 /**
  *
@@ -6439,15 +6439,15 @@ const restoreMainFocus = async (invoke = invoke$A) => {
   }
 };
 
-const state$i = {
+const state$j = {
   isQuickPickOpen: false
 };
 const isQuickPickOpen = () => {
-  return state$i.isQuickPickOpen;
+  return state$j.isQuickPickOpen;
 };
 const closeWidgetElectronQuickPick = async (restoreFocus = true) => {
   const id = QuickPick;
-  state$i.isQuickPickOpen = false;
+  state$j.isQuickPickOpen = false;
   remove$a(id);
   await disposeBrowserViewQuickPick();
   await focus$i();
@@ -7093,14 +7093,14 @@ const getInitData = async () => {
   return rendererProcessInitData;
 };
 
-const state$h = {
+const state$i = {
   shouldLaunchMultipleWorkers: false
 };
 const setConfig = shouldLaunchMultipleWorkers => {
-  state$h.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
+  state$i.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
 };
 const getConfig = () => {
-  return state$h.shouldLaunchMultipleWorkers;
+  return state$i.shouldLaunchMultipleWorkers;
 };
 
 // based on https://github.com/babel/babel/blob/6be6e04f396f03feace4431f709564a8d842163a/packages/babel-code-frame/src/index.ts (License MIT)
@@ -7203,7 +7203,7 @@ const create$18 = (rawLines, loc, opts = {}) => {
   return frame;
 };
 
-const state$g = {
+const state$h = {
   /**
    * @type {any[]}
    */
@@ -7230,7 +7230,7 @@ const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
   return '';
 };
 const getLanguageConfigurationFromWebExtension = async languageId => {
-  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$g.webExtensions, languageId);
+  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$h.webExtensions, languageId);
   if (!languageConfigurationPath) {
     return undefined;
   }
@@ -7285,7 +7285,7 @@ const splitLines = lines => {
 
 // TODO merge all of this with extension host languages module
 
-const state$f = {
+const state$g = {
   isHydrating: false,
   fileNameMap: Object.create(null),
   extensionMap: Object.create(null),
@@ -7300,53 +7300,53 @@ const state$f = {
   hasWarned: []
 };
 const getFirstLines = () => {
-  return state$f.firstLines;
+  return state$g.firstLines;
 };
 const hasLanguageByExtension = extension => {
-  return extension in state$f.extensionMap;
+  return extension in state$g.extensionMap;
 };
 const getLanguageByExtension = extension => {
-  return state$f.extensionMap[extension];
+  return state$g.extensionMap[extension];
 };
 const hasLanguageByFileName = fileName => {
-  return fileName in state$f.fileNameMap;
+  return fileName in state$g.fileNameMap;
 };
 const getLanguageByFileName = fileName => {
-  return state$f.fileNameMap[fileName];
+  return state$g.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$g.tokenizerMap[languageId] || '';
 };
 const setHydrating = value => {
-  state$f.isHydrating = value;
+  state$g.isHydrating = value;
 };
 const setLoaded = value => {
-  state$f.loaded = true;
+  state$g.loaded = true;
 };
 const addExtension = (extension, languageId) => {
-  state$f.extensionMap[extension] = languageId;
+  state$g.extensionMap[extension] = languageId;
 };
 const addFirstLine = (regex, languageId) => {
-  state$f.firstLines.push({
+  state$g.firstLines.push({
     regex,
     languageId
   });
 };
 const hasWarned = languageId => {
-  return state$f.hasWarned.includes(languageId);
+  return state$g.hasWarned.includes(languageId);
 };
 const addWarned = languageId => {
-  return state$f.hasWarned.push(languageId);
+  return state$g.hasWarned.push(languageId);
 };
 const addFileName = (fileName, languageId) => {
-  state$f.fileNameMap[fileName] = languageId;
+  state$g.fileNameMap[fileName] = languageId;
 };
 const addTokenizer = (languageId, tokenizer) => {
-  state$f.tokenizerMap[languageId] = tokenizer;
+  state$g.tokenizerMap[languageId] = tokenizer;
 };
 const hasLoaded$1 = () => {
-  return state$f.loaded;
+  return state$g.loaded;
 };
 
 // TODO merge all of this with extension host languages module
@@ -7548,7 +7548,7 @@ const listen = method => {
 const launchSharedProcess = async () => {
   const ipc = await listen(Node);
   handleIpc(ipc);
-  state$w.ipc = ipc;
+  state$x.ipc = ipc;
 };
 
 const Zero = 0;
@@ -7568,18 +7568,18 @@ const Fourteen = 14;
 const Fifteen = 15;
 const Sixteen = 16;
 
-const state$e = {
+const state$f = {
   listenerMap: Object.create(null),
   phase: Zero
 };
 const mark$1 = event => {
-  const listeners = state$e.listenerMap[event] || [];
+  const listeners = state$f.listenerMap[event] || [];
   for (const listener of listeners) {
     listener();
   }
-  state$e.phase = event;
+  state$f.phase = event;
   if (event === Twelve) {
-    state$e.listenerMap = Object.create(null);
+    state$f.listenerMap = Object.create(null);
   }
 };
 
@@ -7883,8 +7883,8 @@ const exit$1 = code => {
   return invoke$G('Exit.exit', code);
 };
 
-const version = '0.101.15';
-const commit$1 = '0ae7736';
+const version = '0.102.0';
+const commit$1 = 'dbe3eca';
 const productNameLong = 'Lvce Editor - OSS';
 const getPid = () => {
   return invoke$G('Process.getPid');
@@ -8469,12 +8469,12 @@ const creareSessionId = () => {
   return `session-${new Date().toISOString()}`;
 };
 
-const state$d = {
+const state$e = {
   sessionId: ''
 };
 const getSessionId = () => {
-  state$d.sessionId ||= creareSessionId();
-  return state$d.sessionId;
+  state$e.sessionId ||= creareSessionId();
+  return state$e.sessionId;
 };
 
 const withResolvers = () => {
@@ -8531,7 +8531,7 @@ const addSearchParam = (href, key, value) => {
   return parsedUrl.toString();
 };
 const replayCurrentSession = async () => {
-  if (!state$d.sessionId) {
+  if (!state$e.sessionId) {
     throw new VError('session replay is disabled in settings');
   }
   // TODO
@@ -8551,7 +8551,7 @@ const getSessionContent = async () => {
 const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile']);
 const replaySession = async sessionId => {
   const events = await getSessionEvents(sessionId);
-  const originalIpc = state$z.rpc.ipc;
+  const originalIpc = state$A.rpc.ipc;
   unhandleIpc(originalIpc);
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalAddEventListsner = originalIpc.addEventListener.bind(originalIpc);
@@ -8566,33 +8566,33 @@ const replaySession = async sessionId => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$z.rpc.ipc.onmessage = originalAddEventListsner;
-          state$z.rpc.ipc.send = originalSend;
+          state$A.rpc.ipc.onmessage = originalAddEventListsner;
+          state$A.rpc.ipc.send = originalSend;
           await execute$4('ElectronWindow.close');
-          state$z.rpc.ipc.onmessage = wrappedOnMessage;
-          state$z.rpc.ipc.send = wrappedSend;
+          state$A.rpc.ipc.onmessage = wrappedOnMessage;
+          state$A.rpc.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$z.rpc.ipc.onmessage = originalAddEventListsner;
-          state$z.rpc.ipc.send = originalSend;
+          state$A.rpc.ipc.onmessage = originalAddEventListsner;
+          state$A.rpc.ipc.send = originalSend;
           await execute$4('ElectronWindow.minimize');
-          state$z.rpc.ipc.onmessage = wrappedOnMessage;
-          state$z.rpc.ipc.send = wrappedSend;
+          state$A.rpc.ipc.onmessage = wrappedOnMessage;
+          state$A.rpc.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$z.rpc.ipc.onmessage = originalAddEventListsner;
-          state$z.rpc.ipc.send = originalSend;
+          state$A.rpc.ipc.onmessage = originalAddEventListsner;
+          state$A.rpc.ipc.send = originalSend;
           await execute$4('ElectronWindow.maximize');
-          state$z.rpc.ipc.onmessage = wrappedOnMessage;
-          state$z.rpc.ipc.send = wrappedSend;
+          state$A.rpc.ipc.onmessage = wrappedOnMessage;
+          state$A.rpc.ipc.send = wrappedSend;
           break;
       }
     } else {
       throw new Error('unexpected message from renderer worker');
     }
   };
-  state$z.rpc.send = wrappedSend;
-  state$z.rpc.addEventListener('message', wrappedOnMessage);
+  state$A.rpc.send = wrappedSend;
+  state$A.rpc.addEventListener('message', wrappedOnMessage);
   const callbacks = Object.create(null);
   const invoke = event => {
     const {
@@ -8664,8 +8664,8 @@ const wrapIpc = (ipc, name, getData) => {
   return wrappedIpc;
 };
 const startRecording$1 = () => {
-  state$z.rpc.ipc = wrapIpc(state$z.rpc, 'renderer-process', event => event.data);
-  state$w.ipc = wrapIpc(state$w.ipc, 'shared-process', event => event);
+  state$A.rpc.ipc = wrapIpc(state$A.rpc, 'renderer-process', event => event.data);
+  state$x.ipc = wrapIpc(state$x.ipc, 'shared-process', event => event);
 };
 const openSession = async () => {
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */'app://session.json');
@@ -9673,7 +9673,7 @@ const main = async () => {
 };
 main();
 
-const walkValue = (value, transferrables, isTransferrable) => {
+const walkValue$1 = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
   }
@@ -9683,13 +9683,13 @@ const walkValue = (value, transferrables, isTransferrable) => {
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
+      walkValue$1(item, transferrables, isTransferrable);
     }
     return;
   }
   if (typeof value === 'object') {
     for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
+      walkValue$1(property, transferrables, isTransferrable);
     }
     return;
   }
@@ -9714,7 +9714,7 @@ const isTransferrable = value => {
 
 const getTransferrables = value => {
   const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
+  walkValue$1(value, transferrables, isTransferrable);
   return transferrables;
 };
 
@@ -9755,7 +9755,7 @@ const fixElectronParameters = value => {
   };
 };
 
-const getData$1 = event => {
+const getData$2 = event => {
   const {
     data
   } = event;
@@ -9802,7 +9802,7 @@ const wrap$7 = port => {
     set onmessage(listener) {
       this.listener = listener;
       const wrappedListener = event => {
-        const data = getData$1(event);
+        const data = getData$2(event);
         const syntheticEvent = {
           data,
           target: this
@@ -9871,7 +9871,7 @@ const wrap$6 = port => {
     set onmessage(listener) {
       this.listener = listener;
       const wrappedListener = event => {
-        const message = getData$1(event);
+        const message = getData$2(event);
         const syntheticEvent = {
           data: message,
           target: this
@@ -10233,24 +10233,362 @@ const IpcParentWithWebSocket = {
   wrap: wrap$3
 };
 
-const create$10 = async ({
-  url,
-  name,
+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;
+};
+
+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 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;
+
+/** @type {any} */
+const state$d = {
+  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$d.disabled) {
+    return;
+  }
+  state$d.disabled = true;
+  if (state$d.flushTimer !== undefined) {
+    clearTimeout(state$d.flushTimer);
+    state$d.flushTimer = undefined;
+  }
+  state$d.batches.clear();
+  state$d.pendingRecordCount = 0;
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`IPC tracing disabled: ${message}`);
+  void Promise.resolve(state$d.writeStderr(`IPC tracing disabled: ${message}\n`)).catch(() => {});
+};
+const getOptions = async () => {
+  state$d.optionsPromise ||= Promise.resolve(state$d.getArgv()).then(argv => {
+    const options = parseTraceIpc(argv);
+    if (options.error) {
+      reportError(new Error(options.error));
+    }
+    return options;
+  }).catch(error => {
+    reportError(error);
+    return {
+      error: '',
+      selectors: new Set()
+    };
+  });
+  return state$d.optionsPromise;
+};
+const getWorkerId = (traceId, name, runtimeId) => {
+  if (traceId) {
+    return traceId;
+  }
+  const suffix = name ? `-${name}` : '';
+  return `runtime-${runtimeId}${suffix}`;
+};
+const writeBatches = batches => {
+  state$d.writeChain = state$d.writeChain.then(async () => {
+    for (const [workerId, records] of batches) {
+      await state$d.write(workerId, records);
+    }
+  }).catch(reportError);
+};
+const flush = async () => {
+  if (state$d.flushTimer !== undefined) {
+    clearTimeout(state$d.flushTimer);
+    state$d.flushTimer = undefined;
+  }
+  if (state$d.pendingRecordCount === 0) {
+    await state$d.writeChain;
+    return;
+  }
+  const batches = state$d.batches;
+  state$d.batches = new Map();
+  state$d.pendingRecordCount = 0;
+  writeBatches(batches);
+  await state$d.writeChain;
+};
+const queueRecord = (workerId, record) => {
+  if (state$d.disabled) {
+    return;
+  }
+  let records = state$d.batches.get(workerId);
+  if (!records) {
+    records = [];
+    state$d.batches.set(workerId, records);
+  }
+  records.push(record);
+  state$d.pendingRecordCount++;
+  if (state$d.pendingRecordCount >= flushRecordCount) {
+    void flush();
+    return;
+  }
+  state$d.flushTimer ||= state$d.setTimeout(() => {
+    state$d.flushTimer = undefined;
+    void flush();
+  }, flushDelay);
+};
+const getData$1 = 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$1(event);
+    const monotonicTime = state$d.now();
+    const startTime = monotonicTime;
+    let serializedMessage;
+    try {
+      serializedMessage = state$d.serialize(message);
+    } catch (error) {
+      serializedMessage = {
+        $type: 'SerializationError',
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+    const serializationDuration = state$d.now() - startTime;
+    const transferables = state$d.getTransferrables(message);
+    target.postMessage(message, transferables);
+    queueRecord(workerId, {
+      connectionId,
+      direction,
+      message: serializedMessage,
+      monotonicTime,
+      sequence: sequence.value++,
+      serializationDuration,
+      version: 1,
+      wallTime: state$d.wallTime(),
+      workerId
+    });
+  };
+  source.start?.();
+};
+const maybeCreateProxy = async ({
+  id,
+  name = '',
   port,
-  id
+  traceId = ''
 }) => {
+  if (!port || state$d.disabled) {
+    return port;
+  }
+  const options = await getOptions();
+  if (state$d.disabled || !shouldTrace(options.selectors, traceId)) {
+    return port;
+  }
+  const workerId = getWorkerId(traceId, name, id);
+  const connectionId = `${state$d.timeOrigin()}-${state$d.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;
+  }
+};
+
+/** @param {any} options */
+const create$10 = async options => {
+  const {
+    url,
+    name,
+    port,
+    id,
+    traceId = ''
+  } = options;
   // TODO no need to create port if worker
   // has been prelaunched in renderer process
   const {
     port1,
     port2
   } = getPortTuple(port);
+  const workerPort = await maybeCreateProxy({
+    id,
+    name,
+    port: port2,
+    traceId
+  });
   await invokeAndTransfer$E('IpcParent.create', {
     method: ModuleWorkerWithMessagePort,
     url,
     name,
     raw: true,
-    port: port2,
+    port: workerPort,
     id
   });
   return port1;
@@ -10390,7 +10728,7 @@ const wrap = port => {
     set onmessage(listener) {
       this.listener = listener;
       const wrappedListener = event => {
-        const data = getData$1(event);
+        const data = getData$2(event);
         const syntheticEvent = {
           data,
           target: this
@@ -12413,7 +12751,7 @@ const addWebExtension = async path => {
     }
   }
   manifest.status = Resolved;
-  state$g.webExtensions.push(manifest);
+  state$h.webExtensions.push(manifest);
   if (manifest.languages) {
     // TODO handle case when languages is not of type array
     await addLanguages(manifest.languages);
@@ -14829,10 +15167,16 @@ const launchIsolatedExtensionHostWorker = async (port, extensionId, url, workerN
     const pathName = new URL(url, 'http://localhost').pathname;
     await set$2(pathName, contentSecurityPolicy);
   }
+  const workerPort = await maybeCreateProxy({
+    id,
+    name,
+    port,
+    traceId: extensionId
+  });
   await invokeAndTransfer$E('IpcParent.create', {
     method: ModuleWorkerWithMessagePort,
     name,
-    port,
+    port: workerPort,
     raw: true,
     url,
     id
@@ -19849,7 +20193,7 @@ const createContext$1 = () => ({
   assetDir: assetDir,
   isTest: isTest?.() ?? false,
   platform: getPlatform$2(),
-  workspacePath: state$l.workspacePath,
+  workspacePath: state$m.workspacePath,
   workspaceUri: getWorkspaceUri?.()
 });
 const getValue = (values, name, description) => {
@@ -21797,7 +22141,7 @@ const loadContent$z = async state => {
     command,
     args
   } = await getTerminalSpawnOptions();
-  await invoke$2('Terminal.create', uid, cwd || state$l.workspacePath, command, args, {
+  await invoke$2('Terminal.create', uid, cwd || state$m.workspacePath, command, args, {
     backend: getBackend()
   });
   return {
@@ -24298,7 +24642,7 @@ const ViewletKeyBindings_ipc = {
 
 const Deb = 'Deb';
 
-const commit = '0ae7736';
+const commit = 'dbe3eca';
 
 const getAutoUpdateType = () => {
   return invoke$G('AutoUpdater.getAutoUpdateType');
@@ -27120,7 +27464,7 @@ const handleSettingsChanged = async state => {
 };
 const refreshSourceControlBadgeCount = async state => {
   try {
-    const badgeCount = await invoke$m('SourceControl.getWorkspaceBadgeCount', state$l.workspacePath, assetDir, platform);
+    const badgeCount = await invoke$m('SourceControl.getWorkspaceBadgeCount', state$m.workspacePath, assetDir, platform);
     return setBadgeCount(state, SourceControl, badgeCount);
   } catch {
     return {
@@ -30877,7 +31221,7 @@ const loadContent$5 = async (state, savedState) => {
     platform,
     assetDir
   } = state;
-  await invoke$m('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$l.workspacePath,
+  await invoke$m('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$m.workspacePath,
   // TODO use workspace uri
   platform, assetDir);
   const diffResult = await invoke$m('SourceControl.diff2', state.uid);
@@ -30998,7 +31342,7 @@ const hotReload$2 = async state => {
     ...state,
     items: []
   };
-  await invoke$m('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$l.workspacePath,
+  await invoke$m('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$m.workspacePath,
   // TODO use workspace uri
   state.platform, state.assetDir);
   await invoke$m('SourceControl.loadContent', state.uid, savedState);