Report the errors Fable raises, and fail the build on them (#67)

Author: nojaf

CHANGELOG.md

@@ -5,6 +5,16 @@ 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) from version [0.1.0] moving forward.
 
+## [0.4.0] - 2026-09-03
+
+### Fixed
+
+- An F# file that type-checks but that Fable cannot translate now fails `vite build` instead of passing for a successful compile. `Fable.Compiler` filled a compile's diagnostics from the F# type-check only and discarded Fable's own logs, so a call like `Async.RunSynchronously` produced a module that does nothing while the build printed nothing and exited 0, and the app broke in the browser. Fixed upstream in [fable-compiler/Fable#4923](https://github.com/fable-compiler/Fable/pull/4923), which this release picks up: the daemon now reports what Fable said alongside the F# diagnostics, for the first compile of the project as well as for every recompile after an edit, so these errors reach the terminal, the browser overlay and `/api/diagnostics`. They carry no error number, so they are named by their tag — `ERROR FABLE:` where an F# diagnostic reads `ERROR FS0025:`. Diagnostics on files under `fable_modules` are still dropped unless `fableModulesDiagnostics` is on. ([#67](https://github.com/fable-compiler/vite-plugin-fable/pull/67))
+
+### Changed
+
+- Updated Fable.Compiler to 5.15.0 and `@fable-org/fable-library-js` to 2.6.0. ([#67](https://github.com/fable-compiler/vite-plugin-fable/pull/67))
+
 ## [0.3.1] - 2026-08-29
 
 ### Changed

CLAUDE.md

@@ -21,7 +21,7 @@ else's contract:
   hook-contract questions definitively. Several plugin bugs were misdiagnosed from assumptions
   about Vite that the source contradicted, and several fixes in the git history cite line numbers
   from it.
-- `../Fable` — Fable 5.14. Notably `src/Fable.Compiler/Library.fs`, where
+- `../Fable` — Fable 5.15. Notably `src/Fable.Compiler/Library.fs`, where
   `FileWriter.AddSourceMapping` is a no-op, so `CliArgs.SourceMaps` does nothing.
 
 ## Seeing what the plugin actually emitted, without a browser

Directory.Packages.props

@@ -8,7 +8,7 @@
     <PackageVersion Include="FSharp.Core" Version="10.1.203" />
     <PackageVersion Include="FSharp.SystemTextJson" Version="1.4.36" />
     <PackageVersion Include="StreamJsonRpc" Version="2.25.29" />
-    <PackageVersion Include="Fable.Compiler" Version="5.14.1" />
+    <PackageVersion Include="Fable.Compiler" Version="5.15.0" />
     <PackageVersion Include="Suave" Version="2.6.2" />
     <PackageVersion Include="protobuf-net" Version="3.2.30" />
     <!-- lock transitive dependencies -->

ROADMAP.md

@@ -4,14 +4,12 @@ Nothing here is done. Items are deleted as they land, so what remains is open wo
 
 Item 1 is blocked upstream and can only be tracked and item 2 is on hold. Item 3 is a project, items 4 and 5 are smaller ones, item 6 records a rejected decision and item 7 is loose ends.
 
-References into `~/Projects/Fable` are against Fable 5.14, the version in the workspace catalog.
+References into `~/Projects/Fable` are against Fable 5.15, the version in the workspace catalog.
 
 ## 1. Blocked on Fable
 
-Neither of these can be fixed in this repo. Both need an upstream change first.
+This cannot be fixed in this repo. It needs an upstream change first.
 
-- **Fable's own errors never reach the plugin.** `CodeServices.compileMultipleFilesToJavaScript` fills `CompileResult.Diagnostics` from FCS's type-check results only, and discards the `CompilerImpl` holding `com.Logs` (`~/Projects/Fable/src/Fable.Compiler/Library.fs:223` upcasts it to the `Compiler` interface, where `Logs` does not exist). A file that type-checks but that Fable cannot translate therefore compiles to `return null` with no diagnostic at all: `vite build` prints nothing, exits 0, and the app breaks at runtime. Reproduced in `sample-project` with `Async.RunSynchronously`, and filed with a proposed direction as [fable-compiler/Fable#4922](https://github.com/fable-compiler/Fable/issues/4922).
-  There is a local half waiting on it: `FilesCompiledResult.Success` carries no diagnostics, so `tryCompileProject` has nowhere to put them and `failBuildOnErrors` would never see them.
 - **Real F# source maps.** `FileWriter.AddSourceMapping` in `src/Fable.Compiler/Library.fs:84-90` is a no-op with the `SourceMapSharp` generator commented out, so `CliArgs.SourceMaps` does nothing. The plugin returns `{ mappings: '' }`, which is honest about having no mapping, but a real F#-to-JS one needs the Fable change first. Not filed.
 
 ## 2. A Vite DevTools panel (on hold)

bun.lock

@@ -57,7 +57,7 @@ sequenceDiagram
     Plugin->>Daemon: fable/project-changed
     Daemon-->>Plugin: source files, diagnostics, MSBuild inputs
     Plugin->>Daemon: fable/initial-compile
-    Daemon-->>Plugin: JavaScript per F# file
+    Daemon-->>Plugin: JavaScript per F# file, and what Fable could not translate
     Vite->>Plugin: load (per .fs request)
 </div>
 
@@ -80,6 +80,18 @@ and type-checks the project. `fable/initial-compile` then transpiles every sourc
 inside the daemon on [Fable.Compiler](https://github.com/fable-compiler/Fable), the same code
 `dotnet fable` uses.
 
+Both steps report problems, and they are not the same problems. The type-check reports what the F#
+compiler found, `FS0025` and the like: code that does not compile. The compile reports what Fable
+found, which is code that compiles as F# but that Fable cannot turn into JavaScript, such as
+`Async.RunSynchronously`. Those carry no error number, so the plugin names them by their tag:
+
+```text
+  9:42:26 PM [vite] [fable] ERROR FABLE: Microsoft.FSharp.Control.FSharpAsync.RunSynchronously (static) is not supported by Fable Math.fs (6,26) (6,48)
+```
+
+Either kind fails `vite build`. In dev the server stays up and the error goes to the browser
+overlay, so the next edit can fix it.
+
 The daemon also reports which MSBuild files the project depends on. The plugin watches those, so a
 change to an `fsproj` or a `Directory.Build.props` triggers a full re-crack rather than an
 incremental compile.

docs/how.md

@@ -7,7 +7,7 @@
       "sample-project"
     ],
     "catalog": {
-      "@fable-org/fable-library-js": "2.5.1",
+      "@fable-org/fable-library-js": "2.6.0",
       "vite": "^8.2.2",
       "vite-plugin-inspect": "^12.0.2"
     }

package.json

@@ -439,6 +439,25 @@ module WireTests =
                 }
             Severity = "Warning"
             FileName = "/project/Math.fs"
+            Tag = "FSHARP"
+        }
+
+    /// What Fable reports about a file that type-checks but that it cannot translate. It carries no
+    /// error number, which is why `ErrorNumberText` is empty rather than absent.
+    let private fableDiagnostic : Diagnostic =
+        {
+            ErrorNumberText = ""
+            Message = "Microsoft.FSharp.Control.FSharpAsync.RunSynchronously (static) is not supported by Fable"
+            Range =
+                {
+                    StartLine = 7
+                    StartColumn = 12
+                    EndLine = 7
+                    EndColumn = 41
+                }
+            Severity = "Error"
+            FileName = "/project/Math.fs"
+            Tag = "FABLE"
         }
 
     [<Test>]
@@ -458,7 +477,10 @@ module WireTests =
     [<Test>]
     let ``fable/initial-compile matches its fixture`` () =
         let response =
-            FilesCompiledResult.Success (Map.ofList [ "/project/Math.fs", "export const sum = 1;" ])
+            FilesCompiledResult.Success (
+                Map.ofList [ "/project/Math.fs", "export const sum = 1;" ],
+                [| fableDiagnostic |]
+            )
 
         Assert.That (
             normalize (serialize response),
@@ -468,7 +490,10 @@ module WireTests =
     [<Test>]
     let ``fable/compile matches its fixture`` () =
         let response =
-            FileChangedResult.Success (Map.ofList [ "/project/Math.fs", "export const sum = 2;" ], [| diagnostic |])
+            FileChangedResult.Success (
+                Map.ofList [ "/project/Math.fs", "export const sum = 2;" ],
+                [| diagnostic ; fableDiagnostic |]
+            )
 
         Assert.That (normalize (serialize response), Is.EqualTo (normalize (File.ReadAllText (fixture "compile.json"))))
 
@@ -529,6 +554,7 @@ module DebugServerTests =
                                 EndLine = 3
                                 EndColumn = 9
                             }
+                        Tag = "FSHARP"
                         Severity = "Warning"
                         FileName = mathFs
                     }
@@ -651,7 +677,33 @@ module DebugServerTests =
 
             Assert.That (files.RootElement.GetProperty("files").[0].GetProperty("compiled").GetBoolean(), Is.False)
 
-            Debug.publishInitialCompile (Map.ofList [ mathFs, "export const sum = 1;" ]) Set.empty
+            // A file that type-checks but that Fable cannot translate reports nothing to the
+            // type-check, so the compile is the only place its error can come from.
+            let fableError : Diagnostic =
+                {
+                    ErrorNumberText = ""
+                    Message = "Microsoft.FSharp.Control.FSharpAsync.RunSynchronously (static) is not supported by Fable"
+                    Range =
+                        {
+                            StartLine = 7
+                            StartColumn = 12
+                            EndLine = 7
+                            EndColumn = 41
+                        }
+                    Severity = "Error"
+                    FileName = mathFs
+                    Tag = "FABLE"
+                }
+
+            Debug.publishInitialCompile (Map.ofList [ mathFs, "export const sum = 1;" ]) Set.empty [| fableError |]
+
+            use! compileErrors = getJson client $"{baseUrl}/api/diagnostics?severity=error"
+            Assert.That (compileErrors.RootElement.GetProperty("count").GetInt32(), Is.EqualTo 1)
+
+            Assert.That (
+                compileErrors.RootElement.GetProperty("diagnostics").[0].GetProperty("source").GetString(),
+                Is.EqualTo "compile"
+            )
 
             use! compiled = getJson client $"{baseUrl}/api/files?path=Math.fs"
 

packages/vite-plugin-fable/Fable.Daemon.Tests/DebugTests.fs

@@ -212,15 +212,20 @@ let publishProject (project : ProjectState) : unit =
         }
     )
 
-let publishInitialCompile (compiled : Map<FullPath, JavaScript>) (fromCache : Set<FullPath>) : unit =
+let publishInitialCompile
+    (compiled : Map<FullPath, JavaScript>)
+    (fromCache : Set<FullPath>)
+    (diagnostics : Diagnostic array)
+    : unit
+    =
     advance (fun s ->
         { s with
             Compile =
                 Some
                     {
                         CompiledFiles = compiled
                         FromCache = fromCache
-                        Diagnostics = Array.empty
+                        Diagnostics = diagnostics
                         LastRequested = Array.empty
                         LastCompiledAt = DateTime.Now
                     }

packages/vite-plugin-fable/Fable.Daemon/Debug.fs

@@ -51,8 +51,10 @@ val isEnabled : unit -> bool
 /// decides which files the project even has.
 val publishProject : project : ProjectState -> unit
 
-/// Record what a full project compile produced.
-val publishInitialCompile : compiled : Map<FullPath, JavaScript> -> fromCache : Set<FullPath> -> unit
+/// Record what a full project compile produced. The diagnostics are Fable's own; the F# ones
+/// belong to the crack that came before and are reported there.
+val publishInitialCompile :
+    compiled : Map<FullPath, JavaScript> -> fromCache : Set<FullPath> -> diagnostics : Diagnostic array -> unit
 
 /// Record what compiling a set of changed files produced, merged over what was compiled before,
 /// the way the plugin merges it into its own map.