@lwrjs/core 0.5.11-alpha.1 → 0.6.0-alpha.10

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

@@ -24,122 +24,15 @@ var __toModule = (module2) => {
 // packages/@lwrjs/core/src/tools/static-generation.ts
 __markAsModule(exports);
 __export(exports, {
+  ViewImportMetadataImpl: () => ViewImportMetadataImpl,
   default: () => static_generation_default
 });
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_path = __toModule(require("path"));
 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 SiteGenerator = class {
-  async dispatchResourceRecursive(url, dispatcher, resourceOpts, siteConfig) {
-    const {outputDir, visitedUrls} = siteConfig;
-    if (!visitedUrls.has(url)) {
-      visitedUrls.add(url);
-      if (url.indexOf("/:") !== -1) {
-        console.error("Skipped url with variable path segment: " + url);
-        return;
-      }
-      const context = await dispatcher.dispatchUrl(url, "GET", siteConfig.locale);
-      const {resourceType} = resourceOpts;
-      if (resourceType === "route") {
-        const dir = (0, import_dir.createResourceDir)(url, outputDir);
-        const localeDir = (0, import_dir.createResourceDir)(url, (0, import_path.join)(outputDir, siteConfig.locale));
-        const filePath = (0, import_path.join)(dir, "index.html");
-        const fileLocalePath = (0, import_path.join)(localeDir, "index.html");
-        if (siteConfig.locale.toLowerCase().startsWith("en")) {
-          await (0, import_stream.writeResponse)(context, filePath);
-        }
-        (0, import_dir.createDir)(localeDir);
-        await (0, import_stream.writeResponse)(context, fileLocalePath);
-        const viewDefinition = context.fs?.metadata?.viewDefinition;
-        if (viewDefinition) {
-          const assets = viewDefinition.viewRecord.assetReferences || [];
-          for (const asset of assets) {
-            const assetUrl = asset.override?.uri || asset.url;
-            if (assetUrl && !assetUrl.startsWith("data:")) {
-              await this.dispatchResourceRecursive(assetUrl, dispatcher, {resourceType: "asset", asset}, siteConfig);
-            }
-          }
-          const customElements = viewDefinition.viewRecord.customElements || [];
-          for (const customElement of customElements) {
-            const jsUris = Object.values(customElement.flatGraph.uriMap);
-            for (const jsUri of jsUris) {
-              await this.dispatchResourceRecursive(jsUri, dispatcher, {resourceType: "js"}, siteConfig);
-            }
-          }
-          if (viewDefinition.viewRecord.bootstrapModule) {
-            const boot = viewDefinition.viewRecord.bootstrapModule;
-            const jsUris = Object.values(boot.flatGraph.uriMap);
-            for (const jsUri of jsUris) {
-              await this.dispatchResourceRecursive(jsUri, dispatcher, {resourceType: "js"}, siteConfig);
-            }
-          }
-          const bootstrapResources = viewDefinition.viewRecord.bootstrapModule?.resources || [];
-          for (const resource of bootstrapResources) {
-            if (!resource.inline) {
-              const resourceUri = resource.src || resource.specifier;
-              if (resourceUri) {
-                await this.dispatchResourceRecursive(resourceUri, dispatcher, {resourceType: "resource"}, siteConfig);
-              } else {
-                console.warn("Skipped inline bootstrap resource: %j", resource);
-              }
-            }
-          }
-          const resources = viewDefinition.viewRecord.resources || [];
-          for (const resource of resources) {
-            const resourceUri = resource.src || resource.specifier || "";
-            if (resourceUri.startsWith("/")) {
-              await this.dispatchResourceRecursive(resourceUri, dispatcher, {resourceType: "resource"}, siteConfig);
-            } else {
-              console.warn("Skipped resource: %j", resource);
-            }
-          }
-        }
-      } else if (resourceType === "asset" || resourceType === "resource") {
-        const normalizedUrl = decodeURIComponent(url);
-        (0, import_dir.createResourceDir)((0, import_path.dirname)(normalizedUrl), outputDir);
-        const fullPath = (0, import_path.join)(outputDir, normalizedUrl);
-        await (0, import_stream.writeResponse)(context, fullPath);
-      } else if (resourceType === "js") {
-        const normalizedUrl = decodeURIComponent(url);
-        (0, import_dir.createResourceDir)((0, import_path.dirname)(normalizedUrl), outputDir);
-        const ext = (0, import_path.extname)(normalizedUrl);
-        const fullPath = (0, import_path.join)(outputDir, `${normalizedUrl}${ext ? "" : ".js"}`);
-        await (0, import_stream.writeResponse)(context, fullPath);
-        if (normalizedUrl.indexOf("/s/") !== -1) {
-          const rewriteUrl = normalizedUrl.substring(0, normalizedUrl.indexOf("/s/"));
-          siteConfig.urlRewriteMap.set(rewriteUrl, normalizedUrl);
-          siteConfig.urlRewriteMap.set(url.substring(0, url.indexOf("/s/")), 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;
-            if (jsUri.startsWith("/")) {
-              await this.dispatchResourceRecursive(jsUri, dispatcher, {resourceType: "js"}, siteConfig);
-            } else {
-              if (jsUri !== "lwc")
-                console.warn("Skipped import: " + jsUri);
-            }
-          }
-          const dynamicImports = moduleDefinition.linkedModuleRecord?.dynamicImports || moduleDefinition.bundleRecord?.dynamicImports || [];
-          for (const importModule of dynamicImports) {
-            const jsUri = importModule.specifier;
-            if (jsUri.startsWith("/")) {
-              await this.dispatchResourceRecursive(jsUri, dispatcher, {resourceType: "js"}, siteConfig);
-            } else {
-              console.warn("Skipped dynamic import: " + jsUri);
-            }
-          }
-        }
-        const uris = context.fs?.metadata.resolvedUris || [];
-        for (const jsUri of uris) {
-          await this.dispatchResourceRecursive(jsUri, dispatcher, {resourceType: "js"}, siteConfig);
-        }
-      }
-    }
-  }
   async buildStaticApplication(config, dispatcher) {
     console.log("[Static Generation] starting");
     const {routes, staticSiteGenerator, rootDir, assets} = config;
@@ -147,9 +40,11 @@ var SiteGenerator = class {
       staticSiteGenerator.outputDir = "__generated_site__";
     }
     const outputDir = (0, import_path.join)(rootDir, staticSiteGenerator.outputDir);
+    console.log(`[INFO] Clear Output Location: ${outputDir}`);
+    import_fs_extra.default.rmSync(outputDir, {recursive: true, force: true});
     const urlRewriteMap = new Map();
     await this.generateRoutes(staticSiteGenerator, routes, dispatcher, outputDir, urlRewriteMap);
-    this.writeUrlMappings(outputDir, urlRewriteMap);
+    this.writeNetlifyRedirectConfig(outputDir, urlRewriteMap);
     this.copyAssets(assets, outputDir);
     console.log("[Static Generation] complete");
   }
@@ -157,19 +52,203 @@ var SiteGenerator = class {
     if (!staticSiteGenerator.locales) {
       staticSiteGenerator.locales = ["en-US"];
     }
+    const dispatchRequests = [];
+    const generateUrl = this.createGenerateURLFunction(dispatcher);
     for (const locale of staticSiteGenerator.locales) {
-      const visitedUrls = new Set();
       for (const route of routes) {
-        await this.dispatchResourceRecursive(route.path, dispatcher, {resourceType: "route"}, {outputDir, visitedUrls, locale, urlRewriteMap});
+        const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap);
+        dispatchRequests.push(generateUrl(route.path, siteConfig));
       }
       if (staticSiteGenerator._additionalRoutePaths) {
         for (const uri of staticSiteGenerator._additionalRoutePaths) {
-          await this.dispatchResourceRecursive(uri, dispatcher, {resourceType: "route"}, {outputDir, visitedUrls, locale, urlRewriteMap});
+          const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap);
+          dispatchRequests.push(generateUrl(uri, siteConfig));
         }
       }
     }
+    await Promise.all(dispatchRequests);
+  }
+  createGenerateURLFunction(dispatcher) {
+    const generateRoute = async (uri, siteConfig) => {
+      const locale = siteConfig.locale;
+      console.log(`[INFO] Start Generate: ${locale} ${uri}`);
+      await this.dispatchResourceRecursive(uri, dispatcher, {resourceType: "route"}, siteConfig);
+      this.addAdditionalImportMetadataToViewConfig(siteConfig);
+      console.log(`[INFO] End Generate ${locale} ${uri}`);
+    };
+    return generateRoute.bind(this);
   }
-  writeUrlMappings(outputDir, urlRewriteMap) {
+  async dispatchResourceRecursive(url, dispatcher, resourceOpts, siteConfig) {
+    const {visitedUrls} = siteConfig;
+    if (!visitedUrls.has(url)) {
+      visitedUrls.add(url);
+      if (url.indexOf("/:") !== -1) {
+        console.error("Skipped url with variable path segment: " + url);
+        return;
+      }
+      const context = await dispatcher.dispatchUrl(url, "GET", siteConfig.locale);
+      const {resourceType} = resourceOpts;
+      if (resourceType === "route") {
+        await this.handleHtmlResource(url, context, siteConfig, dispatcher);
+      } else if (resourceType === "asset" || resourceType === "resource") {
+        await this.handleAssetOrResource(url, context, siteConfig);
+      } else if (resourceType == "mapping") {
+        await this.handleMappingResource(url, context, siteConfig, dispatcher);
+      } else if (resourceType === "js") {
+        await this.handleJavascriptResource(url, context, siteConfig, dispatcher);
+      }
+    }
+  }
+  async handleJavascriptResource(url, context, siteConfig, dispatcher) {
+    const {outputDir} = siteConfig;
+    const normalizedUrl = decodeURIComponent(url);
+    (0, import_dir.createResourceDir)((0, import_path.dirname)(normalizedUrl), outputDir);
+    const ext = (0, import_path.extname)(normalizedUrl);
+    const fullPath = (0, import_path.join)(outputDir, `${normalizedUrl}${ext ? "" : ".js"}`);
+    await (0, import_stream.writeResponse)(context, fullPath);
+    const dispatchRequests = [];
+    if (normalizedUrl.indexOf("/s/") !== -1) {
+      const rewriteUrl = normalizedUrl.substring(0, normalizedUrl.indexOf("/s/"));
+      siteConfig.urlRewriteMap.set(rewriteUrl, normalizedUrl);
+      siteConfig.urlRewriteMap.set(url.substring(0, url.indexOf("/s/")), normalizedUrl);
+    }
+    const moduleDefinition = context.fs?.metadata?.moduleDefinition;
+    if (moduleDefinition) {
+      const imports = moduleDefinition.linkedModuleRecord?.imports || moduleDefinition.bundleRecord?.imports || [];
+      for (const importModule of imports) {
+        const jsUri = (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 = (0, import_shared_utils.getSpecifier)(importModule);
+        dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+      }
+    }
+    const uris = context.fs?.metadata?.resolvedUris || [];
+    for (const jsUri of uris) {
+      dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+    }
+    await Promise.all(dispatchRequests);
+  }
+  async handleMappingResource(url, context, siteConfig, dispatcher) {
+    const {importMetadata: importMetatdata} = siteConfig;
+    const statusCode = context.response?.status;
+    if (statusCode === 200) {
+      const newImportMetadata = context.fs?.body;
+      if (!importMetatdata) {
+        console.warn("[WARN] Import metadata collector was never initialized");
+        return;
+      }
+      const filteredImportMetadata = importMetatdata.addAdditionalMetadata(newImportMetadata);
+      const dispatchRequests = [];
+      for (const uri of Object.keys(filteredImportMetadata.imports)) {
+        dispatchRequests.push(this.dispatchResourceRecursive(uri, dispatcher, {resourceType: "js"}, siteConfig));
+      }
+      await Promise.all(dispatchRequests);
+    } else {
+      const body = context.fs?.body;
+      console.warn(`[WARN] Failed to fetch ${url}: (${statusCode}) ${body}`);
+    }
+  }
+  async handleHtmlResource(url, context, siteConfig, dispatcher) {
+    const {outputDir} = siteConfig;
+    const dir = (0, import_dir.createResourceDir)(url, outputDir);
+    const localeDir = (0, import_dir.createResourceDir)(url, (0, import_path.join)(outputDir, siteConfig.locale));
+    const filePath = (0, import_path.join)(dir, "index.html");
+    const fileLocalePath = (0, import_path.join)(localeDir, "index.html");
+    if (siteConfig.locale.toLowerCase().startsWith("en")) {
+      await (0, import_stream.writeResponse)(context, filePath);
+    }
+    (0, import_dir.createDir)(localeDir);
+    await (0, import_stream.writeResponse)(context, fileLocalePath);
+    const viewDefinition = context.fs?.metadata?.viewDefinition;
+    if (viewDefinition) {
+      await this.handleViewDefinition(viewDefinition, siteConfig, dispatcher);
+    }
+  }
+  async handleViewDefinition(viewDefinition, siteConfig, dispatcher) {
+    siteConfig.endpoints = viewDefinition.viewRecord.endpoints;
+    if (viewDefinition.viewRecord.importMetadata) {
+      siteConfig.importMetadata = new ViewImportMetadataImpl(viewDefinition.viewRecord.importMetadata);
+    }
+    const dispatchRequests = [];
+    const assets = viewDefinition.viewRecord.assetReferences || [];
+    for (const asset of assets) {
+      const assetUrl = asset.override?.uri || asset.url;
+      if (assetUrl && !assetUrl.startsWith("data:")) {
+        dispatchRequests.push(this.dispatchResourceRecursive(assetUrl, dispatcher, {resourceType: "asset", asset}, siteConfig));
+      }
+    }
+    const customElements = viewDefinition.viewRecord.customElements || [];
+    for (const customElement of customElements) {
+      const jsUris = Object.values(customElement.flatGraph.uriMap);
+      for (const jsUri of jsUris) {
+        dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+      }
+    }
+    if (viewDefinition.viewRecord.bootstrapModule) {
+      const boot = viewDefinition.viewRecord.bootstrapModule;
+      const jsUris = Object.values(boot.flatGraph.uriMap);
+      for (const jsUri of jsUris) {
+        dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+      }
+    }
+    const bootstrapResources = viewDefinition.viewRecord.bootstrapModule?.resources || [];
+    for (const resource of bootstrapResources) {
+      if (!resource.inline) {
+        const resourceUri = resource.src || resource.specifier;
+        if (resourceUri) {
+          dispatchRequests.push(this.dispatchResourceRecursive(resourceUri, dispatcher, {resourceType: "resource"}, siteConfig));
+          if (resourceUri.match(/\/application\/.*\/ai\/.*\/configuration/)) {
+            siteConfig.viewConfigPath = this.getResourcePathFromUrl(siteConfig, resourceUri);
+          }
+        } else {
+          console.warn("Skipped inline bootstrap resource: %j", resource);
+        }
+      }
+    }
+    const resources = viewDefinition.viewRecord.resources || [];
+    for (const resource of resources) {
+      const resourceUri = resource.src || resource.specifier || "";
+      if (resourceUri.startsWith("/")) {
+        dispatchRequests.push(this.dispatchResourceRecursive(resourceUri, dispatcher, {resourceType: "resource"}, siteConfig));
+      } else {
+        console.warn("Skipped resource: %j", resource);
+      }
+    }
+    await Promise.all(dispatchRequests);
+  }
+  async dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig) {
+    if (jsUri.startsWith("/")) {
+      await this.dispatchResourceRecursive(jsUri, dispatcher, {resourceType: "js"}, siteConfig);
+    } else {
+      const supportsFingerprints = siteConfig.experimentalFeatures?.ENABLE_FINGERPRINTS;
+      if (supportsFingerprints) {
+        const mappingEndpoint = siteConfig.endpoints?.uris?.mapping;
+        if (mappingEndpoint) {
+          const mappingURL = siteConfig.endpoints?.uris?.mapping + encodeURIComponent(jsUri);
+          await this.dispatchResourceRecursive(mappingURL, dispatcher, {resourceType: "mapping"}, siteConfig);
+        } else {
+          console.warn('[WARN] Unable to fetch mapping for bare specifier or variable dynamic import: "' + jsUri + '"');
+        }
+      } else {
+        console.warn('[WARN] Unable to resolve bare specifier or variable dynamic import: "' + jsUri + '"');
+      }
+    }
+  }
+  async handleAssetOrResource(url, context, siteConfig) {
+    const fullPath = this.getResourcePathFromUrl(siteConfig, url);
+    await (0, import_stream.writeResponse)(context, fullPath);
+  }
+  getResourcePathFromUrl(siteConfig, url) {
+    const {outputDir} = siteConfig;
+    const normalizedUrl = decodeURIComponent(url);
+    (0, import_dir.createResourceDir)((0, import_path.dirname)(normalizedUrl), outputDir);
+    const fullPath = (0, import_path.join)(outputDir, normalizedUrl);
+    return fullPath;
+  }
+  writeNetlifyRedirectConfig(outputDir, urlRewriteMap) {
     const serveJsonPath = (0, import_path.join)(outputDir, "serve.json");
     const _redirectsPath = (0, import_path.join)(outputDir, "_redirects");
     if (import_fs_extra.default.existsSync(_redirectsPath)) {
@@ -202,5 +281,71 @@ var SiteGenerator = class {
       }
     }
   }
+  createSiteConfig(outputDir, locale, urlRewriteMap) {
+    const experimentalFeatures = this.filterExperimentalFeatures();
+    return {
+      outputDir,
+      visitedUrls: new Set(),
+      locale,
+      urlRewriteMap,
+      ...experimentalFeatures
+    };
+  }
+  filterExperimentalFeatures() {
+    if ((0, import_shared_utils.getExperimentalFeatures)().ENABLE_FINGERPRINTS) {
+      return {experimentalFeatures: {ENABLE_FINGERPRINTS: true}};
+    } else {
+      return void 0;
+    }
+  }
+  addAdditionalImportMetadataToViewConfig(siteConfig) {
+    const supportsFingerprints = siteConfig.experimentalFeatures?.ENABLE_FINGERPRINTS;
+    const additionalImportMetadata = siteConfig?.importMetadata?.getAdditionalImportMetadata();
+    if (supportsFingerprints && siteConfig.viewConfigPath && additionalImportMetadata?.imports && Object.keys(additionalImportMetadata.imports).length > 0) {
+      const imports = additionalImportMetadata.imports ? JSON.stringify(additionalImportMetadata.imports) : "{}";
+      const initImports = `if (!globalThis.LWR.imports) { globalThis.LWR.imports = {}; }`;
+      const mergeImports = `Object.assign(globalThis.LWR.imports, ${imports})`;
+      const index = additionalImportMetadata.index ? JSON.stringify(additionalImportMetadata.index) : "{}";
+      const initIndex = `if (!globalThis.LWR.index) { globalThis.LWR.index = {}; }`;
+      const mergeIndex = `Object.assign(globalThis.LWR.index, ${index})`;
+      import_fs_extra.default.appendFileSync(siteConfig.viewConfigPath, `
+// Appended by Static Site Generator
+${initImports}
+${mergeImports}
+${initIndex}
+${mergeIndex}
+`);
+    }
+  }
 };
 var static_generation_default = SiteGenerator;
+var ViewImportMetadataImpl = class {
+  constructor(existingImportMetadata, additionalImportMetadata) {
+    this.existing = existingImportMetadata;
+    this.additional = additionalImportMetadata || {imports: {}, index: {}};
+  }
+  getAdditionalImportMetadata() {
+    return this.additional;
+  }
+  addAdditionalMetadata(newMetadata) {
+    const filteredImports = this.filterMetadata(newMetadata);
+    this.mergeImportMetadata(this.additional, filteredImports);
+    return filteredImports;
+  }
+  filterMetadata(newMetadata) {
+    const importsArray = Object.entries(newMetadata.imports);
+    const filteredImports = importsArray.filter(([key]) => !this.existing.imports[key]);
+    const imports = Object.fromEntries(filteredImports);
+    const indexArray = Object.entries(newMetadata.index || {});
+    const filteredIndex = indexArray.filter(([key]) => !this.existing.index || !this.existing.index[key]);
+    const index = Object.fromEntries(filteredIndex);
+    return {
+      imports,
+      index
+    };
+  }
+  mergeImportMetadata(targetImportMetdadata, newImportMetadata) {
+    Object.assign(targetImportMetdadata.imports, newImportMetadata.imports);
+    Object.assign(targetImportMetdadata.index, newImportMetadata.index);
+  }
+};

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

@@ -28,9 +28,14 @@ __export(exports, {
 });
 var import_http = __toModule(require("http"));
 var import_https = __toModule(require("https"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var NetworkDispatcher = class {
   constructor(port, internalRequestKey) {
     this.port = port || 3e3;
+    const httpClient = this.port == 443 ? import_https.default : import_http.default;
+    this.pool = new httpClient.Agent({
+      maxSockets: 25
+    });
     this.internalRequestKey = internalRequestKey || "";
   }
   dispatchUrl(url, method, lang) {
@@ -39,6 +44,7 @@ var NetworkDispatcher = class {
       host: "localhost",
       port: this.port,
       path: url,
+      agent: this.pool,
       headers: {
         "Accept-Language": lang,
         "lwr-metadata-request": this.internalRequestKey
@@ -57,13 +63,27 @@ var NetworkDispatcher = class {
             const jsonResponse = JSON.parse(body);
             resolve(jsonResponse);
           } catch (e) {
-            console.error(`[NetworkDispatcher] unexpected response body: '${body}'`, e);
+            console.error(`[ERROR][NetworkDispatcher] unexpected response body: [${method}][${lang}] ${url}: '${body}'`);
+            if (e instanceof import_diagnostics.DiagnosticsError) {
+              console.log("LWR Diagnostic Error: ");
+              console.log(e.diagnostics);
+              console.log(e.stack);
+            } else {
+              console.error(e);
+            }
             resolve({});
           }
         });
       });
       req.on("error", (err) => {
-        console.error("Error occurred fetching metadata: " + err.message);
+        console.error(`[ERROR][NetworkDispatcher] Request: [${method}][${lang}] ${url}`);
+        if (err instanceof import_diagnostics.DiagnosticsError) {
+          console.log("LWR Diagnostic Error: ");
+          console.log(err.diagnostics);
+          console.log(err.stack);
+        } else {
+          console.error(err);
+        }
         reject(err);
       });
       req.end();

package/build/cjs/tools/utils/stream.cjs

@@ -24,6 +24,7 @@ var __toModule = (module2) => {
 // packages/@lwrjs/core/src/tools/utils/stream.ts
 __markAsModule(exports);
 __export(exports, {
+  isObject: () => isObject,
   writeResponse: () => writeResponse,
   writeStream: () => writeStream
 });
@@ -42,6 +43,13 @@ async function writeResponse(context, fullPath) {
     await writeStream(stream, fullPath);
   } else if (context.fs?.body) {
     const body = context.fs?.body;
-    import_fs.default.writeFileSync(fullPath, body, "utf-8");
+    if (isObject(body)) {
+      import_fs.default.writeFileSync(fullPath, JSON.stringify(body), "utf-8");
+    } else {
+      import_fs.default.writeFileSync(fullPath, body, "utf-8");
+    }
   }
 }
+function isObject(o) {
+  return typeof o === "object" && o !== null && !Array.isArray(o);
+}

package/build/cjs/validation/app-config-context.cjs

@@ -44,6 +44,7 @@ var ROOT_ATTRIBUTE_KEYS = createKeys("root", [
   "apiVersion",
   "assets",
   "assetProviders",
+  "assetTransformers",
   "bundleConfig",
   "cacheDir",
   "contentDir",
@@ -68,7 +69,8 @@ var ROOT_ATTRIBUTE_KEYS = createKeys("root", [
   "serverMode",
   "serverType",
   "templateEngine",
-  "viewProviders"
+  "viewProviders",
+  "viewTransformers"
 ]);
 var ASSET_DIR_ATTRIBUTE_KEYS = createKeys("assetDir", ["alias", "dir", "urlPath"]);
 var ASSET_FILE_ATTRIBUTE_KEYS = createKeys("assetFile", ["alias", "file", "urlPath"]);
@@ -101,7 +103,8 @@ var BOOTSTRAP_ATTRIBUTE_KEYS = createKeys("bootstrap", [
   "syntheticShadow",
   "workers",
   "services",
-  "configAsSrc"
+  "configAsSrc",
+  "experimentalSSR"
 ]);
 var SPECIFIER_REGEX = /^@?[\w-]+(\/[\w-]+)*$/;
 function isNotEmptyString(node) {

package/build/cjs/validation/app-config.cjs

@@ -42,6 +42,7 @@ function validateBootstrap(node, validationContext, propPrefix) {
     validationContext.assertValidKeys(node, "bootstrap", import_app_config_context.BOOTSTRAP_ATTRIBUTE_KEYS);
     validationContext.assertArrayOfSpecifiers((0, import_jsonc_parser.findNodeAtLocation)(node, ["services"]), `${propPrefix}.services`);
     validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["autoBoot"]), `${propPrefix}.autoBoot`);
+    validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["experimentalSSR"]), `${propPrefix}.experimentalSSR`);
     validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["configAsSrc"]), `${propPrefix}.configAsSrc`);
     validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["syntheticShadow"]), `${propPrefix}.syntheticShadow`);
     const workers = (0, import_jsonc_parser.findNodeAtLocation)(node, ["workers"]);

package/build/es/env-config.js

@@ -26,6 +26,7 @@ const DEFAULT_DATA_DIR = '$rootDir/src/data';
 // Providers
 const DEFAULT_MODULE_PROVIDERS = [
     '@lwrjs/app-service/moduleProvider',
+    '@lwrjs/lwc-ssr/moduleProvider',
     '@lwrjs/lwc-module-provider',
     '@lwrjs/npm-module-provider',
 ];
@@ -36,7 +37,9 @@ const DEFAULT_VIEW_PROVIDERS = [
     '@lwrjs/markdown-view-provider',
     '@lwrjs/base-view-provider',
 ];
+const DEFAULT_VIEW_TRANFORM_PLUGINS = ['@lwrjs/base-view-transformer', '@lwrjs/lwc-ssr/viewTransformer'];
 const DEFAULT_ASSET_PROVIDERS = ['@lwrjs/fs-asset-provider'];
+const DEFAULT_ASSET_TRANFORM_PLUGINS = ['@lwrjs/asset-transformer'];
 // Packages/modules
 const DEFAULT_TEMPLATE_ENGINE = '@lwrjs/base-template-engine';
 const DEFAULT_AMD_LOADER = 'lwr/loader';
@@ -47,9 +50,11 @@ const DEFAULT_LWR_MODULES = [
     { npm: getLWCEngineSpecifier() },
     { npm: '@lwrjs/client-modules' },
     { npm: '@lwrjs/loader' },
+    { npm: '@lwrjs/o11y' },
     { npm: '@lwrjs/router' },
     { npm: '@lwc/synthetic-shadow' },
 ];
+const DEFAULT_BUNDLE_EXCLUSIONS = ['lwc', '@lwc/synthetic-shadow', 'lwr/navigation', 'lwr/esmLoader'];
 // Default config objects
 const DEFAULT_LWR_CONFIG = {
     port: PORT,
@@ -60,6 +65,8 @@ const DEFAULT_LWR_CONFIG = {
     serverMode: MODE,
     apiVersion: DEFAULT_API_VERSION,
     assets: DEFAULT_ASSETS_DIR,
+    assetProviders: DEFAULT_ASSET_PROVIDERS,
+    assetTransformers: DEFAULT_ASSET_TRANFORM_PLUGINS,
     contentDir: DEFAULT_CONTENT_DIR,
     layoutsDir: DEFAULT_LAYOUTS_DIR,
     staticSiteGenerator: DEFAULT_GENERATOR_CONFIG,
@@ -69,12 +76,13 @@ const DEFAULT_LWR_CONFIG = {
     moduleProviders: DEFAULT_MODULE_PROVIDERS,
     resourceProviders: DEFAULT_RESOURCE_PROVIDERS,
     viewProviders: DEFAULT_VIEW_PROVIDERS,
+    viewTransformers: DEFAULT_VIEW_TRANFORM_PLUGINS,
     templateEngine: DEFAULT_TEMPLATE_ENGINE,
     environment: {},
     lwc: { modules: [] },
     routes: [],
     errorRoutes: [],
-    bundleConfig: {},
+    bundleConfig: { exclude: DEFAULT_BUNDLE_EXCLUSIONS },
     serverType: DEFAULT_SERVER_TYPE,
     locker: DEFAULT_LWR_LOCKER_CONFIG,
 };
@@ -192,6 +200,16 @@ function mergeLWCConfigs(config1, config2) {
             : undefined,
     };
 }
+// merge default bundle exclusions with any bundle exclusions specified in config
+function mergeBundleConfig(jsonConfig, config) {
+    const defaultExclusions = DEFAULT_BUNDLE_EXCLUSIONS;
+    const configExclusions = config?.bundleConfig?.exclude || jsonConfig?.bundleConfig?.exclude || [];
+    return {
+        ...jsonConfig?.bundleConfig,
+        ...config?.bundleConfig,
+        exclude: [...new Set([...defaultExclusions, ...configExclusions])],
+    };
+}
 // merge default locker trusted namespaces/cmps with any trusted namespaces/cmps specified in config
 function mergeLockerConfig(jsonConfig, config) {
     const defaultNamespaces = DEFAULT_LOCKER_TRUSTED_CMP;
@@ -222,6 +240,13 @@ function normalizeLwcConfig(config) {
             : undefined,
     };
 }
+function trimLwrConfig(config) {
+    Object.keys(config).forEach((k) => {
+        if (config[k] === undefined)
+            delete config[k];
+    });
+    return config;
+}
 /**
  * Merge and normalize all LWR configurations.
  *
@@ -233,7 +258,8 @@ function normalizeLwcConfig(config) {
  * @returns the merged and normalized LWR configuration
  */
 export function normalizeConfig(config) {
-    if (config) {
+    if (config !== undefined) {
+        config = trimLwrConfig(config);
         validateLwrAppConfig(JSON.stringify(config), 'pre');
     }
     // Merge all configurations together, and return
@@ -246,6 +272,7 @@ export function normalizeConfig(config) {
         ...lwrJsonConfig,
         ...config,
         lwc: normalizeLwcConfig(mergeLWCConfigs(lwrJsonConfig, config)),
+        bundleConfig: mergeBundleConfig(lwrJsonConfig, config),
         locker: mergeLockerConfig(lwrJsonConfig, config),
         rootDir,
     };
@@ -270,9 +297,11 @@ export function normalizeConfig(config) {
             interchangeableModulesMap: mergedLwrGlobalConfig.lwc.interchangeableModulesMap,
         },
         moduleProviders: normalizeServices(mergedLwrGlobalConfig.moduleProviders, rootDir),
-        assetProviders: normalizeServices(DEFAULT_ASSET_PROVIDERS, rootDir),
+        assetProviders: normalizeServices(mergedLwrGlobalConfig.assetProviders, rootDir),
+        assetTransformers: normalizeServices(mergedLwrGlobalConfig.assetTransformers, rootDir),
         resourceProviders: normalizeServices(mergedLwrGlobalConfig.resourceProviders, rootDir),
         viewProviders: normalizeServices(mergedLwrGlobalConfig.viewProviders, rootDir),
+        viewTransformers: normalizeServices(mergedLwrGlobalConfig.viewTransformers, rootDir),
         routes: normalizeRoutes(mergedLwrGlobalConfig.routes, { rootDir, assets, contentDir, layoutsDir }),
         errorRoutes: normalizeRoutes(mergedLwrGlobalConfig.errorRoutes, {
             rootDir,