mbeditor 0.4.5 → 0.5.1

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

@@ -103,6 +103,8 @@ var ShortcutHelp = function ShortcutHelp(_ref) {
                   null,
                   React.createElement(Row, { keys: 'Ctrl+P', desc: 'Quick-open any file by name' }),
                   React.createElement(Row, { keys: 'Ctrl+S', desc: 'Save the active file' }),
+                  React.createElement(Row, { keys: 'Ctrl+Shift+G', desc: 'Toggle git panel' }),
+                  React.createElement(Row, { keys: 'Ctrl+Shift+Z', desc: 'Toggle zen / focus mode' }),
                   React.createElement(Row, { keys: 'Escape', desc: 'Close quick-open / context menus' })
                 )
               )

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

@@ -51,6 +51,33 @@
 
   var globalsRegistered = false;
 
+  // Enumerate window for user-defined (non-native) globals and return a TypeScript
+  // declaration string.  Sprockets exposes every top-level var/function as a window
+  // property before Monaco initialises, so scanning window at registration time
+  // captures components, services, and helpers without any manual listing.
+  function buildWindowGlobalsShim() {
+    var alreadyDeclared = { React: 1, ReactDOM: 1, PropTypes: 1, MaterialUI: 1 };
+    var lines = [];
+    try {
+      var keys = Object.keys(window);
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if (alreadyDeclared[key]) continue;
+        if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) continue;
+        var value;
+        try { value = window[key]; } catch (e) { continue; }
+        if (value === null || value === undefined) continue;
+        if (typeof value === 'function') {
+          try {
+            if (/\[native code\]/.test(Function.prototype.toString.call(value))) continue;
+          } catch (e) { continue; }
+        }
+        lines.push('declare var ' + key + ': any;');
+      }
+    } catch (e) {}
+    return lines.join('\n');
+  }
+
   function leadingWhitespace(line) {
     var match = line.match(/^\s*/);
     return match ? match[0] : '';
@@ -62,6 +89,9 @@
 
   function rubyIndentUnit(model) {
     var options = model.getOptions ? model.getOptions() : null;
+    if (options && options.insertSpaces === false) {
+      return '\t';
+    }
     var tabSize = options && options.tabSize ? options.tabSize : 4;
     return new Array(tabSize + 1).join(' ');
   }
@@ -350,6 +380,46 @@
       });
     }
 
+    // Unused method dimming — grey out `def method_name` for methods with no
+    // call-sites anywhere in the workspace.
+    var unusedDecIds = [];
+    var unusedTimer = null;
+    var unusedSaveDisposable = null;
+
+    if (language === 'ruby' && typeof FileService !== 'undefined' && FileService.getUnusedMethods) {
+      function refreshUnused() {
+        var path = model._mbeditorPath;
+        if (!path) return;
+        FileService.getUnusedMethods(path).then(function(data) {
+          var unused = data && Array.isArray(data.unused) ? data.unused : [];
+          var newDecs = unused.map(function(m) {
+            var lineContent = model.getLineContent(m.line);
+            var defIdx = lineContent.indexOf('def ');
+            if (defIdx < 0) return null;
+            var nameCol = defIdx + 5; // 1-based column of method name
+            return {
+              range: new monaco.Range(m.line, nameCol, m.line, nameCol + m.name.length),
+              options: {
+                inlineClassName: 'mbeditor-unused-def',
+                stickiness: monaco.editor.TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+                hoverMessage: { value: '**Unused method** — `' + m.name + '` is never called in this application.' }
+              }
+            };
+          }).filter(Boolean);
+          unusedDecIds = editor.deltaDecorations(unusedDecIds, newDecs);
+        }).catch(function() {});
+      }
+
+      // Initial check after a short delay (server cache may not be warm yet).
+      unusedTimer = setTimeout(refreshUnused, 3000);
+
+      // Re-check after each save event (model content stops changing).
+      unusedSaveDisposable = model.onDidChangeContent(function() {
+        clearTimeout(unusedTimer);
+        unusedTimer = setTimeout(refreshUnused, 5000);
+      });
+    }
+
     var contentDisposable = model.onDidChangeContent(function (event) {
       if (suppressInternalEdit) return;
       if (event.isUndoing || event.isRedoing) return;
@@ -381,6 +451,9 @@
         if (gotoMouseDisposable) gotoMouseDisposable.dispose();
         if (gotoActionDisposable) gotoActionDisposable.dispose();
         contentDisposable.dispose();
+        if (unusedSaveDisposable) unusedSaveDisposable.dispose();
+        clearTimeout(unusedTimer);
+        if (unusedDecIds.length > 0) { editor.deltaDecorations(unusedDecIds, []); }
       }
     };
   }
@@ -391,6 +464,68 @@
 
     globalsRegistered = true;
 
+    // JavaScript: enable semantic checking (off by default in Monaco) and JSX support.
+    // checkJs catches undefined variables, noUnusedLocals catches dead assignments.
+    if (monaco.languages.typescript && monaco.languages.typescript.javascriptDefaults) {
+      monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
+        noSemanticValidation: false,
+        noSyntaxValidation: false,
+        noSuggestionDiagnostics: false
+      });
+      monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
+        target: monaco.languages.typescript.ScriptTarget.ES2020,
+        allowNonTsExtensions: true,
+        allowJs: true,
+        checkJs: true,
+        jsx: monaco.languages.typescript.JsxEmit.React,
+        noUnusedLocals: true
+      });
+    }
+
+    // Declare globals that the sprockets asset pipeline injects at runtime so
+    // checkJs doesn't flag them as undefined.  `interface Window` augmentation
+    // covers `window.myAppGlobal` access patterns.  For app-specific component
+    // names not listed here, add `/* global MyComponent */` at the top of the
+    // file — TypeScript's checkJs mode respects that directive.
+    if (monaco.languages.typescript && monaco.languages.typescript.javascriptDefaults) {
+      monaco.languages.typescript.javascriptDefaults.addExtraLib(
+        [
+          'declare var React: any;',
+          'declare var ReactDOM: any;',
+          'declare var PropTypes: any;',
+          'declare var MaterialUI: any;',
+          'interface Window { [key: string]: any; }'
+        ].join('\n'),
+        'inmemory://mbeditor/sprockets-globals.d.ts'
+      );
+
+      var dynamicShim = buildWindowGlobalsShim();
+      if (dynamicShim) {
+        monaco.languages.typescript.javascriptDefaults.addExtraLib(
+          dynamicShim,
+          'inmemory://mbeditor/window-globals.d.ts'
+        );
+      }
+    }
+
+    // TypeScript: enable JSX for .tsx files and catch unused locals.
+    if (monaco.languages.typescript && monaco.languages.typescript.typescriptDefaults) {
+      monaco.languages.typescript.typescriptDefaults.setCompilerOptions({
+        target: monaco.languages.typescript.ScriptTarget.ES2020,
+        allowNonTsExtensions: true,
+        jsx: monaco.languages.typescript.JsxEmit.React,
+        noUnusedLocals: true
+      });
+    }
+
+    // CSS for greyed-out unused method names (applied via decoration inlineClassName).
+    if (!document.getElementById('mbeditor-unused-style')) {
+      var unusedStyle = document.createElement('style');
+      unusedStyle.id = 'mbeditor-unused-style';
+      unusedStyle.textContent = '.mbeditor-unused-def { opacity: 0.35; }';
+      document.head.appendChild(unusedStyle);
+    }
+
     monaco.languages.setLanguageConfiguration('ruby', {
       comments: { lineComment: '#', blockComment: ['=begin', '=end'] },
       brackets: [['(', ')'], ['{', '}'], ['[', ']']],
@@ -730,6 +865,34 @@
         if (RUBY_CORE_METHODS[word]) return null;
         if (typeof FileService === 'undefined' || !FileService.getDefinition) return null;
 
+        // Uppercase first letter → likely a module/class name.
+        // Look up the module's exposed methods via /module_members.
+        if (/^[A-Z]/.test(word) && FileService.getModuleMembers) {
+          var modKey = '__mod__' + word;
+          var modCached = hoverCache[modKey];
+          if (modCached && (Date.now() - modCached.ts) < HOVER_CACHE_TTL_MS) {
+            return modCached.result || null;
+          }
+          var modController = typeof AbortController !== 'undefined' ? new AbortController() : null;
+          if (modController && token && token.onCancellationRequested) {
+            token.onCancellationRequested(function() { modController.abort(); });
+          }
+          return FileService.getModuleMembers(word, modController ? { signal: modController.signal } : {}).then(function(data) {
+            if (token && token.isCancellationRequested) return null;
+            if (!data || !data.methods || data.methods.length === 0) {
+              hoverCache[modKey] = { ts: Date.now(), result: null };
+              return null;
+            }
+            var lines = ['**' + data.name + '**  `' + (data.file || '') + '`\n'];
+            data.methods.slice(0, 20).forEach(function(m) {
+              lines.push('- `' + (m.signature || m.name) + '`');
+            });
+            var result = { contents: [{ value: lines.join('\n') }] };
+            hoverCache[modKey] = { ts: Date.now(), result: result };
+            return result;
+          }).catch(function() { return null; });
+        }
+
         var currentFile = model._mbeditorPath || null;
 
         // Return cached result immediately if still fresh.
@@ -801,6 +964,69 @@
       };
     }
 
+    // Include-aware completion provider for Ruby.
+    // Suggests methods from modules included/extended/prepended in the current file,
+    // with Notepad++-style snippet tab stops for method parameters.
+    var includesCache = {};
+    var INCLUDES_CACHE_TTL_MS = 30000;
+
+    function parseMethodParams(signature) {
+      var m = /\(([^)]+)\)/.exec(signature || '');
+      if (!m) return [];
+      return m[1].split(',').map(function(p) {
+        return p.trim().replace(/^[*&]+/, '').replace(/\s*=.*$/, '').trim();
+      }).filter(function(p) { return p.length > 0; });
+    }
+
+    monaco.languages.registerCompletionItemProvider('ruby', {
+      triggerCharacters: ['.'],
+      provideCompletionItems: function(model, position) {
+        var path = model._mbeditorPath;
+        if (!path || typeof FileService === 'undefined' || !FileService.getFileIncludes) {
+          return { suggestions: [] };
+        }
+
+        var lineUpToCursor = model.getValueInRange({
+          startLineNumber: position.lineNumber, startColumn: 1,
+          endLineNumber: position.lineNumber, endColumn: position.column
+        });
+        var isDot = lineUpToCursor.slice(-1) === '.';
+
+        function buildSuggestions(data) {
+          var suggestions = [];
+          (data.includes || []).forEach(function(mod) {
+            (mod.methods || []).forEach(function(m) {
+              var params = parseMethodParams(m.signature);
+              var snippet = params.length > 0
+                ? m.name + '(' + params.map(function(p, i) {
+                    return '${' + (i + 1) + ':' + p + '}';
+                  }).join(', ') + ')$0'
+                : m.name + '$0';
+              suggestions.push({
+                label: m.name,
+                kind: monaco.languages.CompletionItemKind.Method,
+                detail: mod.name + (mod.file ? '  ' + mod.file : ''),
+                insertText: snippet,
+                insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                sortText: (isDot ? '0' : '1') + m.name
+              });
+            });
+          });
+          return { suggestions: suggestions };
+        }
+
+        var cached = includesCache[path];
+        if (cached && (Date.now() - cached.ts) < INCLUDES_CACHE_TTL_MS) {
+          return buildSuggestions(cached.data);
+        }
+
+        return FileService.getFileIncludes(path).then(function(result) {
+          includesCache[path] = { ts: Date.now(), data: result };
+          return buildSuggestions(result);
+        }).catch(function() { return { suggestions: [] }; });
+      }
+    });
+
     // Vim-style fold-marker folding provider.
     // Recognises {{{ (open) and }}} (close) anywhere in a line, matching the
     // convention used by vim's `foldmethod=marker`. Registered for every

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

@@ -31,6 +31,12 @@ axios.interceptors.response.use(null, function(error) {
   return Promise.reject(error);
 });
 
+// Prefetch cache: path -> { controller: AbortController, promise: Promise<{content,language}>, resolvedAt: number|null }
+// Entries are consumed once (getPrefetched deletes them) or cancelled on mouseleave.
+// Settled entries that are never consumed expire after 30 s (TTL).
+var prefetchCache = new Map();
+var PREFETCH_TTL_MS = 30000;
+
 var FileService = (function () {
   function getWorkspace() {
     return axios.get(window.mbeditorBasePath() + '/workspace').then(function(res) { return res.data; });
@@ -48,6 +54,14 @@ var FileService = (function () {
     return axios.get(window.mbeditorBasePath() + '/file', { params: params }).then(function(res) { return res.data; });
   }
 
+  function getFileChunk(path, startLine, lineCount) {
+    if (lineCount === undefined) {
+      lineCount = 500;
+    }
+    var params = { path: path, start_line: startLine, line_count: lineCount };
+    return axios.get(window.mbeditorBasePath() + '/file', { params: params }).then(function(res) { return res.data; });
+  }
+
   function saveFile(path, code) {
     return axios.post(window.mbeditorBasePath() + '/file', { path: path, code: code }).then(function(res) { return res.data; });
   }
@@ -119,10 +133,82 @@ var FileService = (function () {
     return axios.get(window.mbeditorBasePath() + '/definition', config).then(function(res) { return res.data; });
   }
 
+  // Prefetch file content and store in prefetchCache. Uses native fetch + AbortController
+  // so the in-flight request can be cancelled on mouseleave without touching axios.
+  function prefetch(path) {
+    if (prefetchCache.has(path)) return; // already in-flight or cached
+
+    // Evict stale settled entries before adding a new one
+    var now = Date.now();
+    prefetchCache.forEach(function(entry, key) {
+      if (entry.resolvedAt !== null && now - entry.resolvedAt > PREFETCH_TTL_MS) {
+        prefetchCache.delete(key);
+      }
+    });
+
+    var controller = new AbortController();
+    var entry = { controller: controller, promise: null, resolvedAt: null };
+    // allow_missing=1 so a 404 resolves to { missing:true } instead of rejecting
+    var url = window.mbeditorBasePath() + '/file?path=' + encodeURIComponent(path) + '&allow_missing=1';
+    entry.promise = fetch(url, {
+      signal: controller.signal,
+      headers: { 'X-Mbeditor-Client': '1' }
+    }).then(function(res) {
+      if (!res.ok) throw new Error('prefetch failed: ' + res.status);
+      return res.json();
+    }).then(function(data) {
+      entry.resolvedAt = Date.now();
+      return data;
+    }).catch(function(err) {
+      // Remove from cache on failure/abort so a real open falls back to a fresh fetch
+      prefetchCache.delete(path);
+      return null;
+    });
+    prefetchCache.set(path, entry);
+  }
+
+  // Returns a Promise for the cached result and removes the entry (consume-once),
+  // or returns null if no prefetch is in-flight / completed for this path.
+  // Settled entries older than PREFETCH_TTL_MS are treated as expired.
+  function getPrefetched(path) {
+    var entry = prefetchCache.get(path);
+    if (!entry) return null;
+    if (entry.resolvedAt !== null && Date.now() - entry.resolvedAt > PREFETCH_TTL_MS) {
+      prefetchCache.delete(path);
+      return null;
+    }
+    prefetchCache.delete(path);
+    return entry.promise;
+  }
+
+  // Abort any in-flight prefetch for path and remove it from the cache.
+  function cancelPrefetch(path) {
+    var entry = prefetchCache.get(path);
+    if (!entry) return;
+    entry.controller.abort();
+    prefetchCache.delete(path);
+  }
+
+  function getModuleMembers(name, extraOptions) {
+    var config = Object.assign({ params: { name: name }, timeout: 8000 }, extraOptions || {});
+    return axios.get(window.mbeditorBasePath() + '/module_members', config).then(function(res) { return res.data; });
+  }
+
+  function getFileIncludes(path, extraOptions) {
+    var config = Object.assign({ params: { path: path }, timeout: 15000 }, extraOptions || {});
+    return axios.get(window.mbeditorBasePath() + '/file_includes', config).then(function(res) { return res.data; });
+  }
+
+  function getUnusedMethods(path, extraOptions) {
+    var config = Object.assign({ params: { path: path }, timeout: 30000 }, extraOptions || {});
+    return axios.get(window.mbeditorBasePath() + '/unused_methods', config).then(function(res) { return res.data; });
+  }
+
   return {
     getWorkspace: getWorkspace,
     getTree: getTree,
     getFile: getFile,
+    getFileChunk: getFileChunk,
     saveFile: saveFile,
     createFile: createFile,
     createDir: createDir,
@@ -138,6 +224,12 @@ var FileService = (function () {
     getBranchState: getBranchState,
     saveBranchState: saveBranchState,
     pruneBranchStates: pruneBranchStates,
-    getDefinition: getDefinition
+    getDefinition: getDefinition,
+    prefetch: prefetch,
+    getPrefetched: getPrefetched,
+    cancelPrefetch: cancelPrefetch,
+    getModuleMembers: getModuleMembers,
+    getFileIncludes: getFileIncludes,
+    getUnusedMethods: getUnusedMethods
   };
 })();

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

@@ -1,12 +1,16 @@
 var GitService = (function () {
   function applyGitInfo(data) {
     var files = data.workingTree || data.files || [];
-    EditorStore.setState({
-      gitFiles: files,
+    var current = EditorStore.getState().gitFiles;
+    var stateUpdate = {
       gitBranch: data.branch || "",
       gitInfo: data,
       gitInfoError: null
-    });
+    };
+    if (JSON.stringify(files) !== JSON.stringify(current)) {
+      stateUpdate.gitFiles = files;
+    }
+    EditorStore.setState(stateUpdate);
   }
 
   function fetchInfo() {

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

@@ -1,6 +1,44 @@
 var SearchService = (function () {
   var SEARCH_PAGE_SIZE = 50;
 
+  // --- Result cache ---
+  var CACHE_TTL      = 30000; // 30 seconds
+  var CACHE_MAX_SIZE = 20;
+  var _searchCache   = new Map(); // key -> { data, expiresAt }
+
+  function _cacheKey(query, options, offset) {
+    return JSON.stringify([
+      query,
+      !!options.regex,
+      !!options.matchCase,
+      !!options.wholeWord,
+      offset || 0
+    ]);
+  }
+
+  function _cacheGet(key) {
+    var entry = _searchCache.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      _searchCache.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+
+  function _cacheSet(key, data) {
+    // FIFO approximation: evict oldest-inserted entry if at capacity (Map preserves insertion order, hits don't move to back)
+    if (_searchCache.size >= CACHE_MAX_SIZE && !_searchCache.has(key)) {
+      var oldest = _searchCache.keys().next().value;
+      _searchCache.delete(oldest);
+    }
+    _searchCache.set(key, { data: data, expiresAt: Date.now() + CACHE_TTL });
+  }
+
+  function invalidate() {
+    _searchCache.clear();
+  }
+
   var _miniSearch = new MiniSearch({
     fields: ['path', 'name'],           // indexed fields
     storeFields: ['path', 'name', 'type'] // returned fields (type: 'file'|'dir')
@@ -9,6 +47,9 @@ var SearchService = (function () {
   // Flat doc list kept in sync with _miniSearch so we can do substring lookups.
   var _allDocs = [];
 
+  // Tracks the in-flight projectSearch request so stale requests can be aborted.
+  var _searchController = null;
+
   function buildIndex(treeData) {
     // Capture the tree data immediately so a subsequent refresh doesn't
     // clobber us before the idle callback fires.
@@ -68,23 +109,48 @@ var SearchService = (function () {
     var matchCase = !!(options && options.matchCase);
     var wholeWord = !!(options && options.wholeWord);
 
+    // Check cache before hitting the network
+    var key = _cacheKey(query, options, off);
+    var cached = _cacheGet(key);
+    if (cached) {
+      if (off === 0) {
+        EditorStore.setState({ searchResults: cached.results, searchHasMore: cached.hasMore });
+      } else {
+        var prevResults = EditorStore.getState().searchResults || [];
+        EditorStore.setState({ searchResults: prevResults.concat(cached.results), searchHasMore: cached.hasMore });
+      }
+      return Promise.resolve(cached);
+    }
+
+    if (_searchController) { _searchController.abort(); }
+    var controller = new AbortController();
+    _searchController = controller;
+
     return axios.get(window.mbeditorBasePath() + '/search', {
-      params: { q: query, offset: off, limit: lim, regex: useRegex ? 'true' : 'false', match_case: matchCase ? 'true' : 'false', whole_word: wholeWord ? 'true' : 'false' }
+      params: { q: query, offset: off, limit: lim, regex: useRegex ? 'true' : 'false', match_case: matchCase ? 'true' : 'false', whole_word: wholeWord ? 'true' : 'false' },
+      signal: controller.signal
     }).then(function(res) {
+        _searchController = null;
         var data = res.data;
         var results    = Array.isArray(data) ? data : (data && data.results || []);
         var hasMore    = !Array.isArray(data) && !!(data && data.has_more);
         var totalCount = (data && data.total_count != null) ? data.total_count : null;
 
+        var payload = { results: results, hasMore: hasMore, totalCount: totalCount };
+        _cacheSet(key, payload);
+
         if (off === 0) {
           EditorStore.setState({ searchResults: results, searchHasMore: hasMore });
         } else {
           var prev = EditorStore.getState().searchResults || [];
           EditorStore.setState({ searchResults: prev.concat(results), searchHasMore: hasMore });
         }
-        return { results: results, hasMore: hasMore, totalCount: totalCount };
+        return payload;
       })
       .catch(function(err) {
+        if (axios.isCancel(err) || (err && err.name === 'CanceledError')) {
+          return { results: [], hasMore: false, totalCount: null };
+        }
         EditorStore.setStatus("Search failed: " + err.message, "error");
         return { results: [], hasMore: false, totalCount: null };
       });
@@ -108,11 +174,34 @@ var SearchService = (function () {
     });
   }
 
+  // POST /replace_in_files — replace query with replacement across all matching files.
+  // options: { regex, matchCase, wholeWord }
+  // Returns a promise resolving to { replaced_count, files_affected, errors }.
+  function replaceInFiles(query, replacement, options) {
+    var useRegex   = !!(options && options.regex);
+    var matchCase  = !!(options && options.matchCase);
+    var wholeWord  = !!(options && options.wholeWord);
+
+    return axios.post(window.mbeditorBasePath() + '/replace_in_files', {
+      query:       query,
+      replacement: replacement,
+      regex:       useRegex   ? 'true' : 'false',
+      match_case:  matchCase  ? 'true' : 'false',
+      whole_word:  wholeWord  ? 'true' : 'false'
+    }, {
+      headers: { 'X-Mbeditor-Client': '1' }
+    }).then(function(res) {
+      return res.data;
+    });
+  }
+
   return {
     buildIndex: buildIndex,
     searchFiles: searchFiles,
     projectSearch: projectSearch,
     fetchPage: fetchPage,
+    invalidate: invalidate,
+    replaceInFiles: replaceInFiles,
     PAGE_SIZE: SEARCH_PAGE_SIZE
   };
 })();

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

@@ -1,4 +1,46 @@
 var TabManager = (function () {
+  var MAX_MODELS = 15;
+
+  // Evict the least-recently-used Monaco model that is not currently open in
+  // any pane. Call this before creating a new model entry.
+  function _evictLruModel() {
+    if (!window.__mbeditorModels) return;
+    var keys = Object.keys(window.__mbeditorModels);
+    if (keys.length < MAX_MODELS) return; // room available — evict one to make room for one new entry
+
+    // Collect the set of paths currently open in any pane.
+    var state = EditorStore.getState();
+    var openPaths = {};
+    state.panes.forEach(function(pane) {
+      pane.tabs.forEach(function(tab) {
+        openPaths[tab.path] = true;
+      });
+    });
+
+    // Find the eviction candidate: oldest lastAccessed that is not open.
+    var candidate = null;
+    var candidateTime = Infinity;
+    keys.forEach(function(path) {
+      if (openPaths[path]) return; // skip currently-open files
+      var entry = window.__mbeditorModels[path];
+      var t = entry.lastAccessed || 0; // || 0 treats pre-existing entries (no lastAccessed) as oldest, so they evict first
+      if (t < candidateTime) {
+        candidateTime = t;
+        candidate = path;
+      }
+    });
+
+    // If every cached model is currently open in a pane, skip eviction — never evict an active file.
+    // The cache may temporarily exceed MAX_MODELS; this is acceptable.
+    if (candidate) {
+      var entry = window.__mbeditorModels[candidate];
+      if (entry.model && !entry.model.isDisposed()) {
+        entry.model.dispose();
+      }
+      delete window.__mbeditorModels[candidate];
+    }
+  }
+
   function _isImagePath(path) {
     return /\.(png|jpe?g|gif|svg|ico|webp|bmp|avif)$/i.test(path || "");
   }
@@ -137,7 +179,17 @@ var TabManager = (function () {
       return;
     }
 
-    FileService.getFile(path, { allowMissing: true }).then(function(data) {
+    // Use a prefetched result if available (hover-prefetch hit), otherwise fetch normally.
+    var prefetchPromise = FileService.getPrefetched(path);
+    var filePromise = prefetchPromise || FileService.getFile(path, { allowMissing: true });
+
+    filePromise.then(function(data) {
+      // getPrefetched can resolve to null if the in-flight request failed/was aborted.
+      // In that case fall back to a fresh fetch.
+      if (!data) return FileService.getFile(path, { allowMissing: true });
+      return data;
+    }).then(function(data) {
+      if (!data) { closeTab(paneId, path); return; }
       var loadedContent = typeof data.content === 'string' ? data.content : "";
       var fileNotFound = data && data.missing === true;
       _updateTab(paneId, path, {
@@ -155,6 +207,29 @@ var TabManager = (function () {
       }
     }).catch(function(err) {
       if (path.startsWith('diff://')) return; // diff tabs handle their own loading
+      if (err.response && err.response.status === 413) {
+        FileService.getFileChunk(path, 0, 500).then(function(data) {
+          var loadedContent = typeof data.content === 'string' ? data.content : "";
+          _updateTab(paneId, path, {
+            content: loadedContent,
+            cleanContent: loadedContent,
+            externalContentVersion: 1,
+            isImage: false,
+            fileNotFound: false,
+            dirty: false,
+            loading: false,
+            truncated: true,
+            startLine: data.start_line || 0,
+            lineCount: data.line_count || 0,
+            totalLines: data.total_lines || 0,
+            totalBytes: data.total_bytes || 0
+          });
+        }).catch(function(chunkErr) {
+          EditorStore.setStatus("Failed to load large file: " + ((chunkErr.response && chunkErr.response.data && chunkErr.response.data.error) || chunkErr.message), "error");
+          closeTab(paneId, path);
+        });
+        return;
+      }
       EditorStore.setStatus("Failed to load file: " + ((err.response && err.response.data && err.response.data.error) || err.message), "error");
       closeTab(paneId, path);
     });
@@ -497,6 +572,7 @@ var TabManager = (function () {
     clearGotoLine: clearGotoLine,
     closeAllTabsInPane: closeAllTabsInPane,
     closeAllTabs: closeAllTabs,
-    syncMarkdownPreview: _syncMarkdownPreviewContent
+    syncMarkdownPreview: _syncMarkdownPreviewContent,
+    evictLruModel: _evictLruModel
   };
 })();