@lwrjs/lwc-ssr 0.13.7 → 0.13.9

package/build/cjs/fetchController.cjs

@@ -0,0 +1,138 @@
+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/fetchController.ts
+__markAsModule(exports);
+__export(exports, {
+  FetchController: () => FetchController
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
+var FetchController = class {
+  constructor(trace, host = "", requestDepth = 1) {
+    this.controlledFetch = (request, init) => {
+      if (this.killSwitchActivated) {
+        return this.handleAbortError(request, void 0);
+      }
+      const controller = new AbortController();
+      const updatedInit = {
+        ...init,
+        headers: {...init?.headers, ...this.headers},
+        signal: controller.signal
+      };
+      this.controllers.add(controller);
+      const fetchFunction = this.noOpActivated ? this.fetchNoOp(request, updatedInit) : this.fetchEndowment(request, updatedInit);
+      const fetchPromise = fetchFunction.catch((error) => {
+        if (error && error?.stack.startsWith("AbortError")) {
+          return this.handleAbortError(request, error);
+        } else {
+          throw error;
+        }
+      }).finally(() => {
+        this.controllers.delete(controller);
+      });
+      return fetchPromise;
+    };
+    this.activateKillSwitch = () => {
+      this.killSwitchActivated = true;
+      this.controllers.forEach((controller) => {
+        controller.abort();
+      });
+      this.controllers.clear();
+    };
+    this.deactivateKillSwitch = () => {
+      this.killSwitchActivated = false;
+    };
+    this.activateNoOp = () => {
+      this.noOpActivated = true;
+    };
+    this.deactivateNoOp = () => {
+      this.noOpActivated = false;
+    };
+    this.setFetchRequestContext = (context) => {
+      const {host, headers, requestDepth = 0} = context;
+      this.host = host;
+      this.headers = headers;
+      this.requestDepth = requestDepth;
+    };
+    this.killSwitchActivated = false;
+    this.noOpActivated = false;
+    this.controllers = new Set();
+    this.host = host;
+    this.requestDepth = requestDepth;
+    this.fetchEndowment = this.createFetchEndowment(trace);
+  }
+  handleAbortError(request, error) {
+    const message = `Orphaned ${String(request)} request was killed. 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}));
+  }
+  fetchNoOp(request, init) {
+    return new Promise((resolve) => {
+      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")));
+      } else {
+        const abortHandler = (err) => {
+          init?.signal?.removeEventListener("abort", abortHandler);
+          resolve(this.handleAbortError(request, err));
+        };
+        init.signal.addEventListener("abort", abortHandler);
+      }
+    });
+  }
+  createFetchEndowment(trace) {
+    return (request, init) => {
+      const {host, requestDepth} = this;
+      let finalRequest;
+      let finalUrl;
+      if (request instanceof Request) {
+        const curUrl = request.url;
+        if (curUrl.startsWith("/")) {
+          finalUrl = host + curUrl;
+          finalRequest = new Request(finalUrl, request);
+        } else {
+          finalUrl = curUrl;
+          finalRequest = request;
+        }
+      } else {
+        const curUrl = typeof request === "string" ? request : request.toString();
+        finalRequest = finalUrl = curUrl.startsWith("/") ? host + curUrl : curUrl;
+      }
+      const finalInit = {
+        ...init,
+        headers: {
+          ...init?.headers,
+          [import_shared_utils.REQUEST_DEPTH_HEADER]: String(requestDepth)
+        }
+      };
+      import_diagnostics.logger.info({
+        label: `pre ${import_instrumentation.ViewSpan.Fetch}`,
+        message: `finalUrl: ${String(finalUrl)}`
+      });
+      return trace({name: import_instrumentation.ViewSpan.Fetch, attributes: {url: String(finalUrl)}}, () => fetch(finalRequest, finalInit));
+    };
+  }
+};

package/build/cjs/moduleLoader.cjs

@@ -32,6 +32,7 @@ var import_crypto = __toModule(require("crypto"));
 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_fetchController = __toModule(require("./fetchController.cjs"));
 var FETCH_ABORT_KEY = "__fetchAbortId__";
 var BOOTSTRAP_SPECIFIER = "@lwrjs/ssr-bootstrap";
 function createModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData, bootstrapConfig) {
@@ -137,8 +138,7 @@ async function createESMModuleLoader() {
 function createContext(LWR, runtimeParams) {
   const tracer = (0, import_instrumentation.getTracer)();
   const trace = tracer.trace.bind(tracer);
-  const fetchEndowment = (0, import_utils.createFetchEndowment)(trace, runtimeParams.host, runtimeParams.requestDepth);
-  const fetchController = new import_utils.FetchController(fetchEndowment);
+  const fetchController = new import_fetchController.FetchController(trace, runtimeParams.host, runtimeParams.requestDepth);
   const context = {
     LWR,
     lwcRuntimeFlags: {ENABLE_WIRE_SYNC_EMIT: true},
@@ -160,6 +160,9 @@ function createContext(LWR, runtimeParams) {
       },
       disableFetchKillSwitch: () => {
         fetchController.deactivateKillSwitch();
+      },
+      setFetchRequestContext: (context2) => {
+        fetchController.setFetchRequestContext(context2);
       }
     }
   };

package/build/cjs/renderer.cjs

@@ -89,11 +89,12 @@ var Renderer = class {
     const singleRenderMode = (0, import_shared_utils.getFeatureFlags)().SINGLE_RENDER_MODE;
     let loader, loaderPromise, bootstrapServiceEvaluationMap;
     try {
-      const bootstrapContext = this.getCachedBootstrapContext(route, runtimeEnvironment, runtimeParams, serverData, reevaluateModules);
+      const bootstrapContext = this.getCachedBootstrapContext(route, runtimeEnvironment, runtimeParams, serverData);
       loaderPromise = bootstrapContext.loader;
       bootstrapServiceEvaluationMap = bootstrapContext.bootstrapServiceEvaluationMap;
       loader = await loaderPromise;
-      loader.getFetchController().disableFetchKillSwitch();
+      const fetchController = loader.getFetchController();
+      this.resetFetchController(fetchController, runtimeParams, route);
       const engineServerSpecifier = (0, import_shared_utils.getSpecifier)({
         specifier: "@lwc/engine-server",
         version: route.bootstrap.lwcVersion
@@ -184,22 +185,20 @@ var Renderer = class {
       }
     }
   }
-  getCachedBootstrapContext(route, runtimeEnvironment, runtimeParams, serverData, reevaluateModules) {
+  resetFetchController(fetchController, runtimeParams, route) {
+    fetchController.disableFetchKillSwitch();
+    fetchController.setFetchRequestContext({
+      host: runtimeParams.host,
+      requestDepth: runtimeParams.requestDepth,
+      headers: void 0
+    });
+  }
+  getCachedBootstrapContext(route, runtimeEnvironment, runtimeParams, serverData) {
     let loader, bootstrapServiceEvaluationMap;
-    if (reevaluateModules) {
-      if (!this.cachedBootstrapContext || (0, import_shared_utils.isLocalDev)()) {
-        this.cachedBootstrapContext = {
-          loader: (0, import_moduleLoader.createModuleLoader)(this.config, this.resourceRegistry, this.bundleRegistry, runtimeEnvironment, runtimeParams, serverData, route.bootstrap),
-          bootstrapServiceEvaluationMap: new Map()
-        };
-      }
-      return this.cachedBootstrapContext;
-    }
     const envContext = (0, import_shared_utils.buildEnvironmentContext)(runtimeParams);
-    const {host, requestDepth} = runtimeParams;
-    const contextCacheKey = (0, import_shared_utils.getCacheKeyFromJson)({envContext, host, requestDepth});
+    const contextCacheKey = (0, import_shared_utils.getCacheKeyFromJson)({envContext});
     const bootstrapContext = this.contextPerEnv.get(contextCacheKey);
-    if (!bootstrapContext) {
+    if (!bootstrapContext || (0, import_shared_utils.isLocalDev)()) {
       loader = (0, import_moduleLoader.createModuleLoader)(this.config, this.resourceRegistry, this.bundleRegistry, runtimeEnvironment, runtimeParams, serverData, route.bootstrap);
       bootstrapServiceEvaluationMap = new Map();
       this.contextPerEnv.set(contextCacheKey, {

package/build/cjs/utils.cjs

@@ -24,10 +24,8 @@ var __toModule = (module2) => {
 // packages/@lwrjs/lwc-ssr/src/utils.ts
 __markAsModule(exports);
 __export(exports, {
-  FetchController: () => FetchController,
   SSR_PROPS_ATTR: () => SSR_PROPS_ATTR,
   addHeadMarkup: () => addHeadMarkup,
-  createFetchEndowment: () => createFetchEndowment,
   createHeadMarkup: () => createHeadMarkup,
   createSsrErrorMarkup: () => createSsrErrorMarkup,
   createSsrErrorMessage: () => createSsrErrorMessage,
@@ -39,7 +37,6 @@ __export(exports, {
   getServerBootstrapServices: () => getServerBootstrapServices
 });
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
-var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var DEFAULT_SSR_TIMEOUT = 5e3;
 var SSR_PROPS_ATTR = "data-lwr-props-id";
@@ -126,96 +123,6 @@ function getServerBootstrapServices(route) {
     return acc;
   }, []);
 }
-var FetchController = class {
-  constructor(fetchEndowment) {
-    this.controlledFetch = (request, init) => {
-      if (this.killSwitchActivated) {
-        return this.handleAbortError(request, void 0);
-      }
-      const controller = new AbortController();
-      const updatedInit = {...init, signal: controller.signal};
-      this.controllers.add(controller);
-      const fetchFunction = this.noOpActivated ? this.fetchNoOp(request, updatedInit) : this.fetchEndowment(request, updatedInit);
-      const fetchPromise = fetchFunction.catch((error) => {
-        if (error && error?.stack.startsWith("AbortError")) {
-          return this.handleAbortError(request, error);
-        } else {
-          throw error;
-        }
-      }).finally(() => {
-        this.controllers.delete(controller);
-      });
-      return fetchPromise;
-    };
-    this.activateKillSwitch = () => {
-      this.killSwitchActivated = true;
-      this.controllers.forEach((controller) => {
-        controller.abort();
-      });
-      this.controllers.clear();
-    };
-    this.deactivateKillSwitch = () => {
-      this.killSwitchActivated = false;
-    };
-    this.activateNoOp = () => {
-      this.noOpActivated = true;
-    };
-    this.deactivateNoOp = () => {
-      this.noOpActivated = false;
-    };
-    this.killSwitchActivated = false;
-    this.noOpActivated = false;
-    this.controllers = new Set();
-    this.fetchEndowment = fetchEndowment;
-  }
-  handleAbortError(request, error) {
-    const message = `Orphaned ${String(request)} request was killed. 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}));
-  }
-  fetchNoOp(request, init) {
-    return new Promise((resolve) => {
-      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")));
-      } else {
-        const abortHandler = (err) => {
-          init?.signal?.removeEventListener("abort", abortHandler);
-          resolve(this.handleAbortError(request, err));
-        };
-        init.signal.addEventListener("abort", abortHandler);
-      }
-    });
-  }
-};
-function createFetchEndowment(trace, host = "", requestCount = 1) {
-  return (request, init) => {
-    let finalRequest;
-    let finalUrl;
-    if (request instanceof Request) {
-      const curUrl = request.url;
-      if (curUrl.startsWith("/")) {
-        finalUrl = host + curUrl;
-        finalRequest = new Request(finalUrl, request);
-      } else {
-        finalUrl = curUrl;
-        finalRequest = request;
-      }
-    } else {
-      const curUrl = typeof request === "string" ? request : request.toString();
-      finalRequest = finalUrl = curUrl.startsWith("/") ? host + curUrl : curUrl;
-    }
-    const finalInit = {
-      ...init,
-      headers: {
-        ...init?.headers,
-        [import_shared_utils.REQUEST_DEPTH_HEADER]: String(requestCount)
-      }
-    };
-    return trace({name: import_instrumentation.ViewSpan.Fetch, attributes: {url: String(finalUrl)}}, () => fetch(finalRequest, finalInit));
-  };
-}
 function createMetaTags(meta) {
   return meta.reduce((metaStr, {name, content, httpEquiv}) => {
     if (!name && !content && !httpEquiv)

package/build/es/fetchController.d.ts

@@ -0,0 +1,47 @@
+import { TraceFn } from '@lwrjs/instrumentation';
+export type FetchFunction = (request: string | URL | globalThis.Request, init?: RequestInit) => Promise<Response>;
+export type FetchRequestContext = {
+    host?: string;
+    requestDepth?: number;
+    headers?: HeadersInit | undefined;
+};
+/**
+ * During SSR a context is created with a new fetchController. At this point any fetches work as expected in this context.
+ *
+ * Right before renderComponents we call activateNoOp. At this point any new fetch calls in this context result in a no-op
+ * fetch waiting to be aborted.
+ *
+ * When SSR for this request is complete we call activateKillSwitch which aborts any pending fetch calls in this context.
+ * Any new fetch calls (i.e. from other async function calls) would be immediately aborted.
+ */
+export declare class FetchController {
+    private killSwitchActivated;
+    private noOpActivated;
+    private controllers;
+    private headers;
+    private host;
+    private requestDepth;
+    fetchEndowment: FetchFunction;
+    constructor(trace: TraceFn<Response>, host?: string, requestDepth?: number);
+    controlledFetch: FetchFunction;
+    /**
+     * After SSR is complete the kill switch will abort any pending fetch requests.
+     */
+    activateKillSwitch: () => void;
+    deactivateKillSwitch: () => void;
+    /**
+     * During SSR renderComponent (which is synchronous) Do not even call any fetch requests
+     * since they would not complete before SSR is done.
+     */
+    activateNoOp: () => void;
+    deactivateNoOp: () => void;
+    setFetchRequestContext: (context: FetchRequestContext) => void;
+    private handleAbortError;
+    /**
+     * Create a fetch API that never calls a request.
+     * This is not expected to be called without an AbortController setup.
+     */
+    private fetchNoOp;
+    private createFetchEndowment;
+}
+//# sourceMappingURL=fetchController.d.ts.map

package/build/es/fetchController.js

@@ -0,0 +1,154 @@
+import { REQUEST_DEPTH_HEADER } from '@lwrjs/shared-utils';
+import { logger } from '@lwrjs/diagnostics';
+import { ViewSpan } from '@lwrjs/instrumentation';
+/**
+ * During SSR a context is created with a new fetchController. At this point any fetches work as expected in this context.
+ *
+ * Right before renderComponents we call activateNoOp. At this point any new fetch calls in this context result in a no-op
+ * fetch waiting to be aborted.
+ *
+ * When SSR for this request is complete we call activateKillSwitch which aborts any pending fetch calls in this context.
+ * Any new fetch calls (i.e. from other async function calls) would be immediately aborted.
+ */
+export class FetchController {
+    constructor(trace, host = '', requestDepth = 1) {
+        this.controlledFetch = (request, init) => {
+            if (this.killSwitchActivated) {
+                return this.handleAbortError(request, undefined);
+            }
+            const controller = new AbortController();
+            // Ensure the init object exists and then add the signal to it.
+            const updatedInit = {
+                ...init,
+                headers: { ...init?.headers, ...this.headers },
+                signal: controller.signal,
+            };
+            this.controllers.add(controller);
+            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;
+                }
+            })
+                .finally(() => {
+                this.controllers.delete(controller);
+            });
+            return fetchPromise;
+        };
+        /**
+         * After SSR is complete the kill switch will abort any pending fetch requests.
+         */
+        this.activateKillSwitch = () => {
+            this.killSwitchActivated = true;
+            this.controllers.forEach((controller) => {
+                controller.abort();
+            });
+            this.controllers.clear(); // Clear the set as all fetch calls have been aborted
+        };
+        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 { host, headers, requestDepth = 0 } = context;
+            this.host = host;
+            this.headers = headers;
+            this.requestDepth = requestDepth;
+        };
+        this.killSwitchActivated = false;
+        this.noOpActivated = false;
+        this.controllers = new Set();
+        this.host = host;
+        this.requestDepth = requestDepth;
+        this.fetchEndowment = this.createFetchEndowment(trace);
+    }
+    handleAbortError(request, error) {
+        const message = `Orphaned ${String(request)} request was killed. 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 }));
+    }
+    /**
+     * Create a fetch API that never calls a request.
+     * This is not expected to be called without an AbortController setup.
+     */
+    fetchNoOp(request, init) {
+        return new Promise((resolve) => {
+            if (!init?.signal) {
+                // This should not happen?  This is only called internally to the class and we setup an abort controller.
+                resolve(this.handleAbortError(request, new Error('RequestInit was not setup as expected')));
+            }
+            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')));
+            }
+            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));
+                };
+                init.signal.addEventListener('abort', abortHandler);
+            }
+        });
+    }
+    createFetchEndowment(trace) {
+        return (request, init) => {
+            const { host, requestDepth } = this;
+            let finalRequest;
+            let finalUrl;
+            if (request instanceof Request) {
+                const curUrl = request.url;
+                // proxy relative URLs through the host
+                if (curUrl.startsWith('/')) {
+                    finalUrl = host + curUrl;
+                    finalRequest = new Request(finalUrl, request);
+                }
+                else {
+                    finalUrl = curUrl;
+                    finalRequest = request;
+                }
+            }
+            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
+            }
+            const finalInit = {
+                ...init,
+                headers: {
+                    ...init?.headers,
+                    [REQUEST_DEPTH_HEADER]: String(requestDepth),
+                },
+            };
+            logger.info({
+                label: `pre ${ViewSpan.Fetch}`,
+                message: `finalUrl: ${String(finalUrl)}`,
+            });
+            return trace({ name: ViewSpan.Fetch, attributes: { url: String(finalUrl) } }, () => 
+            // 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
+            // if the caller throws the fetch error, then it will be surfaced in the PARENT traces:
+            // lwr.view.ssr.fetch (this) > lwr.view.ssr > lwr.view.ssr.island > lwr.view.render > lwr.handle.view
+            fetch(finalRequest, finalInit));
+        };
+    }
+}
+//# sourceMappingURL=fetchController.js.map

package/build/es/moduleLoader.d.ts

@@ -1,4 +1,5 @@
 import type { ClientBootstrapConfig, NormalizedLwrAppBootstrapConfig, ProviderAppConfig, PublicModuleBundler, PublicResourceRegistry, RuntimeEnvironment, RuntimeParams, ServerData, ServerServiceAPI } from '@lwrjs/types';
+import type { FetchRequestContext } from './fetchController.js';
 export declare const FETCH_ABORT_KEY = "__fetchAbortId__";
 export interface Context extends Record<string, any> {
     LWR: ClientBootstrapConfig;
@@ -8,6 +9,7 @@ export interface ContextController {
     disableNoOpFetch: () => void;
     enableFetchKillSwitch: () => void;
     disableFetchKillSwitch: () => void;
+    setFetchRequestContext: (context: FetchRequestContext) => void;
 }
 export interface ModuleLoader {
     load: (specifier: string, aliases?: string[]) => Promise<any>;

package/build/es/moduleLoader.js

@@ -2,7 +2,8 @@ import path from 'path';
 import crypto from 'crypto';
 import { getTracer } from '@lwrjs/instrumentation';
 import { explodeSpecifier, getSpecifier } from '@lwrjs/shared-utils';
-import { FetchController, createFetchEndowment, getLoaderConfig, getLoaderId, getLoaderShim, } from './utils.js';
+import { getLoaderConfig, getLoaderId, getLoaderShim } from './utils.js';
+import { FetchController } from './fetchController.js';
 export const FETCH_ABORT_KEY = '__fetchAbortId__';
 const BOOTSTRAP_SPECIFIER = '@lwrjs/ssr-bootstrap';
 export function createModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData, bootstrapConfig) {
@@ -141,8 +142,7 @@ function createContext(LWR, runtimeParams) {
     // todo: fetch endowment should consume tracer directly
     const tracer = getTracer();
     const trace = tracer.trace.bind(tracer);
-    const fetchEndowment = createFetchEndowment(trace, runtimeParams.host, runtimeParams.requestDepth);
-    const fetchController = new FetchController(fetchEndowment);
+    const fetchController = new FetchController(trace, runtimeParams.host, runtimeParams.requestDepth);
     const context = {
         LWR,
         lwcRuntimeFlags: { ENABLE_WIRE_SYNC_EMIT: true },
@@ -167,6 +167,9 @@ function createContext(LWR, runtimeParams) {
             disableFetchKillSwitch: () => {
                 fetchController.deactivateKillSwitch();
             },
+            setFetchRequestContext: (context) => {
+                fetchController.setFetchRequestContext(context);
+            },
         },
     };
 }

package/build/es/renderer.d.ts

@@ -32,8 +32,6 @@ export declare class Renderer {
     bundleRegistry: PublicModuleBundler;
     resourceRegistry: PublicResourceRegistry;
     contextPerEnv: LRUCache<string, BootstrapContext>;
-    cachedBootstrapContext: BootstrapContext | undefined;
-    pendingRender: Promise<RenderResults> | undefined;
     pendingRenders: TaskPool;
     constructor(config: ProviderAppConfig, bundleRegistry: PublicModuleBundler, resourceRegistry: PublicResourceRegistry);
     /**
@@ -54,6 +52,7 @@ export declare class Renderer {
      */
     render(components: Record<string, Component>, route: NormalizedLwrRoute | NormalizedLwrErrorRoute, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams, serverData?: ServerData, isFirstOf2PassSSR?: boolean): Promise<RenderResults>;
     private renderComponents;
+    private resetFetchController;
     private getCachedBootstrapContext;
 }
 export {};

package/build/es/renderer.js

@@ -34,7 +34,7 @@ export class Renderer {
                 logger.info('evicted bootstrap context from renderer cache');
             },
         });
-        // TODO: remove the task pool altogether once W-16104831 and W-16047359 are resolved.
+        // TODO: remove the task pool altogether once W-16047359 is resolved.
         // Until the above issues are resolved, we can only handle one request at a time.
         // Since Lambda's can only handle 1 request at a time anyways, this is fine for now.
         const taskPoolSize = getFeatureFlags().SINGLE_RENDER_MODE ? 1 : 15;
@@ -89,8 +89,11 @@ export class Renderer {
         const errors = {};
         const roots = Object.keys(components);
         const services = getServerBootstrapServices(route);
-        // TODO: not needed once W-16104831 is resolved
+        // For LWR@MRT, module re-evaluation is enabled by default
         const reevaluateModules = getFeatureFlags().REEVALUATE_MODULES === true;
+        // `SINGLE_RENDER_MODE` forces local preview of LWR@MRT apps to only handle
+        // one request at a time. This is required until our fetch endowment (W-16047359) is updated
+        // to be able to handle multiple concurrent requests.
         const singleRenderMode = getFeatureFlags().SINGLE_RENDER_MODE;
         let loader, loaderPromise, bootstrapServiceEvaluationMap;
         try {
@@ -98,13 +101,14 @@ export class Renderer {
             // E.g. if we `env.basePath: '/'` vs `env.basePath: '/foo` will result
             // in the new contexts created and used for by the renderer.
             //
-            // TODO: W-16104831: when `REEVALUATE_MODULES` is enabled, we only have a single context/loader, regardless of env
-            const bootstrapContext = this.getCachedBootstrapContext(route, runtimeEnvironment, runtimeParams, serverData, reevaluateModules);
+            // When `REEVALUATE_MODULES` is enabled, we only have a single context/loader, regardless of env
+            const bootstrapContext = this.getCachedBootstrapContext(route, runtimeEnvironment, runtimeParams, serverData);
             loaderPromise = bootstrapContext.loader;
             bootstrapServiceEvaluationMap = bootstrapContext.bootstrapServiceEvaluationMap;
             loader = await loaderPromise;
-            // Re-enable fetch that was disabled at the end of the previous page render via `enableFetchKillSwitch`
-            loader.getFetchController().disableFetchKillSwitch();
+            // reset/init the fetch controller between page renders
+            const fetchController = loader.getFetchController();
+            this.resetFetchController(fetchController, runtimeParams, route);
             // load and alias the LWC server engine
             // this MUST be done first in case bootstrap services depend on LWC
             const engineServerSpecifier = getSpecifier({
@@ -213,7 +217,6 @@ export class Renderer {
                 // since we have a single global context that is maintained across page renders,
                 // we need to clean it up so that state such as globalThis.LWR.serverData is not preserved
                 loader?.resetGlobalContext();
-                // TODO: not needed once W-16104831 is resolved
                 // When `REEVALUATE_MODULES` is enabled, we clear the loader's module registry + bootstrap services
                 // at the end of every render so that module state is not preserved.
                 if (reevaluateModules) {
@@ -224,25 +227,32 @@ export class Renderer {
             }
         }
     }
-    getCachedBootstrapContext(route, runtimeEnvironment, runtimeParams, serverData, reevaluateModules) {
+    resetFetchController(fetchController, runtimeParams, route) {
+        // Re-enable fetch that was disabled at the end of the previous page render via `enableFetchKillSwitch`
+        fetchController.disableFetchKillSwitch();
+        fetchController.setFetchRequestContext({
+            host: runtimeParams.host,
+            requestDepth: runtimeParams.requestDepth,
+            headers: undefined,
+        });
+    }
+    getCachedBootstrapContext(route, runtimeEnvironment, runtimeParams, serverData) {
         let loader, bootstrapServiceEvaluationMap;
         // when `REEEVALUTE_MODULES` is true, we only have a single context/loader, regardless of the env
-        if (reevaluateModules) {
-            if (!this.cachedBootstrapContext || isLocalDev()) {
-                this.cachedBootstrapContext = {
-                    loader: createModuleLoader(this.config, this.resourceRegistry, this.bundleRegistry, runtimeEnvironment, runtimeParams, serverData, route.bootstrap),
-                    bootstrapServiceEvaluationMap: new Map(),
-                };
-            }
-            return this.cachedBootstrapContext;
-        }
-        // The cache key is derived from LWR env context AND the host header,
-        // because we associate the host header to each fetch context.
+        // We need a new context everytime we change LWR contexts that modules depend on,
+        // because the module needs to be *re-generated* with the new context values.
+        //
+        // On the Salesforce platform, this is *only* needed for label modules (depends on runtimeParams.locale),
+        // and the `lwr/environment` module (depends on multiple runtimeParams).
+        //
+        // North star, we want to avoid runtime generated modules. Do NOT add additional dependencies
+        // unless absolutely neccesary.
         const envContext = buildEnvironmentContext(runtimeParams);
-        const { host, requestDepth } = runtimeParams;
-        const contextCacheKey = getCacheKeyFromJson({ envContext, host, requestDepth });
+        const contextCacheKey = getCacheKeyFromJson({ envContext });
         const bootstrapContext = this.contextPerEnv.get(contextCacheKey);
-        if (!bootstrapContext) {
+        // Note: we can avoid creating a new context for local dev
+        // if we update the loader to allow module redefines during local dev
+        if (!bootstrapContext || isLocalDev()) {
             loader = createModuleLoader(this.config, this.resourceRegistry, this.bundleRegistry, runtimeEnvironment, runtimeParams, serverData, route.bootstrap);
             bootstrapServiceEvaluationMap = new Map();
             this.contextPerEnv.set(contextCacheKey, {

package/build/es/utils.d.ts

@@ -1,5 +1,4 @@
 import type { ClientBootstrapConfig, EnvironmentContext, LwrStringBuilder, NormalizedLwrAppBootstrapConfig, NormalizedLwrErrorRoute, NormalizedLwrRoute, ProviderAppConfig, PublicResourceRegistry, RuntimeEnvironment, RuntimeParams, ServerData, SsrDataResponse } from '@lwrjs/types';
-import { TraceFn } from '@lwrjs/instrumentation';
 interface ServerEnvironment extends EnvironmentContext {
     SSR: boolean;
 }
@@ -14,42 +13,6 @@ export declare function getLoaderConfig(bootstrapModule: string, config: Provide
     env: ServerEnvironment;
 };
 export declare function getServerBootstrapServices(route: NormalizedLwrRoute | NormalizedLwrErrorRoute): string[];
-export type FetchFunction = (request: string | URL | globalThis.Request, init?: RequestInit) => Promise<Response>;
-/**
- * During SSR a context is created with a new fetchController. At this point any fetches work as expected in this context.
- *
- * Right before renderComponents we call activateNoOp. At this point any new fetch calls in this context result in a no-op
- * fetch waiting to be aborted.
- *
- * When SSR for this request is complete we call activateKillSwitch which aborts any pending fetch calls in this context.
- * Any new fetch calls (i.e. from other async function calls) would be immediately aborted.
- */
-export declare class FetchController {
-    private killSwitchActivated;
-    private noOpActivated;
-    private controllers;
-    private fetchEndowment;
-    constructor(fetchEndowment: FetchFunction);
-    controlledFetch: FetchFunction;
-    /**
-     * After SSR is complete the kill switch will abort any pending fetch requests.
-     */
-    activateKillSwitch: () => void;
-    deactivateKillSwitch: () => void;
-    /**
-     * During SSR renderComponent (which is synchronous) Do not even call any fetch requests
-     * since they would not complete before SSR is done.
-     */
-    activateNoOp: () => void;
-    deactivateNoOp: () => void;
-    private handleAbortError;
-    /**
-     * Create a fetch API that never calls a request.
-     * This is not expected to be called without an AbortController setup.
-     */
-    private fetchNoOp;
-}
-export declare function createFetchEndowment(trace: TraceFn<Response>, host?: string, requestCount?: number): FetchFunction;
 /**
  * Serialize SsrDataResponse.markup into an HTML string
  * @param results An array of responses from getServerData hooks

package/build/es/utils.js

@@ -1,6 +1,5 @@
 import { logger, stringifyError } from '@lwrjs/diagnostics';
-import { ViewSpan } from '@lwrjs/instrumentation';
-import { REQUEST_DEPTH_HEADER, buildEnvironmentContext, getFeatureFlags, normalizeVersionToUri, isLambdaEnv, } from '@lwrjs/shared-utils';
+import { buildEnvironmentContext, getFeatureFlags, normalizeVersionToUri, isLambdaEnv, } 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';
 export function getPropsId() {
@@ -101,139 +100,6 @@ export function getServerBootstrapServices(route) {
         return acc;
     }, []);
 }
-/**
- * During SSR a context is created with a new fetchController. At this point any fetches work as expected in this context.
- *
- * Right before renderComponents we call activateNoOp. At this point any new fetch calls in this context result in a no-op
- * fetch waiting to be aborted.
- *
- * When SSR for this request is complete we call activateKillSwitch which aborts any pending fetch calls in this context.
- * Any new fetch calls (i.e. from other async function calls) would be immediately aborted.
- */
-export class FetchController {
-    constructor(fetchEndowment) {
-        this.controlledFetch = (request, init) => {
-            if (this.killSwitchActivated) {
-                return this.handleAbortError(request, undefined);
-            }
-            const controller = new AbortController();
-            // Ensure the init object exists and then add the signal to it.
-            const updatedInit = { ...init, signal: controller.signal };
-            this.controllers.add(controller);
-            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;
-                }
-            })
-                .finally(() => {
-                this.controllers.delete(controller);
-            });
-            return fetchPromise;
-        };
-        /**
-         * After SSR is complete the kill switch will abort any pending fetch requests.
-         */
-        this.activateKillSwitch = () => {
-            this.killSwitchActivated = true;
-            this.controllers.forEach((controller) => {
-                controller.abort();
-            });
-            this.controllers.clear(); // Clear the set as all fetch calls have been aborted
-        };
-        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.killSwitchActivated = false;
-        this.noOpActivated = false;
-        this.controllers = new Set();
-        this.fetchEndowment = fetchEndowment;
-    }
-    handleAbortError(request, error) {
-        const message = `Orphaned ${String(request)} request was killed. 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 }));
-    }
-    /**
-     * Create a fetch API that never calls a request.
-     * This is not expected to be called without an AbortController setup.
-     */
-    fetchNoOp(request, init) {
-        return new Promise((resolve) => {
-            if (!init?.signal) {
-                // This should not happen?  This is only called internally to the class and we setup an abort controller.
-                resolve(this.handleAbortError(request, new Error('RequestInit was not setup as expected')));
-            }
-            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')));
-            }
-            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));
-                };
-                init.signal.addEventListener('abort', abortHandler);
-            }
-        });
-    }
-}
-export function createFetchEndowment(trace, host = '', requestCount = 1) {
-    return (request, init) => {
-        let finalRequest;
-        let finalUrl;
-        if (request instanceof Request) {
-            const curUrl = request.url;
-            // proxy relative URLs through the host
-            if (curUrl.startsWith('/')) {
-                finalUrl = host + curUrl;
-                finalRequest = new Request(finalUrl, request);
-            }
-            else {
-                finalUrl = curUrl;
-                finalRequest = request;
-            }
-        }
-        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
-        }
-        const finalInit = {
-            ...init,
-            headers: {
-                ...init?.headers,
-                [REQUEST_DEPTH_HEADER]: String(requestCount),
-            },
-        };
-        return trace({ name: ViewSpan.Fetch, attributes: { url: String(finalUrl) } }, () => 
-        // 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
-        // if the caller throws the fetch error, then it will be surfaced in the PARENT traces:
-        // lwr.view.ssr.fetch (this) > lwr.view.ssr > lwr.view.ssr.island > lwr.view.render > lwr.handle.view
-        fetch(finalRequest, finalInit));
-    };
-}
 /** SSR HEAD MARKUP UTILS */
 function createMetaTags(meta) {
     return meta.reduce((metaStr, { name, content, httpEquiv }) => {

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.13.7",
+    "version": "0.13.9",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -42,16 +42,16 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/config": "0.13.7",
-        "@lwrjs/diagnostics": "0.13.7",
-        "@lwrjs/instrumentation": "0.13.7",
-        "@lwrjs/loader": "0.13.7",
-        "@lwrjs/shared-utils": "0.13.7",
+        "@lwrjs/config": "0.13.9",
+        "@lwrjs/diagnostics": "0.13.9",
+        "@lwrjs/instrumentation": "0.13.9",
+        "@lwrjs/loader": "0.13.9",
+        "@lwrjs/shared-utils": "0.13.9",
         "fs-extra": "^11.2.0",
         "lru-cache": "^10.4.3"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.13.7",
+        "@lwrjs/types": "0.13.9",
         "jest": "^26.6.3",
         "memfs": "^4.9.3",
         "ts-jest": "^26.5.6"
@@ -62,5 +62,5 @@
     "volta": {
         "extends": "../../../package.json"
     },
-    "gitHead": "216a7383b5ae5cba4274f093ff3fff5accc3405f"
+    "gitHead": "c991b71930739c3ac1f411b361a09ac777f7eeb3"
 }