mbeditor 0.12.7 → 0.12.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e19be096529fa5f410c792379f88395494fa7783964604b2ff07bb5a93d39d8
-  data.tar.gz: d491ca7214661784bbb9d6bc78c13da045a2da9529649d088dae1b0171d17868
+  metadata.gz: 264dfef604baf70be3fcb9984f588a93a8388fe13371cb3c8707d5ee7149d441
+  data.tar.gz: d584056fbb108ea55ddb98a819af73e4eabb939d659fc7d54442446b34b2c203
 SHA512:
-  metadata.gz: 99bbd0a1dd19d7191563ea1586f5c38f9b68d0b70319f412be5439fb1588148b135aed1b8a20b66023129065ea84d71880d80054d6500a8ff1f2b83879f941c0
-  data.tar.gz: de0e4dfbb928584209ff4d5f1ace4a0bdb5c3b56a20c9a695c3c4770e2ccfd3a5063d9274f450706e13cabf4edd6ce2fdc3313b8477c6cecd28432eabc877246
+  metadata.gz: 20141c5dcd65e482c4d0437c5b1a4b1431507f424dc1a31b80af5490d30b4611c2c2e050f0716a4a382c9f2b3804001127e03292cfe371b50049c6d058f3c7b0
+  data.tar.gz: 551f8ad767679d4b63364d2c6e9bcb267663c35bf1750a355b29ff22f7149e445511a0fd9be8aa7a279754f6c0a3ccb79a1b3941d1bec3b11792911541081616

data/CHANGELOG.md

@@ -7,6 +7,109 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.12.9] - 2026-08-07
+
+### Added
+- **Problems panel severity filter.** Three toggle chips — errors, warnings,
+  info — each showing its live count, filtering the list independently of the
+  text filter. Multi-select rather than one-of-three, so "errors and warnings
+  but not the convention noise" is expressible. The selection persists, and the
+  last active severity stays latched on so the panel can't be filtered down to
+  an unexplained blank.
+- **Search results carry match columns.** Clicking a result now puts the cursor
+  at the end of the matched text instead of the start of the line, ready to
+  type. Columns are measured against the raw source line on the server —
+  the row's display text is stripped, so a column derived from it would land
+  short by the indent on every indented hit.
+
+### Changed
+- **The Problems header no longer restates its counts in prose.** The severity
+  chips carry the same three numbers.
+- **Paste re-indents instead of reformatting.** Pasting ran the pasted range
+  through Prettier, which reprinted the whole enclosing statement — and for a
+  paste that filled the document, every line of it — so pasting a snippet
+  rewrote code you never touched. Paste now only re-indents to the file's
+  indentation setting; quotes, semicolons and spacing come through exactly as
+  copied. The setting is renamed "Format on paste" → "Indent on paste"
+  (`indentOnPaste`, still on by default). Monaco ships no indentation rules for
+  JavaScript, which would have made the re-indent a silent no-op there, so
+  VS Code's JS rules are now registered. Format-on-save is unchanged and still
+  off by default.
+
+### Fixed
+- **Go-to-definition on a JS symbol defined in the same file opened a junk tab
+  named after a number.** Models are created without an explicit URI, so Monaco
+  identifies each as `inmemory://model/N`; the TS worker returns that URI for
+  an in-file definition, and the editor opener stripped it to a path and opened
+  a phantom tab called "57". Only `file://` resources are treated as workspace
+  files now — the rest go back to Monaco, which reveals the position in the
+  current editor.
+- **Clicking a search result sometimes landed on the wrong line.** Opening a
+  hit in a file that wasn't already open ran the jump against a still-empty
+  model: it clamped to line 1 and then cleared the pending jump, so when the
+  content finally arrived nothing re-triggered it. Whether it misbehaved came
+  down to whether the fetch beat a 50 ms timer — hence "sometimes". The jump
+  now waits for the content, cancels a superseded timer, and clamps to the
+  file's real length when a result outlives the line it pointed at.
+- **Search results ignored created and deleted files.** Only saves dropped the
+  client-side search cache, so a search re-run after adding or removing a file
+  was served the stale cached page. Every structural mutation now invalidates
+  it and re-runs the active query.
+- **Search and the git status counts lagged behind file changes.** The
+  live-result refresh sat behind a 2 s debounce (now 250 ms), and every save
+  fired the full `/git_info` fan-out — the most expensive request the editor
+  makes — twice over, once directly and once from the broadcast handler, which
+  on a dev server with a few threads queued the tree and search requests behind
+  it. Saves and file mutations now use the cheap `/git_status` probe, which
+  patches the branch and file list immediately and escalates to the fan-out
+  itself only when the branch actually changed.
+
+## [0.12.8] - 2026-08-07
+
+### Added
+- **Untitled scratch tabs.** The tab bar's "+" now opens an in-memory
+  `Untitled-N` buffer (VS Code-style) instead of prompting to create a file on
+  disk. Nothing is written anywhere until you save, at which point a save-as
+  prompt asks for a workspace-relative path and the tab converts to a real
+  file. Scratch tabs are skipped by Save All (each needs its own prompt) and
+  are not persisted across reloads.
+
+### Fixed
+- **"was updated externally" fired after your own saves.** A successful save
+  never refreshed the external-change baseline (the save-time grace window
+  skipped the very fetch that would have), so once you edited the file again,
+  the next save of *any* file compared new disk content against the stale
+  pre-save baseline and raised the banner. Saves now update the baseline
+  directly, the check re-reads live tab state instead of a snapshot taken
+  before its fetch, and — since the files_changed push only ever announces
+  mbeditor's own writes — the push-triggered check is now scoped to the pushed
+  paths instead of re-fetching every open tab on every save. The manual
+  Refresh Workspace button still checks everything.
+- **Virtual tabs no longer poll git.** Changelog/untitled/diff tabs were
+  fetching git line-diff every 10 s and git/file history on focus — guaranteed
+  no-ops, now skipped, along with persistent-undo tracking for paths that have
+  no file behind them.
+- **git-tier search returned nothing, instantly, on hosts with older git.** The
+  exclusion pathspecs added in 0.12.6 produced a pathspec list of nothing but
+  `:(exclude)` entries. Newer git reads that as "everything except these";
+  older git refuses it ("fatal: There is nothing to exclude from"), exits 128,
+  and — with stderr discarded — search silently returned empty. The list is
+  now anchored with a `.` pathspec, which every git version accepts.
+
+### Added
+- **Babel-based scope lint for JS/JSX, surfaced as warnings on save.** On top
+  of the existing babel syntax check (host mini_racer + babel-standalone), the
+  saved file is now traversed for identifier references that bind to nothing:
+  not to any scope in the file, not to a top-level declaration in any other
+  workspace JS file (Sprockets concatenates them into one scope), not to a
+  known `window.X` global, and not to the browser/React/hook names. Each one
+  gets a warning marker — `'name' is not defined in any reachable scope` — in
+  the editor and Problems panel. Also warns on bindings that are only assigned
+  inside a `useEffect`/`useLayoutEffect` callback but read during render
+  (undefined on first render). Report-only; `config.js_scope_lint = false`
+  disables it. Requires a babel-standalone new enough to expose
+  `Babel.packages` (7.9+); older bundles degrade to the syntax check alone.
+
 ## [0.12.7] - 2026-08-06
 
 ### Fixed

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

@@ -603,7 +603,11 @@ var EditorPanel = function EditorPanel(_ref) {
       CollaborationService.ensureRoom(tab.path);
     collabActiveRef.current = _collabActive;
 
-    if (!_collabActive && typeof HistoryService !== 'undefined') {
+    // untitled://, mbeditor:// and friends have no file to persist history
+    // against — tracking them just produces doomed /file_history requests.
+    var _virtualPath = (tab.path || '').indexOf('://') >= 0;
+
+    if (!_collabActive && !_virtualPath && typeof HistoryService !== 'undefined') {
       var _histBranch = EditorStore.getState().gitBranch || '';
       if (_histBranch) {
         if (_reusingModel) {
@@ -643,9 +647,9 @@ var EditorPanel = function EditorPanel(_ref) {
       autoClosingBrackets: editorPrefs.autoClosingBrackets || 'always',
       autoClosingQuotes: editorPrefs.autoClosingQuotes || 'always',
       autoIndent: editorPrefs.autoIndent || 'full',
-      // Monaco's own format-on-paste is left off: it never ran the formatter
-      // here. attachEditorFeatures drives it from onDidPaste instead, gated on
-      // the same editorPrefs.formatOnPaste setting.
+      // Monaco own format-on-paste is left off: it never ran the formatter
+      // here. attachEditorFeatures drives re-indent-on-paste from onDidPaste
+      // instead, gated on editorPrefs.indentOnPaste.
       formatOnPaste: false,
       formatOnType: editorPrefs.formatOnType === true, // off by default: on-type formatting adds per-keystroke latency on slow machines
       quickSuggestions: editorPrefs.quickSuggestions !== false,
@@ -894,7 +898,7 @@ var EditorPanel = function EditorPanel(_ref) {
     // Phase 2: background undo-history replay.
     // Only run for newly-created models (reused models already have their undo stack).
     var _phase2CleanupFn = null;
-    if (!_collabActive && !_reusingModel && typeof HistoryService !== 'undefined') {
+    if (!_collabActive && !_virtualPath && !_reusingModel && typeof HistoryService !== 'undefined') {
       var _phase2Branch  = EditorStore.getState().gitBranch || '';
       var _phase2Path    = tab.path;
       var _phase2Content = tab.content || '';
@@ -1209,9 +1213,9 @@ var EditorPanel = function EditorPanel(_ref) {
         autoClosingBrackets: editorPrefs.autoClosingBrackets || 'always',
         autoClosingQuotes: editorPrefs.autoClosingQuotes || 'always',
         autoIndent: editorPrefs.autoIndent || 'full',
-        // Monaco's own format-on-paste is left off: it never ran the formatter
-      // here. attachEditorFeatures drives it from onDidPaste instead, gated on
-      // the same editorPrefs.formatOnPaste setting.
+        // Monaco own format-on-paste is left off: it never ran the formatter
+      // here. attachEditorFeatures drives re-indent-on-paste from onDidPaste
+      // instead, gated on editorPrefs.indentOnPaste.
       formatOnPaste: false,
         formatOnType: editorPrefs.formatOnType === true, // off by default: on-type formatting adds per-keystroke latency on slow machines
         quickSuggestions: editorPrefs.quickSuggestions !== false,
@@ -1297,22 +1301,40 @@ var EditorPanel = function EditorPanel(_ref) {
     return function() { window.removeEventListener('mbeditor:focusPane', onFocusPane); };
   }, [paneId]);
 
-  // Jump to line if specified
+  // Jump to line if specified.
+  //
+  // The wait for content is load-bearing, not defensive. Opening a search hit
+  // in a file that wasn't already open runs this effect once while the model
+  // is still empty: the jump clamped to line 1 and then cleared gotoLine, so
+  // when the content finally arrived there was nothing left to re-trigger it
+  // and the cursor stayed on the wrong line. Whether it misbehaved came down
+  // to whether the fetch beat a 50 ms timer — hence "sometimes".
   useEffect(function () {
-    if (tab.gotoLine && monacoRef.current) {
-      (function () {
-        var editor = monacoRef.current;
-        setTimeout(function () {
-          editor.revealLineInCenter(tab.gotoLine);
-          editor.setPosition({ lineNumber: tab.gotoLine, column: tab.gotoCol || 1 });
-          editor.focus();
-
-          TabManager.saveTabViewState(tab.id, editor.saveViewState());
-          TabManager.clearGotoLine(paneId, tab.path);
-        }, 50);
-      })();
-    }
-  }, [tab.gotoLine, tab.content]); // need tab.content in dep array so if it loads asynchronously, the jump happens AFTER content loads
+    if (!tab.gotoLine || !monacoRef.current) return;
+    if (tab.loading) return;
+
+    var editor = monacoRef.current;
+    var timer = setTimeout(function () {
+      var model = editor.getModel();
+      if (!model || model.isDisposed()) return;
+
+      // A result can outlive the line it pointed at (the file shrank since the
+      // scan). Clamp instead of asking Monaco for a line that isn't there.
+      var line = Math.max(1, Math.min(tab.gotoLine, model.getLineCount()));
+      var column = tab.gotoCol || 1;
+      var maxColumn = model.getLineMaxColumn(line);
+      if (column > maxColumn) column = maxColumn;
+
+      editor.revealLineInCenter(line);
+      editor.setPosition({ lineNumber: line, column: column });
+      editor.focus();
+
+      TabManager.saveTabViewState(tab.id, editor.saveViewState());
+      TabManager.clearGotoLine(paneId, tab.path);
+    }, 50);
+
+    return function () { clearTimeout(timer); };
+  }, [tab.gotoLine, tab.gotoCol, tab.content, tab.loading]);
 
   // Apply RuboCop markers
   useEffect(function () {
@@ -1410,7 +1432,10 @@ var EditorPanel = function EditorPanel(_ref) {
   var GIT_LINE_POLL_MS = 10000;
 
   useEffect(function () {
+    // Virtual tabs (untitled://, mbeditor://, diff views) have no file behind
+    // them — polling git for one is a guaranteed-404 request every 10s.
     if (!gitAvailable || !tab.path || tab.isDiff || tab.isCombinedDiff) return;
+    if (tab.path.indexOf('://') >= 0) return;
 
     var cancelled = false;
 

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

@@ -109,7 +109,7 @@ var DEFAULT_EDITOR_PREFS = {
   autoClosingBrackets: 'always',
   autoClosingQuotes: 'always',
   autoIndent: 'full',
-  formatOnPaste: true,
+  indentOnPaste: true,
   formatOnType: false,
   formatOnSave: false,
   quickSuggestions: true,
@@ -744,6 +744,21 @@ var MbeditorApp = function MbeditorApp() {
   // buffer flags every dirty tab, which is just the definition of "dirty".
   var lastDiskContentRef = useRef({});
 
+  // Every successful save must go through this. Besides the 3.5s grace window
+  // that stops the external-change check racing our own write, a save defines
+  // the new on-disk truth — so it must also refresh the external-change
+  // baseline. The check's own fetch is skipped inside the grace window, so
+  // without this the baseline stayed at the *pre-save* disk content and the
+  // next files_changed push reported our own save as an external edit on any
+  // tab the user had started editing again.
+  function noteLocalSave(path, content) {
+    recentSavesRef.current[path] = Date.now();
+    setTimeout(function () { delete recentSavesRef.current[path]; }, 3500);
+    if (typeof content === 'string') {
+      lastDiskContentRef.current[path] = content.replace(/\r\n/g, '\n');
+    }
+  }
+
   // ── Draft backup helpers ─────────────────────────────────────────────────
   var draftWriteTimerRef = useRef({});
   var serverOnlineRef = useRef(true);
@@ -841,10 +856,21 @@ var MbeditorApp = function MbeditorApp() {
     });
   };
 
+  // Every structural mutation (create, delete, rename, import) funnels through
+  // here, so this is where the project-search cache has to be dropped. Saves
+  // invalidated it at their own call sites, which is why editing a file
+  // updated the results but adding or deleting one never did — the stale
+  // 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.
   var refreshProjectTree = function refreshProjectTree() {
     return FileService.getTree().then(function (data) {
       setTreeData(data || []);
       SearchService.buildIndex(data || []);
+      SearchService.invalidate();
+      if (searchQueryRef.current && searchPanelVisibleRef.current) {
+        _debouncedSearch(searchQueryRef.current);
+      }
       return data || [];
     })["catch"](function (err) {
       EditorStore.setStatus("Failed to refresh files: " + (err && err.message || "Unknown error"), "error");
@@ -1319,7 +1345,7 @@ var MbeditorApp = function MbeditorApp() {
           return {
             id: p.id,
             activeTabId: p.activeTabId,
-            tabs: p.tabs.filter(function (t) { return !t.isCombinedDiff && !t.isModelGraph; }).map(function (t) {
+            tabs: p.tabs.filter(function (t) { return !t.isCombinedDiff && !t.isModelGraph && !t.isUntitled; }).map(function (t) {
               return {
                 id: t.id, path: t.path, name: t.name, dirty: t.dirty, viewState: t.viewState,
                 isSettings: !!t.isSettings, isPreview: !!t.isPreview, previewFor: t.previewFor || null,
@@ -1648,17 +1674,28 @@ var MbeditorApp = function MbeditorApp() {
         });
       });
     }, Promise.resolve());
-  }, 2000)).current;
+    // 250ms, not 2s. The window only exists to coalesce the paths from a
+    // burst of saves; anything longer is dead time the user spends looking at
+    // stale search rows, and the server-side result cache was already dropped
+    // by the same broadcast, so waiting buys nothing.
+  }, 250)).current;
 
   // 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;
-      GitService.fetchStatus()["catch"](function () {});
+      // 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
+      // queues the tree and search requests behind itself, which is what made
+      // search look like it was waiting for git. fetchStatusLite patches the
+      // 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();
+        checkOpenTabsForExternalChanges(payload && payload.paths);
       })["catch"](function () {});
       if (payload && payload.paths && searchQueryRef.current && searchPanelVisibleRef.current) {
         payload.paths.forEach(function (p) { _pendingSearchRefreshPaths.current.add(p); });
@@ -1694,6 +1731,16 @@ var MbeditorApp = function MbeditorApp() {
       });
       if (changed) EditorStore.setState({ panes: newPanes });
 
+      // The CRDT kept our buffer identical to what the peer just wrote, so the
+      // buffer is the new on-disk truth — refresh the external-change baseline.
+      var _savedTab = null;
+      newPanes.forEach(function (p) {
+        p.tabs.forEach(function (t) { if (t.path === path) _savedTab = t; });
+      });
+      if (_savedTab && typeof _savedTab.content === 'string') {
+        lastDiskContentRef.current[path] = _savedTab.content.replace(/\r\n/g, '\n');
+      }
+
       // Reset the AVI clean baseline so undo past this peer's save shows dirty correctly.
       var _modelEntry = window.__mbeditorModels && window.__mbeditorModels[path];
       if (_modelEntry && _modelEntry.model && !_modelEntry.model.isDisposed()) {
@@ -1704,17 +1751,31 @@ var MbeditorApp = function MbeditorApp() {
     return function () { WebSocketService.offFileSaved(handleFileSaved); };
   }, []);
 
-  function checkOpenTabsForExternalChanges() {
+  // onlyPaths: when the trigger names the files that changed (the
+  // files_changed push always does — it only ever announces mbeditor's own
+  // writes), restrict the check to open tabs on those paths. The old
+  // behaviour re-fetched EVERY open tab on every save: N requests per save,
+  // and each one another chance for a stale comparison to cry "changed
+  // externally". A manual workspace refresh passes nothing and still checks
+  // everything — that is the button's job.
+  function checkOpenTabsForExternalChanges(onlyPaths) {
+    var pathSet = null;
+    if (onlyPaths && onlyPaths.length) {
+      pathSet = {};
+      onlyPaths.forEach(function (p) { pathSet[p] = true; });
+    }
     var st = EditorStore.getState();
     var allTabs = st.panes.reduce(function (acc, p) {
       return acc.concat(p.tabs.map(function (t) { return { paneId: p.id, tab: t }; }));
     }, []);
     var fileTabs = allTabs.filter(function (pt) {
       var path = pt.tab.path || '';
+      if (pathSet && !pathSet[path]) return false;
       return path &&
         !path.startsWith('mbeditor://') &&
         !path.startsWith('diff://') &&
         !path.startsWith('combined-diff://') &&
+        !path.startsWith('untitled://') &&
         !pt.tab.isCombinedDiff &&
         !pt.tab.isSettings &&
         !pt.tab.isImage &&
@@ -1736,6 +1797,16 @@ var MbeditorApp = function MbeditorApp() {
       }
       FileService.getFile(pt.tab.path, { allowMissing: true }).then(function (data) {
         if (!data || typeof data.content !== 'string') return;
+        // Re-read the tab: the snapshot above predates the fetch, and edits or
+        // a save that landed meanwhile would make a stale comparison here
+        // report phantom external changes.
+        var liveState = EditorStore.getState();
+        var livePane = liveState.panes.find(function (p) { return p.id === pt.paneId; });
+        var liveTab = livePane && livePane.tabs.find(function (t) { return t.id === pt.tab.id; });
+        if (!liveTab || liveTab.path !== pt.tab.path) return;
+        var savedAgain = recentSavesRef.current[pt.tab.path];
+        if (savedAgain && Date.now() - savedAgain < 3000) return;
+        pt = { paneId: pt.paneId, tab: liveTab };
         var serverNorm = data.content.replace(/\r\n/g, '\n');
         var tabNorm = (pt.tab.content || '').replace(/\r\n/g, '\n');
 
@@ -1933,17 +2004,29 @@ var MbeditorApp = function MbeditorApp() {
     }
 
     if (save) {
+      if (tab.isUntitled) {
+        // Save-as converts the scratch tab to a real one (closing the scratch
+        // tab in the process); a cancelled prompt keeps the tab open.
+        saveUntitledTab(closingPaneId, tab, { close: true })["catch"](function (err) {
+          if (!(err && err.cancelled)) {
+            EditorStore.setStatus("Save failed: " + (err && err.message || err), "error");
+          }
+        })["finally"](function () {
+          setClosingTabId(null);
+          setClosingPaneId(null);
+        });
+        return;
+      }
       setLoading(function (prev) {
         return _extends({}, prev, { save: true });
       });
       EditorStore.setStatus("Saving " + tab.name + "...", "info");
       isSavingRef.current = true;
       FileService.saveFile(tab.path, tab.content).then(function () {
-        recentSavesRef.current[tab.path] = Date.now();
-        setTimeout(function() { delete recentSavesRef.current[tab.path]; }, 3500);
+        noteLocalSave(tab.path, tab.content);
         EditorStore.setStatus("Saved", "success");
         SearchService.invalidate();
-        GitService.fetchStatus();
+        GitService.fetchStatusLite({ background: true });
         // Reset the AVI clean baseline so undo past this save point shows dirty correctly.
         var _closeEntry = window.__mbeditorModels && window.__mbeditorModels[tab.path];
         if (_closeEntry && _closeEntry.model && !_closeEntry.model.isDisposed()) {
@@ -2037,26 +2120,25 @@ var MbeditorApp = function MbeditorApp() {
     EditorStore.setStatus("Closed " + saved.length + " saved editor" + (saved.length === 1 ? "" : "s"), "info");
   };
 
-  var handleNewFileInTabDir = function handleNewFileInTabDir(paneId) {
-    var pane = state.panes.find(function (p) { return p.id === paneId; });
-    var activeForPane = pane && pane.tabs.find(function (t) { return t.id === pane.activeTabId; });
-    var activePath = activeForPane && activeForPane.path;
-    var isReal = activePath && activePath.indexOf('://') < 0 && activePath !== '__settings__';
-    var baseDir = isReal ? parentDir(activePath) : '';
-    // Make sure the explorer is visible so the inline-create row shows.
-    setActiveSidebarTab('explorer');
-    setSidebarCollapsed(false);
-    // Expand ancestors of the target dir.
-    if (baseDir) {
-      var parts = baseDir.split('/');
-      var ancestors = {};
-      for (var i = 1; i <= parts.length; i++) {
-        ancestors[parts.slice(0, i).join('/')] = true;
+  // Save-as for an untitled scratch tab: ask for a workspace-relative path,
+  // write it, then swap the scratch tab for a real one opened at that path.
+  // Returns a promise that rejects with {cancelled: true} when the user backs
+  // out, so close-flows can abort instead of discarding.
+  var saveUntitledTab = function saveUntitledTab(paneId, tab, opts) {
+    var input = window.prompt('Save as (path relative to workspace root):', tab.name + '.txt');
+    if (!input || !input.trim()) return Promise.reject({ cancelled: true });
+    var newPath = input.trim().replace(/^\/+/, '');
+    return FileService.saveFile(newPath, tab.content).then(function () {
+      noteLocalSave(newPath, tab.content);
+      SearchService.invalidate();
+      GitService.fetchStatusLite({ background: true });
+      FileService.getTree().then(function (data) { setTreeData(_treeUpdater(data || [])); })["catch"](function () {});
+      TabManager.closeTab(paneId, tab.id);
+      if (!(opts && opts.close)) {
+        TabManager.openTab(newPath, newPath.split('/').pop(), null, paneId);
       }
-      setExpandedDirs(function (prev) { return Object.assign({}, prev, ancestors); });
-    }
-    setPendingRename(null);
-    setPendingCreate({ type: 'file', parentPath: baseDir });
+      EditorStore.setStatus('Saved ' + newPath, 'success');
+    });
   };
 
   // Persist state when panes, focusedPaneId, or collapsedSections changes
@@ -2070,7 +2152,7 @@ var MbeditorApp = function MbeditorApp() {
         return {
           id: p.id,
           activeTabId: p.activeTabId,
-          tabs: p.tabs.filter(function(t) { return !t.isCombinedDiff && !t.isModelGraph; }).map(function (t) {
+          tabs: p.tabs.filter(function(t) { return !t.isCombinedDiff && !t.isModelGraph && !t.isUntitled; }).map(function (t) {
             return {
               id: t.id,
               path: t.path,
@@ -2566,7 +2648,7 @@ var MbeditorApp = function MbeditorApp() {
   var setActiveEOL = _useState31e2[1];
 
   useEffect(function () {
-    if (!gitAvailable || !activeTab || activeTab.isDiff || activeTab.isCombinedDiff || activeTab.isCommitGraph || !activeTab.path || activeTab.path.indexOf('diff://') === 0 || activeTab.path.indexOf('combined-diff://') === 0) {
+    if (!gitAvailable || !activeTab || activeTab.isDiff || activeTab.isCombinedDiff || activeTab.isCommitGraph || !activeTab.path || activeTab.path.indexOf('://') >= 0) {
       setActiveFileCommit(null);
       return;
     }
@@ -2711,14 +2793,20 @@ var MbeditorApp = function MbeditorApp() {
   };
 
   var _doSave = function _doSave(paneId, tab) {
+    if (tab.isUntitled) {
+      saveUntitledTab(paneId, tab)["catch"](function (err) {
+        if (err && err.cancelled) return;
+        EditorStore.setStatus("Save failed: " + (err && err.message || err), "error");
+      });
+      return;
+    }
     setLoading(function (prev) {
       return _extends({}, prev, { save: true });
     });
     EditorStore.setStatus("Saving " + tab.name + "...", "info");
     isSavingRef.current = true;
     FileService.saveFile(tab.path, tab.content).then(function () {
-      recentSavesRef.current[tab.path] = Date.now();
-      setTimeout(function() { delete recentSavesRef.current[tab.path]; }, 3500);
+      noteLocalSave(tab.path, tab.content);
       var newPanes = EditorStore.getState().panes.map(function (p) {
         if (p.id === paneId) {
           return _extends({}, p, { tabs: p.tabs.map(function (t) {
@@ -2770,7 +2858,7 @@ var MbeditorApp = function MbeditorApp() {
         })["catch"](function () {});
       }
 
-      GitService.fetchStatus();
+      GitService.fetchStatusLite({ background: true });
     })["catch"](function (err) {
       EditorStore.setStatus("Save failed: " + err.message, "error");
     })["finally"](function () {
@@ -2796,8 +2884,7 @@ var MbeditorApp = function MbeditorApp() {
     if (!tab) { dismissPendingReload(reload); return; }
     isSavingRef.current = true;
     FileService.saveFile(tab.path, tab.content).then(function () {
-      recentSavesRef.current[tab.path] = Date.now();
-      setTimeout(function() { delete recentSavesRef.current[tab.path]; }, 3500);
+      noteLocalSave(tab.path, tab.content);
       EditorStore.setState({
         panes: EditorStore.getState().panes.map(function (p) {
           if (p.id !== reload.paneId) return p;
@@ -2848,7 +2935,9 @@ var MbeditorApp = function MbeditorApp() {
     var dirtyTabs = state.panes.flatMap(function (p) {
       return p.tabs;
     }).filter(function (t) {
-      return t.dirty;
+      // Untitled scratch tabs need a save-as prompt each — Ctrl+S them
+      // individually; bulk-save skips them rather than stacking prompts.
+      return t.dirty && !t.isUntitled;
     });
     if (dirtyTabs.length === 0) return;
 
@@ -2861,10 +2950,8 @@ var MbeditorApp = function MbeditorApp() {
       return FileService.saveFile(tab.path, tab.content);
     });
     Promise.all(promises).then(function () {
-      var now = Date.now();
       dirtyTabs.forEach(function(tab) {
-        recentSavesRef.current[tab.path] = now;
-        setTimeout(function() { delete recentSavesRef.current[tab.path]; }, 3500);
+        noteLocalSave(tab.path, tab.content);
       });
       var newPanes = EditorStore.getState().panes.map(function (p) {
         return _extends({}, p, { tabs: p.tabs.map(function (t) {
@@ -2882,7 +2969,7 @@ var MbeditorApp = function MbeditorApp() {
       });
       EditorStore.setStatus("All files saved", "success");
       SearchService.invalidate();
-      GitService.fetchStatus();
+      GitService.fetchStatusLite({ background: true });
     })["catch"](function (err) {
       EditorStore.setStatus("Failed to save some files", "error");
     })["finally"](function () {
@@ -3807,7 +3894,7 @@ var MbeditorApp = function MbeditorApp() {
         EditorStore.setStatus('Created file: ' + createdName, 'success');
         return refreshProjectTree().then(function () {
           handleSelectFile(createdPath, createdName);
-          GitService.fetchStatus();
+          GitService.fetchStatusLite({ background: true });
         });
       })["catch"](function (err) {
         var message = err && err.response && err.response.data && err.response.data.error || err.message;
@@ -3828,7 +3915,7 @@ var MbeditorApp = function MbeditorApp() {
         handleNodeSelect({ path: createdPath, name: createdPath.split('/').pop(), type: 'folder' });
         EditorStore.setStatus('Created folder: ' + createdPath, 'success');
         return refreshProjectTree().then(function () {
-          return GitService.fetchStatus();
+          return GitService.fetchStatusLite({ background: true });
         });
       })["catch"](function (err) {
         var message = err && err.response && err.response.data && err.response.data.error || err.message;
@@ -3903,7 +3990,7 @@ var MbeditorApp = function MbeditorApp() {
       setSelectedPaths(new Set([renamedPath]));
       EditorStore.setStatus('Renamed to: ' + renamedPath, 'success');
       return refreshProjectTree().then(function () {
-        GitService.fetchStatus();
+        GitService.fetchStatusLite({ background: true });
       });
     })["catch"](function (err) {
       var message = err && err.response && err.response.data && err.response.data.error || err.message;
@@ -3964,7 +4051,7 @@ var MbeditorApp = function MbeditorApp() {
         EditorStore.setStatus('Delete failed: ' + message, 'error');
       }
       return refreshProjectTree().then(function () {
-        GitService.fetchStatus();
+        GitService.fetchStatusLite({ background: true });
       });
     })["finally"](function () {
       setLoading(function (prev) {
@@ -4024,7 +4111,7 @@ var MbeditorApp = function MbeditorApp() {
       onCloseOthers: function (id) { handleCloseOtherTabs(paneId, id); },
       onCloseSaved: function () { handleCloseSavedTabs(paneId); },
       onCloseAll: function () { handleCloseEditorsInGroup(paneId); },
-      onNewFile: function () { handleNewFileInTabDir(paneId); }
+      onNewFile: function () { TabManager.openUntitledTab(paneId); }
     });
   };
 
@@ -4877,7 +4964,9 @@ var MbeditorApp = function MbeditorApp() {
                       {
                         key: i,
                         className: "search-result-item",
-                        onClick: (function(r) { return function() { handleSelectFile(r.file, r.file.split('/').pop(), r.line, r.col); }; })(res)
+                        // 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(
@@ -5485,13 +5574,13 @@ var MbeditorApp = function MbeditorApp() {
                       )
                     ),
                     React.createElement(
-                      'label', { className: 'ide-settings-row ide-settings-row-check', title: 'Auto-format pasted code using the language formatter' },
-                      React.createElement('span', { className: 'ide-settings-label' }, 'Format on paste'),
+                      '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.formatOnPaste !== false,
-                        onChange: function(e) { var v = e.target.checked; setEditorPrefs(function(p) { return Object.assign({}, p, { formatOnPaste: v }); }); }
+                        checked: editorPrefs.indentOnPaste !== false,
+                        onChange: function(e) { var v = e.target.checked; setEditorPrefs(function(p) { return Object.assign({}, p, { indentOnPaste: v }); }); }
                       })
                     ),
                     React.createElement(