init 阶段：compiler

// lib/webpack.js
const webpack = (options, callback) => {
  const create = () => {
      // 校验 options
   if (!asArray(options).every(webpackOptionsSchemaCheck)) {
    getValidateSchema()(webpackOptionsSchema, options);
   }
   let compiler;
   let watch = false;
   let watchOptions;
   //  options 是数组，创建 MultiCompiler
   if (Array.isArray(options)) {
    compiler = createMultiCompiler(
     options,
    );
    // 收集 watch 和 watchOptions
    watch = options.some(options => options.watch);
    watchOptions = options.map(options => options.watchOptions || {});
   } else {
    const webpackOptions = (options);
    // 创建 compiler
    compiler = createCompiler(webpackOptions);
    watch = webpackOptions.watch;
    watchOptions = webpackOptions.watchOptions || {};
   }
   return { compiler, watch, watchOptions };
  };
  if (callback) {
   try {
    const { compiler, watch, watchOptions } = create();
    if (watch) {
      // 配置了 watch，开启 Watching
     compiler.watch(watchOptions, callback);
    } else {
     // 启动 compiler
     compiler.run((err, stats) => {
      // compile 完毕，关闭 compiler
      compiler.close(err2 => {
       callback(err || err2, stats);
      });
     });
    }
    return compiler;
   } catch (err) {
    process.nextTick(() => callback(err));
    return null;
   }
  } else {
   const { compiler, watch } = create();
   //  ......
   return compiler;
  }
};

const webpack = (options, callback) => {
 // 校验 options
 if (!asArray(options).every(webpackOptionsSchemaCheck)) {
  getValidateSchema()(webpackOptionsSchema, options);
 }

 // 创建 compiler
 const compiler = createCompiler(options);

 // 启动 compiler
 compiler.run((err, stats) => {
  // compile 完毕，关闭 compiler
  compiler.close((err2) => {
   callback(err || err2, stats);
  });
 });

 return compiler;
};

// lib/webpack.js
const createCompiler = rawOptions => {
  // options 规整化
 const options = getNormalizedWebpackOptions(rawOptions);
  // merge webpack 基础默认的 options：context、infrastructureLogging
 applyWebpackOptionsBaseDefaults(options);
  // 新建 Compiler
 const compiler = new Compiler(options.context, options);
  // ========== 注册插件 ========== //
  // 注册 NodeEnvironmentPlugin：beforeRun => 初始化 Node 环境 
 new NodeEnvironmentPlugin({
  infrastructureLogging: options.infrastructureLogging
 }).apply(compiler);
  // 注册 options.plugins
 if (Array.isArray(options.plugins)) {
  for (const plugin of options.plugins) {
   if (typeof plugin === "function") {
    plugin.call(compiler, compiler);
   } else {
    plugin.apply(compiler);
   }
  }
 }
  // merge webpack 默认 options: context、target、devtool等
 applyWebpackOptionsDefaults(options);
  // 触发 Hook.environment => call
 compiler.hooks.environment.call();
  // 触发 Hook.afterEnvironment => call
 compiler.hooks.afterEnvironment.call();
  // WebpackOptionsApply 根据 options 注册内置插件
 new WebpackOptionsApply().process(options, compiler);
  // 触发 Hook.initialize => call
 compiler.hooks.initialize.call();
  // 返回 compiler
 return compiler;
};

run(callback) {
  // 如果 compiler 已经在运行则报错
  if (this.running) {
    return callback(new ConcurrentCompilationError());
  }

  // 仅在出现 err 时执行
  const finalCallback = (err, stats) => {
    // 将 compiler 标记为 idle
    this.idle = true;
    // 触发 CacheHook.beginIdle => call
    this.cache.beginIdle();
    this.idle = true;
    // 标记 compiler running 为 false
    this.running = false;
    if (err) {
      // 触发 Hook.failed => call
      this.hooks.failed.call(err);
    }
    if (callback !== undefined) callback(err, stats);
    // 触发 Hook.afterDone => call
    this.hooks.afterDone.call(stats);
  };

  // 标记 running 为 true
  this.running = true;

  const run = () => {
    // 触发 Hook.beforeRun: callAsync 
    this.hooks.beforeRun.callAsync(this, err => {
      if (err) return finalCallback(err);
      // 触发 Hook.run: callAsync
      this.hooks.run.callAsync(this, err => {
        if (err) return finalCallback(err);
        // 尝试从 records 恢复，反序列化
        this.readRecords(err => {
          if (err) return finalCallback(err);
          // 开始 compile
          this.compile(onCompiled);
        });
      });
    });
  };
  // 初始为 false
  if (this.idle) {
    // 触发 CacheHook.endIdle
    this.cache.endIdle(err => {
      if (err) return finalCallback(err);
      
      this.idle = false;
      run();
    });
  } else {
    run();
  }
}

// lib/Compiler.js
compile(callback) {
    // 使用缓存的 compilationParams
  const params = this.newCompilationParams();
    // 触发 Hook.beforeCompile => callAsync
  this.hooks.beforeCompile.callAsync(params, err => {
   if (err) return callback(err);
      // 触发 Hook.compile => call
   this.hooks.compile.call(params);
      // 使用缓存的 compilation 对象
   const compilation = this.newCompilation(params);

   // 触发 Hook.make => callAsync
   this.hooks.make.callAsync(compilation, err => {
    if (err) return callback(err);
    
    // 触发 Hook.finishMake => callAsync
    this.hooks.finishMake.callAsync(compilation, err => {
     if (err) return callback(err);

     process.nextTick(() => {
      // compilation.finish
      compilation.finish(err => {
       if (err) return callback(err);

       // compilation.seal
       compilation.seal(err => {
        if (err) return callback(err);

        // 触发 Hook.afterCompile => callAsync
        this.hooks.afterCompile.callAsync(compilation, err => {
         if (err) return callback(err);

         return callback(null, compilation);
        });
       });
      });
     });
    });
   });
  });
}

newCompilationParams() {
const params = {
  // new NormalModuleFactory()
  normalModuleFactory: this.createNormalModuleFactory(),
  // new ContextModuleFactory()
  contextModuleFactory: this.createContextModuleFactory()
};
return params;
}

// lib/Compiler.js
createCompilation(params) {
  // 注意：这里并不会频繁实例化类，而是在 _cleanupLastCompilation 中将 _lastCompilation 清理之后复用
 this._cleanupLastCompilation();
 return (this._lastCompilation = new Compilation(this, params));
}
newCompilation(params) {
  // 创建 compilation 实例
 const compilation = this.createCompilation(params);
 compilation.name = this.name;
 compilation.records = this.records;
  // 触发 Hook.thisCompilation => call
 this.hooks.thisCompilation.call(compilation, params);
  // 触发 Hook.compilation => call
 this.hooks.compilation.call(compilation, params);
 return compilation;
}

// lib/WebpackOptionsApply.js
new EntryOptionPlugin().apply(compiler);
// 触发 Hook.entryOption => call
compiler.hooks.entryOption.call(options.context, options.entry);

// lib/EntryOptionPlugin.js
class EntryOptionPlugin {
 // ......
 apply(compiler) {
  // 注册 Callback: Hook.entryOption， Hook.entryOption 触发时，将执行 applyEntryOption
  // Hook.entryOption 在此插件注册完毕后就会被触发
  compiler.hooks.entryOption.tap("EntryOptionPlugin", (context, entry) => {
   EntryOptionPlugin.applyEntryOption(compiler, context, entry);
   return true;
  });
 }

 static applyEntryOption(compiler, context, entry) {
  // entry 是函数，注册 DynamicEntryPlugin
  if (typeof entry === "function") {
   const DynamicEntryPlugin = require("./DynamicEntryPlugin");
   new DynamicEntryPlugin(context, entry).apply(compiler);
  } else {
   // entry 是 object，注册 EntryPlugin
   const EntryPlugin = require("./EntryPlugin");
   // 循环 entries 将 entry 生成 options
   //  entry: {
   //   b2: {
   //     dependOn: 'a2',
   //     import: './src/app.js',
   //   },
   // },
   for (const name of Object.keys(entry)) {
    const desc = entry[name];
    const options = EntryOptionPlugin.entryDescriptionToOptions(
     compiler,
     name,
     desc
    );
    // 对于 entry 中每一个入口路径，注册插件 EntryPlugin
    for (const entry of desc.import) {
     new EntryPlugin(context, entry, options).apply(compiler);
    }
   }
  }
 }
}

class EntryPlugin {
 apply(compiler) {
  // 注册 Callback：Hook.compilation
  // Hook.compilation 在  compiler.compile 函数中触发
  compiler.hooks.compilation.tap(
   "EntryPlugin",
   (compilation, { normalModuleFactory }) => {
    // dependencyFactories 记录某种 Dependency 应用哪种 ModuleFactory
    // 记录 EntryDependency 使用 normalModuleFactory
    compilation.dependencyFactories.set(
     EntryDependency,
     normalModuleFactory
    );
   }
  );

  const { entry, options, context } = this;
  // 静态方法创建 EntryDependency
  const dep = EntryPlugin.createDependency(entry, options);
  // 注册 Callback： Hook.make => tapAsync
  // Hook.make 在  compiler.compile 函数中触发
  compiler.hooks.make.tapAsync("EntryPlugin", (compilation, callback) => {
   // compilation.addEntry 添加 Entry，目的是创建 EntryDependency
   compilation.addEntry(context, dep, options, (err) => {
    callback(err);
   });
  });
 }

 static createDependency(entry, options) {
  // 创建 EntryDependency 对象
  const dep = new EntryDependency(entry);
  // TODO webpack 6 remove string option
  dep.loc = { name: typeof options === "object" ? options.name : options };
  return dep;
 }
}