mbeditor 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47a8199a082957d396dce3cfa9de010ece11a11b2b938cf0cf81adfa6dd171f1
-  data.tar.gz: 30dfee949bc6d06245c6bd1ba5b682431b36b064e0ad510b0dac44b320c5a287
+  metadata.gz: 3a664c7e61d20ca986be983f370ade96b639796633533373068221f45ffdbf9e
+  data.tar.gz: d9d6f92fa563330c47bc94f080432fa1e38aeddd4449b5b37f473d0555f513c5
 SHA512:
-  metadata.gz: 81c342ce0dc3f80c44259ae3a130710013dcb81f45052d4cc4488d2a7dc112f7decc6b5d67f3f6aaa81cbcd7ef391d82136ee1adccdd369b369c7cfcd4d6afa7
-  data.tar.gz: b201dda9b9fe55e9f44981725788b1587bc052f940652e8eb7d86a8dcc3d17c45bb0984f71cd3bbbd9f3a001b3b0125ac09a9e53eedd3e580eab96a445be6a17
+  metadata.gz: 0c5ed1f9375cb92b32b74fb86f76b0f98a10646e6498407b89be7b4a07f4ab4105d0bb207ce40746b33f3f34a9eaaf4ee3de16f1816a378d16b0d23f70adac04
+  data.tar.gz: 2813e2df0341112f437241f7c27537ad03f5e66da90fa756fba95647855ac6d0885421a219a0baf392e9aedcaa5c6c86e9fd4bcffacae5337ca4a8ee899e8ecb

data/CHANGELOG.md

@@ -5,6 +5,66 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.11.0] - 2026-07-29
+
+### Added
+- **Real types for your own JavaScript, from your own JavaScript.** The
+  workspace's JS source is now loaded into Monaco's TypeScript program instead
+  of being grepped for names and declared as ambient `any`. Under Sprockets a
+  JS file with no `import`/`export` is a TypeScript *script*, so its top-level
+  declarations land in the global scope — which is exactly the Sprockets model.
+  Cross-file references now get inferred signatures, member completion, and
+  argument-count checking, and genuine unknowns still report `Cannot find
+  name`:
+
+  ```jsx
+  var c = <Card title="x" />;   // Card: (props: any) => JSX.Element
+  var s = formatCents(500);     // formatCents(value: any): string
+  var t = formatCents(1, 2);    // Expected 0-1 arguments, but got 2
+  ```
+
+  Two new options: `config.js_program` (default `true`) and
+  `config.js_program_exclude` (default `%w[vendor]`, added on top of
+  `excluded_paths`). Measured at ~93 ms/MB to build and ~30 ms per file
+  afterwards, so a ~10 MB tree costs under a second, once; only changed files
+  are re-sent after that.
+
+  Ambient declarations are still used for what a program cannot express.
+  TypeScript only sees *lexical* declarations: `window.Foo = ...` is not a
+  declaration to it, and UMD-wrapped libraries assign their global inside a
+  closure — `factory(global.React = {})` — which it cannot follow statically.
+  Their source contributes nothing, which is why vendored code is excluded by
+  default and React stays typed by a bundled stub. Point
+  `js_program_exclude` at any other third-party or generated JS.
+- **A whitespace toggle in the status bar** (¶), showing tabs, spaces and
+  hidden characters in the active editor.
+
+### Fixed
+- **The editor became very slow on JSX files with many unresolved names.**
+  Opening such a file fired one `/js_definition` request per unknown symbol,
+  in parallel — each spawning an `rg` process — and called `addExtraLib` once
+  per resolution, re-validating every open model each time. A file with a
+  thousand warnings meant a thousand greps saturating the dev server and a
+  thousand full TypeScript re-validations. That starved the file-tree poll,
+  git status, and saves behind it. Lookups are now serialized and capped, and
+  the declaration updates are coalesced into a single flush.
+- **Minified bundles crowded out the workspace's real globals.** A minified
+  file is one enormous line that usually opens with `var a,b,c,…` running to
+  thousands of declarators; split on commas, that single line exhausted the
+  3000-symbol cap before the scan reached your own components, so every
+  reference to them showed "Cannot find name". Declaring `a`/`n`/`t` as
+  ambient `any` also silenced real diagnostics for those names everywhere.
+  Minified files are now skipped by filename and by shape, and the endpoint
+  reports `truncated` so a workspace that outgrows the cap is diagnosable
+  instead of silently incomplete.
+- **"File was edited externally" appeared for files nothing had touched.** The
+  check compared the file on disk against the editor buffer — which differ for
+  every unsaved tab by definition — so saving one file broadcast a change that
+  flagged every *other* dirty tab. It now compares disk against the last disk
+  content seen, so only a real on-disk change raises the banner.
+
+---
+
 ## [0.10.1] - 2026-07-27
 
 ### Removed

data/README.md

@@ -77,6 +77,10 @@ Mbeditor.configure do |config|
   # config.ruby_def_include_dirs = %w[app/models app/controllers app/helpers app/concerns]
   # config.related_files_custom_paths = %w[app/assets/javascripts/app app/policies]
 
+  # JavaScript intelligence (see the "JavaScript intelligence" section below)
+  # config.js_program = false                                        # disable the source program entirely
+  # config.js_program_exclude = %w[vendor app/assets/javascripts/react]  # third-party/generated JS
+
   # Resilient routing (see the "Resilient Routing" section below)
   # config.mount_path = "/mbeditor"   # explicit prefix override; auto-detected when nil
   # config.resilient_routing = false  # escape hatch; true keeps the editor up when host routes break
@@ -95,6 +99,8 @@ end
 | `search_timeout` | `15` | Wall-clock bound on project-search subprocesses; a tripped deadline returns the partial results collected so far. `nil` disables. |
 | `search_respect_gitignore` | `false` | When `true`, project search and definition lookups skip files ignored by `.gitignore`. The default searches them, matching the editor's "show me everything on disk" behaviour. |
 | `js_global_identifiers` | `[]` | Extra JS names declared as ambient globals in the editor — for runtime-only globals the static workspace scan can't see (e.g. `%w[Routes I18n]`). |
+| `js_program` | `true` | Load the workspace's own JS source into Monaco's TypeScript program, so cross-file references get real inferred types instead of ambient `any`. See [JavaScript intelligence](#javascript-intelligence). `false` falls back to ambient declarations alone. |
+| `js_program_exclude` | `%w[vendor]` | Directories excluded from that program, on top of `excluded_paths`. Point this at any third-party or generated JS — vendored libraries are UMD-wrapped, so their source costs parse time and contributes no globals. |
 | `js_syntax_check` | `:auto` | Save-time babel parse check for JS/JSX using the host's `mini_racer` + babel-standalone (auto-detected; no-op when either is absent). `false` disables. |
 | `babel_standalone_path` | `nil` | Explicit path to the babel-standalone bundle for the syntax check; `nil` looks up `babel.min.js`/`babel.js` in the host's asset pipeline. |
 | `ruby_lsp` | `:auto` | Use the host's [ruby-lsp](https://github.com/Shopify/ruby-lsp) for Ruby go-to-definition, hover, completion, and diagnostics when it's installed (a persistent process is managed per workspace). `false` disables. Without ruby-lsp everything degrades to the built-in grep/Ripper services — no behavior change. |
@@ -141,6 +147,73 @@ See [Resilient Routing](#resilient-routing) for details.
 | `mount_path` | `nil` | Explicit URL prefix to serve resilient routing from. When `nil`, auto-detected from your `mount Mbeditor::Engine, at: "..."` line on every healthy boot. Set only to override detection. |
 | `resilient_routing` | `true` | Keeps mbeditor reachable when the host's `config/routes.rb` is broken, by serving its traffic from middleware that dispatches to a private route set. Set to `false` as an escape hatch: no middleware is inserted and the private set is never built. |
 
+## JavaScript intelligence
+
+Under Sprockets every JS file shares one global scope, with no imports. The
+editor models that in two layers.
+
+**1. The source program.** Your workspace's own JS is loaded into Monaco's
+TypeScript program. A JS file with no `import`/`export` is a TypeScript
+*script*, so its top-level declarations land in the global scope — which is
+exactly the Sprockets model. You get real inferred types across files:
+
+```jsx
+// app/assets/javascripts/ux/Card.jsx
+var Card = function (props) { return <div>{props.title}</div>; };
+function formatCents(value) { return "$" + (value / 100).toFixed(2); }
+```
+
+```jsx
+// somewhere else — no import needed
+var c = <Card title="x" />;      // Card: (props: any) => JSX.Element
+var s = formatCents(500);        // formatCents(value: any): string
+var t = formatCents(1, 2);       // Expected 0-1 arguments, but got 2
+```
+
+Unknown names still report `Cannot find name` — this adds type information, it
+doesn't silence errors.
+
+**2. Ambient declarations**, for names the program can't supply.
+
+Both layers are needed, because TypeScript only sees *lexical* declarations:
+
+- `window.Foo = ...` is a runtime global TypeScript does not treat as a
+  declaration at all.
+- UMD-wrapped libraries — React, lodash, axios — assign their global inside a
+  closure, `factory(global.React = {})`, which TypeScript cannot follow
+  statically. **Loading their source gets you nothing**, which is why
+  `js_program_exclude` defaults to `vendor` and why React is typed by a
+  bundled stub instead.
+
+So point `js_program_exclude` at directories of third-party or generated JS,
+and leave your own application code in:
+
+```ruby
+config.js_program_exclude = %w[vendor app/assets/javascripts/react]
+```
+
+### Cost
+
+Measured against the Monaco TypeScript worker:
+
+| program size | build | per file opened after |
+|---|---|---|
+| 1 MB | 210 ms | 9 ms |
+| 3 MB | 378 ms | 11 ms |
+| 5.5 MB | 443 ms | 23 ms |
+| 9.4 MB | 872 ms | 32 ms |
+
+Roughly 93 ms/MB, paid once per session. JS gzips about 4.5:1, so a 10 MB tree
+is ~2.2 MB over the wire — worth knowing if your app runs on a remote host.
+After the initial load only changed files are re-sent, never the whole tree.
+
+Nothing is truncated silently: the browser console logs the file count, total
+size, and every skipped file with a reason (minified, oversized, unreadable).
+Minified bundles are skipped by filename and by shape, since they cost parse
+time and declare only one-letter names inside a closure.
+
+Set `config.js_program = false` to disable the layer entirely.
+
 ## Test Runner
 
 The Test button appears in the editor toolbar for any `.rb` file when a `test/` or `spec/` directory exists in the workspace root. Clicking it:

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

@@ -599,6 +599,10 @@ var MbeditorApp = function MbeditorApp() {
   customPathsRef.current = customPaths;
   var recentSavesRef = useRef({});
   var isSavingRef = useRef(false);
+  // path -> the file's content as last seen ON DISK (newline-normalised).
+  // External-change detection compares disk-to-disk; comparing disk to the
+  // buffer flags every dirty tab, which is just the definition of "dirty".
+  var lastDiskContentRef = useRef({});
 
   // ── Draft backup helpers ─────────────────────────────────────────────────
   var draftWriteTimerRef = useRef({});
@@ -1456,7 +1460,21 @@ var MbeditorApp = function MbeditorApp() {
         if (!data || typeof data.content !== 'string') return;
         var serverNorm = data.content.replace(/\r\n/g, '\n');
         var tabNorm = (pt.tab.content || '').replace(/\r\n/g, '\n');
+
+        // Did the file on disk actually change? Compare disk against the last
+        // disk content we saw, never against the buffer — a dirty buffer
+        // differs from disk by definition, so the old comparison reported
+        // every unsaved tab as "updated externally" whenever a files_changed
+        // push arrived (which our own save of some *other* file triggers).
+        // A clean tab's buffer IS the disk content, so it seeds the baseline;
+        // a dirty tab with no baseline yet can't be judged, so record and wait.
+        var prevDisk = lastDiskContentRef.current[pt.tab.path];
+        lastDiskContentRef.current[pt.tab.path] = serverNorm;
         if (serverNorm === tabNorm) return;
+        if (prevDisk === undefined && pt.tab.dirty) return;
+        if (prevDisk === undefined) prevDisk = tabNorm;
+        if (serverNorm === prevDisk) return;
+
         if (!pt.tab.dirty) {
           EditorStore.setState({
             panes: EditorStore.getState().panes.map(function (p) {
@@ -5106,6 +5124,25 @@ var MbeditorApp = function MbeditorApp() {
         React.createElement("i", { className: "fas fa-stream" }),
         " Logs"
       ),
+      React.createElement(
+        "button",
+        {
+          type: "button",
+          className: "statusbar-btn" + (editorPrefs.renderWhitespace === 'all' ? " active" : ""),
+          title: editorPrefs.renderWhitespace === 'all'
+            ? "Hide whitespace characters"
+            : "Show whitespace characters (tabs, spaces, control characters)",
+          "aria-pressed": editorPrefs.renderWhitespace === 'all',
+          onClick: function () {
+            setEditorPrefs(function (p) {
+              return _extends({}, p, {
+                renderWhitespace: p.renderWhitespace === 'all' ? 'none' : 'all'
+              });
+            });
+          }
+        },
+        React.createElement("i", { className: "fas fa-paragraph" })
+      ),
       activeEOL && React.createElement(
         "button",
         {

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

@@ -107,26 +107,122 @@
 
   // Declare a discovered global in Monaco's extra libs so the TS2304 warning disappears.
   // Calling addExtraLib with the same URI replaces the previous content in-place.
-  function addDiscoveredGlobal(name) {
-    if (discoveredJsGlobals[name]) return;
-    if (REACT_MINI_UMD_GLOBALS[name]) return; // already in the mini-UMD
-    discoveredJsGlobals[name] = true;
+  //
+  // Coalesced: addExtraLib invalidates the TypeScript worker and re-validates
+  // EVERY open model. A JSX file that references 500 host-app globals resolves
+  // 500 symbols, and calling addExtraLib once per symbol meant 500 full
+  // re-validations — the editor spends minutes pegged at 100% CPU redoing work
+  // it is about to redo again. Batch them into one flush instead.
+  var _discoveredFlushTimer = null;
+  function flushDiscoveredGlobals() {
+    _discoveredFlushTimer = null;
     var mts = window.monaco && window.monaco.languages && window.monaco.languages.typescript;
-    if (!mts) return;
+    if (!mts || !mts.javascriptDefaults) return;
     var decls = Object.keys(discoveredJsGlobals)
       .map(function(k) { return 'declare var ' + k + ': any;'; }).join('\n');
     mts.javascriptDefaults.addExtraLib(decls, 'inmemory://mbeditor/discovered-globals.d.ts');
   }
 
-  // Bulk ambient globals: fetch every top-level declaration in the workspace
-  // (the Sprockets global scope — /js_globals greps var/function/class at
-  // column 0 plus window.X assignments across *.js/*.jsx/*.js.jsx/...) and
-  // declare them all in ONE extraLib. This proactively prevents TS2304
-  // ("Cannot find name") for cross-file component references instead of the
-  // reactive one-network-lookup-per-symbol path below, which stays as a
-  // fallback for anything the static scan can't see.
-  // Same-URI addExtraLib replaces content in place, which is the refresh
-  // mechanism (called again on files_changed broadcasts).
+  function addDiscoveredGlobal(name) {
+    if (discoveredJsGlobals[name]) return;
+    if (REACT_MINI_UMD_GLOBALS[name]) return; // already in the mini-UMD
+    discoveredJsGlobals[name] = true;
+    if (_discoveredFlushTimer) return;
+    _discoveredFlushTimer = setTimeout(flushDiscoveredGlobals, 300);
+  }
+
+  // Reactive TS2304 resolution runs ONE /js_definition request at a time.
+  // Each request spawns an rg process on the server, so firing one per
+  // unresolved symbol in parallel (a big JSX file can have hundreds) saturated
+  // the dev server: the file tree poll, git status, and file saves all queued
+  // behind hundreds of greps. That is what made the whole editor feel slow and
+  // what let the "file was edited externally" check race its own save.
+  var JS_LOOKUP_QUEUE_MAX = 400;
+  var jsLookupQueue = [];
+  var jsLookupBusy = false;
+
+  function pumpJsLookupQueue() {
+    if (jsLookupBusy) return;
+    var job = jsLookupQueue.shift();
+    if (!job) return;
+    jsLookupBusy = true;
+    var done = function () { jsLookupBusy = false; pumpJsLookupQueue(); };
+    FileService.getJsDefinition(job.sym)
+      .then(function (data) {
+        var results = data && data.results;
+        if (results && results.length && results[0].file !== job.modelPath) {
+          addDiscoveredGlobal(job.sym);
+        } else if (!results || !results.length) {
+          if (isRuntimeWindowGlobal(job.sym)) addDiscoveredGlobal(job.sym);
+        }
+      })
+      .then(done, done);
+  }
+
+  function queueJsGlobalLookup(sym, modelPath) {
+    if (jsLookupQueue.length >= JS_LOOKUP_QUEUE_MAX) return;
+    jsLookupQueue.push({ sym: sym, modelPath: modelPath });
+    pumpJsLookupQueue();
+  }
+
+  // ── The workspace TypeScript program ──────────────────────────────────────
+  //
+  // Two layers, because one does not cover everything:
+  //
+  //   1. /js_program — the workspace's own JS source, added as extraLibs at
+  //      file:/// URIs. A JS file with no import/export is a *script*, so
+  //      TypeScript puts its top-level declarations in the global scope: the
+  //      Sprockets model exactly. This gives REAL types — member completion,
+  //      inferred signatures, argument-count checks — for the host app's own
+  //      components, and still reports TS2304 for genuinely unknown names.
+  //
+  //   2. /js_globals — ambient `declare var X: any` for names the program
+  //      can't supply. UMD-wrapped libraries (React, lodash, axios) assign
+  //      their global inside a closure, `factory(global.React = {})`, which
+  //      TypeScript cannot follow statically, so their source contributes no
+  //      global at all. Those names only exist as ambient declarations.
+  //
+  // A global is skipped from layer 2 only when layer 1 genuinely supplies it,
+  // so a real inferred type is never shadowed by `any` — and, just as
+  // importantly, a name the program can't see never loses its declaration.
+  // "In a program file" is NOT sufficient: `window.Foo = ...` is a runtime
+  // global that TypeScript does not treat as a declaration at all, so those
+  // must keep their ambient `declare var` even though their file is in the
+  // program. Only lexical declarations land in TypeScript's global scope.
+  //
+  // Same-URI addExtraLib replaces content in place; that is how both layers
+  // refresh.
+  var PROGRAM_VISIBLE_KINDS = { 'var': 1, 'let': 1, 'const': 1, 'function': 1, 'class': 1 };
+  var programPaths = {}; // workspace-relative path -> true, for the filter above
+
+  function programUri(path) {
+    return 'file:///' + String(path).replace(/^\/+/, '');
+  }
+
+  function loadWorkspaceProgram(monaco) {
+    if (typeof FileService === 'undefined') return;
+    var mts = monaco && monaco.languages && monaco.languages.typescript;
+    if (!mts || !mts.javascriptDefaults) return;
+
+    var programLoaded = FileService.getJsProgram
+      ? FileService.getJsProgram().then(function (data) {
+          if (!data || !data.ok || !data.files) return;
+          data.files.forEach(function (f) {
+            if (!f || typeof f.content !== 'string' || !f.path) return;
+            programPaths[f.path] = true;
+            mts.javascriptDefaults.addExtraLib(f.content, programUri(f.path));
+          });
+          if (data.skipped && data.skipped.length && window.console) {
+            console.info('[mbeditor] ' + data.fileCount + ' source files (' +
+              Math.round(data.totalBytes / 1024) + ' KB) in the TypeScript program; ' +
+              data.skipped.length + ' skipped:', data.skipped);
+          }
+        }).catch(function () { /* fall through to ambient globals alone */ })
+      : Promise.resolve();
+
+    programLoaded.then(function () { loadWorkspaceGlobals(monaco); });
+  }
+
   function loadWorkspaceGlobals(monaco) {
     if (typeof FileService === 'undefined' || !FileService.getJsGlobals) return;
     var mts = monaco && monaco.languages && monaco.languages.typescript;
@@ -139,6 +235,11 @@
         if (!name || !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)) return;
         if (REACT_MINI_UMD_GLOBALS[name]) return;
         if (discoveredJsGlobals[name]) return; // already in discovered-globals.d.ts
+        // The program already declares this one, with a real type.
+        if (s.file && programPaths[s.file] && PROGRAM_VISIBLE_KINDS[s.kind]) {
+          attemptedJsGlobals[name] = true;
+          return;
+        }
         names.push(name);
         // Pre-seed the reactive resolver so the marker patcher never fires a
         // per-symbol /js_definition request for these.
@@ -149,6 +250,23 @@
     }).catch(function () { /* endpoint unavailable — reactive path still works */ });
   }
 
+  // Incremental refresh: re-send only the files that changed, never the whole
+  // tree. A workspace can be tens of MB, so re-fetching it on every save would
+  // cost more than the feature is worth.
+  function refreshProgramPaths(monaco, paths) {
+    var mts = monaco && monaco.languages && monaco.languages.typescript;
+    if (!mts || !mts.javascriptDefaults) return;
+    if (typeof FileService === 'undefined' || !FileService.getJsProgramFile) return;
+    (paths || []).forEach(function (path) {
+      if (!path || !/\.(js|jsx|ts|tsx)$/i.test(path)) return;
+      FileService.getJsProgramFile(path).then(function (data) {
+        if (!data || !data.ok || !data.file) return;
+        programPaths[data.file.path] = true;
+        mts.javascriptDefaults.addExtraLib(data.file.content, programUri(data.file.path));
+      }).catch(function () {});
+    });
+  }
+
   // Navigate to the first workspace definition of a JS symbol.
   // Returns a Promise<boolean> — true if a definition was found and opened.
   // Try the host's ruby-lsp (via the /ruby_lsp bridge) for a Ruby language
@@ -848,15 +966,22 @@
         );
       }
 
-      // Workspace-wide ambient globals, loaded once now and refreshed when
-      // files change (debounced) or on refocus (throttled, for the no-WS case).
-      loadWorkspaceGlobals(monaco);
+      // The workspace program (source files) plus the ambient globals it can't
+      // supply, loaded once now.
+      loadWorkspaceProgram(monaco);
+
+      // On a change: refresh just the touched files' program entries, and
+      // re-run the (cheap, cached) globals scan. The whole tree is never
+      // re-sent — see refreshProgramPaths.
       var refreshWorkspaceGlobals = function () { loadWorkspaceGlobals(monaco); };
       if (window._ && window._.debounce) {
         refreshWorkspaceGlobals = window._.debounce(refreshWorkspaceGlobals, 2000);
       }
       if (typeof WebSocketService !== 'undefined' && WebSocketService.onFilesChanged) {
-        WebSocketService.onFilesChanged(function () { refreshWorkspaceGlobals(); });
+        WebSocketService.onFilesChanged(function (payload) {
+          if (payload && payload.paths) refreshProgramPaths(monaco, payload.paths);
+          refreshWorkspaceGlobals();
+        });
       }
       var _lastGlobalsFocusRefresh = Date.now();
       window.addEventListener('focus', function () {
@@ -956,17 +1081,7 @@
               var sym = match[1];
               if (attemptedJsGlobals[sym]) return;
               attemptedJsGlobals[sym] = true;
-              var modelPath = model._mbeditorPath;
-              FileService.getJsDefinition(sym)
-                .then(function(data) {
-                  var results = data && data.results;
-                  if (results && results.length && results[0].file !== modelPath) {
-                    addDiscoveredGlobal(sym);
-                  } else if (!results || !results.length) {
-                    if (isRuntimeWindowGlobal(sym)) addDiscoveredGlobal(sym);
-                  }
-                })
-                .catch(function() {});
+              queueJsGlobalLookup(sym, model._mbeditorPath);
             });
           });
         }

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

@@ -247,6 +247,20 @@ var FileService = (function () {
       .then(function(res) { return res.data; });
   }
 
+  // The workspace's own JS source for Monaco's TypeScript program. This is the
+  // largest response the editor fetches (a big app is tens of MB before gzip),
+  // so it gets a generous timeout and is only ever fetched whole once — later
+  // changes go through getJsProgramFile.
+  function getJsProgram() {
+    return axios.get(window.mbeditorBasePath() + '/js_program', { timeout: 120000 })
+      .then(function(res) { return res.data; });
+  }
+
+  function getJsProgramFile(path) {
+    return axios.get(window.mbeditorBasePath() + '/js_program', { params: { path: path }, timeout: 15000 })
+      .then(function(res) { return res.data; });
+  }
+
   function getRelatedFiles(path) {
     return axios.get(window.mbeditorBasePath() + '/related_files', { params: { path: path } })
       .then(function(res) { return res.data; });
@@ -292,6 +306,8 @@ var FileService = (function () {
     getFileIncludes: getFileIncludes,
     getClientConfig: getClientConfig,
     getJsGlobals: getJsGlobals,
+    getJsProgram: getJsProgram,
+    getJsProgramFile: getJsProgramFile,
     rubyLspRequest: rubyLspRequest,
     lspDiagnostics: lspDiagnostics,
     getRelatedFiles: getRelatedFiles,

data/app/controllers/mbeditor/editors_controller.rb

@@ -462,6 +462,21 @@ module Mbeditor
       render json: { ok: false, error: e.message }, status: :unprocessable_content
     end
 
+    # GET /mbeditor/js_program
+    # The workspace's own JS source, for Monaco's TypeScript program. With
+    # ?path= it returns just that one file, which is how the editor refreshes
+    # after a change without re-sending the whole tree.
+    def js_program
+      if params[:path].present?
+        entry = JsProgramService.file(workspace_root, params[:path])
+        return render json: { ok: true, file: entry }
+      end
+
+      render json: JsProgramService.call(workspace_root)
+    rescue StandardError => e
+      render json: { ok: false, error: e.message }, status: :unprocessable_content
+    end
+
     RUBY_LSP_METHODS = {
       "definition"  => "textDocument/definition",
       "hover"       => "textDocument/hover",
@@ -964,6 +979,7 @@ module Mbeditor
       FileTreeService.invalidate(root)
       SearchReplaceService.invalidate_cache(root)
       JsGlobalsService.invalidate(root)
+      JsProgramService.invalidate(root)
       Thread.new do
         GitInfoService.invalidate(root)
       rescue => e

data/app/services/mbeditor/js_globals_service.rb

@@ -22,6 +22,24 @@ module Mbeditor
 
     IDENTIFIER = /[A-Za-z_$][A-Za-z0-9_$]*/
 
+    # Minified bundles are the reason for both guards below.
+    #
+    # A minified file is one enormous line, and it usually opens with a
+    # multi-declarator `var a,b,c,d,…` running to thousands of names. Split on
+    # commas, that ONE line yields thousands of one-letter symbols — enough to
+    # exhaust MAX_SYMBOLS on its own, so the workspace's actual components are
+    # never reached and every reference to them shows "Cannot find name".
+    # Worse, declaring `a`/`n`/`t` as ambient `any` silences genuine
+    # diagnostics for those names everywhere.
+    #
+    # The name check catches the conventional cases; the line-length check
+    # catches bundles that don't say "min" in the filename. Neither is a
+    # judgement about vendored code in general — a normally-formatted
+    # vendor/assets library still contributes its globals, which is correct
+    # under Sprockets.
+    MINIFIED_NAME = /[.\-]min\.(js|jsx|ts|tsx)\z/i
+    MAX_LINE_LENGTH = 2_000
+
     MUTEX = Mutex.new
     private_constant :MUTEX
 
@@ -47,19 +65,27 @@ module Mbeditor
 
       def compute(root)
         symbols = {}
+        truncated = false
 
         CodeSearchService.call(PATTERN, root).each do |raw|
-          break if symbols.length >= MAX_SYMBOLS
+          if symbols.length >= MAX_SYMBOLS
+            truncated = true
+            break
+          end
 
           m = raw.chomp.match(/\A(.+?):(\d+):(.*)\z/m)
           next unless m
 
           abs_path = m[1]
           next unless abs_path.start_with?(root)
+          next if abs_path.match?(MINIFIED_NAME)
+
+          snippet = m[3].strip
+          next if snippet.length > MAX_LINE_LENGTH
 
           rel = abs_path.delete_prefix(root).delete_prefix("/")
           line = m[2].to_i
-          extract_identifiers(m[3].strip).each do |name, kind|
+          extract_identifiers(snippet).each do |name, kind|
             symbols[name] ||= { name: name, file: rel, line: line, kind: kind }
           end
         end
@@ -71,6 +97,9 @@ module Mbeditor
         {
           ok: true,
           generatedAt: Time.now.to_i,
+          # Surfaced so a workspace that outgrows the cap is diagnosable from
+          # the endpoint instead of silently missing globals.
+          truncated: truncated,
           symbols: symbols.values.first(MAX_SYMBOLS).sort_by { |s| s[:name] }
         }
       end

data/app/services/mbeditor/js_program_service.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Enumerates the workspace's own JavaScript source and hands it to the editor
+  # so Monaco's TypeScript worker can build a real program from it.
+  #
+  # This is the file-based replacement for declaring every discovered name as
+  # ambient `any` (JsGlobalsService). Under Sprockets a JS file with no
+  # import/export is a *script*, so its top-level declarations land in the
+  # global scope — which is exactly TypeScript's own model for script files.
+  # Giving the worker the sources instead of a name list yields real inferred
+  # types, member completions, and argument-count checking, and it still
+  # reports "Cannot find name" for genuinely unknown identifiers.
+  #
+  # What it deliberately does NOT solve: UMD-wrapped libraries. React, lodash
+  # and axios all assign their global inside a closure
+  # (`factory(global.React = {})`), which TypeScript cannot follow statically —
+  # loading their source produces no global at all. Those stay on hand-written
+  # declarations (the React mini-UMD stub) or on JsGlobalsService's ambient
+  # names, which is why that service is still here.
+  #
+  # No truncation: a workspace that exceeds any limit reports what it skipped
+  # and why, rather than silently returning a partial program.
+  class JsProgramService
+    SOURCE_EXT = /\.(js|jsx|ts|tsx)\z/i
+
+    # Minified bundles cost parse time and yield nothing useful — their globals
+    # are one-letter names inside a closure. Matched by convention, then by
+    # shape for bundles whose filename doesn't say so.
+    MINIFIED_NAME = /[.\-]min\.(js|jsx|ts|tsx)\z/i
+    MAX_LINE_LENGTH = 2_000
+
+    # A single source file this large is a bundle or generated output, not
+    # something a person edits.
+    MAX_FILE_BYTES = 1024 * 1024
+
+    CACHE_TTL = 10 # seconds
+
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    class << self
+      def call(workspace_root)
+        root = File.expand_path(workspace_root.to_s)
+        now  = monotonic
+        MUTEX.synchronize do
+          entry = (@cache ||= {})[root]
+          return entry[:data] if entry && (now - entry[:ts]) < CACHE_TTL
+        end
+
+        data = compute(root)
+        MUTEX.synchronize { (@cache ||= {})[root] = { ts: monotonic, data: data } }
+        data
+      end
+
+      # Content for a single workspace-relative path, for incremental refresh
+      # after a file changes. Returns nil when the path isn't program material.
+      def file(workspace_root, relative_path)
+        root = File.expand_path(workspace_root.to_s)
+        rel  = relative_path.to_s.delete_prefix("/")
+        return nil unless rel.match?(SOURCE_EXT)
+        return nil if rel.match?(MINIFIED_NAME)
+        return nil if matcher(root).excluded?(rel)
+
+        abs = File.expand_path(File.join(root, rel))
+        return nil unless abs == File.join(root, rel) # no traversal out of the workspace
+        return nil unless File.file?(abs) && !File.symlink?(abs)
+
+        content = read_source(abs)
+        content && { path: rel, content: content }
+      end
+
+      def invalidate(workspace_root)
+        MUTEX.synchronize { (@cache ||= {}).delete(File.expand_path(workspace_root.to_s)) }
+      end
+
+      private
+
+      def compute(root)
+        return disabled_result unless Mbeditor.configuration.js_program
+
+        files   = []
+        skipped = []
+        total   = 0
+
+        each_candidate(root) do |rel, abs|
+          if File.size(abs) > MAX_FILE_BYTES
+            skipped << { path: rel, reason: "larger than #{MAX_FILE_BYTES} bytes" }
+            next
+          end
+
+          content = read_source(abs)
+          if content.nil?
+            skipped << { path: rel, reason: "minified or unreadable" }
+            next
+          end
+
+          total += content.bytesize
+          files << { path: rel, content: content }
+        end
+
+        {
+          ok: true,
+          enabled: true,
+          generatedAt: Time.now.to_i,
+          fileCount: files.length,
+          totalBytes: total,
+          skipped: skipped,
+          files: files.sort_by { |f| f[:path] }
+        }
+      end
+
+      def disabled_result
+        { ok: true, enabled: false, generatedAt: Time.now.to_i,
+          fileCount: 0, totalBytes: 0, skipped: [], files: [] }
+      end
+
+      # Walks the workspace, pruning excluded directories before descending so
+      # a node_modules tree is never entered. Symlinks are skipped outright:
+      # this walk is an enumeration, not a resolve_path lookup, and following
+      # them could both escape the workspace and loop.
+      def each_candidate(root)
+        m = matcher(root)
+        stack = [root]
+        while (dir = stack.pop)
+          children(dir).each do |name|
+            abs = File.join(dir, name)
+            rel = abs.delete_prefix(root).delete_prefix("/")
+            next if m.excluded?(rel)
+            next if File.symlink?(abs)
+
+            if File.directory?(abs)
+              stack.push(abs)
+            elsif name.match?(SOURCE_EXT) && !name.match?(MINIFIED_NAME)
+              yield rel, abs
+            end
+          end
+        end
+      end
+
+      def children(dir)
+        Dir.children(dir)
+      rescue SystemCallError
+        []
+      end
+
+      def matcher(root)
+        ExclusionMatcher.new(exclusion_patterns, root: root)
+      end
+
+      def exclusion_patterns
+        Array(Mbeditor.configuration.excluded_paths).map(&:to_s) +
+          Array(Mbeditor.configuration.js_program_exclude).map(&:to_s)
+      end
+
+      # Returns nil for anything that isn't usable program source: unreadable,
+      # invalid encoding, or minified-by-shape (one very long line).
+      def read_source(abs)
+        content = File.read(abs, encoding: Encoding::UTF_8)
+        return nil unless content.valid_encoding?
+        return nil if content.each_line.any? { |line| line.chomp.length > MAX_LINE_LENGTH }
+
+        content
+      rescue SystemCallError, IOError
+        nil
+      end
+
+      def monotonic
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/mbeditor/configuration.rb

@@ -9,6 +9,7 @@ module Mbeditor
                   :lint_timeout, :base_branch_candidates, :git_timeout, :search_timeout,
                   :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,
                   :ruby_lsp, :ruby_lsp_command, :ruby_lsp_timeout,
                   :search_respect_gitignore
@@ -35,6 +36,15 @@ module Mbeditor
       @related_files_custom_paths = []
       @authentication_cache_ttl = 0
       @js_global_identifiers = [] # extra ambient JS globals for the editor (runtime-only names invisible to static scan, e.g. %w[Routes I18n])
+      # Load the workspace's own JS source into Monaco's TypeScript program, so
+      # cross-file references get real inferred types instead of ambient `any`.
+      @js_program = true
+      # Excluded from that program on top of excluded_paths. Vendored libraries
+      # are UMD-wrapped (the global is assigned inside a closure), so their
+      # source yields no globals to TypeScript and only costs parse time — they
+      # stay on ambient declarations instead. Add any other directory of
+      # 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
       @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

data/lib/mbeditor/route_map.rb

@@ -32,6 +32,7 @@ module Mbeditor
     get    'js_definition',   to: 'editors#js_definition'
     get    'js_members',      to: 'editors#js_members'
     get    'js_globals',      to: 'editors#js_globals'
+    get    'js_program',      to: 'editors#js_program'
     post   'ruby_lsp',        to: 'editors#ruby_lsp'
     get    'module_members',  to: 'editors#module_members'
     get    'file_includes',   to: 'editors#file_includes'

data/lib/mbeditor/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbeditor
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Oliver Noonan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-27 00:00:00.000000000 Z
+date: 2026-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -114,6 +114,7 @@ files:
 - app/services/mbeditor/js_definition_service.rb
 - app/services/mbeditor/js_globals_service.rb
 - app/services/mbeditor/js_members_service.rb
+- app/services/mbeditor/js_program_service.rb
 - app/services/mbeditor/js_syntax_check_service.rb
 - app/services/mbeditor/log_tail_service.rb
 - app/services/mbeditor/lsp_diagnostics_translator.rb