react-on-rails-pro 16.7.0-rc.2 → 17.0.0-rc.0

package/lib/ReactOnRailsRSC.d.ts

@@ -1,4 +1,6 @@
 declare const ReactOnRails: import("react-on-rails/types").ReactOnRailsInternal;
 export * from 'react-on-rails/types';
+export { unstable_cache, registerCacheHandler } from './cache/index.ts';
+export type { CacheHandler, CacheEntry, UnstableCacheOptions } from './cache/index.ts';
 export default ReactOnRails;
 //# sourceMappingURL=ReactOnRailsRSC.d.ts.map

package/lib/ReactOnRailsRSC.js

@@ -17,5 +17,6 @@ import createReactOnRailsPro from "./createReactOnRailsPro.js";
 const currentGlobal = globalThis.ReactOnRails || null;
 const ReactOnRails = createReactOnRailsPro([createSSRCapability(), createProRSCCapability()], currentGlobal);
 export * from 'react-on-rails/types';
+export { unstable_cache, registerCacheHandler } from "./cache/index.js"; // eslint-disable-line camelcase -- matches Next.js API naming convention
 export default ReactOnRails;
 //# sourceMappingURL=ReactOnRailsRSC.js.map

package/lib/cache/CacheHandler.d.ts

@@ -0,0 +1,10 @@
+export interface CacheEntry {
+    value: Buffer[];
+    revalidate: number;
+    timestamp: number;
+}
+export interface CacheHandler {
+    get(key: string): Promise<CacheEntry | null>;
+    set(key: string, entry: CacheEntry): Promise<void>;
+}
+//# sourceMappingURL=CacheHandler.d.ts.map

package/lib/cache/CacheHandler.js

@@ -0,0 +1,15 @@
+/*
+ * 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
+ */
+export {};
+//# sourceMappingURL=CacheHandler.js.map

package/lib/cache/InMemoryLRUCacheHandler.d.ts

@@ -0,0 +1,9 @@
+import type { CacheEntry, CacheHandler } from './CacheHandler.ts';
+export declare class InMemoryLRUCacheHandler implements CacheHandler {
+    private cache;
+    private maxEntries;
+    constructor(maxEntries?: number);
+    get(key: string): Promise<CacheEntry | null>;
+    set(key: string, entry: CacheEntry): Promise<void>;
+}
+//# sourceMappingURL=InMemoryLRUCacheHandler.d.ts.map

package/lib/cache/InMemoryLRUCacheHandler.js

@@ -0,0 +1,50 @@
+/*
+ * 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
+ */
+// eslint-disable-next-line import/prefer-default-export -- designed for named import alongside the interface
+export class InMemoryLRUCacheHandler {
+    constructor(maxEntries = 1000) {
+        this.cache = new Map();
+        this.maxEntries = maxEntries;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await -- CacheHandler interface is async for remote implementations
+    async get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        if (entry.revalidate > 0 && Date.now() - entry.timestamp > entry.revalidate * 1000) {
+            this.cache.delete(key);
+            return null;
+        }
+        // Move to end (most-recently-used) by re-inserting
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        return entry;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async set(key, entry) {
+        // If key already exists, remove it first so re-insert goes to end
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        // Evict oldest (first) entry if at capacity
+        if (this.cache.size >= this.maxEntries) {
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.cache.delete(oldestKey);
+            }
+        }
+        this.cache.set(key, entry);
+    }
+}
+//# sourceMappingURL=InMemoryLRUCacheHandler.js.map

package/lib/cache/buildCacheKey.d.ts

@@ -0,0 +1,2 @@
+export declare function buildCacheKey(buildId: string, id: string, args: unknown[]): string;
+//# sourceMappingURL=buildCacheKey.d.ts.map

package/lib/cache/buildCacheKey.js

@@ -0,0 +1,25 @@
+/*
+ * 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 { createHash } from 'crypto';
+// eslint-disable-next-line import/prefer-default-export -- will grow with additional key utilities
+export function buildCacheKey(buildId, id, args) {
+    const hash = createHash('sha256');
+    hash.update(buildId);
+    hash.update(':');
+    hash.update(id);
+    hash.update(':');
+    hash.update(JSON.stringify(args));
+    return `rorp:rsc-cache:${hash.digest('hex')}`;
+}
+//# sourceMappingURL=buildCacheKey.js.map

package/lib/cache/buildIdProvider.d.ts

@@ -0,0 +1,3 @@
+export declare function setBuildId(id: string): void;
+export declare function getBuildId(): string;
+//# sourceMappingURL=buildIdProvider.d.ts.map

package/lib/cache/buildIdProvider.js

@@ -0,0 +1,25 @@
+/*
+ * 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
+ */
+let buildId;
+export function setBuildId(id) {
+    buildId = id;
+}
+export function getBuildId() {
+    if (!buildId) {
+        throw new Error('BUILD_ID not set. Ensure unstable_cache is used within a React Server Component render context. ' +
+            'The BUILD_ID is initialized from rscBundleHash during the first render request.');
+    }
+    return buildId;
+}
+//# sourceMappingURL=buildIdProvider.js.map

package/lib/cache/cacheHandlerRegistry.d.ts

@@ -0,0 +1,4 @@
+import type { CacheHandler } from './CacheHandler.ts';
+export declare function registerCacheHandler(kind: string, handler: CacheHandler): void;
+export declare function getCacheHandler(kind: string): CacheHandler;
+//# sourceMappingURL=cacheHandlerRegistry.d.ts.map

package/lib/cache/cacheHandlerRegistry.js

@@ -0,0 +1,29 @@
+/*
+ * 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 { InMemoryLRUCacheHandler } from "./InMemoryLRUCacheHandler.js";
+const handlers = new Map();
+handlers.set('default', new InMemoryLRUCacheHandler());
+export function registerCacheHandler(kind, handler) {
+    handlers.set(kind, handler);
+}
+export function getCacheHandler(kind) {
+    const handler = handlers.get(kind);
+    if (!handler) {
+        throw new Error(`No CacheHandler registered for kind "${kind}". ` +
+            `Available kinds: ${[...handlers.keys()].join(', ')}. ` +
+            'Register a handler with registerCacheHandler(kind, handler).');
+    }
+    return handler;
+}
+//# sourceMappingURL=cacheHandlerRegistry.js.map

package/lib/cache/index.d.ts

@@ -0,0 +1,5 @@
+export { unstable_cache } from './unstable_cache.ts';
+export type { UnstableCacheOptions } from './unstable_cache.ts';
+export type { CacheHandler, CacheEntry } from './CacheHandler.ts';
+export { registerCacheHandler } from './cacheHandlerRegistry.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/cache/index.js

@@ -0,0 +1,17 @@
+/*
+ * 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
+ */
+/* eslint-disable camelcase -- matches Next.js API naming convention */
+export { unstable_cache } from "./unstable_cache.js";
+export { registerCacheHandler } from "./cacheHandlerRegistry.js";
+//# sourceMappingURL=index.js.map

package/lib/cache/index.stub.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Stub module for non-react-server contexts (e.g. SSR server bundle).
+ *
+ * The auto-load system includes .server.tsx files in both the RSC bundle
+ * and the SSR server bundle. The SSR bundle never executes server component
+ * code (it delegates to the RSC bundle), but webpack still needs to resolve
+ * all imports at build time. This stub satisfies that requirement.
+ */
+import type { ReactNode } from 'react';
+import type { CacheHandler, CacheEntry } from './CacheHandler.ts';
+export type { CacheHandler, CacheEntry };
+export interface UnstableCacheOptions {
+    id: string;
+    revalidate?: number;
+    kind?: string;
+}
+export declare function unstable_cache<TArgs extends unknown[]>(originalFn: (...args: TArgs) => Promise<ReactNode> | ReactNode, options: UnstableCacheOptions): (...args: TArgs) => Promise<ReactNode>;
+export declare function registerCacheHandler(kind: string, handler: CacheHandler): void;
+//# sourceMappingURL=index.stub.d.ts.map

package/lib/cache/index.stub.js

@@ -0,0 +1,25 @@
+/*
+ * 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
+ */
+const STUB_ERROR = 'unstable_cache is only available in the react-server bundle. ' +
+    'It should not be called from the SSR server bundle or client bundle.';
+// eslint-disable-next-line camelcase -- matches Next.js API naming convention
+export function unstable_cache(originalFn, options) {
+    return () => {
+        throw new Error(STUB_ERROR);
+    };
+}
+export function registerCacheHandler(kind, handler) {
+    throw new Error(STUB_ERROR);
+}
+//# sourceMappingURL=index.stub.js.map

package/lib/cache/manifestLoader.d.ts

@@ -0,0 +1,5 @@
+import { buildClientRenderer } from 'react-on-rails-rsc/client.node';
+export declare function setManifestFileNames(clientManifest: string, serverClientManifest: string): void;
+export declare function getClientManifestFileName(): string | undefined;
+export declare function getClientRenderer(): Promise<ReturnType<typeof buildClientRenderer>>;
+//# sourceMappingURL=manifestLoader.d.ts.map

package/lib/cache/manifestLoader.js

@@ -0,0 +1,46 @@
+/*
+ * 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 { buildClientRenderer } from 'react-on-rails-rsc/client.node';
+import loadJsonFile from "../loadJsonFile.js";
+let clientManifestFileName;
+let serverClientManifestFileName;
+let clientRendererPromise;
+export function setManifestFileNames(clientManifest, serverClientManifest) {
+    clientManifestFileName = clientManifest;
+    serverClientManifestFileName = serverClientManifest;
+}
+export function getClientManifestFileName() {
+    return clientManifestFileName;
+}
+export function getClientRenderer() {
+    if (!clientRendererPromise) {
+        if (!clientManifestFileName || !serverClientManifestFileName) {
+            throw new Error('Manifest file names not set. Ensure setManifestFileNames() is called before getClientRenderer(). ' +
+                'This is done automatically during the first RSC render request.');
+        }
+        const clientFile = clientManifestFileName;
+        const serverFile = serverClientManifestFileName;
+        clientRendererPromise = Promise.all([
+            loadJsonFile(serverFile),
+            loadJsonFile(clientFile),
+        ])
+            .then(([reactServerManifest, reactClientManifest]) => buildClientRenderer(reactClientManifest, reactServerManifest))
+            .catch((err) => {
+            clientRendererPromise = undefined;
+            throw err;
+        });
+    }
+    return clientRendererPromise;
+}
+//# sourceMappingURL=manifestLoader.js.map

package/lib/cache/manifestLoaderServer.d.ts

@@ -0,0 +1,3 @@
+import { buildServerRenderer } from 'react-on-rails-rsc/server.node';
+export declare function getServerRenderer(): Promise<ReturnType<typeof buildServerRenderer>>;
+//# sourceMappingURL=manifestLoaderServer.d.ts.map

package/lib/cache/manifestLoaderServer.js

@@ -0,0 +1,35 @@
+/*
+ * 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 { buildServerRenderer } from 'react-on-rails-rsc/server.node';
+import loadJsonFile from "../loadJsonFile.js";
+import { getClientManifestFileName } from "./manifestLoader.js";
+let serverRendererPromise;
+// eslint-disable-next-line import/prefer-default-export -- named export for consistency with manifestLoader
+export function getServerRenderer() {
+    if (!serverRendererPromise) {
+        const clientManifest = getClientManifestFileName();
+        if (!clientManifest) {
+            throw new Error('Manifest file names not set. Ensure setManifestFileNames() is called before getServerRenderer(). ' +
+                'This is done automatically during the first RSC render request.');
+        }
+        serverRendererPromise = loadJsonFile(clientManifest)
+            .then((reactClientManifest) => buildServerRenderer(reactClientManifest))
+            .catch((err) => {
+            serverRendererPromise = undefined;
+            throw err;
+        });
+    }
+    return serverRendererPromise;
+}
+//# sourceMappingURL=manifestLoaderServer.js.map

package/lib/cache/unstable_cache.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+export interface UnstableCacheOptions {
+    /** Stable identifier for this cached function. Required. */
+    id: string;
+    /** Time in seconds before the cache entry is considered stale. 0 = indefinite. */
+    revalidate?: number;
+    /** Cache handler kind to use. Defaults to 'default' (in-memory LRU). */
+    kind?: string;
+}
+export declare function unstable_cache<TArgs extends unknown[]>(originalFn: (...args: TArgs) => Promise<ReactNode> | ReactNode, options: UnstableCacheOptions): (...args: TArgs) => Promise<ReactNode>;
+//# sourceMappingURL=unstable_cache.d.ts.map

package/lib/cache/unstable_cache.js

@@ -0,0 +1,85 @@
+/*
+ * 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 { PassThrough } from 'stream';
+import { getCacheHandler } from "./cacheHandlerRegistry.js";
+import { buildCacheKey } from "./buildCacheKey.js";
+import { getBuildId } from "./buildIdProvider.js";
+import { getClientRenderer } from "./manifestLoader.js";
+import { getServerRenderer } from "./manifestLoaderServer.js";
+function chunksToNodeStream(chunks) {
+    const stream = new PassThrough();
+    for (const chunk of chunks) {
+        stream.push(chunk);
+    }
+    stream.push(null);
+    return stream;
+}
+function bufferNodeStream(stream) {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        stream.on('data', (chunk) => chunks.push(chunk));
+        stream.on('end', () => resolve(chunks));
+        stream.on('error', reject);
+    });
+}
+// eslint-disable-next-line camelcase -- matches Next.js API naming convention
+export function unstable_cache(originalFn, options) {
+    const { id, revalidate = 0, kind = 'default' } = options;
+    return async function cachedFn(...args) {
+        const handler = getCacheHandler(kind);
+        const cacheKey = buildCacheKey(getBuildId(), id, args);
+        // --- HIT path ---
+        const entry = await handler.get(cacheKey);
+        if (entry) {
+            const replayStream = chunksToNodeStream(entry.value);
+            const { createFromNodeStream } = await getClientRenderer();
+            return createFromNodeStream(replayStream);
+        }
+        // --- MISS path ---
+        const reactTree = await originalFn(...args);
+        const { renderToPipeableStream } = await getServerRenderer();
+        const rscPipeable = renderToPipeableStream(reactTree);
+        const source = new PassThrough();
+        const forCache = new PassThrough();
+        const forReturn = new PassThrough();
+        rscPipeable.pipe(source);
+        source.on('data', (chunk) => {
+            forCache.push(chunk);
+            forReturn.push(chunk);
+        });
+        source.on('end', () => {
+            forCache.push(null);
+            forReturn.push(null);
+        });
+        source.on('error', (err) => {
+            forCache.destroy(err);
+            forReturn.destroy(err);
+        });
+        bufferNodeStream(forCache)
+            .then((chunks) => {
+            const newEntry = {
+                value: chunks,
+                revalidate,
+                timestamp: Date.now(),
+            };
+            return handler.set(cacheKey, newEntry);
+        })
+            .catch((err) => {
+            console.error('unstable_cache: failed to store cache entry', err);
+        });
+        const { createFromNodeStream } = await getClientRenderer();
+        return createFromNodeStream(forReturn);
+    };
+}
+//# sourceMappingURL=unstable_cache.js.map

package/lib/capabilities/proRSC.js

@@ -1,17 +1,64 @@
 /* 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;
+import { setManifestFileNames } from "../cache/manifestLoader.js";
+import { getServerRenderer } from "../cache/manifestLoaderServer.js";
+import { setBuildId } from "../cache/buildIdProvider.js";
+const CLIENT_HOOK_NAMES = [
+    'useState',
+    'useEffect',
+    'useReducer',
+    'useCallback',
+    'useMemo',
+    'useRef',
+    'useLayoutEffect',
+    'useImperativeHandle',
+    'useContext',
+    'useSyncExternalStore',
+    'useTransition',
+    'useDeferredValue',
+    'useId',
+    'useDebugValue',
+    'useInsertionEffect',
+    'useOptimistic',
+    'useActionState',
+].join('|');
+const CLIENT_HOOK_RUNTIME_ERROR_REGEX = new RegExp(`(?:(?:React\\.)|\\(0\\s*,\\s*[\\w$]+\\.)?(${CLIENT_HOOK_NAMES})\\)? is not a function\\b`);
+const addRSCClientHookDiagnostic = (error, componentName) => {
+    const match = error.message.match(CLIENT_HOOK_RUNTIME_ERROR_REGEX);
+    if (!match)
+        return error;
+    const hookName = match[1];
+    const enhancedError = new Error(`[React on Rails Pro] Component "${componentName}" called client hook "${hookName}" while rendering in ` +
+        `the React Server Components runtime.\n\n` +
+        `Most likely cause: "${componentName}", or a component it imports, uses client-only APIs but is missing ` +
+        `the '"use client";' directive.\n\n` +
+        `Add '"use client";' as the first statement of the client component file, or move hooks, event handlers, ` +
+        `and class components into a separate client component.\n\n` +
+        `Note: .client/.server file suffixes only control bundle placement. The '"use client";' directive controls ` +
+        `RSC client/server classification.\n\n` +
+        `Original error: ${error.message}`);
+    enhancedError.name = error.name;
+    enhancedError.cause = error;
+    const enhancedStackFrames = enhancedError.stack?.split('\n').slice(1).join('\n');
+    enhancedError.stack = `${enhancedError.name}: ${enhancedError.message}${enhancedStackFrames ? `\n${enhancedStackFrames}` : ''}\nCaused by: ${error.stack || error.message}`;
+    return enhancedError;
+};
 const streamRenderRSCComponent = (reactRenderingResult, options, streamingTrackers) => {
-    const { throwJsErrors } = options;
+    const { name: componentName, throwJsErrors } = options;
     const { railsContext } = options;
     assertRailsContextWithServerStreamingCapabilities(railsContext);
-    const { reactClientManifestFileName } = railsContext;
+    const { reactClientManifestFileName, reactServerClientManifestFileName } = railsContext;
+    // Initialize manifest loader and BUILD_ID on first render request.
+    // These are per-process constants that don't change between requests.
+    setManifestFileNames(reactClientManifestFileName, reactServerClientManifestFileName);
+    const rscPayloadParams = railsContext.serverSideRSCPayloadParameters;
+    if (rscPayloadParams?.rscBundleHash) {
+        setBuildId(rscPayloadParams.rscBundleHash);
+    }
     const renderState = {
         result: null,
         hasErrors: false,
@@ -19,23 +66,17 @@ const streamRenderRSCComponent = (reactRenderingResult, options, streamingTracke
     };
     const { pipeToTransform, readableStream, emitError } = transformRenderStreamChunksToResultObject(renderState);
     const reportError = (error) => {
-        console.error('Error in RSC stream', error);
+        const diagnosticError = addRSCClientHookDiagnostic(error, componentName);
+        console.error('Error in RSC stream', diagnosticError);
         if (throwJsErrors) {
-            emitError(error);
+            emitError(diagnosticError);
         }
         renderState.hasErrors = true;
-        renderState.error = error;
+        renderState.error = diagnosticError;
+        return diagnosticError;
     };
     const initializeAndRender = async () => {
-        if (!serverRendererPromise) {
-            serverRendererPromise = loadJsonFile(reactClientManifestFileName)
-                .then((reactClientManifest) => buildServerRenderer(reactClientManifest))
-                .catch((err) => {
-                serverRendererPromise = undefined;
-                throw err;
-            });
-        }
-        const { renderToPipeableStream } = await serverRendererPromise;
+        const { renderToPipeableStream } = await getServerRenderer();
         const rscStream = renderToPipeableStream(await reactRenderingResult, {
             onError: (err) => {
                 const error = convertToError(err);
@@ -45,8 +86,7 @@ const streamRenderRSCComponent = (reactRenderingResult, options, streamingTracke
         pipeToTransform(rscStream);
     };
     initializeAndRender().catch((e) => {
-        const error = convertToError(e);
-        reportError(error);
+        const error = reportError(convertToError(e));
         const errorHtml = handleError({ e: error, name: options.name, serverSide: true });
         pipeToTransform(errorHtml);
     });