@lvce-editor/static-server 0.90.1 → 0.91.0

package/static/{d347596 → c7fb6cd}/packages/main-area-worker/dist/mainAreaWorkerMain.js

@@ -3,10 +3,67 @@ const toCommandId = key => {
   return key.slice(dotIndex + 1);
 };
 const create$f = () => {
+  const commandQueues = new Map();
+  const generations = Object.create(null);
   const states = Object.create(null);
   const commandMapRef = {};
+  const getGeneration = uid => generations[uid] || 0;
+  const isCurrentGeneration = (uid, generation) => {
+    return states[uid] !== undefined && getGeneration(uid) === generation;
+  };
+  const updateState = (uid, generation, fallbackState, updater) => {
+    if (!isCurrentGeneration(uid, generation)) {
+      return Promise.resolve(fallbackState);
+    }
+    const current = states[uid];
+    const updatedState = updater(current.newState);
+    if (updatedState !== current.newState) {
+      states[uid] = {
+        newState: updatedState,
+        oldState: current.oldState,
+        scheduledState: updatedState
+      };
+    }
+    return Promise.resolve(updatedState);
+  };
+  const createAsyncCommandContext = (uid, generation) => {
+    let latestState = states[uid].newState;
+    return {
+      getState: () => {
+        if (isCurrentGeneration(uid, generation)) {
+          latestState = states[uid].newState;
+        }
+        return latestState;
+      },
+      updateState: async updater => {
+        latestState = await updateState(uid, generation, latestState, updater);
+        return latestState;
+      }
+    };
+  };
+  const enqueueCommand = async (uid, command) => {
+    const previous = commandQueues.get(uid) || Promise.resolve();
+    const run = async () => {
+      try {
+        await previous;
+      } catch {
+        // The previous caller receives its error; later commands must still run.
+      }
+      await command();
+    };
+    const current = run();
+    commandQueues.set(uid, current);
+    try {
+      await current;
+    } finally {
+      if (commandQueues.get(uid) === current) {
+        commandQueues.delete(uid);
+      }
+    }
+  };
   return {
     clear() {
+      commandQueues.clear();
       for (const key of Object.keys(states)) {
         delete states[key];
       }
@@ -26,6 +83,7 @@ const create$f = () => {
       return diffResult;
     },
     dispose(uid) {
+      commandQueues.delete(uid);
       delete states[uid];
     },
     get(uid) {
@@ -43,14 +101,27 @@ const create$f = () => {
       Object.assign(commandMapRef, commandMap);
     },
     set(uid, oldState, newState, scheduledState) {
+      const current = states[uid];
+      if (!current || oldState === newState && newState !== current.newState) {
+        generations[uid] = getGeneration(uid) + 1;
+      }
       states[uid] = {
         newState,
         oldState,
         scheduledState: scheduledState ?? newState
       };
     },
+    wrapAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const context = createAsyncCommandContext(uid, generation);
+        await fn(context, ...args);
+      };
+      return wrapped;
+    },
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -59,6 +130,9 @@ const create$f = () => {
         if (oldState === newerState || newState === newerState) {
           return;
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return;
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -83,6 +157,7 @@ const create$f = () => {
     },
     wrapLoadContent(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -97,6 +172,11 @@ const create$f = () => {
             error
           };
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return {
+            error
+          };
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -112,6 +192,51 @@ const create$f = () => {
         };
       };
       return wrapped;
+    },
+    wrapSerialAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const context = createAsyncCommandContext(uid, generation);
+          await fn(context, ...args);
+        });
+      };
+      return wrapped;
+    },
+    wrapSerialCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const {
+            newState,
+            oldState
+          } = states[uid];
+          const newerState = await fn(newState, ...args);
+          if (oldState === newerState || newState === newerState) {
+            return;
+          }
+          if (!isCurrentGeneration(uid, generation)) {
+            return;
+          }
+          const latestOld = states[uid];
+          const latestNew = {
+            ...latestOld.newState,
+            ...newerState
+          };
+          states[uid] = {
+            newState: latestNew,
+            oldState: latestOld.oldState,
+            scheduledState: latestNew
+          };
+        });
+      };
+      return wrapped;
     }
   };
 };
@@ -2125,8 +2250,10 @@ const {
   getKeys: getKeys$1,
   registerCommands,
   set,
-  wrapCommand,
-  wrapGetter
+  wrapAsyncCommand,
+  wrapGetter,
+  wrapSerialAsyncCommand,
+  wrapSerialCommand
 } = create$f();
 
 const create$2 = (uid, uri, x, y, width, height, platform, assetDir, tabHeight = 35) => {
@@ -2200,6 +2327,19 @@ const handleAttach = async command => {
   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;
+  }
+};
+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();
 };
@@ -2372,7 +2512,7 @@ const findTabByEditorUid = (state, editorUid) => {
  * With reference nodes, attachment is handled automatically by virtual DOM rendering.
  * No commands needed - state update is sufficient.
  */
-const handleViewletReady = (state, editorUid) => {
+const handleViewletReady = (state, editorUid, title) => {
   if (editorUid === -1) {
     throw new Error('Invalid editorUid -1');
   }
@@ -2387,7 +2527,10 @@ const handleViewletReady = (state, editorUid) => {
   // Reference nodes will handle rendering at the correct position automatically
   const newState = updateTab(state, tab.id, {
     editorUid,
-    loadingState: 'loaded'
+    loadingState: 'loaded',
+    ...(title && {
+      title
+    })
   });
 
   // No attach commands needed - virtual DOM reference nodes handle positioning
@@ -2397,9 +2540,7 @@ const handleViewletReady = (state, editorUid) => {
 const handleCreate = async command => {
   // Safe to call - no visible side effects
 
-  const instanceId = Math.random(); // TODO try to find a better way to get consistent integer ids (thread safe)
-
-  await invoke('Layout.createViewlet', command.viewletModuleId, command.tabId, command.bounds, command.uri, instanceId);
+  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
@@ -2407,7 +2548,7 @@ const handleCreate = async command => {
     newState: state,
     oldState
   } = get(command.uid);
-  const readyState = handleViewletReady(state, command.editorUid);
+  const readyState = handleViewletReady(state, command.editorUid, title);
   set(command.uid, oldState, readyState);
   return readyState;
 };
@@ -2685,10 +2826,6 @@ const getUpdatedGroups = (groups, groupIndex, needsLoading, tabId) => {
   });
 };
 
-const createViewlet = async (viewletModuleId, editorUid, tabId, bounds, uri) => {
-  await invoke('Layout.createViewlet', viewletModuleId, editorUid, tabId, bounds, uri);
-};
-
 const findTabById = (state, tabId) => {
   const {
     layout
@@ -2803,8 +2940,8 @@ const maybeCreateViewletForSelectedTab = async (state, newState, groupIndex, ind
       editorUid
     } = tabWithViewlet.tab;
     if (editorUid !== -1 && selectedTab.uri) {
-      await createViewlet(viewletModuleId, editorUid, tabId, bounds, selectedTab.uri);
-      stateWithViewlet = handleViewletReady(stateWithViewlet, editorUid);
+      const title = await createViewlet(viewletModuleId, editorUid, tabId, bounds, selectedTab.uri);
+      stateWithViewlet = handleViewletReady(stateWithViewlet, editorUid, title);
       set(uid, state, stateWithViewlet);
     }
   }
@@ -3669,7 +3806,7 @@ const getFileIconsForTabs = async (tabs, fileIconCache) => {
   };
 };
 
-const updateTabIcon = async (uid, state, readyState, tabId) => {
+const updateTabIcon = async (context, readyState, tabId) => {
   const newTab = findTabById(readyState, tabId);
   if (!newTab || !newTab.tab.uri) {
     return undefined;
@@ -3678,9 +3815,7 @@ const updateTabIcon = async (uid, state, readyState, tabId) => {
     const {
       newFileIconCache
     } = await getFileIconsForTabs([newTab.tab], readyState.fileIconCache);
-    const {
-      newState: stateBeforeIconUpdate
-    } = get(uid);
+    const stateBeforeIconUpdate = context.getState();
     const icon = newFileIconCache[newTab.tab.uri] || '';
     const stateWithIcon = {
       ...stateBeforeIconUpdate,
@@ -3696,19 +3831,16 @@ const updateTabIcon = async (uid, state, readyState, tabId) => {
         }))
       }
     };
-    set(uid, state, stateWithIcon);
-    return stateWithIcon;
+    return context.updateState(() => stateWithIcon);
   } catch {
     return undefined;
   }
 };
 
-const openInput = async (state, options) => {
+const openInputWithContext = async (context, options) => {
+  const state = context.getState();
   object(state);
   object(options);
-  const {
-    uid
-  } = state;
   const {
     editorInput
   } = options;
@@ -3716,40 +3848,40 @@ const openInput = async (state, options) => {
   const uri = getEditorInputUri(editorInput);
   const title = getEditorInputTitle(editorInput);
   const editorType = getEditorInputEditorType(editorInput);
-  const currentState = getCurrentState(state);
+  const currentState = state;
   const existingTab = findTabByUri(currentState, uri);
   const shouldRetryExistingTab = !!existingTab && existingTab.tab.loadingState === 'error';
   if (existingTab && !shouldRetryExistingTab) {
     const focusedState = focusEditorGroup(currentState, existingTab.groupId);
-    return switchTab(focusedState, existingTab.groupId, existingTab.tab.id);
+    const switchedState = switchTab(focusedState, existingTab.groupId, existingTab.tab.id);
+    await context.updateState(() => switchedState);
+    return;
   }
   const previousTabId = getActiveTabId(currentState);
   const {
     stateWithTab,
     tabId
   } = getStateWithTab(currentState, editorInput, existingTab, shouldRetryExistingTab, uri, preview, title, editorType);
-  set(uid, state, stateWithTab);
+  await context.updateState(() => stateWithTab);
   if (await isDirectoryEditorInput(editorInput)) {
-    const {
-      newState: latestState
-    } = get(uid);
+    const latestState = context.getState();
     const errorState = updateTab(latestState, tabId, {
       errorMessage: 'Expected a file but received a folder',
       loadingState: 'error'
     });
-    set(uid, state, errorState);
-    return errorState;
+    await context.updateState(() => errorState);
+    return;
   }
   try {
     const viewletModuleId = await getViewletModuleIdForEditorInput(editorInput);
-    const {
-      newState: stateAfterModuleId
-    } = get(uid);
+    const stateAfterModuleId = context.getState();
     if (!viewletModuleId) {
-      return updateTab(stateAfterModuleId, tabId, {
+      const unsupportedState = updateTab(stateAfterModuleId, tabId, {
         errorMessage: 'Could not determine editor type for this URI',
         loadingState: 'error'
       });
+      await context.updateState(() => unsupportedState);
+      return;
     }
     const bounds = {
       height: stateAfterModuleId.height - stateAfterModuleId.tabHeight,
@@ -3763,10 +3895,10 @@ const openInput = async (state, options) => {
       newState: switchedState
     } = switchViewlet(intermediateState, previousTabId, tabId);
     intermediateState = switchedState;
-    set(uid, state, intermediateState);
+    await context.updateState(() => intermediateState);
     const tabWithViewlet = findTabById(intermediateState, tabId);
     if (!tabWithViewlet) {
-      return intermediateState;
+      return;
     }
     const {
       editorUid
@@ -3774,33 +3906,42 @@ const openInput = async (state, options) => {
     if (editorUid === -1) {
       throw new Error('invalid editorUid');
     }
-    await createViewlet(viewletModuleId, editorUid, tabId, bounds, uri);
-    const {
-      newState: latestState
-    } = get(uid);
-    const readyState = handleViewletReady(latestState, editorUid);
-    set(uid, state, readyState);
-    const stateWithIcon = await updateTabIcon(uid, state, readyState, tabId);
+    const renderedTitle = await createViewlet(viewletModuleId, editorUid, tabId, bounds, uri);
+    const latestState = context.getState();
+    const readyState = handleViewletReady(latestState, editorUid, renderedTitle);
+    await context.updateState(() => readyState);
+    const stateWithIcon = await updateTabIcon(context, readyState, tabId);
     if (stateWithIcon) {
-      return stateWithIcon;
+      return;
     }
-    const {
-      newState: finalState
-    } = get(uid);
-    return finalState;
   } catch (error) {
-    const {
-      newState: latestState
-    } = get(uid);
+    const latestState = context.getState();
     const errorMessage = error instanceof Error ? error.message : 'Failed to open URI';
     const errorState = updateTab(latestState, tabId, {
       errorMessage,
       loadingState: 'error'
     });
-    set(uid, state, errorState);
-    return errorState;
+    await context.updateState(() => errorState);
   }
 };
+const openInput = async (state, options) => {
+  const {
+    uid
+  } = state;
+  let currentState = getCurrentState(state);
+  const context = {
+    getState: () => get(uid)?.newState ?? currentState,
+    updateState: updater => {
+      const storedState = get(uid);
+      const latestState = storedState?.newState ?? currentState;
+      currentState = updater(latestState);
+      set(uid, storedState?.oldState ?? state, currentState);
+      return Promise.resolve(currentState);
+    }
+  };
+  await openInputWithContext(context, options);
+  return context.getState();
+};
 
 const getOptionUriOptions = options => {
   if (typeof options === 'string') {
@@ -3809,14 +3950,20 @@ const getOptionUriOptions = options => {
   return options.uri;
 };
 
-const openUri = async (state, options) => {
+const getOpenInputOptions = options => {
   const uri = getOptionUriOptions(options);
   const preview = typeof options === 'string' ? false : options.preview ?? false;
-  return openInput(state, {
+  return {
     editorInput: getNormalizedOpenEditorInput(uri),
     focus: typeof options === 'string' ? false : options.focus,
     preview
-  });
+  };
+};
+const openUri = async (state, options) => {
+  return openInput(state, getOpenInputOptions(options));
+};
+const openUriWithContext = async (context, options) => {
+  await openInputWithContext(context, getOpenInputOptions(options));
 };
 
 const retryOpen = async state => {
@@ -4265,13 +4412,13 @@ const newFile = async state => {
   if (actualEditorUid === -1) {
     throw new Error(`invalid editorUid`);
   }
-  await createViewlet(viewletModuleId, actualEditorUid, tabId, bounds, newTab.uri || '');
+  const title = await createViewlet(viewletModuleId, actualEditorUid, tabId, bounds, newTab.uri || '');
 
   // After viewlet is created, get the latest state and mark it as ready
   const {
     newState: latestState
   } = get(uid);
-  const readyState = handleViewletReady(latestState, actualEditorUid);
+  const readyState = handleViewletReady(latestState, actualEditorUid, title);
   return readyState;
 };
 
@@ -4366,6 +4513,9 @@ const handleModifiedStatusChange = (state, uri, newStatus) => {
     }
   };
 };
+const handleModifiedStatusChangeWithContext = async (context, uri, newStatus) => {
+  await context.updateState(state => handleModifiedStatusChange(state, uri, newStatus));
+};
 
 const handleResize = async (state, dimensions) => {
   const {
@@ -4598,47 +4748,6 @@ const handleUriChange = async (state, oldUri, newUri) => {
   };
 };
 
-const handleWorkspaceChange = state => {
-  const {
-    layout
-  } = state;
-  return {
-    ...state,
-    layout: {
-      ...layout,
-      activeGroupId: undefined,
-      groups: []
-    }
-  };
-};
-
-const hasActiveTextEditor = state => {
-  const activeTab = getActiveTab(state);
-  return activeTab?.tab.editorInput?.type === 'editor';
-};
-
-const id = 7201;
-const sendMessagePortToExtensionHostWorker = async port => {
-  await sendMessagePortToExtensionHostWorker$1(port, id);
-};
-
-const createExtensionHostRpc = async () => {
-  try {
-    const rpc = await create$8({
-      commandMap: {},
-      send: sendMessagePortToExtensionHostWorker
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create extension host rpc`);
-  }
-};
-
-const initialize = async () => {
-  const rpc = await createExtensionHostRpc();
-  set$3(rpc);
-};
-
 const toFileUri = path => {
   if (!path) {
     return '';
@@ -4748,15 +4857,22 @@ const tryRestoreLayout = savedState => {
 
 const createViewlets = async (layout, viewletModuleIds, bounds) => {
   const editorUids = {};
+  const titles = {};
   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;
       editorUids[activeTab.id] = editorUid;
-      await createViewlet(viewletModuleIds[activeTab.id], editorUid, activeTab.id, bounds, activeTab.uri);
+      const title = await createViewlet(viewletModuleIds[activeTab.id], editorUid, activeTab.id, bounds, activeTab.uri);
+      if (title) {
+        titles[activeTab.id] = title;
+      }
     }
   }
-  return editorUids;
+  return {
+    editorUids,
+    titles
+  };
 };
 
 const getViewletModuleIds = async layout => {
@@ -4833,7 +4949,10 @@ const restoreAndCreateEditors = async (state, restoredLayout) => {
   const viewletModuleIds = await getViewletModuleIds(newState.layout);
 
   // Create viewlets and get editor UIDs
-  const editorUids = await createViewlets(newState.layout, viewletModuleIds, bounds);
+  const {
+    editorUids,
+    titles
+  } = await createViewlets(newState.layout, viewletModuleIds, bounds);
 
   // Update tabs with editor UIDs
   newState = updateTabs(newState, editorUids);
@@ -4844,7 +4963,7 @@ const restoreAndCreateEditors = async (state, restoredLayout) => {
     if (activeTab && viewletModuleIds[activeTab.id]) {
       const editorUid = editorUids[activeTab.id];
       newState = createViewletForTab(newState, activeTab.id);
-      newState = handleViewletReady(newState, editorUid);
+      newState = handleViewletReady(newState, editorUid, titles[activeTab.id]);
     }
   }
   return newState;
@@ -4887,6 +5006,37 @@ const loadContent = async (state, savedState) => {
   };
 };
 
+const handleWorkspaceChange = async (state, _workspacePath, savedState) => {
+  return loadContent(state, savedState);
+};
+
+const hasActiveTextEditor = state => {
+  const activeTab = getActiveTab(state);
+  return activeTab?.tab.editorInput?.type === 'editor';
+};
+
+const id = 7201;
+const sendMessagePortToExtensionHostWorker = async port => {
+  await sendMessagePortToExtensionHostWorker$1(port, id);
+};
+
+const createExtensionHostRpc = async () => {
+  try {
+    const rpc = await create$8({
+      commandMap: {},
+      send: sendMessagePortToExtensionHostWorker
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create extension host rpc`);
+  }
+};
+
+const initialize = async () => {
+  const rpc = await createExtensionHostRpc();
+  set$3(rpc);
+};
+
 const hasTargetGroup = groupId => {
   return groupId !== undefined && groupId >= 0;
 };
@@ -5260,26 +5410,26 @@ const newWindow = async state => {
   return state;
 };
 
-const openUris = async (state, uris) => {
+const openUrisWithContext = async (context, uris) => {
   if (uris.length === 0) {
-    return state;
+    return;
   }
+  await openUriWithContext(context, uris[0]);
   if (uris.length === 1) {
-    return openUri(state, uris[0]);
+    return;
   }
-  let currentState = await openUri(state, uris[0]);
+  let currentState = context.getState();
   const firstTab = findTabByUri(currentState, uris[0]);
   for (const uri of uris.slice(1)) {
     const existingTab = findTabByUri(currentState, uri);
-    if (existingTab) {
-      continue;
+    if (!existingTab) {
+      currentState = ensureActiveGroup(currentState, uri);
     }
-    currentState = ensureActiveGroup(currentState, uri);
   }
-  if (!firstTab) {
-    return currentState;
+  if (firstTab) {
+    currentState = switchTab(currentState, firstTab.groupId, firstTab.tab.id);
   }
-  return switchTab(currentState, firstTab.groupId, firstTab.tab.id);
+  await context.updateState(() => currentState);
 };
 
 const refresh = state => {
@@ -6652,99 +6802,99 @@ const splitUp = (state, groupId) => {
 };
 
 const commandMap = {
-  'Main.closeActiveEditor': wrapCommand(closeActiveEditor),
-  'Main.closeAll': wrapCommand(closeAll$1),
-  'Main.closeAllEditors': wrapCommand(closeAll$1),
-  'Main.closeFocusedTab': wrapCommand(closeFocusedTab),
-  'Main.closeOthers': wrapCommand(closeOtherTabs),
-  'Main.closeSaved': wrapCommand(closeSaved$1),
-  'Main.closeTabsByUris': wrapCommand(closeTabsByUris),
-  'Main.closeTabsRight': wrapCommand(closeTabsRight),
-  'Main.copyPath': wrapCommand(copyPath$1),
-  'Main.copyRelativePath': wrapCommand(copyRelativePath$1),
-  'Main.focusNext': wrapCommand(focusNextTab),
-  'Main.focusNextTab': wrapCommand(focusNextTab),
-  'Main.focusPrevious': wrapCommand(focusPreviousTab),
-  'Main.focusPreviousTab': wrapCommand(focusPreviousTab),
-  'Main.handleModifiedStatusChange': wrapCommand(handleModifiedStatusChange),
-  'Main.handleTabContextMenu': wrapCommand(handleTabContextMenu),
+  'Main.closeActiveEditor': wrapSerialCommand(closeActiveEditor),
+  'Main.closeAll': wrapSerialCommand(closeAll$1),
+  'Main.closeAllEditors': wrapSerialCommand(closeAll$1),
+  'Main.closeFocusedTab': wrapSerialCommand(closeFocusedTab),
+  'Main.closeOthers': wrapSerialCommand(closeOtherTabs),
+  'Main.closeSaved': wrapSerialCommand(closeSaved$1),
+  'Main.closeTabsByUris': wrapSerialCommand(closeTabsByUris),
+  'Main.closeTabsRight': wrapSerialCommand(closeTabsRight),
+  'Main.copyPath': wrapSerialCommand(copyPath$1),
+  'Main.copyRelativePath': wrapSerialCommand(copyRelativePath$1),
+  'Main.focusNext': wrapSerialCommand(focusNextTab),
+  'Main.focusNextTab': wrapSerialCommand(focusNextTab),
+  'Main.focusPrevious': wrapSerialCommand(focusPreviousTab),
+  'Main.focusPreviousTab': wrapSerialCommand(focusPreviousTab),
+  'Main.handleModifiedStatusChange': wrapAsyncCommand(handleModifiedStatusChangeWithContext),
+  'Main.handleTabContextMenu': wrapSerialCommand(handleTabContextMenu),
   'Main.hasActiveTextEditor': wrapGetter(hasActiveTextEditor),
-  'Main.openInput': wrapCommand(openInput),
-  'Main.openUri': wrapCommand(openUri),
-  'Main.openUris': wrapCommand(openUris),
-  'Main.restoreClosedTab': wrapCommand(restoreClosedTab),
-  'Main.save': wrapCommand(save),
+  'Main.openInput': wrapSerialAsyncCommand(openInputWithContext),
+  'Main.openUri': wrapSerialAsyncCommand(openUriWithContext),
+  'Main.openUris': wrapSerialAsyncCommand(openUrisWithContext),
+  'Main.restoreClosedTab': wrapSerialCommand(restoreClosedTab),
+  'Main.save': wrapSerialCommand(save),
   'Main.saveState': wrapGetter(saveState),
-  'Main.splitRight': wrapCommand(splitRight),
-  'MainArea.closeActiveEditor': wrapCommand(closeActiveEditor),
-  'MainArea.closeAll': wrapCommand(closeAll$1),
-  'MainArea.closeAllEditors': wrapCommand(closeAll$1),
-  'MainArea.closeEditorGroup': wrapCommand(closeEditorGroup$1),
-  'MainArea.closeFocusedTab': wrapCommand(closeFocusedTab),
-  'MainArea.closeOthers': wrapCommand(closeOtherTabs),
-  'MainArea.closeSaved': wrapCommand(closeSaved$1),
-  'MainArea.closeTabsByUris': wrapCommand(closeTabsByUris),
-  'MainArea.closeTabsRight': wrapCommand(closeTabsRight),
-  'MainArea.copyIntoNewWindow': wrapCommand(copyIntoNewWindow$1),
-  'MainArea.copyPath': wrapCommand(copyPath$1),
-  'MainArea.copyRelativePath': wrapCommand(copyRelativePath$1),
+  'Main.splitRight': wrapSerialCommand(splitRight),
+  'MainArea.closeActiveEditor': wrapSerialCommand(closeActiveEditor),
+  'MainArea.closeAll': wrapSerialCommand(closeAll$1),
+  'MainArea.closeAllEditors': wrapSerialCommand(closeAll$1),
+  'MainArea.closeEditorGroup': wrapSerialCommand(closeEditorGroup$1),
+  'MainArea.closeFocusedTab': wrapSerialCommand(closeFocusedTab),
+  'MainArea.closeOthers': wrapSerialCommand(closeOtherTabs),
+  'MainArea.closeSaved': wrapSerialCommand(closeSaved$1),
+  'MainArea.closeTabsByUris': wrapSerialCommand(closeTabsByUris),
+  'MainArea.closeTabsRight': wrapSerialCommand(closeTabsRight),
+  'MainArea.copyIntoNewWindow': wrapSerialCommand(copyIntoNewWindow$1),
+  'MainArea.copyPath': wrapSerialCommand(copyPath$1),
+  'MainArea.copyRelativePath': wrapSerialCommand(copyRelativePath$1),
   'MainArea.create': create$2,
   'MainArea.diff2': diff2,
-  'MainArea.flipEditorLayout': wrapCommand(flipLayout),
-  'MainArea.focusNext': wrapCommand(focusNextTab),
-  'MainArea.focusNextTab': wrapCommand(focusNextTab),
-  'MainArea.focusPrevious': wrapCommand(focusPreviousTab),
-  'MainArea.focusPreviousTab': wrapCommand(focusPreviousTab),
+  'MainArea.flipEditorLayout': wrapSerialCommand(flipLayout),
+  'MainArea.focusNext': wrapSerialCommand(focusNextTab),
+  'MainArea.focusNextTab': wrapSerialCommand(focusNextTab),
+  'MainArea.focusPrevious': wrapSerialCommand(focusPreviousTab),
+  'MainArea.focusPreviousTab': wrapSerialCommand(focusPreviousTab),
   'MainArea.getCommandIds': getCommandIds,
   'MainArea.getMenuEntries': wrapGetter(getMenuEntries),
   'MainArea.getMenuIds': getMenuIds,
-  'MainArea.handleClick': wrapCommand(handleClick),
-  'MainArea.handleClickAction': wrapCommand(handleClickAction),
-  'MainArea.handleClickCloseTab': wrapCommand(handleClickCloseTab),
-  'MainArea.handleClickTab': wrapCommand(handleClickTab),
-  'MainArea.handleClickTogglePreview': wrapCommand(handleClickTogglePreview),
-  'MainArea.handleContextMenu': wrapCommand(handleContextMenu),
-  'MainArea.handleDoubleClick': wrapCommand(handleDoubleClick),
-  'MainArea.handleHeaderDoubleClick': wrapCommand(handleHeaderDoubleClick),
-  'MainArea.handleIconThemeChange': wrapCommand(handleIconThemeChange),
-  'MainArea.handleModifiedStatusChange': wrapCommand(handleModifiedStatusChange),
+  'MainArea.handleClick': wrapSerialCommand(handleClick),
+  'MainArea.handleClickAction': wrapSerialCommand(handleClickAction),
+  'MainArea.handleClickCloseTab': wrapSerialCommand(handleClickCloseTab),
+  'MainArea.handleClickTab': wrapSerialCommand(handleClickTab),
+  'MainArea.handleClickTogglePreview': wrapSerialCommand(handleClickTogglePreview),
+  'MainArea.handleContextMenu': wrapSerialCommand(handleContextMenu),
+  'MainArea.handleDoubleClick': wrapSerialCommand(handleDoubleClick),
+  'MainArea.handleHeaderDoubleClick': wrapSerialCommand(handleHeaderDoubleClick),
+  'MainArea.handleIconThemeChange': wrapSerialCommand(handleIconThemeChange),
+  'MainArea.handleModifiedStatusChange': wrapAsyncCommand(handleModifiedStatusChangeWithContext),
   'MainArea.handleResize': wrapGetter(handleResize),
   // TODO would need to have a function that returns newstate as well as commands
-  'MainArea.handleSashPointerDown': wrapCommand(handleSashPointerDown),
-  'MainArea.handleSashPointerMove': wrapCommand(handleSashPointerMove),
-  'MainArea.handleSashPointerUp': wrapCommand(handleSashPointerUp),
-  'MainArea.handleTabContextMenu': wrapCommand(handleTabContextMenu),
-  'MainArea.handleUriChange': wrapCommand(handleUriChange),
-  'MainArea.handleWorkspaceChange': wrapCommand(handleWorkspaceChange),
+  'MainArea.handleSashPointerDown': wrapSerialCommand(handleSashPointerDown),
+  'MainArea.handleSashPointerMove': wrapSerialCommand(handleSashPointerMove),
+  'MainArea.handleSashPointerUp': wrapSerialCommand(handleSashPointerUp),
+  'MainArea.handleTabContextMenu': wrapSerialCommand(handleTabContextMenu),
+  'MainArea.handleUriChange': wrapSerialCommand(handleUriChange),
+  'MainArea.handleWorkspaceChange': wrapSerialCommand(handleWorkspaceChange),
   'MainArea.hasActiveTextEditor': wrapGetter(hasActiveTextEditor),
   'MainArea.initialize': initialize,
-  'MainArea.loadContent': wrapCommand(loadContent),
-  'MainArea.moveIntoNewWindow': wrapCommand(moveIntoNewWindow),
-  'MainArea.newFile': wrapCommand(newFile),
-  'MainArea.newWindow': wrapCommand(newWindow),
-  'MainArea.openInput': wrapCommand(openInput),
-  'MainArea.openUri': wrapCommand(openUri),
-  'MainArea.openUris': wrapCommand(openUris),
-  'MainArea.refresh': wrapCommand(refresh),
+  'MainArea.loadContent': wrapSerialCommand(loadContent),
+  'MainArea.moveIntoNewWindow': wrapSerialCommand(moveIntoNewWindow),
+  'MainArea.newFile': wrapSerialCommand(newFile),
+  'MainArea.newWindow': wrapSerialCommand(newWindow),
+  'MainArea.openInput': wrapSerialAsyncCommand(openInputWithContext),
+  'MainArea.openUri': wrapSerialAsyncCommand(openUriWithContext),
+  'MainArea.openUris': wrapSerialAsyncCommand(openUrisWithContext),
+  'MainArea.refresh': wrapSerialCommand(refresh),
   'MainArea.render2': render2,
   'MainArea.renderEventListeners': renderEventListeners,
   'MainArea.resize': wrapGetter(handleResize),
-  'MainArea.restoreClosedTab': wrapCommand(restoreClosedTab),
-  'MainArea.save': wrapCommand(save),
+  'MainArea.restoreClosedTab': wrapSerialCommand(restoreClosedTab),
+  'MainArea.save': wrapSerialCommand(save),
   'MainArea.saveState': wrapGetter(saveState),
-  'MainArea.selectTab': wrapCommand(selectTab),
-  'MainArea.setEditorLayoutGrid': wrapCommand(setEditorLayoutGrid),
-  'MainArea.setEditorLayoutSingle': wrapCommand(setEditorLayoutSingle),
-  'MainArea.setEditorLayoutThreeColumns': wrapCommand(setEditorLayoutThreeColumns),
-  'MainArea.setEditorLayoutThreeRows': wrapCommand(setEditorLayoutThreeRows),
-  'MainArea.setEditorLayoutTwoColumns': wrapCommand(setEditorLayoutTwoColumns),
-  'MainArea.setEditorLayoutTwoColumnsBottom': wrapCommand(setEditorLayoutTwoColumnsBottom),
-  'MainArea.setEditorLayoutTwoRows': wrapCommand(setEditorLayoutTwoRows),
-  'MainArea.setEditorLayoutTwoRowsRight': wrapCommand(setEditorLayoutTwoRowsRight),
-  'MainArea.splitDown': wrapCommand(splitDown),
-  'MainArea.splitLeft': wrapCommand(splitLeft),
-  'MainArea.splitRight': wrapCommand(splitRight),
-  'MainArea.splitUp': wrapCommand(splitUp),
+  'MainArea.selectTab': wrapSerialCommand(selectTab),
+  'MainArea.setEditorLayoutGrid': wrapSerialCommand(setEditorLayoutGrid),
+  'MainArea.setEditorLayoutSingle': wrapSerialCommand(setEditorLayoutSingle),
+  'MainArea.setEditorLayoutThreeColumns': wrapSerialCommand(setEditorLayoutThreeColumns),
+  'MainArea.setEditorLayoutThreeRows': wrapSerialCommand(setEditorLayoutThreeRows),
+  'MainArea.setEditorLayoutTwoColumns': wrapSerialCommand(setEditorLayoutTwoColumns),
+  'MainArea.setEditorLayoutTwoColumnsBottom': wrapSerialCommand(setEditorLayoutTwoColumnsBottom),
+  'MainArea.setEditorLayoutTwoRows': wrapSerialCommand(setEditorLayoutTwoRows),
+  'MainArea.setEditorLayoutTwoRowsRight': wrapSerialCommand(setEditorLayoutTwoRowsRight),
+  'MainArea.splitDown': wrapSerialCommand(splitDown),
+  'MainArea.splitLeft': wrapSerialCommand(splitLeft),
+  'MainArea.splitRight': wrapSerialCommand(splitRight),
+  'MainArea.splitUp': wrapSerialCommand(splitUp),
   'MainArea.terminate': terminate
 };