diff --git a/src/ForkTsCheckerWebpackPluginState.ts b/src/ForkTsCheckerWebpackPluginState.ts
index c2e401ac..2661f7a0 100644
--- a/src/ForkTsCheckerWebpackPluginState.ts
+++ b/src/ForkTsCheckerWebpackPluginState.ts
@@ -1,12 +1,12 @@
 import { Tap } from 'tapable';
-import { Dependencies, Report } from './reporter';
+import { FilesMatch, Report } from './reporter';
 import { Issue } from './issue';
 
 interface ForkTsCheckerWebpackPluginState {
   reportPromise: Promise<Report | undefined>;
   issuesPromise: Promise<Issue[] | undefined>;
-  dependenciesPromise: Promise<Dependencies | undefined>;
-  lastDependencies: Dependencies | undefined;
+  dependenciesPromise: Promise<FilesMatch | undefined>;
+  lastDependencies: FilesMatch | undefined;
   watching: boolean;
   initialized: boolean;
   webpackDevServerDoneTap: Tap | undefined;
diff --git a/src/hooks/tapStartToConnectAndRunReporter.ts b/src/hooks/tapStartToConnectAndRunReporter.ts
index 0929ac31..19b4be91 100644
--- a/src/hooks/tapStartToConnectAndRunReporter.ts
+++ b/src/hooks/tapStartToConnectAndRunReporter.ts
@@ -2,7 +2,7 @@ import webpack from 'webpack';
 import { ForkTsCheckerWebpackPluginConfiguration } from '../ForkTsCheckerWebpackPluginConfiguration';
 import { ForkTsCheckerWebpackPluginState } from '../ForkTsCheckerWebpackPluginState';
 import { getForkTsCheckerWebpackPluginHooks } from './pluginHooks';
-import { Dependencies, FilesChange, getFilesChange, ReporterRpcClient } from '../reporter';
+import { FilesMatch, FilesChange, getFilesChange, ReporterRpcClient } from '../reporter';
 import { OperationCanceledError } from '../error/OperationCanceledError';
 import { tapDoneToAsyncGetIssues } from './tapDoneToAsyncGetIssues';
 import { tapAfterCompileToGetIssues } from './tapAfterCompileToGetIssues';
@@ -63,7 +63,7 @@ function tapStartToConnectAndRunReporter(
       configuration.logger.infrastructure.info('Calling reporter service for single check.');
     }
 
-    let resolveDependencies: (dependencies: Dependencies | undefined) => void;
+    let resolveDependencies: (dependencies: FilesMatch | undefined) => void;
     let rejectedDependencies: (error: Error) => void;
     let resolveIssues: (issues: Issue[] | undefined) => void;
     let rejectIssues: (error: Error) => void;
diff --git a/src/reporter/Dependencies.ts b/src/reporter/FilesMatch.ts
similarity index 56%
rename from src/reporter/Dependencies.ts
rename to src/reporter/FilesMatch.ts
index a18b845f..d5aeb665 100644
--- a/src/reporter/Dependencies.ts
+++ b/src/reporter/FilesMatch.ts
@@ -1,7 +1,7 @@
-interface Dependencies {
+interface FilesMatch {
   files: string[];
   dirs: string[];
   extensions: string[];
 }
 
-export { Dependencies };
+export { FilesMatch };
diff --git a/src/reporter/Report.ts b/src/reporter/Report.ts
index d1dcaa8b..166d2361 100644
--- a/src/reporter/Report.ts
+++ b/src/reporter/Report.ts
@@ -1,8 +1,8 @@
-import { Dependencies } from './Dependencies';
+import { FilesMatch } from './FilesMatch';
 import { Issue } from '../issue';
 
 interface Report {
-  getDependencies(): Promise<Dependencies>;
+  getDependencies(): Promise<FilesMatch>;
   getIssues(): Promise<Issue[]>;
   close(): Promise<void>;
 }
diff --git a/src/reporter/index.ts b/src/reporter/index.ts
index adf1fbd5..e79c585d 100644
--- a/src/reporter/index.ts
+++ b/src/reporter/index.ts
@@ -3,7 +3,7 @@ export * from './Reporter';
 export * from './AggregatedReporter';
 
 export * from './FilesChange';
-export * from './Dependencies';
+export * from './FilesMatch';
 
 export * from './reporter-rpc/ReporterRpcClient';
 export * from './reporter-rpc/ReporterRpcService';
diff --git a/src/reporter/reporter-rpc/ReporterRpcProcedure.ts b/src/reporter/reporter-rpc/ReporterRpcProcedure.ts
index 7c17c1ca..271d414c 100644
--- a/src/reporter/reporter-rpc/ReporterRpcProcedure.ts
+++ b/src/reporter/reporter-rpc/ReporterRpcProcedure.ts
@@ -1,11 +1,11 @@
 import { RpcProcedure } from '../../rpc';
 import { FilesChange } from '../FilesChange';
 import { Issue } from '../../issue';
-import { Dependencies } from '../Dependencies';
+import { FilesMatch } from '../FilesMatch';
 
 const configure: RpcProcedure<object, void> = 'configure';
 const getReport: RpcProcedure<FilesChange, void> = 'getReport';
-const getDependencies: RpcProcedure<void, Dependencies> = 'getDependencies';
+const getDependencies: RpcProcedure<void, FilesMatch> = 'getDependencies';
 const getIssues: RpcProcedure<void, Issue[]> = 'getIssues';
 const closeReport: RpcProcedure<void, void> = 'closeReport';
 
diff --git a/src/typescript-reporter/extension/TypeScriptEmbeddedExtension.ts b/src/typescript-reporter/extension/TypeScriptEmbeddedExtension.ts
index 007b66bc..71a1b222 100644
--- a/src/typescript-reporter/extension/TypeScriptEmbeddedExtension.ts
+++ b/src/typescript-reporter/extension/TypeScriptEmbeddedExtension.ts
@@ -2,7 +2,7 @@ import * as ts from 'typescript';
 import { extname } from 'path';
 import { TypeScriptExtension } from './TypeScriptExtension';
 import { Issue } from '../../issue';
-import { Dependencies } from '../../reporter';
+import { FilesMatch } from '../../reporter';
 
 interface TypeScriptEmbeddedSource {
   sourceText: string;
@@ -168,7 +168,7 @@ function createTypeScriptEmbeddedExtension({
         },
       };
     },
-    extendDependencies(dependencies: Dependencies) {
+    extendDependencies(dependencies: FilesMatch) {
       return {
         ...dependencies,
         files: dependencies.files.map((fileName) => {
diff --git a/src/typescript-reporter/extension/TypeScriptExtension.ts b/src/typescript-reporter/extension/TypeScriptExtension.ts
index 071d5d82..9a6d4906 100644
--- a/src/typescript-reporter/extension/TypeScriptExtension.ts
+++ b/src/typescript-reporter/extension/TypeScriptExtension.ts
@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { Issue } from '../../issue';
-import { Dependencies } from '../../reporter';
+import { FilesMatch } from '../../reporter';
 
 interface TypeScriptHostExtension {
   extendWatchSolutionBuilderHost?<
@@ -26,7 +26,7 @@ interface TypeScriptHostExtension {
 
 interface TypeScriptReporterExtension {
   extendIssues?(issues: Issue[]): Issue[];
-  extendDependencies?(dependencies: Dependencies): Dependencies;
+  extendDependencies?(dependencies: FilesMatch): FilesMatch;
 }
 
 interface TypeScriptExtension extends TypeScriptHostExtension, TypeScriptReporterExtension {}
diff --git a/src/typescript-reporter/file-system/MemFileSystem.ts b/src/typescript-reporter/file-system/MemFileSystem.ts
new file mode 100644
index 00000000..890ed271
--- /dev/null
+++ b/src/typescript-reporter/file-system/MemFileSystem.ts
@@ -0,0 +1,99 @@
+import { dirname } from 'path';
+import { fs as mem } from 'memfs';
+import { FileSystem } from './FileSystem';
+// eslint-disable-next-line node/no-unsupported-features/node-builtins
+import { Dirent, Stats } from 'fs';
+
+/**
+ * It's an implementation of FileSystem interface which reads and writes to the in-memory file system.
+ *
+ * @param realFileSystem
+ */
+function createMemFileSystem(realFileSystem: FileSystem): FileSystem {
+  function exists(path: string): boolean {
+    return mem.existsSync(realFileSystem.normalizePath(path));
+  }
+
+  function readStats(path: string): Stats | undefined {
+    return exists(path) ? mem.statSync(realFileSystem.normalizePath(path)) : undefined;
+  }
+
+  function readFile(path: string, encoding?: string): string | undefined {
+    const stats = readStats(path);
+
+    if (stats && stats.isFile()) {
+      return mem
+        .readFileSync(realFileSystem.normalizePath(path), { encoding: encoding as BufferEncoding })
+        .toString();
+    }
+  }
+
+  function readDir(path: string): Dirent[] {
+    const stats = readStats(path);
+
+    if (stats && stats.isDirectory()) {
+      return mem.readdirSync(realFileSystem.normalizePath(path), {
+        withFileTypes: true,
+      }) as Dirent[];
+    }
+
+    return [];
+  }
+
+  function createDir(path: string) {
+    mem.mkdirSync(realFileSystem.normalizePath(path), { recursive: true });
+  }
+
+  function writeFile(path: string, data: string) {
+    if (!exists(dirname(path))) {
+      createDir(dirname(path));
+    }
+
+    mem.writeFileSync(realFileSystem.normalizePath(path), data);
+  }
+
+  function deleteFile(path: string) {
+    if (exists(path)) {
+      mem.unlinkSync(realFileSystem.normalizePath(path));
+    }
+  }
+
+  function updateTimes(path: string, atime: Date, mtime: Date) {
+    if (exists(path)) {
+      mem.utimesSync(realFileSystem.normalizePath(path), atime, mtime);
+    }
+  }
+
+  return {
+    ...realFileSystem,
+    exists(path: string) {
+      return exists(realFileSystem.realPath(path));
+    },
+    readFile(path: string, encoding?: string) {
+      return readFile(realFileSystem.realPath(path), encoding);
+    },
+    readDir(path: string) {
+      return readDir(realFileSystem.realPath(path));
+    },
+    readStats(path: string) {
+      return readStats(realFileSystem.realPath(path));
+    },
+    writeFile(path: string, data: string) {
+      writeFile(realFileSystem.realPath(path), data);
+    },
+    deleteFile(path: string) {
+      deleteFile(realFileSystem.realPath(path));
+    },
+    createDir(path: string) {
+      createDir(realFileSystem.realPath(path));
+    },
+    updateTimes(path: string, atime: Date, mtime: Date) {
+      updateTimes(realFileSystem.realPath(path), atime, mtime);
+    },
+    clearCache() {
+      realFileSystem.clearCache();
+    },
+  };
+}
+
+export { createMemFileSystem };
diff --git a/src/typescript-reporter/file-system/PassiveFileSystem.ts b/src/typescript-reporter/file-system/PassiveFileSystem.ts
index e404f030..75802699 100644
--- a/src/typescript-reporter/file-system/PassiveFileSystem.ts
+++ b/src/typescript-reporter/file-system/PassiveFileSystem.ts
@@ -1,70 +1,37 @@
-import { dirname, normalize } from 'path';
-import { fs as mem } from 'memfs';
 import { FileSystem } from './FileSystem';
-// eslint-disable-next-line node/no-unsupported-features/node-builtins
-import { Dirent, Stats } from 'fs';
 
 /**
  * It's an implementation of FileSystem interface which reads from the real file system, but write to the in-memory file system.
  *
- * @param caseSensitive
+ * @param memFileSystem
  * @param realFileSystem
  */
-function createPassiveFileSystem(caseSensitive = false, realFileSystem: FileSystem): FileSystem {
-  function normalizePath(path: string): string {
-    return caseSensitive ? normalize(path) : normalize(path).toLowerCase();
-  }
-
-  function memExists(path: string): boolean {
-    return mem.existsSync(normalizePath(path));
-  }
-
-  function memReadStats(path: string): Stats | undefined {
-    return memExists(path) ? mem.statSync(normalizePath(path)) : undefined;
-  }
-
-  function memReadFile(path: string, encoding?: string): string | undefined {
-    const stats = memReadStats(path);
-
-    if (stats && stats.isFile()) {
-      return mem
-        .readFileSync(normalizePath(path), { encoding: encoding as BufferEncoding })
-        .toString();
-    }
-  }
-
-  function memReadDir(path: string): Dirent[] {
-    const stats = memReadStats(path);
-
-    if (stats && stats.isDirectory()) {
-      return mem.readdirSync(normalizePath(path), { withFileTypes: true }) as Dirent[];
-    }
-
-    return [];
-  }
-
+function createPassiveFileSystem(
+  memFileSystem: FileSystem,
+  realFileSystem: FileSystem
+): FileSystem {
   function exists(path: string) {
-    return realFileSystem.exists(path) || memExists(path);
+    return realFileSystem.exists(path) || memFileSystem.exists(path);
   }
 
   function readFile(path: string, encoding?: string) {
     const fsStats = realFileSystem.readStats(path);
-    const memStats = memReadStats(path);
+    const memStats = memFileSystem.readStats(path);
 
     if (fsStats && memStats) {
       return fsStats.mtimeMs > memStats.mtimeMs
         ? realFileSystem.readFile(path, encoding)
-        : memReadFile(path, encoding);
+        : memFileSystem.readFile(path, encoding);
     } else if (fsStats) {
       return realFileSystem.readFile(path, encoding);
     } else if (memStats) {
-      return memReadFile(path, encoding);
+      return memFileSystem.readFile(path, encoding);
     }
   }
 
   function readDir(path: string) {
     const fsDirents = realFileSystem.readDir(path);
-    const memDirents = memReadDir(path);
+    const memDirents = memFileSystem.readDir(path);
 
     // merge list of dirents from fs and mem
     return fsDirents
@@ -74,7 +41,7 @@ function createPassiveFileSystem(caseSensitive = false, realFileSystem: FileSyst
 
   function readStats(path: string) {
     const fsStats = realFileSystem.readStats(path);
-    const memStats = memReadStats(path);
+    const memStats = memFileSystem.readStats(path);
 
     if (fsStats && memStats) {
       return fsStats.mtimeMs > memStats.mtimeMs ? fsStats : memStats;
@@ -85,31 +52,8 @@ function createPassiveFileSystem(caseSensitive = false, realFileSystem: FileSyst
     }
   }
 
-  function createDir(path: string) {
-    mem.mkdirSync(normalizePath(path), { recursive: true });
-  }
-
-  function writeFile(path: string, data: string) {
-    if (!memExists(dirname(path))) {
-      createDir(dirname(path));
-    }
-
-    mem.writeFileSync(normalizePath(path), data);
-  }
-
-  function deleteFile(path: string) {
-    if (memExists(path)) {
-      mem.unlinkSync(normalizePath(path));
-    }
-  }
-
-  function updateTimes(path: string, atime: Date, mtime: Date) {
-    if (memExists(path)) {
-      mem.utimesSync(normalizePath(path), atime, mtime);
-    }
-  }
-
   return {
+    ...memFileSystem,
     exists(path: string) {
       return exists(realFileSystem.realPath(path));
     },
@@ -125,21 +69,6 @@ function createPassiveFileSystem(caseSensitive = false, realFileSystem: FileSyst
     realPath(path: string) {
       return realFileSystem.realPath(path);
     },
-    normalizePath(path: string) {
-      return normalizePath(path);
-    },
-    writeFile(path: string, data: string) {
-      writeFile(realFileSystem.realPath(path), data);
-    },
-    deleteFile(path: string) {
-      deleteFile(realFileSystem.realPath(path));
-    },
-    createDir(path: string) {
-      createDir(realFileSystem.realPath(path));
-    },
-    updateTimes(path: string, atime: Date, mtime: Date) {
-      updateTimes(realFileSystem.realPath(path), atime, mtime);
-    },
     clearCache() {
       realFileSystem.clearCache();
     },
diff --git a/src/typescript-reporter/reporter/ControlledTypeScriptSystem.ts b/src/typescript-reporter/reporter/ControlledTypeScriptSystem.ts
index ab0a67ea..2cf7eec7 100644
--- a/src/typescript-reporter/reporter/ControlledTypeScriptSystem.ts
+++ b/src/typescript-reporter/reporter/ControlledTypeScriptSystem.ts
@@ -3,6 +3,8 @@ import { dirname } from 'path';
 import { createPassiveFileSystem } from '../file-system/PassiveFileSystem';
 import forwardSlash from '../../utils/path/forwardSlash';
 import { createRealFileSystem } from '../file-system/RealFileSystem';
+import { createMemFileSystem } from '../file-system/MemFileSystem';
+import { FilesMatch } from '../../reporter';
 
 interface ControlledTypeScriptSystem extends ts.System {
   // control watcher
@@ -34,6 +36,7 @@ interface ControlledTypeScriptSystem extends ts.System {
   clearTimeout(timeoutId: any): void;
   // detect when all tasks scheduled by `setTimeout` finished
   waitForQueued(): Promise<void>;
+  setArtifacts(dependencies: FilesMatch): void;
 }
 
 type FileSystemMode = 'readonly' | 'write-tsbuildinfo' | 'write-references';
@@ -42,6 +45,13 @@ function createControlledTypeScriptSystem(
   typescript: typeof ts,
   mode: FileSystemMode = 'readonly'
 ): ControlledTypeScriptSystem {
+  // dependencies
+  let artifacts: FilesMatch = {
+    files: [],
+    dirs: [],
+    extensions: [],
+  };
+  let isInitialRun = true;
   // watchers
   const fileWatcherCallbacksMap = new Map<string, ts.FileWatcherCallback[]>();
   const directoryWatcherCallbacksMap = new Map<string, ts.DirectoryWatcherCallback[]>();
@@ -53,7 +63,8 @@ function createControlledTypeScriptSystem(
   // third-party libraries, like fsevents
   const caseSensitive = true;
   const realFileSystem = createRealFileSystem(caseSensitive);
-  const passiveFileSystem = createPassiveFileSystem(caseSensitive, realFileSystem);
+  const memFileSystem = createMemFileSystem(realFileSystem);
+  const passiveFileSystem = createPassiveFileSystem(memFileSystem, realFileSystem);
 
   // based on the ts.ignorePaths
   const ignoredPaths = ['/node_modules/.', '/.git', '/.#'];
@@ -130,8 +141,33 @@ function createControlledTypeScriptSystem(
     );
   }
 
+  function isArtifact(path: string) {
+    return (
+      (artifacts.dirs.some((dir) => path.includes(dir)) ||
+        artifacts.files.some((file) => path === file)) &&
+      artifacts.extensions.some((extension) => path.endsWith(extension))
+    );
+  }
+
+  function getReadFileSystem(path: string) {
+    if (
+      !isInitialRun &&
+      (mode === 'readonly' || mode === 'write-tsbuildinfo') &&
+      isArtifact(path)
+    ) {
+      return memFileSystem;
+    }
+
+    return passiveFileSystem;
+  }
+
   function getWriteFileSystem(path: string) {
-    if (mode === 'readonly' || (mode === 'write-tsbuildinfo' && !path.endsWith('.tsbuildinfo'))) {
+    if (mode !== 'write-references' && isArtifact(path)) {
+      return memFileSystem;
+    } else if (
+      mode === 'readonly' ||
+      (mode === 'write-tsbuildinfo' && !path.endsWith('.tsbuildinfo'))
+    ) {
       return passiveFileSystem;
     } else {
       return realFileSystem;
@@ -142,15 +178,15 @@ function createControlledTypeScriptSystem(
     ...typescript.sys,
     useCaseSensitiveFileNames: caseSensitive,
     fileExists(path: string): boolean {
-      const stats = passiveFileSystem.readStats(path);
+      const stats = getReadFileSystem(path).readStats(path);
 
       return !!stats && stats.isFile();
     },
     readFile(path: string, encoding?: string): string | undefined {
-      return passiveFileSystem.readFile(path, encoding);
+      return getReadFileSystem(path).readFile(path, encoding);
     },
     getFileSize(path: string): number {
-      const stats = passiveFileSystem.readStats(path);
+      const stats = getReadFileSystem(path).readStats(path);
 
       return stats ? stats.size : 0;
     },
@@ -165,7 +201,7 @@ function createControlledTypeScriptSystem(
       controlledSystem.invokeFileDeleted(path);
     },
     directoryExists(path: string): boolean {
-      const stats = passiveFileSystem.readStats(path);
+      const stats = getReadFileSystem(path).readStats(path);
 
       return !!stats && stats.isDirectory();
     },
@@ -175,12 +211,12 @@ function createControlledTypeScriptSystem(
       invokeDirectoryWatchers(path);
     },
     getDirectories(path: string): string[] {
-      const dirents = passiveFileSystem.readDir(path);
+      const dirents = getReadFileSystem(path).readDir(path);
 
       return dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     },
     getModifiedTime(path: string): Date | undefined {
-      const stats = passiveFileSystem.readStats(path);
+      const stats = getReadFileSystem(path).readStats(path);
 
       if (stats) {
         return stats.mtime;
@@ -224,6 +260,7 @@ function createControlledTypeScriptSystem(
       while (timeoutCallbacks.size > 0) {
         await new Promise((resolve) => setImmediate(resolve));
       }
+      isInitialRun = false;
     },
     invokeFileCreated(path: string) {
       const normalizedPath = realFileSystem.normalizePath(path);
@@ -259,6 +296,9 @@ function createControlledTypeScriptSystem(
       passiveFileSystem.clearCache();
       realFileSystem.clearCache();
     },
+    setArtifacts(nextArtifacts: FilesMatch) {
+      artifacts = nextArtifacts;
+    },
   };
 
   return controlledSystem;
diff --git a/src/typescript-reporter/reporter/TypeScriptConfigurationParser.ts b/src/typescript-reporter/reporter/TypeScriptConfigurationParser.ts
index a28f0185..989b778c 100644
--- a/src/typescript-reporter/reporter/TypeScriptConfigurationParser.ts
+++ b/src/typescript-reporter/reporter/TypeScriptConfigurationParser.ts
@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
-import { normalize, dirname } from 'path';
+import { normalize, dirname, resolve } from 'path';
 import { TypeScriptConfigurationOverwrite } from '../TypeScriptConfigurationOverwrite';
-import { Dependencies } from '../../reporter';
+import { FilesMatch } from '../../reporter';
 
 function parseTypeScriptConfiguration(
   typescript: typeof ts,
@@ -43,43 +43,39 @@ function parseTypeScriptConfiguration(
 function getDependenciesFromTypeScriptConfiguration(
   typescript: typeof ts,
   parsedConfiguration: ts.ParsedCommandLine,
-  configFileContext: string,
   parseConfigFileHost: ts.ParseConfigFileHost,
   processedConfigFiles: string[] = []
-): Dependencies {
+): FilesMatch {
   const files = new Set<string>(parsedConfiguration.fileNames);
   if (typeof parsedConfiguration.options.configFilePath === 'string') {
     files.add(parsedConfiguration.options.configFilePath);
   }
   const dirs = new Set(Object.keys(parsedConfiguration.wildcardDirectories || {}));
 
-  if (parsedConfiguration.projectReferences) {
-    parsedConfiguration.projectReferences.forEach((projectReference) => {
-      const configFile = typescript.resolveProjectReferencePath(projectReference);
-      if (processedConfigFiles.includes(configFile)) {
-        // handle circular dependencies
-        return;
-      }
-      const parsedConfiguration = parseTypeScriptConfiguration(
-        typescript,
-        configFile,
-        dirname(configFile),
-        {},
-        parseConfigFileHost
-      );
-      const childDependencies = getDependenciesFromTypeScriptConfiguration(
-        typescript,
-        parsedConfiguration,
-        dirname(configFile),
-        parseConfigFileHost,
-        [...processedConfigFiles, configFile]
-      );
-      childDependencies.files.forEach((file) => {
-        files.add(file);
-      });
-      childDependencies.dirs.forEach((dir) => {
-        dirs.add(dir);
-      });
+  for (const projectReference of parsedConfiguration.projectReferences || []) {
+    const configFile = typescript.resolveProjectReferencePath(projectReference);
+    if (processedConfigFiles.includes(configFile)) {
+      // handle circular dependencies
+      continue;
+    }
+    const parsedConfiguration = parseTypeScriptConfiguration(
+      typescript,
+      configFile,
+      dirname(configFile),
+      {},
+      parseConfigFileHost
+    );
+    const childDependencies = getDependenciesFromTypeScriptConfiguration(
+      typescript,
+      parsedConfiguration,
+      parseConfigFileHost,
+      [...processedConfigFiles, configFile]
+    );
+    childDependencies.files.forEach((file) => {
+      files.add(file);
+    });
+    childDependencies.dirs.forEach((dir) => {
+      dirs.add(dir);
     });
   }
 
@@ -98,4 +94,67 @@ function getDependenciesFromTypeScriptConfiguration(
   };
 }
 
-export { parseTypeScriptConfiguration, getDependenciesFromTypeScriptConfiguration };
+function getArtifactsFromTypeScriptConfiguration(
+  typescript: typeof ts,
+  parsedConfiguration: ts.ParsedCommandLine,
+  configFileContext: string,
+  parseConfigFileHost: ts.ParseConfigFileHost,
+  processedConfigFiles: string[] = []
+): FilesMatch {
+  const files = new Set<string>(
+    parsedConfiguration.options.outFile
+      ? [resolve(configFileContext, parsedConfiguration.options.outFile)]
+      : []
+  );
+  const dirs = new Set<string>(
+    parsedConfiguration.options.outDir
+      ? [resolve(configFileContext, parsedConfiguration.options.outDir)]
+      : [configFileContext]
+  );
+
+  for (const projectReference of parsedConfiguration.projectReferences || []) {
+    const configFile = typescript.resolveProjectReferencePath(projectReference);
+    if (processedConfigFiles.includes(configFile)) {
+      // handle circular dependencies
+      continue;
+    }
+    const parsedConfiguration = parseTypeScriptConfiguration(
+      typescript,
+      configFile,
+      dirname(configFile),
+      {},
+      parseConfigFileHost
+    );
+    const childArtifacts = getArtifactsFromTypeScriptConfiguration(
+      typescript,
+      parsedConfiguration,
+      configFileContext,
+      parseConfigFileHost,
+      [...processedConfigFiles, configFile]
+    );
+    childArtifacts.files.forEach((file) => {
+      files.add(file);
+    });
+    childArtifacts.dirs.forEach((dir) => {
+      dirs.add(dir);
+    });
+  }
+
+  const extensions = [
+    typescript.Extension.Dts,
+    typescript.Extension.Js,
+    typescript.Extension.TsBuildInfo,
+  ];
+
+  return {
+    files: Array.from(files).map((file) => normalize(file)),
+    dirs: Array.from(dirs).map((dir) => normalize(dir)),
+    extensions,
+  };
+}
+
+export {
+  parseTypeScriptConfiguration,
+  getDependenciesFromTypeScriptConfiguration,
+  getArtifactsFromTypeScriptConfiguration,
+};
diff --git a/src/typescript-reporter/reporter/TypeScriptReporter.ts b/src/typescript-reporter/reporter/TypeScriptReporter.ts
index 0c9c26d4..8e9074fb 100644
--- a/src/typescript-reporter/reporter/TypeScriptReporter.ts
+++ b/src/typescript-reporter/reporter/TypeScriptReporter.ts
@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import path from 'path';
-import { Dependencies, Reporter } from '../../reporter';
+import { FilesMatch, Reporter } from '../../reporter';
 import { createIssuesFromTsDiagnostics } from '../issue/TypeScriptIssueFactory';
 import { TypeScriptReporterConfiguration } from '../TypeScriptReporterConfiguration';
 import { createControlledWatchCompilerHost } from './ControlledWatchCompilerHost';
@@ -13,6 +13,7 @@ import {
 } from './ControlledTypeScriptSystem';
 import {
   getDependenciesFromTypeScriptConfiguration,
+  getArtifactsFromTypeScriptConfiguration,
   parseTypeScriptConfiguration,
 } from './TypeScriptConfigurationParser';
 import { createPerformance } from '../../profile/Performance';
@@ -28,7 +29,7 @@ interface Tracing {
 function createTypeScriptReporter(configuration: TypeScriptReporterConfiguration): Reporter {
   let parsedConfiguration: ts.ParsedCommandLine | undefined;
   let parseConfigurationDiagnostics: ts.Diagnostic[] = [];
-  let dependencies: Dependencies | undefined;
+  let dependencies: FilesMatch | undefined;
   let configurationChanged = false;
   let watchCompilerHost:
     | ts.WatchCompilerHostOfFilesAndCompilerOptions<ts.SemanticDiagnosticsBuilderProgram>
@@ -157,7 +158,7 @@ function createTypeScriptReporter(configuration: TypeScriptReporterConfiguration
     return parsedConfiguration;
   }
 
-  function getDependencies(): Dependencies {
+  function getDependencies(): FilesMatch {
     parsedConfiguration = parseConfigurationIfNeeded();
 
     const [parseConfigFileHost] = getParseConfigFileHost();
@@ -165,7 +166,6 @@ function createTypeScriptReporter(configuration: TypeScriptReporterConfiguration
     let dependencies = getDependenciesFromTypeScriptConfiguration(
       typescript,
       parsedConfiguration,
-      configuration.context,
       parseConfigFileHost
     );
 
@@ -178,6 +178,19 @@ function createTypeScriptReporter(configuration: TypeScriptReporterConfiguration
     return dependencies;
   }
 
+  function getArtifacts(): FilesMatch {
+    parsedConfiguration = parseConfigurationIfNeeded();
+
+    const [parseConfigFileHost] = getParseConfigFileHost();
+
+    return getArtifactsFromTypeScriptConfiguration(
+      typescript,
+      parsedConfiguration,
+      configuration.context,
+      parseConfigFileHost
+    );
+  }
+
   function startProfilingIfNeeded() {
     if (configuration.profile) {
       performance.enable();
@@ -257,6 +270,7 @@ function createTypeScriptReporter(configuration: TypeScriptReporterConfiguration
       }
 
       parsedConfiguration = parseConfigurationIfNeeded();
+      system.setArtifacts(getArtifacts());
 
       if (configurationChanged) {
         configurationChanged = false;