diff --git a/CHANGELOG.md b/CHANGELOG.md
index 637f08a56..f0ba90d89 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,6 +23,14 @@ After a release, please make sure to run `bundle exec rake update_changelog`. Th
 
 Changes since the last non-beta release.
 
+#### Improved
+
+- Improved RSC rendering flow by eliminating double rendering of server components and reducing the number of HTTP requests.
+- Updated communication protocol between Node Renderer and Rails to version 2.0.0 which supports the ability to upload multiple bundles at once.
+- Introduced `RSCServerRoot` and `RSCPayloadContainer` components to enable server-side rendering (SSR) of server components using RSC payload, and to embed the RSC payload directly into the page.
+
+[PR 1696](https://github.com/shakacode/react_on_rails/pull/1696) by [AbanoubGhadban](https://github.com/AbanoubGhadban).
+
 #### Added
 
 - Configuration option `generated_component_packs_loading_strategy` to control how generated component packs are loaded. It supports `sync`, `async`, and `defer` strategies. [PR 1712](https://github.com/shakacode/react_on_rails/pull/1712) by [AbanoubGhadban](https://github.com/AbanoubGhadban).
diff --git a/eslint.config.ts b/eslint.config.ts
index d70f0dd79..c3a535b69 100644
--- a/eslint.config.ts
+++ b/eslint.config.ts
@@ -42,6 +42,7 @@ const config = tsEslint.config([
     '**/node_modules/',
     // fixtures
     '**/fixtures/',
+    '**/.yalc/**/*',
   ]),
   {
     files: ['**/*.[jt]s', '**/*.[jt]sx', '**/*.[cm][jt]s'],
@@ -71,7 +72,7 @@ const config = tsEslint.config([
         alias: [['Assets', './spec/dummy/client/app/assets']],
 
         node: {
-          extensions: ['.js', '.jsx', '.ts', '.d.ts'],
+          extensions: ['.js', '.jsx', '.ts', '.tsx', '.d.ts'],
         },
       },
     },
@@ -96,6 +97,7 @@ const config = tsEslint.config([
           js: 'never',
           jsx: 'never',
           ts: 'never',
+          tsx: 'never',
         },
       ],
 
@@ -128,6 +130,12 @@ const config = tsEslint.config([
       'react/jsx-props-no-spreading': 'off',
       'react/static-property-placement': 'off',
       'jsx-a11y/anchor-is-valid': 'off',
+      'react/jsx-filename-extension': [
+        'error',
+        {
+          extensions: ['.jsx', '.tsx'],
+        },
+      ],
     },
   },
   {
diff --git a/knip.ts b/knip.ts
index 6d4d898e6..9480c139d 100644
--- a/knip.ts
+++ b/knip.ts
@@ -9,6 +9,7 @@ const config: KnipConfig = {
         'node_package/src/ReactOnRailsRSC.ts!',
         'node_package/src/registerServerComponent/client.ts!',
         'node_package/src/registerServerComponent/server.ts!',
+        'node_package/src/registerServerComponent/server.rsc.ts!',
         'node_package/src/RSCClientRoot.ts!',
         'eslint.config.ts',
       ],
diff --git a/lib/react_on_rails/configuration.rb b/lib/react_on_rails/configuration.rb
index 48e81fdba..d033b7645 100644
--- a/lib/react_on_rails/configuration.rb
+++ b/lib/react_on_rails/configuration.rb
@@ -10,6 +10,7 @@ def self.configure
 
   DEFAULT_GENERATED_ASSETS_DIR = File.join(%w[public webpack], Rails.env).freeze
   DEFAULT_REACT_CLIENT_MANIFEST_FILE = "react-client-manifest.json"
+  DEFAULT_REACT_SERVER_CLIENT_MANIFEST_FILE = "react-server-client-manifest.json"
   DEFAULT_COMPONENT_REGISTRY_TIMEOUT = 5000
 
   def self.configuration
@@ -21,6 +22,7 @@ def self.configuration
       server_bundle_js_file: "",
       rsc_bundle_js_file: "",
       react_client_manifest_file: DEFAULT_REACT_CLIENT_MANIFEST_FILE,
+      react_server_client_manifest_file: DEFAULT_REACT_SERVER_CLIENT_MANIFEST_FILE,
       prerender: false,
       auto_load_bundle: false,
       replay_console: true,
@@ -66,7 +68,7 @@ class Configuration
                   :same_bundle_for_client_and_server, :rendering_props_extension,
                   :make_generated_server_bundle_the_entrypoint,
                   :generated_component_packs_loading_strategy, :force_load, :rsc_bundle_js_file,
-                  :react_client_manifest_file, :component_registry_timeout
+                  :react_client_manifest_file, :react_server_client_manifest_file, :component_registry_timeout
 
     # rubocop:disable Metrics/AbcSize
     def initialize(node_modules_location: nil, server_bundle_js_file: nil, prerender: nil,
@@ -82,7 +84,8 @@ def initialize(node_modules_location: nil, server_bundle_js_file: nil, prerender
                    i18n_dir: nil, i18n_yml_dir: nil, i18n_output_format: nil, i18n_yml_safe_load_options: nil,
                    random_dom_id: nil, server_render_method: nil, rendering_props_extension: nil,
                    components_subdirectory: nil, auto_load_bundle: nil, force_load: nil,
-                   rsc_bundle_js_file: nil, react_client_manifest_file: nil, component_registry_timeout: nil)
+                   rsc_bundle_js_file: nil, react_client_manifest_file: nil, react_server_client_manifest_file: nil,
+                   component_registry_timeout: nil)
       self.node_modules_location = node_modules_location.present? ? node_modules_location : Rails.root
       self.generated_assets_dirs = generated_assets_dirs
       self.generated_assets_dir = generated_assets_dir
@@ -112,6 +115,7 @@ def initialize(node_modules_location: nil, server_bundle_js_file: nil, prerender
       self.server_bundle_js_file = server_bundle_js_file
       self.rsc_bundle_js_file = rsc_bundle_js_file
       self.react_client_manifest_file = react_client_manifest_file
+      self.react_server_client_manifest_file = react_server_client_manifest_file
       self.same_bundle_for_client_and_server = same_bundle_for_client_and_server
       self.server_renderer_pool_size = self.development_mode ? 1 : server_renderer_pool_size
       self.server_renderer_timeout = server_renderer_timeout # seconds
@@ -305,8 +309,11 @@ def ensure_webpack_generated_files_exists
         "manifest.json",
         server_bundle_js_file,
         rsc_bundle_js_file,
-        react_client_manifest_file
+        react_client_manifest_file,
+        react_server_client_manifest_file
       ].compact_blank
+
+      self.webpack_generated_files = files
     end
 
     def configure_skip_display_none_deprecation
diff --git a/lib/react_on_rails/helper.rb b/lib/react_on_rails/helper.rb
index 6534fede9..4c8532d31 100644
--- a/lib/react_on_rails/helper.rb
+++ b/lib/react_on_rails/helper.rb
@@ -358,10 +358,14 @@ def json_safe_and_pretty(hash_or_string)
     # second parameter passed to both component and store Render-Functions.
     # This method can be called from views and from the controller, as `helpers.rails_context`
     #
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def rails_context(server_side: true)
       # ALERT: Keep in sync with node_package/src/types/index.ts for the properties of RailsContext
       @rails_context ||= begin
+        rsc_url = if ReactOnRails::Utils.react_on_rails_pro?
+                    ReactOnRailsPro.configuration.rsc_payload_generation_url_path
+                  end
+
         result = {
           componentRegistryTimeout: ReactOnRails.configuration.component_registry_timeout,
           railsEnv: Rails.env,
@@ -373,8 +377,11 @@ def rails_context(server_side: true)
           # TODO: v13 just use the version if existing
           rorPro: ReactOnRails::Utils.react_on_rails_pro?
         }
+
         if ReactOnRails::Utils.react_on_rails_pro?
           result[:rorProVersion] = ReactOnRails::Utils.react_on_rails_pro_version
+
+          result[:rscPayloadGenerationUrl] = rsc_url if ReactOnRailsPro.configuration.enable_rsc_support
         end
 
         if defined?(request) && request.present?
@@ -432,7 +439,7 @@ def load_pack_for_generated_component(react_component_name, render_options)
       append_stylesheet_pack_tag("generated/#{react_component_name}")
     end
 
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
     private
 
diff --git a/lib/react_on_rails/test_helper/webpack_assets_status_checker.rb b/lib/react_on_rails/test_helper/webpack_assets_status_checker.rb
index f3014af8d..fbd1889a0 100644
--- a/lib/react_on_rails/test_helper/webpack_assets_status_checker.rb
+++ b/lib/react_on_rails/test_helper/webpack_assets_status_checker.rb
@@ -52,6 +52,8 @@ def all_compiled_assets
           webpack_generated_files = @webpack_generated_files.map do |bundle_name|
             if bundle_name == ReactOnRails.configuration.react_client_manifest_file
               ReactOnRails::Utils.react_client_manifest_file_path
+            elsif bundle_name == ReactOnRails.configuration.react_server_client_manifest_file
+              ReactOnRails::Utils.react_server_client_manifest_file_path
             else
               ReactOnRails::Utils.bundle_js_file_path(bundle_name)
             end
diff --git a/lib/react_on_rails/utils.rb b/lib/react_on_rails/utils.rb
index d53a64495..5e50d4478 100644
--- a/lib/react_on_rails/utils.rb
+++ b/lib/react_on_rails/utils.rb
@@ -122,6 +122,15 @@ def self.react_client_manifest_file_path
                                     end
     end
 
+    # React Server Manifest is generated by the server bundle.
+    # So, it will never be served from the dev server.
+    def self.react_server_client_manifest_file_path
+      return @react_server_manifest_path if @react_server_manifest_path && !Rails.env.development?
+
+      asset_name = ReactOnRails.configuration.react_server_client_manifest_file
+      @react_server_manifest_path = File.join(generated_assets_full_path, asset_name)
+    end
+
     def self.running_on_windows?
       (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
     end
diff --git a/node_package/src/RSCClientRoot.ts b/node_package/src/RSCClientRoot.ts
index 7a1d09572..08b5c2fad 100644
--- a/node_package/src/RSCClientRoot.ts
+++ b/node_package/src/RSCClientRoot.ts
@@ -5,12 +5,15 @@ import * as ReactDOMClient from 'react-dom/client';
 import { createFromReadableStream } from 'react-on-rails-rsc/client';
 import { fetch } from './utils.ts';
 import transformRSCStreamAndReplayConsoleLogs from './transformRSCStreamAndReplayConsoleLogs.ts';
-import { RailsContext, RenderFunction } from './types/index.ts';
+import { RailsContext, RenderFunction, RSCPayloadChunk } from './types/index.ts';
+import { ensureReactUseAvailable } from './reactApis.cts';
 
-const { use } = React;
+ensureReactUseAvailable();
 
-if (typeof use !== 'function') {
-  throw new Error('React.use is not defined. Please ensure you are using React 19 to use server components.');
+declare global {
+  interface Window {
+    REACT_ON_RAILS_RSC_PAYLOAD?: RSCPayloadChunk[];
+  }
 }
 
 export type RSCClientRootProps = {
@@ -35,6 +38,60 @@ const fetchRSC = ({ componentName, rscPayloadGenerationUrlPath, componentProps }
   return createFromFetch(fetch(`/${strippedUrlPath}/${componentName}?props=${propsString}`));
 };
 
+const createRSCStreamFromPage = () => {
+  let streamController: ReadableStreamController<RSCPayloadChunk> | undefined;
+  const stream = new ReadableStream<RSCPayloadChunk>({
+    start(controller) {
+      if (typeof window === 'undefined') {
+        return;
+      }
+      const handleChunk = (chunk: RSCPayloadChunk) => {
+        controller.enqueue(chunk);
+      };
+
+      // The RSC payload transfer mechanism works in two possible scenarios:
+      // 1. RSCClientRoot executes first:
+      //    - Initializes REACT_ON_RAILS_RSC_PAYLOAD as an empty array
+      //    - Overrides the push function to handle incoming chunks
+      //    - When server scripts run later, they use the overridden push function
+      // 2. Server scripts execute first:
+      //    - Initialize REACT_ON_RAILS_RSC_PAYLOAD as an empty array
+      //    - Buffer RSC payload chunks in the array
+      //    - When RSCClientRoot runs, it reads buffered chunks and overrides push
+      //
+      // Key points:
+      // - The array is never reassigned, ensuring data consistency
+      // - The push function override ensures all chunks are properly handled
+      // - Execution order is irrelevant - both scenarios work correctly
+      if (!window.REACT_ON_RAILS_RSC_PAYLOAD) {
+        window.REACT_ON_RAILS_RSC_PAYLOAD = [];
+      }
+      window.REACT_ON_RAILS_RSC_PAYLOAD.forEach(handleChunk);
+      window.REACT_ON_RAILS_RSC_PAYLOAD.push = (...chunks) => {
+        chunks.forEach(handleChunk);
+        return chunks.length;
+      };
+      streamController = controller;
+    },
+  });
+
+  if (typeof document !== 'undefined' && document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => {
+      streamController?.close();
+    });
+  } else {
+    streamController?.close();
+  }
+
+  return stream;
+};
+
+const createFromRSCStream = () => {
+  const stream = createRSCStreamFromPage();
+  const transformedStream = transformRSCStreamAndReplayConsoleLogs(stream);
+  return createFromReadableStream<React.ReactNode>(transformedStream);
+};
+
 /**
  * RSCClientRoot is a React component that handles client-side rendering of React Server Components (RSC).
  * It manages the fetching, caching, and rendering of RSC payloads from the server.
@@ -53,7 +110,6 @@ const RSCClientRoot: RenderFunction = async (
   _railsContext?: RailsContext,
   domNodeId?: string,
 ) => {
-  const root = await fetchRSC({ componentName, rscPayloadGenerationUrlPath, componentProps });
   if (!domNodeId) {
     throw new Error('RSCClientRoot: No domNodeId provided');
   }
@@ -62,8 +118,10 @@ const RSCClientRoot: RenderFunction = async (
     throw new Error(`RSCClientRoot: No DOM node found for id: ${domNodeId}`);
   }
   if (domNode.innerHTML) {
+    const root = await createFromRSCStream();
     ReactDOMClient.hydrateRoot(domNode, root);
   } else {
+    const root = await fetchRSC({ componentName, rscPayloadGenerationUrlPath, componentProps });
     ReactDOMClient.createRoot(domNode).render(root);
   }
   // Added only to satisfy the return type of RenderFunction
diff --git a/node_package/src/RSCPayloadContainer.tsx b/node_package/src/RSCPayloadContainer.tsx
new file mode 100644
index 000000000..d1c58fe29
--- /dev/null
+++ b/node_package/src/RSCPayloadContainer.tsx
@@ -0,0 +1,128 @@
+import * as React from 'react';
+
+type StreamChunk = {
+  chunk: string;
+  isLastChunk: boolean;
+};
+
+type RSCPayloadContainerProps = {
+  RSCPayloadStream: NodeJS.ReadableStream;
+};
+
+type RSCPayloadContainerInnerProps = {
+  chunkIndex: number;
+  getChunkPromise: (chunkIndex: number) => Promise<StreamChunk>;
+};
+
+// In JavaScript, when an escape sequence with a backslash (\) is followed by a character
+// that isn't a recognized escape character, the backslash is ignored, and the character
+// is treated as-is.
+// This behavior allows us to use the backslash to escape characters that might be
+// interpreted as HTML tags, preventing them from being processed by the HTML parser.
+// For example, we can escape the comment tag <!-- as <\!-- and the script tag </script>
+// as <\/script>.
+// This ensures that these tags are not prematurely closed or misinterpreted by the browser.
+function escapeScript(script: string) {
+  return script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1');
+}
+
+/**
+ * RSCPayloadContainer is a React component that handles the server-to-client transfer
+ * of React Server Component (RSC) payloads. It works in conjunction with RSCClientRoot
+ * to ensure reliable delivery of RSC chunks.
+ *
+ * How it works:
+ * 1. Receives a NodeJS.ReadableStream containing RSC payload chunks from the server
+ * 2. Creates a series of promises to handle each chunk asynchronously
+ * 3. For each chunk:
+ *    - Creates a script tag that pushes the chunk to window.REACT_ON_RAILS_RSC_PAYLOAD
+ *    - Uses React.use() to handle the async chunk loading
+ *    - Recursively renders the next chunk using Suspense
+ *
+ * The component ensures that:
+ * - Chunks are processed in order
+ * - Server-side console logs are preserved
+ * - The transfer is resilient to network conditions
+ * - The client receives all chunks reliably
+ */
+const RSCPayloadContainer = ({
+  chunkIndex,
+  getChunkPromise,
+}: RSCPayloadContainerInnerProps): React.ReactNode => {
+  const chunkPromise = getChunkPromise(chunkIndex);
+  const chunk = React.use(chunkPromise);
+
+  const scriptElement = (
+    <script
+      // eslint-disable-next-line react/no-danger
+      dangerouslySetInnerHTML={{
+        __html: escapeScript(`(self.REACT_ON_RAILS_RSC_PAYLOAD||=[]).push(${chunk.chunk})`),
+      }}
+    />
+  );
+
+  if (chunk.isLastChunk) {
+    return scriptElement;
+  }
+
+  return (
+    <>
+      {scriptElement}
+      <React.Suspense fallback={null}>
+        <RSCPayloadContainer chunkIndex={chunkIndex + 1} getChunkPromise={getChunkPromise} />
+      </React.Suspense>
+    </>
+  );
+};
+
+export default function RSCPayloadContainerWrapper({ RSCPayloadStream }: RSCPayloadContainerProps) {
+  const [chunkPromises] = React.useState<Promise<StreamChunk>[]>(() => {
+    const promises: Promise<StreamChunk>[] = [];
+    let resolveCurrentPromise: (streamChunk: StreamChunk) => void = () => {};
+    let rejectCurrentPromise: (error: unknown) => void = () => {};
+    const decoder = new TextDecoder();
+
+    const createNewPromise = () => {
+      const promise = new Promise<StreamChunk>((resolve, reject) => {
+        resolveCurrentPromise = resolve;
+        rejectCurrentPromise = reject;
+      });
+
+      promises.push(promise);
+    };
+
+    createNewPromise();
+    RSCPayloadStream.on('data', (streamChunk) => {
+      resolveCurrentPromise({ chunk: decoder.decode(streamChunk as Uint8Array), isLastChunk: false });
+      createNewPromise();
+    });
+
+    RSCPayloadStream.on('error', (error) => {
+      rejectCurrentPromise(error);
+      createNewPromise();
+    });
+
+    RSCPayloadStream.on('end', () => {
+      resolveCurrentPromise({ chunk: '', isLastChunk: true });
+    });
+
+    return promises;
+  });
+
+  const getChunkPromise = React.useCallback(
+    (chunkIndex: number) => {
+      if (chunkIndex >= chunkPromises.length) {
+        throw new Error('React on Rails Error: RSC Chunk index out of bounds');
+      }
+
+      return chunkPromises[chunkIndex];
+    },
+    [chunkPromises],
+  );
+
+  return (
+    <React.Suspense fallback={null}>
+      <RSCPayloadContainer chunkIndex={0} getChunkPromise={getChunkPromise} />
+    </React.Suspense>
+  );
+}
diff --git a/node_package/src/RSCServerRoot.tsx b/node_package/src/RSCServerRoot.tsx
new file mode 100644
index 000000000..39ecb2389
--- /dev/null
+++ b/node_package/src/RSCServerRoot.tsx
@@ -0,0 +1,117 @@
+import * as React from 'react';
+import { createFromNodeStream } from 'react-on-rails-rsc/client.node';
+import { PassThrough } from 'stream';
+import type { RenderFunction, RailsContext } from './types/index.ts';
+import transformRSCStream from './transformRSCNodeStream.ts';
+import loadJsonFile from './loadJsonFile.ts';
+import RSCPayloadContainer from './RSCPayloadContainer.tsx';
+import { ensureReactUseAvailable } from './reactApis.cts';
+
+ensureReactUseAvailable();
+
+declare global {
+  function generateRSCPayload(
+    componentName: string,
+    props: Record<string, unknown>,
+    railsContext: RailsContext,
+  ): Promise<NodeJS.ReadableStream>;
+}
+
+type RSCServerRootProps = {
+  componentName: string;
+  componentProps: Record<string, unknown>;
+};
+
+const { use } = React;
+
+const createFromReactOnRailsNodeStream = (
+  stream: NodeJS.ReadableStream,
+  ssrManifest: Record<string, unknown>,
+) => {
+  const transformedStream = transformRSCStream(stream);
+  return createFromNodeStream(transformedStream, ssrManifest);
+};
+
+const createSSRManifest = async (
+  reactServerManifestFileName: string,
+  reactClientManifestFileName: string,
+) => {
+  const [reactServerManifest, reactClientManifest] = await Promise.all([
+    loadJsonFile(reactServerManifestFileName) as Promise<Record<string, { id: string; chunks: string[] }>>,
+    loadJsonFile(reactClientManifestFileName) as Promise<Record<string, { id: string }>>,
+  ]);
+
+  const moduleMap: Record<string, unknown> = {};
+  Object.entries(reactClientManifest).forEach(([aboluteFileUrl, clientFileBundlingInfo]) => {
+    const { id, chunks } = reactServerManifest[aboluteFileUrl];
+    moduleMap[clientFileBundlingInfo.id] = {
+      '*': {
+        id,
+        chunks,
+        name: '*',
+      },
+    };
+  });
+
+  const ssrManifest = {
+    // The `moduleLoading` property is utilized by the React runtime to load JavaScript modules.
+    // It can accept options such as `prefix` and `crossOrigin` to specify the path and crossorigin attribute for the modules.
+    // In our case, since the server code is bundled into a single bundle, there is no need to load additional JavaScript modules.
+    // As a result, we set this property to an empty object because it will not be used.
+    moduleLoading: {},
+    moduleMap,
+  };
+
+  return ssrManifest;
+};
+
+const RSCServerRoot: RenderFunction = async (
+  { componentName, componentProps }: RSCServerRootProps,
+  railsContext?: RailsContext,
+) => {
+  if (
+    !railsContext?.serverSide ||
+    !railsContext?.reactClientManifestFileName ||
+    !railsContext?.reactServerClientManifestFileName
+  ) {
+    throw new Error(
+      'serverClientManifestFileName and reactServerClientManifestFileName are required. ' +
+        'Please ensure that React Server Component webpack configurations are properly set ' +
+        'as stated in the React Server Component tutorial. ' +
+        'Make sure to use "stream_react_component" instead of "react_component" to SSR a server component.',
+    );
+  }
+
+  if (typeof generateRSCPayload !== 'function') {
+    throw new Error(
+      'generateRSCPayload is not defined. Please ensure that you are using at least version 4.0.0 of ' +
+        'React on Rails Pro and the Node renderer, and that ReactOnRailsPro.configuration.enable_rsc_support ' +
+        'is set to true.',
+    );
+  }
+
+  const ssrManifest = await createSSRManifest(
+    railsContext.reactServerClientManifestFileName,
+    railsContext.reactClientManifestFileName,
+  );
+  const rscPayloadStream = await generateRSCPayload(componentName, componentProps, railsContext);
+
+  // Tee the stream to pass it to the server component and the payload container
+  const rscPayloadStream1 = new PassThrough();
+  rscPayloadStream.pipe(rscPayloadStream1);
+  const rscPayloadStream2 = new PassThrough();
+  rscPayloadStream.pipe(rscPayloadStream2);
+  const serverComponentElement = createFromReactOnRailsNodeStream(rscPayloadStream1, ssrManifest);
+
+  return () => {
+    const resolvedServerComponent = use(serverComponentElement);
+    return (
+      <>
+        {resolvedServerComponent}
+        <RSCPayloadContainer RSCPayloadStream={rscPayloadStream2} />
+      </>
+    );
+  };
+};
+
+export default RSCServerRoot;
diff --git a/node_package/src/ReactOnRails.client.ts b/node_package/src/ReactOnRails.client.ts
index 97d4e1078..752fba1d4 100644
--- a/node_package/src/ReactOnRails.client.ts
+++ b/node_package/src/ReactOnRails.client.ts
@@ -188,6 +188,8 @@ globalThis.ReactOnRails = {
   resetOptions(): void {
     this.options = { ...DEFAULT_OPTIONS };
   },
+
+  isRSCBundle: false,
 };
 
 globalThis.ReactOnRails.resetOptions();
diff --git a/node_package/src/ReactOnRailsRSC.ts b/node_package/src/ReactOnRailsRSC.ts
index 428787eab..08f38eb81 100644
--- a/node_package/src/ReactOnRailsRSC.ts
+++ b/node_package/src/ReactOnRailsRSC.ts
@@ -11,7 +11,7 @@ import {
   streamServerRenderedComponent,
   transformRenderStreamChunksToResultObject,
 } from './streamServerRenderedReactComponent.ts';
-import loadReactClientManifest from './loadReactClientManifest.ts';
+import loadJsonFile from './loadJsonFile.ts';
 
 const stringToStream = (str: string) => {
   const stream = new PassThrough();
@@ -24,7 +24,12 @@ const streamRenderRSCComponent = (
   reactRenderingResult: StreamableComponentResult,
   options: RSCRenderParams,
 ): Readable => {
-  const { throwJsErrors, reactClientManifestFileName } = options;
+  const { throwJsErrors } = options;
+  if (!options.railsContext?.serverSide || !options.railsContext.reactClientManifestFileName) {
+    throw new Error('Rails context is not available');
+  }
+
+  const { reactClientManifestFileName } = options.railsContext;
   const renderState: StreamRenderState = {
     result: null,
     hasErrors: false,
@@ -33,7 +38,7 @@ const streamRenderRSCComponent = (
 
   const { pipeToTransform, readableStream, emitError } =
     transformRenderStreamChunksToResultObject(renderState);
-  Promise.all([loadReactClientManifest(reactClientManifestFileName), reactRenderingResult])
+  Promise.all([loadJsonFile(reactClientManifestFileName), reactRenderingResult])
     .then(([reactClientManifest, reactElement]) => {
       const rscStream = renderToPipeableStream(reactElement, reactClientManifest, {
         onError: (err) => {
@@ -67,5 +72,7 @@ ReactOnRails.serverRenderRSCReactComponent = (options: RSCRenderParams) => {
   }
 };
 
+ReactOnRails.isRSCBundle = true;
+
 export * from './types/index.ts';
 export default ReactOnRails;
diff --git a/node_package/src/buildConsoleReplay.ts b/node_package/src/buildConsoleReplay.ts
index a85437753..b8e924dde 100644
--- a/node_package/src/buildConsoleReplay.ts
+++ b/node_package/src/buildConsoleReplay.ts
@@ -54,5 +54,9 @@ export default function buildConsoleReplay(
   customConsoleHistory: (typeof console)['history'] | undefined = undefined,
   numberOfMessagesToSkip: number = 0,
 ): string {
-  return wrapInScriptTags('consoleReplayLog', consoleReplay(customConsoleHistory, numberOfMessagesToSkip));
+  const consoleReplayJS = consoleReplay(customConsoleHistory, numberOfMessagesToSkip);
+  if (consoleReplayJS.length === 0) {
+    return '';
+  }
+  return wrapInScriptTags('consoleReplayLog', consoleReplayJS);
 }
diff --git a/node_package/src/loadJsonFile.ts b/node_package/src/loadJsonFile.ts
new file mode 100644
index 000000000..2628711f9
--- /dev/null
+++ b/node_package/src/loadJsonFile.ts
@@ -0,0 +1,25 @@
+import * as path from 'path';
+import * as fs from 'fs/promises';
+
+type LoadedJsonFile = Record<string, unknown>;
+const loadedJsonFiles = new Map<string, LoadedJsonFile>();
+
+export default async function loadJsonFile(fileName: string) {
+  // Asset JSON files are uploaded to node renderer.
+  // Renderer copies assets to the same place as the server-bundle.js and rsc-bundle.js.
+  // Thus, the __dirname of this code is where we can find the manifest file.
+  const filePath = path.resolve(__dirname, fileName);
+  const loadedJsonFile = loadedJsonFiles.get(filePath);
+  if (loadedJsonFile) {
+    return loadedJsonFile;
+  }
+
+  try {
+    const file = JSON.parse(await fs.readFile(filePath, 'utf8')) as LoadedJsonFile;
+    loadedJsonFiles.set(filePath, file);
+    return file;
+  } catch (error) {
+    console.error(`Failed to load JSON file: ${filePath}`, error);
+    throw error;
+  }
+}
diff --git a/node_package/src/loadReactClientManifest.ts b/node_package/src/loadReactClientManifest.ts
deleted file mode 100644
index 0295c2391..000000000
--- a/node_package/src/loadReactClientManifest.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs/promises';
-
-type ClientManifest = Record<string, unknown>;
-const loadedReactClientManifests = new Map<string, ClientManifest>();
-
-export default async function loadReactClientManifest(reactClientManifestFileName: string) {
-  // React client manifest is uploaded to node renderer as an asset.
-  // Renderer copies assets to the same place as the server-bundle.js and rsc-bundle.js.
-  // Thus, the __dirname of this code is where we can find the manifest file.
-  const manifestPath = path.resolve(__dirname, reactClientManifestFileName);
-  const loadedReactClientManifest = loadedReactClientManifests.get(manifestPath);
-  if (loadedReactClientManifest) {
-    return loadedReactClientManifest;
-  }
-
-  try {
-    const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8')) as ClientManifest;
-    loadedReactClientManifests.set(manifestPath, manifest);
-    return manifest;
-  } catch (error) {
-    throw new Error(`Failed to load React client manifest from ${manifestPath}: ${error}`);
-  }
-}
diff --git a/node_package/src/reactApis.cts b/node_package/src/reactApis.cts
index 45d6cc9a6..d4a258b12 100644
--- a/node_package/src/reactApis.cts
+++ b/node_package/src/reactApis.cts
@@ -1,4 +1,5 @@
 /* eslint-disable global-require,@typescript-eslint/no-require-imports */
+import * as React from 'react';
 import * as ReactDOM from 'react-dom';
 import type { ReactElement } from 'react';
 import type { RenderReturnType } from './types/index.ts' with { 'resolution-mode': 'import' };
@@ -50,3 +51,11 @@ export const unmountComponentAtNode: typeof ReactDOM.unmountComponentAtNode = su
   ? // not used if we use root API
     () => false
   : ReactDOM.unmountComponentAtNode;
+
+export const ensureReactUseAvailable = () => {
+  if (!('use' in React) || typeof React.use !== 'function') {
+    throw new Error(
+      'React.use is not defined. Please ensure you are using React 19 to use server components.',
+    );
+  }
+};
diff --git a/node_package/src/registerServerComponent/server.rsc.ts b/node_package/src/registerServerComponent/server.rsc.ts
new file mode 100644
index 000000000..694193c44
--- /dev/null
+++ b/node_package/src/registerServerComponent/server.rsc.ts
@@ -0,0 +1,25 @@
+import ReactOnRails from '../ReactOnRails.client.ts';
+import { ReactComponent, RenderFunction } from '../types/index.ts';
+
+/**
+ * Registers React Server Components (RSC) with React on Rails for the RSC bundle.
+ *
+ * This function handles the registration of components in the RSC bundle context,
+ * where components are registered directly into the ComponentRegistry without any
+ * additional wrapping. This is different from the server bundle registration,
+ * which wraps components with RSCServerRoot.
+ *
+ * @param components - Object mapping component names to their implementations
+ *
+ * @example
+ * ```js
+ * registerServerComponent({
+ *   ServerComponent1: ServerComponent1Component,
+ *   ServerComponent2: ServerComponent2Component
+ * });
+ * ```
+ */
+const registerServerComponent = (components: { [id: string]: ReactComponent | RenderFunction }) =>
+  ReactOnRails.register(components);
+
+export default registerServerComponent;
diff --git a/node_package/src/registerServerComponent/server.ts b/node_package/src/registerServerComponent/server.ts
index 40d68a1da..d316f89f3 100644
--- a/node_package/src/registerServerComponent/server.ts
+++ b/node_package/src/registerServerComponent/server.ts
@@ -1,24 +1,17 @@
 import ReactOnRails from '../ReactOnRails.client.ts';
-import { ReactComponent } from '../types/index.ts';
+import RSCServerRoot from '../RSCServerRoot.tsx';
+import { ReactComponent, RenderFunction, RailsContext } from '../types/index.ts';
 
 /**
- * Registers React Server Components (RSC) with React on Rails for both server and RSC bundles.
- * Currently, this function behaves identically to ReactOnRails.register, but is introduced to enable
- * future RSC-specific functionality without breaking changes.
+ * Registers React Server Components (RSC) with React on Rails for the server bundle.
  *
- * Future behavior will differ based on bundle type:
+ * This function wraps each component with RSCServerRoot, which handles the server-side
+ * rendering of React Server Components using pre-generated RSC payloads.
  *
- * RSC Bundle:
- * - Components are registered as any other component by adding the component to the ComponentRegistry
- *
- * Server Bundle:
- * - It works like the function defined at `registerServerComponent/client`
- * - The function itself is not added to the ComponentRegistry
- * - Instead, a RSCServerRoot component is added to the ComponentRegistry
- * - This RSCServerRoot component will use the pre-generated RSC payloads from the RSC bundle to
- *   build the rendering tree of the server component instead of rendering it again
- *
- * This functionality is added now without real implementation to avoid breaking changes in the future.
+ * The RSCServerRoot component:
+ * - Uses pre-generated RSC payloads from the RSC bundle
+ * - Builds the rendering tree of the server component
+ * - Handles the integration with React's streaming SSR
  *
  * @param components - Object mapping component names to their implementations
  *
@@ -31,7 +24,14 @@ import { ReactComponent } from '../types/index.ts';
  * ```
  */
 const registerServerComponent = (components: Record<string, ReactComponent>) => {
-  ReactOnRails.register(components);
+  const componentsWrappedInRSCServerRoot: Record<string, RenderFunction> = {};
+  for (const [componentName] of Object.entries(components)) {
+    componentsWrappedInRSCServerRoot[componentName] = (
+      componentProps?: unknown,
+      railsContext?: RailsContext,
+    ) => RSCServerRoot({ componentName, componentProps }, railsContext);
+  }
+  ReactOnRails.register(componentsWrappedInRSCServerRoot);
 };
 
 export default registerServerComponent;
diff --git a/node_package/src/serverRenderReactComponent.ts b/node_package/src/serverRenderReactComponent.ts
index 2327ed7cf..a33bb5c14 100644
--- a/node_package/src/serverRenderReactComponent.ts
+++ b/node_package/src/serverRenderReactComponent.ts
@@ -115,7 +115,7 @@ async function createPromiseResult(
   } catch (e: unknown) {
     const errorRenderState = handleRenderingError(e, { componentName, throwJsErrors });
     const consoleReplayScript = buildConsoleReplay(consoleHistory);
-    return createResultObject(errorRenderState.result, consoleReplayScript, renderState);
+    return createResultObject(errorRenderState.result, consoleReplayScript, errorRenderState);
   }
 }
 
diff --git a/node_package/src/streamServerRenderedReactComponent.ts b/node_package/src/streamServerRenderedReactComponent.ts
index c57229c7f..1519f6e44 100644
--- a/node_package/src/streamServerRenderedReactComponent.ts
+++ b/node_package/src/streamServerRenderedReactComponent.ts
@@ -87,16 +87,47 @@ export const transformRenderStreamChunksToResultObject = (renderState: StreamRen
   const consoleHistory = console.history;
   let previouslyReplayedConsoleMessages = 0;
 
+  let consoleReplayTimeoutId: NodeJS.Timeout;
+  const buildConsoleReplayChunk = () => {
+    const consoleReplayScript = buildConsoleReplay(consoleHistory, previouslyReplayedConsoleMessages);
+    previouslyReplayedConsoleMessages = consoleHistory?.length || 0;
+    if (consoleReplayScript.length === 0) {
+      return null;
+    }
+    const consoleReplayJsonChunk = JSON.stringify(createResultObject('', consoleReplayScript, renderState));
+    return consoleReplayJsonChunk;
+  };
+
   const transformStream = new PassThrough({
     transform(chunk, _, callback) {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
       const htmlChunk = chunk.toString() as string;
-      const consoleReplayScript = buildConsoleReplay(consoleHistory, previouslyReplayedConsoleMessages);
-      previouslyReplayedConsoleMessages = consoleHistory?.length || 0;
+      const jsonChunk = JSON.stringify(createResultObject(htmlChunk, '', renderState));
+      this.push(`${jsonChunk}\n`);
+
+      // Reset the render state to ensure that the error is not carried over to the next chunk
+      // eslint-disable-next-line no-param-reassign
+      renderState.error = undefined;
+      // eslint-disable-next-line no-param-reassign
+      renderState.hasErrors = false;
+
+      clearTimeout(consoleReplayTimeoutId);
+      consoleReplayTimeoutId = setTimeout(() => {
+        const consoleReplayChunk = buildConsoleReplayChunk();
+        if (consoleReplayChunk) {
+          this.push(`${consoleReplayChunk}\n`);
+        }
+      }, 0);
 
-      const jsonChunk = JSON.stringify(createResultObject(htmlChunk, consoleReplayScript, renderState));
+      callback();
+    },
 
-      this.push(`${jsonChunk}\n`);
+    flush(callback) {
+      clearTimeout(consoleReplayTimeoutId);
+      const consoleReplayChunk = buildConsoleReplayChunk();
+      if (consoleReplayChunk) {
+        this.push(`${consoleReplayChunk}\n`);
+      }
       callback();
     },
   });
diff --git a/node_package/src/transformRSCNodeStream.ts b/node_package/src/transformRSCNodeStream.ts
new file mode 100644
index 000000000..d40e10359
--- /dev/null
+++ b/node_package/src/transformRSCNodeStream.ts
@@ -0,0 +1,31 @@
+import { Transform } from 'stream';
+
+export default function transformRSCStream(stream: NodeJS.ReadableStream): NodeJS.ReadableStream {
+  const decoder = new TextDecoder();
+  let lastIncompleteChunk = '';
+
+  const htmlExtractor = new Transform({
+    transform(oneOrMoreChunks, _, callback) {
+      try {
+        const decodedChunk = lastIncompleteChunk + decoder.decode(oneOrMoreChunks as Uint8Array);
+        const separateChunks = decodedChunk.split('\n').filter((chunk) => chunk.trim() !== '');
+
+        if (!decodedChunk.endsWith('\n')) {
+          lastIncompleteChunk = separateChunks.pop() ?? '';
+        } else {
+          lastIncompleteChunk = '';
+        }
+
+        for (const chunk of separateChunks) {
+          const parsedData = JSON.parse(chunk) as { html: string };
+          this.push(parsedData.html);
+        }
+        callback();
+      } catch (error) {
+        callback(error as Error);
+      }
+    },
+  });
+
+  return stream.pipe(htmlExtractor);
+}
diff --git a/node_package/src/transformRSCStreamAndReplayConsoleLogs.ts b/node_package/src/transformRSCStreamAndReplayConsoleLogs.ts
index 92c25d724..91131e9b0 100644
--- a/node_package/src/transformRSCStreamAndReplayConsoleLogs.ts
+++ b/node_package/src/transformRSCStreamAndReplayConsoleLogs.ts
@@ -1,6 +1,8 @@
 import { RSCPayloadChunk } from './types/index.ts';
 
-export default function transformRSCStreamAndReplayConsoleLogs(stream: ReadableStream<Uint8Array>) {
+export default function transformRSCStreamAndReplayConsoleLogs(
+  stream: ReadableStream<Uint8Array | RSCPayloadChunk>,
+) {
   return new ReadableStream({
     async start(controller) {
       const reader = stream.getReader();
@@ -9,35 +11,44 @@ export default function transformRSCStreamAndReplayConsoleLogs(stream: ReadableS
 
       let lastIncompleteChunk = '';
       let { value, done } = await reader.read();
+
+      const handleJsonChunk = (chunk: RSCPayloadChunk) => {
+        const { html, consoleReplayScript = '' } = chunk;
+        controller.enqueue(encoder.encode(html ?? ''));
+
+        const replayConsoleCode = consoleReplayScript
+          .trim()
+          .replace(/^<script.*>/, '')
+          .replace(/<\/script>$/, '');
+        if (replayConsoleCode?.trim() !== '') {
+          const scriptElement = document.createElement('script');
+          scriptElement.textContent = replayConsoleCode;
+          document.body.appendChild(scriptElement);
+        }
+      };
+
       while (!done) {
-        const decodedValue = lastIncompleteChunk + decoder.decode(value);
-        const chunks = decodedValue.split('\n');
-        lastIncompleteChunk = chunks.pop() ?? '';
-
-        const jsonChunks = chunks
-          .filter((line) => line.trim() !== '')
-          .map((line) => {
-            try {
-              return JSON.parse(line) as RSCPayloadChunk;
-            } catch (error) {
-              console.error('Error parsing JSON:', line, error);
-              throw error;
-            }
-          });
-
-        for (const jsonChunk of jsonChunks) {
-          const { html, consoleReplayScript = '' } = jsonChunk;
-          controller.enqueue(encoder.encode(html ?? ''));
-
-          const replayConsoleCode = consoleReplayScript
-            .trim()
-            .replace(/^<script.*>/, '')
-            .replace(/<\/script>$/, '');
-          if (replayConsoleCode?.trim() !== '') {
-            const scriptElement = document.createElement('script');
-            scriptElement.textContent = replayConsoleCode;
-            document.body.appendChild(scriptElement);
+        if (ArrayBuffer.isView(value)) {
+          const decodedValue = lastIncompleteChunk + decoder.decode(value);
+          const chunks = decodedValue.split('\n');
+          lastIncompleteChunk = chunks.pop() ?? '';
+
+          const jsonChunks = chunks
+            .filter((line) => line.trim() !== '')
+            .map((line) => {
+              try {
+                return JSON.parse(line) as RSCPayloadChunk;
+              } catch (error) {
+                console.error('Error parsing JSON:', line, error);
+                throw error;
+              }
+            });
+
+          for (const jsonChunk of jsonChunks) {
+            handleJsonChunk(jsonChunk);
           }
+        } else if (value) {
+          handleJsonChunk(value);
         }
 
         // eslint-disable-next-line no-await-in-loop
diff --git a/node_package/src/types/index.ts b/node_package/src/types/index.ts
index 16a8a8897..4d13a27bc 100644
--- a/node_package/src/types/index.ts
+++ b/node_package/src/types/index.ts
@@ -17,7 +17,7 @@ type Store = {
 type ReactComponent = ComponentType<any> | string;
 
 // Keep these in sync with method lib/react_on_rails/helper.rb#rails_context
-export interface RailsContext {
+export type RailsContext = {
   componentRegistryTimeout: number;
   railsEnv: string;
   inMailer: boolean;
@@ -26,7 +26,6 @@ export interface RailsContext {
   rorVersion: string;
   rorPro: boolean;
   rorProVersion?: string;
-  serverSide: boolean;
   href: string;
   location: string;
   scheme: string;
@@ -35,7 +34,24 @@ export interface RailsContext {
   pathname: string;
   search: string | null;
   httpAcceptLanguage: string;
-}
+  rscPayloadGenerationUrl?: string;
+} & (
+  | {
+      serverSide: false;
+    }
+  | {
+      serverSide: true;
+      // These parameters are passed from React on Rails Pro to the node renderer.
+      // They contain the necessary information to generate the RSC (React Server Components) payload.
+      // Typically, this includes the bundle hash of the RSC bundle.
+      // The react-on-rails package uses 'unknown' for these parameters to avoid direct dependency.
+      // This ensures that if the communication protocol between the node renderer and the Rails server changes,
+      // we don't need to update this type or introduce a breaking change.
+      serverSideRSCPayloadParameters: unknown;
+      reactClientManifestFileName?: string;
+      reactServerClientManifestFileName?: string;
+    }
+);
 
 // not strictly what we want, see https://github.com/microsoft/TypeScript/issues/17867#issuecomment-323164375
 type AuthenticityHeaders = Record<string, string> & {
@@ -376,6 +392,10 @@ export interface ReactOnRailsInternal extends ReactOnRails {
    * Current options.
    */
   options: ReactOnRailsOptions;
+  /**
+   * Indicates if the RSC bundle is being used.
+   */
+  isRSCBundle: boolean;
 }
 
 export type RenderStateHtml = FinalHtmlResult | Promise<FinalHtmlResult>;
diff --git a/package.json b/package.json
index c380453a2..872632fde 100644
--- a/package.json
+++ b/package.json
@@ -12,7 +12,10 @@
     },
     "./client": "./node_package/lib/ReactOnRails.client.js",
     "./registerServerComponent/client": "./node_package/lib/registerServerComponent/client.js",
-    "./registerServerComponent/server": "./node_package/lib/registerServerComponent/server.js"
+    "./registerServerComponent/server": {
+      "react-server": "./node_package/lib/registerServerComponent/server.rsc.js",
+      "default": "./node_package/lib/registerServerComponent/server.js"
+    }
   },
   "directories": {
     "doc": "docs"
@@ -57,7 +60,7 @@
     "publint": "^0.3.8",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "react-on-rails-rsc": "19.0.0",
+    "react-on-rails-rsc": "git+https://github.com/shakacode/react_on_rails_rsc.git#add-support-for-generating-client-components-manifest-for-server-bundle",
     "redux": "^4.2.1",
     "ts-jest": "^29.2.5",
     "typescript": "^5.8.3"
@@ -65,7 +68,7 @@
   "peerDependencies": {
     "react": ">= 16",
     "react-dom": ">= 16",
-    "react-on-rails-rsc": "19.0.0"
+    "react-on-rails-rsc": "git+https://github.com/shakacode/react_on_rails_rsc.git#add-support-for-generating-client-components-manifest-for-server-bundle"
   },
   "files": [
     "node_package/lib"
diff --git a/yarn.lock b/yarn.lock
index 4f675bbba..a1b9d188d 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5222,17 +5222,9 @@ react-is@^18.0.0:
   resolved "https://registry.yarnpkg.com/react-is/-/react-is-18.2.0.tgz#199431eeaaa2e09f86427efbb4f1473edb47609b"
   integrity sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==
 
-react-on-rails-rsc@19.0.0:
-  version "19.0.0"
-  resolved "https://registry.yarnpkg.com/react-on-rails-rsc/-/react-on-rails-rsc-19.0.0.tgz#0061d8f3eb7cdf12a23c66985212f46e3e2ed2ef"
-  integrity sha512-70K46d9Zs071VgUNxZLz0ModMkPRKpSCu5XiICd/8ChMdivSyxdHEZzY4GSiztQnizzKFX7k25N0EIv/DmUPNg==
-  dependencies:
-    react-server-dom-webpack "19.0.0"
-
-react-server-dom-webpack@19.0.0:
-  version "19.0.0"
-  resolved "https://registry.yarnpkg.com/react-server-dom-webpack/-/react-server-dom-webpack-19.0.0.tgz#c60819b6cb54e317e675ddc0c5959ff915b789d0"
-  integrity sha512-hLug9KEXLc8vnU9lDNe2b2rKKDaqrp5gNiES4uyu2Up3FZfZJZmdwLFXlWzdA9gTB/6/cWduSB2K1Lfag2pSvw==
+"react-on-rails-rsc@git+https://github.com/shakacode/react_on_rails_rsc.git#add-support-for-generating-client-components-manifest-for-server-bundle":
+  version "19.0.0-rc.2"
+  resolved "git+https://github.com/shakacode/react_on_rails_rsc.git#f49dc3fd94629ff23c1c6a397b19b6feff437b2f"
   dependencies:
     acorn-loose "^8.3.0"
     neo-async "^2.6.1"