rwsdk 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/runtime/lib/stitchDocumentAndAppStreams.js

@@ -0,0 +1,143 @@
+/**
+ * A utility to orchestrate and interleave two ReadableStreams (a document shell and an app shell)
+ * based on a set of markers within their content. This is designed to solve a specific
+ * race condition in streaming Server-Side Rendering (SSR) with Suspense.
+ *
+ * The logic is as follows:
+ * 1. Stream the document until a start marker is found.
+ * 2. Switch to the app stream and stream it until an end marker is found. This is the non-suspended shell.
+ * 3. Switch back to the document stream and stream it until the closing body tag. This sends the client script.
+ * 4. Switch back to the app stream and stream the remainder (the suspended content).
+ * 5. Switch back to the document stream and stream the remainder (closing body and html tags).
+ *
+ * @param outerHtml The stream for the document shell (`<Document>`).
+ * @param innerHtml The stream for the application's content.
+ * @param startMarker The marker in the document to start injecting the app.
+ * @param endMarker The marker in the app stream that signals the end of the initial, non-suspended render.
+ */
+export function stitchDocumentAndAppStreams(outerHtml, innerHtml, startMarker, endMarker) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let outerReader;
+    let innerReader;
+    let buffer = "";
+    let outerBufferRemains = "";
+    let phase = "outer-head";
+    const pump = async (controller) => {
+        try {
+            if (phase === "outer-head") {
+                const { done, value } = await outerReader.read();
+                if (done) {
+                    if (buffer)
+                        controller.enqueue(encoder.encode(buffer));
+                    controller.close();
+                    return;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const markerIndex = buffer.indexOf(startMarker);
+                if (markerIndex !== -1) {
+                    controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                    outerBufferRemains = buffer.slice(markerIndex + startMarker.length);
+                    buffer = "";
+                    phase = "inner-shell";
+                }
+                else {
+                    const flushIndex = buffer.lastIndexOf("\n");
+                    if (flushIndex !== -1) {
+                        controller.enqueue(encoder.encode(buffer.slice(0, flushIndex + 1)));
+                        buffer = buffer.slice(flushIndex + 1);
+                    }
+                }
+            }
+            else if (phase === "inner-shell") {
+                const { done, value } = await innerReader.read();
+                if (done) {
+                    if (buffer)
+                        controller.enqueue(encoder.encode(buffer));
+                    phase = "outer-tail";
+                }
+                else {
+                    buffer += decoder.decode(value, { stream: true });
+                    const markerIndex = buffer.indexOf(endMarker);
+                    if (markerIndex !== -1) {
+                        const endOfMarkerIndex = markerIndex + endMarker.length;
+                        controller.enqueue(encoder.encode(buffer.slice(0, endOfMarkerIndex)));
+                        buffer = buffer.slice(endOfMarkerIndex);
+                        phase = "outer-tail";
+                    }
+                    else {
+                        const flushIndex = buffer.lastIndexOf("\n");
+                        if (flushIndex !== -1) {
+                            controller.enqueue(encoder.encode(buffer.slice(0, flushIndex + 1)));
+                            buffer = buffer.slice(flushIndex + 1);
+                        }
+                    }
+                }
+            }
+            else if (phase === "outer-tail") {
+                if (outerBufferRemains) {
+                    buffer = outerBufferRemains;
+                    outerBufferRemains = "";
+                }
+                const { done, value } = await outerReader.read();
+                if (done) {
+                    if (buffer)
+                        controller.enqueue(encoder.encode(buffer));
+                    phase = "inner-suspended";
+                }
+                else {
+                    buffer += decoder.decode(value, { stream: true });
+                    const markerIndex = buffer.indexOf("</body>");
+                    if (markerIndex !== -1) {
+                        controller.enqueue(encoder.encode(buffer.slice(0, markerIndex)));
+                        buffer = buffer.slice(markerIndex);
+                        phase = "inner-suspended";
+                    }
+                    else {
+                        const flushIndex = buffer.lastIndexOf("\n");
+                        if (flushIndex !== -1) {
+                            controller.enqueue(encoder.encode(buffer.slice(0, flushIndex + 1)));
+                            buffer = buffer.slice(flushIndex + 1);
+                        }
+                    }
+                }
+            }
+            else if (phase === "inner-suspended") {
+                const { done, value } = await innerReader.read();
+                if (done) {
+                    phase = "outer-end";
+                }
+                else {
+                    controller.enqueue(value);
+                }
+            }
+            else if (phase === "outer-end") {
+                if (buffer) {
+                    controller.enqueue(encoder.encode(buffer));
+                    buffer = "";
+                }
+                const { done, value } = await outerReader.read();
+                if (done) {
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(value);
+            }
+            await pump(controller);
+        }
+        catch (e) {
+            controller.error(e);
+        }
+    };
+    return new ReadableStream({
+        start(controller) {
+            outerReader = outerHtml.getReader();
+            innerReader = innerHtml.getReader();
+            pump(controller).catch((e) => controller.error(e));
+        },
+        cancel(reason) {
+            outerReader?.cancel(reason);
+            innerReader?.cancel(reason);
+        },
+    });
+}

package/dist/runtime/lib/turnstile/verifyTurnstileToken.d.ts

@@ -1,4 +1,5 @@
-export declare const verifyTurnstileToken: ({ token, secretKey, }: {
+export declare const verifyTurnstileToken: ({ token, secretKey, fetchFn, }: {
     token: string;
     secretKey: string;
+    fetchFn?: typeof fetch;
 }) => Promise<boolean>;

package/dist/runtime/lib/turnstile/verifyTurnstileToken.js

@@ -1,10 +1,10 @@
-export const verifyTurnstileToken = async ({ token, secretKey, }) => {
-    const response = await fetch("https://challenges.cloudflare.com/turnstile/v0/siteverify", {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({ secret: secretKey, response: token }),
-    });
+export const verifyTurnstileToken = async ({ token, secretKey, fetchFn = fetch, }) => {
     try {
+        const response = await fetchFn("https://challenges.cloudflare.com/turnstile/v0/siteverify", {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({ secret: secretKey, response: token }),
+        });
         const data = (await response.json());
         return data?.success === true;
     }

package/dist/runtime/lib/turnstile/verifyTurnstileToken.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/turnstile/verifyTurnstileToken.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi } from "vitest";
+import { verifyTurnstileToken } from "./verifyTurnstileToken";
+describe("verifyTurnstileToken", () => {
+    it("should return true for a successful verification", async () => {
+        const mockFetch = vi.fn().mockResolvedValue(new Response(JSON.stringify({ success: true }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+        }));
+        const result = await verifyTurnstileToken({
+            token: "valid-token",
+            secretKey: "secret",
+            fetchFn: mockFetch,
+        });
+        expect(result).toBe(true);
+        expect(mockFetch).toHaveBeenCalledWith("https://challenges.cloudflare.com/turnstile/v0/siteverify", expect.any(Object));
+    });
+    it("should return false for a failed verification", async () => {
+        const mockFetch = vi.fn().mockResolvedValue(new Response(JSON.stringify({ success: false }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+        }));
+        const result = await verifyTurnstileToken({
+            token: "invalid-token",
+            secretKey: "secret",
+            fetchFn: mockFetch,
+        });
+        expect(result).toBe(false);
+    });
+    it("should return false if the fetch call fails", async () => {
+        const mockFetch = vi.fn().mockRejectedValue(new Error("Network error"));
+        const result = await verifyTurnstileToken({
+            token: "any-token",
+            secretKey: "secret",
+            fetchFn: mockFetch,
+        });
+        expect(result).toBe(false);
+    });
+    it("should return false for a non-JSON response", async () => {
+        const mockFetch = vi
+            .fn()
+            .mockResolvedValue(new Response("not json", { status: 200 }));
+        const result = await verifyTurnstileToken({
+            token: "any-token",
+            secretKey: "secret",
+            fetchFn: mockFetch,
+        });
+        expect(result).toBe(false);
+    });
+});

package/dist/runtime/register/worker.d.ts

@@ -1,4 +1,4 @@
 export declare function registerServerReference(action: Function, id: string, name: string): Function;
-export declare function registerClientReference<Target extends Record<string, any>>(id: string, exportName: string, value: any): any;
+export declare function registerClientReference<Target extends Record<string, unknown>>(ssrModule: Target, id: string, exportName: string): {};
 export declare function __smokeTestActionHandler(timestamp?: number): Promise<unknown>;
 export declare function rscActionHandler(req: Request): Promise<unknown>;

package/dist/runtime/register/worker.js

@@ -1,4 +1,5 @@
 import { registerServerReference as baseRegisterServerReference, registerClientReference as baseRegisterClientReference, decodeReply, } from "react-server-dom-webpack/server.edge";
+import { isValidElementType } from "react-is";
 import { getServerModuleExport } from "../imports/worker.js";
 import { requestInfo } from "../requestInfo/worker.js";
 export function registerServerReference(action, id, name) {
@@ -8,28 +9,39 @@ export function registerServerReference(action, id, name) {
     // Note: We no longer need to register in a Map since we use virtual lookup
     return baseRegisterServerReference(action, id, name);
 }
-export function registerClientReference(id, exportName, value) {
-    const wrappedValue = (value && typeof value === "function") || typeof value === "object"
-        ? value
-        : () => null;
-    const reference = baseRegisterClientReference({}, id, exportName);
-    reference.__rwsdk_clientReferenceId = `${id}#${exportName}`;
-    const finalDescriptors = Object.getOwnPropertyDescriptors(reference);
-    const idDescriptor = finalDescriptors.$$id;
-    if (idDescriptor && idDescriptor.hasOwnProperty("value")) {
-        const originalValue = idDescriptor.value;
-        finalDescriptors.$$id = {
-            configurable: idDescriptor.configurable,
-            enumerable: idDescriptor.enumerable,
-            get() {
-                requestInfo.rw.scriptsToBeLoaded.add(id);
-                return originalValue;
-            },
-        };
+const isComponent = (target) => isValidElementType(target) && target?.toString().includes("jsx");
+export function registerClientReference(ssrModule, id, exportName) {
+    const target = ssrModule[exportName] ?? {};
+    if (isValidElementType(target)) {
+        // This is the original logic from 'main'.
+        // For React components, we create a serializable reference for the RSC pass.
+        const reference = baseRegisterClientReference({}, id, exportName);
+        const finalDescriptors = Object.getOwnPropertyDescriptors(reference);
+        const idDescriptor = finalDescriptors.$$id;
+        if (idDescriptor) {
+            const originalValue = idDescriptor.value;
+            // Create a new accessor descriptor, NOT by spreading the old one.
+            finalDescriptors.$$id = {
+                enumerable: idDescriptor.enumerable,
+                configurable: idDescriptor.configurable,
+                get() {
+                    requestInfo.rw.scriptsToBeLoaded.add(id);
+                    return originalValue;
+                },
+            };
+        }
+        finalDescriptors.$$async = { value: true };
+        finalDescriptors.$$isClientReference = { value: true };
+        // context(justinvdm, 25 Sep 2025): We create a wrapper function to avoid
+        // getting the SSR component's property descriptors - otherwise
+        // this will take precedence over the client reference descriptors
+        const fn = typeof target === "function"
+            ? (...args) => target(...args)
+            : () => null;
+        return Object.defineProperties(fn, finalDescriptors);
     }
-    finalDescriptors.$$async = { value: true };
-    finalDescriptors.$$isClientReference = { value: true };
-    return Object.defineProperties(wrappedValue, finalDescriptors);
+    // For non-components, return the target object directly for use in SSR.
+    return target;
 }
 export async function __smokeTestActionHandler(timestamp) {
     await new Promise((resolve) => setTimeout(resolve, 0));

package/dist/runtime/render/assembleDocument.d.ts

@@ -0,0 +1,6 @@
+import { type RequestInfo } from "../requestInfo/types.js";
+export declare const assembleDocument: ({ requestInfo, pageElement, shouldSSR, }: {
+    requestInfo: RequestInfo;
+    pageElement: React.ReactNode;
+    shouldSSR: boolean;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/runtime/render/assembleDocument.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Preloads } from "./preloads.js";
+import { Stylesheets } from "./stylesheets.js";
+// Note: This is a server component, even though it doesn't have the "use server"
+// directive. It's intended to be imported and used within the RSC render pass.
+export const assembleDocument = ({ requestInfo, pageElement, shouldSSR, }) => {
+    // todo(justinvdm, 18 Jun 2025): We can build on this later to allow users
+    // surface context. e.g:
+    // * we assign `user: requestInfo.clientCtx` here
+    // * user populates requestInfo.clientCtx on worker side
+    // * user can import a read only `import { clientCtx } from "rwsdk/client"`
+    // on client side
+    const clientContext = {
+        rw: {
+            ssr: shouldSSR,
+        },
+    };
+    const Document = requestInfo.rw.Document;
+    return (_jsxs(Document, { ...requestInfo, children: [_jsx("script", { nonce: requestInfo.rw.nonce, dangerouslySetInnerHTML: {
+                    __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)}`,
+                } }), _jsx(Stylesheets, { requestInfo: requestInfo }), _jsx(Preloads, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", children: pageElement })] }));
+};

package/dist/runtime/render/createThenableFromReadableStream.d.ts

@@ -0,0 +1 @@
+export declare const createThenableFromReadableStream: (stream: ReadableStream) => Thenable<T>;

package/dist/runtime/render/createThenableFromReadableStream.js

@@ -0,0 +1,9 @@
+import { createModuleMap } from "./createModuleMap.js";
+import ReactServerDom from "react-server-dom-webpack/client.edge";
+const { createFromReadableStream } = ReactServerDom;
+export const createThenableFromReadableStream = (stream) => createFromReadableStream(stream, {
+    serverConsumerManifest: {
+        moduleMap: createModuleMap(),
+        moduleLoading: null,
+    },
+});

package/dist/runtime/render/normalizeActionResult.d.ts

@@ -0,0 +1 @@
+export declare const normalizeActionResult: (actionResult: any) => any;

package/dist/runtime/render/normalizeActionResult.js

@@ -0,0 +1,43 @@
+// context(justinvdm, 24 Mar 2025): React flight limits chunks to 28 bytes, so we need to rechunk
+// the stream to avoid losing data
+function rechunkStream(stream, maxChunkSize = 28) {
+    const reader = stream.getReader();
+    return new ReadableStream({
+        async pull(controller) {
+            let buffer = new Uint8Array(0);
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done && buffer.length === 0) {
+                        controller.close();
+                        return;
+                    }
+                    if (value) {
+                        buffer = new Uint8Array([...buffer, ...value]);
+                    }
+                    while (buffer.length >= maxChunkSize || (done && buffer.length > 0)) {
+                        const chunk = buffer.slice(0, maxChunkSize);
+                        buffer = buffer.slice(maxChunkSize);
+                        controller.enqueue(chunk);
+                    }
+                    if (done) {
+                        controller.close();
+                        return;
+                    }
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    });
+}
+export const normalizeActionResult = (actionResult) => {
+    if (actionResult instanceof Response) {
+        return null;
+    }
+    if (actionResult instanceof ReadableStream) {
+        return rechunkStream(actionResult);
+    }
+    return actionResult;
+};

package/dist/runtime/render/preloads.d.ts

@@ -1,6 +1,6 @@
 import type { RequestInfo } from "../requestInfo/types.js";
 import type { Manifest, ManifestChunk } from "../lib/manifest.js";
 export declare function findScriptForModule(id: string, manifest: Manifest): ManifestChunk | undefined;
-export declare const Preloads: ({ requestInfo }: {
+export declare const Preloads: ({ requestInfo, }: {
     requestInfo: RequestInfo;
-}) => import("react/jsx-runtime.js").JSX.Element;
+}) => Promise<import("react/jsx-runtime").JSX.Element>;

package/dist/runtime/render/preloads.js

@@ -1,5 +1,4 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { use } from "react";
 import { getManifest } from "../lib/manifest.js";
 export function findScriptForModule(id, manifest) {
     const visited = new Set();
@@ -27,8 +26,8 @@ export function findScriptForModule(id, manifest) {
     }
     return find(id);
 }
-export const Preloads = ({ requestInfo }) => {
-    const manifest = use(getManifest());
+export const Preloads = async ({ requestInfo, }) => {
+    const manifest = await getManifest();
     const allScripts = new Set();
     for (const scriptId of requestInfo.rw.scriptsToBeLoaded) {
         const script = findScriptForModule(scriptId, manifest);

package/dist/runtime/render/{renderRscThenableToHtmlStream.d.ts → renderDocumentHtmlStream.d.ts}

@@ -1,9 +1,9 @@
 import { type DocumentProps } from "../lib/router.js";
 import { type RequestInfo } from "../requestInfo/types.js";
-export declare const renderRscThenableToHtmlStream: ({ thenable, Document, requestInfo, shouldSSR, onError, }: {
-    thenable: any;
+export declare const renderDocumentHtmlStream: ({ rscPayloadStream, Document, requestInfo, shouldSSR, onError, }: {
+    rscPayloadStream: ReadableStream;
     Document: React.FC<DocumentProps>;
     requestInfo: RequestInfo;
     shouldSSR: boolean;
     onError: (error: unknown) => void;
-}) => Promise<import("react-dom/server.js").ReactDOMServerReadableStream>;
+}) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;

package/dist/runtime/render/renderDocumentHtmlStream.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Preloads } from "./preloads.js";
+import { Stylesheets } from "./stylesheets.js";
+import { renderHtmlStream, createThenableFromReadableStream, } from "rwsdk/__ssr_bridge";
+import { stitchDocumentAndAppStreams } from "../lib/stitchDocumentAndAppStreams.js";
+export const renderDocumentHtmlStream = async ({ rscPayloadStream, Document, requestInfo, shouldSSR, onError, }) => {
+    // Extract the app node from the RSC payload
+    const rscAppThenable = createThenableFromReadableStream(rscPayloadStream);
+    const { node: innerAppNode } = (await rscAppThenable);
+    // todo(justinvdm, 18 Jun 2025): We can build on this later to allow users
+    // surface context. e.g:
+    // * we assign `user: requestInfo.clientCtx` here
+    // * user populates requestInfo.clientCtx on worker side
+    // * user can import a read only `import { clientCtx } from "rwsdk/client"`
+    // on client side
+    const clientContext = {
+        rw: {
+            ssr: shouldSSR,
+        },
+    };
+    // Create the outer document with a marker for injection
+    const documentElement = (_jsxs(Document, { ...requestInfo, children: [_jsx("script", { nonce: requestInfo.rw.nonce, dangerouslySetInnerHTML: {
+                    __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)}`,
+                } }), _jsx(Stylesheets, { requestInfo: requestInfo }), _jsx(Preloads, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", children: _jsx("div", { id: "rwsdk-app-start" }) })] }));
+    const outerHtmlStream = await renderHtmlStream({
+        node: documentElement,
+        requestInfo,
+        onError,
+        identifierPrefix: "__RWSDK_DOCUMENT__",
+    });
+    const appHtmlStream = await renderHtmlStream({
+        node: innerAppNode,
+        requestInfo,
+        onError,
+    });
+    // Stitch the streams together
+    const stitchedStream = stitchDocumentAndAppStreams(outerHtmlStream, appHtmlStream, '<div id="rwsdk-app-start"></div>', '<div id="rwsdk-app-end"></div>');
+    return stitchedStream;
+};

package/dist/runtime/render/renderHtmlStream.d.ts

@@ -0,0 +1,7 @@
+import { type RequestInfo } from "../requestInfo/types.js";
+export declare const renderHtmlStream: ({ node, identifierPrefix, requestInfo, onError, }: {
+    node: React.ReactNode;
+    requestInfo: RequestInfo;
+    onError: (error: unknown) => void;
+    identifierPrefix?: string;
+}) => Promise<import("react-dom/server").ReactDOMServerReadableStream>;

package/dist/runtime/render/renderHtmlStream.js

@@ -0,0 +1,31 @@
+import { renderToReadableStream } from "react-dom/server.edge";
+export const renderHtmlStream = async ({ node, identifierPrefix, requestInfo, onError, }) => {
+    return await renderToReadableStream(node, {
+        nonce: requestInfo.rw.nonce,
+        identifierPrefix,
+        onError(error, { componentStack }) {
+            try {
+                if (!error) {
+                    error = new Error(`A falsy value was thrown during rendering: ${String(error)}.`);
+                }
+                const message = error
+                    ? (error.stack ?? error.message ?? error)
+                    : error;
+                const wrappedMessage = `${message}\n\nComponent stack:${componentStack}`;
+                if (error instanceof Error) {
+                    const wrappedError = new Error(wrappedMessage);
+                    wrappedError.stack = error.stack;
+                    error = wrappedError;
+                }
+                else {
+                    error = new Error(wrappedMessage);
+                    error.stack = componentStack;
+                }
+                onError(error);
+            }
+            catch {
+                onError(error);
+            }
+        },
+    });
+};

package/dist/runtime/render/renderToRscStream.d.ts

@@ -1,5 +1,7 @@
-export declare const renderToRscStream: (app: {
-    node: React.ReactElement;
-    actionResult: any;
+export declare const renderToRscStream: ({ input, onError, }: {
+    input: {
+        node: React.ReactNode;
+        actionResult: unknown;
+    };
     onError?: (error: unknown) => void;
 }) => ReadableStream;

package/dist/runtime/render/renderToRscStream.js

@@ -1,46 +1,17 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { renderToReadableStream as baseRenderToRscStream } from "react-server-dom-webpack/server.edge";
 import { createClientManifest } from "./createClientManifest.js";
-// context(justinvdm, 24 Mar 2025): React flight limits chunks to 28 bytes, so we need to rechunk
-// the stream to avoid losing data
-function rechunkStream(stream, maxChunkSize = 28) {
-    const reader = stream.getReader();
-    return new ReadableStream({
-        async pull(controller) {
-            let buffer = new Uint8Array(0);
-            try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done && buffer.length === 0) {
-                        controller.close();
-                        return;
-                    }
-                    if (value) {
-                        buffer = new Uint8Array([...buffer, ...value]);
-                    }
-                    while (buffer.length >= maxChunkSize || (done && buffer.length > 0)) {
-                        const chunk = buffer.slice(0, maxChunkSize);
-                        buffer = buffer.slice(maxChunkSize);
-                        controller.enqueue(chunk);
-                    }
-                    if (done) {
-                        controller.close();
-                        return;
-                    }
-                }
-            }
-            catch (error) {
-                controller.error(error);
-            }
-        },
-    });
-}
-export const renderToRscStream = (app) => {
-    const { node, onError } = app;
-    let { actionResult } = app;
-    if (actionResult instanceof ReadableStream) {
-        actionResult = rechunkStream(actionResult);
-    }
-    return baseRenderToRscStream({ node, actionResult }, createClientManifest(), {
+export const renderToRscStream = ({ input, onError, }) => {
+    const { node: inputNode, actionResult } = input;
+    // context(justinvdm, 2025-09-26): We add a marker here for our stitching logic in
+    // renderDocumentHtmlStream() to find and use. It needs to live here rather than there,
+    // since it needs to live in the RSC payload for hydration to work.
+    const wrappedNode = (_jsxs(_Fragment, { children: [inputNode, _jsx("div", { id: "rwsdk-app-end" })] }));
+    const wrappedInput = {
+        node: wrappedNode,
+        actionResult,
+    };
+    return baseRenderToRscStream(wrappedInput, createClientManifest(), {
         onError,
     });
 };

package/dist/runtime/render/renderToStream.d.ts

@@ -2,8 +2,9 @@ import { ReactElement, FC } from "react";
 import { DocumentProps } from "../lib/router";
 export interface RenderToStreamOptions {
     Document?: FC<DocumentProps>;
+    ssr?: boolean;
     injectRSCPayload?: boolean;
     onError?: (error: unknown) => void;
 }
 export declare const IdentityDocument: FC<DocumentProps>;
-export declare const renderToStream: (element: ReactElement, { Document, injectRSCPayload: shouldInjectRSCPayload, onError, }?: RenderToStreamOptions) => Promise<ReadableStream>;
+export declare const renderToStream: (element: ReactElement, { ssr: shouldSSR, Document, injectRSCPayload: shouldInjectRSCPayload, onError, }?: RenderToStreamOptions) => Promise<ReadableStream>;

package/dist/runtime/render/renderToStream.js

@@ -1,27 +1,34 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { renderToRscStream } from "./renderToRscStream";
-import { transformRscToHtmlStream } from "./transformRscToHtmlStream";
 import { requestInfo } from "../requestInfo/worker";
 import { injectRSCPayload } from "rsc-html-stream/server";
+import { renderDocumentHtmlStream } from "./renderDocumentHtmlStream";
 export const IdentityDocument = ({ children }) => (_jsx(_Fragment, { children: children }));
-export const renderToStream = async (element, { Document = IdentityDocument, injectRSCPayload: shouldInjectRSCPayload = false, onError = () => { }, } = {}) => {
+export const renderToStream = async (element, { ssr: shouldSSR = true, Document = IdentityDocument, injectRSCPayload: shouldInjectRSCPayload = true, onError = () => { }, } = {}) => {
     let rscStream = renderToRscStream({
-        node: element,
-        actionResult: null,
+        input: {
+            node: element,
+            actionResult: undefined,
+        },
         onError,
     });
+    let injectRSCStream;
     if (shouldInjectRSCPayload) {
         const [rscPayloadStream1, rscPayloadStream2] = rscStream.tee();
         rscStream = rscPayloadStream1;
-        rscStream = rscStream.pipeThrough(injectRSCPayload(rscPayloadStream2, {
+        injectRSCStream = injectRSCPayload(rscPayloadStream2, {
             nonce: requestInfo.rw.nonce,
-        }));
+        });
     }
-    const htmlStream = await transformRscToHtmlStream({
-        stream: rscStream,
+    let htmlStream = await renderDocumentHtmlStream({
+        rscPayloadStream: rscStream,
         Document,
         requestInfo,
+        shouldSSR,
         onError,
     });
+    if (injectRSCStream) {
+        htmlStream = htmlStream.pipeThrough(injectRSCStream);
+    }
     return htmlStream;
 };

package/dist/runtime/render/stylesheets.d.ts

@@ -1,4 +1,4 @@
 import { type RequestInfo } from "../requestInfo/types.js";
-export declare const Stylesheets: ({ requestInfo }: {
+export declare const Stylesheets: ({ requestInfo, }: {
     requestInfo: RequestInfo;
-}) => import("react/jsx-runtime.js").JSX.Element;
+}) => Promise<import("react/jsx-runtime").JSX.Element>;