@lvce-editor/static-server 0.91.6 → 0.91.7

package/static/{25356f7 → 98fc4d9}/packages/main-area-worker/dist/mainAreaWorkerMain.js

@@ -599,7 +599,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -1898,700 +1905,769 @@ const closeTab = (state, groupId, tabId) => {
   return withGroups(stateWithClosedTab, newGroups);
 };
 
-const findTabInState = (state, groupId, tabId) => {
-  const {
-    layout
-  } = state;
-  const group = layout.groups.find(g => g.id === groupId);
-  return group?.tabs.find(t => t.id === tabId);
+const handleAttach = async command => {
+  // TODO find a better way to append editors
+  const parentNodeSelector = '.editor-groups-container, .EditorGroup';
+  await invoke('Layout.attachViewlet', parentNodeSelector, command.instanceId);
 };
 
-const saveEditor = async editorUid => {
-  return invoke('Editor.save', editorUid);
+const getTitle$1 = async editorUid => {
+  try {
+    const title = await invoke('Viewlet.getTitle', editorUid);
+    return typeof title === 'string' && title ? title : undefined;
+  } catch {
+    return undefined;
+  }
+};
+const createViewlet = async (viewletModuleId, editorUid, tabId, bounds, uri) => {
+  await invoke('Layout.createViewlet', viewletModuleId, editorUid, tabId, bounds, uri);
+  return getTitle$1(editorUid);
 };
 
-const closeTabAndSave = async (state, groupId, tabId) => {
-  const tab = findTabInState(state, groupId, tabId);
-  if (!tab) {
-    return state;
-  }
-  if (tab.editorUid !== -1 && tab.isDirty) {
-    const editorState = await saveEditor(tab.editorUid);
-    if (!editorState?.modified && tab.uri) {
-      await handleModifiedStatusChange$1(tab.uri, false);
-    }
-  }
-  return closeTab(state, groupId, tabId);
+const {
+  get,
+  getCommandIds,
+  getKeys: getKeys$1,
+  registerCommands,
+  set,
+  wrapAsyncCommand,
+  wrapGetter,
+  wrapSerialAsyncCommand,
+  wrapSerialCommand
+} = create$f();
+
+const create$2 = () => {
+  return Math.random();
 };
 
-const getFocusedGroup = state => {
+const updateTab = (state, tabId, updates) => {
   const {
     layout
   } = state;
   const {
     groups
   } = layout;
-  return groups.find(group => group.focused);
-};
-
-const closeActiveEditor = async state => {
-  const focusedGroup = getFocusedGroup(state);
-  if (!focusedGroup) {
-    return state;
-  }
-  const {
-    activeTabId
-  } = focusedGroup;
-  if (activeTabId === undefined) {
-    return state;
-  }
-  return closeTabAndSave(state, focusedGroup.id, activeTabId);
-};
-
-const closeAll$1 = state => {
-  const entries = state.layout.groups.flatMap((group, groupIndex) => {
-    return group.tabs.map((tab, tabIndex) => ({
-      group,
-      groupIndex,
-      tab,
-      tabIndex
-    }));
+  const updatedGroups = groups.map(group => {
+    const tabIndex = group.tabs.findIndex(t => t.id === tabId);
+    if (tabIndex === -1) {
+      return group;
+    }
+    const updatedTabs = group.tabs.map((tab, index) => {
+      if (index === tabIndex) {
+        return {
+          ...tab,
+          ...updates
+        };
+      }
+      return tab;
+    });
+    return {
+      ...group,
+      tabs: updatedTabs
+    };
   });
-  return withEmptyGroups(addClosedTabs(state, entries));
-};
-
-const redistributeSizesWithRemainder = groups => {
-  const baseSize = Math.floor(100 / groups.length);
-  const remainder = 100 % groups.length;
-  return groups.map((group, index) => ({
-    ...group,
-    size: baseSize + (index === groups.length - 1 ? remainder : 0)
-  }));
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      groups: updatedGroups
+    }
+  };
 };
 
-const closeEditorGroup$1 = (state, groupId) => {
-  if (Number.isNaN(groupId)) {
-    return state;
-  }
+const findTab = (state, tabId) => {
   const {
     layout
   } = state;
   const {
-    activeGroupId,
     groups
   } = layout;
-  const groupIndex = getGroupIndexById(state, groupId);
-  if (groupIndex === -1 || groups.length <= 1) {
-    return state;
+  for (const group of groups) {
+    const tab = group.tabs.find(t => t.id === tabId);
+    if (tab) {
+      return tab;
+    }
   }
-  const remainingGroups = groups.filter(group => group.id !== groupId);
-  const redistributedGroups = redistributeSizesWithRemainder(remainingGroups);
-  const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0].id : activeGroupId;
-  return withGroupsAndActiveGroup(state, redistributedGroups, newActiveGroupId);
+  return undefined;
+};
+const loadFileContent = async path => {
+  const content = await readFile(path);
+  return content;
+};
+const getLoadFileErrorMessage = error => {
+  if (!(error instanceof Error)) {
+    return 'Failed to load file content';
+  }
+  if (error.message.includes('EISDIR') || error.message.includes('illegal operation on a directory') || error.message.includes('is a directory')) {
+    return 'Expected a file but received a folder';
+  }
+  return error.message;
 };
+const loadTabContentAsync = async (tabId, path, requestId, getLatestState) => {
+  try {
+    await loadFileContent(path);
 
-const isFocused = group => {
-  return group.focused;
+    // Check for race condition: get the latest state
+    const latestState = getLatestState();
+    const latestTab = findTab(latestState, tabId);
+
+    // If the tab no longer exists, discard this result
+    if (!latestTab) {
+      return latestState;
+    }
+
+    // If the tab is no longer in loading state, discard this result (newer request started)
+    if (latestTab.loadingState !== 'loading') {
+      return latestState;
+    }
+
+    // Assign editorUid if tab doesn't have one yet
+    const editorUid = latestTab.editorUid === -1 ? create$2() : latestTab.editorUid;
+    return updateTab(latestState, tabId, {
+      editorUid,
+      errorMessage: undefined,
+      loadingState: 'loaded'
+    });
+  } catch (error) {
+    // Check for race condition before updating with error
+    const latestState = getLatestState();
+    const latestTab = findTab(latestState, tabId);
+    if (!latestTab) {
+      return latestState;
+    }
+
+    // If the tab is no longer in loading state, discard this result (newer request started)
+    if (latestTab.loadingState !== 'loading') {
+      return latestState;
+    }
+    const errorMessage = getLoadFileErrorMessage(error);
+    return updateTab(latestState, tabId, {
+      errorMessage,
+      loadingState: 'error'
+    });
+  }
 };
-const closeFocusedTab = async state => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  const focusedGroup = groups.find(isFocused);
-  if (!focusedGroup) {
+
+/**
+ * SAFE: Create viewlet for a tab (no visible side effects)
+ * Can be called eagerly when tab is opened - the viewlet loads in the background.
+ */
+const createViewletForTab = (state, tabId, viewletModuleId, bounds) => {
+  const tab = findTab(state, tabId);
+  if (!tab) {
     return state;
   }
-  const {
-    activeTabId
-  } = focusedGroup;
-  if (activeTabId === undefined) {
+
+  // If tab already has an editorUid or is loading/loaded, don't recreate
+  if (tab.editorUid !== -1 || tab.loadingState === 'loading' || tab.loadingState === 'loaded') {
     return state;
   }
-  return closeTabAndSave(state, focusedGroup.id, activeTabId);
+  const editorUid = create$2();
+  const newState = updateTab(state, tabId, {
+    editorUid
+  });
+  return newState;
 };
 
-const closeOtherTabs = (state, groupId) => {
+/**
+ * Called when switching tabs.
+ * With reference nodes, attachment/detachment is handled automatically by virtual DOM rendering.
+ * No attach/detach commands needed - virtual DOM will render the correct reference at each position.
+ */
+const switchViewlet = (state, fromTabId, toTabId) => {
+  // No commands needed - virtual DOM reference nodes handle attachment automatically
+  // Virtual DOM will:
+  // 1. Remove the old reference node from the previous active tab
+  // 2. Add the new reference node for the now-active tab
+  // This achieves the same effect as detach/attach without explicit commands
+
+  return {
+    commands: [],
+    newState: state
+  };
+};
+
+const findTabByEditorUid = (state, editorUid) => {
   const {
     layout
   } = state;
   const {
-    activeGroupId,
     groups
   } = layout;
-  const targetGroupId = groupId ?? activeGroupId;
-  if (targetGroupId === undefined) {
-    return state;
-  }
-  const group = groups.find(g => g.id === targetGroupId);
-  if (!group) {
-    return state;
-  }
-  const {
-    activeTabId
-  } = group;
-  if (activeTabId === undefined) {
-    return state;
+  for (const group of groups) {
+    const tab = group.tabs.find(t => t.editorUid === editorUid);
+    if (tab) {
+      return tab;
+    }
   }
-  const closedTabs = group.tabs.map((tab, tabIndex) => ({
-    group,
-    groupIndex: groups.findIndex(g => g.id === targetGroupId),
-    tab,
-    tabIndex
-  })).filter(entry => entry.tab.id !== activeTabId);
-  const newGroups = groups.map(g => {
-    if (g.id === targetGroupId) {
-      const newTabs = g.tabs.filter(tab => tab.id === activeTabId);
-      return {
-        ...g,
-        activeTabId,
-        isEmpty: newTabs.length === 0,
-        tabs: newTabs
-      };
-    }
-    return g;
-  });
-  return {
-    ...addClosedTabs(state, closedTabs),
-    layout: {
-      ...layout,
-      groups: newGroups
-    }
-  };
+  return undefined;
 };
 
-const getNextActiveTabId = (tabs, newTabs, activeTabId) => {
-  if (activeTabId === undefined) {
-    return undefined;
-  }
-  if (newTabs.some(tab => tab.id === activeTabId)) {
-    return activeTabId;
+/**
+ * Called when renderer reports viewlet finished creating.
+ * With reference nodes, attachment is handled automatically by virtual DOM rendering.
+ * No commands needed - state update is sufficient.
+ */
+const handleViewletReady = (state, editorUid, title) => {
+  if (editorUid === -1) {
+    throw new Error('Invalid editorUid -1');
   }
-  const activeTabIndex = tabs.findIndex(tab => tab.id === activeTabId);
-  if (activeTabIndex === -1 || newTabs.length === 0) {
-    return undefined;
+  // Find the tab by viewletRequestId
+  const tab = findTabByEditorUid(state, editorUid);
+  if (!tab) {
+    // Tab was closed, dispose viewlet
+    return state;
   }
-  return newTabs[Math.min(activeTabIndex, newTabs.length - 1)].id;
+
+  // Mark viewlet as ready and set instance id
+  // Reference nodes will handle rendering at the correct position automatically
+  const newState = updateTab(state, tab.id, {
+    editorUid,
+    loadingState: 'loaded',
+    ...(title && {
+      title
+    })
+  });
+
+  // No attach commands needed - virtual DOM reference nodes handle positioning
+  return newState;
 };
-const closeSavedInGroup = group => {
-  const {
-    activeTabId,
-    tabs
-  } = group;
-  const newTabs = tabs.filter(tab => tab.isDirty);
-  if (newTabs.length === tabs.length) {
-    return group;
+
+/**
+ * Dispose viewlet when tab is closed.
+ */
+const disposeViewletForTab = (state, tabId) => {
+  const tab = findTab(state, tabId);
+  if (!tab || tab.editorUid === -1) {
+    return {
+      commands: [],
+      newState: state
+    };
   }
-  const newActiveTabId = getNextActiveTabId(tabs, newTabs, activeTabId);
+  const commands = [{
+    instanceId: tab.editorUid,
+    type: 'dispose'
+  }];
   return {
-    ...group,
-    activeTabId: newActiveTabId,
-    isEmpty: newTabs.length === 0,
-    tabs: newTabs
+    commands,
+    newState: state
   };
 };
-const closeSaved$1 = state => {
+
+const handleCreate = async command => {
+  // Safe to call - no visible side effects
+
+  const title = await createViewlet(command.viewletModuleId, command.editorUid, command.tabId, command.bounds, command.uri || '');
+
+  // After viewlet is created, mark it as ready
+  // Attachment is handled automatically by virtual DOM reference nodes
   const {
-    groups
-  } = state.layout;
-  const closedTabs = groups.flatMap((group, groupIndex) => {
-    return group.tabs.map((tab, tabIndex) => ({
-      group,
-      groupIndex,
-      tab,
-      tabIndex
-    })).filter(entry => !entry.tab.isDirty);
-  });
-  const newGroups = groups.map(closeSavedInGroup);
-  return withGroups(addClosedTabs(state, closedTabs), newGroups);
+    newState: state,
+    oldState
+  } = get(command.uid);
+  const readyState = handleViewletReady(state, command.editorUid, title);
+  set(command.uid, oldState, readyState);
+  return readyState;
 };
 
-const closeFirstTabByUri = (state, uri) => {
-  const matchingGroup = state.layout.groups.find(group => {
-    return group.tabs.some(tab => tab.uri === uri);
-  });
-  const matchingTab = matchingGroup?.tabs.find(tab => tab.uri === uri);
-  if (!matchingGroup || !matchingTab) {
-    return undefined;
-  }
-  return closeTab(state, matchingGroup.id, matchingTab.id);
+const handleDetach = async command => {
+  // Hides viewlet but keeps it alive
+
+  await invoke('Viewlet.detach', command.instanceId);
 };
-const closeTabsByUris = (state, uris) => {
-  let currentState = state;
-  for (const uri of uris) {
-    let nextState = closeFirstTabByUri(currentState, uri);
-    while (nextState) {
-      currentState = nextState;
-      nextState = closeFirstTabByUri(currentState, uri);
-    }
-  }
-  return currentState;
+
+const handleDispose = async command => {
+  // Fully destroys viewlet
+
+  await invoke('Viewlet.dispose', command.instanceId);
 };
 
-const getGroupById = (state, groupId) => {
-  return state.layout.groups.find(group => group.id === groupId);
+const handleSetBounds = async command => {
+  await invoke('Viewlet.setBounds', command.instanceId, command.bounds);
 };
 
-const closeTabsRight = (state, groupId) => {
+const executeViewletCommand = async command => {
+  switch (command.type) {
+    case 'attach':
+      await handleAttach(command);
+      return;
+    case 'create':
+      await handleCreate(command);
+      return;
+    case 'detach':
+      await handleDetach(command);
+      return;
+    case 'dispose':
+      await handleDispose(command);
+      return;
+    case 'setBounds':
+      await handleSetBounds(command);
+      return;
+  }
+};
+const executeViewletCommands = async commands => {
+  for (const command of commands) {
+    await executeViewletCommand(command);
+  }
+};
+
+const findTabInState = (state, groupId, tabId) => {
   const {
     layout
   } = state;
-  const {
-    groups
-  } = layout;
-  const group = getGroupById(state, groupId);
-  if (!group) {
-    return state;
-  }
-  const {
-    activeTabId,
-    tabs
-  } = group;
-  if (activeTabId === undefined) {
-    return state;
+  const group = layout.groups.find(g => g.id === groupId);
+  return group?.tabs.find(t => t.id === tabId);
+};
+
+const closeTabWithViewlet = async (state, groupId, tabId) => {
+  const tab = findTabInState(state, groupId, tabId);
+  const commands = [];
+  if (tab && tab.editorUid !== -1) {
+    const {
+      commands: disposeCommands
+    } = disposeViewletForTab(state, tabId);
+    commands.push(...disposeCommands);
+  }
+  const newState = closeTab(state, groupId, tabId);
+  const group = state.layout.groups.find(g => g.id === groupId);
+  const wasActiveTab = group?.activeTabId === tabId;
+  if (wasActiveTab) {
+    const newGroup = newState.layout.groups.find(g => g.id === groupId);
+    const newActiveTabId = newGroup?.activeTabId;
+    if (newActiveTabId !== undefined) {
+      const {
+        commands: switchCommands,
+        newState: switchedState
+      } = switchViewlet(newState);
+      commands.push(...switchCommands);
+      await executeViewletCommands(commands);
+      return switchedState;
+    }
   }
-  const activeTabIndex = tabs.findIndex(tab => tab.id === activeTabId);
-  if (activeTabIndex === -1) {
-    return state;
+  if (commands.length > 0) {
+    await executeViewletCommands(commands);
   }
-  const newTabs = tabs.slice(0, activeTabIndex + 1);
-  if (newTabs.length === tabs.length) {
+  return newState;
+};
+
+const saveEditor = async editorUid => {
+  return invoke('Editor.save', editorUid);
+};
+
+const closeTabAndSave = async (state, groupId, tabId) => {
+  const tab = findTabInState(state, groupId, tabId);
+  if (!tab) {
     return state;
   }
-  const groupIndex = groups.findIndex(g => g.id === groupId);
-  const closedTabs = tabs.slice(activeTabIndex + 1).map((tab, index) => ({
-    group,
-    groupIndex,
-    tab,
-    tabIndex: activeTabIndex + index + 1
-  }));
-  const newGroups = groups.map(g => {
-    if (g.id === groupId) {
-      return {
-        ...g,
-        isEmpty: newTabs.length === 0,
-        tabs: newTabs
-      };
+  if (tab.editorUid !== -1 && tab.isDirty) {
+    const editorState = await saveEditor(tab.editorUid);
+    if (!editorState?.modified && tab.uri) {
+      await handleModifiedStatusChange$1(tab.uri, false);
     }
-    return g;
-  });
-  return withGroups(addClosedTabs(state, closedTabs), newGroups);
+  }
+  if (tab.uri?.startsWith('simple-browser://')) {
+    return closeTabWithViewlet(state, groupId, tabId);
+  }
+  return closeTab(state, groupId, tabId);
 };
 
-const findGroupById = (state, groupId) => {
+const getFocusedGroup = state => {
   const {
     layout
   } = state;
   const {
     groups
   } = layout;
-  return groups.find(group => group.id === groupId);
+  return groups.find(group => group.focused);
 };
 
-const copyIntoNewWindow$1 = async state => {
-  const {
-    activeGroupId
-  } = state.layout;
-  const group = findGroupById(state, activeGroupId ?? 0);
-  if (!group) {
+const closeActiveEditor = async state => {
+  const focusedGroup = getFocusedGroup(state);
+  if (!focusedGroup) {
     return state;
   }
   const {
     activeTabId
-  } = group;
+  } = focusedGroup;
   if (activeTabId === undefined) {
     return state;
   }
-  const tab = group.tabs.find(tab => tab.id === activeTabId);
-  if (!tab?.uri) {
-    return state;
+  return closeTabAndSave(state, focusedGroup.id, activeTabId);
+};
+
+const disposeEditors = async editorUids => {
+  // Dispose all child viewlets in the renderer worker
+  for (const editorUid of editorUids) {
+    try {
+      await invoke('Viewlet.dispose', editorUid);
+    } catch {
+      // Silently ignore errors during disposal
+      // Viewlet may already be disposed or renderer worker may not be available
+    }
   }
-  await invoke('ElectronWindow.openNewWithUri', tab.uri);
-  return state;
 };
 
-const copyPath$1 = async (state, path) => {
-  string(path);
-  await writeClipBoardText(path);
-  return state;
+const closeAll$1 = async state => {
+  const editorUids = state.layout.groups.flatMap(group => group.tabs.map(tab => tab.editorUid)).filter(editorUid => editorUid !== -1);
+  await disposeEditors(editorUids);
+  const entries = state.layout.groups.flatMap((group, groupIndex) => {
+    return group.tabs.map((tab, tabIndex) => ({
+      group,
+      groupIndex,
+      tab,
+      tabIndex
+    }));
+  });
+  return withEmptyGroups(addClosedTabs(state, entries));
 };
 
-const copyRelativePath$1 = async (state, path) => {
-  string(path);
-  // TODO use clipboard worker
-  const relativePath = await invoke('Workspace.pathBaseName', path);
-  await invoke('ClipBoard.writeText', relativePath);
-  return state;
+const redistributeSizesWithRemainder = groups => {
+  const baseSize = Math.floor(100 / groups.length);
+  const remainder = 100 % groups.length;
+  return groups.map((group, index) => ({
+    ...group,
+    size: baseSize + (index === groups.length - 1 ? remainder : 0)
+  }));
 };
 
-const Horizontal = 1;
-const Vertical = 2;
-const isLayoutDirection = direction => {
-  return direction === Horizontal || direction === Vertical;
-};
-const normalizeLayoutDirection = direction => {
-  if (isLayoutDirection(direction)) {
-    return direction;
-  }
-  if (direction === 'horizontal') {
-    return Horizontal;
+const closeEditorGroup$1 = (state, groupId) => {
+  if (Number.isNaN(groupId)) {
+    return state;
   }
-  if (direction === 'vertical') {
-    return Vertical;
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const groupIndex = getGroupIndexById(state, groupId);
+  if (groupIndex === -1 || groups.length <= 1) {
+    return state;
   }
-  return undefined;
-};
-
-const {
-  get,
-  getCommandIds,
-  getKeys: getKeys$1,
-  registerCommands,
-  set,
-  wrapAsyncCommand,
-  wrapGetter,
-  wrapSerialAsyncCommand,
-  wrapSerialCommand
-} = create$f();
-
-const create$2 = (uid, uri, x, y, width, height, platform, assetDir, tabHeight = 35) => {
-  const state = {
-    assetDir,
-    closedTabs: [],
-    fileIconCache: {},
-    height,
-    homeDirUri: '',
-    iframes: [],
-    initial: true,
-    layout: {
-      activeGroupId: undefined,
-      direction: Horizontal,
-      groups: []
-    },
-    maxOpenEditorGroups: Infinity,
-    maxOpenEditors: Infinity,
-    minGroupHeightPx: 80,
-    minGroupWidthPx: 250,
-    platform,
-    splitButtonEnabled: false,
-    tabHeight,
-    uid,
-    width,
-    workspaceuri: uri,
-    x,
-    y
-  };
-  set(uid, state, state);
-};
-
-const isEqual$1 = (oldState, newState) => {
-  return false;
+  const remainingGroups = groups.filter(group => group.id !== groupId);
+  const redistributedGroups = redistributeSizesWithRemainder(remainingGroups);
+  const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0].id : activeGroupId;
+  return withGroupsAndActiveGroup(state, redistributedGroups, newActiveGroupId);
 };
 
-const isEqual = (oldState, newState) => {
-  return oldState.layout === newState.layout;
+const isFocused = group => {
+  return group.focused;
 };
-
-const RenderItems = 4;
-const RenderCss = 10;
-const RenderIncremental = 11;
-
-const modules = [isEqual, isEqual$1];
-const numbers = [RenderIncremental, RenderCss];
-
-const diff = (oldState, newState) => {
-  const diffResult = [];
-  for (let i = 0; i < modules.length; i++) {
-    const fn = modules[i];
-    if (!fn(oldState, newState)) {
-      diffResult.push(numbers[i]);
-    }
+const closeFocusedTab = async state => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const focusedGroup = groups.find(isFocused);
+  if (!focusedGroup) {
+    return state;
   }
-  return diffResult;
-};
-
-const diff2 = uid => {
   const {
-    newState,
-    oldState
-  } = get(uid);
-  const result = diff(oldState, newState);
-  return result;
-};
-
-const handleAttach = async command => {
-  // TODO find a better way to append editors
-  const parentNodeSelector = '.editor-groups-container, .EditorGroup';
-  await invoke('Layout.attachViewlet', parentNodeSelector, command.instanceId);
-};
-
-const getTitle$1 = async editorUid => {
-  try {
-    const title = await invoke('Viewlet.getTitle', editorUid);
-    return typeof title === 'string' && title ? title : undefined;
-  } catch {
-    return undefined;
+    activeTabId
+  } = focusedGroup;
+  if (activeTabId === undefined) {
+    return state;
   }
-};
-const createViewlet = async (viewletModuleId, editorUid, tabId, bounds, uri) => {
-  await invoke('Layout.createViewlet', viewletModuleId, editorUid, tabId, bounds, uri);
-  return getTitle$1(editorUid);
-};
-
-const create$1 = () => {
-  return Math.random();
+  return closeTabAndSave(state, focusedGroup.id, activeTabId);
 };
 
-const updateTab = (state, tabId, updates) => {
+const closeOtherTabs = (state, groupId) => {
   const {
     layout
   } = state;
   const {
+    activeGroupId,
     groups
   } = layout;
-  const updatedGroups = groups.map(group => {
-    const tabIndex = group.tabs.findIndex(t => t.id === tabId);
-    if (tabIndex === -1) {
-      return group;
+  const targetGroupId = groupId ?? activeGroupId;
+  if (targetGroupId === undefined) {
+    return state;
+  }
+  const group = groups.find(g => g.id === targetGroupId);
+  if (!group) {
+    return state;
+  }
+  const {
+    activeTabId
+  } = group;
+  if (activeTabId === undefined) {
+    return state;
+  }
+  const closedTabs = group.tabs.map((tab, tabIndex) => ({
+    group,
+    groupIndex: groups.findIndex(g => g.id === targetGroupId),
+    tab,
+    tabIndex
+  })).filter(entry => entry.tab.id !== activeTabId);
+  const newGroups = groups.map(g => {
+    if (g.id === targetGroupId) {
+      const newTabs = g.tabs.filter(tab => tab.id === activeTabId);
+      return {
+        ...g,
+        activeTabId,
+        isEmpty: newTabs.length === 0,
+        tabs: newTabs
+      };
     }
-    const updatedTabs = group.tabs.map((tab, index) => {
-      if (index === tabIndex) {
-        return {
-          ...tab,
-          ...updates
-        };
-      }
-      return tab;
-    });
-    return {
-      ...group,
-      tabs: updatedTabs
-    };
+    return g;
   });
   return {
-    ...state,
+    ...addClosedTabs(state, closedTabs),
     layout: {
       ...layout,
-      groups: updatedGroups
+      groups: newGroups
     }
   };
 };
 
-const findTab = (state, tabId) => {
-  const {
-    layout
-  } = state;
+const getNextActiveTabId = (tabs, newTabs, activeTabId) => {
+  if (activeTabId === undefined) {
+    return undefined;
+  }
+  if (newTabs.some(tab => tab.id === activeTabId)) {
+    return activeTabId;
+  }
+  const activeTabIndex = tabs.findIndex(tab => tab.id === activeTabId);
+  if (activeTabIndex === -1 || newTabs.length === 0) {
+    return undefined;
+  }
+  return newTabs[Math.min(activeTabIndex, newTabs.length - 1)].id;
+};
+const closeSavedInGroup = group => {
   const {
-    groups
-  } = layout;
-  for (const group of groups) {
-    const tab = group.tabs.find(t => t.id === tabId);
-    if (tab) {
-      return tab;
-    }
+    activeTabId,
+    tabs
+  } = group;
+  const newTabs = tabs.filter(tab => tab.isDirty);
+  if (newTabs.length === tabs.length) {
+    return group;
   }
-  return undefined;
+  const newActiveTabId = getNextActiveTabId(tabs, newTabs, activeTabId);
+  return {
+    ...group,
+    activeTabId: newActiveTabId,
+    isEmpty: newTabs.length === 0,
+    tabs: newTabs
+  };
 };
-const loadFileContent = async path => {
-  const content = await readFile(path);
-  return content;
+const closeSaved$1 = state => {
+  const {
+    groups
+  } = state.layout;
+  const closedTabs = groups.flatMap((group, groupIndex) => {
+    return group.tabs.map((tab, tabIndex) => ({
+      group,
+      groupIndex,
+      tab,
+      tabIndex
+    })).filter(entry => !entry.tab.isDirty);
+  });
+  const newGroups = groups.map(closeSavedInGroup);
+  return withGroups(addClosedTabs(state, closedTabs), newGroups);
 };
-const getLoadFileErrorMessage = error => {
-  if (!(error instanceof Error)) {
-    return 'Failed to load file content';
-  }
-  if (error.message.includes('EISDIR') || error.message.includes('illegal operation on a directory') || error.message.includes('is a directory')) {
-    return 'Expected a file but received a folder';
+
+const closeFirstTabByUri = (state, uri) => {
+  const matchingGroup = state.layout.groups.find(group => {
+    return group.tabs.some(tab => tab.uri === uri);
+  });
+  const matchingTab = matchingGroup?.tabs.find(tab => tab.uri === uri);
+  if (!matchingGroup || !matchingTab) {
+    return undefined;
   }
-  return error.message;
+  return closeTab(state, matchingGroup.id, matchingTab.id);
 };
-const loadTabContentAsync = async (tabId, path, requestId, getLatestState) => {
-  try {
-    await loadFileContent(path);
-
-    // Check for race condition: get the latest state
-    const latestState = getLatestState();
-    const latestTab = findTab(latestState, tabId);
-
-    // If the tab no longer exists, discard this result
-    if (!latestTab) {
-      return latestState;
-    }
-
-    // If the tab is no longer in loading state, discard this result (newer request started)
-    if (latestTab.loadingState !== 'loading') {
-      return latestState;
-    }
-
-    // Assign editorUid if tab doesn't have one yet
-    const editorUid = latestTab.editorUid === -1 ? create$1() : latestTab.editorUid;
-    return updateTab(latestState, tabId, {
-      editorUid,
-      errorMessage: undefined,
-      loadingState: 'loaded'
-    });
-  } catch (error) {
-    // Check for race condition before updating with error
-    const latestState = getLatestState();
-    const latestTab = findTab(latestState, tabId);
-    if (!latestTab) {
-      return latestState;
-    }
-
-    // If the tab is no longer in loading state, discard this result (newer request started)
-    if (latestTab.loadingState !== 'loading') {
-      return latestState;
+const closeTabsByUris = (state, uris) => {
+  let currentState = state;
+  for (const uri of uris) {
+    let nextState = closeFirstTabByUri(currentState, uri);
+    while (nextState) {
+      currentState = nextState;
+      nextState = closeFirstTabByUri(currentState, uri);
     }
-    const errorMessage = getLoadFileErrorMessage(error);
-    return updateTab(latestState, tabId, {
-      errorMessage,
-      loadingState: 'error'
-    });
   }
+  return currentState;
 };
 
-/**
- * SAFE: Create viewlet for a tab (no visible side effects)
- * Can be called eagerly when tab is opened - the viewlet loads in the background.
- */
-const createViewletForTab = (state, tabId, viewletModuleId, bounds) => {
-  const tab = findTab(state, tabId);
-  if (!tab) {
+const getGroupById = (state, groupId) => {
+  return state.layout.groups.find(group => group.id === groupId);
+};
+
+const closeTabsRight = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const group = getGroupById(state, groupId);
+  if (!group) {
     return state;
   }
-
-  // If tab already has an editorUid or is loading/loaded, don't recreate
-  if (tab.editorUid !== -1 || tab.loadingState === 'loading' || tab.loadingState === 'loaded') {
+  const {
+    activeTabId,
+    tabs
+  } = group;
+  if (activeTabId === undefined) {
     return state;
   }
-  const editorUid = create$1();
-  const newState = updateTab(state, tabId, {
-    editorUid
+  const activeTabIndex = tabs.findIndex(tab => tab.id === activeTabId);
+  if (activeTabIndex === -1) {
+    return state;
+  }
+  const newTabs = tabs.slice(0, activeTabIndex + 1);
+  if (newTabs.length === tabs.length) {
+    return state;
+  }
+  const groupIndex = groups.findIndex(g => g.id === groupId);
+  const closedTabs = tabs.slice(activeTabIndex + 1).map((tab, index) => ({
+    group,
+    groupIndex,
+    tab,
+    tabIndex: activeTabIndex + index + 1
+  }));
+  const newGroups = groups.map(g => {
+    if (g.id === groupId) {
+      return {
+        ...g,
+        isEmpty: newTabs.length === 0,
+        tabs: newTabs
+      };
+    }
+    return g;
   });
-  return newState;
-};
-
-/**
- * Called when switching tabs.
- * With reference nodes, attachment/detachment is handled automatically by virtual DOM rendering.
- * No attach/detach commands needed - virtual DOM will render the correct reference at each position.
- */
-const switchViewlet = (state, fromTabId, toTabId) => {
-  // No commands needed - virtual DOM reference nodes handle attachment automatically
-  // Virtual DOM will:
-  // 1. Remove the old reference node from the previous active tab
-  // 2. Add the new reference node for the now-active tab
-  // This achieves the same effect as detach/attach without explicit commands
-
-  return {
-    commands: [],
-    newState: state
-  };
+  return withGroups(addClosedTabs(state, closedTabs), newGroups);
 };
 
-const findTabByEditorUid = (state, editorUid) => {
+const findGroupById = (state, groupId) => {
   const {
     layout
   } = state;
   const {
     groups
   } = layout;
-  for (const group of groups) {
-    const tab = group.tabs.find(t => t.editorUid === editorUid);
-    if (tab) {
-      return tab;
-    }
-  }
-  return undefined;
+  return groups.find(group => group.id === groupId);
 };
 
-/**
- * Called when renderer reports viewlet finished creating.
- * With reference nodes, attachment is handled automatically by virtual DOM rendering.
- * No commands needed - state update is sufficient.
- */
-const handleViewletReady = (state, editorUid, title) => {
-  if (editorUid === -1) {
-    throw new Error('Invalid editorUid -1');
+const copyIntoNewWindow$1 = async state => {
+  const {
+    activeGroupId
+  } = state.layout;
+  const group = findGroupById(state, activeGroupId ?? 0);
+  if (!group) {
+    return state;
   }
-  // Find the tab by viewletRequestId
-  const tab = findTabByEditorUid(state, editorUid);
-  if (!tab) {
-    // Tab was closed, dispose viewlet
+  const {
+    activeTabId
+  } = group;
+  if (activeTabId === undefined) {
     return state;
   }
-
-  // Mark viewlet as ready and set instance id
-  // Reference nodes will handle rendering at the correct position automatically
-  const newState = updateTab(state, tab.id, {
-    editorUid,
-    loadingState: 'loaded',
-    ...(title && {
-      title
-    })
-  });
-
-  // No attach commands needed - virtual DOM reference nodes handle positioning
-  return newState;
+  const tab = group.tabs.find(tab => tab.id === activeTabId);
+  if (!tab?.uri) {
+    return state;
+  }
+  await invoke('ElectronWindow.openNewWithUri', tab.uri);
+  return state;
 };
 
-const handleCreate = async command => {
-  // Safe to call - no visible side effects
-
-  const title = await createViewlet(command.viewletModuleId, command.editorUid, command.tabId, command.bounds, command.uri || '');
-
-  // After viewlet is created, mark it as ready
-  // Attachment is handled automatically by virtual DOM reference nodes
-  const {
-    newState: state,
-    oldState
-  } = get(command.uid);
-  const readyState = handleViewletReady(state, command.editorUid, title);
-  set(command.uid, oldState, readyState);
-  return readyState;
+const copyPath$1 = async (state, path) => {
+  string(path);
+  await writeClipBoardText(path);
+  return state;
 };
 
-const handleDetach = async command => {
-  // Hides viewlet but keeps it alive
+const copyRelativePath$1 = async (state, path) => {
+  string(path);
+  // TODO use clipboard worker
+  const relativePath = await invoke('Workspace.pathBaseName', path);
+  await invoke('ClipBoard.writeText', relativePath);
+  return state;
+};
 
-  await invoke('Viewlet.detach', command.instanceId);
+const Horizontal = 1;
+const Vertical = 2;
+const isLayoutDirection = direction => {
+  return direction === Horizontal || direction === Vertical;
+};
+const normalizeLayoutDirection = direction => {
+  if (isLayoutDirection(direction)) {
+    return direction;
+  }
+  if (direction === 'horizontal') {
+    return Horizontal;
+  }
+  if (direction === 'vertical') {
+    return Vertical;
+  }
+  return undefined;
 };
 
-const handleDispose = async command => {
-  // Fully destroys viewlet
+const create$1 = (uid, uri, x, y, width, height, platform, assetDir, tabHeight = 35) => {
+  const state = {
+    assetDir,
+    closedTabs: [],
+    fileIconCache: {},
+    height,
+    homeDirUri: '',
+    iframes: [],
+    initial: true,
+    layout: {
+      activeGroupId: undefined,
+      direction: Horizontal,
+      groups: []
+    },
+    maxOpenEditorGroups: Infinity,
+    maxOpenEditors: Infinity,
+    minGroupHeightPx: 80,
+    minGroupWidthPx: 250,
+    platform,
+    splitButtonEnabled: false,
+    tabHeight,
+    uid,
+    width,
+    workspaceuri: uri,
+    x,
+    y
+  };
+  set(uid, state, state);
+};
 
-  await invoke('Viewlet.dispose', command.instanceId);
+const isEqual$1 = (oldState, newState) => {
+  return false;
 };
 
-const handleSetBounds = async command => {
-  await invoke('Viewlet.setBounds', command.instanceId, command.bounds);
+const isEqual = (oldState, newState) => {
+  return oldState.layout === newState.layout;
 };
 
-const executeViewletCommand = async command => {
-  switch (command.type) {
-    case 'attach':
-      await handleAttach(command);
-      return;
-    case 'create':
-      await handleCreate(command);
-      return;
-    case 'detach':
-      await handleDetach(command);
-      return;
-    case 'dispose':
-      await handleDispose(command);
-      return;
-    case 'setBounds':
-      await handleSetBounds(command);
-      return;
+const RenderItems = 4;
+const RenderCss = 10;
+const RenderIncremental = 11;
+
+const modules = [isEqual, isEqual$1];
+const numbers = [RenderIncremental, RenderCss];
+
+const diff = (oldState, newState) => {
+  const diffResult = [];
+  for (let i = 0; i < modules.length; i++) {
+    const fn = modules[i];
+    if (!fn(oldState, newState)) {
+      diffResult.push(numbers[i]);
+    }
   }
+  return diffResult;
 };
-const executeViewletCommands = async commands => {
-  for (const command of commands) {
-    await executeViewletCommand(command);
-  }
+
+const diff2 = uid => {
+  const {
+    newState,
+    oldState
+  } = get(uid);
+  const result = diff(oldState, newState);
+  return result;
 };
 
 const requestIdState = {
@@ -2609,6 +2685,7 @@ const getEditorInputEditorType = editorInput => {
     case 'process-explorer':
     case 'running-extensions':
     case 'video':
+    case 'webview':
       return 'custom';
     case 'editor':
       return 'text';
@@ -2622,6 +2699,7 @@ const getEditorInputUri = editorInput => {
     case 'editor':
     case 'image':
     case 'video':
+    case 'webview':
       return editorInput.uri;
     case 'extension-detail-view':
       return `extension-detail://${editorInput.extensionId}`;
@@ -2726,6 +2804,9 @@ const getNormalizedEditorInput = tab => {
     editorInput: tabEditorInput,
     uri: tabUri
   } = tab ?? {};
+  if (tabEditorInput?.type === 'editor' && tabEditorInput.forceText || tabEditorInput?.type === 'webview') {
+    return tabEditorInput;
+  }
   let uri;
   if (typeof tabUri === 'string') {
     uri = tabUri;
@@ -2854,11 +2935,11 @@ const getSelectedTabBounds = state => {
   };
 };
 
-const getViewletModuleId$1 = async uri => {
+const getViewletModuleId$1 = async (uri, opener) => {
   // Query RendererWorker for viewlet module ID (optional, may fail in tests)
   let viewletModuleId;
   try {
-    viewletModuleId = await invoke('Layout.getModuleId', uri);
+    viewletModuleId = opener === undefined ? await invoke('Layout.getModuleId', uri) : await invoke('Layout.getModuleId', uri, opener);
   } catch {
     // Viewlet creation is optional - silently ignore if RendererWorker isn't available
   }
@@ -2877,15 +2958,18 @@ const getViewletModuleIdForEditorInput = async editorInput => {
     case 'diff-editor':
       return DiffEditor;
     case 'editor':
+      return editorInput.forceText ? EditorText : getViewletModuleId$1(editorInput.uri);
+    case 'extension-detail-view':
+      return ExtensionDetail;
     case 'image':
     case 'video':
       return getViewletModuleId$1(editorInput.uri);
-    case 'extension-detail-view':
-      return ExtensionDetail;
     case 'process-explorer':
       return ProcessExplorer;
     case 'running-extensions':
       return RunningExtensions;
+    case 'webview':
+      return getViewletModuleId$1(editorInput.uri, editorInput.providerId);
   }
 };
 
@@ -3434,6 +3518,7 @@ const getEditorInputTitle = editorInput => {
     case 'editor':
     case 'image':
     case 'video':
+    case 'webview':
       return getLabel(editorInput.uri);
     case 'extension-detail-view':
       return editorInput.extensionId;
@@ -3485,9 +3570,9 @@ const createEmptyGroup$1 = (state, uri, requestId, preview = false, title = getL
   const {
     groups
   } = layout;
-  const groupId = create$1();
-  const tabId = create$1();
-  const editorUid = create$1();
+  const groupId = create$2();
+  const tabId = create$2();
+  const editorUid = create$2();
   const newTab = {
     editorInput,
     editorType,
@@ -3528,7 +3613,7 @@ const openTab = (state, groupId, tab) => {
   };
   const newTab = 'id' in normalizedTab && normalizedTab.id !== undefined ? normalizedTab : {
     ...normalizedTab,
-    id: create$1()
+    id: create$2()
   };
   const {
     layout
@@ -3615,8 +3700,8 @@ const ensureActiveGroup = (state, uri, preview = false, title = getLabel(uri), e
     }
 
     // Create a new tab with the URI in the active group
-    const tabId = create$1();
-    const editorUid = create$1();
+    const tabId = create$2();
+    const editorUid = create$2();
     const newTab = {
       editorInput,
       editorType,
@@ -4149,7 +4234,7 @@ const splitEditorGroup$1 = (state, groupId, direction) => {
   if (!sourceGroup) {
     return state;
   }
-  const newGroupId = create$1();
+  const newGroupId = create$2();
   const splitLayoutDirection = getSplitLayoutDirection(direction);
   const baseNewGroup = {
     activeTabId: undefined,
@@ -4366,8 +4451,8 @@ const newFile = async state => {
   getActiveTabId(newState);
 
   // Create a new empty tab
-  const tabId = create$1();
-  const editorUid = create$1();
+  const tabId = create$2();
+  const editorUid = create$2();
   const newTab = {
     editorType: 'text',
     editorUid,
@@ -4861,7 +4946,7 @@ const createViewlets = async (layout, viewletModuleIds, bounds) => {
   for (const group of layout.groups) {
     const activeTab = group.tabs.find(tab => tab.id === group.activeTabId);
     if (activeTab && viewletModuleIds[activeTab.id]) {
-      const editorUid = activeTab.editorUid === -1 ? create$1() : activeTab.editorUid;
+      const editorUid = activeTab.editorUid === -1 ? create$2() : activeTab.editorUid;
       editorUids[activeTab.id] = editorUid;
       const title = await createViewlet(viewletModuleIds[activeTab.id], editorUid, activeTab.id, bounds, activeTab.uri);
       if (title) {
@@ -5049,15 +5134,15 @@ const getMenuEntryArgs = groupId => {
 };
 
 const emptyObject = {};
-const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
 const i18nString = (key, placeholders = emptyObject) => {
   if (placeholders === emptyObject) {
     return key;
   }
-  const replacer = (match, rest) => {
-    return placeholders[rest];
-  };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
+  let result = key;
+  for (const [placeholder, replacement] of Object.entries(placeholders)) {
+    result = result.split(`{${placeholder}}`).join(String(replacement));
+  }
+  return result;
 };
 
 const Close = 'Close';
@@ -5141,7 +5226,7 @@ const copyPath = () => {
 const copyRelativePath = () => {
   return i18nString(CopyRelativePath);
 };
-const reopenEditorWith = () => {
+const reopenEditorWith$1 = () => {
   return i18nString(ReopenEditorWith);
 };
 const share = () => {
@@ -5308,10 +5393,10 @@ const getMenuEntries$1 = state => {
     id: 'copyRelativePath',
     label: copyRelativePath()
   }, menuEntrySeparator, {
-    command: '',
+    command: 'Main.reopenEditorWith',
     flags: None,
     id: 'reopenEditorWith',
-    label: reopenEditorWith()
+    label: reopenEditorWith$1()
   }, menuEntrySeparator, {
     command: '',
     flags: None,
@@ -6396,6 +6481,101 @@ const renderEventListeners = () => {
   }];
 };
 
+const getViewProviderEntries = async uri => {
+  const textEditorEntry = {
+    id: 'editor',
+    label: 'Text Editor',
+    type: 'editor'
+  };
+  try {
+    const providers = await invoke('WebView.getWebViews');
+    const matchingProviders = providers.filter(provider => provider?.id && provider.selector?.some(selector => uri.endsWith(selector)));
+    return [textEditorEntry, ...matchingProviders.map(provider => {
+      const titleElement = provider.elements?.find(element => element.type === 'title');
+      return {
+        id: provider.id,
+        label: provider.name || provider.title || titleElement?.value || provider.id,
+        type: 'webview'
+      };
+    })];
+  } catch {
+    return [textEditorEntry];
+  }
+};
+const reopenEditorWith = async context => {
+  const initialState = context.getState();
+  const {
+    activeGroupId,
+    groups
+  } = initialState.layout;
+  const activeGroup = groups.find(group => group.id === activeGroupId);
+  const initialTab = activeGroup?.tabs.find(tab => tab.id === activeGroup.activeTabId);
+  if (!initialTab?.uri) {
+    return;
+  }
+  const entries = await getViewProviderEntries(initialTab.uri);
+  const items = entries.map(entry => ({
+    description: '',
+    label: entry.label,
+    value: entry
+  }));
+  const selected = await invoke('ExtensionHostQuickPick.showQuickPick', {
+    items,
+    placeholder: 'Select Editor'
+  });
+  if (!selected) {
+    return;
+  }
+  const editorInput = selected.type === 'editor' ? {
+    forceText: true,
+    type: 'editor',
+    uri: initialTab.uri
+  } : {
+    providerId: selected.id,
+    type: 'webview',
+    uri: initialTab.uri
+  };
+  const viewletModuleId = await getViewletModuleIdForEditorInput(editorInput);
+  if (!viewletModuleId) {
+    return;
+  }
+  const latestState = context.getState();
+  const latestTab = findTabById(latestState, initialTab.id);
+  if (!latestTab) {
+    return;
+  }
+  const oldEditorUid = latestTab.tab.editorUid;
+  const resetState = updateTab(latestState, initialTab.id, {
+    editorInput,
+    editorType: getEditorInputEditorType(editorInput),
+    editorUid: -1,
+    errorMessage: undefined,
+    loadingState: undefined
+  });
+  const bounds = {
+    height: resetState.height - resetState.tabHeight,
+    width: resetState.width,
+    x: resetState.x,
+    y: resetState.y + resetState.tabHeight
+  };
+  const stateWithViewlet = createViewletForTab(resetState, initialTab.id);
+  await context.updateState(() => stateWithViewlet);
+  const tabWithViewlet = findTabById(stateWithViewlet, initialTab.id);
+  if (!tabWithViewlet || tabWithViewlet.tab.editorUid === -1) {
+    return;
+  }
+  const renderedTitle = await createViewlet(viewletModuleId, tabWithViewlet.tab.editorUid, initialTab.id, bounds, initialTab.uri);
+  const readyState = handleViewletReady(context.getState(), tabWithViewlet.tab.editorUid, renderedTitle);
+  await context.updateState(() => readyState);
+  if (oldEditorUid !== -1) {
+    try {
+      await invoke('Viewlet.dispose', oldEditorUid);
+    } catch {
+      // Reopening should still proceed if the previous viewlet was already disposed.
+    }
+  }
+};
+
 const getLatestStoredState = (uid, fallbackState, referenceTabId, referenceTabUri, allowMissingReference = false) => {
   const stateFromStore = get(uid);
   if (!stateFromStore) {
@@ -6500,7 +6680,7 @@ const createEmptyGroup = () => {
   return {
     activeTabId: undefined,
     focused: false,
-    id: create$1(),
+    id: create$2(),
     isEmpty: true,
     size: 100,
     tabs: []
@@ -6675,7 +6855,7 @@ const splitDown = (state, groupId) => {
 
   // If there are no groups, create an initial empty group first
   if (groups.length === 0) {
-    const initialGroupId = create$1();
+    const initialGroupId = create$2();
     const initialGroup = {
       activeTabId: undefined,
       focused: true,
@@ -6710,7 +6890,7 @@ const splitLeft = (state, groupId) => {
     groups
   } = layout;
   if (groups.length === 0) {
-    const initialGroupId = create$1();
+    const initialGroupId = create$2();
     const initialGroup = {
       activeTabId: undefined,
       focused: true,
@@ -6744,7 +6924,7 @@ const splitRight = (state, groupId) => {
 
   // If there are no groups, create an initial empty group first
   if (groups.length === 0) {
-    const initialGroupId = create$1();
+    const initialGroupId = create$2();
     const initialGroup = {
       activeTabId: undefined,
       focused: true,
@@ -6775,7 +6955,7 @@ const splitUp = (state, groupId) => {
     groups
   } = layout;
   if (groups.length === 0) {
-    const initialGroupId = create$1();
+    const initialGroupId = create$2();
     const initialGroup = {
       activeTabId: undefined,
       focused: true,
@@ -6838,7 +7018,7 @@ const commandMap = {
   'MainArea.copyIntoNewWindow': wrapSerialCommand(copyIntoNewWindow$1),
   'MainArea.copyPath': wrapSerialCommand(copyPath$1),
   'MainArea.copyRelativePath': wrapSerialCommand(copyRelativePath$1),
-  'MainArea.create': create$2,
+  'MainArea.create': create$1,
   'MainArea.diff2': diff2,
   'MainArea.flipEditorLayout': wrapSerialCommand(flipLayout),
   'MainArea.focusNext': wrapSerialCommand(focusNextTab),
@@ -6878,6 +7058,7 @@ const commandMap = {
   'MainArea.refresh': wrapSerialCommand(refresh),
   'MainArea.render2': render2,
   'MainArea.renderEventListeners': renderEventListeners,
+  'MainArea.reopenEditorWith': wrapSerialAsyncCommand(reopenEditorWith),
   'MainArea.resize': wrapGetter(handleResize),
   'MainArea.restoreClosedTab': wrapSerialCommand(restoreClosedTab),
   'MainArea.save': wrapSerialCommand(save),