react-on-rails-pro 16.6.0 → 16.7.0-rc.0

package/README.md

@@ -1,6 +1,6 @@
 # react-on-rails-pro
 
-The client-side JavaScript package for [React on Rails Pro](https://github.com/shakacode/react_on_rails). This package **replaces** the base `react-on-rails` package and re-exports everything from it, plus Pro-exclusive features like React Server Components support.
+The client-side JavaScript package for [React on Rails Pro](https://reactonrails.com/docs/pro/). This package **replaces** the base `react-on-rails` package and re-exports everything from it, plus Pro-exclusive features like React Server Components support.
 
 ## Installation
 
@@ -14,6 +14,8 @@ pnpm add react-on-rails-pro
 
 **Important:** When using the `react_on_rails_pro` Ruby gem, you **must** use this package (`react-on-rails-pro`) instead of `react-on-rails`. If the Pro gem detects the base `react-on-rails` npm package at runtime, it will raise an error.
 
+React on Rails Pro is free to evaluate in development, CI/CD, and staging. A paid license is required only for production deployments.
+
 ## Usage
 
 ### Component Registration
@@ -90,7 +92,8 @@ See the [full installation guide](https://reactonrails.com/docs/pro/installation
 - [Installation Guide](https://reactonrails.com/docs/pro/installation)
 - [Configuration Reference](https://reactonrails.com/docs/configuration/configuration-pro)
 - [React Server Components Tutorial](https://reactonrails.com/docs/pro/react-server-components/tutorial)
-- [React on Rails Pro Overview](https://pro.reactonrails.com/)
+- [Upgrade from OSS to Pro](https://reactonrails.com/docs/pro/upgrading-to-pro/)
+- [React on Rails Pro Overview](https://reactonrails.com/docs/pro/)
 
 ## License
 

package/lib/AsyncPropsManager.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Manages async props for incremental server-side rendering.
+ *
+ * DESIGN PRINCIPLES:
+ *
+ * 1. PROMISE CACHING: Same promise is returned for multiple getProp() calls.
+ *    This is CRITICAL for React's rendering model - if we returned new promises,
+ *    React would create infinite render loops or flicker as each render would
+ *    get a different promise object.
+ *
+ * 2. ORDER INDEPENDENCE: Props can be set before or after they're requested.
+ *    - If getProp() is called first: Creates promise, suspends, later setProp() resolves it
+ *    - If setProp() is called first: Creates resolved promise, getProp() returns immediately
+ *
+ * 3. STREAM LIFECYCLE: endStream() rejects all unresolved props.
+ *    This handles the case where the HTTP request closes before all props arrive,
+ *    allowing React to show error boundaries instead of hanging forever.
+ *
+ * USAGE FLOW:
+ * 1. ServerRenderingJsCode calls addAsyncPropsCapabilityToComponentProps()
+ * 2. Component calls getReactOnRailsAsyncProp("propName") → getProp() returns promise
+ * 3. React suspends on the promise
+ * 4. Rails sends update chunk → setProp("propName", value) → promise resolves
+ * 5. React resumes rendering with the value
+ *
+ * @example
+ * // Inside a React Server Component
+ * async function MyComponent({ getReactOnRailsAsyncProp }) {
+ *   const users = await getReactOnRailsAsyncProp('users');
+ *   return <UserList users={users} />;
+ * }
+ */
+declare class AsyncPropsManager {
+    private isClosed;
+    private propNameToPromiseController;
+    /**
+     * Gets the promise for an async prop. Returns the SAME promise on repeated calls.
+     *
+     * IMPORTANT: This is not an async function intentionally.
+     * Returning the same Promise object on every call is required for React's
+     * concurrent rendering - new promises would cause re-renders.
+     */
+    getProp(propName: string): Promise<unknown>;
+    setProp(propName: string, propValue: unknown): void;
+    endStream(): void;
+    private getOrCreatePromiseController;
+    private static getNoPropFoundError;
+}
+/**
+ * Gets or creates an AsyncPropsManager from the shared execution context.
+ *
+ * This function implements lazy initialization to handle race conditions between
+ * the initial render request and update chunks. Whichever executes first will
+ * create the manager, and subsequent calls will reuse the same instance.
+ *
+ * @param sharedExecutionContext - Map scoped to the current HTTP request
+ * @returns The AsyncPropsManager instance (existing or newly created)
+ */
+export declare function getOrCreateAsyncPropsManager(sharedExecutionContext: Map<string, unknown>): AsyncPropsManager;
+export default AsyncPropsManager;
+//# sourceMappingURL=AsyncPropsManager.d.ts.map

package/lib/AsyncPropsManager.js

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2025 Shakacode LLC
+ *
+ * This file is NOT licensed under the MIT (open source) license.
+ * It is part of the React on Rails Pro offering and is licensed separately.
+ *
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without a valid license agreement
+ * from Shakacode LLC.
+ *
+ * For licensing terms, please see:
+ * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
+ */
+/**
+ * Manages async props for incremental server-side rendering.
+ *
+ * DESIGN PRINCIPLES:
+ *
+ * 1. PROMISE CACHING: Same promise is returned for multiple getProp() calls.
+ *    This is CRITICAL for React's rendering model - if we returned new promises,
+ *    React would create infinite render loops or flicker as each render would
+ *    get a different promise object.
+ *
+ * 2. ORDER INDEPENDENCE: Props can be set before or after they're requested.
+ *    - If getProp() is called first: Creates promise, suspends, later setProp() resolves it
+ *    - If setProp() is called first: Creates resolved promise, getProp() returns immediately
+ *
+ * 3. STREAM LIFECYCLE: endStream() rejects all unresolved props.
+ *    This handles the case where the HTTP request closes before all props arrive,
+ *    allowing React to show error boundaries instead of hanging forever.
+ *
+ * USAGE FLOW:
+ * 1. ServerRenderingJsCode calls addAsyncPropsCapabilityToComponentProps()
+ * 2. Component calls getReactOnRailsAsyncProp("propName") → getProp() returns promise
+ * 3. React suspends on the promise
+ * 4. Rails sends update chunk → setProp("propName", value) → promise resolves
+ * 5. React resumes rendering with the value
+ *
+ * @example
+ * // Inside a React Server Component
+ * async function MyComponent({ getReactOnRailsAsyncProp }) {
+ *   const users = await getReactOnRailsAsyncProp('users');
+ *   return <UserList users={users} />;
+ * }
+ */
+class AsyncPropsManager {
+    constructor() {
+        this.isClosed = false;
+        this.propNameToPromiseController = new Map();
+    }
+    /**
+     * Gets the promise for an async prop. Returns the SAME promise on repeated calls.
+     *
+     * IMPORTANT: This is not an async function intentionally.
+     * Returning the same Promise object on every call is required for React's
+     * concurrent rendering - new promises would cause re-renders.
+     */
+    getProp(propName) {
+        const promiseController = this.getOrCreatePromiseController(propName);
+        if (!promiseController) {
+            return Promise.reject(AsyncPropsManager.getNoPropFoundError(propName));
+        }
+        return promiseController.promise;
+    }
+    setProp(propName, propValue) {
+        const promiseController = this.getOrCreatePromiseController(propName);
+        if (!promiseController) {
+            throw new Error(`Can't set the async prop "${propName}" because the stream is already closed`);
+        }
+        promiseController.resolve(propValue);
+        promiseController.resolved = true;
+    }
+    endStream() {
+        if (this.isClosed) {
+            return;
+        }
+        this.isClosed = true;
+        this.propNameToPromiseController.forEach((promiseController, propName) => {
+            if (!promiseController.resolved) {
+                promiseController.reject(AsyncPropsManager.getNoPropFoundError(propName));
+            }
+        });
+    }
+    getOrCreatePromiseController(propName) {
+        const promiseController = this.propNameToPromiseController.get(propName);
+        if (promiseController) {
+            return promiseController;
+        }
+        if (this.isClosed) {
+            return undefined;
+        }
+        const partialPromiseController = {
+            resolved: false,
+        };
+        let resolvePromise = () => { };
+        let rejectPromise = () => { };
+        const promise = new Promise((resolve, reject) => {
+            resolvePromise = resolve;
+            rejectPromise = reject;
+        });
+        const newPromiseController = Object.assign(partialPromiseController, {
+            promise,
+            resolve: resolvePromise,
+            reject: rejectPromise,
+        });
+        this.propNameToPromiseController.set(propName, newPromiseController);
+        return newPromiseController;
+    }
+    static getNoPropFoundError(propName) {
+        return new Error(`The async prop "${propName}" is not received. Ensure to send the async prop from ruby side`);
+    }
+}
+const ASYNC_PROPS_MANAGER_KEY = 'asyncPropsManager';
+/**
+ * Gets or creates an AsyncPropsManager from the shared execution context.
+ *
+ * This function implements lazy initialization to handle race conditions between
+ * the initial render request and update chunks. Whichever executes first will
+ * create the manager, and subsequent calls will reuse the same instance.
+ *
+ * @param sharedExecutionContext - Map scoped to the current HTTP request
+ * @returns The AsyncPropsManager instance (existing or newly created)
+ */
+export function getOrCreateAsyncPropsManager(sharedExecutionContext) {
+    let manager = sharedExecutionContext.get(ASYNC_PROPS_MANAGER_KEY);
+    if (manager) {
+        return manager;
+    }
+    manager = new AsyncPropsManager();
+    sharedExecutionContext.set(ASYNC_PROPS_MANAGER_KEY, manager);
+    return manager;
+}
+export default AsyncPropsManager;
+//# sourceMappingURL=AsyncPropsManager.js.map

package/lib/RSCRequestTracker.d.ts

@@ -1,16 +1,4 @@
-import { RSCPayloadStreamInfo, RSCPayloadCallback, RailsContextWithServerComponentMetadata } from 'react-on-rails/types';
-/**
- * Global function provided by React on Rails Pro for generating RSC payloads.
- *
- * This function is injected into the global scope during server-side rendering
- * by the RORP rendering request. It handles the actual generation of React Server
- * Component payloads on the server side.
- *
- * @see https://github.com/shakacode/react_on_rails_pro/blob/master/lib/react_on_rails_pro/server_rendering_js_code.rb
- */
-declare global {
-    function generateRSCPayload(componentName: string, props: unknown, railsContext: RailsContextWithServerComponentMetadata): Promise<NodeJS.ReadableStream>;
-}
+import { RSCPayloadStreamInfo, RSCPayloadCallback, RailsContextWithServerComponentMetadata, GenerateRSCPayloadFunction } from 'react-on-rails/types';
 /**
  * RSC Request Tracker - manages RSC payload generation and tracking for a single request.
  *
@@ -23,7 +11,8 @@ declare class RSCRequestTracker {
     private streams;
     private callbacks;
     private railsContext;
-    constructor(railsContext: RailsContextWithServerComponentMetadata);
+    private generateRSCPayload?;
+    constructor(railsContext: RailsContextWithServerComponentMetadata, generateRSCPayload?: GenerateRSCPayloadFunction);
     /**
      * Clears all streams and callbacks for this request.
      * Should be called when the request is complete to ensure proper cleanup,

package/lib/RSCRequestTracker.js

@@ -22,10 +22,11 @@ import { extractErrorMessage } from "./utils.js";
  * functionality for components.
  */
 class RSCRequestTracker {
-    constructor(railsContext) {
+    constructor(railsContext, generateRSCPayload) {
         this.streams = [];
         this.callbacks = [];
         this.railsContext = railsContext;
+        this.generateRSCPayload = generateRSCPayload;
     }
     /**
      * Clears all streams and callbacks for this request.
@@ -85,14 +86,14 @@ class RSCRequestTracker {
      * @throws Error if generateRSCPayload is not available or fails
      */
     async getRSCPayloadStream(componentName, props) {
-        // Validate that the global generateRSCPayload function is available
-        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.');
+        // Validate that the generateRSCPayload function is available
+        if (!this.generateRSCPayload) {
+            throw new Error('generateRSCPayload function is not available. This could mean: ' +
+                '(1) ReactOnRailsPro.configuration.enable_rsc_support is not enabled, or ' +
+                '(2) You are using an incompatible version of React on Rails Pro (requires 4.0.0+).');
         }
         try {
-            const stream = await generateRSCPayload(componentName, props, this.railsContext);
+            const stream = await this.generateRSCPayload(componentName, props, this.railsContext);
             // Tee stream to allow for multiple consumers:
             //   1. stream1 - Used by React's runtime to perform server-side rendering
             //   2. stream2 - Used by react-on-rails to embed the RSC payloads

package/lib/ReactOnRails.client.js

@@ -11,10 +11,9 @@
  * For licensing terms, please see:
  * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
  */
-import { createBaseClientObject } from 'react-on-rails/@internal/base/client';
 import createReactOnRailsPro from "./createReactOnRailsPro.js";
 const currentGlobal = globalThis.ReactOnRails || null;
-const ReactOnRails = createReactOnRailsPro(createBaseClientObject, currentGlobal);
+const ReactOnRails = createReactOnRailsPro([], currentGlobal);
 export * from 'react-on-rails/types';
 export default ReactOnRails;
 //# sourceMappingURL=ReactOnRails.client.js.map

package/lib/ReactOnRails.full.js

@@ -11,16 +11,10 @@
  * For licensing terms, please see:
  * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
  */
-import { createBaseFullObject } from 'react-on-rails/@internal/base/full';
+import { createSSRCapability } from 'react-on-rails/@internal/capabilities/ssr';
 import createReactOnRailsPro from "./createReactOnRailsPro.js";
-// Warn about bundle size when included in browser bundles
-if (typeof window !== 'undefined') {
-    console.warn('Optimization opportunity: "react-on-rails-pro" includes ~14KB of server-rendering code. ' +
-        'Browsers may not need it. See https://forum.shakacode.com/t/how-to-use-different-versions-of-a-file-for-client-and-server-rendering/1352 ' +
-        '(Requires creating a free account). Click this for the stack trace.');
-}
 const currentGlobal = globalThis.ReactOnRails || null;
-const ReactOnRails = createReactOnRailsPro(createBaseFullObject, currentGlobal);
+const ReactOnRails = createReactOnRailsPro([createSSRCapability()], currentGlobal);
 export * from 'react-on-rails/types';
 export default ReactOnRails;
 //# sourceMappingURL=ReactOnRails.full.js.map

package/lib/ReactOnRails.node.d.ts

@@ -1,3 +1,4 @@
-export * from './ReactOnRails.full.ts';
-export { default } from './ReactOnRails.full.ts';
+declare const ReactOnRails: import("react-on-rails/types").ReactOnRailsInternal;
+export * from 'react-on-rails/types';
+export default ReactOnRails;
 //# sourceMappingURL=ReactOnRails.node.d.ts.map

package/lib/ReactOnRails.node.js

@@ -11,11 +11,11 @@
  * For licensing terms, please see:
  * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
  */
-import ReactOnRails from "./ReactOnRails.full.js";
-import streamServerRenderedReactComponent from "./streamServerRenderedReactComponent.js";
-// Add Pro server-side streaming functionality
-ReactOnRails.streamServerRenderedReactComponent = streamServerRenderedReactComponent;
-export * from "./ReactOnRails.full.js";
-// eslint-disable-next-line no-restricted-exports -- see https://github.com/eslint/eslint/issues/15617
-export { default } from "./ReactOnRails.full.js";
+import { createSSRCapability } from 'react-on-rails/@internal/capabilities/ssr';
+import { createProStreamingCapability } from "./capabilities/proStreaming.js";
+import createReactOnRailsPro from "./createReactOnRailsPro.js";
+const currentGlobal = globalThis.ReactOnRails || null;
+const ReactOnRails = createReactOnRailsPro([createSSRCapability(), createProStreamingCapability()], currentGlobal);
+export * from 'react-on-rails/types';
+export default ReactOnRails;
 //# sourceMappingURL=ReactOnRails.node.js.map

package/lib/ReactOnRailsRSC.d.ts

@@ -1,4 +1,4 @@
-import ReactOnRails from './ReactOnRails.full.ts';
+declare const ReactOnRails: import("react-on-rails/types").ReactOnRailsInternal;
 export * from 'react-on-rails/types';
 export default ReactOnRails;
 //# sourceMappingURL=ReactOnRailsRSC.d.ts.map

package/lib/ReactOnRailsRSC.js

@@ -11,71 +11,11 @@
  * For licensing terms, please see:
  * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
  */
-import { buildServerRenderer } from 'react-on-rails-rsc/server.node';
-import { assertRailsContextWithServerStreamingCapabilities, } from 'react-on-rails/types';
-import { convertToError } from 'react-on-rails/serverRenderUtils';
-import handleError from "./handleErrorRSC.js";
-import ReactOnRails from "./ReactOnRails.full.js";
-import { streamServerRenderedComponent, transformRenderStreamChunksToResultObject, } from "./streamingUtils.js";
-import loadJsonFile from "./loadJsonFile.js";
-let serverRendererPromise;
-const streamRenderRSCComponent = (reactRenderingResult, options, streamingTrackers) => {
-    const { throwJsErrors } = options;
-    const { railsContext } = options;
-    assertRailsContextWithServerStreamingCapabilities(railsContext);
-    const { reactClientManifestFileName } = railsContext;
-    const renderState = {
-        result: null,
-        hasErrors: false,
-        isShellReady: true,
-    };
-    const { pipeToTransform, readableStream, emitError } = transformRenderStreamChunksToResultObject(renderState);
-    const reportError = (error) => {
-        console.error('Error in RSC stream', error);
-        if (throwJsErrors) {
-            emitError(error);
-        }
-        renderState.hasErrors = true;
-        renderState.error = error;
-    };
-    const initializeAndRender = async () => {
-        if (!serverRendererPromise) {
-            serverRendererPromise = loadJsonFile(reactClientManifestFileName)
-                .then((reactClientManifest) => buildServerRenderer(reactClientManifest))
-                .catch((err) => {
-                serverRendererPromise = undefined;
-                throw err;
-            });
-        }
-        const { renderToPipeableStream } = await serverRendererPromise;
-        const rscStream = renderToPipeableStream(await reactRenderingResult, {
-            onError: (err) => {
-                const error = convertToError(err);
-                reportError(error);
-            },
-        });
-        pipeToTransform(rscStream);
-    };
-    initializeAndRender().catch((e) => {
-        const error = convertToError(e);
-        reportError(error);
-        const errorHtml = handleError({ e: error, name: options.name, serverSide: true });
-        pipeToTransform(errorHtml);
-    });
-    readableStream.on('end', () => {
-        streamingTrackers.postSSRHookTracker.notifySSREnd();
-    });
-    return readableStream;
-};
-ReactOnRails.serverRenderRSCReactComponent = (options) => {
-    try {
-        return streamServerRenderedComponent(options, streamRenderRSCComponent, handleError);
-    }
-    finally {
-        console.history = [];
-    }
-};
-ReactOnRails.isRSCBundle = true;
+import { createSSRCapability } from 'react-on-rails/@internal/capabilities/ssr';
+import { createProRSCCapability } from "./capabilities/proRSC.js";
+import createReactOnRailsPro from "./createReactOnRailsPro.js";
+const currentGlobal = globalThis.ReactOnRails || null;
+const ReactOnRails = createReactOnRailsPro([createSSRCapability(), createProRSCCapability()], currentGlobal);
 export * from 'react-on-rails/types';
 export default ReactOnRails;
 //# sourceMappingURL=ReactOnRailsRSC.js.map

package/lib/capabilities/proLifecycle.d.ts

@@ -0,0 +1,12 @@
+/** Shared implementation used by both the capability object and proClientStartup. */
+export declare function reactOnRailsPageLoaded(): Promise<void>;
+/**
+ * Pro lifecycle capability.
+ * Overrides core lifecycle with Pro implementations that support hydration
+ * and on-demand rendering.
+ */
+export declare function createProLifecycleCapability(): {
+    reactOnRailsPageLoaded: typeof reactOnRailsPageLoaded;
+    reactOnRailsComponentLoaded(domId: string): Promise<void>;
+};
+//# sourceMappingURL=proLifecycle.d.ts.map

package/lib/capabilities/proLifecycle.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2025 Shakacode LLC
+ *
+ * This file is NOT licensed under the MIT (open source) license.
+ * It is part of the React on Rails Pro offering and is licensed separately.
+ *
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without a valid license agreement
+ * from Shakacode LLC.
+ *
+ * For licensing terms, please see:
+ * https://github.com/shakacode/react_on_rails/blob/master/REACT-ON-RAILS-PRO-LICENSE.md
+ */
+import { debugTurbolinks } from 'react-on-rails/turbolinksUtils';
+import { renderOrHydrateComponent, renderOrHydrateAllComponents, hydrateAllStores, } from "../ClientSideRenderer.js";
+/** Shared implementation used by both the capability object and proClientStartup. */
+export async function reactOnRailsPageLoaded() {
+    debugTurbolinks('reactOnRailsPageLoaded [PRO]');
+    await Promise.all([hydrateAllStores(), renderOrHydrateAllComponents()]);
+}
+/**
+ * Pro lifecycle capability.
+ * Overrides core lifecycle with Pro implementations that support hydration
+ * and on-demand rendering.
+ */
+export function createProLifecycleCapability() {
+    return {
+        reactOnRailsPageLoaded,
+        reactOnRailsComponentLoaded(domId) {
+            return renderOrHydrateComponent(domId);
+        },
+    };
+}
+//# sourceMappingURL=proLifecycle.js.map

package/lib/capabilities/proMethods.d.ts

@@ -0,0 +1,12 @@
+import type { RegisteredComponent, Store, StoreGenerator } from 'react-on-rails/types';
+/**
+ * Pro methods capability.
+ * Provides Pro-only features: async component/store access and store hydration.
+ */
+export declare function createProMethodCapability(): {
+    getOrWaitForComponent(name: string): Promise<RegisteredComponent>;
+    getOrWaitForStore(name: string): Promise<Store>;
+    getOrWaitForStoreGenerator(name: string): Promise<StoreGenerator>;
+    reactOnRailsStoreLoaded(storeName: string): Promise<void>;
+};
+//# sourceMappingURL=proMethods.d.ts.map

package/lib/capabilities/proMethods.js

@@ -0,0 +1,25 @@
+/* eslint-disable import/prefer-default-export -- named export for consistency with capability API */
+import * as ProComponentRegistry from "../ComponentRegistry.js";
+import * as ProStoreRegistry from "../StoreRegistry.js";
+import { hydrateStore } from "../ClientSideRenderer.js";
+/**
+ * Pro methods capability.
+ * Provides Pro-only features: async component/store access and store hydration.
+ */
+export function createProMethodCapability() {
+    return {
+        getOrWaitForComponent(name) {
+            return ProComponentRegistry.getOrWaitForComponent(name);
+        },
+        getOrWaitForStore(name) {
+            return ProStoreRegistry.getOrWaitForStore(name);
+        },
+        getOrWaitForStoreGenerator(name) {
+            return ProStoreRegistry.getOrWaitForStoreGenerator(name);
+        },
+        reactOnRailsStoreLoaded(storeName) {
+            return hydrateStore(storeName);
+        },
+    };
+}
+//# sourceMappingURL=proMethods.js.map

package/lib/capabilities/proRSC.d.ts

@@ -0,0 +1,17 @@
+import { Readable } from 'stream';
+import { RSCRenderParams } from 'react-on-rails/types';
+/**
+ * Pro RSC capability.
+ * Provides React Server Components rendering support.
+ */
+export declare function createProRSCCapability(): {
+    isRSCBundle: true;
+    serverRenderRSCReactComponent(options: RSCRenderParams): Readable;
+    addAsyncPropsCapabilityToComponentProps<AsyncPropsType extends Record<string, unknown>, PropsType extends Record<string, unknown>>(props: PropsType, sharedExecutionContext: Map<string, unknown>): {
+        props: PropsType & {
+            getReactOnRailsAsyncProp: <PropName extends keyof AsyncPropsType>(propName: PropName) => Promise<AsyncPropsType[PropName]>;
+        };
+    };
+    getOrCreateAsyncPropsManager(sharedExecutionContext: Map<string, unknown>): import("../AsyncPropsManager.ts").default;
+};
+//# sourceMappingURL=proRSC.d.ts.map

package/lib/capabilities/proRSC.js

@@ -0,0 +1,88 @@
+/* eslint-disable import/prefer-default-export -- named export for consistency with capability API */
+import { buildServerRenderer } from 'react-on-rails-rsc/server.node';
+import { assertRailsContextWithServerStreamingCapabilities, } from 'react-on-rails/types';
+import { convertToError } from 'react-on-rails/serverRenderUtils';
+import handleError from "../handleErrorRSC.js";
+import { getOrCreateAsyncPropsManager } from "../AsyncPropsManager.js";
+import { streamServerRenderedComponent, transformRenderStreamChunksToResultObject, } from "../streamingUtils.js";
+import loadJsonFile from "../loadJsonFile.js";
+let serverRendererPromise;
+const streamRenderRSCComponent = (reactRenderingResult, options, streamingTrackers) => {
+    const { throwJsErrors } = options;
+    const { railsContext } = options;
+    assertRailsContextWithServerStreamingCapabilities(railsContext);
+    const { reactClientManifestFileName } = railsContext;
+    const renderState = {
+        result: null,
+        hasErrors: false,
+        isShellReady: true,
+    };
+    const { pipeToTransform, readableStream, emitError } = transformRenderStreamChunksToResultObject(renderState);
+    const reportError = (error) => {
+        console.error('Error in RSC stream', error);
+        if (throwJsErrors) {
+            emitError(error);
+        }
+        renderState.hasErrors = true;
+        renderState.error = error;
+    };
+    const initializeAndRender = async () => {
+        if (!serverRendererPromise) {
+            serverRendererPromise = loadJsonFile(reactClientManifestFileName)
+                .then((reactClientManifest) => buildServerRenderer(reactClientManifest))
+                .catch((err) => {
+                serverRendererPromise = undefined;
+                throw err;
+            });
+        }
+        const { renderToPipeableStream } = await serverRendererPromise;
+        const rscStream = renderToPipeableStream(await reactRenderingResult, {
+            onError: (err) => {
+                const error = convertToError(err);
+                reportError(error);
+            },
+        });
+        pipeToTransform(rscStream);
+    };
+    initializeAndRender().catch((e) => {
+        const error = convertToError(e);
+        reportError(error);
+        const errorHtml = handleError({ e: error, name: options.name, serverSide: true });
+        pipeToTransform(errorHtml);
+    });
+    readableStream.on('end', () => {
+        streamingTrackers.postSSRHookTracker.notifySSREnd();
+    });
+    return readableStream;
+};
+/**
+ * Pro RSC capability.
+ * Provides React Server Components rendering support.
+ */
+export function createProRSCCapability() {
+    return {
+        isRSCBundle: true,
+        serverRenderRSCReactComponent(options) {
+            try {
+                return streamServerRenderedComponent(options, streamRenderRSCComponent, handleError);
+            }
+            finally {
+                console.history = [];
+            }
+        },
+        addAsyncPropsCapabilityToComponentProps(props, sharedExecutionContext) {
+            const asyncPropManager = getOrCreateAsyncPropsManager(sharedExecutionContext);
+            const propsAfterAddingAsyncProps = {
+                ...props,
+                getReactOnRailsAsyncProp: (propName) => {
+                    return asyncPropManager.getProp(propName);
+                },
+            };
+            return { props: propsAfterAddingAsyncProps };
+        },
+        getOrCreateAsyncPropsManager(sharedExecutionContext) {
+            return getOrCreateAsyncPropsManager(sharedExecutionContext);
+        },
+    };
+}
+//# sourceMappingURL=proRSC.js.map

package/lib/capabilities/proStreaming.d.ts

@@ -0,0 +1,10 @@
+import type { Readable } from 'stream';
+import type { RenderParams } from 'react-on-rails/types';
+/**
+ * Pro streaming capability.
+ * Provides server-side streaming rendering via streamServerRenderedReactComponent.
+ */
+export declare function createProStreamingCapability(): {
+    streamServerRenderedReactComponent(options: RenderParams): Readable;
+};
+//# sourceMappingURL=proStreaming.d.ts.map

package/lib/capabilities/proStreaming.js

@@ -0,0 +1,14 @@
+/* eslint-disable import/prefer-default-export -- named export for consistency with capability API */
+import streamServerRenderedReactComponent from "../streamServerRenderedReactComponent.js";
+/**
+ * Pro streaming capability.
+ * Provides server-side streaming rendering via streamServerRenderedReactComponent.
+ */
+export function createProStreamingCapability() {
+    return {
+        streamServerRenderedReactComponent(options) {
+            return streamServerRenderedReactComponent(options);
+        },
+    };
+}
+//# sourceMappingURL=proStreaming.js.map