Fix the transform sourcemap signal and path normalisation

Two hook-contract bugs, plus the CI and script gaps found alongside them.

The transform hook returned `map: null`, which in the Rollup and Vite
contract means "I did not move code, keep the previous mapping". That is
false here — the hook replaces F# with JavaScript — and downstream stages
took it at face value, generating a map whose `sources` named a `.fs`
file while its `sourcesContent` held the compiled JavaScript. Devtools
duly showed an F# filename containing JavaScript, which is worse than no
map at all. `{ mappings: "" }` is how Vite's own plugins say a mapping was
lost. Real F#-to-JS source maps stay blocked on Fable, where
FileWriter.AddSourceMapping is a no-op.

compileProject built its compiled-output map by iterating the source file
list and indexing the daemon's response with an already-normalised path,
while fsharpFileChanged normalised the daemon's keys on the way in. The
two sets are not the same — signature files are reported as sources and
never compiled — and the mismatched lookup would yield undefined for
every entry if the daemon ever reported a non-POSIX path. Both paths now
key off what the daemon returned.

CI ran the plugin tests but never `dotnet test`, so the daemon suite,
including the signature-file test added with the hotUpdate work, was not
running there at all. Added as its own step in both workflows.

Also adds a top-level `ci` script that runs lint, formatting and tests in
parallel, for use before committing.

The roadmap's claim that `.fsx` files are matched but never compiled was
wrong and is dropped rather than acted on: the daemon filters only `.fsi`,
so a script listed in the fsproj compiles like any other file, and one
that is not listed fails exactly as a stray `.fs` would.

Author: nojaf

.github/workflows/main.yml

@@ -42,6 +42,9 @@ jobs:
       - name: Test plugin
         run: bun run test:plugin
 
+      - name: Test daemon
+        run: bun run test:daemon
+
       - name: Build daemon
         run: bun run --cwd packages/vite-plugin-fable postinstall
 

.github/workflows/pr.yml

@@ -35,6 +35,9 @@ jobs:
       - name: Test plugin
         run: bun run test:plugin
 
+      - name: Test daemon
+        run: bun run test:daemon
+
       - name: Build daemon
         run: bun run --cwd packages/vite-plugin-fable postinstall
 

CHANGELOG.md

@@ -27,6 +27,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- The `transform` hook reports `map: { mappings: "" }` instead of `map: null`. `null` claims the previous source mapping still applies, which made later stages emit a map labelling the compiled JavaScript as the contents of a `.fs` file — devtools showed an F# filename containing JavaScript. Real F#-to-JS source maps remain blocked on Fable.
+- Compiled output is now keyed off what the daemon returned rather than looked up per source file. The two sets differ (signature files are never compiled), and indexing the daemon's map with an already-normalised path would have yielded `undefined` for every entry had the daemon ever reported a non-POSIX path.
+- CI runs the daemon test suite; previously only the plugin tests ran.
 - TypeScript `strict` is on. That surfaced a real bug: `configResolved` derived the project directory from `resolvedConfig.configFile`, which is optional, so a project without a Vite config file (or one created programmatically) reached `fs.readdir(undefined)`. It now uses `resolvedConfig.root`, which is always resolved and is also the correct directory when `root` differs from the config file's location. A missing `.fsproj` is now an error rather than a `null` handed to the daemon.
 - oxlint warnings fail the lint instead of being reported and ignored.
 - `sample-project` runs its scripts on the Bun runtime through its own `bunfig.toml` rather than `bunx --bun` in each script, so the scripts are plain `vite`, `vite build` and `vite preview`. Bun only reads the `bunfig.toml` in the directory a command starts from, so the one at the repo root does not cover it.

ROADMAP.md

@@ -8,14 +8,11 @@ Order is a rough suggestion: 1-3 are contract fixes and design questions, 4-7 ar
 
 ## 1. Hook-contract fixes
 
-- **`map: null` is the wrong signal** (`index.js:454`). In the Rollup/Vite contract `null` means "I did not move code, keep the previous map"; the transform replaces F# with JS. The correct value is `{ mappings: '' }` — what Vite's own plugins use for this case (`plugins/css.ts:583`, `plugins/asset.ts:247`).
-  Note: real F# source maps are **blocked upstream**. `FileWriter.AddSourceMapping` in `~/Projects/Fable/src/Fable.Compiler/Library.fs:84-90` is a no-op with the `SourceMapSharp` generator commented out; `CliArgs.SourceMaps` exists but does nothing. Needs a Fable PR first.
-  Worth knowing what happens meanwhile: because the plugin returns `map: null`, later stages generate their own map, and the served module ends with a `sourceMappingURL` whose `sources` says `Greeting.fs` while its `sourcesContent` is the compiled **JavaScript**. Devtools therefore shows a file named `.fs` containing JavaScript, which is more misleading than having no map at all. `{ mappings: '' }` fixes that on its own.
+- **Real F# source maps are blocked upstream.** `FileWriter.AddSourceMapping` in `~/Projects/Fable/src/Fable.Compiler/Library.fs:84-90` is a no-op with the `SourceMapSharp` generator commented out; `CliArgs.SourceMaps` exists but does nothing. Needs a Fable PR first.
+  The plugin now returns `{ mappings: '' }`, which stops later stages from producing a map that labels the compiled JavaScript as the contents of a `.fs` file, but a real F#-to-JS mapping needs the Fable change first.
 - **No `load` hook.** Vite reads the whole `.fs` file off disk purely so `transform` can discard it. A `load` for ids in `compilableFiles` skips the I/O and states the intent. Return `moduleType: 'js'` too — `vite:oxc` does (`plugins/oxc.ts:330`) — otherwise rolldown infers the type from the `.fs` extension.
 - **`configuration` is derived from `env.MODE`** (`index.js:364`), so `vite build --mode staging` compiles Debug F#. `state.isBuild` is already captured from `command === "build"` (`index.js:365`) but unused for this. Make it an explicit plugin option defaulting to `isBuild ? Release : Debug`, and document it.
 - **`transform.filter` ignores query strings** (`index.js:435`). Vite's convention is `makeIdFiltersToMatchWithQuery` from `@rolldown/pluginutils`, used by Vite itself (`plugins/asset.ts:205`) and by plugin-react. Low impact for the main path — Vite still appends `?import` to bare module URLs (`src/node/utils.ts:308`) but strips it in `transformRequest.ts:497` before the id reaches the plugin container, so `transform` sees a clean absolute path. Explicit queries like `./Component.fs?raw` still fall straight through, and the `compilableFiles.has(id)` lookups should go through `cleanUrl`.
-- **Path normalisation is asymmetric** (`index.js:234-238` vs `282-285`). `fsharpFileChanged` normalises the daemon's keys before storing them; `compileProject` indexes `compiledFSharpFiles` with an already-normalised name instead. If the daemon ever returns a backslash path, every value in `compilableFiles` becomes `undefined`. Normalise on the way in, in one place.
-- **`.fsx` is matched but never compiled** (`index.js:15`). Script files are never in `compilableFiles`, so every `.fsx` import warns and then fails to parse. Either drop `.fsx` from the regex or handle it.
 
 ## 2. The JSX handoff to plugin-react works by accident
 

package.json

@@ -18,6 +18,7 @@
     "build": "bun run build:daemon && bun run build:plugin",
     "build:daemon": "bun run --cwd packages/vite-plugin-fable build:daemon",
     "build:plugin": "bun run --cwd packages/vite-plugin-fable build",
+    "ci": "bun run --no-exit-on-error --parallel lint fmt test",
     "fmt": "oxfmt && dotnet fantomas .",
     "fmt:check": "oxfmt --check && dotnet fantomas check .",
     "lint": "oxlint --deny-warnings && bun run lint:types",

packages/vite-plugin-fable/src/index.ts

@@ -185,11 +185,13 @@ export function createFablePlugin(
     }
     const compiledFSharpFiles: Record<string, string> = await requireDaemon().initialCompile();
     logInfo("compileProject", `Full compile completed of ${state.fsproj}`);
-    state.sourceFiles.forEach((file: string) => {
-      addWatchFile(file);
-      const normalizedFileName: string = normalizePath(file);
-      state.compilableFiles.set(normalizedFileName, compiledFSharpFiles[file]);
-    });
+    state.sourceFiles.forEach((file: string): void => addWatchFile(file));
+    // Key off what the daemon returned rather than looking each source file up in it: the two sets
+    // differ (signature files are never compiled), and indexing a raw-keyed map with an
+    // already-normalised path silently yields `undefined` for every entry.
+    for (const [file, javaScript] of Object.entries(compiledFSharpFiles)) {
+      state.compilableFiles.set(normalizePath(file), javaScript);
+    }
   }
 
   /**
@@ -476,8 +478,10 @@ export function createFablePlugin(
             code = oxcResult.code;
           }
           return {
-            code: code,
-            map: null,
+            code,
+            // Not `null`, which would claim the previous mapping still holds: this replaced F#
+            // with JavaScript. `{ mappings: "" }` is how Vite's own plugins say a map was lost.
+            map: { mappings: "" as const },
           };
         } else if (state.isBuild) {
           // Returning nothing would let Vite parse the F# source as JavaScript, and the user would

packages/vite-plugin-fable/tests/index.test.ts

@@ -56,7 +56,7 @@ interface EnvironmentStub {
   sent: unknown[];
 }
 
-type TransformOutput = { code: string; map: null } | undefined;
+type TransformOutput = { code: string; map: { mappings: "" } } | undefined;
 
 interface Harness {
   plugin: Plugin;
@@ -286,6 +286,33 @@ describe("transform", () => {
     expect(result?.code).toBe("export const sum = 1;");
   });
 
+  test("signals that the source mapping was lost rather than preserved", async () => {
+    const h: Harness = harness(
+      {},
+      { sourceFiles: [mathFs], compiled: { [mathFs]: "export const sum = 1;" } },
+    );
+    await h.start();
+    // `null` would tell Vite the previous mapping still applies, and it would then build a map
+    // claiming the JavaScript is the contents of a `.fs` file.
+    expect((await h.transform(mathFs))?.map).toEqual({ mappings: "" });
+  });
+
+  test("keys compiled output off what the daemon returned, not the source list", async () => {
+    // The daemon reports signature files as sources but never compiles them.
+    const componentFs = `${sampleProject}/Component.fs`;
+    const componentFsi = `${sampleProject}/Component.fsi`;
+    const h: Harness = harness(
+      {},
+      {
+        sourceFiles: [componentFs, componentFsi],
+        compiled: { [componentFs]: "export const c = 1;" },
+      },
+    );
+    await h.start();
+    expect((await h.transform(componentFs))?.code).toBe("export const c = 1;");
+    expect(await h.transform(componentFsi)).toBeUndefined();
+  });
+
   test("returns nothing for an F# file the daemon never compiled", async () => {
     const h: Harness = harness({}, { sourceFiles: [] });
     await h.start();