npm - @shopify/hydrogen - Versions diffs - 0.22.1 → 0.23.0 - Mend

@shopify/hydrogen 0.22.1 → 0.23.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (468) hide show

package/dist/esnext/entry-server.js CHANGED Viewed

@@ -1,31 +1,31 @@
 import React, { Suspense } from 'react';
 import { logServerResponse, logCacheControlHeaders, logQueryTimings, getLoggerWithContext, } from './utilities/log';
 import { getErrorMarkup } from './utilities/error';
-import { defer } from './utilities/defer';
-import { Html, applyHtmlHead } from './framework/Hydration/Html';
-import { ServerComponentResponse } from './framework/Hydration/ServerComponentResponse.server';
-import { ServerComponentRequest } from './framework/Hydration/ServerComponentRequest.server';
+import { Html, applyHtmlHead } from './foundation/Html/Html';
+import { HydrogenResponse } from './foundation/HydrogenResponse/HydrogenResponse.server';
+import { HydrogenRequest, } from './foundation/HydrogenRequest/HydrogenRequest.server';
 import { preloadRequestCacheData, ServerRequestProvider, } from './foundation/ServerRequestProvider';
 import { getApiRouteFromURL, renderApiRoute, getApiRoutes, } from './utilities/apiRoutes';
 import { ServerPropsProvider } from './foundation/ServerPropsProvider';
 import { isBotUA } from './utilities/bot-ua';
-import { setContext, setCache } from './framework/runtime';
-import { setConfig } from './framework/config';
-import { ssrRenderToPipeableStream, ssrRenderToReadableStream, rscRenderToReadableStream, createFromReadableStream, isStreamingSupported, bufferReadableStream, } from './streaming.server';
+import { setCache } from './foundation/runtime';
+import { ssrRenderToPipeableStream, ssrRenderToReadableStream, rscRenderToReadableStream, createFromReadableStream, bufferReadableStream, } from './streaming.server';
 import { RSC_PATHNAME, EVENT_PATHNAME, EVENT_PATHNAME_REGEX } from './constants';
 import { stripScriptsFromTemplate } from './utilities/template';
+import { setLogger } from './utilities/log/log';
 import { Analytics } from './foundation/Analytics/Analytics.server';
 import { ServerAnalyticsRoute } from './foundation/Analytics/ServerAnalyticsRoute.server';
 import { getSyncSessionApi } from './foundation/session/session';
 import { parseJSON } from './utilities/parse';
 import { htmlEncode } from './utilities';
+import { splitCookiesString } from 'set-cookie-parser';
 const DOCTYPE = '<!DOCTYPE html>';
 const CONTENT_TYPE = 'Content-Type';
 const HTML_CONTENT_TYPE = 'text/html; charset=UTF-8';
 export const renderHydrogen = (App) => {
     const handleRequest = async function (rawRequest, options) {
-        const { indexTemplate, streamableResponse, dev, cache, context, nonce, buyerIpHeader, } = options;
-        const request = new ServerComponentRequest(rawRequest);
+        const { dev, nonce, cache, context, buyerIpHeader, indexTemplate, streamableResponse: nodeResponse, } = options;
+        const request = new HydrogenRequest(rawRequest);
         const url = new URL(request.url);
         const { default: inlineHydrogenConfig } = await import(
         // @ts-ignore
@@ -41,151 +41,122 @@ export const renderHydrogen = (App) => {
         };
         request.ctx.hydrogenConfig = hydrogenConfig;
         request.ctx.buyerIpHeader = buyerIpHeader;
+        setLogger(hydrogenConfig.logger);
         const log = getLoggerWithContext(request);
+        const response = new HydrogenResponse();
         const sessionApi = hydrogenConfig.session
             ? hydrogenConfig.session(log)
             : undefined;
-        const componentResponse = new ServerComponentResponse();
-        request.ctx.session = getSyncSessionApi(request, componentResponse, log, sessionApi);
+        request.ctx.session = getSyncSessionApi(request, response, log, sessionApi);
         /**
          * Inject the cache & context into the module loader so we can pull it out for subrequests.
          */
+        request.ctx.runtime = context;
         setCache(cache);
-        setContext(context);
-        setConfig({ dev });
         if (url.pathname === EVENT_PATHNAME ||
             EVENT_PATHNAME_REGEX.test(url.pathname)) {
             return ServerAnalyticsRoute(request, hydrogenConfig.serverAnalyticsConnectors);
         }
-        const isReactHydrationRequest = url.pathname === RSC_PATHNAME;
-        if (!isReactHydrationRequest) {
-            const apiRoute = getApiRoute(url, hydrogenConfig.routes);
-            // The API Route might have a default export, making it also a server component
-            // If it does, only render the API route if the request method is GET
-            if (apiRoute &&
-                (!apiRoute.hasServerComponent || request.method !== 'GET')) {
-                const apiResponse = await renderApiRoute(request, apiRoute, hydrogenConfig.shopify, sessionApi);
-                return apiResponse instanceof Request
-                    ? handleRequest(apiResponse, options)
-                    : apiResponse;
-            }
+        const isRSCRequest = url.pathname === RSC_PATHNAME;
+        const apiRoute = !isRSCRequest && getApiRoute(url, hydrogenConfig.routes);
+        // The API Route might have a default export, making it also a server component
+        // If it does, only render the API route if the request method is GET
+        if (apiRoute &&
+            (!apiRoute.hasServerComponent || request.method !== 'GET')) {
+            const apiResponse = await renderApiRoute(request, apiRoute, hydrogenConfig.shopify, sessionApi);
+            return apiResponse instanceof Request
+                ? handleRequest(apiResponse, options)
+                : apiResponse;
+        }
+        const state = isRSCRequest
+            ? parseJSON(url.searchParams.get('state') || '{}')
+            : { pathname: url.pathname, search: url.search };
+        const rsc = runRSC({ App, state, log, request, response });
+        if (isRSCRequest) {
+            const buffered = await bufferReadableStream(rsc.readable.getReader());
+            postRequestTasks('rsc', 200, request, response);
+            return new Response(buffered, {
+                headers: { 'cache-control': response.cacheControlHeader },
+            });
         }
-        const isStreamable = (hydrogenConfig.enableStreaming
-            ? hydrogenConfig.enableStreaming(request)
-            : true) &&
-            !isBotUA(url, request.headers.get('user-agent')) &&
-            (!!streamableResponse || (await isStreamingSupported()));
-        let template = typeof indexTemplate === 'function'
-            ? await indexTemplate(url.toString())
-            : indexTemplate;
-        if (template && typeof template !== 'string') {
-            template = template.default;
+        if (isBotUA(url, request.headers.get('user-agent'))) {
+            response.doNotStream();
         }
-        const params = {
-            App,
+        return runSSR({
             log,
             dev,
+            rsc,
             nonce,
+            state,
             request,
-            template,
-            isStreamable,
-            componentResponse,
-            response: streamableResponse,
-        };
-        if (isReactHydrationRequest) {
-            return hydrate(url, params);
-        }
-        /**
-         * Stream back real-user responses, but for bots/etc,
-         * use `render` instead. This is because we need to inject <head>
-         * things for SEO reasons.
-         */
-        if (isStreamable) {
-            return stream(url, params);
-        }
-        return render(url, params);
+            response,
+            nodeResponse,
+            template: await getTemplate(indexTemplate, url),
+        });
     };
-    if (__WORKER__)
+    if (__HYDROGEN_WORKER__)
         return handleRequest;
     return ((rawRequest, options) => handleFetchResponseInNode(handleRequest(rawRequest, options), options.streamableResponse));
 };
+async function getTemplate(indexTemplate, url) {
+    let template = typeof indexTemplate === 'function'
+        ? await indexTemplate(url.toString())
+        : indexTemplate;
+    if (template && typeof template !== 'string') {
+        template = template.default;
+    }
+    return template;
+}
 function getApiRoute(url, routes) {
     const apiRoutes = getApiRoutes(routes);
     return getApiRouteFromURL(url, apiRoutes);
 }
-/**
- * The render function is responsible for turning the provided `App` into an HTML string,
- * and returning any initial state that needs to be hydrated into the client version of the app.
- * NOTE: This is currently only used for SEO bots or Worker runtime (where Stream is not yet supported).
- */
-async function render(url, { App, request, template, componentResponse, nonce, log }) {
-    const state = { pathname: url.pathname, search: url.search };
-    const { AppSSR, rscReadable } = buildAppSSR({
-        App,
-        log,
-        state,
-        request,
-        response: componentResponse,
-    }, { template });
-    function onErrorShell(error) {
-        log.error(error);
-        componentResponse.writeHead({ status: 500 });
-        return template;
+function assembleHtml({ ssrHtml, rscPayload, request, template, }) {
+    let html = applyHtmlHead(ssrHtml, request.ctx.head, template);
+    if (rscPayload) {
+        html = html.replace('</body>',
+        // This must be a function to avoid replacing
+        // special patterns like `$1` in `String.replace`.
+        () => flightContainer(rscPayload) + '</body>');
     }
-    let [html, flight] = await Promise.all([
-        renderToBufferedString(AppSSR, { log, nonce }).catch(onErrorShell),
-        bufferReadableStream(rscReadable.getReader()).catch(() => null),
-    ]);
-    const { headers, status, statusText } = getResponseOptions(componentResponse);
-    /**
-     * TODO: Also add `Vary` headers for `accept-language` and any other keys
-     * we want to shard our full-page cache for all Hydrogen storefronts.
-     */
-    headers.set('cache-control', componentResponse.cacheControlHeader);
-    headers.set(CONTENT_TYPE, HTML_CONTENT_TYPE);
-    html = applyHtmlHead(html, request.ctx.head, template);
-    if (flight) {
-        html = html.replace('</body>', () => flightContainer(flight) + '</body>');
-    }
-    postRequestTasks('ssr', status, request, componentResponse);
-    return new Response(html, {
-        status,
-        statusText,
-        headers,
-    });
+    return html;
 }
 /**
- * Stream a response to the client. NOTE: This omits custom `<head>`
- * information, so this method should not be used by crawlers.
+ * Run the SSR/Fizz part of the App. If streaming is disabled,
+ * this buffers the output and applies SEO enhancements.
  */
-async function stream(url, { App, request, response, componentResponse, template, nonce, dev, log, }) {
-    var _a;
-    const state = { pathname: url.pathname, search: url.search };
-    log.trace('start stream');
-    const { noScriptTemplate, bootstrapScripts, bootstrapModules } = stripScriptsFromTemplate(template);
-    const { AppSSR, rscReadable, rscDidError } = buildAppSSR({
-        App,
-        log,
-        state,
-        request,
-        response: componentResponse,
-    }, { template: noScriptTemplate });
-    const rscToScriptTagReadable = new ReadableStream({
-        start(controller) {
-            log.trace('rsc start chunks');
-            const encoder = new TextEncoder();
-            bufferReadableStream(rscReadable.getReader(), (chunk) => {
-                const metaTag = flightContainer(chunk);
-                controller.enqueue(encoder.encode(metaTag));
-            }).then(() => {
-                log.trace('rsc finish chunks');
-                return controller.close();
-            });
-        },
-    });
+async function runSSR({ rsc, state, request, response, nodeResponse, template, nonce, dev, log, }) {
     let ssrDidError;
-    if (__WORKER__) {
-        const onCompleteAll = defer();
+    const didError = () => { var _a; return (_a = rsc.didError()) !== null && _a !== void 0 ? _a : ssrDidError; };
+    const [rscReadableForFizz, rscReadableForFlight] = rsc.readable.tee();
+    const rscResponse = createFromReadableStream(rscReadableForFizz);
+    const RscConsumer = () => rscResponse.readRoot();
+    const { noScriptTemplate, bootstrapScripts, bootstrapModules } = stripScriptsFromTemplate(template);
+    const AppSSR = (React.createElement(Html, { template: response.canStream() ? noScriptTemplate : template, hydrogenConfig: request.ctx.hydrogenConfig },
+        React.createElement(ServerRequestProvider, { request: request, isRSC: false },
+            React.createElement(ServerPropsProvider, { initialServerProps: state, setServerPropsForRsc: () => { } },
+                React.createElement(PreloadQueries, { request: request },
+                    React.createElement(Suspense, { fallback: null },
+                        React.createElement(RscConsumer, null)),
+                    React.createElement(Suspense, { fallback: null },
+                        React.createElement(Analytics, null)))))));
+    log.trace('start ssr');
+    const rscReadable = response.canStream()
+        ? new ReadableStream({
+            start(controller) {
+                log.trace('rsc start chunks');
+                const encoder = new TextEncoder();
+                bufferReadableStream(rscReadableForFlight.getReader(), (chunk) => {
+                    const metaTag = flightContainer(chunk);
+                    controller.enqueue(encoder.encode(metaTag));
+                }).then(() => {
+                    log.trace('rsc finish chunks');
+                    return controller.close();
+                });
+            },
+        })
+        : rscReadableForFlight;
+    if (__HYDROGEN_WORKER__) {
         const encoder = new TextEncoder();
         const transform = new TransformStream();
         const writable = transform.writable.getWriter();
@@ -212,72 +183,82 @@ async function stream(url, { App, request, response, componentResponse, template
                 headers: { [CONTENT_TYPE]: HTML_CONTENT_TYPE },
             });
         }
-        log.trace('worker ready to stream');
-        ssrReadable.allReady.then(() => {
-            log.trace('worker complete stream');
-            onCompleteAll.resolve(true);
-        });
-        /* eslint-disable no-inner-declarations */
-        function prepareForStreaming(flush) {
-            Object.assign(responseOptions, getResponseOptions(componentResponse, rscDidError !== null && rscDidError !== void 0 ? rscDidError : ssrDidError));
+        if (response.canStream())
+            log.trace('worker ready to stream');
+        ssrReadable.allReady.then(() => log.trace('worker complete ssr'));
+        const prepareForStreaming = () => {
+            Object.assign(responseOptions, getResponseOptions(response, didError()));
             /**
              * TODO: This assumes `response.cache()` has been called _before_ any
              * queries which might be caught behind Suspense. Clarify this or add
              * additional checks downstream?
              */
-            responseOptions.headers.set('cache-control', componentResponse.cacheControlHeader);
+            /**
+             * TODO: Also add `Vary` headers for `accept-language` and any other keys
+             * we want to shard our full-page cache for all Hydrogen storefronts.
+             */
+            responseOptions.headers.set('cache-control', response.cacheControlHeader);
             if (isRedirect(responseOptions)) {
                 return false;
             }
-            if (flush) {
-                responseOptions.headers.set(CONTENT_TYPE, HTML_CONTENT_TYPE);
-                writable.write(encoder.encode(DOCTYPE));
-                if (rscDidError !== null && rscDidError !== void 0 ? rscDidError : ssrDidError) {
-                    // This error was delayed until the headers were properly sent.
-                    writable.write(encoder.encode(getErrorMarkup((rscDidError !== null && rscDidError !== void 0 ? rscDidError : ssrDidError))));
-                }
-                return true;
+            responseOptions.headers.set(CONTENT_TYPE, HTML_CONTENT_TYPE);
+            writable.write(encoder.encode(DOCTYPE));
+            const error = didError();
+            if (error) {
+                // This error was delayed until the headers were properly sent.
+                writable.write(encoder.encode(dev ? getErrorMarkup(error) : template));
             }
-        }
-        /* eslint-enable no-inner-declarations */
-        const shouldReturnApp = (_a = prepareForStreaming(componentResponse.canStream())) !== null && _a !== void 0 ? _a : (await onCompleteAll.promise.then(prepareForStreaming));
-        if (shouldReturnApp) {
+            return true;
+        };
+        const shouldFlushBody = response.canStream()
+            ? prepareForStreaming()
+            : await ssrReadable.allReady.then(prepareForStreaming);
+        if (shouldFlushBody) {
             let bufferedSsr = '';
             let isPendingSsrWrite = false;
-            const writingSSR = bufferReadableStream(ssrReadable.getReader(), (chunk) => {
-                bufferedSsr += chunk;
-                if (!isPendingSsrWrite) {
-                    isPendingSsrWrite = true;
-                    setTimeout(() => {
-                        isPendingSsrWrite = false;
-                        // React can write fractional chunks synchronously.
-                        // This timeout ensures we only write full HTML tags
-                        // in order to allow RSC writing concurrently.
-                        if (bufferedSsr) {
-                            writable.write(encoder.encode(bufferedSsr));
-                            bufferedSsr = '';
-                        }
-                    }, 0);
+            const writingSSR = bufferReadableStream(ssrReadable.getReader(), response.canStream()
+                ? (chunk) => {
+                    bufferedSsr += chunk;
+                    if (!isPendingSsrWrite) {
+                        isPendingSsrWrite = true;
+                        setTimeout(() => {
+                            isPendingSsrWrite = false;
+                            // React can write fractional chunks synchronously.
+                            // This timeout ensures we only write full HTML tags
+                            // in order to allow RSC writing concurrently.
+                            if (bufferedSsr) {
+                                writable.write(encoder.encode(bufferedSsr));
+                                bufferedSsr = '';
+                            }
+                        }, 0);
+                    }
+                }
+                : undefined);
+            const writingRSC = bufferReadableStream(rscReadable.getReader(), response.canStream()
+                ? (scriptTag) => writable.write(encoder.encode(scriptTag))
+                : undefined);
+            Promise.all([writingSSR, writingRSC]).then(([ssrHtml, rscPayload]) => {
+                if (!response.canStream()) {
+                    const html = assembleHtml({ ssrHtml, rscPayload, request, template });
+                    writable.write(encoder.encode(html));
                 }
-            });
-            const writingRSC = bufferReadableStream(rscToScriptTagReadable.getReader(), (scriptTag) => writable.write(encoder.encode(scriptTag)));
-            Promise.all([writingSSR, writingRSC]).then(() => {
                 // Last SSR write might be pending, delay closing the writable one tick
                 setTimeout(() => writable.close(), 0);
-                postRequestTasks('str', responseOptions.status, request, componentResponse);
+                postRequestTasks('str', responseOptions.status, request, response);
             });
         }
         else {
+            // Redirects do not write body
             writable.close();
-            postRequestTasks('str', responseOptions.status, request, componentResponse);
+            postRequestTasks('str', responseOptions.status, request, response);
         }
-        if (await isStreamingSupported()) {
+        if (response.canStream()) {
             return new Response(transform.readable, responseOptions);
         }
         const bufferedBody = await bufferReadableStream(transform.readable.getReader());
         return new Response(bufferedBody, responseOptions);
     }
-    else if (response) {
+    else if (nodeResponse) {
         const { pipe } = ssrRenderToPipeableStream(AppSSR, {
             nonce,
             bootstrapScripts,
@@ -289,59 +270,68 @@ async function stream(url, { App, request, response, componentResponse, template
                  * queries which might be caught behind Suspense. Clarify this or add
                  * additional checks downstream?
                  */
-                response.setHeader('cache-control', componentResponse.cacheControlHeader);
-                writeHeadToServerResponse(response, componentResponse, log, rscDidError !== null && rscDidError !== void 0 ? rscDidError : ssrDidError);
-                if (isRedirect(response)) {
+                writeHeadToNodeResponse(nodeResponse, response, log, didError());
+                if (isRedirect(nodeResponse)) {
                     // Return redirects early without further rendering/streaming
-                    return response.end();
+                    return nodeResponse.end();
                 }
-                if (!componentResponse.canStream())
+                if (!response.canStream())
                     return;
-                startWritingHtmlToServerResponse(response, dev ? rscDidError !== null && rscDidError !== void 0 ? rscDidError : ssrDidError : undefined);
+                startWritingToNodeResponse(nodeResponse, dev ? didError() : undefined);
                 setTimeout(() => {
                     log.trace('node pipe response');
-                    pipe(response);
+                    pipe(nodeResponse);
                 }, 0);
-                bufferReadableStream(rscToScriptTagReadable.getReader(), (chunk) => {
+                bufferReadableStream(rscReadable.getReader(), (chunk) => {
                     log.trace('rsc chunk');
-                    return response.write(chunk);
+                    return nodeResponse.write(chunk);
                 });
             },
-            onAllReady() {
-                log.trace('node complete stream');
-                if (componentResponse.canStream() || response.writableEnded) {
-                    postRequestTasks('str', response.statusCode, request, componentResponse);
+            async onAllReady() {
+                log.trace('node complete ssr');
+                if (response.canStream() || nodeResponse.writableEnded) {
+                    postRequestTasks('str', nodeResponse.statusCode, request, response);
                     return;
                 }
-                writeHeadToServerResponse(response, componentResponse, log, rscDidError !== null && rscDidError !== void 0 ? rscDidError : ssrDidError);
-                postRequestTasks('str', response.statusCode, request, componentResponse);
-                if (isRedirect(response)) {
+                writeHeadToNodeResponse(nodeResponse, response, log, didError());
+                if (isRedirect(nodeResponse)) {
                     // Redirects found after any async code
-                    return response.end();
+                    return nodeResponse.end();
                 }
-                startWritingHtmlToServerResponse(response, dev ? rscDidError !== null && rscDidError !== void 0 ? rscDidError : ssrDidError : undefined);
-                bufferReadableStream(rscToScriptTagReadable.getReader()).then((scriptTags) => {
-                    // Piping ends the response so script tags
-                    // must be written before that.
-                    response.write(scriptTags);
-                    pipe(response);
+                const bufferedResponse = await createNodeWriter();
+                const bufferedRscPromise = bufferReadableStream(rscReadable.getReader());
+                let ssrHtml = '';
+                bufferedResponse.on('data', (chunk) => (ssrHtml += chunk.toString()));
+                bufferedResponse.once('error', (error) => (ssrDidError = error));
+                bufferedResponse.once('end', async () => {
+                    const rscPayload = await bufferedRscPromise;
+                    const error = didError();
+                    startWritingToNodeResponse(nodeResponse, dev ? error : undefined);
+                    let html = template;
+                    if (!error) {
+                        html = assembleHtml({ ssrHtml, rscPayload, request, template });
+                        postRequestTasks('ssr', nodeResponse.statusCode, request, response);
+                    }
+                    nodeResponse.write(html);
+                    nodeResponse.end();
                 });
+                pipe(bufferedResponse);
             },
             onShellError(error) {
                 log.error(error);
-                if (!response.writableEnded) {
-                    writeHeadToServerResponse(response, componentResponse, log, error);
-                    startWritingHtmlToServerResponse(response, dev ? error : undefined);
-                    response.write(template);
-                    response.end();
+                if (!nodeResponse.writableEnded) {
+                    writeHeadToNodeResponse(nodeResponse, response, log, error);
+                    startWritingToNodeResponse(nodeResponse, dev ? error : undefined);
+                    nodeResponse.write(template);
+                    nodeResponse.end();
                 }
             },
             onError(error) {
                 ssrDidError = error;
-                if (dev && response.headersSent) {
+                if (dev && nodeResponse.headersSent) {
                     // Calling write would flush headers automatically.
                     // Delay this error until headers are properly sent.
-                    response.write(getErrorMarkup(error));
+                    nodeResponse.write(getErrorMarkup(error));
                 }
                 log.error(error);
             },
@@ -349,150 +339,66 @@ async function stream(url, { App, request, response, componentResponse, template
     }
 }
 /**
- * Stream a hydration response to the client.
+ * Run the RSC/Flight part of the App
  */
-async function hydrate(url, { App, log, request, response, isStreamable, componentResponse, }) {
-    const state = parseJSON(url.searchParams.get('state') || '{}');
-    const { AppRSC } = buildAppRSC({
-        App,
-        log,
-        state,
-        request,
-        response: componentResponse,
-    });
-    const rscReadable = rscRenderToReadableStream(AppRSC, {
-        onError(e) {
-            log.error(e);
-        },
-    });
-    const bufferedBody = await bufferReadableStream(rscReadable.getReader());
-    postRequestTasks('rsc', 200, request, componentResponse);
-    return new Response(bufferedBody, {
-        headers: {
-            'cache-control': componentResponse.cacheControlHeader,
-        },
-    });
-}
-function buildAppRSC({ App, log, state, request, response }) {
-    const hydrogenServerProps = { request, response, log };
-    const serverProps = {
-        ...state,
-        ...hydrogenServerProps,
-    };
+function runRSC({ App, state, log, request, response }) {
+    const serverProps = { ...state, request, response, log };
     request.ctx.router.serverProps = serverProps;
     const AppRSC = (React.createElement(ServerRequestProvider, { request: request, isRSC: true },
         React.createElement(PreloadQueries, { request: request },
             React.createElement(App, { ...serverProps }),
             React.createElement(Suspense, { fallback: null },
                 React.createElement(Analytics, null)))));
-    return { AppRSC };
-}
-function buildAppSSR({ App, state, request, response, log }, htmlOptions) {
-    const { AppRSC } = buildAppRSC({
-        App,
-        log,
-        state,
-        request,
-        response,
-    });
     let rscDidError;
-    const [rscReadableForFizz, rscReadableForFlight] = rscRenderToReadableStream(AppRSC, {
+    const rscReadable = rscRenderToReadableStream(AppRSC, {
         onError(e) {
             rscDidError = e;
             log.error(e);
         },
-    }).tee();
-    const rscResponse = createFromReadableStream(rscReadableForFizz);
-    const RscConsumer = () => rscResponse.readRoot();
-    const AppSSR = (React.createElement(Html, { ...htmlOptions },
-        React.createElement(ServerRequestProvider, { request: request, isRSC: false },
-            React.createElement(ServerPropsProvider, { initialServerProps: state, setServerPropsForRsc: () => { } },
-                React.createElement(PreloadQueries, { request: request },
-                    React.createElement(Suspense, { fallback: null },
-                        React.createElement(RscConsumer, null)),
-                    React.createElement(Suspense, { fallback: null },
-                        React.createElement(Analytics, null)))))));
-    return { AppSSR, rscReadable: rscReadableForFlight, rscDidError };
+    });
+    return { readable: rscReadable, didError: () => rscDidError };
 }
 function PreloadQueries({ request, children, }) {
     const preloadQueries = request.getPreloadQueries();
     preloadRequestCacheData(request, preloadQueries);
     return React.createElement(React.Fragment, null, children);
 }
-async function renderToBufferedString(ReactApp, { log, nonce }) {
-    if (__WORKER__) {
-        const ssrReadable = await ssrRenderToReadableStream(ReactApp, {
-            nonce,
-            onError: (error) => log.error(error),
-        });
-        /**
-         * We want to wait until `allReady` resolves before fetching the
-         * stream body. Otherwise, React 18's streaming JS script/template tags
-         * will be included in the output and cause issues when loading
-         * the Client Components in the browser.
-         */
-        await ssrReadable.allReady;
-        return bufferReadableStream(ssrReadable.getReader());
-    }
-    else {
-        const writer = await createNodeWriter();
-        return new Promise((resolve, reject) => {
-            const { pipe } = ssrRenderToPipeableStream(ReactApp, {
-                nonce,
-                /**
-                 * When hydrating, we have to wait until `onCompleteAll` to avoid having
-                 * `template` and `script` tags inserted and rendered as part of the hydration response.
-                 */
-                onAllReady() {
-                    let data = '';
-                    writer.on('data', (chunk) => (data += chunk.toString()));
-                    writer.once('error', reject);
-                    writer.once('end', () => resolve(data));
-                    // Tell React to start writing to the writer
-                    pipe(writer);
-                },
-                onShellError: reject,
-                onError: (error) => log.error(error),
-            });
-        });
-    }
-}
 export default renderHydrogen;
-function startWritingHtmlToServerResponse(response, error) {
-    if (!response.headersSent) {
-        response.setHeader(CONTENT_TYPE, HTML_CONTENT_TYPE);
-        response.write(DOCTYPE);
+function startWritingToNodeResponse(nodeResponse, error) {
+    if (!nodeResponse.headersSent) {
+        nodeResponse.setHeader(CONTENT_TYPE, HTML_CONTENT_TYPE);
+        nodeResponse.write(DOCTYPE);
     }
     if (error) {
         // This error was delayed until the headers were properly sent.
-        response.write(getErrorMarkup(error));
+        nodeResponse.write(getErrorMarkup(error));
     }
 }
-function getResponseOptions({ headers, status, customStatus }, error) {
-    var _a, _b;
-    const responseInit = {};
-    responseInit.headers = headers;
-    if (error) {
-        responseInit.status = 500;
-    }
-    else {
-        responseInit.status = (_b = (_a = customStatus === null || customStatus === void 0 ? void 0 : customStatus.code) !== null && _a !== void 0 ? _a : status) !== null && _b !== void 0 ? _b : 200;
-        if (customStatus === null || customStatus === void 0 ? void 0 : customStatus.text) {
-            responseInit.statusText = customStatus.text;
-        }
+function getResponseOptions({ headers, status, statusText }, error) {
+    const responseInit = {
+        headers,
+        status: error ? 500 : status,
+    };
+    if (!error && statusText) {
+        responseInit.statusText = statusText;
     }
     return responseInit;
 }
-function writeHeadToServerResponse(response, serverComponentResponse, log, error) {
-    if (response.headersSent)
+function writeHeadToNodeResponse(nodeResponse, componentResponse, log, error) {
+    if (nodeResponse.headersSent)
         return;
-    log.trace('writeHeadToServerResponse');
-    const { headers, status, statusText } = getResponseOptions(serverComponentResponse, error);
-    response.statusCode = status;
+    log.trace('writeHeadToNodeResponse');
+    /**
+     * TODO: Also add `Vary` headers for `accept-language` and any other keys
+     * we want to shard our full-page cache for all Hydrogen storefronts.
+     */
+    nodeResponse.setHeader('cache-control', componentResponse.cacheControlHeader);
+    const { headers, status, statusText } = getResponseOptions(componentResponse, error);
+    nodeResponse.statusCode = status;
     if (statusText) {
-        response.statusMessage = statusText;
+        nodeResponse.statusMessage = statusText;
     }
-    setServerHeaders(headers, response);
+    setNodeHeaders(headers, nodeResponse);
 }
 function isRedirect(response) {
     var _a, _b;
@@ -504,16 +410,16 @@ async function createNodeWriter() {
     // when building for workers, even though this code
     // does not run in a worker. Looks like tree-shaking
     // kicks in after the import analysis/bundle.
-    const streamImport = __WORKER__ ? '' : 'stream';
+    const streamImport = __HYDROGEN_WORKER__ ? '' : 'stream';
     const { PassThrough } = await import(streamImport);
     return new PassThrough();
 }
 function flightContainer(chunk) {
     return `<meta data-flight="${htmlEncode(chunk)}" />`;
 }
-function postRequestTasks(type, status, request, componentResponse) {
+function postRequestTasks(type, status, request, response) {
     logServerResponse(type, request, status);
-    logCacheControlHeaders(type, request, componentResponse);
+    logCacheControlHeaders(type, request, response);
     logQueryTimings(type, request);
     request.savePreloadQueries();
 }
@@ -525,20 +431,38 @@ function handleFetchResponseInNode(fetchResponsePromise, nodeResponse) {
         fetchResponsePromise.then((response) => {
             if (!response)
                 return;
-            setServerHeaders(response.headers, nodeResponse);
+            setNodeHeaders(response.headers, nodeResponse);
             nodeResponse.statusCode = response.status;
             if (response.body) {
-                nodeResponse.write(response.body);
+                if (response.body instanceof ReadableStream) {
+                    bufferReadableStream(response.body.getReader(), (chunk) => {
+                        nodeResponse.write(chunk);
+                    }).then(() => nodeResponse.end());
+                }
+                else {
+                    nodeResponse.write(response.body);
+                    nodeResponse.end();
+                }
+            }
+            else {
+                nodeResponse.end();
             }
-            nodeResponse.end();
         });
     }
     return fetchResponsePromise;
 }
-// From fetch Headers to Node Response
-function setServerHeaders(headers, nodeResponse) {
-    // Headers.raw is only implemented in node-fetch, which is used by Hydrogen in dev and prod.
-    // It is the only way for now to access `set-cookie` header as an array.
-    // https://github.com/Shopify/hydrogen/issues/1228
-    Object.entries(headers.raw()).forEach(([key, value]) => nodeResponse.setHeader(key, value));
+/**
+ * Convert Headers to outgoing Node.js headers.
+ * Specifically, parse set-cookie headers to split them properly as separate
+ * `set-cookie` headers rather than a single, combined header.
+ */
+function setNodeHeaders(headers, nodeResponse) {
+    for (const [key, value] of headers.entries()) {
+        if (key.toLowerCase() === 'set-cookie') {
+            nodeResponse.setHeader(key, splitCookiesString(value));
+        }
+        else {
+            nodeResponse.setHeader(key, value);
+        }
+    }
 }