@lvce-editor/renderer-process 30.68.9 → 30.68.10

package/dist/rendererProcessMain.js

@@ -1464,15 +1464,15 @@ const createClient = url => {
 const commandMapRef = {};
 
 const workers$1 = new Map();
-const state$m = {
+const state$n = {
   generation: 0,
   nextId: 0
 };
-const getGeneration = () => state$m.generation;
+const getGeneration = () => state$n.generation;
 const createRuntimeName = name => {
-  state$m.nextId++;
-  const id = `worker-${state$m.nextId}`;
-  const runtimeId = `worker-${String(state$m.nextId).padStart(2, '0')}`;
+  state$n.nextId++;
+  const id = `worker-${state$n.nextId}`;
+  const runtimeId = `worker-${String(state$n.nextId).padStart(2, '0')}`;
   return {
     id,
     name,
@@ -1480,8 +1480,8 @@ const createRuntimeName = name => {
     runtimeName: `[${runtimeId}] ${name}`
   };
 };
-const track = (worker, startedIn = state$m.generation, trackedWorker) => {
-  if (startedIn !== state$m.generation) {
+const track = (worker, startedIn = state$n.generation, trackedWorker) => {
+  if (startedIn !== state$n.generation) {
     worker.terminate();
     throw new Error('Worker launch canceled by application restart');
   }
@@ -1508,7 +1508,7 @@ const terminate$1 = id => {
 };
 const getWorkers$1 = () => workers$1.values().toArray();
 const terminateAll = () => {
-  state$m.generation++;
+  state$n.generation++;
   const retiring = workers$1.keys().toArray();
   workers$1.clear();
   for (const worker of retiring) {
@@ -1654,7 +1654,7 @@ const launchRendererWorker = async () => {
 };
 
 const selector = 'script.RendererWorkerTrace';
-const state$l = {
+const state$m = {
   enabled: false,
   entries: []
 };
@@ -1704,14 +1704,14 @@ const isCommand = value => {
 };
 const initialize$1 = search => {
   const searchParams = new URLSearchParams(search);
-  state$l.enabled = searchParams.has('traceRendererWorker');
-  state$l.entries = [];
+  state$m.enabled = searchParams.has('traceRendererWorker');
+  state$m.entries = [];
 };
 const record = (direction, method, params) => {
-  if (!state$l.enabled) {
+  if (!state$m.enabled) {
     return;
   }
-  state$l.entries.push({
+  state$m.entries.push({
     direction,
     method,
     params: serialize(params),
@@ -1719,7 +1719,7 @@ const record = (direction, method, params) => {
   });
 };
 const listen$1 = rpc => {
-  if (!state$l.enabled) {
+  if (!state$m.enabled) {
     return;
   }
   const ipc = rpc.ipc;
@@ -1734,7 +1734,7 @@ const listen$1 = rpc => {
   });
 };
 const exportToDom = () => {
-  if (!state$l.enabled) {
+  if (!state$m.enabled) {
     return;
   }
   const existing = document.querySelector(selector);
@@ -1742,7 +1742,7 @@ const exportToDom = () => {
   script.className = 'RendererWorkerTrace';
   script.type = 'application/json';
   script.textContent = JSON.stringify({
-    entries: state$l.entries,
+    entries: state$m.entries,
     version: 1
   });
   if (!existing) {
@@ -1750,49 +1750,49 @@ const exportToDom = () => {
   }
 };
 const scheduleExport = () => {
-  if (!state$l.enabled) {
+  if (!state$m.enabled) {
     return;
   }
   queueMicrotask(exportToDom);
 };
 
-const state$k = {
+const state$l = {
   rpc: undefined
 };
 const hydrate$4 = async () => {
   const result = await launchRendererWorker();
   if (isError(result)) {
-    state$k.rpc = undefined;
+    state$l.rpc = undefined;
     return result;
   }
-  state$k.rpc = result.value;
+  state$l.rpc = result.value;
   listen$1(result.value);
   return success(undefined);
 };
 
 // TODO needed?
 const dispose$m = async () => {
-  const rpc = state$k.rpc;
-  state$k.rpc = undefined;
+  const rpc = state$l.rpc;
+  state$l.rpc = undefined;
   await rpc?.dispose();
 };
 const send$1 = (method, ...params) => {
   record('sent', method, params);
   // @ts-ignore
-  state$k.rpc.send(method, ...params);
+  state$l.rpc.send(method, ...params);
 };
 const invoke$1 = (method, ...params) => {
   record('sent', method, params);
   // @ts-ignore
-  return state$k.rpc.invoke(method, ...params);
+  return state$l.rpc.invoke(method, ...params);
 };
 const invokeAndTransfer = (method, ...params) => {
   record('sent', method, params);
   // @ts-ignore
-  return state$k.rpc.invokeAndTransfer(method, ...params);
+  return state$l.rpc.invokeAndTransfer(method, ...params);
 };
 
-const state$j = {
+const state$k = {
   client: undefined,
   enabled: false,
   lastError: '',
@@ -1802,38 +1802,38 @@ const state$j = {
 const workerUrl = new URL('sessionReplayWorkerMain.js', import.meta.url);
 const reloadMessage = 'Reload the window to start session replay with the complete DOM command history';
 const report = error => {
-  state$j.lastError = error instanceof Error ? error.message : String(error);
-  state$j.stopObserving?.();
-  state$j.stopObserving = undefined;
-  console.warn(`Session replay: ${state$j.lastError}`);
+  state$k.lastError = error instanceof Error ? error.message : String(error);
+  state$k.stopObserving?.();
+  state$k.stopObserving = undefined;
+  console.warn(`Session replay: ${state$k.lastError}`);
 };
 
 // Retain snapshot recording for older renderer workers during dependency rollout.
 const configure$1 = async options => {
-  state$j.stopObserving?.();
-  state$j.stopObserving = undefined;
-  state$j.enabled = false;
-  if (state$j.client) {
+  state$k.stopObserving?.();
+  state$k.stopObserving = undefined;
+  state$k.enabled = false;
+  if (state$k.client) {
     try {
-      await state$j.client.invoke('stop');
+      await state$k.client.invoke('stop');
     } catch (error) {
       report(error);
     }
     // Live channels still need their proxy after capture stops.
-    if (!state$j.proxy) {
-      state$j.client.dispose();
-      state$j.client = undefined;
+    if (!state$k.proxy) {
+      state$k.client.dispose();
+      state$k.client = undefined;
     }
   }
   if (!options.local && !options.upload) return '';
-  if (state$j.proxy) throw new Error(reloadMessage);
-  state$j.lastError = '';
+  if (state$k.proxy) throw new Error(reloadMessage);
+  state$k.lastError = '';
   const client = createClient(workerUrl);
   try {
     const id = await client.invoke('start', options);
-    state$j.stopObserving = observe(document, (type, data) => client.invoke('record', type, data), report);
-    state$j.client = client;
-    state$j.enabled = true;
+    state$k.stopObserving = observe(document, (type, data) => client.invoke('record', type, data), report);
+    state$k.client = client;
+    state$k.enabled = true;
     return id;
   } catch (error) {
     client.dispose();
@@ -1841,7 +1841,7 @@ const configure$1 = async options => {
   }
 };
 const configureProxy = async (options, port) => {
-  if (state$j.client || !options.local && !options.upload) {
+  if (state$k.client || !options.local && !options.upload) {
     port.close();
     throw new Error(reloadMessage);
   }
@@ -1854,25 +1854,25 @@ const configureProxy = async (options, port) => {
       commandMap: commandMapRef,
       messagePort: proxyPort
     });
-    const original = state$k.rpc;
-    state$k.rpc = {
+    const original = state$l.rpc;
+    state$l.rpc = {
       ...rpc,
       async dispose() {
         try {
           await rpc.dispose();
         } finally {
           client.dispose();
-          state$j.client = undefined;
-          state$j.enabled = false;
-          state$j.proxy = false;
+          state$k.client = undefined;
+          state$k.enabled = false;
+          state$k.proxy = false;
           await original?.dispose();
         }
       }
     };
-    state$j.client = client;
-    state$j.enabled = true;
-    state$j.proxy = true;
-    state$j.lastError = '';
+    state$k.client = client;
+    state$k.enabled = true;
+    state$k.proxy = true;
+    state$k.lastError = '';
     return id;
   } catch (error) {
     proxyPort?.close();
@@ -1882,21 +1882,21 @@ const configureProxy = async (options, port) => {
   }
 };
 const getSession = async () => {
-  if (!state$j.enabled || !state$j.client) throw new Error('Session replay is disabled in settings');
-  return state$j.client.invoke('export');
+  if (!state$k.enabled || !state$k.client) throw new Error('Session replay is disabled in settings');
+  return state$k.client.invoke('export');
 };
 const getStatus$1 = async () => {
-  if (!state$j.client) return {
+  if (!state$k.client) return {
     enabled: false,
-    error: state$j.lastError
+    error: state$k.lastError
   };
   return {
-    enabled: state$j.enabled,
-    ...(await state$j.client.invoke('status')),
-    captureError: state$j.lastError
+    enabled: state$k.enabled,
+    ...(await state$k.client.invoke('status')),
+    captureError: state$k.lastError
   };
 };
-const flush = async () => state$j.client?.invoke('flush');
+const flush = async () => state$k.client?.invoke('flush');
 const openLocalFile = async () => {
   const input = document.createElement('input');
   input.type = 'file';
@@ -1954,12 +1954,12 @@ const initializeLayout = async href => {
   return true;
 };
 const dispose$l = async () => {
-  state$j.stopObserving?.();
-  state$j.stopObserving = undefined;
-  const client = state$j.client;
-  state$j.client = undefined;
-  state$j.enabled = false;
-  state$j.proxy = false;
+  state$k.stopObserving?.();
+  state$k.stopObserving = undefined;
+  const client = state$k.client;
+  state$k.client = undefined;
+  state$k.enabled = false;
+  state$k.proxy = false;
   if (client) {
     try {
       await client.invoke('flush');
@@ -2065,34 +2065,34 @@ const launchDragAndDropWorker = async () => {
   }
 };
 
-const state$i = {
+const state$j = {
   rpc: undefined
 };
 const hydrate$3 = async () => {
   const result = await launchDragAndDropWorker();
   if (isError(result)) {
-    state$i.rpc = undefined;
+    state$j.rpc = undefined;
     return result;
   }
-  state$i.rpc = result.value;
+  state$j.rpc = result.value;
   return success(undefined);
 };
 const handleMessagePort$1 = async port => {
-  if (!state$i.rpc) {
+  if (!state$j.rpc) {
     const result = await hydrate$3();
     if (isError(result)) {
       throw result.error;
     }
   }
-  const rpc = state$i.rpc;
+  const rpc = state$j.rpc;
   if (!rpc) {
     throw new Error('Drag And Drop Worker failed to initialize');
   }
   await rpc.invokeAndTransfer('DragAndDrop.handleMessagePort', port);
 };
 const dispose$k = async () => {
-  const rpc = state$i.rpc;
-  state$i.rpc = undefined;
+  const rpc = state$j.rpc;
+  state$j.rpc = undefined;
   await rpc?.dispose();
 };
 
@@ -2216,7 +2216,7 @@ const createIdGenerator = () => {
 };
 const create$A = createIdGenerator();
 
-const state$h = Object.create(null);
+const state$i = Object.create(null);
 const retainString = (item, index) => {
   const value = new Promise(resolve => {
     item.getAsString(resolve);
@@ -2267,25 +2267,25 @@ const retainItems = dataTransfer => {
 };
 const addItems = items => {
   const id = create$A();
-  state$h[id] = items;
+  state$i[id] = items;
   return id;
 };
 const add$2 = dataTransfer => {
   return addItems(retainItems(dataTransfer));
 };
 const acquire$2 = id => {
-  const items = state$h[id];
+  const items = state$i[id];
   if (!items) {
     throw new Error(`Drop data not found: ${id}`);
   }
-  delete state$h[id];
+  delete state$i[id];
   return items;
 };
 
-const state$g = Object.create(null);
+const state$h = Object.create(null);
 const acquire$1 = id => {
-  const promise = state$g[id];
-  delete state$g[id];
+  const promise = state$h[id];
+  delete state$h[id];
   return promise;
 };
 const getFileHandles = async ids => {
@@ -2295,7 +2295,7 @@ const getFileHandles = async ids => {
 };
 const add$1 = promise => {
   const id = create$A();
-  state$g[id] = promise;
+  state$h[id] = promise;
   return id;
 };
 const addFileHandle$1 = fileHandle => {
@@ -2489,14 +2489,14 @@ const getEventListenerArgs = (params, event) => {
   return serialized;
 };
 
-const state$f = {
+const state$g = {
   ipc: undefined
 };
 const getIpc = () => {
-  return state$f.ipc;
+  return state$g.ipc;
 };
 const setIpc = value => {
-  state$f.ipc = value;
+  state$g.ipc = value;
 };
 
 const nameAnonymousFunction$1 = (fn, name) => {
@@ -4172,12 +4172,12 @@ const unregisterView = uid => {
   viewRpcIds.delete(uid);
 };
 
-const state$e = {
+const state$f = {
   snapshot: undefined
 };
-const get$7 = () => state$e.snapshot;
+const get$7 = () => state$f.snapshot;
 const set$9 = value => {
-  state$e.snapshot = value;
+  state$f.snapshot = value;
 };
 
 const ipcs = Object.create(null);
@@ -4686,32 +4686,32 @@ const launchWorkers = async () => {
   return success(undefined);
 };
 
-const state$d = {
+const state$e = {
   renderer: undefined
 };
 const configure = options => {
   const cache = options?.cache;
-  state$d.renderer = cache?.dom > 0 || cache?.text > 0 ? createRenderer(options) : undefined;
+  state$e.renderer = cache?.dom > 0 || cache?.text > 0 ? createRenderer(options) : undefined;
 };
 const render = (nodes, eventMap = {}, newEventMap = {}) => {
-  return state$d.renderer?.render(nodes, eventMap, newEventMap) || render$1(nodes, eventMap, newEventMap);
+  return state$e.renderer?.render(nodes, eventMap, newEventMap) || render$1(nodes, eventMap, newEventMap);
 };
 const renderInto = (parent, nodes, eventMap = {}, newEventMap = {}) => {
-  if (state$d.renderer) {
-    state$d.renderer.renderInto(parent, nodes, eventMap, newEventMap);
+  if (state$e.renderer) {
+    state$e.renderer.renderInto(parent, nodes, eventMap, newEventMap);
     return;
   }
   renderInto$1(parent, nodes, eventMap);
 };
 const applyPatch$1 = (element, patches, eventMap = {}, id = 0) => {
-  if (state$d.renderer) {
-    state$d.renderer.applyPatch(element, patches, eventMap, id);
+  if (state$e.renderer) {
+    state$e.renderer.applyPatch(element, patches, eventMap, id);
     return;
   }
   applyPatch$2(element, patches, eventMap, id);
 };
 const dispose$i = root => {
-  state$d.renderer?.dispose(root);
+  state$e.renderer?.dispose(root);
 };
 
 const applyPatch = (element, patches, eventMap = {}, id = 0) => {
@@ -4724,25 +4724,25 @@ const attachEvents$7 = ($Node, eventMap) => {
   }
 };
 
-const state$c = {
+const state$d = {
   styleSheets: Object.create(null),
   texts: Object.create(null)
 };
 const set$6 = (id, sheet) => {
-  state$c.styleSheets[id] = sheet;
+  state$d.styleSheets[id] = sheet;
 };
 const get$5 = id => {
-  return state$c.styleSheets[id];
+  return state$d.styleSheets[id];
 };
 const setText$1 = (id, text) => {
-  state$c.texts[id] = text;
+  state$d.texts[id] = text;
 };
 const getText = id => {
-  return state$c.texts[id];
+  return state$d.texts[id];
 };
 const remove$2 = id => {
-  delete state$c.styleSheets[id];
-  delete state$c.texts[id];
+  delete state$d.styleSheets[id];
+  delete state$d.texts[id];
 };
 
 const addCssStyleSheet = (id, text) => {
@@ -4816,25 +4816,25 @@ const PointerUp = 'pointerup';
 const Resize = 'resize';
 const Wheel = 'wheel';
 
-const state$b = {
+const state$c = {
   currentDragInfo: undefined
 };
 const set$5 = (id, data) => {
-  state$b.currentDragInfo = data;
+  state$c.currentDragInfo = data;
   setDragInfo(id, data);
 };
 const getCurrent = () => {
-  return state$b.currentDragInfo;
+  return state$c.currentDragInfo;
 };
 
-const state$a = {
+const state$b = {
   identifiers: new Uint32Array()
 };
 const setIdentifiers$1 = identifiers => {
-  state$a.identifiers = identifiers;
+  state$b.identifiers = identifiers;
 };
 const getIdentifiers = () => {
-  return state$a.identifiers;
+  return state$b.identifiers;
 };
 
 // TODO store keybindings as JSON somewhere
@@ -4864,11 +4864,11 @@ const info = (...args) => {
 };
 
 const pendingBatches = new Map();
-const state$9 = {
+const state$a = {
   nextTransactionId: 1
 };
 const queue = (uid, commands, focusVersion = 0) => {
-  const transactionId = state$9.nextTransactionId++;
+  const transactionId = state$a.nextTransactionId++;
   pendingBatches.set(transactionId, {
     commands,
     committed: false,
@@ -5060,7 +5060,7 @@ class VError extends Error {
 }
 
 // TODO this file is not needed when all elements are position fixed
-const state$8 = {
+const state$9 = {
   $Widgets: undefined,
   widgetSet: new Set()
 };
@@ -5072,20 +5072,20 @@ const create$Widgets = () => {
 };
 const append$1 = $Element => {
   // TODO should not call append in the first place if it is already in DOM
-  if (state$8.widgetSet.has($Element)) {
+  if (state$9.widgetSet.has($Element)) {
     return;
   }
-  state$8.widgetSet.add($Element);
-  if (state$8.$Widgets) {
+  state$9.widgetSet.add($Element);
+  if (state$9.$Widgets) {
     // @ts-expect-error
-    state$8.$Widgets.append($Element);
+    state$9.$Widgets.append($Element);
   } else {
     // @ts-expect-error
-    state$8.$Widgets = create$Widgets();
+    state$9.$Widgets = create$Widgets();
     // @ts-expect-error
-    state$8.$Widgets.append($Element);
+    state$9.$Widgets.append($Element);
     // @ts-expect-error
-    document.body.append(state$8.$Widgets);
+    document.body.append(state$9.$Widgets);
   }
 };
 const remove$1 = $Element => {
@@ -5093,13 +5093,13 @@ const remove$1 = $Element => {
     // TODO $Element should always be defined
     return;
   }
-  state$8.widgetSet.delete($Element);
+  state$9.widgetSet.delete($Element);
   $Element.remove();
   // TODO state.$Widgets should always be defined at this point
-  if (state$8.widgetSet.size === 0 && state$8.$Widgets) {
+  if (state$9.widgetSet.size === 0 && state$9.$Widgets) {
     // @ts-expect-error
-    state$8.$Widgets.remove();
-    state$8.$Widgets = undefined;
+    state$9.$Widgets.remove();
+    state$9.$Widgets = undefined;
   }
 };
 
@@ -7475,16 +7475,16 @@ const EditorTextError = 'EditorTextError';
 const EditorRename = 'EditorRename';
 const EditorCodeGenerator = 'EditorCodeGenerator';
 
-const state$7 = {
+const state$8 = {
   /**
    * @type {HTMLElement|undefined}
    */
   $PreviousFocusElement: undefined};
 const setElement = $Element => {
-  state$7.$PreviousFocusElement = $Element;
+  state$8.$PreviousFocusElement = $Element;
 };
 const getElement = () => {
-  return state$7.$PreviousFocusElement;
+  return state$8.$PreviousFocusElement;
 };
 
 const focus$8 = $Element => {
@@ -7893,11 +7893,11 @@ const ViewletSidebar = {
 };
 
 const pendingSelections = new WeakMap();
-const state$6 = {};
+const state$7 = {};
 const handleFocus$2 = event => {
   const target = event.target;
   if (target instanceof HTMLElement && !target.closest('.SimpleBrowser') && target.closest('.Main, .Panel, .Editor, .Terminal')) {
-    state$6.codingFocus = new WeakRef(target);
+    state$7.codingFocus = new WeakRef(target);
   }
 };
 const handleFocusOut$2 = event => {
@@ -7926,7 +7926,7 @@ const listen = () => {
   document.addEventListener('keydown', cancelPendingAddressSelection);
 };
 const restoreCodingFocus$1 = () => {
-  const target = state$6.codingFocus?.deref();
+  const target = state$7.codingFocus?.deref();
   if (!target?.isConnected) {
     return false;
   }
@@ -8419,7 +8419,7 @@ const create$BackDrop = () => {
 
 // TODO keyboard handling
 
-const state$5 = {
+const state$6 = {
   $$Menus: [],
   $BackDrop: undefined,
   anchorTime: -1,
@@ -8430,7 +8430,7 @@ const state$5 = {
 };
 const getLevel = $Menu => {
   // @ts-expect-error
-  return state$5.$$Menus.indexOf($Menu);
+  return state$6.$$Menus.indexOf($Menu);
 };
 const handleMouseDown$1 = event => {
   const $Target = event.target;
@@ -8500,10 +8500,10 @@ const handleMouseLeave = event => {
 
 // const handleBlur = (event) => {}
 const handleKeyDown = event => {
-  state$5.handleKeyDown(event);
+  state$6.handleKeyDown(event);
 };
 const handleFocusOut$1 = event => {
-  state$5.handleFocusOut(event);
+  state$6.handleFocusOut(event);
 };
 const create$Menu$1 = () => {
   // TODO set aria label on menu (e.g. File, Edit, Selection)
@@ -8531,7 +8531,7 @@ const create$Menu$1 = () => {
   return $Menu;
 };
 const focusIndex = (level, oldFocusedIndex, newFocusedIndex) => {
-  const $Menu = state$5.$$Menus[level];
+  const $Menu = state$6.$$Menus[level];
   if (oldFocusedIndex !== -1) {
     // @ts-expect-error
     $Menu.children[oldFocusedIndex].classList.remove('MenuItemFocused');
@@ -8553,21 +8553,21 @@ const handleBackDropMouseDown = event => {
   preventDefault(event);
   stopPropagation(event);
   send$1(/* Menu.hide */'Menu.hide');
-  if (state$5.$BackDrop) {
-    remove$1(state$5.$BackDrop);
-    state$5.$BackDrop = undefined;
+  if (state$6.$BackDrop) {
+    remove$1(state$6.$BackDrop);
+    state$6.$BackDrop = undefined;
   }
 };
 const handleContextMenu$1 = event => {
   preventDefault(event);
 };
 const showMenu = (x, y, width, height, items, level, parentIndex = -1, dom = [], mouseBlocking = false) => {
-  if (mouseBlocking && !state$5.$BackDrop) {
+  if (mouseBlocking && !state$6.$BackDrop) {
     const $BackDrop = create$BackDrop();
     $BackDrop.onmousedown = handleBackDropMouseDown;
     $BackDrop.oncontextmenu = handleContextMenu$1;
     // @ts-expect-error
-    state$5.$BackDrop = $BackDrop;
+    state$6.$BackDrop = $BackDrop;
     append$1($BackDrop);
   }
   const $Menu = create$Menu$1();
@@ -8575,7 +8575,7 @@ const showMenu = (x, y, width, height, items, level, parentIndex = -1, dom = [],
   setXAndY($Menu, x, y);
   $Menu.id = `Menu-${level}`;
   if (parentIndex !== -1) {
-    const $ParentMenu = state$5.$$Menus[level - 1];
+    const $ParentMenu = state$6.$$Menus[level - 1];
     // @ts-expect-error
     const $ParentMenuItem = $ParentMenu.children[parentIndex];
     $ParentMenuItem.ariaExpanded = True;
@@ -8583,7 +8583,7 @@ const showMenu = (x, y, width, height, items, level, parentIndex = -1, dom = [],
   }
 
   // @ts-expect-error
-  state$5.$$Menus.push($Menu);
+  state$6.$$Menus.push($Menu);
   append$1($Menu);
   if (level === 0) {
     focus$8($Menu);
@@ -8591,14 +8591,14 @@ const showMenu = (x, y, width, height, items, level, parentIndex = -1, dom = [],
   }
 };
 const hideSubmenu = level => {
-  const $$ChildMenus = state$5.$$Menus.slice(level);
+  const $$ChildMenus = state$6.$$Menus.slice(level);
   for (const $ChildMenu of $$ChildMenus) {
     remove$1($ChildMenu);
   }
-  state$5.$$Menus = state$5.$$Menus.slice(0, level);
-  if (state$5.$$Menus.length === 0 && state$5.$BackDrop) {
-    remove$1(state$5.$BackDrop);
-    state$5.$BackDrop = undefined;
+  state$6.$$Menus = state$6.$$Menus.slice(0, level);
+  if (state$6.$$Menus.length === 0 && state$6.$BackDrop) {
+    remove$1(state$6.$BackDrop);
+    state$6.$BackDrop = undefined;
   }
 };
 
@@ -8637,7 +8637,7 @@ const showControlled = ({
   y
 }) => {
   showMenu(x, y, width, height, items, level);
-  const $Menu = state$5.$$Menus.at(-1);
+  const $Menu = state$6.$$Menus.at(-1);
   if ($Parent && $Menu) {
     const uid = get$9($Parent);
     set$a($Menu, uid);
@@ -8645,9 +8645,9 @@ const showControlled = ({
   // TODO menu should not necessarily know about parent (titleBarMenuBar)
   // it should be the other way around
   // @ts-expect-error
-  state$5.$Parent = $Parent;
-  state$5.handleFocusOut = handleFocusOut;
-  state$5.handleKeyDown = handleKeyDown;
+  state$6.$Parent = $Parent;
+  state$6.handleFocusOut = handleFocusOut;
+  state$6.handleKeyDown = handleKeyDown;
   if ($Parent) {
     // state.$Menu.ariaLabel=''
     // state.$Menu.ariaLabelledBy  =$Parent.id
@@ -8659,13 +8659,13 @@ const showControlled = ({
 // TODO have function to show submenu
 
 const hide = (restoreFocus = true) => {
-  for (const $Menu of state$5.$$Menus) {
+  for (const $Menu of state$6.$$Menus) {
     remove$1($Menu);
   }
-  state$5.$$Menus = [];
-  if (state$5.$BackDrop) {
-    remove$1(state$5.$BackDrop);
-    state$5.$BackDrop = undefined;
+  state$6.$$Menus = [];
+  if (state$6.$BackDrop) {
+    remove$1(state$6.$BackDrop);
+    state$6.$BackDrop = undefined;
   }
   // TODO focus previous item
   if (restoreFocus) {
@@ -8910,8 +8910,8 @@ const openMenu = (state, unFocusIndex, index, level, menuItems, menuFocusedIndex
     $Viewlet.children[unFocusIndex].removeAttribute(AriaOwns);
   }
   $Viewlet.children[index].ariaExpanded = True;
-  const $$Menus = state$5.$$Menus;
-  state$5.$$Menus = [];
+  const $$Menus = state$6.$$Menus;
+  state$6.$$Menus = [];
   // @ts-expect-error
   showControlled({
     $Parent: $Viewlet.children[index],
@@ -9320,14 +9320,14 @@ const load$1 = moduleId => {
   return loadModule();
 };
 
-const state$4 = {
+const state$5 = {
   currentPanelView: undefined,
   currentSidebarView: undefined,
   modules: Object.create(null)
 };
 
 const create$4 = (id, uid = id) => {
-  const module = state$4.modules[id];
+  const module = state$5.modules[id];
   if (!module) {
     throw new Error(`module not found: ${id}`);
   }
@@ -9346,7 +9346,7 @@ const create$4 = (id, uid = id) => {
   });
 };
 const createFunctionalRoot = (id, uid = id, hasFunctionalEvents, directEventRpcId) => {
-  let module = state$4.modules[id];
+  let module = state$5.modules[id];
   if (hasFunctionalEvents) {
     module ||= {};
   }
@@ -9378,7 +9378,7 @@ const removeKeyBindings = id => {
 const loadModule = async id => {
   try {
     const module = await load$1(id);
-    state$4.modules[id] = module;
+    state$5.modules[id] = module;
   } catch (error) {
     throw new VError(error, `Failed to load ${id}`);
   }
@@ -9562,7 +9562,7 @@ const refresh = (viewletId, viewletContext) => {
     instance.factory.refresh(instance.state, viewletContext);
   } else {
     // @ts-expect-error
-    state$4.refreshContext[viewletId] = viewletContext;
+    state$5.refreshContext[viewletId] = viewletContext;
   }
 };
 const specialIds = new Set(['TitleBar', 'SideBar', 'Main', 'ActivityBar', 'StatusBar', 'Panel']);
@@ -10172,7 +10172,7 @@ const getFn = command => {
   return fn;
 };
 
-const state$3 = {
+const state$4 = {
   duration: 0,
   lastError: '',
   pending: false
@@ -10188,9 +10188,9 @@ const waitForReady = async () => {
   }
 };
 const getStatus = () => ({
-  duration: state$3.duration,
-  error: state$3.lastError,
-  pending: state$3.pending
+  duration: state$4.duration,
+  error: state$4.lastError,
+  pending: state$4.pending
 });
 const restart = async () => {
   const started = performance.now();
@@ -10213,9 +10213,9 @@ const restart = async () => {
     if (isError(result)) throw result.error;
     await waitForReady();
     set$9(undefined);
-    state$3.duration = performance.now() - started;
+    state$4.duration = performance.now() - started;
   } catch (error) {
-    state$3.lastError = error instanceof Error ? error.message : String(error);
+    state$4.lastError = error instanceof Error ? error.message : String(error);
     console.error(error);
     // Keep the snapshot available for recovery; never silently discard drafts.
     const snapshot = get$7();
@@ -10229,21 +10229,21 @@ const restart = async () => {
       }
     }
     const recovery = document.createElement('button');
-    recovery.textContent = `Application restart failed: ${state$3.lastError}. Reload window`;
+    recovery.textContent = `Application restart failed: ${state$4.lastError}. Reload window`;
     recovery.onclick = () => location.reload();
     document.body.append(recovery);
   } finally {
     document.documentElement.inert = false;
-    state$3.pending = false;
+    state$4.pending = false;
   }
 };
 
 // Reply on the old RPC before retiring it. Awaiting restart from that RPC would
 // strand the caller when its worker is terminated.
 const request = () => {
-  if (state$3.pending) return;
-  state$3.pending = true;
-  state$3.lastError = '';
+  if (state$4.pending) return;
+  state$4.pending = true;
+  state$4.lastError = '';
   setTimeout(() => void restart(), 0);
 };
 
@@ -10483,6 +10483,10 @@ const addFileHandle = fileHandle => {
   return addFileHandle$1(fileHandle);
 };
 
+const state$3 = {
+  hydrated: false,
+  lastPathName: ''
+};
 const getPathName = () => {
   return location.pathname;
 };
@@ -10499,6 +10503,7 @@ const setPathName = pathName => {
     return;
   }
   history.pushState(null, '', pathName);
+  state$3.lastPathName = getPathName();
 };
 const setHash = hash => {
   const currentHref = getHref();
@@ -10518,8 +10523,25 @@ const setWorkspaceUri = workspaceUri => {
   }
   history.replaceState(null, '', url.href);
 };
+const isChatPath = pathName => {
+  return /(?:^|\/)chat\/?$/.test(pathName);
+};
+const handlePopState = () => {
+  const pathName = getPathName();
+  if (isChatPath(pathName)) {
+    send$1('Layout.enterAiNativeLayout');
+  } else if (isChatPath(state$3.lastPathName)) {
+    send$1('Layout.leaveSideBarFocusMode');
+  }
+  state$3.lastPathName = pathName;
+};
 const hydrate = () => {
-  // addEventListener('popstate', handlePopState)
+  if (state$3.hydrated) {
+    return;
+  }
+  state$3.lastPathName = getPathName();
+  addEventListener('popstate', handlePopState);
+  state$3.hydrated = true;
 };
 
 const getConfig = () => {
@@ -12515,15 +12537,15 @@ const main = async () => {
   initialize$1(location.search);
   Object.assign(commandMapRef, commandMap);
   enable(window);
-  state$4.modules[ColorPicker] = ViewletColorPicker;
-  state$4.modules[EditorCodeGenerator] = ViewletEditorCodeGenerator;
-  state$4.modules[EditorCompletion] = ViewletEditorCompletion;
-  state$4.modules[EditorCompletionDetails] = ViewletEditorCompletionDetails;
-  state$4.modules[EditorHover] = ViewletEditorHover;
-  state$4.modules[EditorRename] = ViewletEditorRename;
-  state$4.modules[EditorSourceActions] = ViewletEditorSourceActions;
-  state$4.modules[FindWidget] = ViewletFindWidget;
-  state$4.modules[TitleBar] = ViewletTitleBar;
+  state$5.modules[ColorPicker] = ViewletColorPicker;
+  state$5.modules[EditorCodeGenerator] = ViewletEditorCodeGenerator;
+  state$5.modules[EditorCompletion] = ViewletEditorCompletion;
+  state$5.modules[EditorCompletionDetails] = ViewletEditorCompletionDetails;
+  state$5.modules[EditorHover] = ViewletEditorHover;
+  state$5.modules[EditorRename] = ViewletEditorRename;
+  state$5.modules[EditorSourceActions] = ViewletEditorSourceActions;
+  state$5.modules[FindWidget] = ViewletFindWidget;
+  state$5.modules[TitleBar] = ViewletTitleBar;
   // TODO this is discovered very late
   const launchWorkersResult = await launchWorkers();
   if (isError(launchWorkersResult)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/renderer-process",
-  "version": "30.68.9",
+  "version": "30.68.10",
   "keywords": [
     "lvce-editor",
     "renderer-process"