mbeditor 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fe258515a6f0945da8bfcbfbe85197262af224c054924367597d97d370530e2
-  data.tar.gz: d3f65b3c351fef56291170d9401103d9b73d4b3a7ebad24885713b8deef5df85
+  metadata.gz: 3a664c7e61d20ca986be983f370ade96b639796633533373068221f45ffdbf9e
+  data.tar.gz: d9d6f92fa563330c47bc94f080432fa1e38aeddd4449b5b37f473d0555f513c5
 SHA512:
-  metadata.gz: 4de0d8f9374a370f4df1339166ff648013dafb07b23eeba6936f3ebf1d492c831905d7143d5ece2ece4e397f4f4b314b7461e496cec00003c507db5701347604
-  data.tar.gz: 17c4ef992175fc0a5fd8f18102214ac46cce75963ba7d06661f3ffac66eb7e7d55e69bef6c6f71e3ddb9999839c78fd9a2668abb99397442ac7bfb68da6ee561
+  metadata.gz: 0c5ed1f9375cb92b32b74fb86f76b0f98a10646e6498407b89be7b4a07f4ab4105d0bb207ce40746b33f3f34a9eaaf4ee3de16f1816a378d16b0d23f70adac04
+  data.tar.gz: 2813e2df0341112f437241f7c27537ad03f5e66da90fa756fba95647855ac6d0885421a219a0baf392e9aedcaa5c6c86e9fd4bcffacae5337ca4a8ee899e8ecb

data/CHANGELOG.md

@@ -5,6 +5,103 @@ 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
+- **The `listen`-based file watcher, and with it `config.watch_files`.**
+  0.10.0 enabled a workspace watcher by default. On Linux each watched
+  directory costs an inotify watch from `fs.inotify.max_user_watches`, a
+  *per-user* budget shared with everything else watching files — including the
+  host app's own code reloader and any other gem using `listen`. Exhausting it
+  raises `iNotify max watches exceeded`, and because `listen` reports some of
+  those failures from its own background thread, mbeditor could not even
+  rescue them. Claiming a share of a scarce OS resource by default was the
+  wrong trade for a development tool, and raising the limit needs root, which
+  a developer may not have.
+
+  Nothing is lost: external changes are picked up by polling, which is how the
+  editor already tracked git state. If you set `config.watch_files`, remove it
+  — it is now ignored.
+
+### Fixed
+- **The file tree never refreshed for changes made outside the editor.** Its
+  10-second poll returned early whenever the Action Cable socket was connected,
+  on the reasoning that the push covered it — but the server only broadcasts
+  from mbeditor's own mutation endpoints. With a socket connected, which is the
+  normal case, an external `git checkout` or generator run was never picked up.
+  The poll now always runs; the push remains the instant path for our own
+  writes. This is the bug the 0.10.0 watcher was compensating for.
+- **Git line-number tinting went stale for external changes**, for the same
+  reason, and its refresh timer was being cleared and recreated on every
+  re-render so it never survived long enough to fire. It now polls on its own
+  timer and on window focus, matching the file tree.
+- **Watched paths were dropped when the workspace was reached through a
+  symlink** (macOS `/var` → `/private/var`, or a symlinked checkout), because
+  reported paths resolve to the real path and no longer matched the configured
+  root.
+
+---
+
 ## [0.10.0] - 2026-07-27
 
 ### Added

data/README.md

@@ -16,7 +16,6 @@ Mbeditor (Mini Browser Editor) is a mountable Rails engine that adds a browser-b
 - Optional RuboCop lint and format endpoints (uses host app RuboCop)
 - Optional Ruby language-server integration (definitions, hover, completion, diagnostics)
 - Optional test runner with inline failure markers and a dedicated results panel (Minitest and RSpec)
-- Optional workspace file watching, so changes made outside the editor refresh the tree and git decorations
 
 ## Security Warning
 Mbeditor exposes read and write access to your Rails application directory over HTTP. It is intended only for local development.
@@ -78,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
@@ -96,12 +99,13 @@ 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. |
 | `ruby_lsp_command` | `nil` | Override the ruby-lsp launch command (String or Array). `nil` auto-resolves `bin/ruby-lsp` → installed gem → `bundle exec ruby-lsp`. |
 | `ruby_lsp_timeout` | `3` | Seconds per LSP request; on timeout (e.g. during initial indexing) the editor falls back to the built-in services for that request. |
-| `watch_files` | `:auto` | Watch the workspace for changes made outside the editor (a terminal `git checkout`, a generator, another editor) and push a refresh to open clients. Requires the host's [`listen`](https://github.com/guard/listen) gem; without it the editor behaves as before and only announces its own writes. `false` disables. |
 
 ### Authentication
 
@@ -143,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:
@@ -205,113 +276,9 @@ The gem keeps host/tooling responsibilities in the host app:
 - `minitest` or `rspec` in the host app's bundle (required for the test runner)
 - `actioncable` framework/gem (optional, required only for realtime file-change push + websocket state saves)
 - `ruby-lsp` gem (optional — see below)
-- `listen` gem (optional — see below)
 
 All lint and test tools are auto-detected at runtime. The engine gracefully disables features if the tools are not available. Neither `rubocop`, `haml_lint`, nor any test framework are runtime dependencies of the gem itself — they are discovered from the host app's environment.
 
-### Workspace file watching (Optional)
-
-Add [`listen`](https://github.com/guard/listen) to the host app's development
-group and mbeditor watches the workspace for changes it did not make itself:
-
-```ruby
-group :development do
-  gem 'listen'
-end
-```
-
-Without it, only writes made *through* the editor announce themselves, so a
-`git checkout` or a generator run in a terminal leaves the file tree and the
-git line-number colours stale until you reopen the file. With it, those refresh
-on their own.
-
-The watcher runs only in `allowed_environments` and only in processes that
-serve requests, so rake tasks and consoles never start one. It respects
-`excluded_paths`, coalesces bursts (a branch switch is one refresh, not
-hundreds), and requires Action Cable to actually deliver the push. If it cannot
-start — inotify limits, permissions — it logs a warning and the editor carries
-on exactly as it would without the gem. Set `config.watch_files = false` to
-disable it even when `listen` is present.
-
-### Ruby language server (Optional)
-
-Add [ruby-lsp](https://github.com/Shopify/ruby-lsp) to the host app's
-development group and mbeditor uses it automatically for Ruby
-go-to-definition, hover, completion, and diagnostics:
-
-```ruby
-gem "ruby-lsp", require: false, group: :development
-gem "ruby-lsp-rails", require: false, group: :development  # Rails-aware results
-```
-
-`ruby-lsp-rails` needs no mbeditor configuration — ruby-lsp loads it as an
-addon, so associations, model attributes, and route helpers start resolving on
-their own.
-
-What changes when it's present:
-
-- **Diagnostics.** Ruby files are checked by ruby-lsp instead of booting
-  RuboCop over HTTP on every debounce, so you also get Prism syntax errors and
-  warnings alongside RuboCop offenses. Quick-fix lightbulbs still work for
-  correctable cops. Very large files fall back to syntax-only diagnostics.
-- **Definitions, hover, completion.** Answered from the language server's index
-  rather than a workspace grep, including your unsaved buffer contents.
-
-Everything degrades on its own: if ruby-lsp is missing, times out (its first
-index of a large app takes a while), or crashes, that request falls back to the
-built-in grep/Ripper services. ERB templates always use the built-in services —
-ruby-lsp cannot parse ERB.
-
-### Realtime via Action Cable (Optional)
-
-Mbeditor works without Action Cable. If Action Cable is unavailable, unreachable, or returns transient errors, the editor automatically falls back to polling.
-
-To enable realtime features in a host app:
-
-1. Ensure Action Cable is enabled in the host app (for apps that do not load it by default, add the framework/gem explicitly).
-2. Mount cable in host routes:
-
-```ruby
-mount ActionCable.server => '/cable'
-```
-
-3. Make Action Cable JavaScript available to the page (for asset-pipeline apps, `actioncable.js` is typically sufficient).
-
-If any of these are missing, mbeditor still runs in polling mode.
-
-### Syntax Highlighting Support
-Monaco runtime assets are served from the engine route namespace (`/mbeditor/monaco-editor/*` and `/mbeditor/monaco_worker.js`).
-The gem includes syntax highlighting for common Rails and React development file types:
-
-**Web & Template Languages:**
-- **Ruby** (.rb, Gemfile, gemspec, Rakefile)
-- **HTML** 
-- **ERB** (.html.erb, .erb) — dedicated ERB grammar, plus Ruby intellisense
-  inside `<% %>` tags: hover, completion, go-to-definition (Ctrl/Cmd+click or
-  F12) and auto-`end`, all inert in the surrounding HTML. ERB uses the built-in
-  workspace services rather than ruby-lsp, which cannot parse ERB.
-- **HAML** (.haml) — plaintext syntax highlighting (no dedicated HAML grammar in Monaco; haml-lint provides inline error markers when available)
-- **CSS** and **SCSS** stylesheets
-
-**JavaScript & React:**
-- **JavaScript / JSX** (.js, .jsx, .js.jsx) — Monaco's TypeScript worker runs in
-  checked-JS mode with JSX enabled. Built for the Sprockets world where every
-  top-level `var`/`function`/`class` (and `window.X =` assignment) is a global:
-  the editor scans the workspace once at boot (`GET /js_globals`) and declares
-  all of them as ambient globals, so cross-file component references need no
-  `import` and produce no "Cannot find name" diagnostics. The list refreshes
-  automatically when files change. Runtime-only globals the static scan can't
-  see (e.g. `Routes`, `I18n`) can be declared via
-  `config.js_global_identifiers = %w[Routes I18n]`.
-  Known limits: everything is typed `any` (no cross-file type inference), and
-  genuinely undefined names are shown as warnings, not errors.
-- **TypeScript** (.ts, .tsx)
-
-**Configuration & Documentation:**
-- **YAML** (.yml, .yaml)
-- **Markdown** (.md)
-
-These language modules are packaged locally with the gem for true offline operation. No network fallback is needed—all highlighting works without internet connectivity.
 
 ## Asset Pipeline
 

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

@@ -70,6 +70,9 @@ var EditorPanel = function EditorPanel(_ref) {
 
   var blameDecorationsRef = useRef([]);
   var gitLineDecorationsRef = useRef([]);
+  // Latest git line-diff refresh, read by the poll effect so its interval does
+  // not have to be torn down whenever the active tab changes.
+  var gitLineRefreshRef = useRef(null);
   var blameZoneIdsRef = useRef([]);
   var testDecorationIdsRef = useRef([]);
   var testZoneIdsRef = useRef([]);
@@ -1290,7 +1293,14 @@ var EditorPanel = function EditorPanel(_ref) {
   // The ranges come from `git diff -U0` against HEAD, so they describe the file
   // as last written to disk. Monaco anchors decorations to the model and shifts
   // them as you type, which keeps them roughly right mid-edit; the authoritative
-  // refresh happens when the file lands on disk and the server broadcasts it.
+  // refresh happens on the signals wired up at the end of this effect.
+
+  // Poll cadence for the tint, matching the file tree's. Slower to react than a
+  // filesystem watcher would be, at the cost of one `git diff -U0` on one file
+  // per visible pane — against a resource nothing else is competing for, rather
+  // than a share of the kernel's inotify budget.
+  var GIT_LINE_POLL_MS = 10000;
+
   useEffect(function () {
     if (!gitAvailable || !tab.path || tab.isDiff || tab.isCombinedDiff) return;
 
@@ -1347,17 +1357,45 @@ var EditorPanel = function EditorPanel(_ref) {
 
     refresh();
 
+    // Publish the current refresh for the poll below, which lives in its own
+    // effect so a re-render of this one cannot restart its clock.
+    gitLineRefreshRef.current = refresh;
+
+    // Immediate path for writes mbeditor made itself.
     var hasSocket = typeof WebSocketService !== 'undefined' && WebSocketService.onFilesChanged;
     var onChanged = hasSocket ? function () { refresh(); } : null;
     if (onChanged) WebSocketService.onFilesChanged(onChanged);
 
     return function () {
       cancelled = true;
+      gitLineRefreshRef.current = null;
       if (onChanged && WebSocketService.offFilesChanged) WebSocketService.offFilesChanged(onChanged);
       clear();
     };
   }, [tab.path, tab.externalContentVersion, tab.isDiff, tab.isCombinedDiff, gitAvailable]);
 
+  // The poll for changes made outside the editor — a terminal commit or branch
+  // switch alters the diff without touching this buffer.
+  //
+  // Deliberately its own effect with no dependencies. Held inside the effect
+  // above, the interval was cleared and recreated on every re-render of that
+  // one and never survived long enough to fire, so the tint only ever updated
+  // via the WebSocket — i.e. never for external changes, which is the whole
+  // point of it. Reading the refresh through a ref keeps this clock running
+  // across tab switches.
+  useEffect(function () {
+    var tick = function () {
+      if (document.hidden) return;
+      if (gitLineRefreshRef.current) gitLineRefreshRef.current();
+    };
+    var intervalId = setInterval(tick, GIT_LINE_POLL_MS);
+    window.addEventListener('focus', tick);
+    return function () {
+      clearInterval(intervalId);
+      window.removeEventListener('focus', tick);
+    };
+  }, []);
+
   // Handle Blame data fetching
   useEffect(function () {
     if (!isBlameVisible) {

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) {
@@ -1498,14 +1516,18 @@ var MbeditorApp = function MbeditorApp() {
     });
   }
 
-  // Auto-refresh the file tree every 10s to pick up external changes (new files, deletions, etc.)
-  // When an ActionCable WebSocket is connected this acts only as a safety-net fallback —
-  // the WebSocket push above handles immediate invalidation after mbeditor mutations.
+  // Auto-refresh the file tree every 10s to pick up external changes (new files,
+  // deletions, a branch switch in a terminal).
+  //
+  // This runs whether or not the WebSocket is connected. It used to skip when
+  // connected, on the reasoning that the push covered it — but the server only
+  // broadcasts from mbeditor's own mutation endpoints, so a connected socket
+  // meant external changes were never picked up at all. The push remains the
+  // instant path for our own writes; this is what catches everything else.
   // Uses functional setTreeData to skip the re-render when nothing has changed.
   useEffect(function () {
     var intervalId = setInterval(function () {
       if (document.hidden) return;
-      if (WebSocketService.isConnected()) return; // WebSocket is handling refreshes
       FileService.getTree().then(function (data) {
         var newData = data || [];
         setTreeData(function (prevData) {
@@ -5102,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,9 +9,10 @@ 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, :watch_files
+                  :search_respect_gitignore
 
     def initialize
       @allowed_environments = [:development]
@@ -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
@@ -42,7 +52,6 @@ module Mbeditor
       @ruby_lsp_timeout = 3     # seconds per LSP request before falling back to the built-in services
       @mount_path = nil # explicit URL prefix override; nil falls through to detection/"/mbeditor"
       @resilient_routing = true # serve /mbeditor from middleware so the editor survives a broken host routes.rb; false is the escape hatch
-      @watch_files = :auto # watch the workspace for changes made outside the editor when the host has the `listen` gem; false disables
     end
   end
 end

data/lib/mbeditor/engine.rb

@@ -4,7 +4,6 @@ require "mbeditor/rack/silence_ping_request"
 require "mbeditor/rack/handle_pending_migrations"
 require "mbeditor/rack/resilient_router"
 require "mbeditor/cable_log_filter"
-require "mbeditor/file_watcher"
 
 module Mbeditor
   class Engine < ::Rails::Engine
@@ -82,8 +81,6 @@ module Mbeditor
         raise ArgumentError, "[mbeditor] config.workspace_root is set to '#{cfg.workspace_root}' but that path is not a directory"
       end
 
-      Mbeditor::FileWatcher.start_if_enabled
-
       if cfg.redmine_enabled
         require "uri"
         if cfg.redmine_url.blank?

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.0"
+  VERSION = "0.11.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbeditor
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  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
@@ -136,7 +137,6 @@ files:
 - lib/mbeditor/configuration.rb
 - lib/mbeditor/editor_bootstrap.rb
 - lib/mbeditor/engine.rb
-- lib/mbeditor/file_watcher.rb
 - lib/mbeditor/mount_path.rb
 - lib/mbeditor/private_routes.rb
 - lib/mbeditor/rack/handle_pending_migrations.rb

data/lib/mbeditor/file_watcher.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module Mbeditor
-  # Watches the workspace for changes made outside the editor — a terminal
-  # `git checkout`, a rebase, another editor, a generator — and broadcasts the
-  # same `files_changed` payload the mutation endpoints send. Clients refresh
-  # the file tree, git line-number tinting and cached globals from it.
-  #
-  # The `listen` gem is an optional host dependency. Without it the editor
-  # behaves exactly as before: only changes made *through* mbeditor announce
-  # themselves. Nothing warns loudly about the missing gem — it is opt-in.
-  #
-  # Only one watcher runs per process. It is deliberately not started in test
-  # or in non-server processes (rake, console, the Rails runner), where a
-  # background listener thread is pure overhead.
-  module FileWatcher
-    # Coalesce bursts: a branch switch touches hundreds of files, and each one
-    # would otherwise be its own broadcast.
-    DEBOUNCE_SECONDS = 0.3
-
-    class << self
-      def available?
-        return @available if defined?(@available)
-
-        @available = begin
-          require "listen"
-          true
-        rescue LoadError
-          false
-        end
-      end
-
-      def running?
-        !@listener.nil?
-      end
-
-      # Boot entry point. Confined to the environments the editor is allowed in
-      # and to processes that actually serve requests — a rake task or console
-      # has no client to broadcast to, and a listener thread there would only
-      # burn file handles. MBEDITOR_FORCE_WATCH overrides the process check for
-      # unusual servers and for tests.
-      def start_if_enabled
-        cfg = Mbeditor.configuration
-        return false if cfg.watch_files == false
-        return false unless cfg.allowed_environments.map(&:to_s).include?(Rails.env.to_s)
-        return false unless serving_requests?
-
-        start(cfg.workspace_root.presence || Rails.root.to_s)
-      end
-
-      # Returns true when a watcher was started, false for every reason not to
-      # (gem absent, already running, no workspace, disabled by config).
-      def start(root)
-        return false unless available?
-        return false if running?
-
-        root = root.to_s
-        return false if root.empty? || !File.directory?(root)
-
-        ignores = ignore_patterns(root)
-        @listener = ::Listen.to(root, ignore: ignores, latency: DEBOUNCE_SECONDS) do |modified, added, removed|
-          broadcast(root, modified + added + removed)
-        end
-        @listener.start
-        Rails.logger.info("[mbeditor] watching #{root} for external changes")
-        true
-      rescue StandardError => e
-        # A watcher that cannot start must never take the host app down with it:
-        # inotify limits on Linux, permission issues, an unreadable root.
-        Rails.logger.warn("[mbeditor] file watcher failed to start: #{e.class}: #{e.message}")
-        @listener = nil
-        false
-      end
-
-      def stop
-        @listener&.stop
-      rescue StandardError
-        nil
-      ensure
-        @listener = nil
-      end
-
-      private
-
-      def serving_requests?
-        return true if ENV["MBEDITOR_FORCE_WATCH"]
-
-        defined?(Rails::Server) || defined?(Puma::Server) || defined?(Unicorn) || defined?(Passenger)
-      end
-
-      # `listen` matches ignores against paths relative to the watched root, so
-      # the configured exclusions become anchored regexps. Escaping matters:
-      # entries like "vendor/bundle" and "public/assets" contain separators, and
-      # a stray metacharacter in host config should not build a bogus pattern.
-      def ignore_patterns(root)
-        Array(Mbeditor.configuration.excluded_paths).map(&:to_s).reject(&:empty?).map do |path|
-          %r{\A#{Regexp.escape(path.delete_prefix("/").delete_suffix("/"))}(/|\z)}
-        end
-      end
-
-      # Paths arrive absolute. Anything that does not sit under the workspace
-      # is dropped rather than sent raw: the client keys everything by
-      # workspace-relative path, and an absolute one would leak host layout.
-      def relative_paths(root, paths)
-        paths.filter_map do |path|
-          rel = path.to_s.delete_prefix("#{root}/")
-          rel unless rel.empty? || rel == path.to_s
-        end
-      end
-
-      def broadcast(root, paths)
-        relative = relative_paths(root, paths)
-
-        invalidate_caches(root)
-        return unless defined?(ActionCable.server)
-
-        payload = { type: "files_changed" }
-        payload[:paths] = relative.first(200) if relative.any?
-        ActionCable.server.broadcast("mbeditor_editor", payload)
-      rescue StandardError => e
-        Rails.logger.warn("[mbeditor] file watcher broadcast failed: #{e.class}: #{e.message}")
-      end
-
-      # Mirrors EditorsController#broadcast_files_changed: a change the editor
-      # did not make invalidates exactly the same caches as one it did.
-      def invalidate_caches(root)
-        FileTreeService.invalidate(root)
-        SearchReplaceService.invalidate_cache(root)
-        JsGlobalsService.invalidate(root)
-        GitInfoService.invalidate(root)
-      rescue StandardError => e
-        Rails.logger.warn("[mbeditor] file watcher cache invalidation failed: #{e.class}: #{e.message}")
-      end
-    end
-  end
-end