@lwrjs/core 0.12.0-alpha.3 → 0.12.0-alpha.30

package/build/cjs/context/provider.cjs

@@ -26,7 +26,9 @@ __markAsModule(exports);
 __export(exports, {
   createProviderContext: () => createProviderContext
 });
+var import_fs = __toModule(require("fs"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_site_metadata = __toModule(require("@lwrjs/static/site-metadata"));
 function createProviderContext(serverContext) {
   const {
     assets,
@@ -43,7 +45,8 @@ function createProviderContext(serverContext) {
     esmLoader,
     environment,
     basePath,
-    bundleConfig
+    bundleConfig,
+    staticSiteGenerator
   } = serverContext.appConfig;
   const {onModuleDefinitionChange, onModuleSourceChange} = serverContext.appObserver;
   const {
@@ -52,6 +55,7 @@ function createProviderContext(serverContext) {
     notifyViewSourceChanged,
     notifyAssetSourceChanged
   } = serverContext.appEmitter;
+  const siteMetadata = staticSiteGenerator.outputDir && import_fs.default.existsSync(staticSiteGenerator.outputDir) ? new import_site_metadata.SiteMetadataImpl({rootDir: staticSiteGenerator.outputDir}) : void 0;
   return {
     appObserver: (0, import_shared_utils.deepFreeze)({onModuleDefinitionChange, onModuleSourceChange}),
     appEmitter: {
@@ -83,6 +87,7 @@ function createProviderContext(serverContext) {
       bundleConfig
     }),
     runtimeEnvironment: (0, import_shared_utils.deepFreeze)(serverContext.runtimeEnvironment),
-    watcherFactory: serverContext.watcherFactory
+    watcherFactory: serverContext.watcherFactory,
+    siteMetadata
   };
 }

package/build/cjs/index.cjs

@@ -70,10 +70,15 @@ async function initContext(appConfig, runtimeEnvironment, globalData) {
     const skipValidation = true;
     await (0, import_config.executeConfigHooks)(hooks, appConfig, runtimeEnvironment, globalData, skipValidation);
     (0, import_config.executeInstrumentationHooks)(hooks);
-    (0, import_config.executeStartHooks)(hooks, appConfig, runtimeEnvironment);
   }
   const services = await (0, import_modules.loadServices)(appConfig);
   const serverContext = (0, import_instrumentation.getTracer)().trace({name: import_instrumentation.CoreSpan.CreateServerContext}, () => (0, import_server2.createServerContext)(appConfig, runtimeEnvironment, globalData));
+  const routeHandlers = await (0, import_modules.loadRouteHandlers)(appConfig);
+  serverContext.routeHandlers = routeHandlers;
+  if (hooks.length) {
+    await (0, import_config.executeContextHooks)(hooks, serverContext);
+    (0, import_config.executeStartHooks)(hooks, appConfig, runtimeEnvironment);
+  }
   const providerContext = (0, import_provider.createProviderContext)(serverContext);
   const {moduleRegistry, assetRegistry, resourceRegistry, viewRegistry, moduleBundler} = serverContext;
   const moduleProviders = createServices(services.moduleProviders, providerContext);
@@ -94,29 +99,26 @@ async function initContext(appConfig, runtimeEnvironment, globalData) {
   viewRegistry.addViewProviders(viewProviders);
   viewRegistry.addViewTransformers(viewTransformers);
   await serverContext.viewRegistry.initializeViewProviders();
-  const routeHandlers = await (0, import_modules.loadRouteHandlers)(appConfig);
-  serverContext.routeHandlers = routeHandlers;
   return serverContext;
 }
 var LwrApp = class {
-  constructor(config = {}) {
+  constructor(configs) {
     this.initialized = false;
     const span = (0, import_instrumentation.getTracer)().startSpan({name: import_instrumentation.CoreSpan.CreateServer});
-    const {appConfig, runtimeEnvironment, globalData} = (0, import_config.loadConfig)(config);
+    const {appConfig, runtimeEnvironment, globalData} = configs;
     this.config = appConfig;
     this.runtimeEnvironment = runtimeEnvironment;
     this.globalData = globalData;
-    const {basePath} = this.config;
-    this.app = (0, import_server.createInternalServer)(this.config.serverType, {basePath});
+    const {basePath, serverType} = this.config;
+    this.serverType = serverType;
+    this.app = (0, import_server.createInternalServer)(serverType, {basePath});
     this.server = this.app.createHttpServer();
+    this.use = this.app.use.bind(this.app);
+    this.all = this.app.all.bind(this.app);
+    this.get = this.app.get.bind(this.app);
+    this.post = this.app.post.bind(this.app);
     span.end();
   }
-  setConfig(config) {
-    const {appConfig, runtimeEnvironment, globalData} = (0, import_config.loadConfig)(config);
-    this.config = appConfig;
-    this.runtimeEnvironment = runtimeEnvironment;
-    this.globalData = globalData;
-  }
   getConfig() {
     return this.config;
   }
@@ -168,24 +170,16 @@ var LwrApp = class {
       });
     });
   }
-  async close() {
-    this.server?.close && await this.server.close();
+  close() {
+    this.server?.close && this.server.close();
   }
   getInternalServer() {
     return this.app.getImpl();
   }
-  getServer() {
-    return {
-      use: this.app.use.bind(this.app),
-      all: this.app.all.bind(this.app),
-      get: this.app.get.bind(this.app),
-      post: this.app.post.bind(this.app),
-      getRegexWildcard: this.app.getRegexWildcard.bind(this.app)
-    };
-  }
 };
 function createServer(config) {
-  return new LwrApp(config);
+  const configs = (0, import_config.loadConfig)(config);
+  return new LwrApp(configs);
 }
 async function generateStaticSite(config) {
   config = config || {};

package/build/cjs/info/route-handler.cjs

@@ -0,0 +1,149 @@
+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/core/src/info/route-handler.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => siteInfoHandler
+});
+var import_config = __toModule(require("@lwrjs/config"));
+var import_fs = __toModule(require("fs"));
+var baseHtml = `<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
+        <title>Site Information</title>
+        <style>
+            body {
+                font-family: Arial, sans-serif;
+                margin: 0;
+                padding: 20px;
+                background-color: #f9f9f9;
+                color: #333;
+                display: flex;
+            }
+
+            .container {
+                max-width: 800px;
+                width: 100%;
+            }
+
+            h1, h2 {
+                color: #555;
+                margin-bottom: 16px;
+            }
+
+            ul {
+                list-style-type: none;
+                padding: 0;
+            }
+
+            li {
+                background-color: #fff;
+                border: 1px solid #ddd;
+                margin-bottom: 10px;
+                padding: 10px;
+                border-radius: 4px;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                display: flex;
+            }
+
+            .key {
+                margin-right: 10px;
+                color: #777;
+                font-weight: normal;
+                min-width: 200px;
+            }
+
+            .val {
+                font-weight: bold;
+                color: steelblue;
+                font-size: 1.1em;
+                flex-grow: 1;
+                text-align: left;
+            }
+
+            .data-container {
+                padding: 20px;
+                border: 1px solid #333;
+                border-radius: 5px;
+                white-space: pre;
+                font-family: monospace;
+                text-align: justify;
+              };
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>Site Information</h1>
+            <h2>Environment</h2>
+            {{ versionInfo }}
+            <h2>Metadata</h2>
+            {{ metadata }}
+        </div>
+    </body>
+</html>
+`;
+async function siteInfoHandler(_request, context) {
+  const versionInfo = {
+    "LWR Version": import_config.LWR_VERSION,
+    "LWC Version": import_config.LWC_VERSION,
+    "Node Version": import_config.NODE_VERSION,
+    "PWA Kit Runtime Version": import_config.PWA_KIT_RUNTIME_VERSION
+  };
+  let versionInfoString = "<ul>";
+  for (const key in versionInfo) {
+    if (versionInfo[key] !== "note-provided") {
+      versionInfoString += `<li><span class="key">${key}:</span><span class="val">${versionInfo[key]}</span></li>
+`;
+    }
+  }
+  versionInfoString += "</ul>";
+  const providedMetadataPath = `${context.rootDir}/site/.metadata/runtime-info.json`;
+  let providedMetadata = {};
+  if (import_fs.default.existsSync(providedMetadataPath)) {
+    providedMetadata = JSON.parse(import_fs.default.readFileSync(providedMetadataPath, "utf-8"));
+  }
+  let providedInfoString = "<ul>";
+  for (const key in providedMetadata) {
+    if (providedMetadata[key] !== "note-provided") {
+      const value = typeof providedMetadata[key] === "object" ? `<div class="data-container val">${JSON.stringify(providedMetadata[key], null, 2)}</div>` : `<span class="val">${providedMetadata[key]}</span>`;
+      providedInfoString += `<li><span class="key">${key}:</span>${value}</li>
+`;
+    }
+  }
+  providedInfoString += "</ul>";
+  let infoHtml = baseHtml;
+  infoHtml = infoHtml.replace("{{ versionInfo }}", versionInfoString);
+  infoHtml = infoHtml.replace("{{ metadata }}", providedInfoString);
+  return {
+    body: infoHtml,
+    headers: {
+      "content-type": `text/html; charset=utf-8`
+    },
+    cache: {
+      ttl: "200s"
+    }
+  };
+}

package/build/cjs/middleware/asset-middleware.cjs

@@ -31,6 +31,24 @@ var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_identity = __toModule(require("./utils/identity.cjs"));
 var import_error_handling = __toModule(require("./utils/error-handling.cjs"));
+var import_fs_extra = __toModule(require("fs-extra"));
+function assetMiddleware(app, context) {
+  const paths = context.appConfig.assets.map((config) => {
+    const assetDirConfig = config;
+    let urlPath = config.urlPath;
+    if (assetDirConfig.root) {
+      urlPath = "/:filename";
+    } else if (assetDirConfig.dir) {
+      urlPath += app.getRegexWildcard();
+    }
+    return urlPath;
+  });
+  app.get([
+    ...[...new Set(paths)],
+    "/:apiVersion/:assetType(asset|content-asset)/:immutable?/s/:signature/" + app.getRegexWildcard(),
+    "/:apiVersion/:assetType(asset|content-asset)/:immutable?/" + app.getRegexWildcard()
+  ], (0, import_error_handling.handleErrors)(createAssetMiddleware(context)));
+}
 function createAssetMiddleware(context) {
   const {
     assetRegistry,
@@ -43,23 +61,16 @@ function createAssetMiddleware(context) {
       assetId.specifier = import_path.default.join(basePath, assetId.specifier);
     }
     try {
+      let asset;
       const assetUri = await assetRegistry.resolveAssetUri(assetId, runtimeEnvironment);
       if (assetUri.external) {
-        res.set({
-          Location: assetUri.uri,
-          "cache-control": "public, max-age=60"
-        });
-        res.sendStatus(302);
-        return;
-      }
-      const asset = await (0, import_instrumentation.getTracer)().trace({
-        name: import_instrumentation.RequestHandlerSpan.GetAsset,
-        attributes: {
-          specifier: assetId.specifier
+        asset = await getAssetDefinition(assetId, req, assetRegistry, signature, runtimeEnvironment);
+        if (!import_fs_extra.default.existsSync(asset.entry) && assetUri.uri.startsWith("/mobify/bundle")) {
+          return sendRedirect(res, assetUri);
         }
-      }, () => {
-        return assetRegistry.getAsset({...assetId, signature}, runtimeEnvironment, req.isSiteGeneration());
-      });
+      } else {
+        asset = await getAssetDefinition(assetId, req, assetRegistry, signature, runtimeEnvironment);
+      }
       if (req.isSiteGeneration()) {
         res.setSiteGenerationMetadata({asset});
       }
@@ -81,20 +92,22 @@ function createAssetMiddleware(context) {
     }
   };
 }
-function assetMiddleware(app, context) {
-  const paths = context.appConfig.assets.map((config) => {
-    const assetDirConfig = config;
-    let urlPath = config.urlPath;
-    if (assetDirConfig.root) {
-      urlPath = "/:filename";
-    } else if (assetDirConfig.dir) {
-      urlPath += app.getRegexWildcard();
+async function getAssetDefinition(assetId, req, assetRegistry, signature, runtimeEnvironment) {
+  const asset = await (0, import_instrumentation.getTracer)().trace({
+    name: import_instrumentation.RequestHandlerSpan.GetAsset,
+    attributes: {
+      specifier: assetId.specifier,
+      url: req.originalUrl
     }
-    return urlPath;
+  }, () => {
+    return assetRegistry.getAsset({...assetId, signature}, runtimeEnvironment, req.isSiteGeneration());
   });
-  app.get([
-    ...[...new Set(paths)],
-    "/:apiVersion/:assetType(asset|content-asset)/:immutable?/s/:signature/" + app.getRegexWildcard(),
-    "/:apiVersion/:assetType(asset|content-asset)/:immutable?/" + app.getRegexWildcard()
-  ], (0, import_error_handling.handleErrors)(createAssetMiddleware(context)));
+  return asset;
+}
+function sendRedirect(res, assetUri) {
+  res.set({
+    Location: assetUri.uri,
+    "cache-control": "public, max-age=60"
+  });
+  res.sendStatus(302);
 }

package/build/cjs/middleware/bundle-middleware.cjs

@@ -53,6 +53,11 @@ function createBundleMiddleware(context) {
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_JSON().message);
       return;
     }
+    if (!req.validateApiVersion(appConfig)) {
+      res.status(400);
+      res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_API_VERSION(req.params.apiVersion, appConfig.apiVersion).message);
+      return;
+    }
     const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(defaultRuntimeEnvironment);
     const importer = req.query.importer ? await (0, import_request.getRequestImporter)(req, moduleRegistry, runtimeParams) : void 0;
     const {moduleId, signature} = (0, import_identity.getModuleIdentity)(req, importer);
@@ -64,7 +69,8 @@ function createBundleMiddleware(context) {
     const bundleDefinition = await (0, import_instrumentation.getTracer)().trace({
       name: import_instrumentation.RequestHandlerSpan.GetBundle,
       attributes: {
-        specifier: moduleId.specifier
+        specifier: moduleId.specifier,
+        url: req.originalUrl
       }
     }, () => {
       return moduleBundler.getModuleBundle(moduleId, {...runtimeEnvironment, bundle: true, sourceMapUrl}, runtimeParams);

package/build/cjs/middleware/mapping-middleware.cjs

@@ -47,7 +47,10 @@ function createMappingMiddleware(context) {
     const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(defaultRuntimeEnvironment);
     const {moduleIds} = (0, import_identity.getMappingIdentity)(req);
     const importMetadata = await (0, import_instrumentation.getTracer)().trace({
-      name: import_instrumentation.RequestHandlerSpan.GetMapping
+      name: import_instrumentation.RequestHandlerSpan.GetMapping,
+      attributes: {
+        url: req.originalUrl
+      }
     }, () => {
       return (0, import_shared_utils.getImportMetadataMappings)(moduleIds, runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler);
     });

package/build/cjs/middleware/module-middleware.cjs

@@ -47,6 +47,11 @@ function createModuleMiddleware(context) {
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_JSON().message);
       return;
     }
+    if (!req.validateApiVersion(appConfig)) {
+      res.status(400);
+      res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_API_VERSION(req.params.apiVersion, appConfig.apiVersion).message);
+      return;
+    }
     const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(defaultRuntimeEnvironment);
     const importer = req.query.importer ? await (0, import_request.getRequestImporter)(req, moduleRegistry, runtimeParams) : void 0;
     const {moduleId, signature} = (0, import_identity.getModuleIdentity)(req, importer);
@@ -57,7 +62,8 @@ function createModuleMiddleware(context) {
     const moduleDefinition = await (0, import_instrumentation.getTracer)().trace({
       name: import_instrumentation.RequestHandlerSpan.GetModule,
       attributes: {
-        specifier: moduleId.specifier
+        specifier: moduleId.specifier,
+        url: req.originalUrl
       }
     }, () => {
       return moduleRegistry.getLinkedModule(moduleId, {...runtimeEnvironment, bundle: false}, runtimeParams);

package/build/cjs/middleware/request-processor-middleware.cjs

@@ -27,14 +27,20 @@ __export(exports, {
   requestProcessorMiddleware: () => requestProcessorMiddleware
 });
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var MRT_REQUEST_CLASS = "X-Mobify-Request-Class";
 var MRT_REQUEST_CLASS_KEY = MRT_REQUEST_CLASS.toLowerCase();
 function requestProcessorMiddleware(app, context) {
   const {basePath} = context.runtimeEnvironment;
-  app.use(async (req, _res, next) => {
+  app.use(async (req, res, next) => {
     let requestClass;
+    let requestDepth;
     if (req.headers) {
       if (import_diagnostics.logger.isDebugEnabled()) {
+        import_diagnostics.logger.debug({
+          label: `request-processor-middleware`,
+          message: `Request: ${req.originalUrl}`
+        });
         for (const headerName in req.headers) {
           import_diagnostics.logger.debug({
             label: `request-processor-middleware`,
@@ -43,6 +49,14 @@ function requestProcessorMiddleware(app, context) {
         }
       }
       requestClass = req.headers[MRT_REQUEST_CLASS_KEY];
+      requestDepth = (0, import_shared_utils.parseRequestDepthHeader)(req.headers);
+    }
+    if (requestDepth && requestDepth > 0) {
+      import_diagnostics.logger.error({
+        label: "request-processor-middleware",
+        message: `Lambda SSR request cycle detected: ${req.originalUrl}`
+      });
+      return res.status(400).send("Request depth limit reached");
     }
     if (req.headers && typeof requestClass === "string") {
       const parsedRequestClass = parseRequestClass(requestClass);

package/build/cjs/middleware/utils/error-handling.cjs

@@ -35,7 +35,7 @@ function createReturnStatus(error, url) {
   if (error instanceof import_diagnostics.LwrUnresolvableError) {
     return {status: 404, message: error.message};
   }
-  return {status: 500, message: import_diagnostics.descriptions.UNRESOLVABLE.SERVER_ERROR(url).message};
+  return {status: 500, message: import_diagnostics.descriptions.SERVER.SERVER_ERROR(url).message};
 }
 function handleErrors(middleware) {
   return async (req, res, next) => {

package/build/cjs/middleware/utils/identity.cjs

@@ -75,7 +75,7 @@ function getResourceIdentity(req) {
 }
 function getAssetIdentity(req) {
   const {signature, immutable, assetType: type} = req.params;
-  const specifier = type ? "/" + req.params[0] : req.originalUrl.split("?")[0];
+  const specifier = type ? process.platform === "win32" ? req.params[0] : "/" + req.params[0] : req.originalUrl.split("?")[0];
   if (validateSpecifier(specifier) === false) {
     throw (0, import_diagnostics.createSingleDiagnosticError)({
       description: import_diagnostics.descriptions.UNRESOLVABLE.INVALID_SPECIFIER(specifier)

package/build/cjs/middleware/view-middleware.cjs

@@ -66,13 +66,19 @@ function createViewMiddleware(route, errorRoutes, context, viewHandler) {
     const resolve = req.isJsonRequest() ? viewHandler.getViewJson : viewHandler.getViewContent;
     let viewResponse;
     let resolvedRoute;
+    let traceId;
     try {
       viewResponse = await (0, import_instrumentation.getTracer)().trace({
         name: import_instrumentation.RequestHandlerSpan.GetView,
         attributes: {
-          view: route.id
+          view: route.id,
+          url: req.originalUrl,
+          host: runtimeParams.host,
+          basePath: runtimeParams.basePath,
+          locale: runtimeParams.locale
         }
-      }, () => {
+      }, (span) => {
+        traceId = span.traceId;
         return resolve.call(viewHandler, viewRequest, route, runtimeEnvironment, runtimeParams);
       });
       resolvedRoute = route;
@@ -105,6 +111,9 @@ function createViewMiddleware(route, errorRoutes, context, viewHandler) {
         res.setHeader("cache-control", `public, max-age=${cacheTtl}`);
       }
     }
+    if (traceId?.length) {
+      res.setHeader("x-trace-id", traceId);
+    }
     const status = resolvedRoute.status || viewResponse.status || 200;
     res.status(status);
     res.send(viewResponse.body);

package/build/cjs/tools/static-generation.cjs

@@ -36,6 +36,7 @@ var import_fs_extra = __toModule(require("fs-extra"));
 var import_stream = __toModule(require("./utils/stream.cjs"));
 var import_dir = __toModule(require("./utils/dir.cjs"));
 var import_config = __toModule(require("@lwrjs/config"));
+var import_url = __toModule(require("url"));
 var SiteGenerator = class {
   async buildStaticApplication(config, dispatcher) {
     const startTime = import_perf_hooks.performance.now();
@@ -161,6 +162,14 @@ var SiteGenerator = class {
   }
   async handleJavascriptResource(url, context, siteConfig, dispatcher) {
     const {outputDir} = siteConfig;
+    const moduleDefinition = context.fs?.metadata?.moduleDefinition;
+    const bundleConfig = moduleDefinition?.config || {};
+    const siteBundles = siteConfig?.siteMetadata?.getSiteBundles()?.bundles;
+    const specifier = moduleDefinition?.specifier;
+    if ((0, import_shared_utils.isExternalSpecifier)(specifier, bundleConfig)) {
+      this.handleExternalBundle(specifier, siteBundles, bundleConfig.external, outputDir);
+      return;
+    }
     const normalizedUrl = decodeURIComponent(url);
     (0, import_dir.createResourceDir)((0, import_path.dirname)(normalizedUrl), outputDir);
     const ext = (0, import_path.extname)(normalizedUrl);
@@ -173,17 +182,26 @@ var SiteGenerator = class {
       siteConfig.urlRewriteMap.set(normalizedUrl.substring(0, normalizedUrl.indexOf("/v/")), normalizedUrl);
       siteConfig.urlRewriteMap.set(url.substring(0, url.indexOf("%2Fv%2F")), normalizedUrl);
     }
-    const moduleDefinition = context.fs?.metadata?.moduleDefinition;
     if (moduleDefinition) {
       const imports = moduleDefinition.linkedModuleRecord?.imports || moduleDefinition.bundleRecord?.imports || [];
       for (const importModule of imports) {
-        const jsUri = importModule.specifier.startsWith("/") ? importModule.specifier : (0, import_shared_utils.getSpecifier)(importModule);
-        dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+        const importSpecifier = importModule.specifier;
+        if ((0, import_shared_utils.isExternalSpecifier)(importSpecifier, bundleConfig)) {
+          this.handleExternalBundle(importSpecifier, siteBundles, bundleConfig.external, outputDir);
+        } else {
+          const jsUri = importSpecifier.startsWith("/") ? importSpecifier : (0, import_shared_utils.getSpecifier)(importModule);
+          dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+        }
       }
       const dynamicImports = moduleDefinition.linkedModuleRecord?.dynamicImports || moduleDefinition.bundleRecord?.dynamicImports || [];
       for (const importModule of dynamicImports) {
-        const jsUri = importModule.specifier.startsWith("/") ? importModule.specifier : (0, import_shared_utils.getSpecifier)(importModule);
-        dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+        const importSpecifier = importModule.specifier;
+        if ((0, import_shared_utils.isExternalSpecifier)(importSpecifier, bundleConfig)) {
+          this.handleExternalBundle(importSpecifier, siteBundles, bundleConfig.external, outputDir);
+        } else {
+          const jsUri = importSpecifier.startsWith("/") ? importSpecifier : (0, import_shared_utils.getSpecifier)(importModule);
+          dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+        }
       }
       if (moduleDefinition.bundleRecord) {
         this.addBundleToSiteMetadata(moduleDefinition, url, siteConfig);
@@ -195,14 +213,31 @@ var SiteGenerator = class {
     }
     await Promise.all(dispatchRequests);
   }
+  handleExternalBundle(specifier, siteBundles, externals, outputDir) {
+    if (siteBundles && externals[specifier]?.startsWith(import_shared_utils.PROTOCOL_FILE) && !siteBundles[specifier]) {
+      const path = (0, import_shared_utils.normalizeFromFileURL)(externals[specifier], process.cwd());
+      const normalizedPath = decodeURIComponent(path);
+      (0, import_dir.createResourceDir)((0, import_path.dirname)(normalizedPath), outputDir);
+      const ext = (0, import_path.extname)(normalizedPath);
+      const fullPath = (0, import_path.join)(outputDir, `${normalizedPath}${ext ? "" : ".js"}`);
+      import_fs_extra.default.copyFileSync((0, import_url.fileURLToPath)(externals[specifier]), fullPath);
+      const bundleMetadata = {
+        specifier,
+        path: normalizedPath,
+        imports: []
+      };
+      siteBundles[specifier] = bundleMetadata;
+    }
+  }
   addBundleToSiteMetadata(bundleDefinition, url, siteConfig) {
     if (siteConfig.siteMetadata) {
       const locale = siteConfig.locale;
       const specifier = siteConfig.i18n.defaultLocale === locale ? bundleDefinition.specifier : `${bundleDefinition.specifier}|l/${locale}`;
       const imports = bundleDefinition.bundleRecord.imports?.map((moduleRef) => (0, import_shared_utils.getSpecifier)(moduleRef)) || [];
       const dynamicImports = bundleDefinition.bundleRecord.dynamicImports?.map((moduleRef) => (0, import_shared_utils.getSpecifier)(moduleRef));
+      const version = bundleDefinition.version === import_shared_utils.VERSION_NOT_PROVIDED ? void 0 : bundleDefinition.version;
       const bundleMetadata = {
-        version: bundleDefinition.version,
+        version,
         path: decodeURIComponent(url),
         includedModules: bundleDefinition.bundleRecord.includedModules || [],
         imports,

package/build/cjs/tools/utils/network-dispatcher.cjs

@@ -79,16 +79,17 @@ var NetworkDispatcher = class {
               const jsonResponse = JSON.parse(body);
               resolve(jsonResponse);
             } catch (err) {
+              const message = process.env.MRT_HMR !== "true" ? `unexpected response body: [${method}][${lang}] ${url}: '${body}'` : `unexpected response body: [${method}][${lang}] ${url}`;
               if (import_diagnostics.logger.isDebugEnabled()) {
                 import_diagnostics.logger.warn({
                   label: `NetworkDispatcher`,
-                  message: `unexpected response body: [${method}][${lang}] ${url}: '${body}'`,
+                  message,
                   additionalInfo: err
                 });
               } else {
                 import_diagnostics.logger.warn({
                   label: `NetworkDispatcher`,
-                  message: `unexpected response body: [${method}][${lang}] ${url}: '${body}'`
+                  message
                 });
               }
               resolve({});

package/build/es/context/provider.js

@@ -1,9 +1,14 @@
+import fs from 'fs';
 import { deepFreeze } from '@lwrjs/shared-utils';
+import { SiteMetadataImpl } from '@lwrjs/static/site-metadata';
 export function createProviderContext(serverContext) {
     // This is a subset of config to user-land code
-    const { assets, cacheDir, i18n, lwc: { modules = [] }, routes, errorRoutes, rootDir, contentDir, layoutsDir, locker, amdLoader, esmLoader, environment, basePath, bundleConfig, } = serverContext.appConfig;
+    const { assets, cacheDir, i18n, lwc: { modules = [] }, routes, errorRoutes, rootDir, contentDir, layoutsDir, locker, amdLoader, esmLoader, environment, basePath, bundleConfig, staticSiteGenerator, } = serverContext.appConfig;
     const { onModuleDefinitionChange, onModuleSourceChange } = serverContext.appObserver;
     const { notifyModuleDefinitionChanged, notifyModuleSourceChanged, notifyViewSourceChanged, notifyAssetSourceChanged, } = serverContext.appEmitter;
+    const siteMetadata = staticSiteGenerator.outputDir && fs.existsSync(staticSiteGenerator.outputDir)
+        ? new SiteMetadataImpl({ rootDir: staticSiteGenerator.outputDir })
+        : undefined;
     return {
         appObserver: deepFreeze({ onModuleDefinitionChange, onModuleSourceChange }),
         appEmitter: {
@@ -36,6 +41,7 @@ export function createProviderContext(serverContext) {
         }),
         runtimeEnvironment: deepFreeze(serverContext.runtimeEnvironment),
         watcherFactory: serverContext.watcherFactory,
+        siteMetadata,
     };
 }
 //# sourceMappingURL=provider.js.map