feat: rsc plugin

Cargo.toml

@@ -170,6 +170,7 @@ rspack_plugin_progress                 = { version = "0.2.0", path = "crates/rsp
 rspack_plugin_real_content_hash        = { version = "0.2.0", path = "crates/rspack_plugin_real_content_hash" }
 rspack_plugin_remove_duplicate_modules = { version = "0.2.0", path = "crates/rspack_plugin_remove_duplicate_modules" }
 rspack_plugin_remove_empty_chunks      = { version = "0.2.0", path = "crates/rspack_plugin_remove_empty_chunks" }
+rspack_plugin_rsc                      = { version = "0.2.0", path = "crates/rspack_plugin_rsc" }
 rspack_plugin_runtime                  = { version = "0.2.0", path = "crates/rspack_plugin_runtime" }
 rspack_plugin_runtime_chunk            = { version = "0.2.0", path = "crates/rspack_plugin_runtime_chunk" }
 rspack_plugin_schemes                  = { version = "0.2.0", path = "crates/rspack_plugin_schemes" }

crates/node_binding/binding.d.ts

@@ -364,7 +364,10 @@ export declare enum BuiltinPluginName {
   BundlerInfoRspackPlugin = 'BundlerInfoRspackPlugin',
   CssExtractRspackPlugin = 'CssExtractRspackPlugin',
   JsLoaderRspackPlugin = 'JsLoaderRspackPlugin',
-  LazyCompilationPlugin = 'LazyCompilationPlugin'
+  LazyCompilationPlugin = 'LazyCompilationPlugin',
+  RSCClientEntryRspackPlugin = 'RSCClientEntryRspackPlugin',
+  RSCClientReferenceManifestRspackPlugin = 'RSCClientReferenceManifestRspackPlugin',
+  RSCProxyRspackPlugin = 'RSCProxyRspackPlugin'
 }
 
 export declare function cleanupGlobalTrace(): void
@@ -1392,6 +1395,7 @@ export interface RawExperiments {
 incremental?: false | { [key: string]: boolean }
 rspackFuture?: RawRspackFuture
 cache: boolean | { type: "persistent" } & RawExperimentCacheOptionsPersistent | { type: "memory" }
+rsc: boolean
 }
 
 export interface RawExperimentSnapshotOptions {
@@ -1853,6 +1857,11 @@ export interface RawProvideOptions {
   strictVersion?: boolean
 }
 
+export interface RawReactRoute {
+  name: ChunkName
+  import: RoutePath
+}
+
 export interface RawRelated {
   sourceMap?: string
 }
@@ -1919,6 +1928,14 @@ export interface RawResolveTsconfigOptions {
   references?: Array<string>
 }
 
+export interface RawRscClientEntryRspackPluginOptions {
+  routes?: Array<RawReactRoute>
+}
+
+export interface RawRscClientReferenceManifestRspackPluginOptions {
+  routes?: Array<RawReactRoute>
+}
+
 export interface RawRspackFuture {
 
 }

crates/rspack_binding_values/Cargo.toml

@@ -75,6 +75,7 @@ rspack_plugin_progress                 = { workspace = true }
 rspack_plugin_real_content_hash        = { workspace = true }
 rspack_plugin_remove_duplicate_modules = { workspace = true }
 rspack_plugin_remove_empty_chunks      = { workspace = true }
+rspack_plugin_rsc                      = { workspace = true }
 rspack_plugin_runtime                  = { workspace = true }
 rspack_plugin_runtime_chunk            = { workspace = true }
 rspack_plugin_schemes                  = { workspace = true }

crates/rspack_binding_values/src/plugins/js_loader/resolver.rs

@@ -20,6 +20,11 @@ use rspack_loader_preact_refresh::PREACT_REFRESH_LOADER_IDENTIFIER;
 use rspack_loader_react_refresh::REACT_REFRESH_LOADER_IDENTIFIER;
 use rspack_loader_swc::{SwcLoader, SWC_LOADER_IDENTIFIER};
 use rspack_paths::Utf8Path;
+use rspack_plugin_rsc::{
+  RSCClientEntryLoader, RSCProxyLoader, RSCServerActionClientLoader, RSCServerActionServerLoader,
+  RSC_CLIENT_ENTRY_LOADER_IDENTIFIER, RSC_PROXY_LOADER_IDENTIFIER,
+  RSC_SERVER_ACTION_CLIENT_LOADER_IDENTIFIER, RSC_SERVER_ACTION_SERVER_LOADER_IDENTIFIER,
+};
 use rustc_hash::FxHashMap;
 use tokio::sync::RwLock;
 
@@ -123,6 +128,54 @@ pub async fn get_builtin_loader(builtin: &str, options: Option<&str>) -> Result<
   if builtin.starts_with(rspack_loader_testing::NO_PASS_THROUGH_LOADER_IDENTIFIER) {
     return Ok(Arc::new(rspack_loader_testing::NoPassthroughLoader));
   }
+  if builtin.starts_with(RSC_PROXY_LOADER_IDENTIFIER) {
+    return Ok(Arc::new(
+      RSCProxyLoader::new(serde_json::from_str(options.as_ref()).map_err(|e| {
+        serde_error_to_miette(
+          e,
+          options,
+          "failed to parse builtin:rsc-proxy-loader options",
+        )
+      })?)
+      .with_identifier(builtin.into()),
+    ));
+  }
+  if builtin.starts_with(RSC_CLIENT_ENTRY_LOADER_IDENTIFIER) {
+    return Ok(Arc::new(
+      RSCClientEntryLoader::new(serde_json::from_str(options.as_ref()).map_err(|e| {
+        serde_error_to_miette(
+          e,
+          options,
+          "failed to parse builtin:rsc-client-entry-loader options",
+        )
+      })?)
+      .with_identifier(builtin.into()),
+    ));
+  }
+  if builtin.starts_with(RSC_SERVER_ACTION_SERVER_LOADER_IDENTIFIER) {
+    return Ok(Arc::new(
+      RSCServerActionServerLoader::new(serde_json::from_str(options.as_ref()).map_err(|e| {
+        serde_error_to_miette(
+          e,
+          options,
+          "failed to parse builtin:rsc-server-action-server-loader options",
+        )
+      })?)
+      .with_identifier(builtin.into()),
+    ));
+  }
+  if builtin.starts_with(RSC_SERVER_ACTION_CLIENT_LOADER_IDENTIFIER) {
+    return Ok(Arc::new(
+      RSCServerActionClientLoader::new(serde_json::from_str(options.as_ref()).map_err(|e| {
+        serde_error_to_miette(
+          e,
+          options,
+          "failed to parse builtin:rsc-server-client-server-loader options",
+        )
+      })?)
+      .with_identifier(builtin.into()),
+    ));
+  }
   unreachable!("Unexpected builtin loader: {builtin}")
 }
 

crates/rspack_binding_values/src/raw_options/raw_builtins/mod.rs

@@ -11,6 +11,7 @@ mod raw_lightning_css_minimizer;
 mod raw_limit_chunk_count;
 mod raw_mf;
 mod raw_progress;
+mod raw_rsc;
 mod raw_runtime_chunk;
 mod raw_size_limits;
 mod raw_swc_js_minimizer;
@@ -68,6 +69,9 @@ use rspack_plugin_progress::ProgressPlugin;
 use rspack_plugin_real_content_hash::RealContentHashPlugin;
 use rspack_plugin_remove_duplicate_modules::RemoveDuplicateModulesPlugin;
 use rspack_plugin_remove_empty_chunks::RemoveEmptyChunksPlugin;
+use rspack_plugin_rsc::{
+  RSCClientEntryRspackPlugin, RSCClientReferenceManifestRspackPlugin, RSCProxyRspackPlugin,
+};
 use rspack_plugin_runtime::{
   enable_chunk_loading_plugin, ArrayPushCallbackChunkFormatPlugin, BundlerInfoPlugin,
   ChunkPrefetchPreloadPlugin, CommonJsChunkFormatPlugin, ModuleChunkFormatPlugin, RuntimePlugin,
@@ -92,6 +96,9 @@ pub use self::{
   raw_limit_chunk_count::RawLimitChunkCountPluginOptions,
   raw_mf::RawContainerPluginOptions,
   raw_progress::RawProgressPluginOptions,
+  raw_rsc::{
+    RawRSCClientEntryRspackPluginOptions, RawRSCClientReferenceManifestRspackPluginOptions,
+  },
   raw_swc_js_minimizer::RawSwcJsMinimizerRspackPluginOptions,
 };
 use self::{
@@ -192,11 +199,11 @@ pub enum BuiltinPluginName {
   LightningCssMinimizerRspackPlugin,
   BundlerInfoRspackPlugin,
   CssExtractRspackPlugin,
-
-  // rspack js adapter plugins
-  // naming format follow XxxRspackPlugin
   JsLoaderRspackPlugin,
   LazyCompilationPlugin,
+  RSCClientEntryRspackPlugin,
+  RSCClientReferenceManifestRspackPlugin,
+  RSCProxyRspackPlugin,
 }
 
 #[napi(object)]
@@ -558,6 +565,19 @@ impl BuiltinPlugin {
         let options = raw_options.into();
         plugins.push(DllReferenceAgencyPlugin::new(options).boxed());
       }
+      BuiltinPluginName::RSCClientEntryRspackPlugin => {
+        let plugin_options: RawRSCClientEntryRspackPluginOptions =
+          downcast_into::<RawRSCClientEntryRspackPluginOptions>(self.options)?;
+        plugins.push(RSCClientEntryRspackPlugin::new(plugin_options.into()).boxed())
+      }
+      BuiltinPluginName::RSCClientReferenceManifestRspackPlugin => {
+        let plugin_options: RawRSCClientReferenceManifestRspackPluginOptions =
+          downcast_into::<RawRSCClientReferenceManifestRspackPluginOptions>(self.options)?;
+        plugins.push(RSCClientReferenceManifestRspackPlugin::new(plugin_options.into()).boxed())
+      }
+      BuiltinPluginName::RSCProxyRspackPlugin => {
+        plugins.push(RSCProxyRspackPlugin::new(Default::default()).boxed())
+      }
     }
     Ok(())
   }

crates/rspack_binding_values/src/raw_options/raw_builtins/raw_rsc.rs

@@ -0,0 +1,61 @@
+use napi_derive::napi;
+use rspack_plugin_rsc::rsc_client_entry_rspack_plugin::RSCClientEntryRspackPluginOptions;
+use rspack_plugin_rsc::rsc_client_reference_manifest_rspack_plugin::RSCClientReferenceManifestRspackPluginOptions;
+use rspack_plugin_rsc::ReactRoute;
+use serde::Deserialize;
+use serde::Serialize;
+
+type ChunkName = String;
+type RoutePath = String;
+
+#[derive(Deserialize, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+#[napi(object)]
+pub struct RawReactRoute {
+  pub name: ChunkName,
+  pub import: RoutePath,
+}
+
+#[derive(Deserialize, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+#[napi(object)]
+pub struct RawRSCClientEntryRspackPluginOptions {
+  pub routes: Option<Vec<RawReactRoute>>,
+}
+
+#[derive(Deserialize, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+#[napi(object)]
+pub struct RawRSCClientReferenceManifestRspackPluginOptions {
+  pub routes: Option<Vec<RawReactRoute>>,
+}
+
+impl From<RawRSCClientReferenceManifestRspackPluginOptions>
+  for RSCClientReferenceManifestRspackPluginOptions
+{
+  fn from(value: RawRSCClientReferenceManifestRspackPluginOptions) -> Self {
+    let raw_routes = value.routes.unwrap_or_default();
+    let routes: Vec<ReactRoute> = raw_routes
+      .into_iter()
+      .map(|route| ReactRoute {
+        name: route.name,
+        import: route.import,
+      })
+      .collect();
+    RSCClientReferenceManifestRspackPluginOptions { routes }
+  }
+}
+
+impl From<RawRSCClientEntryRspackPluginOptions> for RSCClientEntryRspackPluginOptions {
+  fn from(value: RawRSCClientEntryRspackPluginOptions) -> Self {
+    let raw_routes = value.routes.unwrap_or_default();
+    let routes: Vec<ReactRoute> = raw_routes
+      .into_iter()
+      .map(|route| ReactRoute {
+        name: route.name,
+        import: route.import,
+      })
+      .collect();
+    RSCClientEntryRspackPluginOptions { routes }
+  }
+}

crates/rspack_binding_values/src/raw_options/raw_experiments/mod.rs

@@ -22,6 +22,7 @@ pub struct RawExperiments {
     ts_type = r#"boolean | { type: "persistent" } & RawExperimentCacheOptionsPersistent | { type: "memory" }"#
   )]
   pub cache: RawExperimentCacheOptions,
+  pub rsc: bool,
 }
 
 impl From<RawExperiments> for Experiments {
@@ -38,6 +39,7 @@ impl From<RawExperiments> for Experiments {
       top_level_await: value.top_level_await,
       rspack_future: value.rspack_future.unwrap_or_default().into(),
       cache: normalize_raw_experiment_cache_options(value.cache),
+      rsc: value.rsc,
     }
   }
 }

crates/rspack_core/src/concatenated_module.rs

@@ -559,6 +559,7 @@ impl Module for ConcatenatedModule {
       json_data: Default::default(),
       top_level_declarations: Some(Default::default()),
       module_concatenation_bailout: Default::default(),
+      directives: Default::default(),
     };
     self.clear_diagnostics();
 

crates/rspack_core/src/module.rs

@@ -67,6 +67,7 @@ pub struct BuildInfo {
   #[cacheable(with=AsOption<AsVec<AsPreset>>)]
   pub top_level_declarations: Option<HashSet<Atom>>,
   pub module_concatenation_bailout: Option<String>,
+  pub directives: Vec<String>,
 }
 
 impl Default for BuildInfo {
@@ -85,6 +86,7 @@ impl Default for BuildInfo {
       json_data: None,
       top_level_declarations: None,
       module_concatenation_bailout: None,
+      directives: Vec::default(),
     }
   }
 }

crates/rspack_core/src/options/experiments/mod.rs

@@ -11,6 +11,7 @@ pub struct Experiments {
   pub top_level_await: bool,
   pub rspack_future: RspackFuture,
   pub cache: ExperimentCacheOptions,
+  pub rsc: bool,
 }
 
 #[allow(clippy::empty_structs_with_brackets)]

crates/rspack_loader_swc/Cargo.toml

@@ -29,6 +29,7 @@ rspack_core              = { workspace = true }
 rspack_error             = { workspace = true }
 rspack_loader_runner     = { workspace = true }
 rspack_plugin_javascript = { workspace = true }
+rspack_plugin_rsc        = { path = "../rspack_plugin_rsc" }
 rspack_swc_plugin_import = { workspace = true }
 rspack_util              = { workspace = true }
 serde                    = { workspace = true, features = ["derive"] }