@lwrjs/lwc-ssr 0.13.0-alpha.8 → 0.13.0

package/README.md

@@ -115,7 +115,7 @@ declare global {
 
 ### Loading data during SSR
 
-Many components depend on external data and resources. LWR provides a `getServerData()` hook for developers to fetch data on the server. During SSR, LWR calls the `getServerData()` hook for each **root component**, then serializes the resulting data into the page document as either [JSON](#json) or [markup](#markup).
+Many components depend on external data and resources. LWR provides a [`getServerData()` hook](https://developer.salesforce.com/docs/platform/lwr/guide/lwr-enable-ssr-site.html#load-data-during-ssr) for developers to fetch data on the server. During SSR, LWR calls the `getServerData()` hook for each **root component**, then serializes the resulting data into the page document as either [JSON](#json) or [markup](#markup).
 
 If an error is thrown from `getServerData()`, rendering will fail and the server will return an HTTP 500 error for the page request. If this is undesirable, catch any errors thrown while fetching data and return default values from `getServerData()`.
 

package/build/cjs/moduleLoader.cjs

@@ -24,6 +24,7 @@ var __toModule = (module2) => {
 // packages/@lwrjs/lwc-ssr/src/moduleLoader.ts
 __markAsModule(exports);
 __export(exports, {
+  FETCH_ABORT_KEY: () => FETCH_ABORT_KEY,
   createModuleLoader: () => createModuleLoader
 });
 var import_path = __toModule(require("path"));
@@ -31,34 +32,44 @@ 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 FETCH_ABORT_KEY = "__fetchAbortId__";
 var BOOTSTRAP_SPECIFIER = "@lwrjs/ssr-bootstrap";
-function createModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData) {
+function createModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData, bootstrapConfig) {
   const createLoader = runtimeEnvironment.format === "amd" ? createAMDModuleLoader : createESMModuleLoader;
-  return createLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData);
+  return createLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData, bootstrapConfig);
 }
-async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData) {
+async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData, bootstrapConfig) {
   const loaderConfig = (0, import_utils.getLoaderConfig)(BOOTSTRAP_SPECIFIER, config, runtimeParams, serverData);
   const {context, controller} = createContext(loaderConfig, runtimeParams);
+  const contextKeyMap = new Map(Object.keys(context).map((key) => [key, true]));
   let run;
   context.LWR.customInit = async (lwr) => {
     run = lwr.initializeApp;
   };
+  const useEval = process.env.SSR_DEBUG === "true";
   const init = (source) => {
-    const fn = new Function("globalThis", ...Object.keys(context), source);
-    fn(context, ...Object.values(context));
+    if (!useEval) {
+      const fn = new Function("globalThis", ...Object.keys(context), source);
+      fn(context, ...Object.values(context));
+    } else {
+      ((context) => {
+        eval(`${Object.keys(context).reduce((c, k) => c + `const ${k} = context['${k}'];`, "globalThis=context;")} ${source}`);
+      })(context);
+    }
   };
-  init(await (0, import_utils.getLoaderShim)(resourceRegistry, runtimeEnvironment));
+  init(await (0, import_utils.getLoaderShim)(resourceRegistry, runtimeEnvironment, bootstrapConfig));
   if (!run) {
     throw new Error("Failed to init loader shim: custom init not called");
   }
   const p = new Promise((resolve) => {
-    context.LWR.define(BOOTSTRAP_SPECIFIER, [(0, import_utils.getLoaderId)(context.LWR)], (l) => resolve(l));
+    context.LWR.define(BOOTSTRAP_SPECIFIER, [(0, import_utils.getLoaderId)(context.LWR, bootstrapConfig)], (l) => resolve(l));
   });
   run();
-  const {load, services} = await p;
+  const {load, services, clearRegistry} = await p;
   const visited = new Set(["lwc"]);
   return {
     services,
+    clearRegistry,
     load: async (specifier, aliases) => {
       const injectBundle = async (bundle, aliases2) => {
         if (visited.has(bundle) && specifier !== bundle) {
@@ -67,9 +78,10 @@ async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, r
         visited.add(bundle);
         const moduleId = (0, import_shared_utils.explodeSpecifier)(bundle);
         const def = await bundleRegistry.getModuleBundle(moduleId, runtimeEnvironment, runtimeParams);
-        if (typeof def.src === "string") {
+        if (typeof def.src === "string" && !def.code.includes("//# sourceURL=")) {
+          const srcUrl = (0, import_shared_utils.isLocalDev)() ? (0, import_shared_utils.getLocalDevOverrideUrl)(config.cacheDir, moduleId.specifier, def.src) : def.src;
           def.code += `
-//# sourceURL=${import_path.default.resolve(def.src)}`;
+//# sourceURL=${import_path.default.resolve(srcUrl)}`;
         }
         const staticImports = def.bundleRecord.imports?.map((dep) => (0, import_shared_utils.getSpecifier)(dep)) ?? [];
         const dynamicImports = def.bundleRecord.dynamicImports?.map((dep) => (0, import_shared_utils.getSpecifier)(dep)) ?? [];
@@ -101,7 +113,21 @@ async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, r
         module: mod
       };
     },
-    getContextController: () => controller
+    getFetchController: () => controller,
+    resetGlobalContext: () => {
+      for (const key in context) {
+        if (Object.prototype.hasOwnProperty.call(context, key) && !contextKeyMap.has(key)) {
+          delete context[key];
+        }
+      }
+      context.LWR = {
+        ...context.LWR,
+        serverData: void 0
+      };
+    },
+    getContext: () => {
+      return context;
+    }
   };
 }
 async function createESMModuleLoader() {
@@ -125,8 +151,14 @@ function createContext(LWR, runtimeParams) {
       enableNoOpFetch: () => {
         fetchController.activateNoOp();
       },
-      abortAllFetches: () => {
+      disableNoOpFetch: () => {
+        fetchController.deactivateNoOp();
+      },
+      enableFetchKillSwitch: () => {
         fetchController.activateKillSwitch();
+      },
+      disableFetchKillSwitch: () => {
+        fetchController.deactivateKillSwitch();
       }
     }
   };

package/build/cjs/renderer.cjs

@@ -27,6 +27,7 @@ __export(exports, {
   Renderer: () => Renderer,
   getRenderer: () => getRenderer
 });
+var import_lru_cache = __toModule(require("lru-cache"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
@@ -45,38 +46,70 @@ var Renderer = class {
     this.config = config;
     this.bundleRegistry = bundleRegistry;
     this.resourceRegistry = resourceRegistry;
-  }
-  async render(components, route, runtimeEnvironment, runtimeParams, serverData = {}) {
-    let timerId;
-    const timeout = new Promise((_, reject) => {
-      timerId = setTimeout(() => {
-        reject((0, import_diagnostics.createSingleDiagnosticError)({
-          description: import_diagnostics.descriptions.UNRESOLVABLE.SSR_TIMEOUT(route.id, (0, import_utils.getRenderTimeout)())
-        }, import_diagnostics.LwrUnresolvableError));
-      }, (0, import_utils.getRenderTimeout)());
+    this.contextPerEnv = new import_lru_cache.LRUCache({
+      max: 50,
+      dispose: () => {
+        import_diagnostics.logger.info("evicted bootstrap context from renderer cache");
+      }
     });
-    const result = await Promise.race([
-      timeout,
-      this.renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData)
-    ]);
-    clearTimeout(timerId);
+    const taskPoolSize = (0, import_shared_utils.getFeatureFlags)().SINGLE_RENDER_MODE ? 1 : 15;
+    this.pendingRenders = new import_shared_utils.TaskPool(taskPoolSize);
+  }
+  async render(components, route, runtimeEnvironment, runtimeParams, serverData = {}, isFirstOf2PassSSR) {
+    let result;
+    if ((0, import_shared_utils.isLambdaEnv)() || process.env.SSR_TIMEOUT !== void 0) {
+      let timerId;
+      const timeout = new Promise((_, reject) => {
+        timerId = setTimeout(() => {
+          reject((0, import_diagnostics.createSingleDiagnosticError)({
+            description: import_diagnostics.descriptions.UNRESOLVABLE.SSR_TIMEOUT(route.id, (0, import_utils.getRenderTimeout)())
+          }, import_diagnostics.LwrUnresolvableError));
+        }, (0, import_utils.getRenderTimeout)());
+      });
+      result = await this.pendingRenders.execute(async () => {
+        return Promise.race([
+          timeout,
+          this.renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData, isFirstOf2PassSSR)
+        ]);
+      });
+      clearTimeout(timerId);
+    } else {
+      result = await this.pendingRenders.execute(async () => {
+        return this.renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData, isFirstOf2PassSSR);
+      });
+    }
     return result;
   }
-  async renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData = {}) {
+  async renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData = {}, isFirstOf2PassSSR = false) {
     const results = {};
     const errors = {};
     const roots = Object.keys(components);
     const services = (0, import_utils.getServerBootstrapServices)(route);
-    let loader;
+    const reevaluateModules = (0, import_shared_utils.getFeatureFlags)().REEVALUATE_MODULES === true;
+    const singleRenderMode = (0, import_shared_utils.getFeatureFlags)().SINGLE_RENDER_MODE;
+    let loader, loaderPromise, bootstrapServiceEvaluationMap;
     try {
-      loader = await (0, import_moduleLoader.createModuleLoader)(this.config, this.resourceRegistry, this.bundleRegistry, runtimeEnvironment, runtimeParams, serverData);
-      const engine = await loader.load("@lwc/engine-server", ["lwc"]);
-      const serviceModules = await Promise.all(services.map((specifier) => loader?.load(specifier)));
-      const serverBootstrapServices = (0, import_serverBootstrapServices.createServerBootstrapServices)(loader);
-      for (const service of serviceModules) {
-        const error = await (0, import_serverBootstrapServices.evaluateServerBootstrapModule)(service, serverBootstrapServices.serviceAPI);
-        if (error) {
-          errors[service.specifier] = error;
+      const bootstrapContext = this.getCachedBootstrapContext(route, runtimeEnvironment, runtimeParams, serverData, reevaluateModules);
+      loaderPromise = bootstrapContext.loader;
+      bootstrapServiceEvaluationMap = bootstrapContext.bootstrapServiceEvaluationMap;
+      loader = await loaderPromise;
+      loader.getFetchController().disableFetchKillSwitch();
+      const engineServerSpecifier = (0, import_shared_utils.getSpecifier)({
+        specifier: "@lwc/engine-server",
+        version: route.bootstrap.lwcVersion
+      });
+      const engine = await loader.load(engineServerSpecifier, ["lwc"]);
+      const shouldRunBootstrapServices = !bootstrapServiceEvaluationMap?.has(route.id);
+      let serverBootstrapServices;
+      if (shouldRunBootstrapServices) {
+        bootstrapServiceEvaluationMap?.set(route.id, true);
+        const serviceModules = await Promise.all(services.map((specifier) => loader?.load(specifier)));
+        serverBootstrapServices = (0, import_serverBootstrapServices.createServerBootstrapServices)(loader);
+        for (const service of serviceModules) {
+          const error = await (0, import_serverBootstrapServices.evaluateServerBootstrapModule)(service, serverBootstrapServices.serviceAPI);
+          if (error) {
+            errors[service.specifier] = error;
+          }
         }
       }
       const componentModules = await Promise.all(roots.map((specifier) => loader?.load(specifier)));
@@ -103,14 +136,18 @@ var Renderer = class {
           results[component.specifier] = data;
         }
       }
-      serverBootstrapServices.evaluateServerDataHooks(serverData);
+      if (serverBootstrapServices) {
+        serverBootstrapServices.evaluateServerDataHooks(serverData);
+      }
       if (!route.bootstrap.ssr) {
         if (Object.keys(errors).length) {
           return {results, errors};
         }
         return {results};
       }
-      loader.getContextController().enableNoOpFetch();
+      if ((0, import_shared_utils.getFeatureFlags)().SINGLE_RENDER_MODE) {
+        loader.getFetchController().enableNoOpFetch();
+      }
       for (const component of componentModules) {
         if (errors[component.specifier]) {
           continue;
@@ -134,8 +171,49 @@ var Renderer = class {
         }
       };
     } finally {
-      loader?.getContextController().abortAllFetches();
+      if (singleRenderMode) {
+        loader?.getFetchController().disableNoOpFetch();
+        loader?.getFetchController().enableFetchKillSwitch();
+      }
+      if (!isFirstOf2PassSSR) {
+        loader?.resetGlobalContext();
+        if (reevaluateModules) {
+          bootstrapServiceEvaluationMap?.delete(route.id);
+          loader?.clearRegistry();
+        }
+      }
+    }
+  }
+  getCachedBootstrapContext(route, runtimeEnvironment, runtimeParams, serverData, reevaluateModules) {
+    let loader, bootstrapServiceEvaluationMap;
+    if (reevaluateModules) {
+      if (!this.cachedBootstrapContext) {
+        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 bootstrapContext = this.contextPerEnv.get(contextCacheKey);
+    if (!bootstrapContext) {
+      loader = (0, import_moduleLoader.createModuleLoader)(this.config, this.resourceRegistry, this.bundleRegistry, runtimeEnvironment, runtimeParams, serverData, route.bootstrap);
+      bootstrapServiceEvaluationMap = new Map();
+      this.contextPerEnv.set(contextCacheKey, {
+        loader,
+        bootstrapServiceEvaluationMap
+      });
+    } else {
+      loader = bootstrapContext.loader;
+      bootstrapServiceEvaluationMap = bootstrapContext.bootstrapServiceEvaluationMap;
     }
+    return {
+      loader,
+      bootstrapServiceEvaluationMap
+    };
   }
 };
 function getServerData(component, context, serverData) {

package/build/cjs/serverBootstrapServices.cjs

@@ -31,7 +31,7 @@ __export(exports, {
 var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var ServerBootstrapServices = class {
-  evaluateServerDataHooks(serverData) {
+  evaluateServerDataHooks(serverData = {}) {
     for (const serverDataHook of this.serverDataCallbacks) {
       serverDataHook({serverData});
     }
@@ -40,7 +40,12 @@ var ServerBootstrapServices = class {
     this.serverDataCallbacks = [];
     this._serviceAPI = {
       addServerDataCallback: this.registerServerDataCallbacks.bind(this),
-      addLoaderPlugin: loader.services?.addLoaderPlugin
+      addLoaderPlugin: (hooks) => {
+        if (hooks.loadModule) {
+          throw new Error("`loadModule` loader hook is not supported on the server.");
+        }
+        return loader.services.addLoaderPlugin(hooks);
+      }
     };
   }
   get serviceAPI() {

package/build/cjs/utils.cjs

@@ -37,7 +37,6 @@ __export(exports, {
   getRenderTimeout: () => getRenderTimeout,
   getServerBootstrapServices: () => getServerBootstrapServices
 });
-var import_package = __toModule(require("@lwrjs/config/package"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
@@ -53,28 +52,35 @@ function getRenderTimeout() {
 function createSsrErrorMessage(specifier, e) {
   return `Server-side rendering for "${specifier}" failed. Falling back to client-side rendering. Reason: ${(0, import_diagnostics.stringifyError)(e)}`;
 }
-async function getLoaderShim(resourceRegistry, runtimeEnvironment) {
-  const specifier = (0, import_shared_utils.getFeatureFlags)().LEGACY_LOADER ? "lwr-loader-shim-legacy.bundle.min.js" : "lwr-loader-shim.bundle.min.js";
-  const resource = await resourceRegistry.getResource({specifier}, runtimeEnvironment);
-  if (!resource?.stream) {
+async function getLoaderShim(resourceRegistry, runtimeEnvironment, bootstrapConfig) {
+  const {debug} = runtimeEnvironment;
+  const useDebug = debug && !(0, import_shared_utils.isLambdaEnv)();
+  const specifier = (0, import_shared_utils.getFeatureFlags)().LEGACY_LOADER ? useDebug ? "lwr-loader-shim-legacy.bundle.js" : "lwr-loader-shim-legacy.bundle.min.js" : useDebug ? "lwr-loader-shim.bundle.js" : "lwr-loader-shim.bundle.min.js";
+  const resource = await resourceRegistry.getResource({specifier, version: bootstrapConfig.lwrVersion}, runtimeEnvironment, {ignoreDebug: !useDebug});
+  if (!resource?.content && !resource?.stream) {
     throw new Error("Failed to find the loader shim");
   }
   let result = "";
-  for await (const chunk of resource.stream()) {
-    result += chunk;
+  if (resource.content) {
+    result = resource.content;
+  } else {
+    const stream = resource.stream();
+    for await (const chunk of stream) {
+      result += chunk;
+    }
   }
   result += `
 //# sourceURL=${resource.entry}`;
   return result;
 }
-function getLoaderId(config) {
+function getLoaderId(config, bootstrapConfig) {
   if (config.requiredModules) {
     const id = config.requiredModules.find((specifier) => specifier.startsWith("lwr/loader"));
     if (id) {
       return id;
     }
   }
-  const version = (0, import_shared_utils.normalizeVersionToUri)(import_package.lwrVersion);
+  const version = (0, import_shared_utils.normalizeVersionToUri)(bootstrapConfig.lwrVersion);
   return (0, import_shared_utils.getFeatureFlags)().LEGACY_LOADER ? `lwr/loaderLegacy/v/${version}` : `lwr/loader/v/${version}`;
 }
 function getLoaderConfig(bootstrapModule, config, runtimeParams, serverData) {
@@ -121,7 +127,7 @@ var FetchController = class {
       this.controllers.add(controller);
       const fetchFunction = this.noOpActivated ? this.fetchNoOp(request, updatedInit) : this.fetchEndowment(request, updatedInit);
       const fetchPromise = fetchFunction.catch((error) => {
-        if (this.killSwitchActivated) {
+        if (error && error?.stack.startsWith("AbortError")) {
           return this.handleAbortError(request, error);
         } else {
           throw error;
@@ -138,9 +144,15 @@ var FetchController = class {
       });
       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();

package/build/cjs/viewProvider/index.cjs

@@ -59,9 +59,9 @@ var LwcViewProvider = class extends import_base_view_provider.default {
       filePath: specifier,
       viewId,
       properties: viewProperties,
-      render: async (runtimeParams) => {
-        const {config, moduleBundler, resourceRegistry, runtimeEnvironment} = this;
-        const debug = runtimeParams.query?.debug !== void 0;
+      render: async (runtimeParams, runtimeEnvironment) => {
+        const {config, moduleBundler, resourceRegistry} = this;
+        const {debug} = runtimeEnvironment;
         const element = (0, import_shared_utils.moduleSpecifierToKebabCase)(specifier);
         return (0, import_instrumentation.getTracer)().trace({
           name: import_instrumentation.ViewSpan.RenderPage,
@@ -71,7 +71,7 @@ var LwcViewProvider = class extends import_base_view_provider.default {
           if (!route) {
             throw new Error(`Unable to resolve configuration for view: ${viewId.id}`);
           }
-          const {results = {}, errors} = await (0, import_renderer.getRenderer)(config, moduleBundler, resourceRegistry).render({[specifier]: {specifier, props: {}}}, route, runtimeEnvironment, Object(runtimeParams));
+          const {results = {}, errors} = await (0, import_renderer.getRenderer)(config, moduleBundler, resourceRegistry).render({[specifier]: {specifier, props: {}}}, route, runtimeEnvironment, Object(runtimeParams), void 0, true);
           if (errors) {
             const errorString = Object.values(errors).join(", ");
             if (!debug && !(0, import_shared_utils.getFeatureFlags)().SSR_WITH_CSR_FALLBACK) {

package/build/cjs/viewTransformer/index.cjs

@@ -65,7 +65,7 @@ function lwcSsrViewTransformer(options, {config, moduleBundler, resourceRegistry
         if (!route) {
           throw new Error(`Unable to resolve configuration for view: ${viewContext.view.id}`);
         }
-        const {results, errors} = await (0, import_renderer.getRenderer)(config, moduleBundler, resourceRegistry).render(ssrModules, route, viewContext.runtimeEnvironment, viewContext.runtimeParams, metadata.serverData);
+        const {results, errors} = await (0, import_renderer.getRenderer)(config, moduleBundler, resourceRegistry).render(ssrModules, route, viewContext.runtimeEnvironment, viewContext.runtimeParams, metadata.serverData, false);
         for (const root in results) {
           const {html, props, cache} = results[root];
           const {tagName, startOffset, endOffset, hydrate} = ssrModules[root];

package/build/es/moduleLoader.d.ts

@@ -1,15 +1,21 @@
-import type { ClientBootstrapConfig, ProviderAppConfig, PublicModuleBundler, PublicResourceRegistry, RuntimeEnvironment, RuntimeParams, ServerData, ServerServiceAPI } from '@lwrjs/types';
+import type { ClientBootstrapConfig, NormalizedLwrAppBootstrapConfig, ProviderAppConfig, PublicModuleBundler, PublicResourceRegistry, RuntimeEnvironment, RuntimeParams, ServerData, ServerServiceAPI } from '@lwrjs/types';
+export declare const FETCH_ABORT_KEY = "__fetchAbortId__";
 export interface Context extends Record<string, any> {
     LWR: ClientBootstrapConfig;
 }
 export interface ContextController {
     enableNoOpFetch: () => void;
-    abortAllFetches: () => void;
+    disableNoOpFetch: () => void;
+    enableFetchKillSwitch: () => void;
+    disableFetchKillSwitch: () => void;
 }
 export interface ModuleLoader {
     load: (specifier: string, aliases?: string[]) => Promise<any>;
-    getContextController: () => ContextController;
-    services?: ServerServiceAPI;
+    getFetchController: () => ContextController;
+    resetGlobalContext: () => void;
+    getContext: () => Context;
+    clearRegistry: Function;
+    services: ServerServiceAPI;
 }
-export declare function createModuleLoader(config: ProviderAppConfig, resourceRegistry: PublicResourceRegistry, bundleRegistry: PublicModuleBundler, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams, serverData: ServerData): Promise<ModuleLoader>;
+export declare function createModuleLoader(config: ProviderAppConfig, resourceRegistry: PublicResourceRegistry, bundleRegistry: PublicModuleBundler, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams, serverData: ServerData, bootstrapConfig: NormalizedLwrAppBootstrapConfig): Promise<ModuleLoader>;
 //# sourceMappingURL=moduleLoader.d.ts.map

package/build/es/moduleLoader.js

@@ -1,44 +1,56 @@
 import path from 'path';
 import crypto from 'crypto';
 import { getTracer } from '@lwrjs/instrumentation';
-import { explodeSpecifier, getSpecifier } from '@lwrjs/shared-utils';
+import { explodeSpecifier, getLocalDevOverrideUrl, getSpecifier, isLocalDev } from '@lwrjs/shared-utils';
 import { FetchController, createFetchEndowment, getLoaderConfig, getLoaderId, getLoaderShim, } from './utils.js';
+export const FETCH_ABORT_KEY = '__fetchAbortId__';
 const BOOTSTRAP_SPECIFIER = '@lwrjs/ssr-bootstrap';
-export function createModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData) {
+export function createModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData, bootstrapConfig) {
     const createLoader = runtimeEnvironment.format === 'amd' ? createAMDModuleLoader : createESMModuleLoader;
-    return createLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData);
+    return createLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData, bootstrapConfig);
 }
-async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData) {
+async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData, bootstrapConfig) {
     // creating a render context to avoid polluting globals
     const loaderConfig = getLoaderConfig(BOOTSTRAP_SPECIFIER, config, runtimeParams, serverData);
     const { context, controller } = createContext(loaderConfig, runtimeParams);
+    const contextKeyMap = new Map(Object.keys(context).map((key) => [key, true]));
     // attaching custom init to delay bootstrap module evaluation
     let run;
     context.LWR.customInit = async (lwr) => {
         run = lwr.initializeApp;
     };
     // instantiate modules with shadowed globals
+    const useEval = process.env.SSR_DEBUG === 'true';
     const init = (source) => {
-        const fn = new Function('globalThis', ...Object.keys(context), source);
-        fn(context, ...Object.values(context));
+        if (!useEval) {
+            const fn = new Function('globalThis', ...Object.keys(context), source);
+            fn(context, ...Object.values(context));
+        }
+        else {
+            // use eval to ensure source map line numbers are correct for debugging
+            ((context) => {
+                eval(`${Object.keys(context).reduce((c, k) => c + `const ${k} = context['${k}'];`, 'globalThis=context;')} ${source}`);
+            })(context);
+        }
     };
     // load and instantiate the loader shim
-    init(await getLoaderShim(resourceRegistry, runtimeEnvironment));
+    init(await getLoaderShim(resourceRegistry, runtimeEnvironment, bootstrapConfig));
     if (!run) {
         throw new Error('Failed to init loader shim: custom init not called');
     }
     // manually define bootstrap module to export the loader
     const p = new Promise((resolve) => {
-        context.LWR.define(BOOTSTRAP_SPECIFIER, [getLoaderId(context.LWR)], (l) => resolve(l));
+        context.LWR.define(BOOTSTRAP_SPECIFIER, [getLoaderId(context.LWR, bootstrapConfig)], (l) => resolve(l));
     });
     // execute the bootstrap module
     run();
     // loader API should be available after bootstrap module evaluation
-    const { load, services } = await p;
+    const { load, services, clearRegistry } = await p;
     // todo: could this use the loader's module cache?
     const visited = new Set(['lwc']);
     return {
         services,
+        clearRegistry,
         load: async (specifier, aliases) => {
             const injectBundle = async (bundle, aliases) => {
                 if (visited.has(bundle) && specifier !== bundle) {
@@ -47,10 +59,13 @@ async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, r
                 visited.add(bundle);
                 const moduleId = explodeSpecifier(bundle);
                 const def = await bundleRegistry.getModuleBundle(moduleId, runtimeEnvironment, runtimeParams);
-                if (typeof def.src === 'string') {
-                    def.code += `\n//# sourceURL=${path.resolve(def.src)}`;
+                if (typeof def.src === 'string' && !def.code.includes('//# sourceURL=')) {
+                    // @view bundles are stored in a special location during local-dev
+                    const srcUrl = isLocalDev()
+                        ? getLocalDevOverrideUrl(config.cacheDir, moduleId.specifier, def.src)
+                        : def.src;
+                    def.code += `\n//# sourceURL=${path.resolve(srcUrl)}`;
                 }
-                // todo: could this be a loader hook?
                 const staticImports = def.bundleRecord.imports?.map((dep) => getSpecifier(dep)) ?? [];
                 const dynamicImports = def.bundleRecord.dynamicImports?.map((dep) => getSpecifier(dep)) ?? [];
                 if (staticImports.length || dynamicImports.length) {
@@ -59,6 +74,7 @@ async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, r
                 }
                 // inject the bundle into the loader's module registry
                 init(def.code);
+                // TODO: fix duplicate aliases problem
                 // create aliases
                 if (aliases?.length) {
                     for (const alias of aliases) {
@@ -69,7 +85,7 @@ async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, r
                         }), [def.id], (mod) => mod);
                     }
                 }
-                // version hack
+                // TODO: remove this once we confirm it's no longer needed in CLWR
                 if (def.specifier.startsWith('@app') || def.specifier.startsWith('@salesforce')) {
                     context.LWR.define(getSpecifier(def), [def.specifier], (mod) => mod);
                 }
@@ -87,7 +103,27 @@ async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, r
                 module: mod,
             };
         },
-        getContextController: () => controller,
+        getFetchController: () => controller,
+        resetGlobalContext: () => {
+            // Clear the context of all of the keys that may be added by module evaluation.
+            // Do not delete keys that we added ourselves.
+            for (const key in context) {
+                if (Object.prototype.hasOwnProperty.call(context, key) && !contextKeyMap.has(key)) {
+                    delete context[key];
+                }
+            }
+            // Reset LWR globals as needed.
+            // Note: we only need to reset serverData today, since it is the only
+            // property that mutates between page renders.
+            context.LWR = {
+                ...context.LWR,
+                serverData: undefined,
+            };
+        },
+        // Note: only used for testing
+        getContext: () => {
+            return context;
+        },
     };
 }
 async function createESMModuleLoader() {
@@ -113,7 +149,7 @@ function createContext(LWR, runtimeParams) {
         // browser api polyfills
         crypto,
         CustomEvent: Event,
-        // global api overrides
+        // global fetch api override
         fetch: fetchController.controlledFetch,
     };
     return {
@@ -122,9 +158,15 @@ function createContext(LWR, runtimeParams) {
             enableNoOpFetch: () => {
                 fetchController.activateNoOp();
             },
-            abortAllFetches: () => {
+            disableNoOpFetch: () => {
+                fetchController.deactivateNoOp();
+            },
+            enableFetchKillSwitch: () => {
                 fetchController.activateKillSwitch();
             },
+            disableFetchKillSwitch: () => {
+                fetchController.deactivateKillSwitch();
+            },
         },
     };
 }

package/build/es/renderer.d.ts

@@ -1,4 +1,7 @@
 import type { NormalizedLwrErrorRoute, NormalizedLwrRoute, ProviderAppConfig, PublicModuleBundler, PublicResourceRegistry, RuntimeEnvironment, RuntimeParams, ServerData, SsrDataResponse } from '@lwrjs/types';
+import { LRUCache } from 'lru-cache';
+import { TaskPool } from '@lwrjs/shared-utils';
+import { ModuleLoader } from './moduleLoader.js';
 export interface Component {
     specifier: string;
     props?: {
@@ -20,10 +23,18 @@ export interface RenderResults {
  * @returns singleton
  */
 export declare function getRenderer(config: ProviderAppConfig, bundleRegistry: PublicModuleBundler, resourceRegistry: PublicResourceRegistry): Renderer;
+interface BootstrapContext {
+    loader: Promise<ModuleLoader>;
+    bootstrapServiceEvaluationMap: Map<string, boolean>;
+}
 export declare class Renderer {
     config: ProviderAppConfig;
     bundleRegistry: PublicModuleBundler;
     resourceRegistry: PublicResourceRegistry;
+    contextPerEnv: LRUCache<string, BootstrapContext>;
+    cachedBootstrapContext: BootstrapContext | undefined;
+    pendingRender: Promise<RenderResults> | undefined;
+    pendingRenders: TaskPool;
     constructor(config: ProviderAppConfig, bundleRegistry: PublicModuleBundler, resourceRegistry: PublicResourceRegistry);
     /**
      * Render components to HTML strings
@@ -41,7 +52,9 @@ export declare class Renderer {
      * @param serverData - render data TODO serverData is modified (add test?)
      * @returns render results and errors per component
      */
-    render(components: Record<string, Component>, route: NormalizedLwrRoute | NormalizedLwrErrorRoute, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams, serverData?: ServerData): Promise<RenderResults>;
+    render(components: Record<string, Component>, route: NormalizedLwrRoute | NormalizedLwrErrorRoute, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams, serverData?: ServerData, isFirstOf2PassSSR?: boolean): Promise<RenderResults>;
     private renderComponents;
+    private getCachedBootstrapContext;
 }
+export {};
 //# sourceMappingURL=renderer.d.ts.map

package/build/es/renderer.js

@@ -1,5 +1,7 @@
+// TODO: investigate perf impact W-16056356
+import { LRUCache } from 'lru-cache';
 import { LwrUnresolvableError, createSingleDiagnosticError, descriptions, logger, stringifyError, } from '@lwrjs/diagnostics';
-import { moduleSpecifierToKebabCase } from '@lwrjs/shared-utils';
+import { buildEnvironmentContext, getCacheKeyFromJson, getSpecifier, isLambdaEnv, moduleSpecifierToKebabCase, getFeatureFlags, TaskPool, } from '@lwrjs/shared-utils';
 import { ViewSpan, getTracer } from '@lwrjs/instrumentation';
 import { getServerBootstrapServices, getRenderTimeout } from './utils.js';
 import { createModuleLoader } from './moduleLoader.js';
@@ -24,6 +26,19 @@ export class Renderer {
         this.config = config;
         this.bundleRegistry = bundleRegistry;
         this.resourceRegistry = resourceRegistry;
+        // Prevent number of cached contexts from growing unbounded.
+        // In reality, the number of env permutations should be relatively small
+        this.contextPerEnv = new LRUCache({
+            max: 50,
+            dispose: () => {
+                logger.info('evicted bootstrap context from renderer cache');
+            },
+        });
+        // TODO: remove the task pool altogether once W-16104831 and W-16047359 are 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;
+        this.pendingRenders = new TaskPool(taskPoolSize);
     }
     /**
      * Render components to HTML strings
@@ -41,46 +56,80 @@ export class Renderer {
      * @param serverData - render data TODO serverData is modified (add test?)
      * @returns render results and errors per component
      */
-    async render(components, route, runtimeEnvironment, runtimeParams, serverData = {}) {
-        let timerId;
-        const timeout = new Promise((_, reject) => {
-            timerId = setTimeout(() => {
-                reject(createSingleDiagnosticError({
-                    description: descriptions.UNRESOLVABLE.SSR_TIMEOUT(route.id, getRenderTimeout()),
-                }, LwrUnresolvableError));
-            }, getRenderTimeout());
-        });
-        const result = await Promise.race([
-            timeout,
-            // todo: abort the render if timeout occurs
-            this.renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData),
-        ]);
-        clearTimeout(timerId);
+    async render(components, route, runtimeEnvironment, runtimeParams, serverData = {}, isFirstOf2PassSSR) {
+        let result;
+        // Only use a timeout when running in a lambda environment or if we've manually specified a timeout (for local testing purposes)
+        if (isLambdaEnv() || process.env.SSR_TIMEOUT !== undefined) {
+            let timerId;
+            const timeout = new Promise((_, reject) => {
+                timerId = setTimeout(() => {
+                    reject(createSingleDiagnosticError({
+                        description: descriptions.UNRESOLVABLE.SSR_TIMEOUT(route.id, getRenderTimeout()),
+                    }, LwrUnresolvableError));
+                }, getRenderTimeout());
+            });
+            result = (await this.pendingRenders.execute(async () => {
+                return Promise.race([
+                    timeout,
+                    // todo: abort the render if timeout occurs
+                    this.renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData, isFirstOf2PassSSR),
+                ]);
+            }));
+            clearTimeout(timerId);
+        }
+        else {
+            result = (await this.pendingRenders.execute(async () => {
+                return this.renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData, isFirstOf2PassSSR);
+            }));
+        }
         return result;
     }
-    async renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData = {}) {
+    async renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData = {}, isFirstOf2PassSSR = false) {
         const results = {};
         const errors = {};
         const roots = Object.keys(components);
         const services = getServerBootstrapServices(route);
-        let loader;
+        // TODO: not needed once W-16104831 is resolved
+        const reevaluateModules = getFeatureFlags().REEVALUATE_MODULES === true;
+        const singleRenderMode = getFeatureFlags().SINGLE_RENDER_MODE;
+        let loader, loaderPromise, bootstrapServiceEvaluationMap;
         try {
-            loader = await createModuleLoader(this.config, this.resourceRegistry, this.bundleRegistry, runtimeEnvironment, runtimeParams, serverData);
+            // We want a new context (and cache it for re-use) for each LWR env context.
+            // 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);
+            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();
             // load and alias the LWC server engine
             // this MUST be done first in case bootstrap services depend on LWC
-            const engine = await loader.load('@lwc/engine-server', ['lwc']);
-            // bootstrap services MUST load/evaluate before any module resolution (except LWC)
-            // this ensures any loader `resolveHook` is registered first
-            const serviceModules = await Promise.all(services.map((specifier) => loader?.load(specifier)));
-            // set up the server-side Service API for the loader
-            const serverBootstrapServices = createServerBootstrapServices(loader);
-            // evaluate the default function from each service module, passing in the Service API
-            // this is where the loader and server data hooks are set
-            for (const service of serviceModules) {
-                // eslint-disable-next-line
-                const error = await evaluateServerBootstrapModule(service, serverBootstrapServices.serviceAPI);
-                if (error) {
-                    errors[service.specifier] = error;
+            const engineServerSpecifier = getSpecifier({
+                specifier: '@lwc/engine-server',
+                version: route.bootstrap.lwcVersion,
+            });
+            const engine = await loader.load(engineServerSpecifier, ['lwc']);
+            // By default, we only run bootstrap services once per page render.
+            const shouldRunBootstrapServices = !bootstrapServiceEvaluationMap?.has(route.id);
+            let serverBootstrapServices;
+            if (shouldRunBootstrapServices) {
+                bootstrapServiceEvaluationMap?.set(route.id, true);
+                // bootstrap services MUST load/evaluate before any module resolution (except LWC)
+                // this ensures any loader `resolveHook` is registered first
+                const serviceModules = await Promise.all(services.map((specifier) => loader?.load(specifier)));
+                // set up the server-side Service API for the loader
+                serverBootstrapServices = createServerBootstrapServices(loader);
+                // evaluate the default function from each service module, passing in the Service API
+                // this is where the loader and server data hooks are set
+                for (const service of serviceModules) {
+                    // eslint-disable-next-line
+                    const error = await evaluateServerBootstrapModule(service, serverBootstrapServices.serviceAPI);
+                    if (error) {
+                        errors[service.specifier] = error;
+                    }
                 }
             }
             // load root component modules (and dependencies ofc)
@@ -110,8 +159,10 @@ export class Renderer {
                     results[component.specifier] = data;
                 }
             }
-            // now that we have server data, run the server data hooks
-            serverBootstrapServices.evaluateServerDataHooks(serverData);
+            if (serverBootstrapServices) {
+                // now that we have server data, run the server data hooks
+                serverBootstrapServices.evaluateServerDataHooks(serverData);
+            }
             // exit early when preloading data
             if (!route.bootstrap.ssr) {
                 if (Object.keys(errors).length) {
@@ -119,8 +170,11 @@ export class Renderer {
                 }
                 return { results };
             }
-            // Disable async APIs before rendering components
-            loader.getContextController().enableNoOpFetch();
+            // TODO: W-16047359 - reactivate this outside of the Lambda
+            if (getFeatureFlags().SINGLE_RENDER_MODE) {
+                // Disable async APIs before rendering components
+                loader.getFetchController().enableNoOpFetch();
+            }
             // render components
             for (const component of componentModules) {
                 // skip rendering if an error has already occurred for the component
@@ -148,9 +202,62 @@ export class Renderer {
             };
         }
         finally {
-            // activate fetch controller kill switch
-            loader?.getContextController().abortAllFetches();
+            // TODO: W-16047359 - remove this check
+            if (singleRenderMode) {
+                loader?.getFetchController().disableNoOpFetch();
+                // activate fetch controller kill switch
+                loader?.getFetchController().enableFetchKillSwitch();
+            }
+            // At the end of 2-pass SSR, clean up for the next page render
+            if (!isFirstOf2PassSSR) {
+                // 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) {
+                    // clear bootstrap services so that next page render can call bootstrap services again
+                    bootstrapServiceEvaluationMap?.delete(route.id);
+                    loader?.clearRegistry();
+                }
+            }
+        }
+    }
+    getCachedBootstrapContext(route, runtimeEnvironment, runtimeParams, serverData, reevaluateModules) {
+        let loader, bootstrapServiceEvaluationMap;
+        // when `REEEVALUTE_MODULES` is true, we only have a single context/loader, regardless of the env
+        if (reevaluateModules) {
+            if (!this.cachedBootstrapContext) {
+                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.
+        const envContext = buildEnvironmentContext(runtimeParams);
+        const { host, requestDepth } = runtimeParams;
+        const contextCacheKey = getCacheKeyFromJson({ envContext, host, requestDepth });
+        const bootstrapContext = this.contextPerEnv.get(contextCacheKey);
+        if (!bootstrapContext) {
+            loader = createModuleLoader(this.config, this.resourceRegistry, this.bundleRegistry, runtimeEnvironment, runtimeParams, serverData, route.bootstrap);
+            bootstrapServiceEvaluationMap = new Map();
+            this.contextPerEnv.set(contextCacheKey, {
+                loader,
+                bootstrapServiceEvaluationMap,
+            });
+        }
+        else {
+            loader = bootstrapContext.loader;
+            bootstrapServiceEvaluationMap = bootstrapContext.bootstrapServiceEvaluationMap;
         }
+        return {
+            loader: loader,
+            bootstrapServiceEvaluationMap,
+        };
     }
 }
 /**

package/build/es/serverBootstrapServices.d.ts

@@ -1,9 +1,9 @@
 import type { ServerServiceAPI, ServerData } from '@lwrjs/types';
-import type { ModuleLoader } from './moduleLoader';
+import type { ModuleLoader } from './moduleLoader.js';
 export declare class ServerBootstrapServices {
     private serverDataCallbacks;
     _serviceAPI: ServerServiceAPI;
-    evaluateServerDataHooks(serverData: ServerData): void;
+    evaluateServerDataHooks(serverData?: ServerData): void;
     constructor(loader: ModuleLoader);
     get serviceAPI(): ServerServiceAPI;
     private registerServerDataCallbacks;

package/build/es/serverBootstrapServices.js

@@ -1,7 +1,7 @@
 import { ViewSpan, getTracer } from '@lwrjs/instrumentation';
 import { logger, stringifyError } from '@lwrjs/diagnostics';
 export class ServerBootstrapServices {
-    evaluateServerDataHooks(serverData) {
+    evaluateServerDataHooks(serverData = {}) {
         // now that we have server data, run the server data hooks
         for (const serverDataHook of this.serverDataCallbacks) {
             serverDataHook({ serverData });
@@ -11,8 +11,12 @@ export class ServerBootstrapServices {
         this.serverDataCallbacks = [];
         this._serviceAPI = {
             addServerDataCallback: this.registerServerDataCallbacks.bind(this),
-            // TODO: SSR loader hooks - throw when `loadModule` hook is used
-            addLoaderPlugin: loader.services?.addLoaderPlugin,
+            addLoaderPlugin: (hooks) => {
+                if (hooks.loadModule) {
+                    throw new Error('`loadModule` loader hook is not supported on the server.');
+                }
+                return loader.services.addLoaderPlugin(hooks);
+            },
         };
     }
     get serviceAPI() {

package/build/es/utils.d.ts

@@ -1,4 +1,4 @@
-import type { ClientBootstrapConfig, EnvironmentContext, LwrStringBuilder, NormalizedLwrErrorRoute, NormalizedLwrRoute, ProviderAppConfig, PublicResourceRegistry, RuntimeEnvironment, RuntimeParams, ServerData, SsrDataResponse } from '@lwrjs/types';
+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;
@@ -7,8 +7,8 @@ export declare const SSR_PROPS_ATTR = "data-lwr-props-id";
 export declare function getPropsId(): string;
 export declare function getRenderTimeout(): number;
 export declare function createSsrErrorMessage(specifier: string, e: any): string;
-export declare function getLoaderShim(resourceRegistry: PublicResourceRegistry, runtimeEnvironment: RuntimeEnvironment): Promise<string>;
-export declare function getLoaderId(config: ClientBootstrapConfig): string;
+export declare function getLoaderShim(resourceRegistry: PublicResourceRegistry, runtimeEnvironment: RuntimeEnvironment, bootstrapConfig: NormalizedLwrAppBootstrapConfig): Promise<string>;
+export declare function getLoaderId(config: ClientBootstrapConfig, bootstrapConfig: NormalizedLwrAppBootstrapConfig): string;
 export declare function getLoaderConfig(bootstrapModule: string, config: ProviderAppConfig, runtimeParams: RuntimeParams, serverData: ServerData): ClientBootstrapConfig & {
     env: ServerEnvironment;
 };
@@ -34,11 +34,13 @@ export declare class FetchController {
      * 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.

package/build/es/utils.js

@@ -1,7 +1,6 @@
-import { lwrVersion } from '@lwrjs/config/package';
 import { logger, stringifyError } from '@lwrjs/diagnostics';
 import { ViewSpan } from '@lwrjs/instrumentation';
-import { REQUEST_DEPTH_HEADER, buildEnvironmentContext, getFeatureFlags, normalizeVersionToUri, } from '@lwrjs/shared-utils';
+import { REQUEST_DEPTH_HEADER, 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() {
@@ -14,22 +13,39 @@ export function getRenderTimeout() {
 export function createSsrErrorMessage(specifier, e) {
     return `Server-side rendering for "${specifier}" failed. Falling back to client-side rendering. Reason: ${stringifyError(e)}`;
 }
-export async function getLoaderShim(resourceRegistry, runtimeEnvironment) {
+export async function getLoaderShim(resourceRegistry, runtimeEnvironment, bootstrapConfig) {
+    const { debug } = runtimeEnvironment;
+    // debug resources are not available in deployed lambda env
+    const useDebug = debug && !isLambdaEnv();
     const specifier = getFeatureFlags().LEGACY_LOADER
-        ? 'lwr-loader-shim-legacy.bundle.min.js'
-        : 'lwr-loader-shim.bundle.min.js';
-    const resource = await resourceRegistry.getResource({ specifier }, runtimeEnvironment);
-    if (!resource?.stream) {
+        ? useDebug
+            ? 'lwr-loader-shim-legacy.bundle.js'
+            : 'lwr-loader-shim-legacy.bundle.min.js'
+        : useDebug
+            ? 'lwr-loader-shim.bundle.js'
+            : 'lwr-loader-shim.bundle.min.js';
+    const resource = await resourceRegistry.getResource({ specifier, version: bootstrapConfig.lwrVersion }, runtimeEnvironment, 
+    // HACK: this code is tricky because resource IDs are different between prod vs debug ("lwr-loader-shim.bundle.min.js" vs "lwr-loader-shim.bundle.js").
+    // 1. In debug mode on Lambda (during SSR), we need to ignore runtimeEnvironment.debug because we will always ask for the prod version (lwr-loader-shim.bundle.min.js)
+    // 2. But when we generate the view, we can't ignore runtimeEnvironment.debug because we need the debug version of the loader shim (lwr-loader-shim.bundle.js)
+    { ignoreDebug: !useDebug });
+    if (!resource?.content && !resource?.stream) {
         throw new Error('Failed to find the loader shim');
     }
     let result = '';
-    for await (const chunk of resource.stream()) {
-        result += chunk;
+    if (resource.content) {
+        result = resource.content;
+    }
+    else {
+        const stream = resource.stream();
+        for await (const chunk of stream) {
+            result += chunk;
+        }
     }
     result += `\n//# sourceURL=${resource.entry}`;
     return result;
 }
-export function getLoaderId(config) {
+export function getLoaderId(config, bootstrapConfig) {
     // TODO W-15509657 - hack: checking `requiredModules` because the loader may not be the same version as the current runtime
     if (config.requiredModules) {
         const id = config.requiredModules.find((specifier) => specifier.startsWith('lwr/loader'));
@@ -38,7 +54,7 @@ export function getLoaderId(config) {
         }
     }
     // default to the active LWR version
-    const version = normalizeVersionToUri(lwrVersion);
+    const version = normalizeVersionToUri(bootstrapConfig.lwrVersion);
     return getFeatureFlags().LEGACY_LOADER ? `lwr/loaderLegacy/v/${version}` : `lwr/loader/v/${version}`;
 }
 export function getLoaderConfig(bootstrapModule, config, runtimeParams, serverData) {
@@ -101,7 +117,7 @@ export class FetchController {
             const fetchPromise = fetchFunction
                 .catch((error) => {
                 // Check if the error is an AbortError
-                if (this.killSwitchActivated) {
+                if (error && error?.stack.startsWith('AbortError')) {
                     return this.handleAbortError(request, error);
                 }
                 else {
@@ -124,6 +140,9 @@ export class FetchController {
             });
             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.
@@ -131,6 +150,9 @@ export class FetchController {
         this.activateNoOp = () => {
             this.noOpActivated = true;
         };
+        this.deactivateNoOp = () => {
+            this.noOpActivated = false;
+        };
         this.killSwitchActivated = false;
         this.noOpActivated = false;
         this.controllers = new Set();

package/build/es/viewProvider/index.js

@@ -32,10 +32,10 @@ export default class LwcViewProvider extends BaseViewProvider {
             filePath: specifier,
             viewId,
             properties: viewProperties,
-            render: async (runtimeParams) => {
+            render: async (runtimeParams, runtimeEnvironment) => {
                 // SSR the root component (without passing any public properties)
-                const { config, moduleBundler, resourceRegistry, runtimeEnvironment } = this;
-                const debug = runtimeParams.query?.debug !== undefined;
+                const { config, moduleBundler, resourceRegistry } = this;
+                const { debug } = runtimeEnvironment;
                 const element = moduleSpecifierToKebabCase(specifier);
                 return getTracer().trace({
                     name: ViewSpan.RenderPage,
@@ -45,7 +45,9 @@ export default class LwcViewProvider extends BaseViewProvider {
                     if (!route) {
                         throw new Error(`Unable to resolve configuration for view: ${viewId.id}`);
                     }
-                    const { results = {}, errors } = await getRenderer(config, moduleBundler, resourceRegistry).render({ [specifier]: { specifier, props: {} } }, route, runtimeEnvironment, Object(runtimeParams));
+                    const { results = {}, errors } = await getRenderer(config, moduleBundler, resourceRegistry).render({ [specifier]: { specifier, props: {} } }, route, runtimeEnvironment, Object(runtimeParams), undefined, 
+                    // lets the renderer know this is the first of 2-pass SSR
+                    true);
                     // Handle errors: fallback to CSR or throw
                     if (errors) {
                         const errorString = Object.values(errors).join(', ');

package/build/es/viewTransformer/index.js

@@ -57,7 +57,7 @@ export default function lwcSsrViewTransformer(options, { config, moduleBundler,
                 if (!route) {
                     throw new Error(`Unable to resolve configuration for view: ${viewContext.view.id}`);
                 }
-                const { results, errors } = await getRenderer(config, moduleBundler, resourceRegistry).render(ssrModules, route, viewContext.runtimeEnvironment, viewContext.runtimeParams, metadata.serverData);
+                const { results, errors } = await getRenderer(config, moduleBundler, resourceRegistry).render(ssrModules, route, viewContext.runtimeEnvironment, viewContext.runtimeParams, metadata.serverData, false);
                 for (const root in results) {
                     const { html, props, cache } = results[root];
                     const { tagName, startOffset, endOffset, hydrate } = ssrModules[root];
@@ -126,9 +126,7 @@ function handleErrors(errors, customElements, specifiers, debug, serverDebug) {
                 ? (ce.props = {
                     [HYDRATE_DIRECTIVE]: HYDRATE_CLIENT_VALUE,
                 })
-                : // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    // @ts-ignore - TS thinks that props may still be undefined
-                    (ce.props[HYDRATE_DIRECTIVE] = HYDRATE_CLIENT_VALUE);
+                : (ce.props[HYDRATE_DIRECTIVE] = HYDRATE_CLIENT_VALUE);
         }
         // Log error with stack details
         const errMessage = createSsrErrorMessage(specifier, err);

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.13.0-alpha.8",
+    "version": "0.13.0",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -33,7 +33,7 @@
     },
     "scripts": {
         "build": "tsc -b",
-        "clean": "rm -rf build node_modules",
+        "clean": "rimraf build node_modules",
         "test": "jest"
     },
     "files": [
@@ -42,15 +42,16 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/config": "0.13.0-alpha.8",
-        "@lwrjs/diagnostics": "0.13.0-alpha.8",
-        "@lwrjs/instrumentation": "0.13.0-alpha.8",
-        "@lwrjs/shared-utils": "0.13.0-alpha.8",
+        "@lwrjs/config": "0.13.0",
+        "@lwrjs/diagnostics": "0.13.0",
+        "@lwrjs/instrumentation": "0.13.0",
+        "@lwrjs/loader": "0.13.0",
+        "@lwrjs/shared-utils": "0.13.0",
         "fs-extra": "^11.2.0",
-        "lru-cache": "^10.2.0"
+        "lru-cache": "^10.4.3"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.13.0-alpha.8",
+        "@lwrjs/types": "0.13.0",
         "jest": "^26.6.3",
         "mock-fs": "^5.2.0",
         "ts-jest": "^26.5.6"
@@ -61,5 +62,5 @@
     "volta": {
         "extends": "../../../package.json"
     },
-    "gitHead": "91e731eae1457bbbebeb274fa0ea5574705c51a2"
+    "gitHead": "21dc6b8ffd2e633f36b46daf9e1563992c5143b9"
 }