@lwrjs/lwc-ssr 0.17.2-alpha.2 → 0.17.2-alpha.20

package/build/cjs/viewTransformer/index.cjs

@@ -48,12 +48,8 @@ function lwcSsrViewTransformer(options, {config, moduleBundler, resourceRegistry
       if (!metadata.serverData) {
         metadata.serverData = {};
       }
-      if (!metadata.serverDebug) {
-        metadata.serverDebug = {};
-      }
       const allBundles = new Set([...metadata.serverBundles ?? []]);
-      const {customElements, serverData, serverDebug} = metadata;
-      const {debug} = viewContext.runtimeEnvironment;
+      const {customElements, serverData} = metadata;
       const ssrModules = getComponentsToSSR(customElements, stringBuilder);
       const rootSpecifiers = Object.values(ssrModules).map((m) => m.specifier);
       if (!rootSpecifiers.length) {
@@ -62,33 +58,39 @@ function lwcSsrViewTransformer(options, {config, moduleBundler, resourceRegistry
       const islands = rootSpecifiers.join(",");
       let pageTtl;
       await (0, import_instrumentation.getTracer)().trace({name: import_instrumentation.ViewSpan.RenderIsland, attributes: {specifiers: islands}}, async () => {
-        const route = routes.find((r) => r.id === viewContext.view.id);
-        if (!route) {
-          throw new Error(`Unable to resolve configuration for view: ${viewContext.view.id}`);
-        }
-        const {
-          results,
-          errors,
-          bundles: islandBundles
-        } = await (0, import_renderer.getRenderer)(config, moduleBundler, resourceRegistry).render(ssrModules, route, viewContext.runtimeEnvironment, viewContext.runtimeParams, metadata.serverData, false);
-        for (const root in results) {
-          const {html, props, cache} = results[root];
-          const {tagName, startOffset, endOffset, hydrate} = ssrModules[root];
-          pageTtl = (0, import_shared_utils.shortestTtl)(cache?.ttl, pageTtl);
-          if (html) {
-            let propsAttr = "";
-            if (hydrate) {
-              const propsId = (0, import_utils.getPropsId)();
-              propsAttr = ` ${import_utils.SSR_PROPS_ATTR}="${propsId}"`;
-              serverData[propsId] = props;
+        try {
+          const route = routes.find((r) => r.id === viewContext.view.id);
+          if (!route) {
+            throw new Error(`Unable to resolve configuration for view: ${viewContext.view.id}`);
+          }
+          const {
+            results,
+            warnings,
+            bundles: islandBundles
+          } = await (0, import_renderer.getRenderer)(config, moduleBundler, resourceRegistry).render(ssrModules, route, viewContext.runtimeEnvironment, viewContext.runtimeParams, metadata.serverData, false);
+          for (const root in results) {
+            const {html, props, cache} = results[root] || {};
+            const {tagName, startOffset, endOffset, hydrate} = ssrModules[root];
+            pageTtl = (0, import_shared_utils.shortestTtl)(cache?.ttl, pageTtl);
+            if (html) {
+              let propsAttr = "";
+              if (hydrate) {
+                const propsId = (0, import_utils.getPropsId)();
+                propsAttr = ` ${import_utils.SSR_PROPS_ATTR}="${propsId}"`;
+                serverData[propsId] = props;
+              }
+              const [, remain] = html.split(`<${tagName}`);
+              stringBuilder.overwrite(startOffset, endOffset, [`<${tagName}`, propsAttr, remain].join(""));
             }
-            const [, remain] = html.split(`<${tagName}`);
-            stringBuilder.overwrite(startOffset, endOffset, [`<${tagName}`, propsAttr, remain].join(""));
           }
+          (0, import_utils.mergeWarnings)(metadata, warnings);
+          metadata.serverBundles = islandBundles ? new Set([...allBundles, ...islandBundles]) : allBundles;
+          results && (0, import_shared_utils.addHeadMarkup)(Object.values(results).map((r) => r.markup), stringBuilder);
+        } catch (e) {
+          if (e instanceof import_diagnostics.LwrError)
+            throw e;
+          throw new import_diagnostics.LwrApplicationError(import_diagnostics.descriptions.APPLICATION.SSR_ERROR(islands, (0, import_diagnostics.stringifyError)(e)));
         }
-        metadata.serverBundles = islandBundles ? new Set([...allBundles, ...islandBundles]) : allBundles;
-        results && (0, import_utils.addHeadMarkup)(Object.values(results), stringBuilder);
-        errors && handleErrors(errors, customElements, islands, debug, serverDebug);
       });
       import_diagnostics.logger.verbose({
         label: "lwcSsrViewTransformer",
@@ -118,22 +120,3 @@ function getComponentsToSSR(customElements, stringBuilder) {
   }
   return cmpInfo;
 }
-function handleErrors(errors, customElements, specifiers, debug, serverDebug) {
-  const allErrors = Object.values(errors).join(", ");
-  if (!debug || (0, import_shared_utils.isLocalDev)() && process.env.SSR_THROW_ERRORS === "true") {
-    throw new import_diagnostics.LwrApplicationError(import_diagnostics.descriptions.APPLICATION.SSR_ERROR(specifiers, allErrors));
-  }
-  Object.entries(errors).forEach(([specifier, err]) => {
-    const ce = customElements.find(({tagName}) => specifier === (0, import_shared_utils.kebabCaseToModuleSpecifier)(tagName));
-    if (ce) {
-      ce.props === void 0 ? ce.props = {
-        [import_shared_utils.HYDRATE_DIRECTIVE]: import_shared_utils.HYDRATE_CLIENT_VALUE
-      } : ce.props[import_shared_utils.HYDRATE_DIRECTIVE] = import_shared_utils.HYDRATE_CLIENT_VALUE;
-    }
-    const errMessage = (0, import_utils.createSsrErrorMessage)(specifier, err);
-    import_diagnostics.logger.warn(errMessage, err);
-  });
-  if (debug) {
-    serverDebug.message = (0, import_utils.createSsrErrorMessage)(specifiers, allErrors);
-  }
-}

package/build/es/dataViewTransformer/index.js

@@ -1,6 +1,7 @@
-import { logger } from '@lwrjs/diagnostics';
+import { descriptions, logger, LwrStatusError, stringifyError } from '@lwrjs/diagnostics';
 import { ViewSpan, getTracer } from '@lwrjs/instrumentation';
-import { addHeadMarkup } from '../utils.js';
+import { addHeadMarkup } from '@lwrjs/shared-utils';
+import { mergeWarnings } from '../utils.js';
 import { getRenderer } from '../renderer.js';
 const NAME = 'preload-data-transformer';
 /**
@@ -26,7 +27,7 @@ export default function preloadDataViewTransformer(_options, { config, moduleBun
                 return {}; // must be a CSRed rootComponent with preloadData ON
             }
             logger.debug({ label: NAME, message: `Preload data for root component "${rootComponent}"` });
-            const { results = {}, errors, bundles, } = await getTracer().trace({
+            const { results = {}, warnings, bundles, } = await getTracer().trace({
                 name: ViewSpan.PreloadData,
                 attributes: { rootComponent },
             }, async () => {
@@ -34,27 +35,33 @@ export default function preloadDataViewTransformer(_options, { config, moduleBun
                 if (!route) {
                     throw new Error(`Unable to resolve configuration for view: ${viewContext.view.id}`);
                 }
-                return await getRenderer(config, moduleBundler, resourceRegistry).render({ [rootComponent]: { specifier: rootComponent, props: {} } }, route, viewContext.runtimeEnvironment, viewContext.runtimeParams);
-            });
-            // If we find errors just log as warnings since these are SSR errors for a CSR page
-            if (errors) {
-                for (const err of Object.entries(errors)) {
-                    logger.warn({
-                        label: 'preloadDataViewTransformer',
-                        message: `Unexpected error during preload data: ${err[0]}`,
-                    }, err[1]);
+                try {
+                    return await getRenderer(config, moduleBundler, resourceRegistry).render({ [rootComponent]: { specifier: rootComponent, props: {} } }, route, viewContext.runtimeEnvironment, viewContext.runtimeParams);
+                }
+                catch (e) {
+                    // Pass redirects along
+                    if (e instanceof LwrStatusError)
+                        throw e;
+                    // If we find errors just log as warnings since these are SSR errors for a CSR page
+                    const message = descriptions.APPLICATION.PRELOAD_DATA_ERROR(rootComponent, stringifyError(e));
+                    logger.warn({ label: 'preloadDataViewTransformer', message });
+                    return { warnings: [message] }; // return 0 results
                 }
+            });
+            mergeWarnings(metadata, warnings);
+            const result = results[rootComponent];
+            if (!result) {
                 // Returns no data since there was an error loading modules
                 return {};
             }
             // Log and process the data response
-            const { props, markup, cache: { ttl } = { ttl: undefined }, status } = results[rootComponent];
+            const { props, markup, cache: { ttl } = { ttl: undefined } } = result || {};
             logger.verbose({ label: NAME, message: 'response', additionalInfo: props });
-            markup && addHeadMarkup([results[rootComponent]], stringBuilder); // add links to the <head> tag
+            markup && addHeadMarkup([result.markup], stringBuilder); // add links to the <head> tag
             metadata.serverData = metadata.serverData || {}; // create serverData if necessary
             Object.assign(metadata.serverData, props); // add the preloaded data to serverData for serialization
             metadata.serverBundles = bundles ? new Set([...allBundles, ...bundles]) : allBundles; // add server bundles for preloadData
-            return { cache: { ttl }, status };
+            return { cache: { ttl } };
         },
     };
 }

package/build/es/fetchController.d.ts

@@ -2,7 +2,6 @@ import type { DirectToCoreProxy } from '@lwrjs/types';
 export type FetchFunction = (request: string | URL | globalThis.Request, init?: RequestInit) => Promise<Response>;
 export type FetchRequestContext = {
     host?: string;
-    requestDepth?: number;
     headers?: HeadersInit | undefined;
     coreProxy?: DirectToCoreProxy;
     abortController?: AbortController;
@@ -22,7 +21,6 @@ export declare class FetchController {
     private abortController;
     private headers;
     private host;
-    private requestDepth;
     private coreProxy;
     fetchEndowment: FetchFunction;
     constructor(context: FetchRequestContext);

package/build/es/fetchController.js

@@ -1,8 +1,7 @@
 import { Pool as ClientPool } from 'undici';
 import { logger } from '@lwrjs/diagnostics';
 import { getTracer, ViewSpan } from '@lwrjs/instrumentation';
-import { REQUEST_DEPTH_HEADER } from '@lwrjs/shared-utils';
-const ROUTE_CORE_HEADER = 'X-SFDC-Route-Core';
+import { ROUTE_CORE_HEADER, getTraceHeaders, toHostname } from '@lwrjs/shared-utils';
 // a single Lambda only services 1 org, so this cache will not grow too large
 const CORE_CLIENTS = new Map();
 /**
@@ -67,10 +66,9 @@ export class FetchController {
             this.noOpActivated = false;
         };
         this.setFetchRequestContext = (context) => {
-            const { abortController, host, headers, requestDepth, coreProxy } = context;
+            const { abortController, host, headers, coreProxy } = context;
             this.host = host;
             this.headers = headers;
-            this.requestDepth = requestDepth;
             this.coreProxy = coreProxy;
             this.abortController = abortController;
         };
@@ -111,20 +109,14 @@ export class FetchController {
         });
     }
     createFetchEndowment() {
-        return (request, init) => {
-            const { host = '', requestDepth = 1, coreProxy } = this;
-            const origin = coreProxy?.origin && coreProxy.origin.startsWith('http') ? coreProxy.origin : host; // The Direct-to-Core proxy origin takes precedence over the Forwarded host
+        return (request, init = {}) => {
+            const { host: forwardedOrigin = '', coreProxy } = this;
+            // The Direct-to-Core proxy origin takes precedence over the Forwarded host
+            const origin = coreProxy?.origin && coreProxy.origin.startsWith('http') ? coreProxy.origin : forwardedOrigin;
             const { finalRequest, finalUrl } = this.getFinalRequest(request, origin);
-            const finalInit = {
-                ...init,
-                headers: {
-                    ...init?.headers,
-                    [REQUEST_DEPTH_HEADER]: String(requestDepth),
-                },
-            };
-            if (coreProxy || (host && finalUrl.startsWith(host))) {
+            if (coreProxy || (forwardedOrigin && finalUrl.startsWith(forwardedOrigin))) {
                 // hint for the CDN that the request is targeted to Core
-                finalInit.headers[ROUTE_CORE_HEADER] = 'true';
+                init.headers[ROUTE_CORE_HEADER] = 'true';
             }
             const proxyStr = coreProxy ? JSON.stringify(coreProxy) : 'none';
             const hasCookies = this.headers && this.headers.Cookie ? 'yes' : 'no';
@@ -137,7 +129,13 @@ export class FetchController {
             // Default URL to  final URL if successful addInfoToSpan will replace with response.url
             {
                 name: ViewSpan.Fetch,
-                attributes: { url: finalUrl, fetchType: 'cdn', coreProxy: proxyStr, hasCookies },
+                attributes: {
+                    url: finalUrl,
+                    fetchType: 'cdn',
+                    forwardedOrigin,
+                    coreProxy: proxyStr,
+                    hasCookies,
+                },
             }, (span) => {
                 // this trace will NOT fail if fetch fails; it is meant to log the URLs fetched from the server
                 // the fetch caller (ie: getServerData) should handle the error if response.ok is false
@@ -149,28 +147,30 @@ export class FetchController {
                     span.setAttributes({ statusCode: res.status });
                     return res;
                 };
+                // add tracing headers based on span values
+                init.headers = { ...init.headers, ...getTraceHeaders({}, span) };
                 if (coreProxy) {
-                    return this.fetchWithAgent(finalUrl, finalInit, host, coreProxy, span)
+                    return this.fetchWithAgent(finalUrl, init, forwardedOrigin, coreProxy, span)
                         .then((res) => addInfoToSpan(res))
                         .catch((err) => {
-                        const { finalRequest: cdnRequest, finalUrl: cdnUrl } = this.getFinalRequest(request, host);
+                        const { finalRequest: cdnRequest, finalUrl: cdnUrl } = this.getFinalRequest(request, forwardedOrigin);
                         logger.warn(`Fetching data directly from Core failed, retrying through CDN: ${cdnUrl} Error is: ${err.message || err}`);
                         span.setAttributes({ fetchType: 'cdnFallback' });
-                        return fetch(cdnRequest, finalInit).then((res) => addInfoToSpan(res));
+                        return fetch(cdnRequest, init).then((res) => addInfoToSpan(res));
                     });
                 }
-                return fetch(finalRequest, finalInit).then((res) => addInfoToSpan(res));
+                return fetch(finalRequest, init).then((res) => addInfoToSpan(res));
             });
         };
     }
-    getFinalRequest(request, host) {
+    getFinalRequest(request, origin) {
         let finalRequest;
         let finalUrl;
         if (request instanceof Request) {
             const curUrl = request.url;
-            // proxy relative URLs through the host
+            // proxy relative URLs through the origin
             if (curUrl.startsWith('/')) {
-                finalUrl = host + curUrl;
+                finalUrl = origin + curUrl;
                 finalRequest = new Request(finalUrl, request);
             }
             else {
@@ -180,25 +180,28 @@ export class FetchController {
         }
         else {
             const curUrl = typeof request === 'string' ? request : request.toString(); // handle string-able types, eg: URL
-            finalRequest = finalUrl = curUrl.startsWith('/') ? host + curUrl : curUrl; // proxy relative URLs through the host
+            finalRequest = finalUrl = curUrl.startsWith('/') ? origin + curUrl : curUrl; // proxy relative URLs through the origin
         }
         return { finalRequest, finalUrl };
     }
-    async fetchWithAgent(rawUrl, init, forwardedHost, coreProxy, span) {
+    async fetchWithAgent(rawUrl, init, forwardedOrigin, coreProxy, span) {
         let { origin, servername } = coreProxy;
-        const host = coreProxy.host ?? forwardedHost.replace(/^https?:\/\//, '');
+        const forwardedHostname = toHostname(forwardedOrigin);
+        const hostHeader = coreProxy.host ?? forwardedHostname;
         const ENHANCED_DOMAIN_TLD = '.site.com';
         const MY_DOMAIN_TLD = '.salesforce.com';
-        if (forwardedHost.endsWith(ENHANCED_DOMAIN_TLD)) {
+        if (forwardedHostname.endsWith(ENHANCED_DOMAIN_TLD)) {
+            const myHostname = forwardedHostname.slice(0, -ENHANCED_DOMAIN_TLD.length) + MY_DOMAIN_TLD;
             // use the Salesforce TLD by replacing the Site TLD
             // caller must be an Enhanced Domain on Cloudflare
-            origin = forwardedHost.slice(0, -ENHANCED_DOMAIN_TLD.length) + MY_DOMAIN_TLD;
+            origin = 'https://' + myHostname;
             // do not use SNI with the Enhanced Domain route
-            servername = origin;
+            // never include a protocol in the servername
+            servername = myHostname;
         }
         else if (origin.startsWith('.')) {
             // use the CDN origin if the leading '.' is missing in the coreProxy origin
-            origin = forwardedHost + origin;
+            origin = 'https://' + forwardedHostname + origin;
         }
         const urlParts = new URL(rawUrl);
         const path = urlParts.pathname + urlParts.search;
@@ -209,7 +212,7 @@ export class FetchController {
             fetchType: 'direct',
             url,
             coreUrl: url,
-            coreHostHeader: host,
+            coreHostHeader: hostHeader,
             coreServername: servername,
         });
         let client = CORE_CLIENTS.get(origin);
@@ -227,7 +230,7 @@ export class FetchController {
             // @ts-ignore - HttpMethod not available for typecasting :|
             method: init.method || 'GET',
             path,
-            headers: { ...init?.headers, Host: host },
+            headers: { ...init?.headers, Host: hostHeader },
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore - not properly typed >:|
             servername,

package/build/es/moduleLoader.js

@@ -13,7 +13,7 @@ export function createModuleLoader(config, resourceRegistry, bundleRegistry, run
 async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData, bootstrapConfig, abortController) {
     // creating a render context to avoid polluting globals
     const loaderConfig = getLoaderConfig(BOOTSTRAP_SPECIFIER, config, runtimeParams, serverData);
-    const { context, controller } = createContext(loaderConfig, runtimeParams, runtimeEnvironment, abortController);
+    const { context, controller } = createContext(loaderConfig, runtimeParams, abortController);
     const contextKeyMap = new Map(Object.keys(context).map((key) => [key, true]));
     // attaching custom init to delay bootstrap module evaluation
     let run;
@@ -238,10 +238,9 @@ async function createESMModuleLoader() {
  * @param runtimeParams - request parameters
  * @returns a `globalThis` object
  */
-function createContext(LWR, runtimeParams, runtimeEnvironment, abortController) {
+function createContext(LWR, runtimeParams, abortController) {
     const fetchController = new FetchController({
         host: runtimeParams.host,
-        requestDepth: runtimeParams.requestDepth,
         coreProxy: runtimeParams.coreProxy,
         abortController,
     });

package/build/es/renderer.d.ts

@@ -13,7 +13,7 @@ export interface ServerResults extends SsrDataResponse {
 }
 export interface RenderResults {
     results?: Record<string, ServerResults>;
-    errors?: Record<string, string>;
+    warnings: (Error | string)[];
     bundles?: Set<BundleDefinition>;
 }
 /**
@@ -50,7 +50,7 @@ export declare class Renderer {
      * @param runtimeEnvironment - environment context
      * @param runtimeParams - request context
      * @param serverData - render data TODO serverData is modified (add test?)
-     * @returns render results and errors per component
+     * @returns render results per component
      */
     render(components: Record<string, Component>, route: NormalizedLwrRoute | NormalizedLwrErrorRoute, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams, serverData?: ServerData, isFirstOf2PassSSR?: boolean): Promise<RenderResults>;
     private renderComponents;

package/build/es/renderer.js

@@ -1,7 +1,7 @@
 // TODO: investigate perf impact W-16056356
 import { LRUCache } from 'lru-cache';
-import { LwrApplicationError, descriptions, logger, stringifyError } from '@lwrjs/diagnostics';
-import { buildEnvironmentContext, getCacheKeyFromJson, getSpecifier, isLambdaEnv, moduleSpecifierToKebabCase, getFeatureFlags, TaskPool, isLocalDev, cookieStringToObject, } from '@lwrjs/shared-utils';
+import { LwrApplicationError, LwrError, LwrStatusError, descriptions, logger, stringifyError, } from '@lwrjs/diagnostics';
+import { REQUEST_DEPTH_HEADER, TaskPool, buildEnvironmentContext, cookieStringToObject, getCacheKeyFromJson, getFeatureFlags, getSpecifier, getTraceHeaders, isLambdaEnv, isLocalDev, moduleSpecifierToKebabCase, } from '@lwrjs/shared-utils';
 import { ViewSpan, cacheCountStore, getTracer } from '@lwrjs/instrumentation';
 import { getServerBootstrapServices, getRenderTimeout } from './utils.js';
 import { createModuleLoader } from './moduleLoader.js';
@@ -61,7 +61,7 @@ export class Renderer {
      * @param runtimeEnvironment - environment context
      * @param runtimeParams - request context
      * @param serverData - render data TODO serverData is modified (add test?)
-     * @returns render results and errors per component
+     * @returns render results per component
      */
     async render(components, route, runtimeEnvironment, runtimeParams, serverData = {}, isFirstOf2PassSSR) {
         let result;
@@ -93,7 +93,7 @@ export class Renderer {
     }
     async renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData = {}, isFirstOf2PassSSR = false, abortController) {
         const results = {};
-        const errors = {};
+        const warnings = [];
         const roots = Object.keys(components);
         const services = getServerBootstrapServices(route);
         // For LWR@MRT, module re-evaluation is enabled by default
@@ -111,48 +111,24 @@ export class Renderer {
             // When `REEVALUATE_MODULES` is enabled, we only have a single context/loader, regardless of env
             let lwcEngine, serverBootstrapServices;
             ({ bootstrapServiceEvaluationMap, loader, lwcEngine, serverBootstrapServices } =
-                await this.createLoader(components, route, serverData, isFirstOf2PassSSR, services, errors, runtimeEnvironment, runtimeParams, abortController));
+                await this.createLoader(components, route, serverData, isFirstOf2PassSSR, services, runtimeEnvironment, runtimeParams, abortController));
             // load root component modules (and dependencies)
             const componentModules = await this.loadAppCode(components, route, roots, loader);
             // Execute Services that fetch application data
-            await this.executeDataServices(components, route, serverBootstrapServices, componentModules, serverData, results, errors, runtimeEnvironment, runtimeParams);
+            await this.executeDataServices(components, route, serverBootstrapServices, componentModules, serverData, results, warnings, runtimeEnvironment, runtimeParams);
             // exit early when preloading data
             if (!route.bootstrap.ssr) {
-                if (Object.keys(errors).length) {
-                    return { results, errors };
-                }
-                return { results, bundles: loader?.getBundles() };
+                return { results, warnings, bundles: loader?.getBundles() };
             }
             // Assumed in SINGLE_RENDER mode to enable no-op during renderCmp phase.
             loader?.getFetchController().enableNoOpFetch();
             // render components
             for (const component of componentModules) {
-                // skip rendering if an error has already occurred for the component
-                if (errors[component.specifier]) {
-                    continue;
-                }
                 // eslint-disable-next-line no-await-in-loop
-                const { html, error } = await renderToString(lwcEngine.module, component, results[component.specifier].props);
-                if (error) {
-                    errors[component.specifier] = error;
-                    continue;
-                }
+                const { html } = await renderToString(lwcEngine.module, component, results[component.specifier].props);
                 results[component.specifier].html = html;
             }
-            const bundles = loader?.getBundles();
-            if (Object.keys(errors).length) {
-                return { results, errors, bundles };
-            }
-            return { results, bundles };
-        }
-        catch (e) {
-            const error = Object(e);
-            return {
-                errors: {
-                    [roots.join(',')]: error.message ?? stringifyError(e),
-                },
-                bundles: loader?.getBundles(),
-            };
+            return { results, warnings, bundles: loader?.getBundles() };
         }
         finally {
             // Assumed in SINGLE_RENDER mode
@@ -205,7 +181,7 @@ export class Renderer {
     /**
      * Run bootstrap services and fetch server data
      */
-    async executeDataServices(components, route, serverBootstrapServices, componentModules, serverData, results, errors, runtimeEnvironment, runtimeParams) {
+    async executeDataServices(components, route, serverBootstrapServices, componentModules, serverData, results, warnings, runtimeEnvironment, runtimeParams) {
         return getTracer().trace({
             name: ViewSpan.ExecuteServices,
             attributes: {
@@ -237,14 +213,11 @@ export class Renderer {
                     crossRequestCache: this.globalCache,
                 };
                 // eslint-disable-next-line
-                const { data, error } = await getServerData(component, context, serverData);
-                if (error) {
-                    errors[component.specifier] = error;
-                    continue;
-                }
+                const data = await getServerData(component, context, serverData);
                 if (data) {
                     results[component.specifier] = data;
                 }
+                data.warnings && warnings.push(...data.warnings);
             }
             if (serverBootstrapServices) {
                 // now that we have server data, run the server data hooks
@@ -255,7 +228,7 @@ export class Renderer {
     /**
      * Create and initialize the loader and LWC engine for SSR
      */
-    async createLoader(components, route, serverData, isFirstOf2PassSSR, services, errors, runtimeEnvironment, runtimeParams, abortController) {
+    async createLoader(components, route, serverData, isFirstOf2PassSSR, services, runtimeEnvironment, runtimeParams, abortController) {
         return getTracer().trace({
             name: ViewSpan.CreateLoader,
             attributes: {
@@ -301,10 +274,7 @@ export class Renderer {
                         // this is where the loader and server data hooks are set
                         for (const service of serviceModules) {
                             // eslint-disable-next-line
-                            const error = await evaluateServerBootstrapModule(service, serverBootstrapServices.serviceAPI);
-                            if (error) {
-                                errors[service.specifier] = error;
-                            }
+                            await evaluateServerBootstrapModule(service, serverBootstrapServices.serviceAPI);
                         }
                     }
                     const ret = {
@@ -331,15 +301,15 @@ export class Renderer {
     resetFetchController(fetchController, runtimeParams, route, abortController) {
         // Re-enable fetch that was disabled at the end of the previous page render via `enableFetchKillSwitch`
         fetchController.disableFetchKillSwitch();
+        const baseHeaders = {
+            [REQUEST_DEPTH_HEADER]: runtimeParams.requestDepth ?? '0',
+            ...getTraceHeaders(runtimeParams),
+        };
         fetchController.setFetchRequestContext({
             host: runtimeParams.host,
-            requestDepth: runtimeParams.requestDepth,
             headers: route.bootstrap.includeCookiesForSSR
-                ? {
-                    Cookie: runtimeParams.cookie,
-                    'True-Client-IP': runtimeParams.trueClientIP,
-                }
-                : { 'True-Client-IP': runtimeParams.trueClientIP },
+                ? { Cookie: runtimeParams.cookie, ...baseHeaders }
+                : baseHeaders,
             coreProxy: runtimeParams.coreProxy,
             abortController,
         });
@@ -396,29 +366,44 @@ function getServerData(component, context, serverData) {
         try {
             const data = await component.module.getServerData(context);
             Object.assign(serverData, data.props);
-            return { data };
+            // TODO: delete with W-17406173 after consumers have migrated away from SsrDataResponse.status
+            const dataRes = data;
+            if (dataRes.status) {
+                const { code, location } = dataRes.status;
+                throw new LwrStatusError(undefined, code, location ? { location } : undefined);
+            }
+            return data;
         }
         catch (e) {
-            const message = `Error in "getServerData" for "${component.specifier}": ${stringifyError(e)}`;
-            logger.error(message);
-            return { error: message };
+            if (e instanceof LwrError)
+                throw e;
+            // getServerData cannot import the LwrStatusError from "@lwrjs/dianostics", since it's a client code
+            // Once getServerData is decoupled from root components (TD-0187092), then it can import from "@lwrjs/*" server modules
+            const statusError = e;
+            if (typeof statusError.status === 'number') {
+                throw new LwrStatusError(statusError.message, statusError.status, statusError.headers);
+            }
+            throw new LwrApplicationError(`Error in "getServerData" for "${component.specifier}": ${stringifyError(e)}`);
         }
     });
 }
 async function renderToString(engine, component, props) {
+    const isSSRv2 = getFeatureFlags().SSR_COMPILER_ENABLED || false;
     return getTracer().trace({
         name: ViewSpan.RenderComponent,
-        attributes: { specifier: component.specifier },
+        attributes: { specifier: component.specifier, isSSRv2 },
     }, async () => {
         try {
             const elementName = moduleSpecifierToKebabCase(component.specifier);
             const moduleDefault = component.module.default;
-            const html = getFeatureFlags().SSR_COMPILER_ENABLED
+            const html = isSSRv2
                 ? await engine.renderComponent(elementName, moduleDefault, props, 'sync')
                 : engine.renderComponent(elementName, moduleDefault, props);
             return { html };
         }
         catch (e) {
+            if (e instanceof LwrError)
+                throw e;
             const error = Object(e);
             // add the LWC rendering stack to the error message
             const message = error.message ?? stringifyError(e);
@@ -428,8 +413,7 @@ async function renderToString(engine, component, props) {
                     '. Error was: ' +
                     message
                 : `An error occurred during server-side rendering "${component.specifier}": ` + message;
-            logger.error(detailedMessage);
-            return { error: detailedMessage };
+            throw new LwrApplicationError(detailedMessage);
         }
     });
 }

package/build/es/serverBootstrapServices.d.ts

@@ -12,5 +12,5 @@ export declare class ServerBootstrapServices {
     private registerRequestHooks;
 }
 export declare function createServerBootstrapServices(loader: ModuleLoader): ServerBootstrapServices;
-export declare function evaluateServerBootstrapModule(serviceModule: any, serviceApi: ServerServiceAPI): Promise<string | undefined>;
+export declare function evaluateServerBootstrapModule(serviceModule: any, serviceApi: ServerServiceAPI): Promise<void>;
 //# sourceMappingURL=serverBootstrapServices.d.ts.map

package/build/es/serverBootstrapServices.js

@@ -1,5 +1,5 @@
 import { ViewSpan, getTracer } from '@lwrjs/instrumentation';
-import { logger, stringifyError } from '@lwrjs/diagnostics';
+import { LwrApplicationError, LwrError, stringifyError } from '@lwrjs/diagnostics';
 export class ServerBootstrapServices {
     evaluateServerDataHooks(serverData = {}) {
         // now that we have server data, run the server data hooks
@@ -48,9 +48,9 @@ export function evaluateServerBootstrapModule(serviceModule, serviceApi) {
             await serviceModule.module.default(serviceApi);
         }
         catch (e) {
-            const message = `An SSR error occurred in bootstrap service "${serviceModule.specifier}": ${stringifyError(e)}`;
-            logger.error(message);
-            return message;
+            if (e instanceof LwrError)
+                throw e;
+            throw new LwrApplicationError(`An SSR error occurred in bootstrap service "${serviceModule.specifier}": ${stringifyError(e)}`);
         }
     });
 }