mbeditor 0.12.9 → 0.13.1

data/app/assets/javascripts/mbeditor/components/MbeditorApp.js

@@ -10,6 +10,7 @@ var _React = React;
 var useState = _React.useState;
 var useEffect = _React.useEffect;
 var useRef = _React.useRef;
+var useMemo = _React.useMemo;
 
 // Functional setTreeData updater shared by every path that re-fetches the tree
 // (WebSocket push, the 10s poll, the manual refresh button).
@@ -109,7 +110,6 @@ var DEFAULT_EDITOR_PREFS = {
   autoClosingBrackets: 'always',
   autoClosingQuotes: 'always',
   autoIndent: 'full',
-  indentOnPaste: true,
   formatOnType: false,
   formatOnSave: false,
   quickSuggestions: true,
@@ -118,6 +118,7 @@ var DEFAULT_EDITOR_PREFS = {
   autoRevealInExplorer: true,
   toolbarIconOnly: false,
   rubocopLintEnabled: true,
+  routeHints: true,
   prettierPrintWidth: 80,
   prettierSemi: true,
   prettierSingleQuote: false,
@@ -169,18 +170,32 @@ var SidebarActionButton = function SidebarActionButton(_ref) {
   var _ref$ariaBusy = _ref.ariaBusy;
   var ariaBusy = _ref$ariaBusy === undefined ? false : _ref$ariaBusy;
 
+  // The tooltip lives on a wrapper, not on the button, and is drawn by CSS
+  // rather than the title attribute. Both parts are load-bearing:
+  //
+  // The host app's Pico CSS sets `pointer-events: none` on [disabled], so a
+  // disabled button never receives hover and a native title never appears at
+  // all — and Rename/Delete are disabled whenever nothing is selected, which
+  // is most of the time. Hanging the tooltip on an always-enabled wrapper is
+  // what keeps it working in that state.
+  //
+  // Native titles are also ~1s late, which is already why .collab-hovercard
+  // exists rather than a title on the collab chip.
   return React.createElement(
-    "button",
-    {
-      type: "button",
-      className: "project-action-btn" + (danger ? " danger" : ""),
-      title: title,
-      "aria-label": ariaLabel || title,
-      "aria-busy": !!ariaBusy,
-      onClick: onClick,
-      disabled: !!disabled
-    },
-    !ariaBusy && React.createElement("i", { className: iconClass })
+    "span",
+    { className: "sb-tip", "data-tip": title },
+    React.createElement(
+      "button",
+      {
+        type: "button",
+        className: "project-action-btn" + (danger ? " danger" : ""),
+        "aria-label": ariaLabel || title,
+        "aria-busy": !!ariaBusy,
+        onClick: onClick,
+        disabled: !!disabled
+      },
+      !ariaBusy && React.createElement("i", { className: iconClass })
+    )
   );
 };
 
@@ -201,6 +216,23 @@ var SectionActionGroup = function SectionActionGroup(_ref2) {
   );
 };
 
+// Split a search hit into [before, match, after] so the match can be tinted
+// and pinned on screen. `col`/`end_col` are 1-based against the RAW line while
+// the row renders the stripped `text`, so `lead` — the characters strip took
+// off the front — is what maps one onto the other. Returns null for the tiers
+// and queries that produce no columns; the row then renders as plain text.
+function searchMatchParts(res) {
+  var text = res.text == null ? "" : String(res.text);
+  if (!res.col || !res.end_col) return null;
+  var start = res.col - 1 - (res.lead || 0);
+  var end = Math.min(res.end_col - 1 - (res.lead || 0), text.length);
+  if (!(start >= 0 && end > start && start < text.length)) return null;
+  // U+200E: a strong LTR character, so the left-ellipsis trick in
+  // .search-result-pre (direction: rtl) can never reorder a segment that
+  // happens to be all punctuation.
+  return ["‎" + text.slice(0, start), text.slice(start, end), text.slice(end)];
+}
+
 function FileReloadBanner(_ref) {
   var pendingReloads = _ref.pendingReloads;
   var onSaveAndReload = _ref.onSaveAndReload;
@@ -347,6 +379,67 @@ var MbeditorApp = function MbeditorApp() {
   var searchWholeWordRef = useRef(false);
   var searchResultsContainerRef = useRef(null);
 
+  // Search results are windowed: a project-wide query can return up to
+  // SearchReplaceService::MAX_RESULTS (10_000) rows, and every row is five
+  // elements, so rendering the list in full built ~50k nodes — enough to kill
+  // the tab outright, and 92 ms of render for a mere 3_000 rows. Rows are a
+  // fixed 22px, which is what makes the arithmetic here as simple as the file
+  // tree's. The results are a VS Code-style tree — a header row per file, its
+  // matches nested under it — but header and match rows are deliberately the
+  // *same* height (.search-result-file-row and .search-result-item both pin
+  // it), so the flattened row array still windows by plain multiplication.
+  // Give the two rows different heights and every offset here is wrong.
+  var SEARCH_ROW_HEIGHT = 22;
+  var SEARCH_ROW_BUFFER = 5;
+
+  // File paths whose match list is folded away. Keyed by path, so a file that
+  // scrolls out of the window keeps its state.
+  var _useStateSC = useState({});
+  var _useStateSC2 = _slicedToArray(_useStateSC, 2);
+  var searchCollapsedFiles = _useStateSC2[0];
+  var setSearchCollapsedFiles = _useStateSC2[1];
+  var toggleSearchFile = function toggleSearchFile(file) {
+    setSearchCollapsedFiles(function (prev) {
+      var next = Object.assign({}, prev);
+      if (next[file]) delete next[file]; else next[file] = true;
+      return next;
+    });
+  };
+  var _useStateSV = useState({ scrollTop: 0, height: 0 });
+  var _useStateSV2 = _slicedToArray(_useStateSV, 2);
+  var searchViewport = _useStateSV2[0];
+  var setSearchViewport = _useStateSV2[1];
+
+  // The container's height is only known once it is on screen, and a viewport
+  // of 0 would render a single row and never grow — nothing would scroll, so
+  // no scroll event would arrive to correct it.
+  //
+  // Measured from a callback ref rather than an effect: the results list
+  // mounts and unmounts as the sidebar tab changes and as a query goes from
+  // no-results to results, none of which an effect's dependency list sees.
+  // Same reason the model graph wires its pan/zoom this way.
+  var searchViewportObserverRef = useRef(null);
+  var measureSearchViewport = function measureSearchViewport(el) {
+    if (!el) return;
+    setSearchViewport(function (prev) {
+      if (prev.height === el.clientHeight && prev.scrollTop === el.scrollTop) return prev;
+      return { scrollTop: el.scrollTop, height: el.clientHeight };
+    });
+  };
+  var attachSearchResults = useRef(function (el) {
+    if (searchViewportObserverRef.current) {
+      searchViewportObserverRef.current.disconnect();
+      searchViewportObserverRef.current = null;
+    }
+    searchResultsContainerRef.current = el;
+    if (!el) return;
+    measureSearchViewport(el);
+    if (typeof ResizeObserver === 'undefined') return;
+    var obs = new ResizeObserver(function () { measureSearchViewport(el); });
+    obs.observe(el);
+    searchViewportObserverRef.current = obs;
+  }).current;
+
   var _useStateRM = useState(false);
   var _useStateRM2 = _slicedToArray(_useStateRM, 2);
   var replaceMode = _useStateRM2[0];
@@ -408,6 +501,12 @@ var MbeditorApp = function MbeditorApp() {
   var importConflict = _useStateImportConflict2[0];
   var setImportConflict = _useStateImportConflict2[1];
 
+  // { initialFolder } while the upload dialog is open, null otherwise.
+  var _useStateImportDialog = useState(null);
+  var _useStateImportDialog2 = _slicedToArray(_useStateImportDialog, 2);
+  var importDialog = _useStateImportDialog2[0];
+  var setImportDialog = _useStateImportDialog2[1];
+
   var _useStateSchemaLoading = useState(null);
   var _useStateSchemaLoading2 = _slicedToArray(_useStateSchemaLoading, 2);
   var schemaLoadingLabel = _useStateSchemaLoading2[0];
@@ -544,13 +643,6 @@ var MbeditorApp = function MbeditorApp() {
   var modelGraphLoading = _useStateModelGraphLoading2[0];
   var setModelGraphLoading = _useStateModelGraphLoading2[1];
 
-  // ruby-lsp status for the status-bar chip. 'off' means never available here,
-  // 'degraded' means we backed off after a failure, 'ok' means it's answering.
-  var _useStateLspHealth = useState({ status: 'off', reason: null });
-  var _useStateLspHealth2 = _slicedToArray(_useStateLspHealth, 2);
-  var lspHealth = _useStateLspHealth2[0];
-  var setLspHealth = _useStateLspHealth2[1];
-
   var _useState18g = useState(320);
   var _useState18g2 = _slicedToArray(_useState18g, 2);
   var gitPanelWidth = _useState18g2[0];
@@ -606,11 +698,6 @@ var MbeditorApp = function MbeditorApp() {
   var rubocopConfigPath = _useState18rc2[0];
   var setRubocopConfigPath = _useState18rc2[1];
 
-  var _useState18t = useState(false);
-  var _useState18t2 = _slicedToArray(_useState18t, 2);
-  var testAvailable = _useState18t2[0];
-  var setTestAvailable = _useState18t2[1];
-
   var _useState18u = useState(null);
   var _useState18u2 = _slicedToArray(_useState18u, 2);
   var testResult = _useState18u2[0];
@@ -757,6 +844,11 @@ var MbeditorApp = function MbeditorApp() {
     if (typeof content === 'string') {
       lastDiskContentRef.current[path] = content.replace(/\r\n/g, '\n');
     }
+    // The file on disk just moved, so any line-diff answer we are holding for
+    // it predates the write and must not be reused for the tint.
+    if (typeof GitService !== 'undefined' && GitService.invalidateLineDiff) {
+      GitService.invalidateLineDiff(path);
+    }
   }
 
   // ── Draft backup helpers ─────────────────────────────────────────────────
@@ -821,6 +913,13 @@ var MbeditorApp = function MbeditorApp() {
     });
   };
 
+  // filterDotFiles rebuilds the whole tree, so calling it inline in the render
+  // handed FileTreeMemo a fresh array every time and its `prev.items ===
+  // next.items` check never held — the memo was there but never fired.
+  var fileTreeItems = useMemo(function () {
+    return editorPrefs.showDotFiles ? treeData : filterDotFiles(treeData || []);
+  }, [treeData, editorPrefs.showDotFiles]);
+
   var normalizeRelativePath = function normalizeRelativePath(input) {
     return (input || "").replace(/\\/g, "/").trim().replace(/^\/+/, "").replace(/\/+$/, "").replace(/\/+/g, "/");
   };
@@ -863,10 +962,22 @@ var MbeditorApp = function MbeditorApp() {
   // cached page was served for the same query. The per-path delta refresh on
   // the files_changed push can't cover it either: it re-scans named files,
   // and a file that just appeared or vanished isn't in the previous result set.
+  // True when the server will push a files_changed broadcast for a write we are
+  // about to make, so the coalesced handler will refresh the tree and git for
+  // us. Every mutation used to refresh both itself as well, which doubled or
+  // tripled the most expensive requests the editor makes. Without a socket
+  // nothing arrives, so callers keep their own refresh for that case.
+  var _socketWillBroadcast = function _socketWillBroadcast() {
+    return typeof WebSocketService !== 'undefined' &&
+      typeof WebSocketService.isCableAvailable === 'function' &&
+      WebSocketService.isCableAvailable();
+  };
+
   var refreshProjectTree = function refreshProjectTree() {
     return FileService.getTree().then(function (data) {
-      setTreeData(data || []);
-      SearchService.buildIndex(data || []);
+      // _treeUpdater keeps the previous array (and skips the index rebuild)
+      // when the tree is unchanged; going round it re-rendered the whole app.
+      setTreeData(_treeUpdater(data || []));
       SearchService.invalidate();
       if (searchQueryRef.current && searchPanelVisibleRef.current) {
         _debouncedSearch(searchQueryRef.current);
@@ -930,73 +1041,18 @@ var MbeditorApp = function MbeditorApp() {
     loadModelGraph(false);
   }, [activeSidebarTab, sidebarCollapsed]);
 
-  var readLspHealth = function readLspHealth() {
-    if (!window.MBEDITOR_RUBY_LSP_AVAILABLE) {
-      return { status: 'off', reason: window.MBEDITOR_RUBY_LSP_REASON || null };
-    }
-    if (window.MbeditorEditorPlugins && MbeditorEditorPlugins.lspBackedOff()) {
-      return { status: 'degraded', reason: window.MBEDITOR_RUBY_LSP_REASON || null };
-    }
-    return { status: 'ok', reason: null };
-  };
-
-  // The backoff expires on a wall-clock deadline rather than a timer, so the
-  // chip also re-reads on a slow interval — otherwise it would sit on
-  // 'degraded' until the next failure or restart click.
+  // The one writer for the markers map. Two things it must not do:
   //
-  // readLspHealth() builds a fresh object every call, so handing it straight to
-  // setLspHealth re-rendered the whole app every 10 seconds whether or not the
-  // health had changed — React bails on Object.is, and two object literals are
-  // never identical. Compare the fields and keep the previous object when they
-  // match. (Same shape of bug as the file-tree poll; see _treeUpdater.)
-  useEffect(function () {
-    var sync = function () {
-      setLspHealth(function (prev) {
-        var next = readLspHealth();
-        if (prev && prev.status === next.status && prev.reason === next.reason) return prev;
-        return next;
-      });
-    };
-    sync();
-    window.addEventListener('mbeditor:lsp-health', sync);
-    var tick = setInterval(sync, 10000);
-    return function () {
-      window.removeEventListener('mbeditor:lsp-health', sync);
-      clearInterval(tick);
-    };
-  }, []);
-
-  var restartRubyLsp = function restartRubyLsp() {
-    if (!FileService.rubyLspRequest) return;
-    EditorStore.setStatus('Restarting ruby-lsp…', 'info');
-    FileService.rubyLspRequest('restart', '', '', 1, 1).then(function (data) {
-      var ok = data && data.available && data.state !== 'failed';
-      if (ok) {
-        window.MBEDITOR_RUBY_LSP_AVAILABLE = true;
-        window.MBEDITOR_RUBY_LSP_DISABLED_UNTIL = 0;
-        window.MBEDITOR_RUBY_LSP_REASON = null;
-      } else {
-        window.MBEDITOR_RUBY_LSP_REASON =
-          (data && (data.reason || data.error)) || 'ruby-lsp did not come back';
-      }
-      EditorStore.setStatus(ok ? 'ruby-lsp restarted' : 'ruby-lsp unavailable', ok ? 'success' : 'warning');
-      setLspHealth(readLspHealth());
-    })["catch"](function (err) {
-      noteLspFailure(err);
-      EditorStore.setStatus('Could not restart ruby-lsp', 'error');
-      setLspHealth(readLspHealth());
-    });
-  };
-
-  var applyMarkersForTab = function applyMarkersForTab(paneId, tabId, nextMarkers) {
-    var currentPane = EditorStore.getState().panes.find(function (p) {
-      return p.id === paneId;
-    });
-    var current = currentPane ? currentPane.tabs.find(function (t) {
-      return t.id === tabId;
-    }) : null;
-    if (current) current.markers = nextMarkers;
+  //   * write a fresh map when nothing changed — the auto-lint fires per
+  //     keystroke on JS files and re-clearing an already-empty marker list
+  //     would re-render the whole app every time;
+  //   * mutate the tab object in the store — EditorStore's contract is that
+  //     every nested value is replaced, never edited in place, or
+  //     subscribeToSlice cannot see the change. TabBar reads this map instead.
+  var applyMarkersForTab = function applyMarkersForTab(tabId, nextMarkers) {
     setMarkers(function (prev) {
+      var cur = prev[tabId];
+      if (cur && cur.length === 0 && nextMarkers.length === 0) return prev;
       return _extends({}, prev, _defineProperty({}, tabId, nextMarkers));
     });
   };
@@ -1006,6 +1062,20 @@ var MbeditorApp = function MbeditorApp() {
 
     if (!tab || (!isRubyPath(tab.path) && !tab.path.endsWith('.haml'))) return Promise.resolve(null);
 
+    // An empty buffer has no offenses, and answering that here rather than over
+    // the wire skips the most expensive request the Ruby path makes: a
+    // whole-document RuboCop run, budgeted at 10s server-side. It matters
+    // because every newly created .rb file starts empty and is opened
+    // immediately, so the lint fired on a document with nothing in it.
+    // Resolving with an empty marker set (rather than null) keeps the
+    // marker-clearing below intact, so deleting a file's contents still clears
+    // its squiggles.
+    if (!String(tab.content || '').trim()) {
+      applyMarkersForTab(tab.id, []);
+      if (options.showStatus) EditorStore.setStatus('No RuboCop offenses!', 'success');
+      return Promise.resolve({ markers: [] });
+    }
+
     if (options.showLoading) {
       setLoading(function (prev) {
         return _extends({}, prev, { lint: true });
@@ -1037,7 +1107,7 @@ var MbeditorApp = function MbeditorApp() {
 
     return lintRequest.then(function (res) {
       var nextMarkers = res.markers || [];
-      applyMarkersForTab(paneId, tab.id, nextMarkers);
+      applyMarkersForTab(tab.id, nextMarkers);
 
       if (options.showStatus) {
         var count = res.summary && res.summary.offense_count || 0;
@@ -1075,16 +1145,7 @@ var MbeditorApp = function MbeditorApp() {
     if (parserName && window.prettier && window.prettierPlugins) {
       var prefs = EditorStore.getState().editorPrefs || DEFAULT_EDITOR_PREFS;
       window.prettier.format(tab.content, prettierOptions(prefs, parserName)).then(function () {
-        var currentPane = EditorStore.getState().panes.find(function (p) {
-          return p.id === paneId;
-        });
-        var current = currentPane ? currentPane.tabs.find(function (t) {
-          return t.id === tab.id;
-        }) : null;
-        if (current) current.markers = [];
-        setMarkers(function (prev) {
-          return _extends({}, prev, _defineProperty({}, tab.id, []));
-        });
+        applyMarkersForTab(tab.id, []);
       })["catch"](function (err) {
         var newMarkers = [];
         if (err && err.loc) {
@@ -1101,16 +1162,7 @@ var MbeditorApp = function MbeditorApp() {
             endCol: endLoc ? endLoc.column : loc.column + 1
           });
         }
-        var currentPane = EditorStore.getState().panes.find(function (p) {
-          return p.id === paneId;
-        });
-        var current = currentPane ? currentPane.tabs.find(function (t) {
-          return t.id === tab.id;
-        }) : null;
-        if (current) current.markers = newMarkers;
-        setMarkers(function (prev) {
-          return _extends({}, prev, _defineProperty({}, tab.id, newMarkers));
-        });
+        applyMarkersForTab(tab.id, newMarkers);
       });
     }
   }, 600)).current;
@@ -1168,8 +1220,8 @@ var MbeditorApp = function MbeditorApp() {
       if (workspace && typeof workspace.redmineEnabled === 'boolean') {
         setRedmineEnabled(workspace.redmineEnabled);
       }
-      if (workspace && typeof workspace.testAvailable === 'boolean') {
-        setTestAvailable(workspace.testAvailable);
+      if (workspace && workspace.testTimeout) {
+        FileService.setTestTimeout(workspace.testTimeout);
       }
       if (workspace && typeof workspace.actionCableEnabled === 'boolean') {
         WebSocketService.connect(workspace.actionCableEnabled);
@@ -1683,8 +1735,32 @@ var MbeditorApp = function MbeditorApp() {
   // WebSocket push — when the server broadcasts files_changed, refresh the tree
   // and git status immediately (same work as the 10s poll below does).
   useEffect(function () {
-    function handleFilesChanged(payload) {
-      if (document.hidden) return;
+    // One broadcast per written file, so a bulk write (Save All, Format All,
+    // a drag-and-drop import, a rename) used to cost one full tree walk and
+    // one git status PER FILE, all in flight at once. On a real host repo
+    // those are the two most expensive requests the editor makes, and with
+    // the browser's six sockets per host the saves themselves ended up queued
+    // behind their own fallout — past ~30 files the POSTs hit the 30 s axios
+    // timeout and Save All reported failure for writes that had succeeded.
+    // The refresh is idempotent, so a burst only needs one of each.
+    var timer = null;
+    var pendingPaths = [];
+    var pendingFullCheck = false;
+    var pendingStructural = false;
+
+    function flush() {
+      timer = null;
+      // The named paths and "re-check everything" are two separate questions.
+      // Collapsing them lost the paths whenever a path-less broadcast (a new
+      // directory, say) landed in the same window as a save, and the saved
+      // file's search rows then stayed stale until the next edit.
+      var paths = pendingPaths;
+      var fullCheck = pendingFullCheck;
+      var structural = pendingStructural;
+      pendingPaths = [];
+      pendingFullCheck = false;
+      pendingStructural = false;
+      var tabsToCheck = (fullCheck || paths.length === 0) ? null : paths;
       // The cheap /git_status probe, not the full /git_info fan-out. This
       // fires on every save, and the fan-out is the most expensive request
       // the editor makes — on a dev server with a handful of threads it
@@ -1693,17 +1769,75 @@ var MbeditorApp = function MbeditorApp() {
       // branch and file list immediately and escalates to the fan-out on its
       // own when the branch actually changed.
       GitService.fetchStatusLite({ background: true })["catch"](function () {});
-      FileService.getTree().then(function (data) {
-        setTreeData(_treeUpdater(data || []));
-        checkOpenTabsForExternalChanges(payload && payload.paths);
-      })["catch"](function () {});
-      if (payload && payload.paths && searchQueryRef.current && searchPanelVisibleRef.current) {
-        payload.paths.forEach(function (p) { _pendingSearchRefreshPaths.current.add(p); });
+
+      // A save changes a file's contents, not the shape of the workspace, so
+      // there is nothing in the tree for it to invalidate: the names, the
+      // nesting and the quick-open index are all exactly as they were. Walking
+      // the whole workspace to learn that — and then rebuilding the MiniSearch
+      // index from the result, because the file's byte count moved and made
+      // the payload compare unequal — was pure cost on the save path, and it
+      // grew with the size of the checkout rather than with the edit.
+      // Git badges come from git_status above, not from this payload.
+      if (structural) {
+        FileService.getTree().then(function (data) {
+          setTreeData(_treeUpdater(data || []));
+          checkOpenTabsForExternalChanges(tabsToCheck);
+        })["catch"](function () {});
+      } else {
+        checkOpenTabsForExternalChanges(tabsToCheck);
+      }
+
+      if (paths.length && searchQueryRef.current && searchPanelVisibleRef.current) {
+        paths.forEach(function (p) { _pendingSearchRefreshPaths.current.add(p); });
         _flushSearchRefresh();
       }
     }
+
+    function handleFilesChanged(payload) {
+      if (document.hidden) return;
+      // No paths named means "something changed, re-check everything" — it
+      // must not be swallowed by a burst that did name paths.
+      if (!payload || !payload.paths) pendingFullCheck = true;
+      else pendingPaths = pendingPaths.concat(payload.paths);
+      // Absent (an older server) counts as structural — the conservative read.
+      if (!payload || payload.structural !== false) pendingStructural = true;
+      if (timer) return;
+      timer = setTimeout(flush, 200);
+    }
+    // Deferring the refresh means it can now come due after the page has begun
+    // going away. Requests issued into a closing page are aborted mid-flight,
+    // which wastes a tree walk and leaves the server holding a connection that
+    // never completes.
+    var cancelPending = function () {
+      if (timer) clearTimeout(timer);
+      timer = null;
+    };
+    window.addEventListener('pagehide', cancelPending);
+
     WebSocketService.onFilesChanged(handleFilesChanged);
-    return function () { WebSocketService.offFilesChanged(handleFilesChanged); };
+    return function () {
+      cancelPending();
+      window.removeEventListener('pagehide', cancelPending);
+      WebSocketService.offFilesChanged(handleFilesChanged);
+    };
+  }, []);
+
+  // A branch switch changes every tracked file at once, and no push announces
+  // it — the broadcast only covers mbeditor's own writes. Re-read the tree and
+  // every open tab, the same work a manual workspace refresh does. Clean tabs
+  // take the new branch's content; dirty ones queue the usual reload prompt,
+  // so unsaved work is never overwritten.
+  useEffect(function () {
+    function onBranchChanged() {
+      SearchService.invalidate();
+      FileService.getTree({ refresh: true }).then(function (data) {
+        setTreeData(_treeUpdater(data || []));
+      })["catch"](function () {})["finally"](function () {
+        checkOpenTabsForExternalChanges();
+      });
+    }
+    window.addEventListener('mbeditor:branch-changed', onBranchChanged);
+    return function () { window.removeEventListener('mbeditor:branch-changed', onBranchChanged); };
   }, []);
 
   // WebSocket push — when a peer saves a collaboratively-bound file, the CRDT has
@@ -1839,6 +1973,12 @@ var MbeditorApp = function MbeditorApp() {
               });
             })
           });
+          // The text just moved under the diagnostics. Only the mounted editor
+          // re-lints, so without this a background tab kept reporting offenses
+          // at line numbers the external write had shifted — and the Problems
+          // panel and status-bar tallies reported them too. Dropping them says
+          // "not known yet", which is true: the file re-lints when you open it.
+          discardStaleMarkers(pt.tab.path);
         } else {
           // Re-verify the tab still exists before queuing
           var currentState = EditorStore.getState();
@@ -1926,7 +2066,13 @@ var MbeditorApp = function MbeditorApp() {
       if (timer) clearTimeout(timer);
       timer = setTimeout(function () {
         timer = null;
-        setProblemCounts(window.ProblemsPanel.counts());
+        var next = window.ProblemsPanel.counts();
+        // Two object literals are never Object.is-equal, so handing React a
+        // fresh {errors, warnings} re-rendered the app on every marker change
+        // — which for a JS file is every keystroke. Compare the fields.
+        setProblemCounts(function (prev) {
+          return (prev && prev.errors === next.errors && prev.warnings === next.warnings) ? prev : next;
+        });
       }, 250);
     };
 
@@ -1939,8 +2085,8 @@ var MbeditorApp = function MbeditorApp() {
     };
   }, [monacoReady]);
 
-  var handleSelectFile = function handleSelectFile(path, name, line, col) {
-    TabManager.openTab(path, name, line, null, false, col);
+  var handleSelectFile = function handleSelectFile(path, name, line, col, endCol) {
+    TabManager.openTab(path, name, line, null, false, col, endCol);
     handleNodeSelect({ path: path, name: name || path.split('/').pop(), type: 'file' });
     setQuickOpen(false);
   };
@@ -1968,6 +2114,33 @@ var MbeditorApp = function MbeditorApp() {
     handleNodeSelect({ path: path, name: name || path.split('/').pop(), type: 'file' });
   };
 
+  // Both of these are keyed by something that dies with the tab — markers by
+  // tab id, the external-change baseline by path — and nothing dropped them, so
+  // a long session held a full copy of every file it had ever opened. Run after
+  // a close (single or bulk) and reconcile against what is still open: a path
+  // the other pane still shows keeps its baseline, which a per-tab delete
+  // would have got wrong.
+  var forgetClosedTabs = function forgetClosedTabs() {
+    var openIds = {};
+    var openPaths = {};
+    EditorStore.getState().panes.forEach(function (p) {
+      p.tabs.forEach(function (t) {
+        openIds[t.id] = true;
+        if (t.path) openPaths[t.path] = true;
+      });
+    });
+    Object.keys(lastDiskContentRef.current).forEach(function (path) {
+      if (!openPaths[path]) delete lastDiskContentRef.current[path];
+    });
+    setMarkers(function (prev) {
+      var stale = Object.keys(prev).filter(function (id) { return !openIds[id]; });
+      if (stale.length === 0) return prev;
+      var next = _extends({}, prev);
+      stale.forEach(function (id) { delete next[id]; });
+      return next;
+    });
+  };
+
   var requestCloseTab = function requestCloseTab(paneId, id) {
     var pane = state.panes.find(function (p) {
       return p.id === paneId;
@@ -1987,6 +2160,7 @@ var MbeditorApp = function MbeditorApp() {
           });
         })
       });
+      forgetClosedTabs();
     }
   };
 
@@ -2040,6 +2214,7 @@ var MbeditorApp = function MbeditorApp() {
             });
           })
         });
+        forgetClosedTabs();
       })["catch"](function (err) {
         EditorStore.setStatus("Save failed: " + err.message, "error");
       })["finally"](function () {
@@ -2059,6 +2234,7 @@ var MbeditorApp = function MbeditorApp() {
           });
         })
       });
+      forgetClosedTabs();
       setClosingTabId(null);
       setClosingPaneId(null);
     }
@@ -2083,6 +2259,7 @@ var MbeditorApp = function MbeditorApp() {
     if (!confirmBulkClose(allTabs, "all editors")) return;
 
     TabManager.closeAllTabs();
+    forgetClosedTabs();
     setClosingTabId(null);
     setClosingPaneId(null);
     EditorStore.setStatus("Closed " + allTabs.length + " editor" + (allTabs.length === 1 ? "" : "s"), "info");
@@ -2096,6 +2273,7 @@ var MbeditorApp = function MbeditorApp() {
     if (!confirmBulkClose(pane.tabs, "all editors in Group " + paneId)) return;
 
     TabManager.closeAllTabsInPane(paneId);
+    forgetClosedTabs();
     setClosingTabId(null);
     setClosingPaneId(null);
     EditorStore.setStatus("Closed " + pane.tabs.length + " editor" + (pane.tabs.length === 1 ? "" : "s") + " in Group " + paneId, "info");
@@ -2108,6 +2286,7 @@ var MbeditorApp = function MbeditorApp() {
     if (others.length === 0) return;
     if (!confirmBulkClose(others, "other editors")) return;
     TabManager.closeOtherTabsInPane(paneId, keepId);
+    forgetClosedTabs();
     EditorStore.setStatus("Closed " + others.length + " editor" + (others.length === 1 ? "" : "s"), "info");
   };
 
@@ -2117,6 +2296,7 @@ var MbeditorApp = function MbeditorApp() {
     var saved = pane.tabs.filter(function (t) { return !t.dirty; });
     if (saved.length === 0) return;
     TabManager.closeSavedTabsInPane(paneId);
+    forgetClosedTabs();
     EditorStore.setStatus("Closed " + saved.length + " saved editor" + (saved.length === 1 ? "" : "s"), "info");
   };
 
@@ -2134,6 +2314,7 @@ var MbeditorApp = function MbeditorApp() {
       GitService.fetchStatusLite({ background: true });
       FileService.getTree().then(function (data) { setTreeData(_treeUpdater(data || [])); })["catch"](function () {});
       TabManager.closeTab(paneId, tab.id);
+      forgetClosedTabs();
       if (!(opts && opts.close)) {
         TabManager.openTab(newPath, newPath.split('/').pop(), null, paneId);
       }
@@ -2296,7 +2477,10 @@ var MbeditorApp = function MbeditorApp() {
   var RAILS_MAX_RESOURCES = 10;
 
   // Map resource label → representative path (capped at RAILS_MAX_RESOURCES, focused pane first)
-  var railsResourceDeps = (function() {
+  // Memoised: all three of these walk every tab in every pane and were rebuilt
+  // on every render, including the ones a keystroke causes.
+  // resourceLabelFromPath reads customPathsRef, hence customPaths in the deps.
+  var railsResourceDeps = useMemo(function() {
     var deps = {};
     var panesOrdered = state.panes.slice().sort(function(a, b) {
       return a.id === state.focusedPaneId ? -1 : b.id === state.focusedPaneId ? 1 : 0;
@@ -2313,10 +2497,10 @@ var MbeditorApp = function MbeditorApp() {
       });
     });
     return deps;
-  })();
+  }, [state.panes, state.focusedPaneId, customPaths]);
   var railsResourceDepStr = Object.keys(railsResourceDeps).sort().join('|');
 
-  var railsOverflow = (function() {
+  var railsOverflow = useMemo(function() {
     var all = {};
     state.panes.forEach(function(p) {
       p.tabs.forEach(function(t) {
@@ -2326,9 +2510,9 @@ var MbeditorApp = function MbeditorApp() {
       });
     });
     return Math.max(0, Object.keys(all).length - Object.keys(railsResourceDeps).length);
-  })();
+  }, [state.panes, railsResourceDeps, customPaths]);
 
-  var dirtyPaths = (function() {
+  var dirtyPaths = useMemo(function() {
     var set = {};
     state.panes.forEach(function(p) {
       p.tabs.forEach(function(t) {
@@ -2336,7 +2520,7 @@ var MbeditorApp = function MbeditorApp() {
       });
     });
     return set;
-  })();
+  }, [state.panes]);
 
   useEffect(function() {
     if (activeSidebarTab !== 'rails') return;
@@ -2552,17 +2736,43 @@ var MbeditorApp = function MbeditorApp() {
   // unchanged state is an identical string and React bails rather than
   // re-rendering the app every tick.
   useEffect(function () {
+    // A reconnect is not a fault. Action Cable drops and re-establishes its
+    // socket routinely, and a dev server busy with a burst of saves is enough
+    // to cause it — the cable shares the same thread pool as every request the
+    // editor makes. Reporting the first non-connected sample made the chip
+    // announce "Pairing off" during exactly the moments the editor was already
+    // struggling, then clear a few seconds later, which reads as a second
+    // failure rather than as the self-healing reconnect it actually is.
+    //
+    // So a transient state has to be seen twice before it is shown, with the
+    // confirming check brought forward so a real outage still surfaces in
+    // seconds. Hard failures are exempt: missing libraries, no Action Cable, a
+    // server that does not advertise it, or a *rejected* handshake never heal
+    // on their own, so they report on the first sample as before.
+    var TRANSIENT_PROBLEMS = { connected: true };
+    var unconfirmed = null;
+    var recheckTimer = null;
+
     function check() {
       if (typeof CollaborationService === 'undefined' ||
           typeof CollaborationService.diagnostics !== 'function') return;
       var d = CollaborationService.diagnostics();
       // "Nobody else is here" is not a fault; everything else is.
       var problem = d.firstProblem && d.firstProblem.key !== 'peers' ? d.firstProblem.key : null;
+      var transient = !!problem && !!TRANSIENT_PROBLEMS[problem] && d.cableStatus !== 'rejected';
+
+      if (transient && unconfirmed !== problem) {
+        unconfirmed = problem;
+        clearTimeout(recheckTimer);
+        recheckTimer = setTimeout(check, 3000);
+        return;
+      }
+      unconfirmed = transient ? problem : null;
       setCollabTrouble(function (prev) { return prev === problem ? prev : problem; });
     }
     check();
     var id = setInterval(check, 10000);
-    return function () { clearInterval(id); };
+    return function () { clearInterval(id); clearTimeout(recheckTimer); };
   }, []);
 
   var collabPeerIds = Object.keys(collabRoster);
@@ -2689,7 +2899,7 @@ var MbeditorApp = function MbeditorApp() {
 
     // Clear markers and skip auto-lint when RuboCop linting is disabled
     if (isRubyPath(activeTab.path) && editorPrefs.rubocopLintEnabled === false) {
-      setMarkers(function(prev) { return _extends({}, prev, _defineProperty({}, activeTab.id, [])); });
+      applyMarkersForTab(activeTab.id, []);
       return;
     }
 
@@ -2767,7 +2977,18 @@ var MbeditorApp = function MbeditorApp() {
     return runPrettier(tab.content, editorPrefs, parserName)["catch"](function () { return null; });
   };
 
+  // Re-read a tab from the store after flushing TabManager's throttled content
+  // write. `tab` here is whatever the render captured, so flushing alone is not
+  // enough — the fresh text lands in the store, not in this object.
+  var _freshTab = function _freshTab(paneId, tab) {
+    TabManager.flushContent();
+    var pane = EditorStore.getState().panes.find(function (p) { return p.id === paneId; });
+    var live = pane && pane.tabs.find(function (t) { return t.id === tab.id; });
+    return live || tab;
+  };
+
   var handleSave = function handleSave(paneId, tab) {
+    tab = _freshTab(paneId, tab);
     if (editorPrefs.formatOnSave === true) {
       EditorStore.setStatus("Formatting " + tab.name + "...", "info");
       _formatContentForSave(tab).then(function (formatted) {
@@ -2844,21 +3065,25 @@ var MbeditorApp = function MbeditorApp() {
         FileService.lintFile(tab.path, tab.content, 'javascript').then(function (res) {
           var babelMarkers = (res && res.markers) || [];
           if (babelMarkers.length > 0) {
-            applyMarkersForTab(paneId, tab.id, babelMarkers);
+            applyMarkersForTab(tab.id, babelMarkers);
             EditorStore.setStatus('Saved — babel: ' + babelMarkers[0].message, 'warning');
           } else {
             // Clear any previous babel marker for this tab (keep others none —
             // JS tabs have no rubocop markers, so replacing is safe).
-            var existing = (EditorStore.getState().panes.find(function (p) { return p.id === paneId; }) || { tabs: [] })
-              .tabs.find(function (t) { return t.id === tab.id; });
-            if (existing && existing.markers && existing.markers.length) {
-              applyMarkersForTab(paneId, tab.id, []);
-            }
+            // applyMarkersForTab keeps the previous map when it is already empty.
+            applyMarkersForTab(tab.id, []);
           }
         })["catch"](function () {});
       }
 
-      GitService.fetchStatusLite({ background: true });
+      // The server broadcasts files_changed for this very write, and the
+      // coalesced handler refreshes git status there — so firing here too ran
+      // the git work twice per save, and this copy is the one a burst cannot
+      // coalesce. fetchStatusLite escalates to the full /git_info fan-out
+      // whenever the working tree signature moved, which saving a different
+      // file every time does by definition, so the duplicate was the expensive
+      // one. Without a socket no broadcast arrives, so keep it for that case.
+      if (!_socketWillBroadcast()) GitService.fetchStatusLite({ background: true });
     })["catch"](function (err) {
       EditorStore.setStatus("Save failed: " + err.message, "error");
     })["finally"](function () {
@@ -2932,7 +3157,10 @@ var MbeditorApp = function MbeditorApp() {
   }
 
   var handleSaveAll = function handleSaveAll() {
-    var dirtyTabs = state.panes.flatMap(function (p) {
+    // Flush first, then read the panes back out of the store — the render's
+    // `state` predates the flush. See TabManager's flush contract.
+    TabManager.flushContent();
+    var dirtyTabs = EditorStore.getState().panes.flatMap(function (p) {
       return p.tabs;
     }).filter(function (t) {
       // Untitled scratch tabs need a save-as prompt each — Ctrl+S them
@@ -2946,32 +3174,53 @@ var MbeditorApp = function MbeditorApp() {
     });
     EditorStore.setStatus("Saving " + dirtyTabs.length + " files...", "info");
     isSavingRef.current = true;
+    // allSettled, not all: one slow or rejected write used to abandon the
+    // bookkeeping for every other file, so tabs whose contents were already on
+    // disk stayed dirty and the only thing on offer was to hit Save All again.
+    // Each file is now settled on its own result.
     var promises = dirtyTabs.map(function (tab) {
       return FileService.saveFile(tab.path, tab.content);
     });
-    Promise.all(promises).then(function () {
-      dirtyTabs.forEach(function(tab) {
+    Promise.allSettled(promises).then(function (results) {
+      var saved = dirtyTabs.filter(function (tab, i) { return results[i].status === "fulfilled"; });
+      // Object.create(null): these keys are file paths, and a file called
+      // "constructor" would otherwise test as present against Object.prototype
+      // and have its tab marked clean without ever being written.
+      var savedPaths = Object.create(null);
+      saved.forEach(function (tab) {
+        savedPaths[tab.path] = tab.content;
         noteLocalSave(tab.path, tab.content);
       });
       var newPanes = EditorStore.getState().panes.map(function (p) {
         return _extends({}, p, { tabs: p.tabs.map(function (t) {
+            // Compare content, not just the path: a tab edited again while the
+            // save was in flight is dirty against what actually reached disk.
+            if (!(t.path in savedPaths) || t.content !== savedPaths[t.path]) return t;
             return _extends({}, t, { dirty: false, cleanContent: t.content });
           })
         });
       });
       EditorStore.setState({ panes: newPanes });
       // Reset AVI clean baselines for all saved files so undo past save shows dirty correctly.
-      dirtyTabs.forEach(function(tab) {
+      saved.forEach(function(tab) {
         var _me = window.__mbeditorModels && window.__mbeditorModels[tab.path];
         if (_me && _me.model && !_me.model.isDisposed()) {
           _me.cleanVersionId = _me.model.getAlternativeVersionId();
         }
       });
-      EditorStore.setStatus("All files saved", "success");
+      if (saved.length === dirtyTabs.length) {
+        EditorStore.setStatus("All files saved", "success");
+      } else {
+        EditorStore.setStatus("Saved " + saved.length + " of " + dirtyTabs.length +
+          " files — " + (dirtyTabs.length - saved.length) + " failed", "error");
+      }
       SearchService.invalidate();
       GitService.fetchStatusLite({ background: true });
-    })["catch"](function (err) {
-      EditorStore.setStatus("Failed to save some files", "error");
+    })["catch"](function () {
+      // allSettled never rejects, so this only fires if the bookkeeping above
+      // throws. Without it that would be an unhandled rejection and the status
+      // bar would sit on "Saving N files..." forever.
+      EditorStore.setStatus("Save All finished with errors", "error");
     })["finally"](function () {
       isSavingRef.current = false;
       return setLoading(function (prev) {
@@ -3029,7 +3278,7 @@ var MbeditorApp = function MbeditorApp() {
       return _extends({}, prev, { refreshWorkspace: true });
     });
     GitService.fetchStatus()["catch"](function () {});
-    FileService.getTree().then(function (data) {
+    FileService.getTree({ refresh: true }).then(function (data) {
       setTreeData(_treeUpdater(data || []));
       checkOpenTabsForExternalChanges();
       EditorStore.setStatus("Workspace refreshed", "success");
@@ -3095,19 +3344,53 @@ var MbeditorApp = function MbeditorApp() {
     return runPrettier(tab.content, prefs, parserName);
   };
 
+  // Markers are per-model and only the mounted editor re-lints, so a document
+  // formatted in the background kept the diagnostics of the text it no longer
+  // holds — the Problems panel and the status-bar tallies went on reporting
+  // offenses at line numbers that had moved, and Format All barely moved the
+  // counts because only the visible tab was re-checked. Dropping them says
+  // "not known yet", which is true: the file re-lints when you open it.
+  var discardStaleMarkers = function discardStaleMarkers(path) {
+    if (!path) return;
+
+    // The React map has to go too, not just Monaco's copy. It is what TabBar
+    // counts, and EditorPanel re-applies it to the model the next time that tab
+    // mounts — so clearing only Monaco left every background tab primed to put
+    // its stale squiggles straight back on the next tab switch.
+    EditorStore.getState().panes.forEach(function (p) {
+      p.tabs.forEach(function (t) {
+        if (t.path === path) applyMarkersForTab(t.id, []);
+      });
+    });
+
+    if (!window.monaco || !window.monaco.editor) return;
+    var entry = window.__mbeditorModels && window.__mbeditorModels[path];
+    if (!entry || !entry.model || entry.model.isDisposed()) return;
+
+    var owners = {};
+    window.monaco.editor.getModelMarkers({ resource: entry.model.uri }).forEach(function (m) {
+      owners[m.owner] = true;
+    });
+    Object.keys(owners).forEach(function (owner) {
+      window.monaco.editor.setModelMarkers(entry.model, owner, []);
+    });
+  };
+
   // Write formatted content back to a tab, dirty and unsaved — the user decides
   // when to save. EditorPanel applies it through executeEdits, so undo works.
   var applyFormattedContent = function applyFormattedContent(paneId, tabId, formatted) {
+    var formattedPath = null;
     EditorStore.setState({
       panes: EditorStore.getState().panes.map(function (p) {
         if (p.id !== paneId) return p;
         return _extends({}, p, { tabs: p.tabs.map(function (t) {
-          return t.id === tabId
-            ? _extends({}, t, { content: formatted, dirty: true, externalContentVersion: (t.externalContentVersion || 0) + 1 })
-            : t;
+          if (t.id !== tabId) return t;
+          formattedPath = t.path;
+          return _extends({}, t, { content: formatted, dirty: true, externalContentVersion: (t.externalContentVersion || 0) + 1 });
         }) });
       })
     });
+    discardStaleMarkers(formattedPath);
   };
 
   var highlightFormatChanges = function highlightFormatChanges(before, after) {
@@ -3124,8 +3407,8 @@ var MbeditorApp = function MbeditorApp() {
   var handleFormat = function handleFormat() {
     if (!activeTab) return;
 
-    var tab = activeTab;
     var paneId = focusedPane.id;
+    var tab = _freshTab(paneId, activeTab);
     var originalContent = tab.content;
 
     setLoading(function (prev) { return _extends({}, prev, { format: true }); });
@@ -3163,6 +3446,8 @@ var MbeditorApp = function MbeditorApp() {
   // thrown, so one unparseable file cannot stop the rest. Virtual tabs (diffs,
   // settings, the changelog) have no path on disk and are skipped.
   var handleFormatAll = function handleFormatAll() {
+    // See TabManager's flush contract — the panes are read straight after.
+    TabManager.flushContent();
     var targets = [];
     EditorStore.getState().panes.forEach(function (p) {
       p.tabs.forEach(function (t) {
@@ -3209,15 +3494,6 @@ var MbeditorApp = function MbeditorApp() {
 
   var TEST_CACHE_PREFIX = 'mbeditor_test_result_';
 
-  var loadCachedTestResult = function loadCachedTestResult(filePath) {
-    try {
-      var stored = localStorage.getItem(TEST_CACHE_PREFIX + filePath);
-      return stored ? JSON.parse(stored) : null;
-    } catch (e) {
-      return null;
-    }
-  };
-
   var saveCachedTestResult = function saveCachedTestResult(filePath, result) {
     try {
       localStorage.setItem(TEST_CACHE_PREFIX + filePath, JSON.stringify(result));
@@ -3259,21 +3535,6 @@ var MbeditorApp = function MbeditorApp() {
     });
   };
 
-  var handleRunTest = function handleRunTest() {
-    if (!activeTab || !activeTab.path) return;
-    if (testLoading) return;
-
-    var cached = loadCachedTestResult(activeTab.path);
-    if (cached && !testPanelOpen) {
-      setTestResult(cached);
-      setTestPanelFile(cached.testFile || activeTab.path);
-      setTestPanelOpen(true);
-      return;
-    }
-
-    executeTestRun(activeTab.path);
-  };
-
   var handleRerunTest = function handleRerunTest() {
     if (!activeTab || !activeTab.path) return;
     if (testLoading) return;
@@ -3314,6 +3575,7 @@ var MbeditorApp = function MbeditorApp() {
     searchOffsetRef.current = 0;
     searchLoadingMoreRef.current = false;
     searchQueryRef.current = q;
+    setSearchCollapsedFiles({});
     EditorStore.setState({ searchResults: [], searchHasMore: false });
     EditorStore.setStatus("Searching project...", "info");
     SearchService.projectSearch(q, 0, SearchService.PAGE_SIZE, { regex: searchUseRegexRef.current, matchCase: searchMatchCaseRef.current, wholeWord: searchWholeWordRef.current }).then(function (res) {
@@ -3430,8 +3692,13 @@ var MbeditorApp = function MbeditorApp() {
       // Update any open Monaco models whose content changed.
       if (files.length && window.__mbeditorModels) {
         files.forEach(function(relPath) {
-          var model = window.__mbeditorModels[relPath];
-          if (!model) return;
+          // The registry holds {model, aviBase, ...} entries, not models. This
+          // used to call setValue/isDisposed straight on the entry, which threw
+          // into the .catch below — so an open tab kept its pre-replace text and
+          // could save it back over the replacement.
+          var entry = window.__mbeditorModels[relPath];
+          var model = entry && entry.model;
+          if (!model || model.isDisposed()) return;
           FileService.getFile(relPath).then(function(res) {
             if (res && res.content != null && !model.isDisposed()) {
               model.setValue(res.content);
@@ -3457,6 +3724,13 @@ var MbeditorApp = function MbeditorApp() {
     if (el.scrollHeight - el.scrollTop - el.clientHeight < 200) {
       loadMoreSearchResults();
     }
+    setSearchViewport(function (prev) {
+      // Only the rows that moved in or out of the window matter, and those
+      // change a row at a time. Comparing keeps a scroll gesture from
+      // committing a render per pixel.
+      if (prev.scrollTop === el.scrollTop && prev.height === el.clientHeight) return prev;
+      return { scrollTop: el.scrollTop, height: el.clientHeight };
+    });
   };
 
   var toggleGitPanel = function toggleGitPanel() {
@@ -3556,12 +3830,17 @@ var MbeditorApp = function MbeditorApp() {
     });
   };
 
-  var finishImport = function finishImport(result) {
-    var imported = (result.imported || []).length;
+  var finishImport = function finishImport(result, destFolder) {
+    var written  = result.imported || [];
+    var imported = written.length;
     var skipped  = (result.conflicts || []).length;
     var failed   = (result.errors || []).length;
 
-    var parts = [imported + ' file' + (imported === 1 ? '' : 's') + ' imported'];
+    // Say where the files went. A bulk upload that reports only a count looks
+    // the same whether it landed where you meant it to or in the workspace
+    // root, and the destination is the whole question a folder import raises.
+    var where = destFolder ? ' to ' + destFolder : ' to the workspace root';
+    var parts = [imported + ' file' + (imported === 1 ? '' : 's') + ' imported' + (imported > 0 ? where : '')];
     if (skipped > 0) parts.push(skipped + ' skipped');
     if (failed > 0) parts.push(failed + ' failed');
 
@@ -3569,7 +3848,21 @@ var MbeditorApp = function MbeditorApp() {
     EditorStore.setStatus(parts.join(', ') + '.', level);
 
     if (imported > 0) {
-      refreshProjectTree().then(function() { GitService.fetchStatus(); });
+      // Expand down to what was just written, so the tree actually shows it —
+      // importing into a collapsed folder otherwise leaves the explorer looking
+      // untouched. Deliberately does not *select* the folder: the tree
+      // selection is what the toolbar's Upload button reads for its default
+      // destination, and pinning it here would make every later upload default
+      // to this import's folder.
+      var landed = parentDir(written[0].path);
+      var toExpand = {};
+      var bits = landed ? landed.split('/') : [];
+      for (var i = 1; i <= bits.length; i++) toExpand[bits.slice(0, i).join('/')] = true;
+
+      refreshProjectTree().then(function() {
+        if (bits.length) setExpandedDirs(function (prev) { return Object.assign({}, prev, toExpand); });
+        GitService.fetchStatus();
+      });
     }
   };
 
@@ -3613,7 +3906,7 @@ var MbeditorApp = function MbeditorApp() {
         if (result.conflicts && result.conflicts.length > 0) {
           setImportConflict({ result: result, entries: entries, targetFolderPath: targetFolderPath });
         } else {
-          finishImport(result);
+          finishImport(result, targetFolderPath);
         }
       })['catch'](function(err) {
         var message = err && err.response && err.response.data && err.response.data.error || err.message;
@@ -3626,14 +3919,14 @@ var MbeditorApp = function MbeditorApp() {
     setImportConflict(null);
     if (!pending) return;
 
-    if (mode === 'skip') { finishImport(pending.result); return; }
+    if (mode === 'skip') { finishImport(pending.result, pending.targetFolderPath); return; }
 
     var retry = FileImport.conflictedEntries(
       pending.entries,
       pending.targetFolderPath,
       pending.result.conflicts
     );
-    if (retry.length === 0) { finishImport(pending.result); return; }
+    if (retry.length === 0) { finishImport(pending.result, pending.targetFolderPath); return; }
 
     FileService.importFiles(FileImport.buildFormData(retry, pending.targetFolderPath, mode))
       .then(function(second) {
@@ -3641,13 +3934,47 @@ var MbeditorApp = function MbeditorApp() {
           imported: (pending.result.imported || []).concat(second.imported || []),
           conflicts: [],
           errors: (pending.result.errors || []).concat(second.errors || [])
-        });
+        }, pending.targetFolderPath);
       })['catch'](function(err) {
         var message = err && err.response && err.response.data && err.response.data.error || err.message;
         EditorStore.setStatus('Import failed: ' + message, 'error');
       });
   };
 
+  // Downloads go straight through /raw?download=1 — the browser's own save
+  // flow, so nothing is buffered client-side and a 5 MB file costs no memory.
+  // A synthetic anchor rather than location.href: navigating away from the
+  // editor to an attachment response leaves the page in a half-unloaded state
+  // in Safari.
+  var handleDownloadFile = function handleDownloadFile(node) {
+    if (!node || node.type !== 'file') return;
+    var link = document.createElement('a');
+    link.href = window.mbeditorBasePath() + '/raw?download=1&path=' + encodeURIComponent(node.path);
+    link.download = node.name;
+    link.rel = 'noopener';
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    EditorStore.setStatus('Downloading ' + node.name + '...', 'info');
+  };
+
+  // A file node means "upload alongside this file", so the dialog opens on its
+  // parent — right-clicking a file to upload next to it is the common gesture.
+  var openImportDialog = function openImportDialog(node) {
+    var folder = '';
+    if (node && node.type === 'folder') {
+      folder = node.path;
+    } else if (node && node.path) {
+      folder = node.path.split('/').slice(0, -1).join('/');
+    }
+    setImportDialog({ initialFolder: folder });
+  };
+
+  var confirmImportDialog = function confirmImportDialog(entries, destFolder, meta) {
+    setImportDialog(null);
+    handleImportFiles(entries, destFolder, meta);
+  };
+
   var openContextMenu = function openContextMenu(e, node) {
     setContextMenu({ x: e.clientX, y: e.clientY, node: node });
     handleNodeSelect(node);
@@ -3675,6 +4002,12 @@ var MbeditorApp = function MbeditorApp() {
     if (action === 'delete') {
       handleDeletePath(node);return;
     }
+    if (action === 'download' && node) {
+      handleDownloadFile(node);return;
+    }
+    if (action === 'upload') {
+      openImportDialog(node);return;
+    }
     if (action === 'copyPath' && node) {
       if (navigator.clipboard) {
         navigator.clipboard.writeText(node.path)["catch"](function () {});
@@ -3823,15 +4156,7 @@ var MbeditorApp = function MbeditorApp() {
       activeTabId: activePane ? activePane.activeTabId : null
     });
 
-    if (removedTabIds.length) {
-      setMarkers(function (prev) {
-        var next = _extends({}, prev);
-        removedTabIds.forEach(function (tabId) {
-          return delete next[tabId];
-        });
-        return next;
-      });
-    }
+    if (removedTabIds.length) forgetClosedTabs();
   };
 
   // Reveal a folder path in the explorer: switch to explorer tab and expand
@@ -3890,8 +4215,27 @@ var MbeditorApp = function MbeditorApp() {
       FileService.createFile(path, '').then(function (res) {
         var createdPath = res && res.path || path;
         var createdName = createdPath.split('/').pop();
+        // We just wrote this file and know it is empty, so opening it does not
+        // need to ask the server what is in it. noteLocalSave records the write
+        // for the same reason a save does: the create's own broadcast comes
+        // straight back as a files_changed naming this path, and without this
+        // the external-change check read the file back off disk to ask whether
+        // it had changed since we wrote it a moment earlier.
+        if (FileService.seedPrefetch) FileService.seedPrefetch(createdPath, '');
+        noteLocalSave(createdPath, '');
         handleNodeSelect({ path: createdPath, name: createdName, type: 'file' });
         EditorStore.setStatus('Created file: ' + createdName, 'success');
+        // The optimistic node is already in the tree and the server's
+        // structural broadcast refreshes it for real a moment later, so
+        // walking the workspace here as well made one create cost three full
+        // tree walks — and every write invalidates the server's tree cache, so
+        // each one is a fresh recursive scan of the whole checkout. Same for
+        // git status, which the same broadcast handler already refreshes.
+        // Without a socket neither happens on its own, so keep both for that.
+        if (_socketWillBroadcast()) {
+          handleSelectFile(createdPath, createdName);
+          return;
+        }
         return refreshProjectTree().then(function () {
           handleSelectFile(createdPath, createdName);
           GitService.fetchStatusLite({ background: true });
@@ -3914,6 +4258,8 @@ var MbeditorApp = function MbeditorApp() {
         var createdPath = res && res.path || path;
         handleNodeSelect({ path: createdPath, name: createdPath.split('/').pop(), type: 'folder' });
         EditorStore.setStatus('Created folder: ' + createdPath, 'success');
+        // See handleCreateConfirm's file branch — the broadcast covers both.
+        if (_socketWillBroadcast()) return;
         return refreshProjectTree().then(function () {
           return GitService.fetchStatusLite({ background: true });
         });
@@ -4074,6 +4420,9 @@ var MbeditorApp = function MbeditorApp() {
       tabs: tabs,
       activeId: activeId,
       paneId: paneId,
+      // Diagnostics live in this map, not on the tab object — writing them onto
+      // the tab would mutate a value inside EditorStore.
+      markers: markers,
       tabDisplayMode: editorPrefs.tabDisplayMode || 'scroll',
       onSelect: function (id) {
         // Sync explorer selection with the newly active tab so there's only one highlight
@@ -4275,7 +4624,8 @@ var MbeditorApp = function MbeditorApp() {
           "button",
           { className: "statusbar-btn", onClick: function () {
               return activeTab && handleSave(focusedPane.id, activeTab);
-            }, disabled: loading.save || !activeTab || !activeTab.dirty, 'aria-busy': !!loading.save },
+            }, disabled: loading.save || !activeTab || !activeTab.dirty, 'aria-busy': !!loading.save,
+            title: "Save the active file (Ctrl+S)" },
           !loading.save && React.createElement("i", { className: "fas fa-save" }),
           !toolbarIconOnly && !loading.save && " Save",
           !loading.save && activeTab && activeTab.dirty ? " ●" : ""
@@ -4286,7 +4636,7 @@ var MbeditorApp = function MbeditorApp() {
               return p.tabs;
             }).some(function (t) {
               return t.dirty;
-            }), 'aria-busy': !!loading.saveAll },
+            }), 'aria-busy': !!loading.saveAll, title: "Save every file with unsaved changes" },
           !loading.saveAll && React.createElement(
             "i",
             { className: "fas fa-save", style: { position: 'relative' } },
@@ -4330,7 +4680,8 @@ var MbeditorApp = function MbeditorApp() {
           React.createElement("div", { className: "statusbar-sep" }),
           React.createElement(
             "button",
-            { type: "button", className: "statusbar-btn", onClick: toggleGitPanel },
+            { type: "button", className: "statusbar-btn", onClick: toggleGitPanel,
+              title: (showGitPanel ? "Hide" : "Show") + " the git panel (Ctrl+Shift+G)" },
             React.createElement("i", { className: "fas fa-code-branch" }),
             !toolbarIconOnly && " Git"
           )
@@ -4545,7 +4896,7 @@ var MbeditorApp = function MbeditorApp() {
     React.createElement(
       "div",
       { className: "ide-body", id: "ide-body-container" },
-      /* Activity bar — always visible, 48px wide */
+      /* Activity bar — always visible, 60px wide */
       !zenMode && React.createElement(
         "div",
         { className: "ide-activity-bar" },
@@ -4688,6 +5039,9 @@ var MbeditorApp = function MbeditorApp() {
                         {
                           key: tab.id,
                           className: "tree-item " + (pane.activeTabId === tab.id && state.focusedPaneId === pane.id ? "active" : ""),
+                          // The name ellipsises in a narrow sidebar, so the row
+                          // carries the full path the way file-tree rows do.
+                          title: tab.path || tab.name,
                           onClick: function () {
                             if (tab.path && !tab.path.startsWith('mbeditor://') && tab.path !== '__settings__') {
                               handleNodeSelect({ path: tab.path, name: tab.name, type: 'file' });
@@ -4698,17 +5052,24 @@ var MbeditorApp = function MbeditorApp() {
                         React.createElement("i", { className: "tree-item-icon " + (window.getFileIcon ? window.getFileIcon(tab.name) : 'far fa-file-code') + " tree-file-icon" }),
                         React.createElement(
                           "div",
-                          { className: "tree-item-name", style: { display: 'flex', alignItems: 'center' } },
+                          // minWidth:0 on both the row's name cell and the label
+                          // itself: without it a flex item refuses to shrink
+                          // below its content, so a long filename pushed out
+                          // under the (formerly absolute) action buttons.
+                          { className: "tree-item-name", style: { display: 'flex', alignItems: 'center', minWidth: 0 } },
                           React.createElement(
                             "span",
-                            { style: { overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' } },
+                            { style: { overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', minWidth: 0 } },
                             tab.name
                           ),
-                          tab.dirty && React.createElement("i", { className: "fas fa-circle", style: { fontSize: '5px', color: '#e3d286', marginLeft: '6px', marginTop: '1px' } })
+                          tab.dirty && React.createElement("i", { className: "fas fa-circle", style: { fontSize: '5px', color: '#e3d286', marginLeft: '6px', marginTop: '1px', flexShrink: 0 } })
                         ),
                         React.createElement(
                           "div",
-                          { className: "tab-actions", style: { display: 'flex', position: 'absolute', right: '4px', top: 0, height: '100%', alignItems: 'center' } },
+                          // In flow, not absolute — the buttons now claim their
+                          // own width so the name truncates instead of running
+                          // underneath them.
+                          { className: "tab-actions", style: { display: 'flex', alignItems: 'center', flexShrink: 0, marginLeft: 'auto' } },
                           React.createElement(
                             "div",
                             { className: "tab-split", onClick: function (e) {
@@ -4720,7 +5081,10 @@ var MbeditorApp = function MbeditorApp() {
                             "div",
                             { className: "tab-close", onClick: function (e) {
                                 e.stopPropagation();requestCloseTab(pane.id, tab.id);
-                              }, style: { padding: '0 4px', cursor: 'pointer', opacity: 0.6 } },
+                              }, style: { padding: '0 4px', cursor: 'pointer', opacity: 0.6 },
+                              // See TabBar: role="button" would pick up Pico's
+                              // button skin from the host app and square this off.
+                              title: "Close " + tab.name + (tab.dirty ? " (unsaved changes)" : "") },
                             React.createElement("i", { className: "fas fa-times" })
                           )
                         )
@@ -4780,6 +5144,13 @@ var MbeditorApp = function MbeditorApp() {
                   },
                   disabled: !!loading.createDir
                 }),
+                React.createElement(SidebarActionButton, {
+                  title: "Upload files",
+                  iconClass: 'fas fa-upload',
+                  onClick: function () {
+                    return openImportDialog(selectedTreeNode);
+                  }
+                }),
                 React.createElement(SidebarActionButton, {
                   title: "Rename selected",
                   iconClass: 'fas fa-pen',
@@ -4802,7 +5173,7 @@ var MbeditorApp = function MbeditorApp() {
               )
             },
             React.createElement(FileTree, {
-              items: editorPrefs.showDotFiles ? treeData : filterDotFiles(treeData || []),
+              items: fileTreeItems,
               onSelect: handleSoftOpenFile,
               activePath: editorPrefs.autoRevealInExplorer !== false ? (activeTab && activeTab.path) : null,
               selectedPaths: selectedPaths,
@@ -4937,6 +5308,30 @@ var MbeditorApp = function MbeditorApp() {
             var total       = searchTotalCount > 0 ? searchTotalCount : loadedCount;
             var hasAny      = loadedCount > 0;
 
+            // Grouped into a VS Code-style tree, then flattened straight back
+            // into one row array: the windowing below is unchanged, it just
+            // indexes rows instead of results. Every tier emits its hits file
+            // by file, so a run of the same path is the whole group.
+            var rows = [];
+            var group = null;
+            allResults.forEach(function (res, idx) {
+              if (!group || group.file !== res.file) {
+                group = { type: 'file', file: res.file, count: 0 };
+                rows.push(group);
+              }
+              group.count += 1;
+              if (!searchCollapsedFiles[res.file]) rows.push({ type: 'match', res: res, idx: idx });
+            });
+            var rowCount = rows.length;
+
+            // Only the rows on screen (plus a small buffer either side) are
+            // built. Everything else is represented by the height of the
+            // spacer, so the scrollbar and every scroll position stay exactly
+            // as they would be for the full list.
+            var winStart = Math.max(0, Math.floor(searchViewport.scrollTop / SEARCH_ROW_HEIGHT) - SEARCH_ROW_BUFFER);
+            var winEnd   = Math.min(rowCount, Math.ceil((searchViewport.scrollTop + (searchViewport.height || 600)) / SEARCH_ROW_HEIGHT) + SEARCH_ROW_BUFFER);
+            var visible  = rows.slice(winStart, winEnd);
+
             return React.createElement(
               React.Fragment,
               null,
@@ -4954,32 +5349,65 @@ var MbeditorApp = function MbeditorApp() {
                   "div",
                   {
                     className: "search-results" + (searchLoading ? " search-results-blurred" : ""),
-                    ref: searchResultsContainerRef,
+                    ref: attachSearchResults,
                     onScroll: handleSearchResultsScroll
                   },
-                  allResults.map(function(res, i) {
-                    var fileName = res.file.split('/').pop();
-                    return React.createElement(
-                      "div",
-                      {
-                        key: i,
-                        className: "search-result-item",
-                        // end_col puts the cursor just past the match, which is
-                        // where you want to start typing after jumping to a hit.
-                        onClick: (function(r) { return function() { handleSelectFile(r.file, r.file.split('/').pop(), r.line, r.end_col || r.col); }; })(res)
-                      },
-                      React.createElement("i", { className: (window.getFileIcon ? window.getFileIcon(fileName) : 'far fa-file-code') + " search-result-icon" }),
-                      React.createElement(
-                        "div", { className: "search-result-body" },
-                        React.createElement(
-                          "div", { className: "search-result-file" },
-                          fileName,
-                          React.createElement("span", { className: "search-result-line-num" }, " ", res.file, ":", res.line)
-                        ),
-                        React.createElement("div", { className: "search-result-text" }, res.text)
-                      )
-                    );
-                  }),
+                  React.createElement(
+                    "div",
+                    { style: { height: rowCount * SEARCH_ROW_HEIGHT, position: 'relative' } },
+                    visible.map(function(row, vi) {
+                      var i = winStart + vi;
+                      var top = { position: 'absolute', top: i * SEARCH_ROW_HEIGHT, left: 0, right: 0 };
+
+                      if (row.type === 'file') {
+                        var fileName = row.file.split('/').pop();
+                        var dir = row.file.slice(0, row.file.length - fileName.length).replace(/\/$/, '');
+                        var collapsed = !!searchCollapsedFiles[row.file];
+                        return React.createElement(
+                          "div",
+                          {
+                            key: 'f:' + row.file,
+                            className: "search-result-file-row",
+                            style: top,
+                            title: row.file,
+                            onClick: (function(f) { return function() { toggleSearchFile(f); }; })(row.file)
+                          },
+                          React.createElement("i", { className: "codicon codicon-chevron-" + (collapsed ? "right" : "down") + " search-result-chevron" }),
+                          React.createElement("i", { className: (window.getFileIcon ? window.getFileIcon(fileName) : 'far fa-file-code') + " search-result-icon" }),
+                          React.createElement("span", { className: "search-result-file-name" }, fileName),
+                          dir && React.createElement("span", { className: "search-result-file-dir" }, dir),
+                          React.createElement("span", { className: "search-result-count" }, row.count)
+                        );
+                      }
+
+                      var res = row.res;
+                      return React.createElement(
+                        "div",
+                        {
+                          key: 'm:' + row.idx,
+                          className: "search-result-item",
+                          style: top,
+                          title: res.file + ":" + res.line,
+                          // col..end_col selects the match and leaves the cursor
+                          // just past it, which is where you want to start
+                          // typing after jumping to a hit — not column 1.
+                          onClick: (function(r) { return function() { handleSelectFile(r.file, r.file.split('/').pop(), r.line, r.col || r.end_col, r.end_col); }; })(res)
+                        },
+                        React.createElement("span", { className: "search-result-line-num" }, res.line),
+                        (function () {
+                          var parts = searchMatchParts(res);
+                          if (!parts) return React.createElement("span", { className: "search-result-text" }, res.text);
+                          return React.createElement(
+                            "span",
+                            { className: "search-result-text search-result-text-split" },
+                            React.createElement("span", { className: "search-result-pre" }, parts[0]),
+                            React.createElement("mark", { className: "search-result-match" }, parts[1]),
+                            React.createElement("span", { className: "search-result-post" }, parts[2])
+                          );
+                        })()
+                      );
+                    })
+                  ),
                   searchHasMore && React.createElement(
                     "div", { className: "search-loading-more" },
                     React.createElement("i", { className: "fas fa-spinner fa-spin" }),
@@ -5573,16 +6001,6 @@ var MbeditorApp = function MbeditorApp() {
                         React.createElement('option', { value: 'allDocuments' }, 'All open files')
                       )
                     ),
-                    React.createElement(
-                      'label', { className: 'ide-settings-row ide-settings-row-check', title: 'Re-indent pasted code to match where it lands. Only leading whitespace changes — the formatter is not run.' },
-                      React.createElement('span', { className: 'ide-settings-label' }, 'Indent on paste'),
-                      React.createElement('input', {
-                        type: 'checkbox',
-                        className: 'ide-settings-checkbox',
-                        checked: editorPrefs.indentOnPaste !== false,
-                        onChange: function(e) { var v = e.target.checked; setEditorPrefs(function(p) { return Object.assign({}, p, { indentOnPaste: v }); }); }
-                      })
-                    ),
                     React.createElement(
                       'label', { className: 'ide-settings-row ide-settings-row-check', title: 'Re-indent and auto-close blocks as you type (e.g. after pressing Enter inside {})' },
                       React.createElement('span', { className: 'ide-settings-label' }, 'Format on type'),
@@ -5767,6 +6185,17 @@ var MbeditorApp = function MbeditorApp() {
                       })
                     ),
 
+                    React.createElement(
+                      'label', { className: 'ide-settings-row ide-settings-row-check', title: 'Show the verb and path that route to each controller action after its def line, and mark public actions nothing routes to' },
+                      React.createElement('span', { className: 'ide-settings-label' }, 'Controller route hints'),
+                      React.createElement('input', {
+                        type: 'checkbox',
+                        className: 'ide-settings-checkbox',
+                        checked: editorPrefs.routeHints !== false,
+                        onChange: function(e) { var v = e.target.checked; setEditorPrefs(function(p) { return Object.assign({}, p, { routeHints: v }); }); }
+                      })
+                    ),
+
                     /* ── RuboCop ─────────────────────────────────── */
                     React.createElement('div', { className: 'ide-settings-section-header' }, 'RuboCop'),
                     React.createElement(
@@ -5798,6 +6227,7 @@ var MbeditorApp = function MbeditorApp() {
                       {
                         className: 'ide-settings-reset-btn',
                         type: 'button',
+                        title: 'Restore every editor preference on this page to its default',
                         onClick: function() { setEditorPrefs(Object.assign({}, DEFAULT_EDITOR_PREFS)); }
                       },
                       React.createElement('i', { className: 'fas fa-undo', style: { marginRight: 6 } }),
@@ -5824,17 +6254,14 @@ var MbeditorApp = function MbeditorApp() {
                   paneId: pane.id,
                   markers: markers[pActiveTab.id] || [],
                   gitAvailable: gitAvailable,
-                  testAvailable: testAvailable,
                   treeData: treeData,
                   testResult: testResult,
                   testPanelFile: testPanelFile,
-                  testLoading: testLoading,
                   testInlineVisible: testInlineVisible,
                   editorPrefs: editorPrefs,
                   monacoReady: monacoReady,
                   onFormat: function() { onFormatRef.current(); },
                   onSave: function() { handleSave(pane.id, pActiveTab); },
-                  onRunTest: handleRunTest,
                   onRunTestAtCursor: handleRunTestAtCursor,
                   onShowHistory: function(path) { setHistoryPanelPath(path); },
                   onContentChange: function onContentChange(val) {
@@ -6018,8 +6445,14 @@ var MbeditorApp = function MbeditorApp() {
         onClose: function () { setShowProblemsPanel(false); },
         onOpenFile: function (path, line, col) {
           handleSelectFile(path, path.split('/').pop(), line, col);
-        }
-      })
+        },
+        // `rubocop -a` writes through a subprocess, so the server's
+        // files_changed broadcast is the only notice — and there is no
+        // broadcast at all without a cable connection. Re-read every open tab
+        // here too: clean tabs take the corrected text (and re-lint), dirty
+        // ones get the usual reload prompt instead of being silently clobbered.
+        onFilesRewritten: function () { checkOpenTabsForExternalChanges(); }
+      }),
       ),
 
       // Right-side Git panel (children of ide-body, alongside sidebar and ide-main)
@@ -6079,33 +6512,9 @@ var MbeditorApp = function MbeditorApp() {
         },
         React.createElement("i", { className: "fas fa-bug statusbar-problems-error-icon" }),
         React.createElement("span", { className: "statusbar-problems-count" }, problemCounts.errors),
-        React.createElement("i", {
-          className: "fas fa-exclamation-triangle statusbar-problems-warning-icon",
-          style: { marginLeft: "8px" }
-        }),
+        React.createElement("i", { className: "fas fa-exclamation-triangle statusbar-problems-warning-icon" }),
         React.createElement("span", { className: "statusbar-problems-count" }, problemCounts.warnings)
       ),
-      // ruby-lsp indicator. Hidden entirely when ruby-lsp was never available
-      // and nothing has gone wrong — a permanent "off" badge in a project with
-      // no Ruby is noise. A healthy server gets a quiet icon; a degraded one
-      // gets an amber chip you can click to restart.
-      (lspHealth.status !== 'off' || lspHealth.reason) && React.createElement(
-        "button",
-        {
-          type: "button",
-          className: "statusbar-btn statusbar-lsp statusbar-lsp-" + lspHealth.status,
-          onClick: restartRubyLsp,
-          title: lspHealth.status === 'ok'
-            ? 'ruby-lsp is running — click to restart'
-            : 'ruby-lsp unavailable' + (lspHealth.reason ? ': ' + lspHealth.reason : '') +
-              '. Falling back to search-based lookups. Click to retry.'
-        },
-        React.createElement("i", {
-          className: "fas " + (lspHealth.status === 'ok' ? 'fa-gem' : 'fa-plug'),
-          "aria-hidden": "true"
-        }),
-        lspHealth.status !== 'ok' && React.createElement("span", null, " ruby-lsp")
-      ),
       !serverOnline && (function () {
         var dirtyCount = state.panes.reduce(function (acc, p) {
           return acc + p.tabs.filter(function (t) { return t.dirty; }).length;
@@ -6424,6 +6833,23 @@ var MbeditorApp = function MbeditorApp() {
           " Delete"
         ),
         React.createElement("div", { className: "context-menu-divider" }),
+        contextMenu.node && contextMenu.node.type === 'file' && React.createElement(
+          "div",
+          { className: "context-menu-item", onClick: function () {
+              return handleContextMenuAction('download');
+            } },
+          React.createElement("i", { className: "fas fa-download context-menu-icon" }),
+          " Download"
+        ),
+        React.createElement(
+          "div",
+          { className: "context-menu-item", onClick: function () {
+              return handleContextMenuAction('upload');
+            } },
+          React.createElement("i", { className: "fas fa-upload context-menu-icon" }),
+          " Upload Files Here..."
+        ),
+        React.createElement("div", { className: "context-menu-divider" }),
         React.createElement(
           "div",
           { className: "context-menu-item", onClick: function () {
@@ -6499,6 +6925,14 @@ var MbeditorApp = function MbeditorApp() {
       )
     ),
 
+    /* ── Upload dialog ─────────────────────────────────────────────────── */
+    importDialog && React.createElement(ImportDialog, {
+      initialFolder: importDialog.initialFolder,
+      docs: SearchService.allDocs(),
+      onCancel: function () { setImportDialog(null); },
+      onImport: confirmImportDialog
+    }),
+
     /* ── Import conflict modal ─────────────────────────────────────────── */
     importConflict && React.createElement(ImportConflictModal, {
       conflicts: importConflict.result.conflicts,