mbeditor 0.12.7 → 0.12.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e19be096529fa5f410c792379f88395494fa7783964604b2ff07bb5a93d39d8
-  data.tar.gz: d491ca7214661784bbb9d6bc78c13da045a2da9529649d088dae1b0171d17868
+  metadata.gz: 4f4e31cf2770935dab538488ed3b946b26c7bacfb8519a7d1069cd84d8064838
+  data.tar.gz: db294fee8ac1938dc03f58d0332e13c2da4c8f2a322c62a22fbcd859b8d3b17c
 SHA512:
-  metadata.gz: 99bbd0a1dd19d7191563ea1586f5c38f9b68d0b70319f412be5439fb1588148b135aed1b8a20b66023129065ea84d71880d80054d6500a8ff1f2b83879f941c0
-  data.tar.gz: de0e4dfbb928584209ff4d5f1ace4a0bdb5c3b56a20c9a695c3c4770e2ccfd3a5063d9274f450706e13cabf4edd6ce2fdc3313b8477c6cecd28432eabc877246
+  metadata.gz: d3d8769779acc2c71a535c2d324385f182937a117218471f42dccac8ebe10c0e0741b46da229d3f388c70d8f10c27e510ae25c0eb6e8507dc7967c6e694c46d6
+  data.tar.gz: 130c85228b63ab45775d542086a7bb3104515cf07ecf15e88c8c23e8fe79f42207c9c1ab1f2f3ee16bf611a712c599335d5074e2060d1da90ac37dc52b833b09

data/CHANGELOG.md

@@ -7,6 +7,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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) {
@@ -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 || '';
@@ -1410,7 +1414,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

@@ -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);
@@ -1319,7 +1334,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,
@@ -1658,7 +1673,7 @@ var MbeditorApp = function MbeditorApp() {
       GitService.fetchStatus()["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 +1709,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 +1729,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 +1775,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,14 +1982,26 @@ 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();
@@ -2037,26 +2098,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.fetchStatus();
+      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 +2130,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 +2626,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 +2771,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) {
@@ -2796,8 +2862,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 +2913,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 +2928,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) {
@@ -4024,7 +4089,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); }
     });
   };
 

data/app/assets/javascripts/mbeditor/editor_plugins.js

@@ -1220,13 +1220,24 @@
           // Single-line comments
           [/#.*$/, 'comment'],
 
-          // Heredoc start — capture the terminator word; route to specialized state by delimiter name
+          // Heredoc start — capture the terminator word. A tag naming a
+          // language hands the body to Monaco's own tokenizer for that
+          // language via nextEmbedded, so <<~JS is highlighted as real
+          // JavaScript, not an imitation.
           [/<<[-~]?(['"]?)(\w+)\1/, {
             cases: {
-              '$2~(?i:SQL)':        { token: 'string.heredoc.delimiter', next: '@heredocSQL.$2' },
-              '$2~(?i:HTML?)':      { token: 'string.heredoc.delimiter', next: '@heredocHTML.$2' },
-              '$2~(?i:JS|JAVASCRIPT)': { token: 'string.heredoc.delimiter', next: '@heredocJS.$2' },
-              '@default':           { token: 'string.heredoc.delimiter', next: '@heredoc.$2' }
+              '$2~(?i:SQL)':            { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'sql' },
+              '$2~(?i:HTML?|ERB)':      { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'html' },
+              '$2~(?i:JS|JAVASCRIPT)':  { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'javascript' },
+              '$2~(?i:CSS)':            { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'css' },
+              '$2~(?i:SCSS)':           { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'scss' },
+              '$2~(?i:JSON)':           { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'json' },
+              '$2~(?i:XML|SVG)':        { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'xml' },
+              '$2~(?i:YAML|YML)':       { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'yaml' },
+              '$2~(?i:SH|BASH|SHELL)':  { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'shell' },
+              '$2~(?i:GRAPHQL|GQL)':    { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'graphql' },
+              '$2~(?i:RUBY)':           { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'ruby' },
+              '@default':               { token: 'string.heredoc.delimiter', next: '@heredoc.$2' }
             }
           }],
 
@@ -1360,9 +1371,12 @@
           [/\s+/, '']
         ],
 
-        // Generic heredoc — all content is string.heredoc
+        // Generic heredoc — all content is string.heredoc. The terminator may
+        // be indented: that is the whole point of <<~ (and <<-), and the old
+        // /^(\w+)$/ rule missed it, leaving the rest of the file painted as a
+        // string.
         heredoc: [
-          [/^(\w+)\s*$/, {
+          [/^\s*(\w+)\s*$/, {
             cases: {
               '$1==$S2': { token: 'string.heredoc.delimiter', next: '@pop' },
               '@default': 'string.heredoc'
@@ -1371,67 +1385,23 @@
           [/.+/, 'string.heredoc']
         ],
 
-        // SQL heredoc — keyword/string/number/comment tokenization
-        heredocSQL: [
-          [/^(\w+)\s*$/, {
+        // Language-tagged heredoc body. While embedded, Monarch only consults
+        // this state to find the leaving rule; everything before it is
+        // tokenized by the embedded language. @rematch + switchTo hands the
+        // terminator line to @heredocEnd so it gets the delimiter colour
+        // rather than being re-lexed as Ruby.
+        heredocEmbedded: [
+          [/^\s*(\w+)\s*$/, {
             cases: {
-              '$1==$S2': { token: 'string.heredoc.delimiter', next: '@pop' },
-              '@default': { token: '@rematch', next: '@heredocSQLLine' }
-            }
-          }],
-          [/.+/, { token: '@rematch', next: '@heredocSQLLine' }]
-        ],
-
-        heredocSQLLine: [
-          [/--.*$/, { token: 'comment.sql', next: '@pop' }],
-          [/'[^']*'/, 'string.sql'],
-          [/\b\d+(?:\.\d+)?\b/, 'number.sql'],
-          [/\b(?:SELECT|FROM|WHERE|INSERT|UPDATE|DELETE|JOIN|LEFT|RIGHT|INNER|OUTER|ON|GROUP|ORDER|BY|HAVING|LIMIT|OFFSET|CREATE|DROP|ALTER|TABLE|INDEX|INTO|VALUES|SET|AS|AND|OR|NOT|NULL|IS|IN|LIKE|BETWEEN|DISTINCT|COUNT|SUM|AVG|MIN|MAX)\b/i, 'keyword.sql'],
-          [/[^\s\w'"-]+/, 'string.heredoc'],
-          [/\w+/, 'string.heredoc'],
-          [/$/, { token: '', next: '@pop' }]
-        ],
-
-        // HTML heredoc — tag/attribute tokenization
-        heredocHTML: [
-          [/^(\w+)\s*$/, {
-            cases: {
-              '$1==$S2': { token: 'string.heredoc.delimiter', next: '@pop' },
-              '@default': { token: '@rematch', next: '@heredocHTMLLine' }
-            }
-          }],
-          [/.+/, { token: '@rematch', next: '@heredocHTMLLine' }]
-        ],
-
-        heredocHTMLLine: [
-          [/<\/?[a-zA-Z][a-zA-Z0-9]*/, 'tag.html'],
-          [/[a-zA-Z_:][a-zA-Z0-9_:\-\.]*(?=\s*=)/, 'attribute.name.html'],
-          [/\/?>/, 'tag.html'],
-          [/[^<>]+/, 'string.heredoc'],
-          [/$/, { token: '', next: '@pop' }]
-        ],
-
-        // JS heredoc — keyword/string/number/comment tokenization
-        heredocJS: [
-          [/^(\w+)\s*$/, {
-            cases: {
-              '$1==$S2': { token: 'string.heredoc.delimiter', next: '@pop' },
-              '@default': { token: '@rematch', next: '@heredocJSLine' }
+              '$1==$S2': { token: '@rematch', switchTo: '@heredocEnd.$S2', nextEmbedded: '@pop' },
+              '@default': { token: '' }
             }
           }],
-          [/.+/, { token: '@rematch', next: '@heredocJSLine' }]
+          [/.*/, { token: '' }]
         ],
 
-        heredocJSLine: [
-          [/\/\/.*$/, { token: 'comment', next: '@pop' }],
-          [/"(?:[^"\\]|\\.)*"/, 'string'],
-          [/'(?:[^'\\]|\\.)*'/, 'string'],
-          [/`(?:[^`\\]|\\.)*`/, 'string'],
-          [/\b\d+(?:\.\d+)?\b/, 'number'],
-          [/\b(?:var|let|const|function|return|if|else|for|while|do|switch|case|break|continue|new|delete|typeof|instanceof|in|of|class|extends|import|export|default|null|undefined|true|false|this|super|async|await|try|catch|finally|throw|void|yield)\b/, 'keyword'],
-          [/[^\s\w'"`;\/]+/, 'string.heredoc'],
-          [/\w+/, 'string.heredoc'],
-          [/$/, { token: '', next: '@pop' }]
+        heredocEnd: [
+          [/^\s*\w+\s*$/, { token: 'string.heredoc.delimiter', next: '@pop' }]
         ],
 
         // %w[] %W[] word arrays

data/app/assets/javascripts/mbeditor/tab_manager.js

@@ -650,8 +650,42 @@ var TabManager = (function () {
     _updateTab(paneId, path, { gotoLine: null, gotoCol: null });
   }
 
+  // VS Code-style scratch buffer: a tab with no file behind it. Nothing is
+  // written anywhere until the user saves, at which point the save flow asks
+  // for a real path and converts the tab.
+  function openUntitledTab(forcePaneId) {
+    var state = EditorStore.getState();
+    var paneId = forcePaneId || state.focusedPaneId;
+    var pane = state.panes.find(function (p) { return p.id === paneId; });
+    if (!pane) return;
+
+    var used = {};
+    state.panes.forEach(function (p) {
+      p.tabs.forEach(function (t) { if (t.isUntitled) used[t.name] = true; });
+    });
+    var n = 1;
+    while (used['Untitled-' + n]) n++;
+    var name = 'Untitled-' + n;
+    var path = 'untitled://' + name;
+
+    var newTab = {
+      id: path, path: path, name: name,
+      dirty: false, content: '', cleanContent: '',
+      viewState: null, isUntitled: true, loading: false,
+      externalContentVersion: 1
+    };
+    var newPanes = state.panes.map(function (p) {
+      if (p.id === paneId) {
+        return Object.assign({}, p, { tabs: p.tabs.concat(newTab), activeTabId: path });
+      }
+      return p;
+    });
+    EditorStore.setState({ panes: newPanes, focusedPaneId: paneId, activeTabId: path });
+  }
+
   return {
     openTab: openTab,
+    openUntitledTab: openUntitledTab,
     getRecentFiles: getRecentFiles,
     openDiffTab: openDiffTab,
     openCombinedDiffTab: openCombinedDiffTab,

data/app/controllers/mbeditor/editors_controller.rb

@@ -931,7 +931,20 @@ module Mbeditor
             startLine: line, startCol: col, endLine: line, endCol: col + 1
           }]
         else
-          []
+          # Only when the file parses: the scope lint would re-hit the same
+          # parse error and report nothing useful on top of the marker above.
+          JsSyntaxCheckService.scope_lint(workspace_root, code).map do |w|
+            line = w["line"] || 1
+            col  = (w["column"] || 0) + 1
+            {
+              severity: "warning",
+              copName: "BabelScope",
+              correctable: false,
+              message: "[babel] #{w['message']}",
+              startLine: line, startCol: col,
+              endLine: line, endCol: col + [w["name"].to_s.length, 1].max
+            }
+          end
         end
         return render json: { markers: markers }
       end

data/app/services/mbeditor/js_syntax_check_service.rb

@@ -14,6 +14,153 @@ module Mbeditor
     # V8 heap grows across transforms; recreate the context periodically.
     MAX_CHECKS_PER_CONTEXT = 50
     BABEL_ASSET_CANDIDATES = %w[babel.min.js babel.js babel-standalone.js babel-standalone.min.js].freeze
+    MAX_SCOPE_FINDINGS = 50
+
+    # Names defined by the browser rather than by any workspace file. ES
+    # builtins (Array, Promise, ...) are NOT listed: babel's own
+    # Scope#hasBinding already knows them, so this only needs the DOM layer.
+    BROWSER_GLOBALS = %w[
+      window document navigator location history screen console
+      alert confirm prompt getComputedStyle matchMedia scrollTo scrollBy
+      innerWidth innerHeight devicePixelRatio
+      fetch Headers Request Response XMLHttpRequest WebSocket EventSource
+      FormData URL URLSearchParams Blob File FileReader FileList DataTransfer
+      AbortController AbortSignal DOMParser XMLSerializer
+      setTimeout setInterval clearTimeout clearInterval
+      requestAnimationFrame cancelAnimationFrame requestIdleCallback cancelIdleCallback
+      queueMicrotask structuredClone atob btoa
+      localStorage sessionStorage indexedDB crypto performance
+      Event CustomEvent KeyboardEvent MouseEvent TouchEvent ErrorEvent
+      MessageEvent PopStateEvent StorageEvent ProgressEvent ClipboardEvent
+      MutationObserver ResizeObserver IntersectionObserver
+      Node NodeList Element HTMLElement SVGElement Image Audio Option
+      CSS customElements
+    ].freeze
+
+    # The React UMD globals plus the bare hook aliases host apps conventionally
+    # pull out of React at the top of a Sprockets bundle.
+    REACT_GLOBALS = %w[
+      React ReactDOM PropTypes
+      useState useEffect useLayoutEffect useRef useMemo useCallback useContext
+      useReducer useId useTransition useDeferredValue useSyncExternalStore
+      useImperativeHandle useDebugValue
+    ].freeze
+
+    # Installed into the V8 context alongside babel-standalone. collect()
+    # returns a file's top-level declaration names (Sprockets concatenates
+    # every file into one scope, so these are the cross-file globals). lint()
+    # reports references babel can bind to no scope and no whitelist entry,
+    # plus bindings that are only ever assigned inside a
+    # useEffect/useLayoutEffect callback but read during render.
+    LINT_HELPERS_JS = <<~'JS'
+      (function () {
+        if (globalThis.__mbLint) return;
+        if (typeof Babel === "undefined" || !Babel.packages || !Babel.packages.parser || !Babel.packages.traverse) return;
+        var parser = Babel.packages.parser;
+        var traverse = Babel.packages.traverse["default"] || Babel.packages.traverse;
+
+        function parse(source) {
+          return parser.parse(source, { sourceType: "script", plugins: ["jsx"], errorRecovery: true });
+        }
+
+        function bindNames(node, out) {
+          if (!node) return;
+          switch (node.type) {
+            case "Identifier": out.push(node.name); break;
+            case "ObjectPattern": node.properties.forEach(function (p) { bindNames(p.value || p.argument, out); }); break;
+            case "ArrayPattern": node.elements.forEach(function (el) { bindNames(el, out); }); break;
+            case "AssignmentPattern": bindNames(node.left, out); break;
+            case "RestElement": bindNames(node.argument, out); break;
+          }
+        }
+
+        // Is this path inside the callback argument of useEffect/useLayoutEffect?
+        function insideEffectCallback(path) {
+          var fn = path.getFunctionParent();
+          while (fn) {
+            var parent = fn.parentPath;
+            if (parent && parent.isCallExpression() && parent.node.arguments[0] === fn.node) {
+              var callee = parent.node.callee;
+              var name = callee.type === "Identifier" ? callee.name
+                : (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier"
+                    ? callee.property.name : null);
+              if (name === "useEffect" || name === "useLayoutEffect") return true;
+            }
+            fn = fn.getFunctionParent();
+          }
+          return false;
+        }
+
+        globalThis.__mbLint = {
+          collect: function (source) {
+            var names = [];
+            var ast;
+            try { ast = parse(source); } catch (e) { return names; }
+            ast.program.body.forEach(function (node) {
+              if (node.type === "VariableDeclaration") {
+                node.declarations.forEach(function (d) { bindNames(d.id, names); });
+              } else if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+                if (node.id) names.push(node.id.name);
+              }
+            });
+            return names;
+          },
+
+          lint: function (source, whitelist, max) {
+            var findings = [];
+            var wl = {};
+            whitelist.forEach(function (n) { wl[n] = true; });
+            var ast;
+            try { ast = parse(source); } catch (e) { return findings; }
+            var seen = {};
+
+            try {
+              traverse(ast, {
+                ReferencedIdentifier: function (p) {
+                  if (findings.length >= max) { p.stop(); return; }
+                  var name = p.node.name;
+                  if (p.isJSXIdentifier() && !/^[A-Z]/.test(name)) return; // <div>, <span>
+                  if (wl[name]) return;
+                  if (p.scope.hasBinding(name)) return; // includes ES builtins
+                  if (p.parentPath && p.parentPath.isUnaryExpression({ operator: "typeof" })) return;
+                  var loc = p.node.loc && p.node.loc.start;
+                  var key = name + ":" + (loc ? loc.line : 0);
+                  if (seen[key]) return;
+                  seen[key] = true;
+                  findings.push({
+                    kind: "undeclared", name: name,
+                    line: loc ? loc.line : 1, column: loc ? loc.column : 0,
+                    message: "'" + name + "' is not defined in any reachable scope"
+                  });
+                },
+
+                Function: function (p) {
+                  if (findings.length >= max) { p.stop(); return; }
+                  var bindings = p.scope.bindings;
+                  Object.keys(bindings).forEach(function (name) {
+                    var b = bindings[name];
+                    if (b.kind !== "let" && b.kind !== "var") return;
+                    if (!b.path.isVariableDeclarator() || b.path.node.init) return;
+                    var writes = b.constantViolations || [];
+                    if (!writes.length) return;
+                    if (!writes.every(insideEffectCallback)) return;
+                    var renderReads = (b.referencePaths || []).filter(function (r) { return !insideEffectCallback(r); });
+                    if (!renderReads.length) return;
+                    var loc = renderReads[0].node.loc && renderReads[0].node.loc.start;
+                    findings.push({
+                      kind: "effect", name: name,
+                      line: loc ? loc.line : 1, column: loc ? loc.column : 0,
+                      message: "'" + name + "' is only assigned inside an effect but read during render — undefined on first render"
+                    });
+                  });
+                }
+              });
+            } catch (e) { /* traversal blew up on odd input — report what we have */ }
+            return findings;
+          }
+        };
+      })();
+    JS
 
     MUTEX = Mutex.new
     private_constant :MUTEX
@@ -62,11 +209,43 @@ module Mbeditor
         end
       end
 
+      # Babel-based scope lint: warnings for identifier references that bind to
+      # no scope, no top-level declaration anywhere in the workspace's own JS
+      # (Sprockets: one shared scope), no known window.X global, and no
+      # browser/React name — the typos Monaco's TS worker misses once ambient
+      # globals are declared. Plus the effect-write/render-read hazard.
+      # Report-only; returns [] whenever anything is unavailable or fails.
+      def scope_lint(workspace_root, source)
+        return [] unless available? && Mbeditor.configuration.js_scope_lint != false
+
+        MUTEX.synchronize do
+          begin
+            ctx = context
+            return [] unless ctx
+
+            ctx.eval(LINT_HELPERS_JS) unless @lint_helpers_loaded
+            @lint_helpers_loaded = true
+            return [] unless ctx.eval("typeof __mbLint !== 'undefined'")
+
+            names = whitelist(ctx, workspace_root)
+            findings = ctx.eval("__mbLint.lint(#{source.to_json}, #{names.to_json}, #{MAX_SCOPE_FINDINGS})")
+
+            @checks_run = (@checks_run || 0) + 1
+            reset_context! if @checks_run >= MAX_CHECKS_PER_CONTEXT
+            Array(findings).select { |f| f.is_a?(Hash) }
+          rescue StandardError
+            reset_context!
+            []
+          end
+        end
+      end
+
       # Exposed for tests.
       def reset!
         MUTEX.synchronize do
           reset_context!
           @babel_path = :unresolved
+          @decl_cache = nil
         end
       end
 
@@ -91,6 +270,39 @@ module Mbeditor
       def reset_context!
         @context = nil
         @checks_run = 0
+        @lint_helpers_loaded = false
+      end
+
+      # Cross-file whitelist: every top-level declaration in the workspace's
+      # own JS program, every window.X-style global JsGlobalsService knows,
+      # plus the browser and React layers. Per-file declaration names are
+      # cached by content digest, so a steady-state save re-parses only the
+      # files that changed since the last lint.
+      def whitelist(ctx, workspace_root)
+        names = []
+        @decl_cache ||= {}
+        live = {}
+
+        program = JsProgramService.call(workspace_root.to_s)
+        Array(program[:files]).each do |f|
+          digest = f[:content].hash
+          entry = @decl_cache[f[:path]]
+          entry = { digest: digest, names: collect_names(ctx, f[:content]) } unless entry && entry[:digest] == digest
+          live[f[:path]] = entry
+          names.concat(entry[:names])
+        end
+        @decl_cache = live
+
+        globals = JsGlobalsService.call(workspace_root.to_s)
+        names.concat(Array(globals[:symbols]).map { |s| s[:name].to_s })
+
+        (names + BROWSER_GLOBALS + REACT_GLOBALS).uniq
+      end
+
+      def collect_names(ctx, source)
+        Array(ctx.eval("__mbLint.collect(#{source.to_json})")).grep(String)
+      rescue StandardError
+        []
       end
 
       def babel_source_path

data/app/services/mbeditor/search_replace_service.rb

@@ -297,9 +297,11 @@ module Mbeditor
           # Exclusions have to reach git as pathspecs, not just be dropped from
           # the results by the matcher below: otherwise git walks node_modules
           # and every other excluded tree in full before we discard the matches.
-          # A pathspec list of nothing but :(exclude) entries means
-          # "everything except these", which is exactly what the unscoped
-          # search wants.
+          # The "." anchor is required: newer git reads a pathspec list of
+          # nothing but :(exclude) entries as "everything except these", but
+          # older git refuses it outright ("fatal: There is nothing to exclude
+          # from"), exits 128, and search silently returns empty.
+          args << "." if paths.nil? && exclusions.any?
           args += exclusions.map { |p| ":(exclude)#{p}" }
           # No LC_ALL=C: measured neutral for the -F -i default and 2.2x slower
           # for -E, and the UTF-8 locale case-folds non-ASCII correctly.

data/lib/mbeditor/configuration.rb

@@ -10,7 +10,7 @@ module Mbeditor
                   :ruby_def_include_dirs, :related_files_custom_paths,
                   :mount_path, :resilient_routing, :js_global_identifiers,
                   :js_program, :js_program_exclude,
-                  :js_syntax_check, :babel_standalone_path,
+                  :js_syntax_check, :babel_standalone_path, :js_scope_lint,
                   :ruby_lsp, :ruby_lsp_command, :ruby_lsp_timeout,
                   :exception_capture, :model_graph_max_models,
                   :search_respect_gitignore, :ripgrep_command
@@ -84,6 +84,7 @@ module Mbeditor
       # third-party or generated JS here, e.g. "app/assets/javascripts/react".
       @js_program_exclude = %w[vendor]
       @js_syntax_check = :auto # save-time babel parse check via host mini_racer + babel-standalone; false disables
+      @js_scope_lint   = true  # save-time undeclared-identifier warnings (needs js_syntax_check active); false disables
       @babel_standalone_path = nil # explicit path to babel-standalone JS; nil auto-detects via the asset pipeline
       @ruby_lsp         = :auto # use the host's ruby-lsp for Ruby definitions/hover/completion when available; false disables
       @ruby_lsp_command = nil   # override the ruby-lsp launch command (String or Array); nil auto-resolves bin/ruby-lsp > gem > bundle exec

data/lib/mbeditor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mbeditor
-  VERSION = "0.12.7"
+  VERSION = "0.12.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbeditor
 version: !ruby/object:Gem::Version
-  version: 0.12.7
+  version: 0.12.8
 platform: ruby
 authors:
 - Oliver Noonan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-06 00:00:00.000000000 Z
+date: 2026-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails