fix(typescript): rebase sourcemap sources paths when outDir differs from source directory

TypeScript emits sourcemaps with `sources` paths relative to the output map
file location (inside `outDir`). `findTypescriptOutput` returned this sourcemap
verbatim from the `load` hook, but Rollup's `getCollapsedSourcemap` resolves
these paths relative to `path.dirname(id)` — the original source file's
directory. When these two directories differ (common in monorepos), the resolved
absolute paths are wrong, producing broken source references in the final bundle
sourcemap.

Rebase each `sources` entry in `findTypescriptOutput` by resolving it from the
map file's directory and re-relativizing it against the source file's directory.

Fixes #1966

Author: skrtheboss

packages/typescript/src/outputFile.ts

@@ -4,7 +4,7 @@ import { promises as fs } from 'fs';
 
 import type typescript from 'typescript';
 
-import type { OutputOptions, PluginContext, SourceDescription } from 'rollup';
+import type { ExistingRawSourceMap, OutputOptions, PluginContext, SourceDescription } from 'rollup';
 import type { ParsedCommandLine } from 'typescript';
 
 import type TSCache from './tscache';
@@ -65,10 +65,17 @@ export function getEmittedFile(
 }
 
 /**
- * Finds the corresponding emitted Javascript files for a given Typescript file.
- * @param id Path to the Typescript file.
- * @param emittedFiles Map of file names to source code,
- * containing files emitted by the Typescript compiler.
+ * Finds the corresponding emitted JavaScript files for a given TypeScript file.
+ *
+ * Returns the transpiled code, an optional sourcemap (with rebased source paths),
+ * and a list of declaration file paths.
+ *
+ * @param ts The TypeScript module instance.
+ * @param parsedOptions The parsed TypeScript compiler options (tsconfig).
+ * @param id Absolute path to the original TypeScript source file.
+ * @param emittedFiles Map of output file paths to their content, populated by the TypeScript compiler during emission.
+ * @param tsCache A cache of previously emitted files for incremental builds.
+ * @returns An object containing the transpiled code, sourcemap with corrected paths, and declaration file paths.
  */
 export default function findTypescriptOutput(
   ts: typeof typescript,
@@ -86,9 +93,68 @@ export default function findTypescriptOutput(
   const codeFile = emittedFileNames.find(isCodeOutputFile);
   const mapFile = emittedFileNames.find(isMapOutputFile);
 
+  let map: ExistingRawSourceMap | string | undefined = getEmittedFile(
+    mapFile,
+    emittedFiles,
+    tsCache
+  );
+
+  // Rebase sourcemap `sources` paths from the map file's directory to the
+  // original source file's directory.
+  //
+  // Why this is needed:
+  //   TypeScript emits sourcemaps with `sources` relative to the **output**
+  //   map file location (inside `outDir`), optionally prefixed by `sourceRoot`.
+  //   For example, compiling `my-project/src/test.ts` with
+  //   `outDir: "../dist/project"` produces `dist/project/src/test.js.map`
+  //   containing:
+  //
+  //     { "sources": ["../../../my-project/src/test.ts"], "sourceRoot": "." }
+  //
+  //   This resolves correctly from the map file's directory:
+  //     resolve("dist/project/src", ".", "../../../my-project/src/test.ts")
+  //       → "my-project/src/test.ts"  ✅
+  //
+  //   However, Rollup's `getCollapsedSourcemap` resolves these paths relative
+  //   to `dirname(id)` — the **original source file's directory** — not the
+  //   output map file's directory. When `outDir` differs from the source tree
+  //   (common in monorepos), this mismatch produces incorrect absolute paths
+  //   that escape the project root.
+  //
+  // The fix resolves each source entry to an absolute path via the map file's
+  // directory (honoring `sourceRoot`), then re-relativizes it against the
+  // source file's directory so Rollup can consume it correctly.
+  if (map && mapFile) {
+    try {
+      const parsedMap: ExistingRawSourceMap = JSON.parse(map);
+
+      if (parsedMap.sources) {
+        const mapDir = path.dirname(mapFile);
+        const sourceDir = path.dirname(id);
+        const sourceRoot = parsedMap.sourceRoot || '.';
+
+        parsedMap.sources = parsedMap.sources.map((source) => {
+          // Resolve to absolute using the map file's directory + sourceRoot
+          const absolute = path.resolve(mapDir, sourceRoot, source);
+          // Re-relativize against the original source file's directory
+          return path.relative(sourceDir, absolute);
+        });
+
+        // sourceRoot has been folded into the rebased paths; remove it so
+        // Rollup does not double-apply it during sourcemap collapse.
+        delete parsedMap.sourceRoot;
+
+        map = parsedMap;
+      }
+    } catch (e) {
+      // If the map string is not valid JSON (shouldn't happen for TypeScript
+      // output), fall through and return the original map string unchanged.
+    }
+  }
+
   return {
     code: getEmittedFile(codeFile, emittedFiles, tsCache),
-    map: getEmittedFile(mapFile, emittedFiles, tsCache),
+    map,
     declarations: emittedFileNames.filter((name) => name !== codeFile && name !== mapFile)
   };
 }

packages/typescript/test/fixtures/outdir-outside-source/src/main.ts

@@ -0,0 +1,3 @@
+const answer = 42;
+
+export default answer;

packages/typescript/test/fixtures/outdir-outside-source/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "lib": ["es2020"],
+    "outDir": "../dist-outside",
+    "target": "es2020",
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "noEmitOnError": true,
+    "noErrorTruncation": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "strict": true
+  },
+  "include": ["src/**/*"]
+}
+

packages/typescript/test/fixtures/outdir-with-sourceroot/src/greet.ts

@@ -0,0 +1,5 @@
+export const greeting = 'Hello, World!';
+
+export function greet() {
+  return greeting;
+}

packages/typescript/test/fixtures/outdir-with-sourceroot/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "lib": ["es2020"],
+    "outDir": "../output",
+    "target": "es2020",
+    "sourceMap": true,
+    "mapRoot": "./maps",
+    "skipLibCheck": true,
+    "noEmitOnError": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "strict": true
+  },
+  "include": ["src/**/*"]
+}
+

packages/typescript/test/test.js

@@ -710,6 +710,95 @@ test.serial('should not emit sourceContent that references a non-existent file',
   t.false(sourcemap.sourcesContent.includes('//# sourceMappingURL=main.js.map'));
 });
 
+test.serial(
+  'should correctly resolve sourcemap sources when outDir is outside source directory',
+  async (t) => {
+    // This test verifies the fix for issue #1966
+    // When TypeScript's outDir places emitted files in a different directory tree than
+    // the source files (e.g., outDir: "../dist"), TypeScript emits sourcemaps with
+    // sources relative to the output map file location. Rollup's getCollapsedSourcemap
+    // resolves those paths relative to the original source file's directory instead.
+    // The fix rebases the sourcemap sources to be relative to the source file directory.
+    const bundle = await rollup({
+      input: 'fixtures/outdir-outside-source/src/main.ts',
+      output: {
+        sourcemap: true
+      },
+      plugins: [
+        typescript({
+          tsconfig: 'fixtures/outdir-outside-source/tsconfig.json'
+        })
+      ],
+      onwarn
+    });
+    const output = await getCode(bundle, { format: 'es', sourcemap: true }, true);
+    const sourcemap = output[0].map;
+
+    // Debug: log the sourcemap structure
+    // console.log('sourcemap:', JSON.stringify(sourcemap, null, 2));
+
+    // Verify sourcemap has the correct sources
+    t.is(sourcemap.sources.length, 1, 'Should have exactly one source');
+
+    // The source path should be relative to the source file's directory
+    // and should NOT point multiple levels above the project root
+    const [sourcePath] = sourcemap.sources;
+
+    // Before the fix, this would be something like "../../../outdir-outside-source/src/main.ts"
+    // After the fix, it should be just "main.ts" (relative to src/ directory)
+    t.false(
+      sourcePath.startsWith('../../../'),
+      `Source path should not go above project root: ${sourcePath}`
+    );
+
+    // The source should correctly point to main.ts
+    t.true(
+      sourcePath === 'main.ts' || sourcePath.endsWith('main.ts'),
+      `Source path should reference main.ts: ${sourcePath}`
+    );
+
+    // Verify sourceRoot has been cleared (no longer needed after path rebasing)
+    t.is(sourcemap.sourceRoot, undefined, 'sourceRoot should be cleared after path rebasing');
+  }
+);
+
+test.serial('should correctly resolve sourcemap sources with mapRoot option', async (t) => {
+  // This test verifies that the fix works correctly even when mapRoot is set
+  const bundle = await rollup({
+    input: 'fixtures/outdir-with-sourceroot/src/greet.ts',
+    output: {
+      sourcemap: true
+    },
+    plugins: [
+      typescript({
+        tsconfig: 'fixtures/outdir-with-sourceroot/tsconfig.json'
+      })
+    ],
+    onwarn
+  });
+  const output = await getCode(bundle, { format: 'es', sourcemap: true }, true);
+  const sourcemap = output[0].map;
+
+  // Verify sourcemap has the correct sources
+  t.is(sourcemap.sources.length, 1, 'Should have exactly one source');
+
+  const [sourcePath] = sourcemap.sources;
+
+  // The source path should correctly reference greet.ts without going above project root
+  t.false(
+    sourcePath.startsWith('../../../'),
+    `Source path should not go above project root: ${sourcePath}`
+  );
+
+  t.true(
+    sourcePath === 'greet.ts' || sourcePath.endsWith('greet.ts'),
+    `Source path should reference greet.ts: ${sourcePath}`
+  );
+
+  // Verify sourceRoot has been cleared
+  t.is(sourcemap.sourceRoot, undefined, 'sourceRoot should be cleared after path rebasing');
+});
+
 test.serial('should not fail if source maps are off', async (t) => {
   await t.notThrowsAsync(
     rollup({