@lwrjs/lwc-ssr 0.17.2-alpha.9 → 0.18.0

package/build/cjs/dataViewTransformer/index.cjs

@@ -28,6 +28,7 @@ __export(exports, {
 });
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_utils = __toModule(require("../utils.cjs"));
 var import_renderer = __toModule(require("../renderer.cjs"));
 var NAME = "preload-data-transformer";
@@ -71,7 +72,7 @@ function preloadDataViewTransformer(_options, {config, moduleBundler, resourceRe
       }
       const {props, markup, cache: {ttl} = {ttl: void 0}} = result || {};
       import_diagnostics.logger.verbose({label: NAME, message: "response", additionalInfo: props});
-      markup && (0, import_utils.addHeadMarkup)([result], stringBuilder);
+      markup && (0, import_shared_utils.addHeadMarkup)([result.markup], stringBuilder);
       metadata.serverData = metadata.serverData || {};
       Object.assign(metadata.serverData, props);
       metadata.serverBundles = bundles ? new Set([...allBundles, ...bundles]) : allBundles;

package/build/cjs/fetchController.cjs

@@ -30,13 +30,12 @@ var import_undici = __toModule(require("undici"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-var ROUTE_CORE_HEADER = "X-SFDC-Route-Core";
 var CORE_CLIENTS = new Map();
 var FetchController = class {
   constructor(context) {
     this.controlledFetch = (request, init) => {
       if (this.killSwitchActivated) {
-        return this.handleAbortError(request, void 0);
+        return this.handleAbortError(request, "Kill switch was already enabled");
       }
       if (!this.abortController) {
         this.abortController = new AbortController();
@@ -49,7 +48,8 @@ var FetchController = class {
       };
       const fetchFunction = this.noOpActivated ? this.fetchNoOp(request, updatedInit) : this.fetchEndowment(request, updatedInit);
       const fetchPromise = fetchFunction.catch((error) => {
-        if (error && error?.stack.startsWith("AbortError")) {
+        const errorMsg = error.message || error;
+        if (error && (errorMsg.startsWith("AbortError") || error?.stack.startsWith("AbortError"))) {
           return this.handleAbortError(request, error);
         } else {
           throw error;
@@ -59,7 +59,7 @@ var FetchController = class {
     };
     this.activateKillSwitch = () => {
       this.killSwitchActivated = true;
-      this.abortController?.abort();
+      this.abortController?.abort("AbortError: Kill switch enabled");
       this.abortController = void 0;
     };
     this.deactivateKillSwitch = () => {
@@ -72,10 +72,9 @@ var FetchController = class {
       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;
     };
@@ -85,7 +84,7 @@ var FetchController = class {
     this.fetchEndowment = this.createFetchEndowment();
   }
   handleAbortError(request, error) {
-    const message = `Orphaned ${String(request)} request was killed. Either the request timed out or it was dispatched during SSR. Async processes are not supported during SSR. For more information, see: https://developer.salesforce.com/docs/platform/lwr/guide/lwr-configure-component-ssr.html.`;
+    const message = `${String(request)} request was killed. Either the request timed out or it was dispatched during SSR. Async processes are not supported during SSR. For more information, see: https://developer.salesforce.com/docs/platform/lwr/guide/lwr-configure-component-ssr.html.`;
     import_diagnostics.logger.warn({label: `Server-side Rendering`, message}, error);
     return Promise.resolve(new Response(message, {status: 500}));
   }
@@ -94,30 +93,23 @@ var FetchController = class {
       if (!init?.signal) {
         resolve(this.handleAbortError(request, new Error("RequestInit was not setup as expected")));
       } else if (init.signal.aborted) {
-        resolve(this.handleAbortError(request, new Error("Request was aborted")));
+        resolve(this.handleAbortError(request, new Error("Request was already aborted")));
       } else {
         const abortHandler = (err) => {
           init?.signal?.removeEventListener("abort", abortHandler);
-          resolve(this.handleAbortError(request, err));
+          resolve(this.handleAbortError(request, new Error("Not allowed: Request was dispatched during SSR", {cause: err})));
         };
         init.signal.addEventListener("abort", abortHandler);
       }
     });
   }
   createFetchEndowment() {
-    return (request, init) => {
-      const {host: forwardedOrigin = "", requestDepth = 1, coreProxy} = this;
+    return (request, init = {}) => {
+      const {host: forwardedOrigin = "", coreProxy} = this;
       const origin = coreProxy?.origin && coreProxy.origin.startsWith("http") ? coreProxy.origin : forwardedOrigin;
       const {finalRequest, finalUrl} = this.getFinalRequest(request, origin);
-      const finalInit = {
-        ...init,
-        headers: {
-          ...init?.headers,
-          [import_shared_utils.REQUEST_DEPTH_HEADER]: String(requestDepth)
-        }
-      };
       if (coreProxy || forwardedOrigin && finalUrl.startsWith(forwardedOrigin)) {
-        finalInit.headers[ROUTE_CORE_HEADER] = "true";
+        init.headers[import_shared_utils.ROUTE_CORE_HEADER] = "true";
       }
       const proxyStr = coreProxy ? JSON.stringify(coreProxy) : "none";
       const hasCookies = this.headers && this.headers.Cookie ? "yes" : "no";
@@ -140,15 +132,25 @@ var FetchController = class {
           span.setAttributes({statusCode: res.status});
           return res;
         };
+        const addErrorToSpan = (err) => {
+          span.setAttributes({error: (0, import_diagnostics.stringifyError)(err)});
+        };
+        init.headers = {...init.headers, ...(0, import_shared_utils.getTraceHeaders)({}, span)};
         if (coreProxy) {
-          return this.fetchWithAgent(finalUrl, finalInit, forwardedOrigin, coreProxy, span).then((res) => addInfoToSpan(res)).catch((err) => {
+          return this.fetchWithAgent(finalUrl, init, forwardedOrigin, coreProxy, span).then((res) => addInfoToSpan(res)).catch((err) => {
             const {finalRequest: cdnRequest, finalUrl: cdnUrl} = this.getFinalRequest(request, forwardedOrigin);
             import_diagnostics.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)).catch((e) => {
+              addErrorToSpan(e);
+              throw e;
+            });
           });
         }
-        return fetch(finalRequest, finalInit).then((res) => addInfoToSpan(res));
+        return fetch(finalRequest, init).then((res) => addInfoToSpan(res)).catch((e) => {
+          addErrorToSpan(e);
+          throw e;
+        });
       });
     };
   }

package/build/cjs/moduleLoader.cjs

@@ -41,7 +41,7 @@ function createModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnv
 }
 async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData, bootstrapConfig, abortController) {
   const loaderConfig = (0, import_utils.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]));
   let run;
   context.LWR.customInit = async (lwr) => {
@@ -218,10 +218,9 @@ function isValidResolveResponse(res) {
 async function createESMModuleLoader() {
   throw new Error("ESM support coming soon.");
 }
-function createContext(LWR, runtimeParams, runtimeEnvironment, abortController) {
+function createContext(LWR, runtimeParams, abortController) {
   const fetchController = new import_fetchController.FetchController({
     host: runtimeParams.host,
-    requestDepth: runtimeParams.requestDepth,
     coreProxy: runtimeParams.coreProxy,
     abortController
   });

package/build/cjs/renderer.cjs

@@ -67,8 +67,9 @@ var Renderer = class {
       const abortController = new AbortController();
       const timeout = new Promise((_, reject) => {
         timerId = setTimeout(() => {
-          abortController.abort();
-          reject(new import_diagnostics.LwrApplicationError(import_diagnostics.descriptions.APPLICATION.SSR_TIMEOUT(route.id, (0, import_utils.getRenderTimeout)())));
+          const message = import_diagnostics.descriptions.APPLICATION.SSR_TIMEOUT(route.id, (0, import_utils.getRenderTimeout)());
+          abortController.abort(`AbortError: ${message}`);
+          reject(new import_diagnostics.LwrApplicationError(message));
         }, (0, import_utils.getRenderTimeout)());
       });
       result = await this.pendingRenders.execute(async () => {
@@ -229,13 +230,13 @@ var Renderer = class {
   }
   resetFetchController(fetchController, runtimeParams, route, abortController) {
     fetchController.disableFetchKillSwitch();
+    const baseHeaders = {
+      [import_shared_utils.REQUEST_DEPTH_HEADER]: runtimeParams.requestDepth ?? "0",
+      ...(0, import_shared_utils.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},
+      headers: route.bootstrap.includeCookiesForSSR ? {Cookie: runtimeParams.cookie, ...baseHeaders} : baseHeaders,
       coreProxy: runtimeParams.coreProxy,
       abortController
     });
@@ -267,14 +268,13 @@ function getServerData(component, context, serverData) {
   return (0, import_instrumentation.getTracer)().trace({
     name: import_instrumentation.ViewSpan.GetServerData,
     attributes: {specifier: component.specifier}
-  }, async () => {
+  }, async (span) => {
     try {
       const data = await component.module.getServerData(context);
       Object.assign(serverData, data.props);
-      const dataRes = data;
-      if (dataRes.status) {
-        const {code, location} = dataRes.status;
-        throw new import_diagnostics.LwrStatusError(void 0, code, location ? {location} : void 0);
+      if (data.warnings) {
+        const warnings = data.warnings.map((w) => (0, import_diagnostics.stringifyError)(w)).join(", ");
+        span.setAttributes({warnings});
       }
       return data;
     } catch (e) {
@@ -289,14 +289,15 @@ function getServerData(component, context, serverData) {
   });
 }
 async function renderToString(engine, component, props) {
+  const isSSRv2 = (0, import_shared_utils.getFeatureFlags)().SSR_COMPILER_ENABLED || false;
   return (0, import_instrumentation.getTracer)().trace({
     name: import_instrumentation.ViewSpan.RenderComponent,
-    attributes: {specifier: component.specifier}
+    attributes: {specifier: component.specifier, isSSRv2}
   }, async () => {
     try {
       const elementName = (0, import_shared_utils.moduleSpecifierToKebabCase)(component.specifier);
       const moduleDefault = component.module.default;
-      const html = (0, import_shared_utils.getFeatureFlags)().SSR_COMPILER_ENABLED ? await engine.renderComponent(elementName, moduleDefault, props, "sync") : engine.renderComponent(elementName, moduleDefault, props);
+      const html = isSSRv2 ? await engine.renderComponent(elementName, moduleDefault, props, elementName, false, "sync") : engine.renderComponent(elementName, moduleDefault, props);
       return {html};
     } catch (e) {
       if (e instanceof import_diagnostics.LwrError)

package/build/cjs/resourceProvider.cjs

@@ -0,0 +1,94 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/lwc-ssr/src/resourceProvider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => resourceProvider_default
+});
+var import_path = __toModule(require("path"));
+var import_rollup = __toModule(require("rollup"));
+var import_plugin_node_resolve = __toModule(require("@rollup/plugin-node-resolve"));
+var import_plugin_terser = __toModule(require("@rollup/plugin-terser"));
+var import_config = __toModule(require("@lwrjs/config"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
+var import_package = __toModule(require("@lwrjs/lwc-ssr/package"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var banner = `/**
+* Copyright (c) 2025, salesforce.com, inc.
+* All rights reserved.
+* SPDX-License-Identifier: MIT
+* For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+*/
+/* LWC SSR Client Utils v${import_config.LWC_VERSION} */`;
+var SsrResourceProvider = class {
+  constructor(_config, context) {
+    this.name = "lwc-ssr-client-utils";
+    this.ssrUtilsName = "register-lwc-style.js";
+    this.versionCache = new Map();
+    this.context = context;
+  }
+  async getResource(resource, environment) {
+    const {specifier, version = import_config.LWC_VERSION} = resource;
+    if (specifier !== this.ssrUtilsName || version !== import_config.LWC_VERSION) {
+      return;
+    }
+    const cacheKey = `${specifier}_${version}`;
+    if (this.versionCache.has(cacheKey)) {
+      return this.versionCache.get(cacheKey);
+    }
+    const {output} = await (0, import_instrumentation.getTracer)().trace({
+      name: import_instrumentation.BundleSpan.Rollup,
+      attributes: {specifier}
+    }, async () => {
+      const bundler = await (0, import_rollup.rollup)({
+        input: import_path.default.join(import_package.rootPath, "build", "scripts", specifier),
+        plugins: [
+          (0, import_plugin_node_resolve.nodeResolve)({
+            extensions: [".js"],
+            modulesOnly: true,
+            modulePaths: ["node_modules/@lwc"]
+          }),
+          (0, import_plugin_terser.default)({
+            output: {
+              comments: (_, comment) => comment.value.includes("LWC SSR Client Utils")
+            }
+          })
+        ]
+      });
+      return bundler.generate({format: "iife", banner});
+    });
+    const resourceDef = {
+      specifier,
+      version,
+      type: "application/javascript",
+      inline: true,
+      src: await this.context.resourceRegistry.resolveResourceUri({specifier, version}, environment),
+      content: output[0].code,
+      integrity: (0, import_shared_utils.createIntegrityHash)(output[0].code)
+    };
+    this.versionCache.set(cacheKey, resourceDef);
+    return resourceDef;
+  }
+};
+var resourceProvider_default = SsrResourceProvider;

package/build/cjs/utils.cjs

@@ -25,8 +25,6 @@ var __toModule = (module2) => {
 __markAsModule(exports);
 __export(exports, {
   SSR_PROPS_ATTR: () => SSR_PROPS_ATTR,
-  addHeadMarkup: () => addHeadMarkup,
-  createHeadMarkup: () => createHeadMarkup,
   getLoaderConfig: () => getLoaderConfig,
   getLoaderId: () => getLoaderId,
   getLoaderShim: () => getLoaderShim,
@@ -35,7 +33,6 @@ __export(exports, {
   getServerBootstrapServices: () => getServerBootstrapServices,
   mergeWarnings: () => mergeWarnings
 });
-var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var DEFAULT_SSR_TIMEOUT = 5e3;
 var SSR_PROPS_ATTR = "data-lwr-props-id";
@@ -120,52 +117,3 @@ function mergeWarnings(metadata, warnings = []) {
   metadata.serverDebug.warnings = metadata.serverDebug.warnings || [];
   metadata.serverDebug.warnings.push(...warnings);
 }
-function createMetaTags(meta) {
-  return meta.reduce((metaStr, {name, content, httpEquiv}) => {
-    if (!name && !content && !httpEquiv)
-      return metaStr;
-    const nameStr = name ? ` name="${name}"` : "", httpEquivStr = httpEquiv ? ` http-equiv="${httpEquiv}"` : "", contentStr = content ? ` content="${content}"` : "";
-    return metaStr + `<meta${nameStr}${httpEquivStr}${contentStr}>
-`;
-  }, "");
-}
-function createScriptTags(scripts) {
-  return scripts.reduce((scriptStr, {body}) => scriptStr + `<script type="application/ld+json">${body}</script>
-`, "");
-}
-function createLinkTags(links) {
-  return links.reduce((linkStr, {href, rel, as, fetchpriority}) => {
-    const relStr = rel ? ` rel="${rel}"` : "", asStr = as ? ` as="${as}"` : "", fetchStr = fetchpriority ? ` fetchpriority="${fetchpriority}"` : "";
-    return linkStr + `<link href="${href}"${relStr}${asStr}${fetchStr}>
-`;
-  }, "");
-}
-function createStyleTags(styles) {
-  return styles.reduce((styleStr, {body, id}) => {
-    const idStr = id ? ` id="${id}"` : "";
-    return styleStr + `<style type="text/css"${idStr}>${body}</style>
-`;
-  }, "");
-}
-function createHeadMarkup(results) {
-  let hasTitle = false;
-  return results.reduce((str, {markup: {title, scripts = [], meta = [], links = [], styles = []} = {}}) => {
-    if (title && !hasTitle) {
-      hasTitle = true;
-      str += `<title>${title}</title>
-`;
-    }
-    return str + createMetaTags(meta) + createScriptTags(scripts) + createLinkTags(links) + createStyleTags(styles);
-  }, "");
-}
-function addHeadMarkup(results, stringBuilder) {
-  const headMarkup = createHeadMarkup(Object.values(results));
-  if (headMarkup) {
-    const headIndex = stringBuilder.original.indexOf("</head>");
-    if (headIndex >= 0) {
-      stringBuilder.prependLeft(headIndex, headMarkup);
-    } else {
-      import_diagnostics.logger.error("Adding markup during server-side rendering failed. Could not find the </head> tag.");
-    }
-  }
-}

package/build/cjs/viewProvider/index.cjs

@@ -30,7 +30,6 @@ var import_base_view_provider = __toModule(require("@lwrjs/base-view-provider"))
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-var import_utils = __toModule(require("../utils.cjs"));
 var import_renderer = __toModule(require("../renderer.cjs"));
 var LwcViewProvider = class extends import_base_view_provider.default {
   constructor(_pluginConfig, providerConfig) {
@@ -77,7 +76,7 @@ var LwcViewProvider = class extends import_base_view_provider.default {
               throw new Error("Failed to render content template component");
             }
             if (markup)
-              viewProperties.serverHeadMarkup = (0, import_utils.createHeadMarkup)([results[specifier]]);
+              viewProperties.serverHeadMarkup = (0, import_shared_utils.createHeadMarkup)([markup]);
             return {
               renderedView: html.replace(`<${element}`, `<${element} lwc:external`),
               metadata: {

package/build/cjs/viewTransformer/index.cjs

@@ -85,7 +85,7 @@ function lwcSsrViewTransformer(options, {config, moduleBundler, resourceRegistry
           }
           (0, import_utils.mergeWarnings)(metadata, warnings);
           metadata.serverBundles = islandBundles ? new Set([...allBundles, ...islandBundles]) : allBundles;
-          results && (0, import_utils.addHeadMarkup)(Object.values(results), stringBuilder);
+          results && (0, import_shared_utils.addHeadMarkup)(Object.values(results).map((r) => r.markup), stringBuilder);
         } catch (e) {
           if (e instanceof import_diagnostics.LwrError)
             throw e;

package/build/es/dataViewTransformer/index.js

@@ -1,6 +1,7 @@
 import { descriptions, logger, LwrStatusError, stringifyError } from '@lwrjs/diagnostics';
 import { ViewSpan, getTracer } from '@lwrjs/instrumentation';
-import { addHeadMarkup, mergeWarnings } from '../utils.js';
+import { addHeadMarkup } from '@lwrjs/shared-utils';
+import { mergeWarnings } from '../utils.js';
 import { getRenderer } from '../renderer.js';
 const NAME = 'preload-data-transformer';
 /**
@@ -56,7 +57,7 @@ export default function preloadDataViewTransformer(_options, { config, moduleBun
             // Log and process the data response
             const { props, markup, cache: { ttl } = { ttl: undefined } } = result || {};
             logger.verbose({ label: NAME, message: 'response', additionalInfo: props });
-            markup && addHeadMarkup([result], 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

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 { logger, stringifyError } from '@lwrjs/diagnostics';
 import { getTracer, ViewSpan } from '@lwrjs/instrumentation';
-import { REQUEST_DEPTH_HEADER, toHostname } 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();
 /**
@@ -15,72 +14,79 @@ const CORE_CLIENTS = new Map();
  * Any new fetch calls (i.e. from other async function calls) would be immediately aborted.
  */
 export class FetchController {
+    killSwitchActivated;
+    noOpActivated;
+    abortController;
+    headers;
+    host;
+    coreProxy;
+    fetchEndowment;
     constructor(context) {
-        this.controlledFetch = (request, init) => {
-            if (this.killSwitchActivated) {
-                return this.handleAbortError(request, undefined);
-            }
-            if (!this.abortController) {
-                this.abortController = new AbortController();
-            }
-            const signal = this.abortController?.signal;
-            // Ensure the init object exists and then add the signal to it.
-            const updatedInit = {
-                ...init,
-                headers: { ...init?.headers, ...this.headers },
-                signal,
-            };
-            const fetchFunction = this.noOpActivated
-                ? this.fetchNoOp(request, updatedInit)
-                : this.fetchEndowment(request, updatedInit);
-            const fetchPromise = fetchFunction.catch((error) => {
-                // Check if the error is an AbortError
-                if (error && error?.stack.startsWith('AbortError')) {
-                    return this.handleAbortError(request, error);
-                }
-                else {
-                    // Re-throw the error if it's not an AbortError
-                    throw error;
-                }
-            });
-            return fetchPromise;
-        };
-        /**
-         * After SSR is complete the kill switch will abort any pending fetch requests.
-         */
-        this.activateKillSwitch = () => {
-            this.killSwitchActivated = true;
-            this.abortController?.abort();
-            this.abortController = undefined;
-        };
-        this.deactivateKillSwitch = () => {
-            this.killSwitchActivated = false;
-        };
-        /**
-         * During SSR renderComponent (which is synchronous) Do not even call any fetch requests
-         * since they would not complete before SSR is done.
-         */
-        this.activateNoOp = () => {
-            this.noOpActivated = true;
-        };
-        this.deactivateNoOp = () => {
-            this.noOpActivated = false;
-        };
-        this.setFetchRequestContext = (context) => {
-            const { abortController, host, headers, requestDepth, coreProxy } = context;
-            this.host = host;
-            this.headers = headers;
-            this.requestDepth = requestDepth;
-            this.coreProxy = coreProxy;
-            this.abortController = abortController;
-        };
         this.killSwitchActivated = false;
         this.noOpActivated = false;
         this.setFetchRequestContext(context);
         this.fetchEndowment = this.createFetchEndowment();
     }
+    controlledFetch = (request, init) => {
+        if (this.killSwitchActivated) {
+            return this.handleAbortError(request, 'Kill switch was already enabled');
+        }
+        if (!this.abortController) {
+            this.abortController = new AbortController();
+        }
+        const signal = this.abortController?.signal;
+        // Ensure the init object exists and then add the signal to it.
+        const updatedInit = {
+            ...init,
+            headers: { ...init?.headers, ...this.headers },
+            signal,
+        };
+        const fetchFunction = this.noOpActivated
+            ? this.fetchNoOp(request, updatedInit)
+            : this.fetchEndowment(request, updatedInit);
+        const fetchPromise = fetchFunction.catch((error) => {
+            // Check if the error is an AbortError
+            const errorMsg = error.message || error;
+            if (error && (errorMsg.startsWith('AbortError') || error?.stack.startsWith('AbortError'))) {
+                return this.handleAbortError(request, error);
+            }
+            else {
+                // Re-throw the error if it's not an AbortError
+                throw error;
+            }
+        });
+        return fetchPromise;
+    };
+    /**
+     * After SSR is complete the kill switch will abort any pending fetch requests.
+     */
+    activateKillSwitch = () => {
+        this.killSwitchActivated = true;
+        this.abortController?.abort('AbortError: Kill switch enabled');
+        this.abortController = undefined;
+    };
+    deactivateKillSwitch = () => {
+        this.killSwitchActivated = false;
+    };
+    /**
+     * During SSR renderComponent (which is synchronous) Do not even call any fetch requests
+     * since they would not complete before SSR is done.
+     */
+    activateNoOp = () => {
+        this.noOpActivated = true;
+    };
+    deactivateNoOp = () => {
+        this.noOpActivated = false;
+    };
+    setFetchRequestContext = (context) => {
+        const { abortController, host, headers, coreProxy } = context;
+        this.host = host;
+        this.headers = headers;
+        this.coreProxy = coreProxy;
+        this.abortController = abortController;
+    };
     handleAbortError(request, error) {
-        const message = `Orphaned ${String(request)} request was killed. Either the request timed out or it was dispatched during SSR. Async processes are not supported during SSR. For more information, see: https://developer.salesforce.com/docs/platform/lwr/guide/lwr-configure-component-ssr.html.`;
+        const message = `${String(request)} request was killed. Either the request timed out or it was dispatched during SSR. Async processes are not supported during SSR. For more information, see: https://developer.salesforce.com/docs/platform/lwr/guide/lwr-configure-component-ssr.html.`;
         logger.warn({ label: `Server-side Rendering`, message }, error);
         // Return a response to indicate kill switch
         return Promise.resolve(new Response(message, { status: 500 }));
@@ -97,35 +103,28 @@ export class FetchController {
             }
             else if (init.signal.aborted) {
                 // The request was already aborted go ahead and return the abort error
-                resolve(this.handleAbortError(request, new Error('Request was aborted')));
+                resolve(this.handleAbortError(request, new Error('Request was already aborted')));
             }
             else {
                 // Wait until fetches are aborted to resolve with an abort error
                 const abortHandler = (err) => {
                     init?.signal?.removeEventListener('abort', abortHandler);
                     // Resolve the fetch
-                    resolve(this.handleAbortError(request, err));
+                    resolve(this.handleAbortError(request, new Error('Not allowed: Request was dispatched during SSR', { cause: err })));
                 };
                 init.signal.addEventListener('abort', abortHandler);
             }
         });
     }
     createFetchEndowment() {
-        return (request, init) => {
-            const { host: forwardedOrigin = '', requestDepth = 1, coreProxy } = this;
+        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 || (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';
@@ -156,17 +155,33 @@ export class FetchController {
                     span.setAttributes({ statusCode: res.status });
                     return res;
                 };
+                const addErrorToSpan = (err) => {
+                    // add fetch errors to the trace
+                    span.setAttributes({ error: stringifyError(err) });
+                };
+                // add tracing headers based on span values
+                init.headers = { ...init.headers, ...getTraceHeaders({}, span) };
                 if (coreProxy) {
-                    return this.fetchWithAgent(finalUrl, finalInit, forwardedOrigin, coreProxy, span)
+                    return this.fetchWithAgent(finalUrl, init, forwardedOrigin, coreProxy, span)
                         .then((res) => addInfoToSpan(res))
                         .catch((err) => {
                         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))
+                            .catch((e) => {
+                            addErrorToSpan(e);
+                            throw e;
+                        });
                     });
                 }
-                return fetch(finalRequest, finalInit).then((res) => addInfoToSpan(res));
+                return fetch(finalRequest, init)
+                    .then((res) => addInfoToSpan(res))
+                    .catch((e) => {
+                    addErrorToSpan(e);
+                    throw e;
+                });
             });
         };
     }
@@ -259,19 +274,6 @@ export class FetchController {
                 values.forEach((v) => headers.append(key, v));
             }
             return new Response(body, { status: res.statusCode, headers });
-            // If we want to fallback to CDN for certain status codes
-            // if (!fetchRes.ok) {
-            //     throw new Error('Failed with status code: ' + fetchRes.status);
-            // }
-            // return {
-            //     ...res,
-            //     url: origin + path,
-            //     ok: res.statusCode < 400,
-            //     status: res.statusCode,
-            //     redirected: res.statusCode >= 300 && res.statusCode < 400,
-            //     text: res.body.text.bind(res.body),
-            //     json: res.body.json.bind(res.body),
-            // } as unknown as Response;
         });
     }
 }

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.js

@@ -1,7 +1,7 @@
 // TODO: investigate perf impact W-16056356
 import { LRUCache } from 'lru-cache';
 import { LwrApplicationError, LwrError, LwrStatusError, descriptions, logger, stringifyError, } from '@lwrjs/diagnostics';
-import { buildEnvironmentContext, getCacheKeyFromJson, getSpecifier, isLambdaEnv, moduleSpecifierToKebabCase, getFeatureFlags, TaskPool, isLocalDev, cookieStringToObject, } from '@lwrjs/shared-utils';
+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';
@@ -22,8 +22,13 @@ export function getRenderer(config, bundleRegistry, resourceRegistry) {
     return singleton;
 }
 export class Renderer {
+    config;
+    bundleRegistry;
+    resourceRegistry;
+    contextPerEnv;
+    pendingRenders;
+    globalCache = {};
     constructor(config, bundleRegistry, resourceRegistry) {
-        this.globalCache = {};
         this.config = config;
         this.bundleRegistry = bundleRegistry;
         this.resourceRegistry = resourceRegistry;
@@ -71,8 +76,9 @@ export class Renderer {
             const abortController = new AbortController();
             const timeout = new Promise((_, reject) => {
                 timerId = setTimeout(() => {
-                    abortController.abort();
-                    reject(new LwrApplicationError(descriptions.APPLICATION.SSR_TIMEOUT(route.id, getRenderTimeout())));
+                    const message = descriptions.APPLICATION.SSR_TIMEOUT(route.id, getRenderTimeout());
+                    abortController.abort(`AbortError: ${message}`);
+                    reject(new LwrApplicationError(message));
                 }, getRenderTimeout());
             });
             result = (await this.pendingRenders.execute(async () => {
@@ -301,15 +307,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,
         });
@@ -362,15 +368,13 @@ function getServerData(component, context, serverData) {
     return getTracer().trace({
         name: ViewSpan.GetServerData,
         attributes: { specifier: component.specifier },
-    }, async () => {
+    }, async (span) => {
         try {
             const data = await component.module.getServerData(context);
             Object.assign(serverData, data.props);
-            // 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);
+            if (data.warnings) {
+                const warnings = data.warnings.map((w) => stringifyError(w)).join(', ');
+                span.setAttributes({ warnings });
             }
             return data;
         }
@@ -388,15 +392,18 @@ function getServerData(component, context, serverData) {
     });
 }
 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
-                ? await engine.renderComponent(elementName, moduleDefault, props, 'sync')
+            const html = isSSRv2
+                ? // serverSideRenderComponent(tagName: string, Component: ComponentWithGenerateMarkup, props: Properties = {}, styleDedupePrefix = '', styleDedupeIsEnabled = false, mode: CompilationMode = DEFAULT_SSR_MODE / 'sync'
+                    await engine.renderComponent(elementName, moduleDefault, props, elementName, false, // true, re-enable with W-18004123
+                    'sync')
                 : engine.renderComponent(elementName, moduleDefault, props);
             return { html };
         }

package/build/es/resourceProvider.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderContext, ResourceDefinition, ResourceIdentifier, ResourceProvider, RuntimeEnvironment } from '@lwrjs/types';
+export default class SsrResourceProvider implements ResourceProvider {
+    name: string;
+    private ssrUtilsName;
+    private versionCache;
+    private context;
+    constructor(_config: any, context: ProviderContext);
+    getResource<T extends ResourceIdentifier, R extends RuntimeEnvironment>(resource: T, environment: R): Promise<ResourceDefinition | undefined>;
+}
+//# sourceMappingURL=resourceProvider.d.ts.map

package/build/es/resourceProvider.js

@@ -0,0 +1,80 @@
+import path from 'path';
+import { rollup } from 'rollup';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import terser from '@rollup/plugin-terser';
+import { LWC_VERSION } from '@lwrjs/config';
+import { BundleSpan, getTracer } from '@lwrjs/instrumentation';
+import { rootPath } from '@lwrjs/lwc-ssr/package';
+import { createIntegrityHash } from '@lwrjs/shared-utils';
+/**
+ * Provide an IIFE script resource containing @lwc/ssr-client-utils#register-lwc-style.js
+ * This script performs style de-duping for components which are SSR compiled.
+ * It must be included in the <head> section of every page which uses the SSR compiler.
+ * If the script is not included, only the first instance of each SSRed component will be styled!
+ * The @lwc/ssr-client-utils package is a peer dependency so LWR is not tied to an LWC version.
+ */
+const banner = `/**
+* Copyright (c) 2025, salesforce.com, inc.
+* All rights reserved.
+* SPDX-License-Identifier: MIT
+* For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+*/
+/* LWC SSR Client Utils v${LWC_VERSION} */`;
+export default class SsrResourceProvider {
+    name = 'lwc-ssr-client-utils';
+    ssrUtilsName = 'register-lwc-style.js';
+    versionCache = new Map();
+    context;
+    constructor(_config, context) {
+        this.context = context;
+    }
+    async getResource(resource, environment) {
+        // validate identifier
+        const { specifier, version = LWC_VERSION } = resource;
+        if (specifier !== this.ssrUtilsName || version !== LWC_VERSION) {
+            return;
+        }
+        // check cache
+        const cacheKey = `${specifier}_${version}`;
+        if (this.versionCache.has(cacheKey)) {
+            return this.versionCache.get(cacheKey);
+        }
+        // generate script resource
+        const { output } = await getTracer().trace({
+            name: BundleSpan.Rollup,
+            attributes: { specifier },
+        }, async () => {
+            const bundler = await rollup({
+                input: path.join(rootPath, 'build', 'scripts', specifier),
+                plugins: [
+                    nodeResolve({
+                        // import from @lwc/ssr-client-utils
+                        extensions: ['.js'],
+                        modulesOnly: true,
+                        modulePaths: ['node_modules/@lwc'],
+                    }),
+                    terser({
+                        output: {
+                            comments: (_, comment) => comment.value.includes('LWC SSR Client Utils'),
+                        },
+                    }),
+                ],
+            });
+            return bundler.generate({ format: 'iife', banner });
+        });
+        // assemble resource definition
+        const resourceDef = {
+            specifier,
+            version,
+            type: 'application/javascript',
+            inline: true,
+            src: await this.context.resourceRegistry.resolveResourceUri({ specifier, version }, environment),
+            content: output[0].code,
+            integrity: createIntegrityHash(output[0].code),
+        };
+        // cache and return
+        this.versionCache.set(cacheKey, resourceDef);
+        return resourceDef;
+    }
+}
+//# sourceMappingURL=resourceProvider.js.map

package/build/es/serverBootstrapServices.js

@@ -1,6 +1,9 @@
 import { ViewSpan, getTracer } from '@lwrjs/instrumentation';
 import { LwrApplicationError, LwrError, stringifyError } from '@lwrjs/diagnostics';
 export class ServerBootstrapServices {
+    serverDataCallbacks;
+    requestHooks;
+    _serviceAPI;
     evaluateServerDataHooks(serverData = {}) {
         // now that we have server data, run the server data hooks
         for (const serverDataHook of this.serverDataCallbacks) {

package/build/es/utils.d.ts

@@ -1,4 +1,4 @@
-import type { ClientBootstrapConfig, EnvironmentContext, LwrStringBuilder, NormalizedLwrAppBootstrapConfig, NormalizedLwrErrorRoute, NormalizedLwrRoute, ProviderAppConfig, PublicResourceRegistry, RenderedViewMetadata, RuntimeEnvironment, RuntimeParams, ServerData, SsrDataResponse } from '@lwrjs/types';
+import type { ClientBootstrapConfig, EnvironmentContext, NormalizedLwrAppBootstrapConfig, NormalizedLwrErrorRoute, NormalizedLwrRoute, ProviderAppConfig, PublicResourceRegistry, RenderedViewMetadata, RuntimeEnvironment, RuntimeParams, ServerData } from '@lwrjs/types';
 interface ServerEnvironment extends EnvironmentContext {
     SSR: boolean;
 }
@@ -12,17 +12,5 @@ export declare function getLoaderConfig(bootstrapModule: string, config: Provide
 };
 export declare function getServerBootstrapServices(route: NormalizedLwrRoute | NormalizedLwrErrorRoute): string[];
 export declare function mergeWarnings(metadata: RenderedViewMetadata, warnings?: (Error | string)[]): void;
-/**
- * Serialize SsrDataResponse.markup into an HTML string
- * @param results An array of responses from getServerData hooks
- * @returns A string of HTML generated from markup metadata
- */
-export declare function createHeadMarkup(results: SsrDataResponse[]): string;
-/**
- * Serialize SsrDataResponse.markup into HTML, then add it to the <head> of a base doc
- * @param results An array of responses from getServerData hooks
- * @param stringBuilder The string builder for a base document
- */
-export declare function addHeadMarkup(results: SsrDataResponse[], stringBuilder: LwrStringBuilder): void;
 export {};
 //# sourceMappingURL=utils.d.ts.map

package/build/es/utils.js

@@ -1,4 +1,3 @@
-import { logger } from '@lwrjs/diagnostics';
 import { buildEnvironmentContext, getFeatureFlags, normalizeVersionToUri, isLambdaEnv, getSpecifier, } from '@lwrjs/shared-utils';
 const DEFAULT_SSR_TIMEOUT = 5000; // 5 seconds, override with process.env.SSR_TIMEOUT
 export const SSR_PROPS_ATTR = 'data-lwr-props-id';
@@ -98,69 +97,4 @@ export function mergeWarnings(metadata, warnings = []) {
     metadata.serverDebug.warnings = metadata.serverDebug.warnings || [];
     metadata.serverDebug.warnings.push(...warnings);
 }
-/** SSR HEAD MARKUP UTILS */
-function createMetaTags(meta) {
-    return meta.reduce((metaStr, { name, content, httpEquiv }) => {
-        if (!name && !content && !httpEquiv)
-            return metaStr; // do not create empty <meta> tags
-        const nameStr = name ? ` name="${name}"` : '', httpEquivStr = httpEquiv ? ` http-equiv="${httpEquiv}"` : '', contentStr = content ? ` content="${content}"` : '';
-        return metaStr + `<meta${nameStr}${httpEquivStr}${contentStr}>\n`;
-    }, '');
-}
-function createScriptTags(scripts) {
-    return scripts.reduce((scriptStr, { body }) => scriptStr + `<script type="application/ld+json">${body}</script>\n`, '');
-}
-function createLinkTags(links) {
-    return links.reduce((linkStr, { href, rel, as, fetchpriority }) => {
-        const relStr = rel ? ` rel="${rel}"` : '', asStr = as ? ` as="${as}"` : '', fetchStr = fetchpriority ? ` fetchpriority="${fetchpriority}"` : '';
-        return linkStr + `<link href="${href}"${relStr}${asStr}${fetchStr}>\n`;
-    }, '');
-}
-function createStyleTags(styles) {
-    return styles.reduce((styleStr, { body, id }) => {
-        const idStr = id ? ` id="${id}"` : '';
-        return styleStr + `<style type="text/css"${idStr}>${body}</style>\n`;
-    }, '');
-}
-/**
- * Serialize SsrDataResponse.markup into an HTML string
- * @param results An array of responses from getServerData hooks
- * @returns A string of HTML generated from markup metadata
- */
-export function createHeadMarkup(results) {
-    // Loop through the <title>, <script>, <meta>, and <link> tag information
-    // Create an HTML string for each tag
-    let hasTitle = false;
-    return results.reduce((str, { markup: { title, scripts = [], meta = [], links = [], styles = [] } = {} }) => {
-        if (title && !hasTitle) {
-            // first <title> wins
-            hasTitle = true;
-            str += `<title>${title}</title>\n`;
-        }
-        return (str +
-            createMetaTags(meta) +
-            createScriptTags(scripts) +
-            createLinkTags(links) +
-            createStyleTags(styles));
-    }, '');
-}
-/**
- * Serialize SsrDataResponse.markup into HTML, then add it to the <head> of a base doc
- * @param results An array of responses from getServerData hooks
- * @param stringBuilder The string builder for a base document
- */
-export function addHeadMarkup(results, stringBuilder) {
-    // Create HTML tags for each item in the SsrDataResponse.markup bag
-    const headMarkup = createHeadMarkup(Object.values(results));
-    if (headMarkup) {
-        // Add all the links to the <head> section of the base document
-        const headIndex = stringBuilder.original.indexOf('</head>');
-        if (headIndex >= 0) {
-            stringBuilder.prependLeft(headIndex, headMarkup);
-        }
-        else {
-            logger.error('Adding markup during server-side rendering failed. Could not find the </head> tag.');
-        }
-    }
-}
 //# sourceMappingURL=utils.js.map

package/build/es/viewProvider/index.js

@@ -1,13 +1,17 @@
 import BaseViewProvider from '@lwrjs/base-view-provider';
 import { descriptions, LwrApplicationError, LwrError, stringifyError } from '@lwrjs/diagnostics';
 import { ViewSpan, getTracer } from '@lwrjs/instrumentation';
-import { hashContent, isSpecifier, moduleSpecifierToKebabCase, slugify } from '@lwrjs/shared-utils';
-import { createHeadMarkup } from '../utils.js';
+import { createHeadMarkup, hashContent, isSpecifier, moduleSpecifierToKebabCase, slugify, } from '@lwrjs/shared-utils';
 import { getRenderer } from '../renderer.js';
 export default class LwcViewProvider extends BaseViewProvider {
+    name = 'ssr-view-provider';
+    moduleBundler;
+    resourceRegistry;
+    routes;
+    runtimeEnvironment;
+    config;
     constructor(_pluginConfig, providerConfig) {
         super();
-        this.name = 'ssr-view-provider';
         this.moduleBundler = providerConfig.moduleBundler;
         this.resourceRegistry = providerConfig.resourceRegistry;
         this.routes = [...providerConfig.config.routes, ...providerConfig.config.errorRoutes];
@@ -54,7 +58,7 @@ export default class LwcViewProvider extends BaseViewProvider {
                             throw new Error('Failed to render content template component');
                         }
                         if (markup)
-                            viewProperties.serverHeadMarkup = createHeadMarkup([results[specifier]]); // generate <head> markup
+                            viewProperties.serverHeadMarkup = createHeadMarkup([markup]); // generate <head> markup
                         return {
                             // add "lwc:external" to the contentTemplate component to mark it as already processed
                             renderedView: html.replace(`<${element}`, `<${element} lwc:external`),

package/build/es/viewTransformer/index.js

@@ -1,7 +1,7 @@
 import { descriptions, logger, LwrApplicationError, LwrError, stringifyError } from '@lwrjs/diagnostics';
 import { ViewSpan, getTracer } from '@lwrjs/instrumentation';
-import { HYDRATE_DIRECTIVE, isCsrIsland, isHydrateOnLoad, kebabCaseToModuleSpecifier, shortestTtl, } from '@lwrjs/shared-utils';
-import { SSR_PROPS_ATTR, addHeadMarkup, getPropsId, mergeWarnings } from '../utils.js';
+import { HYDRATE_DIRECTIVE, addHeadMarkup, isCsrIsland, isHydrateOnLoad, kebabCaseToModuleSpecifier, shortestTtl, } from '@lwrjs/shared-utils';
+import { SSR_PROPS_ATTR, getPropsId, mergeWarnings } from '../utils.js';
 import { getRenderer } from '../renderer.js';
 /**
  * This is a view transformer run by the view registry during linking of a page document/route (configured in lwr.config.json[routes]).
@@ -79,7 +79,8 @@ export default function lwcSsrViewTransformer(options, { config, moduleBundler,
                     metadata.serverBundles = islandBundles
                         ? new Set([...allBundles, ...islandBundles])
                         : allBundles;
-                    results && addHeadMarkup(Object.values(results), stringBuilder);
+                    results &&
+                        addHeadMarkup(Object.values(results).map((r) => r.markup), stringBuilder);
                 }
                 catch (e) {
                     if (e instanceof LwrError)

package/build/scripts/register-lwc-style.js

@@ -0,0 +1,5 @@
+// see: https://github.com/salesforce/lwc/blob/master/packages/%40lwc/ssr-client-utils/register-lwc-style.js
+
+import { registerLwcStyleComponent } from '@lwc/ssr-client-utils';
+
+registerLwcStyleComponent();

package/package.cjs

@@ -0,0 +1,9 @@
+const fs = require('fs');
+const path = require('path');
+const rootPath = path.join(__dirname, './');
+const version = JSON.parse(fs.readFileSync(path.join(rootPath, 'package.json'), 'utf-8')).version;
+
+module.exports = {
+    rootPath,
+    version
+};

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.17.2-alpha.9",
+    "version": "0.18.0",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -29,39 +29,51 @@
         "./dataViewTransformer": {
             "import": "./build/es/dataViewTransformer/index.js",
             "require": "./build/cjs/dataViewTransformer/index.cjs"
-        }
+        },
+        "./resourceProvider": {
+            "import": "./build/es/resourceProvider.js",
+            "require": "./build/cjs/resourceProvider.cjs"
+        },
+        "./package": "./package.cjs"
     },
     "scripts": {
-        "build": "tsc -b",
+        "build": "tsc -b && shx cp -R ./src/scripts ./build",
         "clean": "rimraf build node_modules",
         "test": "jest"
     },
     "files": [
         "build/**/*.js",
         "build/**/*.cjs",
-        "build/**/*.d.ts"
+        "build/**/*.d.ts",
+        "package.cjs"
     ],
     "dependencies": {
-        "@lwrjs/config": "0.17.2-alpha.9",
-        "@lwrjs/diagnostics": "0.17.2-alpha.9",
-        "@lwrjs/instrumentation": "0.17.2-alpha.9",
-        "@lwrjs/loader": "0.17.2-alpha.9",
-        "@lwrjs/shared-utils": "0.17.2-alpha.9",
+        "@lwrjs/config": "0.18.0",
+        "@lwrjs/diagnostics": "0.18.0",
+        "@lwrjs/instrumentation": "0.18.0",
+        "@lwrjs/loader": "0.18.0",
+        "@lwrjs/shared-utils": "0.18.0",
+        "@rollup/plugin-node-resolve": "^15.2.3",
+        "@rollup/plugin-terser": "^0.4.4",
         "fs-extra": "^11.2.0",
         "lru-cache": "^10.4.3",
+        "rollup": "^2.79.2",
         "undici": "^6.21.1"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.17.2-alpha.9",
-        "jest": "^26.6.3",
+        "@lwrjs/types": "0.18.0",
+        "jest": "29.7.0",
         "memfs": "^4.13.0",
-        "ts-jest": "^26.5.6"
+        "ts-jest": "^29.2.6"
+    },
+    "peerDependencies": {
+        "@lwc/ssr-client-utils": ">= 8.16"
     },
     "engines": {
-        "node": ">=18.0.0"
+        "node": ">=20.0.0"
     },
     "volta": {
         "extends": "../../../package.json"
     },
-    "gitHead": "7ede5d04a97513b9869b13e66155bc4f3920bb99"
+    "gitHead": "763c7c558ea75fe34a91162c9793de63e55f1d2f"
 }