@lvce-editor/static-server 0.80.16 → 0.80.18

package/static/{995dbd2 → 0e2b358}/packages/main-area-worker/dist/mainAreaWorkerMain.js

@@ -118,330 +118,6 @@ const terminate = () => {
   globalThis.close();
 };
 
-const getGroupIndexById = (state, groupId) => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  return groups.findIndex(group => group.id === groupId);
-};
-
-const redistributeSizesWithRounding = groups => {
-  return groups.map(group => ({
-    ...group,
-    size: Math.round(100 / groups.length)
-  }));
-};
-
-const withGroupsAndActiveGroup = (state, groups, activeGroupId) => {
-  return {
-    ...state,
-    layout: {
-      ...state.layout,
-      activeGroupId,
-      groups
-    }
-  };
-};
-
-const withEmptyGroups = state => {
-  return withGroupsAndActiveGroup(state, [], undefined);
-};
-
-const withGroups = (state, groups) => {
-  return {
-    ...state,
-    layout: {
-      ...state.layout,
-      groups
-    }
-  };
-};
-
-const closeTab = (state, groupId, tabId) => {
-  const {
-    activeGroupId,
-    groups
-  } = state.layout;
-
-  // Find the group to close the tab from
-  const groupIndex = getGroupIndexById(state, groupId);
-  if (groupIndex === -1) {
-    return state;
-  }
-  const group = groups[groupIndex];
-  // Check if the tab exists in the group
-  const tabWasRemoved = group.tabs.some(tab => tab.id === tabId);
-  if (!tabWasRemoved) {
-    return state;
-  }
-  const newGroups = groups.map(grp => {
-    if (grp.id === groupId) {
-      const newTabs = grp.tabs.filter(tab => tab.id !== tabId);
-      let newActiveTabId = grp.activeTabId;
-      if (grp.activeTabId === tabId) {
-        const tabIndex = grp.tabs.findIndex(tab => tab.id === tabId);
-        if (newTabs.length > 0) {
-          newActiveTabId = newTabs[Math.min(tabIndex, newTabs.length - 1)].id;
-        } else {
-          newActiveTabId = undefined;
-        }
-      }
-      return {
-        ...grp,
-        activeTabId: newActiveTabId,
-        isEmpty: newTabs.length === 0,
-        tabs: newTabs
-      };
-    }
-    return grp;
-  });
-
-  // If the group has no tabs left after closing, remove the group
-  const groupIsNowEmpty = newGroups[groupIndex].tabs.length === 0;
-  if (groupIsNowEmpty) {
-    const remainingGroups = newGroups.filter(group => group.id !== groupId);
-
-    // If there are remaining groups, redistribute sizes
-    if (remainingGroups.length > 0) {
-      const redistributedGroups = redistributeSizesWithRounding(remainingGroups);
-      const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0]?.id : activeGroupId;
-      return withGroupsAndActiveGroup(state, redistributedGroups, newActiveGroupId);
-    }
-
-    // If no remaining groups, return empty layout
-    return withEmptyGroups(state);
-  }
-  return withGroups(state, newGroups);
-};
-
-const getFocusedGroup = state => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  return groups.find(group => group.focused);
-};
-
-const closeActiveEditor = state => {
-  const focusedGroup = getFocusedGroup(state);
-  if (!focusedGroup) {
-    return state;
-  }
-  const {
-    activeTabId
-  } = focusedGroup;
-  if (activeTabId === undefined) {
-    return state;
-  }
-  return closeTab(state, focusedGroup.id, activeTabId);
-};
-
-const closeAll$1 = state => {
-  return withEmptyGroups(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 closeEditorGroup$1 = (state, groupId) => {
-  if (Number.isNaN(groupId)) {
-    return state;
-  }
-  const {
-    layout
-  } = state;
-  const {
-    activeGroupId,
-    groups
-  } = layout;
-  const groupIndex = getGroupIndexById(state, groupId);
-  if (groupIndex === -1 || groups.length <= 1) {
-    return state;
-  }
-  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 isFocused = group => {
-  return group.focused;
-};
-const closeFocusedTab = state => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  const focusedGroup = groups.find(isFocused);
-  if (!focusedGroup) {
-    return state;
-  }
-  const {
-    activeTabId
-  } = focusedGroup;
-  if (activeTabId === undefined) {
-    return state;
-  }
-  return closeTab(state, focusedGroup.id, activeTabId);
-};
-
-const closeOtherTabs = (state, groupId) => {
-  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;
-  }
-  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 {
-    ...state,
-    layout: {
-      ...layout,
-      groups: newGroups
-    }
-  };
-};
-
-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 {
-    activeTabId,
-    tabs
-  } = group;
-  const newTabs = tabs.filter(tab => tab.isDirty);
-  if (newTabs.length === tabs.length) {
-    return group;
-  }
-  const newActiveTabId = getNextActiveTabId(tabs, newTabs, activeTabId);
-  return {
-    ...group,
-    activeTabId: newActiveTabId,
-    isEmpty: newTabs.length === 0,
-    tabs: newTabs
-  };
-};
-const closeSaved$1 = state => {
-  const {
-    groups
-  } = state.layout;
-  const newGroups = groups.map(closeSavedInGroup);
-  return withGroups(state, newGroups);
-};
-
-const closeTabsByUris = (state, uris) => {
-  let currentState = state;
-  for (const uri of uris) {
-    while (true) {
-      const matchingGroup = currentState.layout.groups.find(group => {
-        return group.tabs.some(tab => tab.uri === uri);
-      });
-      if (!matchingGroup) {
-        break;
-      }
-      const matchingTab = matchingGroup.tabs.find(tab => tab.uri === uri);
-      if (!matchingTab) {
-        break;
-      }
-      currentState = closeTab(currentState, matchingGroup.id, matchingTab.id);
-    }
-  }
-  return currentState;
-};
-
-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;
-  }
-  const {
-    activeTabId,
-    tabs
-  } = group;
-  if (activeTabId === undefined) {
-    return state;
-  }
-  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 newGroups = groups.map(g => {
-    if (g.id === groupId) {
-      return {
-        ...g,
-        isEmpty: newTabs.length === 0,
-        tabs: newTabs
-      };
-    }
-    return g;
-  });
-  return withGroups(state, newGroups);
-};
-
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -1764,35 +1440,433 @@ const getIcons = async iconRequests => {
   return invoke$1('IconTheme.getIcons', iconRequests);
 };
 
-const {
-  invoke,
-  invokeAndTransfer,
-  set: set$1
-} = create$3(RendererWorker);
-const showContextMenu2 = async (uid, menuId, x, y, args) => {
-  number(uid);
-  number(menuId);
-  number(x);
-  number(y);
-  await invoke('ContextMenu.show2', uid, menuId, x, y, args);
+const {
+  invoke,
+  invokeAndTransfer,
+  set: set$1
+} = create$3(RendererWorker);
+const handleModifiedStatusChange$1 = async (uri, modified) => {
+  return invoke('Main.handleModifiedStatusChange', uri, modified);
+};
+const showContextMenu2 = async (uid, menuId, x, y, args) => {
+  number(uid);
+  number(menuId);
+  number(x);
+  number(y);
+  await invoke('ContextMenu.show2', uid, menuId, x, y, args);
+};
+const sendMessagePortToClipBoardWorker$1 = async (port, rpcId) => {
+  const command = 'ClipBoard.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToClipBoardWorker', port, command, rpcId);
+};
+const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
+  const command = 'IconTheme.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+};
+const readFile = async uri => {
+  return invoke('FileSystem.readFile', uri);
+};
+const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const writeClipBoardText = async text => {
+  await invoke('ClipBoard.writeText', /* text */text);
+};
+
+const addClosedTabs = (state, entries) => {
+  if (entries.length === 0) {
+    return state;
+  }
+  return {
+    ...state,
+    closedTabs: [...state.closedTabs, ...entries].slice(-20)
+  };
+};
+
+const getGroupIndexById = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  return groups.findIndex(group => group.id === groupId);
+};
+
+const redistributeSizesWithRounding = groups => {
+  return groups.map(group => ({
+    ...group,
+    size: Math.round(100 / groups.length)
+  }));
+};
+
+const withGroupsAndActiveGroup = (state, groups, activeGroupId) => {
+  return {
+    ...state,
+    layout: {
+      ...state.layout,
+      activeGroupId,
+      groups
+    }
+  };
+};
+
+const withEmptyGroups = state => {
+  return withGroupsAndActiveGroup(state, [], undefined);
+};
+
+const withGroups = (state, groups) => {
+  return {
+    ...state,
+    layout: {
+      ...state.layout,
+      groups
+    }
+  };
+};
+
+const closeTab = (state, groupId, tabId) => {
+  const {
+    activeGroupId,
+    groups
+  } = state.layout;
+
+  // Find the group to close the tab from
+  const groupIndex = getGroupIndexById(state, groupId);
+  if (groupIndex === -1) {
+    return state;
+  }
+  const group = groups[groupIndex];
+  const tabIndex = group.tabs.findIndex(tab => tab.id === tabId);
+
+  // Check if the tab exists in the group
+  if (tabIndex === -1) {
+    return state;
+  }
+  const stateWithClosedTab = addClosedTabs(state, [{
+    group,
+    groupIndex,
+    tab: group.tabs[tabIndex],
+    tabIndex
+  }]);
+  const newGroups = groups.map(grp => {
+    if (grp.id === groupId) {
+      const newTabs = grp.tabs.filter(tab => tab.id !== tabId);
+      let newActiveTabId = grp.activeTabId;
+      if (grp.activeTabId === tabId) {
+        if (newTabs.length > 0) {
+          newActiveTabId = newTabs[Math.min(tabIndex, newTabs.length - 1)].id;
+        } else {
+          newActiveTabId = undefined;
+        }
+      }
+      return {
+        ...grp,
+        activeTabId: newActiveTabId,
+        isEmpty: newTabs.length === 0,
+        tabs: newTabs
+      };
+    }
+    return grp;
+  });
+
+  // If the group has no tabs left after closing, remove the group
+  const groupIsNowEmpty = newGroups[groupIndex].tabs.length === 0;
+  if (groupIsNowEmpty) {
+    const remainingGroups = newGroups.filter(group => group.id !== groupId);
+
+    // If there are remaining groups, redistribute sizes
+    if (remainingGroups.length > 0) {
+      const redistributedGroups = redistributeSizesWithRounding(remainingGroups);
+      const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0]?.id : activeGroupId;
+      return withGroupsAndActiveGroup(stateWithClosedTab, redistributedGroups, newActiveGroupId);
+    }
+
+    // If no remaining groups, return empty layout
+    return withEmptyGroups(stateWithClosedTab);
+  }
+  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 saveEditor = async editorUid => {
+  return invoke('Editor.save', editorUid);
+};
+
+const closeTabAndSave = async (state, groupId, tabId) => {
+  const tab = findTabInState(state, groupId, tabId);
+  if (!tab) {
+    return state;
+  }
+  if (tab.editorUid !== -1) {
+    const editorState = await saveEditor(tab.editorUid);
+    if (!editorState?.modified && tab.uri) {
+      await handleModifiedStatusChange$1(tab.uri, false);
+    }
+  }
+  return closeTab(state, groupId, tabId);
+};
+
+const getFocusedGroup = state => {
+  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
+    }));
+  });
+  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)
+  }));
+};
+
+const closeEditorGroup$1 = (state, groupId) => {
+  if (Number.isNaN(groupId)) {
+    return state;
+  }
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const groupIndex = getGroupIndexById(state, groupId);
+  if (groupIndex === -1 || groups.length <= 1) {
+    return state;
+  }
+  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 isFocused = group => {
+  return group.focused;
+};
+const closeFocusedTab = async state => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const focusedGroup = groups.find(isFocused);
+  if (!focusedGroup) {
+    return state;
+  }
+  const {
+    activeTabId
+  } = focusedGroup;
+  if (activeTabId === undefined) {
+    return state;
+  }
+  return closeTabAndSave(state, focusedGroup.id, activeTabId);
+};
+
+const closeOtherTabs = (state, groupId) => {
+  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;
+  }
+  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
+    }
+  };
+};
+
+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 sendMessagePortToClipBoardWorker$1 = async (port, rpcId) => {
-  const command = 'ClipBoard.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToClipBoardWorker', port, command, rpcId);
+const closeSavedInGroup = group => {
+  const {
+    activeTabId,
+    tabs
+  } = group;
+  const newTabs = tabs.filter(tab => tab.isDirty);
+  if (newTabs.length === tabs.length) {
+    return group;
+  }
+  const newActiveTabId = getNextActiveTabId(tabs, newTabs, activeTabId);
+  return {
+    ...group,
+    activeTabId: newActiveTabId,
+    isEmpty: newTabs.length === 0,
+    tabs: newTabs
+  };
 };
-const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
-  const command = 'IconTheme.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+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 readFile = async uri => {
-  return invoke('FileSystem.readFile', uri);
+
+const closeTabsByUris = (state, uris) => {
+  let currentState = state;
+  for (const uri of uris) {
+    while (true) {
+      const matchingGroup = currentState.layout.groups.find(group => {
+        return group.tabs.some(tab => tab.uri === uri);
+      });
+      if (!matchingGroup) {
+        break;
+      }
+      const matchingTab = matchingGroup.tabs.find(tab => tab.uri === uri);
+      if (!matchingTab) {
+        break;
+      }
+      currentState = closeTab(currentState, matchingGroup.id, matchingTab.id);
+    }
+  }
+  return currentState;
 };
-const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+
+const getGroupById = (state, groupId) => {
+  return state.layout.groups.find(group => group.id === groupId);
 };
-const writeClipBoardText = async text => {
-  await invoke('ClipBoard.writeText', /* text */text);
+
+const closeTabsRight = (state, groupId) => {
+  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 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 withGroups(addClosedTabs(state, closedTabs), newGroups);
 };
 
 const copyPath$1 = async (state, path) => {
@@ -1840,6 +1914,7 @@ const {
 const create$2 = (uid, uri, x, y, width, height, platform, assetDir, tabHeight = 35) => {
   const state = {
     assetDir,
+    closedTabs: [],
     fileIconCache: {},
     height,
     iframes: [],
@@ -1864,39 +1939,225 @@ const create$2 = (uid, uri, x, y, width, height, platform, assetDir, tabHeight =
   set(uid, state, state);
 };
 
-const isEqual$1 = (oldState, newState) => {
-  return false;
+const isEqual$1 = (oldState, newState) => {
+  return false;
+};
+
+const isEqual = (oldState, newState) => {
+  return oldState.layout === newState.layout;
+};
+
+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 diff2 = uid => {
+  const {
+    newState,
+    oldState
+  } = get(uid);
+  const result = diff(oldState, newState);
+  return result;
+};
+
+const getActiveTabId$1 = state => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const activeGroup = groups.find(group => group.id === activeGroupId);
+  return activeGroup?.activeTabId;
+};
+
+const getSelectedTabBounds = state => {
+  return {
+    height: state.height - state.tabHeight,
+    width: state.width,
+    x: state.x,
+    y: state.y + state.tabHeight
+  };
+};
+
+const getSelectedTabData = (state, groupIndex, index) => {
+  const group = state.layout.groups[groupIndex];
+  if (!group || index < 0 || index >= group.tabs.length) {
+    return undefined;
+  }
+  const tab = group.tabs[index];
+  return {
+    group,
+    groupId: group.id,
+    tab,
+    tabId: tab.id
+  };
+};
+
+const getUpdatedGroups = (groups, groupIndex, needsLoading, tabId) => {
+  return groups.map((group, index) => {
+    if (index !== groupIndex) {
+      return {
+        ...group,
+        focused: false
+      };
+    }
+    const tabs = needsLoading ? group.tabs.map(tab => {
+      if (tab.id !== tabId) {
+        return tab;
+      }
+      return {
+        ...tab,
+        errorMessage: '',
+        loadingState: 'loading'
+      };
+    }) : group.tabs;
+    return {
+      ...group,
+      activeTabId: tabId,
+      focused: true,
+      tabs
+    };
+  });
+};
+
+const getViewletModuleId$1 = async uri => {
+  // Query RendererWorker for viewlet module ID (optional, may fail in tests)
+  let viewletModuleId;
+  try {
+    viewletModuleId = await invoke('Layout.getModuleId', uri);
+  } catch {
+    // Viewlet creation is optional - silently ignore if RendererWorker isn't available
+  }
+  return viewletModuleId;
 };
 
-const isEqual = (oldState, newState) => {
-  return oldState.layout === newState.layout;
+const DiffEditor = 'DiffEditor';
+const EditorText = 'Editor';
+const ExtensionDetail = 'ExtensionDetail';
+const QuickPick = 'QuickPick';
+
+const getViewletModuleIdForEditorInput = async editorInput => {
+  switch (editorInput.type) {
+    case 'diff-editor':
+      return DiffEditor;
+    case 'editor':
+      return getViewletModuleId$1(editorInput.uri);
+    case 'extension-detail-view':
+      return ExtensionDetail;
+  }
 };
 
-const RenderItems = 4;
-const RenderCss = 10;
-const RenderIncremental = 11;
+const getEditorInputEditorType = editorInput => {
+  switch (editorInput.type) {
+    case 'diff-editor':
+    case 'extension-detail-view':
+      return 'custom';
+    case 'editor':
+      return 'text';
+  }
+};
 
-const modules = [isEqual, isEqual$1];
-const numbers = [RenderIncremental, RenderCss];
+const getEditorInputUri = editorInput => {
+  switch (editorInput.type) {
+    case 'diff-editor':
+      return `diff://?left=${encodeURIComponent(editorInput.uriLeft)}&right=${encodeURIComponent(editorInput.uriRight)}`;
+    case 'editor':
+      return editorInput.uri;
+    case 'extension-detail-view':
+      return `extension-detail://${editorInput.extensionId}`;
+  }
+};
 
-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 getEditorInputFromUri = uri => {
+  if (uri.startsWith('diff://?')) {
+    try {
+      const parsed = new URL(uri);
+      const uriLeft = parsed.searchParams.get('left');
+      const uriRight = parsed.searchParams.get('right');
+      if (uriLeft && uriRight) {
+        return {
+          type: 'diff-editor',
+          uriLeft,
+          uriRight
+        };
+      }
+    } catch {
+      // Ignore malformed legacy URIs and fall back to a text editor input.
     }
   }
-  return diffResult;
+  if (uri.startsWith('extension-detail://')) {
+    const extensionIdWithPath = uri.slice('extension-detail://'.length);
+    const extensionId = extensionIdWithPath.split('/')[0];
+    if (extensionId) {
+      return {
+        extensionId,
+        type: 'extension-detail-view'
+      };
+    }
+  }
+  return {
+    type: 'editor',
+    uri
+  };
 };
-
-const diff2 = uid => {
+const getNormalizedEditorInput = tab => {
   const {
-    newState,
-    oldState
-  } = get(uid);
-  const result = diff(oldState, newState);
-  return result;
+    editorInput: tabEditorInput,
+    uri: tabUri
+  } = tab ?? {};
+  let uri;
+  if (typeof tabUri === 'string') {
+    uri = tabUri;
+  } else if (typeof tabEditorInput?.uri === 'string') {
+    const {
+      uri: tabEditorInputUri
+    } = tabEditorInput;
+    uri = tabEditorInputUri;
+  }
+  if (uri) {
+    const inferredEditorInput = getEditorInputFromUri(uri);
+    if (inferredEditorInput.type !== 'editor') {
+      return inferredEditorInput;
+    }
+  }
+  return tab?.editorInput;
+};
+const normalizeTabEditorInput = tab => {
+  const editorInput = getNormalizedEditorInput(tab);
+  if (!editorInput) {
+    return tab;
+  }
+  const uri = typeof tab?.uri === 'string' ? tab.uri : getEditorInputUri(editorInput);
+  return {
+    ...tab,
+    editorInput,
+    editorType: getEditorInputEditorType(editorInput),
+    uri
+  };
+};
+const getNormalizedOpenEditorInput = uri => {
+  return getEditorInputFromUri(uri);
+};
+
+const getViewletModuleId = async tab => {
+  const normalizedTab = normalizeTabEditorInput(tab);
+  return normalizedTab.editorInput ? getViewletModuleIdForEditorInput(normalizedTab.editorInput) : invoke('Layout.getModuleId', normalizedTab.uri);
 };
 
 const createViewlet = async (viewletModuleId, editorUid, tabId, bounds, uri) => {
@@ -2156,162 +2417,55 @@ const executeViewletCommands = async commands => {
         await handleSetBounds(command);
         break;
     }
-  }
-};
-
-const findTabById = (state, tabId) => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  for (const group of groups) {
-    const tab = group.tabs.find(t => t.id === tabId);
-    if (tab) {
-      return {
-        groupId: group.id,
-        tab
-      };
-    }
-  }
-  return undefined;
-};
-
-// Counter for request IDs to handle race conditions
-let requestIdCounter = 0;
-const getNextRequestId = () => {
-  return ++requestIdCounter;
-};
-
-const getViewletModuleId$1 = async uri => {
-  // Query RendererWorker for viewlet module ID (optional, may fail in tests)
-  let viewletModuleId;
-  try {
-    viewletModuleId = await invoke('Layout.getModuleId', uri);
-  } catch {
-    // Viewlet creation is optional - silently ignore if RendererWorker isn't available
-  }
-  return viewletModuleId;
-};
-
-const DiffEditor = 'DiffEditor';
-const ExtensionDetail = 'ExtensionDetail';
-const QuickPick = 'QuickPick';
-
-const getViewletModuleIdForEditorInput = async editorInput => {
-  switch (editorInput.type) {
-    case 'diff-editor':
-      return DiffEditor;
-    case 'editor':
-      return getViewletModuleId$1(editorInput.uri);
-    case 'extension-detail-view':
-      return ExtensionDetail;
-  }
-};
-
-const shouldLoadContentForTab = tab => {
-  if (tab.editorInput && tab.editorInput.type !== 'editor') {
-    return false;
-  }
-  if (!tab.uri) {
-    return false;
-  }
-  if (tab.loadingState === 'loading') {
-    return false;
-  }
-  if (tab.loadingState === 'loaded' && tab.editorUid !== -1) {
-    return false;
-  }
-  return true;
-};
-
-const startContentLoading = async (oldState, state, tabId, path, requestId) => {
-  try {
-    const getLatestState = () => {
-      return get(state.uid).newState;
-    };
-    set(state.uid, oldState, state);
-    const newState = await loadTabContentAsync(tabId, path, requestId, getLatestState);
-    return newState;
-  } catch {
-    // Silently ignore errors - the tab may have been closed or the component unmounted
-  }
-  return state;
-};
-
-const getActiveTabId$1 = state => {
-  const {
-    layout
-  } = state;
-  const {
-    activeGroupId,
-    groups
-  } = layout;
-  const activeGroup = groups.find(g => g.id === activeGroupId);
-  return activeGroup?.activeTabId;
-};
-const getSelectedTabData = (state, groupIndex, index) => {
-  const group = state.layout.groups[groupIndex];
-  if (!group || index < 0 || index >= group.tabs.length) {
-    return undefined;
-  }
-  const tab = group.tabs[index];
-  return {
-    group,
-    groupId: group.id,
-    tab,
-    tabId: tab.id
-  };
-};
-const getUpdatedGroups = (groups, groupIndex, needsLoading, tabId) => {
-  return groups.map((group, index) => {
-    if (index !== groupIndex) {
-      return {
-        ...group,
-        focused: false
-      };
-    }
-    const tabs = needsLoading ? group.tabs.map(tab => {
-      if (tab.id !== tabId) {
-        return tab;
-      }
-      return {
-        ...tab,
-        errorMessage: '',
-        loadingState: 'loading'
-      };
-    }) : group.tabs;
-    return {
-      ...group,
-      activeTabId: tabId,
-      focused: true,
-      tabs
-    };
-  });
-};
-const shouldCreateViewletForSelectedTab = tab => {
-  return Boolean(tab.uri) && (tab.editorUid === -1 || !tab.loadingState || tab.loadingState === 'loading');
+  }
 };
-const getSelectedTabBounds = state => {
-  return {
-    height: state.height - state.tabHeight,
-    width: state.width,
-    x: state.x,
-    y: state.y + state.tabHeight
-  };
+
+const findTabById = (state, tabId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  for (const group of groups) {
+    const tab = group.tabs.find(t => t.id === tabId);
+    if (tab) {
+      return {
+        groupId: group.id,
+        tab
+      };
+    }
+  }
+  return undefined;
 };
-const getViewletModuleId = async tab => {
-  return tab.editorInput ? getViewletModuleIdForEditorInput(tab.editorInput) : invoke('Layout.getModuleId', tab.uri);
+
+const startContentLoading = async (oldState, state, tabId, path, requestId) => {
+  try {
+    const getLatestState = () => {
+      return get(state.uid).newState;
+    };
+    set(state.uid, oldState, state);
+    const newState = await loadTabContentAsync(tabId, path, requestId, getLatestState);
+    return newState;
+  } catch {
+    // Silently ignore errors - the tab may have been closed or the component unmounted
+  }
+  return state;
 };
+
 const maybeStartLoading = async (state, newState, tabId, tab, needsLoading, requestId) => {
   if (needsLoading && tab.uri) {
     return startContentLoading(state, newState, tabId, tab.uri, requestId);
   }
   return newState;
 };
+
+const shouldCreateViewletForSelectedTab = tab => {
+  return Boolean(tab.uri) && (tab.editorUid === -1 || !tab.loadingState || tab.loadingState === 'loading');
+};
+
 const maybeCreateViewletForSelectedTab = async (state, newState, groupIndex, index, tabId, tab, uid, needsLoading, requestId, switchCommands) => {
-  const selectedTab = newState.layout.groups[groupIndex].tabs[index];
+  const selectedTab = normalizeTabEditorInput(newState.layout.groups[groupIndex].tabs[index]);
   if (!shouldCreateViewletForSelectedTab(selectedTab)) {
     return undefined;
   }
@@ -2338,6 +2492,29 @@ const maybeCreateViewletForSelectedTab = async (state, newState, groupIndex, ind
   }
   return maybeStartLoading(state, stateWithViewlet, tabId, tab, needsLoading, requestId);
 };
+
+// Counter for request IDs to handle race conditions
+let requestIdCounter = 0;
+const getNextRequestId = () => {
+  return ++requestIdCounter;
+};
+
+const shouldLoadContentForTab = tab => {
+  if (tab.editorInput && tab.editorInput.type !== 'editor') {
+    return false;
+  }
+  if (!tab.uri) {
+    return false;
+  }
+  if (tab.loadingState === 'loading') {
+    return false;
+  }
+  if (tab.loadingState === 'loaded' && tab.editorUid !== -1) {
+    return false;
+  }
+  return true;
+};
+
 const selectTab = async (state, groupIndex, index) => {
   const {
     layout,
@@ -2359,12 +2536,13 @@ const selectTab = async (state, groupIndex, index) => {
     tab,
     tabId
   } = selectedTabData;
+  const normalizedTab = normalizeTabEditorInput(tab);
   const isAlreadyActive = layout.activeGroupId === groupId && group.activeTabId === tabId;
-  if (isAlreadyActive && !shouldLoadContentForTab(tab)) {
+  if (isAlreadyActive && !shouldLoadContentForTab(normalizedTab)) {
     return state;
   }
   getActiveTabId$1(state);
-  const needsLoading = shouldLoadContentForTab(tab);
+  const needsLoading = shouldLoadContentForTab(normalizedTab);
   const requestId = needsLoading ? getNextRequestId() : 0;
   const updatedGroups = getUpdatedGroups(groups, groupIndex, needsLoading, tabId);
   let newState = {
@@ -2380,7 +2558,7 @@ const selectTab = async (state, groupIndex, index) => {
     newState: stateWithViewlet
   } = switchViewlet(newState);
   newState = stateWithViewlet;
-  const maybeCreatedState = await maybeCreateViewletForSelectedTab(state, newState, groupIndex, index, tabId, tab, uid, needsLoading, requestId, switchCommands);
+  const maybeCreatedState = await maybeCreateViewletForSelectedTab(state, newState, groupIndex, index, tabId, normalizedTab, uid, needsLoading, requestId, switchCommands);
   if (maybeCreatedState) {
     return maybeCreatedState;
   }
@@ -2388,7 +2566,7 @@ const selectTab = async (state, groupIndex, index) => {
   if (switchCommands.length > 0) {
     await executeViewletCommands(switchCommands);
   }
-  return maybeStartLoading(state, newState, tabId, tab, needsLoading, requestId);
+  return maybeStartLoading(state, newState, tabId, normalizedTab, needsLoading, requestId);
 };
 
 const focusNextTab = async state => {
@@ -2505,6 +2683,7 @@ const handleClickTogglePreview = async state => {
 
 const CloseGroup = 'close-group';
 const RetryOpen = 'retry-open';
+const RestoreClosedTab = 'restore-closed-tab';
 const SplitRight$1 = 'split-right';
 const TogglePreview$1 = 'toggle-preview';
 
@@ -2535,6 +2714,175 @@ const findTabByUri = (state, uri) => {
   return undefined;
 };
 
+const focusGroup = (groups, groupId, activeTabId) => {
+  return groups.map(group => {
+    if (group.id === groupId) {
+      return {
+        ...group,
+        activeTabId,
+        focused: true
+      };
+    }
+    return {
+      ...group,
+      focused: false
+    };
+  });
+};
+const clampIndex = (value, min, max) => {
+  return Math.min(Math.max(value, min), max);
+};
+const getRestoredTab = tab => {
+  return {
+    ...tab,
+    editorUid: -1,
+    errorMessage: '',
+    loadingState: undefined
+  };
+};
+const getStateWithoutLastClosedTab = state => {
+  return {
+    ...state,
+    closedTabs: state.closedTabs.slice(0, -1)
+  };
+};
+const restoreExistingUri = (state, entry) => {
+  if (!entry.tab.uri) {
+    return undefined;
+  }
+  const existing = findTabByUri(state, entry.tab.uri);
+  if (!existing) {
+    return undefined;
+  }
+  const groupIndex = state.layout.groups.findIndex(group => group.id === existing.groupId);
+  if (groupIndex === -1) {
+    return undefined;
+  }
+  const tabIndex = state.layout.groups[groupIndex].tabs.findIndex(tab => tab.id === existing.tab.id);
+  if (tabIndex === -1) {
+    return undefined;
+  }
+  const newStateWithoutClosedTab = getStateWithoutLastClosedTab(state);
+  const groups = focusGroup(newStateWithoutClosedTab.layout.groups, existing.groupId, existing.tab.id);
+  return {
+    groupIndex,
+    newState: {
+      ...newStateWithoutClosedTab,
+      layout: {
+        ...newStateWithoutClosedTab.layout,
+        activeGroupId: existing.groupId,
+        groups
+      }
+    },
+    tabIndex
+  };
+};
+const restoreIntoExistingGroup = (state, entry) => {
+  const {
+    groups
+  } = state.layout;
+  const groupIndex = groups.findIndex(group => group.id === entry.group.id);
+  if (groupIndex === -1) {
+    return undefined;
+  }
+  const restoredTab = getRestoredTab(entry.tab);
+  const group = groups[groupIndex];
+  const tabIndex = clampIndex(entry.tabIndex, 0, group.tabs.length);
+  const tabs = [...group.tabs];
+  tabs.splice(tabIndex, 0, restoredTab);
+  const newStateWithoutClosedTab = getStateWithoutLastClosedTab(state);
+  const updatedGroups = groups.map((currentGroup, index) => {
+    if (index === groupIndex) {
+      return {
+        ...currentGroup,
+        activeTabId: restoredTab.id,
+        focused: true,
+        isEmpty: false,
+        tabs
+      };
+    }
+    return {
+      ...currentGroup,
+      focused: false
+    };
+  });
+  return {
+    groupIndex,
+    newState: {
+      ...newStateWithoutClosedTab,
+      layout: {
+        ...newStateWithoutClosedTab.layout,
+        activeGroupId: group.id,
+        groups: updatedGroups
+      }
+    },
+    tabIndex
+  };
+};
+const createRestoredGroup = entry => {
+  return {
+    ...entry.group,
+    activeTabId: entry.tab.id,
+    focused: true,
+    isEmpty: false,
+    tabs: [getRestoredTab(entry.tab)]
+  };
+};
+const restoreIntoRecreatedGroup = (state, entry) => {
+  const newStateWithoutClosedTab = getStateWithoutLastClosedTab(state);
+  const restoredGroup = createRestoredGroup(entry);
+  const {
+    groups
+  } = newStateWithoutClosedTab.layout;
+  if (groups.length === 0) {
+    return {
+      groupIndex: 0,
+      newState: {
+        ...newStateWithoutClosedTab,
+        layout: {
+          ...newStateWithoutClosedTab.layout,
+          activeGroupId: restoredGroup.id,
+          groups: [restoredGroup]
+        }
+      },
+      tabIndex: 0
+    };
+  }
+  const groupIndex = clampIndex(entry.groupIndex, 0, groups.length);
+  const unfocusedGroups = groups.map(group => ({
+    ...group,
+    focused: false
+  }));
+  const insertedGroups = [...unfocusedGroups.slice(0, groupIndex), restoredGroup, ...unfocusedGroups.slice(groupIndex)];
+  return {
+    groupIndex,
+    newState: {
+      ...newStateWithoutClosedTab,
+      layout: {
+        ...newStateWithoutClosedTab.layout,
+        activeGroupId: restoredGroup.id,
+        groups: redistributeSizesWithRounding(insertedGroups)
+      }
+    },
+    tabIndex: 0
+  };
+};
+const restoreClosedTabState = state => {
+  const entry = state.closedTabs.at(-1);
+  if (!entry) {
+    return undefined;
+  }
+  return restoreExistingUri(state, entry) || restoreIntoExistingGroup(state, entry) || restoreIntoRecreatedGroup(state, entry);
+};
+
+const restoreClosedTab = async state => {
+  const restored = restoreClosedTabState(state);
+  if (!restored) {
+    return state;
+  }
+  return selectTab(restored.newState, restored.groupIndex, restored.tabIndex);
+};
+
 const focusEditorGroup = (state, groupId) => {
   const {
     layout
@@ -2589,16 +2937,6 @@ const getCurrentState = state => {
   return state;
 };
 
-const getEditorInputEditorType = editorInput => {
-  switch (editorInput.type) {
-    case 'diff-editor':
-    case 'extension-detail-view':
-      return 'custom';
-    case 'editor':
-      return 'text';
-  }
-};
-
 const getBasename$1 = uri => {
   const lastSlashIndex = uri.lastIndexOf('/');
   if (lastSlashIndex === -1) {
@@ -2648,17 +2986,6 @@ const getEditorInputTitle = editorInput => {
   }
 };
 
-const getEditorInputUri = editorInput => {
-  switch (editorInput.type) {
-    case 'diff-editor':
-      return `diff://?left=${encodeURIComponent(editorInput.uriLeft)}&right=${encodeURIComponent(editorInput.uriRight)}`;
-    case 'editor':
-      return editorInput.uri;
-    case 'extension-detail-view':
-      return `extension-detail://${editorInput.extensionId}`;
-  }
-};
-
 const createEmptyGroup = (state, uri, requestId, preview = false, title = getLabel(uri), editorType = 'text', editorInput) => {
   const {
     layout
@@ -3120,62 +3447,6 @@ const getOptionUriOptions = options => {
   return options.uri;
 };
 
-const getEditorInputFromUri = uri => {
-  if (uri.startsWith('diff://?')) {
-    try {
-      const parsed = new URL(uri);
-      const uriLeft = parsed.searchParams.get('left');
-      const uriRight = parsed.searchParams.get('right');
-      if (uriLeft && uriRight) {
-        return {
-          type: 'diff-editor',
-          uriLeft,
-          uriRight
-        };
-      }
-    } catch {
-      // Ignore malformed legacy URIs and fall back to a text editor input.
-    }
-  }
-  if (uri.startsWith('extension-detail://')) {
-    const extensionIdWithPath = uri.slice('extension-detail://'.length);
-    const extensionId = extensionIdWithPath.split('/')[0];
-    if (extensionId) {
-      return {
-        extensionId,
-        type: 'extension-detail-view'
-      };
-    }
-  }
-  return {
-    type: 'editor',
-    uri
-  };
-};
-const getNormalizedEditorInput = tab => {
-  if (typeof tab?.uri === 'string') {
-    const inferredEditorInput = getEditorInputFromUri(tab.uri);
-    if (inferredEditorInput.type !== 'editor') {
-      return inferredEditorInput;
-    }
-  }
-  return tab?.editorInput;
-};
-const normalizeTabEditorInput = tab => {
-  const editorInput = getNormalizedEditorInput(tab);
-  if (!editorInput) {
-    return tab;
-  }
-  return {
-    ...tab,
-    editorInput,
-    editorType: getEditorInputEditorType(editorInput)
-  };
-};
-const getNormalizedOpenEditorInput = uri => {
-  return getEditorInputFromUri(uri);
-};
-
 const openUri = async (state, options) => {
   const uri = getOptionUriOptions(options);
   const preview = typeof options === 'string' ? false : options.preview ?? false;
@@ -3407,6 +3678,9 @@ const handleClickAction = async (state, action, rawGroupId) => {
   if (!action) {
     return state;
   }
+  if (action === RestoreClosedTab) {
+    return restoreClosedTab(state);
+  }
   if (activeGroupId === undefined) {
     return state;
   }
@@ -3434,7 +3708,7 @@ const handleClickAction = async (state, action, rawGroupId) => {
   }
 };
 
-const handleClickCloseTab = (state, rawGroupIndex, rawIndex) => {
+const handleClickCloseTab = async (state, rawGroupIndex, rawIndex) => {
   if (!rawGroupIndex || !rawIndex) {
     return state;
   }
@@ -3458,7 +3732,7 @@ const handleClickCloseTab = (state, rawGroupIndex, rawIndex) => {
   const tab = group.tabs[index];
   const groupId = group.id;
   const tabId = tab.id;
-  return closeTab(state, groupId, tabId);
+  return closeTabAndSave(state, groupId, tabId);
 };
 
 const handleClickTab = async (state, groupIndexRaw, indexRaw) => {
@@ -3605,6 +3879,7 @@ const newFile = async state => {
     x: stateWithNewTab.x,
     y: stateWithNewTab.y + stateWithNewTab.tabHeight
   };
+  const viewletModuleId = EditorText;
   const stateWithViewlet = createViewletForTab(stateWithNewTab, tabId);
   let intermediateState = stateWithViewlet;
 
@@ -3626,7 +3901,7 @@ const newFile = async state => {
   if (actualEditorUid === -1) {
     throw new Error(`invalid editorUid`);
   }
-  await createViewlet('Editor', actualEditorUid, tabId, bounds, newTab.uri || '');
+  await createViewlet(viewletModuleId, actualEditorUid, tabId, bounds, newTab.uri || '');
 
   // After viewlet is created, get the latest state and mark it as ready
   const {
@@ -4102,7 +4377,12 @@ const getViewletModuleIds = async layout => {
     } = group;
     const activeTab = tabs.find(tab => tab.id === group.activeTabId);
     if (activeTab && (activeTab.editorInput || activeTab.uri)) {
-      const viewletModuleId = activeTab.editorInput ? await getViewletModuleIdForEditorInput(activeTab.editorInput) : await getViewletModuleId$1(activeTab.uri);
+      const normalizedTab = normalizeTabEditorInput(activeTab);
+      const {
+        editorInput,
+        uri
+      } = normalizedTab;
+      const viewletModuleId = normalizedTab.editorInput ? await getViewletModuleIdForEditorInput(editorInput) : await getViewletModuleId$1(uri);
       if (viewletModuleId) {
         viewletModuleIds[activeTab.id] = viewletModuleId;
       }
@@ -5553,33 +5833,54 @@ const renderEventListeners = () => {
   }];
 };
 
-const saveEditor = async editorUid => {
-  await invoke('Editor.save', editorUid);
-};
-const getEditorSaveState = async editorUid => {
-  return invoke('Editor.saveState', editorUid);
+const getLatestStoredState = (uid, fallbackState, referenceTabId, referenceTabUri, allowMissingReference = false) => {
+  const stateFromStore = get(uid);
+  if (!stateFromStore) {
+    return fallbackState;
+  }
+  const storedState = stateFromStore.newState;
+  const storedActiveTabData = getActiveTab(storedState);
+  if (!storedActiveTabData) {
+    return fallbackState;
+  }
+  if (allowMissingReference && referenceTabId === undefined && referenceTabUri === undefined) {
+    return storedState;
+  }
+  if (storedActiveTabData.tab.id === referenceTabId) {
+    return storedState;
+  }
+  if (referenceTabUri && storedActiveTabData.tab.uri === referenceTabUri) {
+    return storedState;
+  }
+  return fallbackState;
 };
-
 const save = async state => {
-  const activeTabData = getActiveTab(state);
+  const requestedActiveTabData = getActiveTab(state);
+  const currentState = getLatestStoredState(state.uid, state, requestedActiveTabData?.tab.id, requestedActiveTabData?.tab.uri, !requestedActiveTabData);
+  const activeTabData = getActiveTab(currentState);
   if (!activeTabData) {
-    return state;
+    return currentState;
   }
   const {
     tab
   } = activeTabData;
   if (tab.loadingState === 'loading') {
-    return state;
+    return currentState;
   }
-  await saveEditor(tab.editorUid);
   if (!tab.isDirty) {
-    return state;
+    await saveEditor(tab.editorUid);
+    return getLatestStoredState(state.uid, currentState, tab.id, tab.uri);
   }
-  const editorState = await getEditorSaveState(tab.editorUid);
-  if (editorState.modified) {
-    return state;
+  const editorState = await saveEditor(tab.editorUid);
+  const latestState = getLatestStoredState(state.uid, currentState, tab.id, tab.uri);
+  if (editorState?.modified) {
+    return latestState;
+  }
+  if (tab.uri) {
+    await handleModifiedStatusChange$1(tab.uri, false);
   }
-  return updateTab(state, tab.id, {
+  const stateAfterModifiedStatusChange = getLatestStoredState(state.uid, latestState, tab.id, tab.uri);
+  return updateTab(stateAfterModifiedStatusChange, tab.id, {
     isDirty: false
   });
 };
@@ -5768,11 +6069,14 @@ const commandMap = {
   'Main.focusNextTab': wrapCommand(focusNextTab),
   'Main.focusPrevious': wrapCommand(focusPreviousTab),
   'Main.focusPreviousTab': wrapCommand(focusPreviousTab),
+  'Main.handleModifiedStatusChange': wrapCommand(handleModifiedStatusChange),
   'Main.handleTabContextMenu': wrapCommand(handleTabContextMenu),
   'Main.openInput': wrapCommand(openInput),
   'Main.openUri': wrapCommand(openUri),
   'Main.openUris': wrapCommand(openUris),
+  'Main.restoreClosedTab': wrapCommand(restoreClosedTab),
   'Main.save': wrapCommand(save),
+  'Main.saveState': wrapGetter(saveState),
   'Main.splitRight': wrapCommand(splitRight),
   'MainArea.closeActiveEditor': wrapCommand(closeActiveEditor),
   'MainArea.closeAll': wrapCommand(closeAll$1),
@@ -5823,6 +6127,7 @@ const commandMap = {
   'MainArea.render2': render2,
   'MainArea.renderEventListeners': renderEventListeners,
   'MainArea.resize': wrapGetter(handleResize),
+  'MainArea.restoreClosedTab': wrapCommand(restoreClosedTab),
   'MainArea.save': wrapCommand(save),
   'MainArea.saveState': wrapGetter(saveState),
   'MainArea.selectTab': wrapCommand(selectTab),