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/my-project-1/src/index.ts

@@ -0,0 +1,2 @@
+export { foo } from './test';
+export { testNested } from './nested/test-nested';

packages/typescript/test/fixtures/outdir-outside-source/my-project-1/src/nested/test-nested.ts

@@ -0,0 +1 @@
+export const testNested = 'nested';

packages/typescript/test/fixtures/outdir-outside-source/my-project-1/src/test.ts

@@ -0,0 +1 @@
+export const foo = 'bar';

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

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "moduleResolution": "node",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "skipDefaultLibCheck": true,
+    "strict": true,
+    "baseUrl": ".",
+    "module": "esnext",
+    "outDir": "../dist/project-1",
+    "types": [],
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "declaration": true,
+    "inlineSources": true,
+    "rootDir": "./",
+    "allowJs": false,
+    "composite": false,
+    "declarationDir": "../dist/project-1",
+    "noEmitOnError": true,
+    "sourceMap": true
+  },
+  "include": ["**/*.ts"]
+}

packages/typescript/test/test.js

@@ -710,6 +710,47 @@ test.serial('should not emit sourceContent that references a non-existent file',
   t.false(sourcemap.sourcesContent.includes('//# sourceMappingURL=main.js.map'));
 });
 
+test.only('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/my-project-1/src/index.ts',
+    output: {
+      dir: './fixtures/outdir-outside-source/dist/project-1',
+      format: 'es',
+      entryFileNames: '[name].js',
+      chunkFileNames: '[name]-[hash].js',
+      sourcemap: true
+    },
+    plugins: [
+      typescript({
+        tsconfig: './fixtures/outdir-outside-source/my-project-1/tsconfig.json'
+      })
+    ],
+    onwarn
+  });
+  const [indexJsOutput] = await getCode(bundle, { format: 'es', sourcemap: true }, true);
+
+  const sourcemap = indexJsOutput.map;
+
+  // Verify sourcemap has the correct sources
+  t.is(sourcemap.sources.length, 2, 'Should have exactly 2 sources');
+
+  // The source path should be relative to the source file's directory
+  // and should NOT point multiple levels above the project root
+  const [testSourcePath, nestedSourcePath] = sourcemap.sources;
+
+  t.is(testSourcePath, 'fixtures/outdir-outside-source/my-project-1/src/test.ts');
+  t.is(nestedSourcePath, 'fixtures/outdir-outside-source/my-project-1/src/nested/test-nested.ts');
+
+  // 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 not fail if source maps are off', async (t) => {
   await t.notThrowsAsync(
     rollup({