@lwrjs/config 0.10.0-alpha.2 → 0.10.0-alpha.20

package/build/cjs/defaults.cjs

@@ -24,8 +24,10 @@ var __toModule = (module2) => {
 // packages/@lwrjs/config/src/defaults.ts
 __markAsModule(exports);
 __export(exports, {
+  DEFAULT_AMD_BUNDLE_EXCLUSIONS: () => DEFAULT_AMD_BUNDLE_EXCLUSIONS,
   DEFAULT_AMD_LOADER: () => DEFAULT_AMD_LOADER,
   DEFAULT_AMD_LOADER_LEGACY: () => DEFAULT_AMD_LOADER_LEGACY,
+  DEFAULT_ESM_BUNDLE_EXCLUSIONS: () => DEFAULT_ESM_BUNDLE_EXCLUSIONS,
   DEFAULT_ESM_LOADER: () => DEFAULT_ESM_LOADER,
   DEFAULT_GENERATOR_CONFIG: () => DEFAULT_GENERATOR_CONFIG,
   DEFAULT_LWR_CONFIG: () => DEFAULT_LWR_CONFIG,
@@ -84,6 +86,7 @@ var DEFAULT_VIEW_TRANSFORM_PLUGINS = ["@lwrjs/base-view-transformer"];
 var SSR_VIEW_TRANSFORM_PLUGIN = "@lwrjs/lwc-ssr/viewTransformer";
 var DEFAULT_ASSET_PROVIDERS = ["@lwrjs/fs-asset-provider"];
 var DEFAULT_ASSET_TRANSFORM_PLUGINS = ["@lwrjs/asset-transformer"];
+var DEFAULT_URI_TRANSFORM_PLUGINS = [];
 var DEFAULT_AMD_LOADER = "lwr/loader";
 var DEFAULT_AMD_LOADER_LEGACY = "lwr/loaderLegacy";
 var DEFAULT_ESM_LOADER = "lwr/esmLoader";
@@ -101,7 +104,8 @@ var DEFAULT_ESM_BUNDLE_EXCLUSIONS = [
   "@lwc/synthetic-shadow",
   "lwr/navigation",
   "lwr/esmLoader",
-  "lwr/profiler"
+  "lwr/profiler",
+  "@salesforce/lds-default-luvio"
 ];
 var DEFAULT_AMD_BUNDLE_EXCLUSIONS = ["lwc", "lwr/navigation"];
 var DEFAULT_ESM_BUNDLE_EXTERNALS = {};
@@ -152,5 +156,6 @@ var DEFAULT_LWR_CONFIG = {
   routeHandlers: {},
   bundleConfig: getDefaultBundleConfig(MODE),
   serverType: DEFAULT_SERVER_TYPE,
-  locker: import_shared_utils.DEFAULT_LWR_LOCKER_CONFIG
+  locker: import_shared_utils.DEFAULT_LWR_LOCKER_CONFIG,
+  uriTransformers: DEFAULT_URI_TRANSFORM_PLUGINS
 };

package/build/cjs/global-config.cjs

@@ -44,6 +44,7 @@ var import_merge = __toModule(require("./utils/merge.cjs"));
 var import_lwc = __toModule(require("./utils/lwc.cjs"));
 var import_runtime_config = __toModule(require("./runtime-config.cjs"));
 var import_global_data = __toModule(require("./utils/global-data.cjs"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 function getLwrConfigFromFile(rootDir, lwrConfigPath = import_defaults2.DEFAULT_LWR_CONFIG_JSON) {
   const resolvedLwrConfigPath = import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(lwrConfigPath, rootDir));
   if (!import_fs.default.existsSync(resolvedLwrConfigPath)) {
@@ -93,10 +94,12 @@ function normalizeConfig(config) {
     assetProviders: (0, import_services.normalizeServices)(config.assetProviders),
     assetTransformers: (0, import_services.normalizeServices)(config.assetTransformers),
     resourceProviders: (0, import_services.normalizeServices)(config.resourceProviders),
+    uriTransformers: (0, import_services.normalizeServices)(config.uriTransformers),
     viewProviders: (0, import_services.normalizeServices)(config.viewProviders),
     viewTransformers: (0, import_services.normalizeServices)(config.viewTransformers),
     routes: (0, import_routes.normalizeRoutes)(config.routes, config.routeHandlers),
-    errorRoutes: (0, import_routes.normalizeRoutes)(config.errorRoutes, config.routeHandlers)
+    errorRoutes: (0, import_routes.normalizeRoutes)(config.errorRoutes, config.routeHandlers),
+    routeHandlers: (0, import_routes.normalizeRouteHandlers)(config.routeHandlers)
   };
 }
 function normalizeConfigPaths(config) {
@@ -122,6 +125,7 @@ function normalizeConfigPaths(config) {
     assetProviders: (0, import_services.normalizeServicePaths)(config.assetProviders, rootDir),
     assetTransformers: (0, import_services.normalizeServicePaths)(config.assetTransformers, rootDir),
     resourceProviders: (0, import_services.normalizeServicePaths)(config.resourceProviders, rootDir),
+    uriTransformers: (0, import_services.normalizeServicePaths)(config.uriTransformers, rootDir),
     viewProviders: (0, import_services.normalizeServicePaths)(config.viewProviders, rootDir),
     viewTransformers: (0, import_services.normalizeServicePaths)(config.viewTransformers, rootDir),
     routes: (0, import_routes.normalizeRoutePaths)(config.routes, resourcePaths),
@@ -145,17 +149,19 @@ function applySsrConfig(config) {
 function applyStaticProviderConfig(config) {
   return {
     ...config,
-    resourceProviders: [["@lwrjs/lambda/mrt-static-resource-provider", {}]],
-    moduleProviders: [["@lwrjs/lambda/mrt-static-module-provider", void 0]],
-    assetProviders: [["@lwrjs/lambda/mrt-static-asset-provider", void 0]],
+    assetProviders: [["@lwrjs/static/asset-provider", void 0]],
+    assetTransformers: [],
+    resourceProviders: [["@lwrjs/static/resource-provider", {}]],
+    moduleProviders: [["@lwrjs/static/module-provider", void 0]],
     bundleProviders: [
-      ["@lwrjs/lambda/mrt-static-bundle-provider", void 0],
+      ["@lwrjs/static/bundle-provider", void 0],
       ["@lwrjs/module-bundler/amd-runtime-bundle-provider", void 0]
     ],
-    assetTransformers: []
+    uriTransformers: [["@lwrjs/lambda/mrt-static-uri-transformer", void 0]]
   };
 }
 function resolveGlobalConfig(configArg, options) {
+  const span = (0, import_instrumentation.getTracer)().startSpan({name: import_instrumentation.ConfigSpan.ResolveConfig});
   const mergedConfig = mergeConfig(configArg);
   let normalizedConfig = normalizeConfig(mergedConfig);
   if (options?.useStaticProviders) {
@@ -166,20 +172,26 @@ function resolveGlobalConfig(configArg, options) {
     createCacheFolder(normalizedConfig.cacheDir, normalizedConfig.rootDir);
   }
   if (options?.skipDirNormalization) {
+    span.end();
     return normalizedConfig;
   }
-  return normalizeConfigPaths(normalizedConfig);
+  const retVal = normalizeConfigPaths(normalizedConfig);
+  span.end();
+  return retVal;
 }
 function loadConfig(config, options) {
+  const span = (0, import_instrumentation.getTracer)().startSpan({name: import_instrumentation.ConfigSpan.LoadConfig});
   const appConfig = resolveGlobalConfig(config, options);
   const runtimeEnvironment = (0, import_runtime_config.getRuntimeEnvironment)(appConfig);
   const globalData = (0, import_global_data.getGlobalData)(appConfig.globalDataDir, appConfig.globalData);
   if (!appConfig.hooks.length) {
     (0, import_app_config.validateLwrAppConfig)(appConfig, "post");
   }
-  return {
+  const retVal = {
     appConfig,
     runtimeEnvironment,
     globalData
   };
+  span.end();
+  return retVal;
 }

package/build/cjs/hooks.cjs

@@ -25,13 +25,17 @@ var __toModule = (module2) => {
 __markAsModule(exports);
 __export(exports, {
   executeConfigHooks: () => executeConfigHooks,
+  executeInstrumentationHooks: () => executeInstrumentationHooks,
   executeStartHooks: () => executeStartHooks
 });
 var import_routes = __toModule(require("./utils/routes.cjs"));
 var import_app_config = __toModule(require("./validation/app-config.cjs"));
 var import_global_config = __toModule(require("./global-config.cjs"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 async function executeConfigHooks(hooks, globalConfig, runtimeEnvironment, globalData, skipValidate = false) {
+  const span = (0, import_instrumentation.getTracer)().startSpan({name: import_instrumentation.ConfigSpan.ExecuteConfigHooks});
   if (!hooks.length) {
+    span.end();
     return;
   }
   for (const hook of hooks) {
@@ -48,9 +52,12 @@ async function executeConfigHooks(hooks, globalConfig, runtimeEnvironment, globa
   if (!skipValidate) {
     (0, import_app_config.validateLwrAppConfig)(globalConfig, "post");
   }
+  span.end();
 }
 function executeStartHooks(hooks, globalConfig, skipValidate = false) {
+  const span = (0, import_instrumentation.getTracer)().startSpan({name: import_instrumentation.ConfigSpan.ExecuteStartHooks});
   if (!hooks.length) {
+    span.end();
     return;
   }
   for (const hook of hooks) {
@@ -66,4 +73,18 @@ function executeStartHooks(hooks, globalConfig, skipValidate = false) {
   if (!skipValidate) {
     (0, import_app_config.validateLwrAppConfig)(globalConfig, "post");
   }
+  span.end();
+}
+function executeInstrumentationHooks(hooks) {
+  const span = (0, import_instrumentation.getTracer)().startSpan({name: import_instrumentation.ConfigSpan.ExecuteInstrHooks});
+  let retVal = false;
+  for (const hook of hooks) {
+    if (!hook.initInstrumentation) {
+      continue;
+    }
+    retVal = true;
+    hook.initInstrumentation();
+  }
+  span.end();
+  return retVal;
 }

package/build/cjs/index.cjs

@@ -27,6 +27,7 @@ __export(exports, {
   LWC_VERSION: () => import_package.lwcVersion,
   LWR_VERSION: () => import_package.version,
   executeConfigHooks: () => import_hooks.executeConfigHooks,
+  executeInstrumentationHooks: () => import_hooks.executeInstrumentationHooks,
   executeStartHooks: () => import_hooks.executeStartHooks,
   getLwrConfigFromFile: () => import_global_config.getLwrConfigFromFile,
   getRuntimeEnvironment: () => import_runtime_config.getRuntimeEnvironment,

package/build/cjs/modules.cjs

@@ -69,6 +69,7 @@ async function loadServices(config) {
   const assetProviders = await loadServiceEntries(config.assetProviders, config.rootDir, config.cacheDir);
   const assetTransformers = await loadServiceEntries(config.assetTransformers, config.rootDir, config.cacheDir);
   const resourceProviders = await loadServiceEntries(config.resourceProviders, config.rootDir, config.cacheDir);
+  const uriTransformers = await loadServiceEntries(config.uriTransformers, config.rootDir, config.cacheDir);
   const viewProviders = await loadServiceEntries(config.viewProviders, config.rootDir, config.cacheDir);
   const viewTransformers = await loadServiceEntries(config.viewTransformers, config.rootDir, config.cacheDir);
   return {
@@ -77,6 +78,7 @@ async function loadServices(config) {
     assetProviders,
     assetTransformers,
     resourceProviders,
+    uriTransformers,
     viewProviders,
     viewTransformers
   };
@@ -84,9 +86,9 @@ async function loadServices(config) {
 async function loadRouteHandlers(config) {
   const routeHandlers = {};
   await Promise.all(Object.keys(config.routeHandlers).map(async (id) => {
-    const handlerPath = config.routeHandlers[id];
+    const [handlerPath, handlerOptions] = config.routeHandlers[id];
     const handler = await importModule(handlerPath, config.rootDir, import_path.default.join(config.cacheDir, "routeHandlers"));
-    routeHandlers[id] = handler;
+    routeHandlers[id] = [handler, handlerOptions];
   }));
   return routeHandlers;
 }

package/build/cjs/utils/assets.cjs

@@ -42,10 +42,12 @@ function normalizeAssets(assets) {
 }
 function normalizeAssetPaths(assets, rootDir) {
   return assets.map((asset) => {
-    const assetDir = asset.dir;
+    const assetDirConfig = asset;
+    const assetDir = assetDirConfig.dir;
     if (assetDir) {
       return {
         ...asset,
+        urlPath: assetDirConfig.root ? "/" : asset.urlPath,
         dir: assetDir && (0, import_shared_utils.normalizeDirectory)(assetDir, rootDir)
       };
     }

package/build/cjs/utils/routes.cjs

@@ -25,16 +25,28 @@ var __toModule = (module2) => {
 __markAsModule(exports);
 __export(exports, {
   normalizeRouteHandlerPaths: () => normalizeRouteHandlerPaths,
+  normalizeRouteHandlers: () => normalizeRouteHandlers,
   normalizeRoutePaths: () => normalizeRoutePaths,
   normalizeRoutes: () => normalizeRoutes
 });
+var import_fs = __toModule(require("fs"));
 var import_path = __toModule(require("path"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 function normalizeRoutes(routes, routeHandlers) {
   return routes.map((route) => {
-    if (route.routeHandler && !routeHandlers[route.routeHandler]) {
-      const handlerPath = route.routeHandler;
-      routeHandlers[handlerPath] = handlerPath;
+    if (route.routeHandler) {
+      const [handler, options] = typeof route.routeHandler === "string" ? [route.routeHandler, void 0] : route.routeHandler;
+      if (!routeHandlers[handler]) {
+        routeHandlers[handler] = [handler, options];
+      }
+      return {
+        ...route,
+        routeHandler: [handler, options],
+        bootstrap: {
+          ...import_shared_utils.DEFAULT_LWR_BOOTSTRAP_CONFIG,
+          ...route.bootstrap
+        }
+      };
     }
     return {
       ...route,
@@ -60,9 +72,20 @@ function normalizeRoutePaths(routes = [], resourcePaths) {
     return route;
   });
 }
+function normalizeRouteHandlers(routeHandlers) {
+  for (const [id, config] of Object.entries(routeHandlers)) {
+    if (typeof config === "string") {
+      routeHandlers[id] = [config, void 0];
+    }
+  }
+  return routeHandlers;
+}
 function normalizeRouteHandlerPaths(routeHandlers, resourcePaths) {
-  for (const [id, handlerPath] of Object.entries(routeHandlers)) {
-    routeHandlers[id] = import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(handlerPath, resourcePaths.rootDir));
+  for (const [id, [handler, options]] of Object.entries(routeHandlers)) {
+    const normalizedPath = import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(handler, resourcePaths.rootDir));
+    if (import_fs.default.existsSync(normalizedPath)) {
+      routeHandlers[id] = [normalizedPath, options];
+    }
   }
   return routeHandlers;
 }

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

@@ -73,10 +73,11 @@ var ROOT_ATTRIBUTE_KEYS = createKeys("root", [
   "serverMode",
   "minify",
   "serverType",
+  "uriTransformers",
   "viewProviders",
   "viewTransformers"
 ]);
-var ASSET_DIR_ATTRIBUTE_KEYS = createKeys("assetDir", ["alias", "dir", "urlPath"]);
+var ASSET_DIR_ATTRIBUTE_KEYS = createKeys("assetDir", ["alias", "dir", "urlPath", "root"]);
 var ASSET_FILE_ATTRIBUTE_KEYS = createKeys("assetFile", ["alias", "file", "urlPath"]);
 var LOCKER_ATTRIBUTE_KEYS = createKeys("locker", ["enabled", "trustedComponents", "clientOnly"]);
 var ROUTE_ATTRIBUTE_KEYS = createKeys("routes", [
@@ -348,19 +349,23 @@ var ValidationContext = class {
         location: this.getLocationFromNode(node)
       });
     } else if (node.children && node.children.length > 0) {
-      node.children.forEach((n, index) => {
-        if (n.type !== "string" && n.type !== "array") {
-          this.diagnostics.push({
-            description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(`${property}[${index}]`, "string or array", n.type),
-            location: this.getLocationFromNode(n)
-          });
-        }
-        if (n.type === "string" && n.value.length === 0 || n.type === "array" && n.children && (n.children.length !== 2 || !isNotEmptyString(n.children[0]))) {
-          this.diagnostics.push({
-            description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_SERVICE(`${property}[${index}]`, n.value === void 0 && n.children ? `invalid Array[${n.children.length}]` : n.value),
-            location: this.getLocationFromNode(n)
-          });
-        }
+      node.children.forEach((n, index) => this.assertIsService(n, property, index));
+    }
+  }
+  assertIsService(node, property, index) {
+    if (!node) {
+      return;
+    }
+    if (node.type !== "string" && node.type !== "array") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(index !== void 0 ? `${property}[${index}]` : property, "string or array", node.type),
+        location: this.getLocationFromNode(node)
+      });
+    }
+    if (node.type === "string" && node.value.length === 0 || node.type === "array" && node.children && (node.children.length !== 2 || !isNotEmptyString(node.children[0]))) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_SERVICE(index !== void 0 ? `${property}[${index}]` : property, node.value === void 0 && node.children ? `invalid Array[${node.children.length}]` : node.value),
+        location: this.getLocationFromNode(node)
       });
     }
   }
@@ -377,6 +382,28 @@ var ValidationContext = class {
       });
     }
   }
+  assertClientLockerSSR(routesNode, lockerNode) {
+    if (routesNode && lockerNode) {
+      const enabled = (0, import_jsonc_parser.findNodeAtLocation)(lockerNode, ["enabled"]);
+      const clientOnly = (0, import_jsonc_parser.findNodeAtLocation)(lockerNode, ["clientOnly"]);
+      const compileTimeLocker = enabled && enabled.value === true && (!clientOnly || clientOnly.value === false);
+      if (compileTimeLocker && routesNode.children) {
+        const hasSSR = routesNode.children.some((n) => {
+          const bootstrap = (0, import_jsonc_parser.findNodeAtLocation)(n, ["bootstrap"]);
+          if (bootstrap) {
+            const ssr = (0, import_jsonc_parser.findNodeAtLocation)(bootstrap, ["ssr"]);
+            return ssr?.value === true;
+          }
+        });
+        if (hasSSR) {
+          this.diagnostics.push({
+            description: import_diagnostics.descriptions.CONFIG_PARSER.COMPILE_LOCKER_SSR(),
+            location: this.getLocationFromNode(lockerNode)
+          });
+        }
+      }
+    }
+  }
   assertRequiredKeys(node, property, requiredPropertyKeys) {
     const missingProps = requiredPropertyKeys.filter((p) => (0, import_jsonc_parser.findNodeAtLocation)(node, [p]) === void 0);
     if (missingProps.length > 0) {
@@ -409,4 +436,12 @@ var ValidationContext = class {
       }
     }
   }
+  assertNoBundleConfigDupes(node, dupes) {
+    if (dupes.length) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.DUPLICATE_BUNDLE_CONFIG(dupes),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
 };

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

@@ -31,6 +31,8 @@ var import_jsonc_parser = __toModule(require("jsonc-parser"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_app_config_context = __toModule(require("./app-config-context.cjs"));
 var import_helpers = __toModule(require("./helpers.cjs"));
+var import_defaults = __toModule(require("../defaults.cjs"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var SOURCE_BY_PHASE = {
   file: "lwr.config.json",
   pre: "argument passed to createServer",
@@ -67,7 +69,7 @@ function validateRouteCommon(node, validationContext, propPrefix) {
   validationContext.assertIsSpecifier((0, import_jsonc_parser.findNodeAtLocation)(node, ["rootComponent"]), `${propPrefix}.rootComponent`);
   validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["contentTemplate"]), `${propPrefix}.contentTemplate`);
   validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["layoutTemplate"]), `${propPrefix}.layoutTemplate`);
-  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["routeHandler"]), `${propPrefix}.routeHandler`);
+  validationContext.assertIsService((0, import_jsonc_parser.findNodeAtLocation)(node, ["routeHandler"]), `${propPrefix}.routeHandler`);
   validateBootstrap((0, import_jsonc_parser.findNodeAtLocation)(node, ["bootstrap"]), validationContext, `${propPrefix}.bootstrap`);
 }
 function validateRoutes(node, validationContext, preMerge) {
@@ -88,6 +90,50 @@ function validateRoutes(node, validationContext, preMerge) {
     }
   }
 }
+function validateBundleConfig(node, validationContext) {
+  if (node) {
+    validationContext.assertIsObject(node, "bundleConfig");
+    const dupeMap = new Map();
+    const dupes = new Set();
+    const excludeNode = (0, import_jsonc_parser.findNodeAtLocation)(node, ["exclude"]);
+    validationContext.assertArrayOfSpecifiers(excludeNode, "bundleConfig.exclude");
+    excludeNode?.children?.forEach((n) => {
+      dupeMap.set(n.value, true);
+    });
+    const external = (0, import_jsonc_parser.findNodeAtLocation)(node, ["external"]);
+    if (external) {
+      external?.children?.forEach((n) => {
+        const specifier = (n?.children && n.children[0])?.value;
+        if (specifier && dupeMap.has(specifier)) {
+          dupes.add(specifier);
+        } else {
+          dupeMap.set(specifier, true);
+        }
+      });
+    }
+    const groups = (0, import_jsonc_parser.findNodeAtLocation)(node, ["groups"]);
+    if (groups) {
+      validationContext.assertIsObject(groups, "bundleConfig.groups");
+      groups?.children?.forEach((n) => {
+        const groupKey = n?.children && n.children[0];
+        const group = n?.children && n.children[1];
+        if (group && groupKey) {
+          validationContext.assertNotEmptyArray(group, `bundleConfig.groups.${groupKey.value}`);
+          validationContext.assertArrayOfSpecifiers(group, `bundleConfig.groups.${groupKey.value}`);
+          const groupies = group?.children;
+          groupies?.forEach((n2) => {
+            if (dupeMap.has(n2.value)) {
+              dupes.add(n2.value);
+            }
+          });
+        }
+      });
+    }
+    const defaultExcludes = new Set([...import_defaults.DEFAULT_AMD_BUNDLE_EXCLUSIONS, ...import_defaults.DEFAULT_ESM_BUNDLE_EXCLUSIONS]);
+    const dupesFiltered = Array.from(dupes).filter((specifier) => !defaultExcludes.has(specifier));
+    validationContext.assertNoBundleConfigDupes(node, dupesFiltered);
+  }
+}
 function validateErrorRoutes(node, validationContext) {
   if (node) {
     validationContext.assertIsArray(node, "errorRoutes");
@@ -116,20 +162,27 @@ function validateAssets(node, validationContext, preMerge) {
       validationContext.assertNotEmptyArray(node, "assets");
       if (node.children) {
         node.children.forEach((n, index) => {
+          const rootDirNode = (0, import_jsonc_parser.findNodeAtLocation)(n, ["root"]);
           const dirNode = (0, import_jsonc_parser.findNodeAtLocation)(n, ["dir"]);
           const fileNode = (0, import_jsonc_parser.findNodeAtLocation)(n, ["file"]);
-          if (dirNode?.type === "string") {
+          if (rootDirNode?.type === "boolean") {
+            validationContext.assertIsObject(n, "assetDir");
+            validationContext.assertValidKeys(n, "assetDir", import_app_config_context.ASSET_DIR_ATTRIBUTE_KEYS);
+          } else if (dirNode?.type === "string") {
             validationContext.assertIsObject(n, "assetDir");
             validationContext.assertValidKeys(n, "assetDir", import_app_config_context.ASSET_DIR_ATTRIBUTE_KEYS);
+            validationContext.assertRequiredKeys(n, `assets[${index}]`, ["urlPath"]);
+            validationContext.assertIsPath((0, import_jsonc_parser.findNodeAtLocation)(n, ["urlPath"]), `assets[${index}].urlPath`);
           } else if (fileNode?.type === "string") {
             validationContext.assertIsObject(n, "assetFile");
             validationContext.assertValidKeys(n, "assetFile", import_app_config_context.ASSET_FILE_ATTRIBUTE_KEYS);
+            validationContext.assertRequiredKeys(n, `assets[${index}]`, ["urlPath"]);
+            validationContext.assertIsPath((0, import_jsonc_parser.findNodeAtLocation)(n, ["urlPath"]), `assets[${index}].urlPath`);
           }
-          validationContext.assertRequiredKeys(n, `assets[${index}]`, ["urlPath"]);
           validationContext.assertHasOnlyOne(n, `assets[${index}]`, ["dir", "file"]);
           validationContext.assertNotEmptyString(dirNode, `assets[${index}].dir`);
           validationContext.assertNotEmptyString(fileNode, `assets[${index}].file`);
-          validationContext.assertIsPath((0, import_jsonc_parser.findNodeAtLocation)(n, ["urlPath"]), `assets[${index}].urlPath`);
+          validationContext.assertIsBoolean(rootDirNode, `assets[${index}].root`);
           validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(n, ["alias"]), `assets[${index}].alias`);
         });
       }
@@ -152,11 +205,15 @@ function validateRoot(node, validationContext, preMerge) {
   const routes = (0, import_jsonc_parser.findNodeAtLocation)(node, ["routes"]);
   const errorRoutes = (0, import_jsonc_parser.findNodeAtLocation)(node, ["errorRoutes"]);
   validationContext.assertUniqueIds([...routes?.children || [], ...errorRoutes?.children || []], "routes");
+  const lockerNode = (0, import_jsonc_parser.findNodeAtLocation)(node, ["locker"]);
+  const bundleConfigNode = (0, import_jsonc_parser.findNodeAtLocation)(node, ["bundleConfig"]);
   validateRoutes(routes, validationContext, preMerge);
   validateErrorRoutes(errorRoutes, validationContext);
   validateRouteHandlers((0, import_jsonc_parser.findNodeAtLocation)(node, ["routeHandlers"]), validationContext);
   validateAssets((0, import_jsonc_parser.findNodeAtLocation)(node, ["assets"]), validationContext, preMerge);
-  validateLocker((0, import_jsonc_parser.findNodeAtLocation)(node, ["locker"]), validationContext);
+  validateLocker(lockerNode, validationContext);
+  validateBundleConfig(bundleConfigNode, validationContext);
+  validationContext.assertClientLockerSSR(routes, lockerNode);
   validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["apiVersion"]), "apiVersion");
   validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["lwrVersion"]), "lwrVersion");
   validationContext.assertIsSpecifier((0, import_jsonc_parser.findNodeAtLocation)(node, ["amdLoader"]), "amdLoader");
@@ -181,6 +238,7 @@ function validateRoot(node, validationContext, preMerge) {
   validationContext.assertIsBasePath((0, import_jsonc_parser.findNodeAtLocation)(node, ["basePath"]), "basePath");
 }
 function validateLwrAppConfig(config, phase) {
+  const span = (0, import_instrumentation.getTracer)().startSpan({name: import_instrumentation.ConfigSpan.ValidateConfig});
   try {
     const jsonSourceText = typeof config === "string" ? config : JSON.stringify(config);
     const errors = [];
@@ -200,8 +258,10 @@ function validateLwrAppConfig(config, phase) {
     if (validationContext.diagnostics.length) {
       throw new import_diagnostics.LwrConfigValidationError(`Configuration validation errors in ${SOURCE_BY_PHASE[phase]}`, validationContext.diagnostics);
     }
+    span.end();
     return;
   } catch (err) {
+    span.end();
     if (process.env.UNSAFE_IGNORE_CONFIG_VALIDATION === "true") {
       console.warn("ignoring config validation errors due to UNSAFE_IGNORE_CONFIG_VALIDATION flag...proceed with caution");
       console.dir(err, {depth: null});

package/build/es/defaults.d.ts

@@ -19,6 +19,8 @@ export declare const DEFAULT_SERVICE_PACKAGE_NAME: RegExp;
 export declare const DEFAULT_LWR_MODULES: {
     npm: string;
 }[];
+export declare const DEFAULT_ESM_BUNDLE_EXCLUSIONS: string[];
+export declare const DEFAULT_AMD_BUNDLE_EXCLUSIONS: string[];
 export declare function getDefaultBundleConfig(mode?: string): BundleConfig;
 export declare const DEFAULT_LWR_CONFIG: Required<LwrGlobalConfig>;
 //# sourceMappingURL=defaults.d.ts.map

package/build/es/defaults.js

@@ -46,6 +46,7 @@ const DEFAULT_VIEW_TRANSFORM_PLUGINS = ['@lwrjs/base-view-transformer'];
 export const SSR_VIEW_TRANSFORM_PLUGIN = '@lwrjs/lwc-ssr/viewTransformer';
 const DEFAULT_ASSET_PROVIDERS = ['@lwrjs/fs-asset-provider'];
 const DEFAULT_ASSET_TRANSFORM_PLUGINS = ['@lwrjs/asset-transformer'];
+const DEFAULT_URI_TRANSFORM_PLUGINS = [];
 export const DEFAULT_AMD_LOADER = 'lwr/loader';
 export const DEFAULT_AMD_LOADER_LEGACY = 'lwr/loaderLegacy';
 export const DEFAULT_ESM_LOADER = 'lwr/esmLoader';
@@ -58,14 +59,15 @@ export const DEFAULT_LWR_MODULES = [
     { npm: '@lwrjs/router' },
     { npm: '@lwc/synthetic-shadow' },
 ];
-const DEFAULT_ESM_BUNDLE_EXCLUSIONS = [
+export const DEFAULT_ESM_BUNDLE_EXCLUSIONS = [
     'lwc',
     '@lwc/synthetic-shadow',
     'lwr/navigation',
     'lwr/esmLoader',
     'lwr/profiler',
+    '@salesforce/lds-default-luvio',
 ];
-const DEFAULT_AMD_BUNDLE_EXCLUSIONS = ['lwc', 'lwr/navigation'];
+export const DEFAULT_AMD_BUNDLE_EXCLUSIONS = ['lwc', 'lwr/navigation'];
 const DEFAULT_ESM_BUNDLE_EXTERNALS = {};
 const DEFAULT_AMD_BUNDLE_EXTERNALS = {
     'lwr/loader': 'lwr-loader-shim.bundle.min.js',
@@ -119,5 +121,6 @@ export const DEFAULT_LWR_CONFIG = {
     bundleConfig: getDefaultBundleConfig(MODE),
     serverType: DEFAULT_SERVER_TYPE,
     locker: DEFAULT_LWR_LOCKER_CONFIG,
+    uriTransformers: DEFAULT_URI_TRANSFORM_PLUGINS,
 };
 //# sourceMappingURL=defaults.js.map

package/build/es/global-config.js

@@ -7,11 +7,12 @@ import { DEFAULT_AMD_LOADER, DEFAULT_AMD_LOADER_LEGACY, DEFAULT_ESM_LOADER, DEFA
 import { validateLwrAppConfig } from './validation/app-config.js';
 import { normalizeAssetPaths, normalizeAssets } from './utils/assets.js';
 import { normalizeServicePaths, normalizeServices } from './utils/services.js';
-import { normalizeRouteHandlerPaths, normalizeRoutePaths, normalizeRoutes } from './utils/routes.js';
+import { normalizeRoutePaths, normalizeRoutes, normalizeRouteHandlers, normalizeRouteHandlerPaths, } from './utils/routes.js';
 import { mergeBundleConfig, mergeLockerConfig, mergeLwcConfig, mergeStaticGenerationConfig, trimLwrConfig, } from './utils/merge.js';
 import { normalizeLwcConfig, normalizeModulePaths } from './utils/lwc.js';
 import { getRuntimeEnvironment } from './runtime-config.js';
 import { getGlobalData } from './utils/global-data.js';
+import { getTracer, ConfigSpan } from '@lwrjs/instrumentation';
 /**
  * Load and validate the global config file.
  *
@@ -118,11 +119,13 @@ function normalizeConfig(config) {
         assetProviders: normalizeServices(config.assetProviders),
         assetTransformers: normalizeServices(config.assetTransformers),
         resourceProviders: normalizeServices(config.resourceProviders),
+        uriTransformers: normalizeServices(config.uriTransformers),
         viewProviders: normalizeServices(config.viewProviders),
         viewTransformers: normalizeServices(config.viewTransformers),
         // normalize routes and capture all route handlers
         routes: normalizeRoutes(config.routes, config.routeHandlers),
         errorRoutes: normalizeRoutes(config.errorRoutes, config.routeHandlers),
+        routeHandlers: normalizeRouteHandlers(config.routeHandlers),
     };
 }
 /**
@@ -159,6 +162,7 @@ function normalizeConfigPaths(config) {
         assetProviders: normalizeServicePaths(config.assetProviders, rootDir),
         assetTransformers: normalizeServicePaths(config.assetTransformers, rootDir),
         resourceProviders: normalizeServicePaths(config.resourceProviders, rootDir),
+        uriTransformers: normalizeServicePaths(config.uriTransformers, rootDir),
         viewProviders: normalizeServicePaths(config.viewProviders, rootDir),
         viewTransformers: normalizeServicePaths(config.viewTransformers, rootDir),
         // normalize all route paths
@@ -203,14 +207,15 @@ export function applySsrConfig(config) {
 export function applyStaticProviderConfig(config) {
     return {
         ...config,
-        resourceProviders: [['@lwrjs/lambda/mrt-static-resource-provider', {}]],
-        moduleProviders: [['@lwrjs/lambda/mrt-static-module-provider', undefined]],
-        assetProviders: [['@lwrjs/lambda/mrt-static-asset-provider', undefined]],
+        assetProviders: [['@lwrjs/static/asset-provider', undefined]],
+        assetTransformers: [],
+        resourceProviders: [['@lwrjs/static/resource-provider', {}]],
+        moduleProviders: [['@lwrjs/static/module-provider', undefined]],
         bundleProviders: [
-            ['@lwrjs/lambda/mrt-static-bundle-provider', undefined],
+            ['@lwrjs/static/bundle-provider', undefined],
             ['@lwrjs/module-bundler/amd-runtime-bundle-provider', undefined],
         ],
-        assetTransformers: [],
+        uriTransformers: [['@lwrjs/lambda/mrt-static-uri-transformer', undefined]],
     };
 }
 /**
@@ -229,6 +234,7 @@ export function applyStaticProviderConfig(config) {
  * @returns {NormalizedLwrGlobalConfig} a normalized global config relative to the provided options
  */
 export function resolveGlobalConfig(configArg, options) {
+    const span = getTracer().startSpan({ name: ConfigSpan.ResolveConfig });
     const mergedConfig = mergeConfig(configArg);
     let normalizedConfig = normalizeConfig(mergedConfig);
     // Add static providers if applicable
@@ -243,9 +249,12 @@ export function resolveGlobalConfig(configArg, options) {
     }
     // skip dir normalization when the option is set
     if (options?.skipDirNormalization) {
+        span.end();
         return normalizedConfig;
     }
-    return normalizeConfigPaths(normalizedConfig);
+    const retVal = normalizeConfigPaths(normalizedConfig);
+    span.end();
+    return retVal;
 }
 /**
  * Resolve all application configurations by loading and merging global data, applying config hooks, and
@@ -255,6 +264,7 @@ export function resolveGlobalConfig(configArg, options) {
  * @returns {Configurations} all of the fully resolved configurations
  */
 export function loadConfig(config, options) {
+    const span = getTracer().startSpan({ name: ConfigSpan.LoadConfig });
     const appConfig = resolveGlobalConfig(config, options);
     const runtimeEnvironment = getRuntimeEnvironment(appConfig);
     const globalData = getGlobalData(appConfig.globalDataDir, appConfig.globalData);
@@ -263,10 +273,12 @@ export function loadConfig(config, options) {
         // route length validation happens in the `post` phase of validation
         validateLwrAppConfig(appConfig, 'post');
     }
-    return {
+    const retVal = {
         appConfig,
         runtimeEnvironment,
         globalData,
     };
+    span.end();
+    return retVal;
 }
 //# sourceMappingURL=global-config.js.map

package/build/es/hooks.d.ts

@@ -29,4 +29,5 @@ export declare function executeConfigHooks(hooks: HooksPlugin[], globalConfig: N
  * @param globalConfig - global configuration
  */
 export declare function executeStartHooks(hooks: HooksPlugin[], globalConfig: NormalizedLwrGlobalConfig, skipValidate?: boolean): void;
+export declare function executeInstrumentationHooks(hooks: HooksPlugin[]): boolean;
 //# sourceMappingURL=hooks.d.ts.map

package/build/es/hooks.js

@@ -1,6 +1,7 @@
 import { normalizeRoutes } from './utils/routes.js';
 import { validateLwrAppConfig } from './validation/app-config.js';
 import { applySsrConfig } from './global-config.js';
+import { getTracer, ConfigSpan } from '@lwrjs/instrumentation';
 /**
  * Run `initConfigs` hooks
  *
@@ -16,7 +17,9 @@ import { applySsrConfig } from './global-config.js';
  * @param globalData - resolved global data
  */
 export async function executeConfigHooks(hooks, globalConfig, runtimeEnvironment, globalData, skipValidate = false) {
+    const span = getTracer().startSpan({ name: ConfigSpan.ExecuteConfigHooks });
     if (!hooks.length) {
+        span.end();
         return;
     }
     for (const hook of hooks) {
@@ -34,6 +37,7 @@ export async function executeConfigHooks(hooks, globalConfig, runtimeEnvironment
     if (!skipValidate) {
         validateLwrAppConfig(globalConfig, 'post');
     }
+    span.end();
 }
 /**
  * Run `onStart` hooks
@@ -50,7 +54,9 @@ export async function executeConfigHooks(hooks, globalConfig, runtimeEnvironment
  * @param globalConfig - global configuration
  */
 export function executeStartHooks(hooks, globalConfig, skipValidate = false) {
+    const span = getTracer().startSpan({ name: ConfigSpan.ExecuteStartHooks });
     if (!hooks.length) {
+        span.end();
         return;
     }
     for (const hook of hooks) {
@@ -66,5 +72,19 @@ export function executeStartHooks(hooks, globalConfig, skipValidate = false) {
     if (!skipValidate) {
         validateLwrAppConfig(globalConfig, 'post');
     }
+    span.end();
+}
+export function executeInstrumentationHooks(hooks) {
+    const span = getTracer().startSpan({ name: ConfigSpan.ExecuteInstrHooks });
+    let retVal = false;
+    for (const hook of hooks) {
+        if (!hook.initInstrumentation) {
+            continue;
+        }
+        retVal = true;
+        hook.initInstrumentation();
+    }
+    span.end();
+    return retVal;
 }
 //# sourceMappingURL=hooks.js.map

package/build/es/index.d.ts

@@ -1,6 +1,6 @@
 export { version as LWR_VERSION, lwcVersion as LWC_VERSION } from '@lwrjs/config/package';
 export { loadConfig, resolveGlobalConfig as normalizeConfig, getLwrConfigFromFile } from './global-config.js';
 export { getRuntimeEnvironment } from './runtime-config.js';
-export { executeConfigHooks, executeStartHooks } from './hooks.js';
+export { executeConfigHooks, executeStartHooks, executeInstrumentationHooks } from './hooks.js';
 export { validateLwrAppConfig } from './validation/app-config.js';
 //# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -1,6 +1,6 @@
 export { version as LWR_VERSION, lwcVersion as LWC_VERSION } from '@lwrjs/config/package';
 export { loadConfig, resolveGlobalConfig as normalizeConfig, getLwrConfigFromFile } from './global-config.js';
 export { getRuntimeEnvironment } from './runtime-config.js';
-export { executeConfigHooks, executeStartHooks } from './hooks.js';
+export { executeConfigHooks, executeStartHooks, executeInstrumentationHooks } from './hooks.js';
 export { validateLwrAppConfig } from './validation/app-config.js';
 //# sourceMappingURL=index.js.map

package/build/es/modules.js

@@ -59,6 +59,7 @@ export async function loadServices(config) {
     const assetProviders = await loadServiceEntries(config.assetProviders, config.rootDir, config.cacheDir);
     const assetTransformers = await loadServiceEntries(config.assetTransformers, config.rootDir, config.cacheDir);
     const resourceProviders = await loadServiceEntries(config.resourceProviders, config.rootDir, config.cacheDir);
+    const uriTransformers = await loadServiceEntries(config.uriTransformers, config.rootDir, config.cacheDir);
     const viewProviders = await loadServiceEntries(config.viewProviders, config.rootDir, config.cacheDir);
     const viewTransformers = await loadServiceEntries(config.viewTransformers, config.rootDir, config.cacheDir);
     return {
@@ -67,6 +68,7 @@ export async function loadServices(config) {
         assetProviders,
         assetTransformers,
         resourceProviders,
+        uriTransformers,
         viewProviders,
         viewTransformers,
     };
@@ -83,9 +85,9 @@ export async function loadServices(config) {
 export async function loadRouteHandlers(config) {
     const routeHandlers = {};
     await Promise.all(Object.keys(config.routeHandlers).map(async (id) => {
-        const handlerPath = config.routeHandlers[id];
+        const [handlerPath, handlerOptions] = config.routeHandlers[id];
         const handler = await importModule(handlerPath, config.rootDir, path.join(config.cacheDir, 'routeHandlers'));
-        routeHandlers[id] = handler;
+        routeHandlers[id] = [handler, handlerOptions];
     }));
     return routeHandlers;
 }

package/build/es/utils/assets.d.ts

@@ -1,4 +1,4 @@
-import { AssetConfig } from '@lwrjs/types';
+import type { AssetConfig } from '@lwrjs/types';
 export declare function normalizeAssets(assets: string | AssetConfig[]): AssetConfig[];
 export declare function normalizeAssetPaths(assets: AssetConfig[], rootDir: string): AssetConfig[];
 //# sourceMappingURL=assets.d.ts.map

package/build/es/utils/assets.js

@@ -13,10 +13,13 @@ export function normalizeAssets(assets) {
 }
 export function normalizeAssetPaths(assets, rootDir) {
     return assets.map((asset) => {
-        const assetDir = asset.dir;
+        const assetDirConfig = asset;
+        const assetDir = assetDirConfig.dir;
         if (assetDir) {
             return {
                 ...asset,
+                // Add a wild card URL paths for root assets
+                urlPath: assetDirConfig.root ? '/' : asset.urlPath,
                 dir: assetDir && normalizeDirectory(assetDir, rootDir),
             };
         }

package/build/es/utils/global-data.d.ts

@@ -1,3 +1,3 @@
-import { GlobalData } from '@lwrjs/types';
+import type { GlobalData } from '@lwrjs/types';
 export declare function getGlobalData(globalDataDir: string, defaultData?: GlobalData): GlobalData;
 //# sourceMappingURL=global-data.d.ts.map

package/build/es/utils/routes.d.ts

@@ -1,8 +1,9 @@
-import type { LwrErrorRoute, LwrRoute, NormalizedLwrErrorRoute, NormalizedLwrRoute, ResourcePaths, RouteHandlersConfig } from '@lwrjs/types';
-declare type ViewOrErrorRoute = LwrRoute | LwrErrorRoute;
-declare type NormalizedRoute<T extends ViewOrErrorRoute> = T extends LwrRoute ? NormalizedLwrRoute : NormalizedLwrErrorRoute;
+import type { LwrErrorRoute, LwrRoute, NormalizedLwrErrorRoute, NormalizedLwrRoute, NormalizedRouteHandlersConfig, ResourcePaths, RouteHandlersConfig } from '@lwrjs/types';
+type ViewOrErrorRoute = LwrRoute | LwrErrorRoute;
+type NormalizedRoute<T extends ViewOrErrorRoute> = T extends LwrRoute ? NormalizedLwrRoute : NormalizedLwrErrorRoute;
 export declare function normalizeRoutes<T extends ViewOrErrorRoute>(routes: T[], routeHandlers: RouteHandlersConfig): NormalizedRoute<T>[];
 export declare function normalizeRoutePaths<T extends ViewOrErrorRoute>(routes: T[] | undefined, resourcePaths: ResourcePaths): NormalizedRoute<T>[];
-export declare function normalizeRouteHandlerPaths(routeHandlers: RouteHandlersConfig, resourcePaths: ResourcePaths): RouteHandlersConfig;
+export declare function normalizeRouteHandlers(routeHandlers: RouteHandlersConfig): NormalizedRouteHandlersConfig;
+export declare function normalizeRouteHandlerPaths(routeHandlers: NormalizedRouteHandlersConfig, resourcePaths: ResourcePaths): NormalizedRouteHandlersConfig;
 export {};
 //# sourceMappingURL=routes.d.ts.map

package/build/es/utils/routes.js

@@ -1,12 +1,22 @@
+import fs from 'fs';
 import path from 'path';
 import { DEFAULT_LWR_BOOTSTRAP_CONFIG, normalizeDirectory, normalizeResourcePath } from '@lwrjs/shared-utils';
 export function normalizeRoutes(routes, routeHandlers) {
     return routes.map((route) => {
         // when a route handler is set, ensure it is set in the route handler config
-        if (route.routeHandler && !routeHandlers[route.routeHandler]) {
-            const handlerPath = route.routeHandler;
-            // the non-normalized path to the handler will be the id used when invoking the route handler
-            routeHandlers[handlerPath] = handlerPath;
+        if (route.routeHandler) {
+            const [handler, options] = typeof route.routeHandler === 'string' ? [route.routeHandler, undefined] : route.routeHandler;
+            if (!routeHandlers[handler]) {
+                routeHandlers[handler] = [handler, options];
+            }
+            return {
+                ...route,
+                routeHandler: [handler, options],
+                bootstrap: {
+                    ...DEFAULT_LWR_BOOTSTRAP_CONFIG,
+                    ...route.bootstrap,
+                },
+            };
         }
         return {
             ...route,
@@ -33,9 +43,21 @@ export function normalizeRoutePaths(routes = [], resourcePaths) {
         return route;
     });
 }
+export function normalizeRouteHandlers(routeHandlers) {
+    for (const [id, config] of Object.entries(routeHandlers)) {
+        if (typeof config === 'string') {
+            routeHandlers[id] = [config, undefined];
+        }
+    }
+    return routeHandlers;
+}
 export function normalizeRouteHandlerPaths(routeHandlers, resourcePaths) {
-    for (const [id, handlerPath] of Object.entries(routeHandlers)) {
-        routeHandlers[id] = path.resolve(normalizeDirectory(handlerPath, resourcePaths.rootDir));
+    for (const [id, [handler, options]] of Object.entries(routeHandlers)) {
+        const normalizedPath = path.resolve(normalizeDirectory(handler, resourcePaths.rootDir));
+        // use the normalized path if it exists; otherwise the handler is module specifier
+        if (fs.existsSync(normalizedPath)) {
+            routeHandlers[id] = [normalizedPath, options];
+        }
     }
     return routeHandlers;
 }

package/build/es/validation/app-config-context.d.ts

@@ -1,11 +1,11 @@
-import { AssetDirConfig, AssetFileConfig, LwrErrorRoute, LwrRoute, NormalizedLwrGlobalConfig, NormalizedLwrAppBootstrapConfig, LwrLockerConfig, RouteHandlersConfig } from '@lwrjs/types';
+import type { AssetDirConfig, AssetFileConfig, LwrErrorRoute, LwrRoute, NormalizedLwrGlobalConfig, NormalizedLwrAppBootstrapConfig, LwrLockerConfig, RouteHandlersConfig, BundleConfig } from '@lwrjs/types';
 import { Node } from 'jsonc-parser';
 import { Diagnostic } from '@lwrjs/diagnostics';
-declare type RequiredAssetDirConfig = Required<AssetDirConfig>;
-declare type RequiredAssetFileConfig = Required<AssetFileConfig>;
-declare type RequiredLwrRoute = Required<LwrRoute>;
-declare type RequiredLwrErrorRoute = Required<LwrErrorRoute>;
-declare type RequiredLwrLockerConfig = Required<LwrLockerConfig>;
+type RequiredAssetDirConfig = Required<AssetDirConfig>;
+type RequiredAssetFileConfig = Required<AssetFileConfig>;
+type RequiredLwrRoute = Required<LwrRoute>;
+type RequiredLwrErrorRoute = Required<LwrErrorRoute>;
+type RequiredLwrLockerConfig = Required<LwrLockerConfig>;
 interface ConfigMap {
     root: NormalizedLwrGlobalConfig;
     assetDir: RequiredAssetDirConfig;
@@ -15,9 +15,12 @@ interface ConfigMap {
     routeHandlers: RouteHandlersConfig;
     bootstrap: NormalizedLwrAppBootstrapConfig;
     locker: RequiredLwrLockerConfig;
+    bundleConfig: BundleConfig;
+    'bundleConfig.external': BundleConfig;
+    'bundleConfig.groups': BundleConfig;
 }
-export declare const ROOT_ATTRIBUTE_KEYS: ["amdLoader", "apiVersion", "assets", "assetProviders", "assetTransformers", "bundleConfig", "bundleProviders", "cacheDir", "contentDir", "environment", "errorRoutes", "esmLoader", "staticSiteGenerator", "globalData", "globalDataDir", "hooks", "ignoreLwrConfigFile", "lwrConfigFile", "layoutsDir", "locker", "lwc", "lwrVersion", "moduleProviders", "port", "basePath", "resourceProviders", "rootDir", "routeHandlers", "routes", "serverMode", "minify", "serverType", "viewProviders", "viewTransformers"];
-export declare const ASSET_DIR_ATTRIBUTE_KEYS: ["alias", "dir", "urlPath"];
+export declare const ROOT_ATTRIBUTE_KEYS: ["amdLoader", "apiVersion", "assets", "assetProviders", "assetTransformers", "bundleConfig", "bundleProviders", "cacheDir", "contentDir", "environment", "errorRoutes", "esmLoader", "staticSiteGenerator", "globalData", "globalDataDir", "hooks", "ignoreLwrConfigFile", "lwrConfigFile", "layoutsDir", "locker", "lwc", "lwrVersion", "moduleProviders", "port", "basePath", "resourceProviders", "rootDir", "routeHandlers", "routes", "serverMode", "minify", "serverType", "uriTransformers", "viewProviders", "viewTransformers"];
+export declare const ASSET_DIR_ATTRIBUTE_KEYS: ["alias", "dir", "urlPath", "root"];
 export declare const ASSET_FILE_ATTRIBUTE_KEYS: ["alias", "file", "urlPath"];
 export declare const LOCKER_ATTRIBUTE_KEYS: ["enabled", "trustedComponents", "clientOnly"];
 export declare const ROUTE_ATTRIBUTE_KEYS: ["bootstrap", "subRoutes", "contentTemplate", "id", "cache", "layoutTemplate", "method", "path", "rootComponent", "routeHandler", "properties"];
@@ -48,9 +51,12 @@ export declare class ValidationContext {
     assertArrayOfStrings(node: Node | undefined, property: string): void;
     assertArrayOfSpecifiers(node: Node | undefined, property: string): void;
     assertArrayOfServices(node: Node | undefined, property: string): void;
+    assertIsService(node: Node | undefined, property: string, index?: number): void;
     assertUniqueIds(nodes: Node[], property: string): void;
+    assertClientLockerSSR(routesNode: Node | undefined, lockerNode: Node | undefined): void;
     assertRequiredKeys(node: Node, property: string, requiredPropertyKeys: string[]): void;
     assertValidKeys<T extends keyof ConfigMap>(node: Node, property: T, validPropertyKeys: (keyof ConfigMap[T])[]): void;
+    assertNoBundleConfigDupes(node: Node, dupes: string[]): void;
 }
 export {};
 //# sourceMappingURL=app-config-context.d.ts.map

package/build/es/validation/app-config-context.js

@@ -39,10 +39,11 @@ export const ROOT_ATTRIBUTE_KEYS = createKeys('root', [
     'serverMode',
     'minify',
     'serverType',
+    'uriTransformers',
     'viewProviders',
     'viewTransformers',
 ]);
-export const ASSET_DIR_ATTRIBUTE_KEYS = createKeys('assetDir', ['alias', 'dir', 'urlPath']);
+export const ASSET_DIR_ATTRIBUTE_KEYS = createKeys('assetDir', ['alias', 'dir', 'urlPath', 'root']);
 export const ASSET_FILE_ATTRIBUTE_KEYS = createKeys('assetFile', ['alias', 'file', 'urlPath']);
 export const LOCKER_ATTRIBUTE_KEYS = createKeys('locker', ['enabled', 'trustedComponents', 'clientOnly']);
 export const ROUTE_ATTRIBUTE_KEYS = createKeys('routes', [
@@ -323,24 +324,28 @@ export class ValidationContext {
             });
         }
         else if (node.children && node.children.length > 0) {
-            node.children.forEach((n, index) => {
-                if (n.type !== 'string' && n.type !== 'array') {
-                    this.diagnostics.push({
-                        description: descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(`${property}[${index}]`, 'string or array', n.type),
-                        location: this.getLocationFromNode(n),
-                    });
-                }
-                if ((n.type === 'string' && n.value.length === 0) ||
-                    (n.type === 'array' &&
-                        n.children &&
-                        (n.children.length !== 2 || !isNotEmptyString(n.children[0])))) {
-                    this.diagnostics.push({
-                        description: descriptions.CONFIG_PARSER.INVALID_SERVICE(`${property}[${index}]`, n.value === undefined && n.children
-                            ? `invalid Array[${n.children.length}]`
-                            : n.value),
-                        location: this.getLocationFromNode(n),
-                    });
-                }
+            node.children.forEach((n, index) => this.assertIsService(n, property, index));
+        }
+    }
+    assertIsService(node, property, index) {
+        if (!node) {
+            return;
+        }
+        if (node.type !== 'string' && node.type !== 'array') {
+            this.diagnostics.push({
+                description: descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(index !== undefined ? `${property}[${index}]` : property, 'string or array', node.type),
+                location: this.getLocationFromNode(node),
+            });
+        }
+        if ((node.type === 'string' && node.value.length === 0) ||
+            (node.type === 'array' &&
+                node.children &&
+                (node.children.length !== 2 || !isNotEmptyString(node.children[0])))) {
+            this.diagnostics.push({
+                description: descriptions.CONFIG_PARSER.INVALID_SERVICE(index !== undefined ? `${property}[${index}]` : property, node.value === undefined && node.children
+                    ? `invalid Array[${node.children.length}]`
+                    : node.value),
+                location: this.getLocationFromNode(node),
             });
         }
     }
@@ -359,6 +364,28 @@ export class ValidationContext {
             });
         }
     }
+    assertClientLockerSSR(routesNode, lockerNode) {
+        if (routesNode && lockerNode) {
+            const enabled = findNodeAtLocation(lockerNode, ['enabled']);
+            const clientOnly = findNodeAtLocation(lockerNode, ['clientOnly']);
+            const compileTimeLocker = enabled && enabled.value === true && (!clientOnly || clientOnly.value === false);
+            if (compileTimeLocker && routesNode.children) {
+                const hasSSR = routesNode.children.some((n) => {
+                    const bootstrap = findNodeAtLocation(n, ['bootstrap']);
+                    if (bootstrap) {
+                        const ssr = findNodeAtLocation(bootstrap, ['ssr']);
+                        return ssr?.value === true;
+                    }
+                });
+                if (hasSSR) {
+                    this.diagnostics.push({
+                        description: descriptions.CONFIG_PARSER.COMPILE_LOCKER_SSR(),
+                        location: this.getLocationFromNode(lockerNode),
+                    });
+                }
+            }
+        }
+    }
     assertRequiredKeys(node, property, requiredPropertyKeys) {
         // All of the given properties must exist on the node
         const missingProps = requiredPropertyKeys.filter((p) => findNodeAtLocation(node, [p]) === undefined);
@@ -393,5 +420,13 @@ export class ValidationContext {
             }
         }
     }
+    assertNoBundleConfigDupes(node, dupes) {
+        if (dupes.length) {
+            this.diagnostics.push({
+                description: descriptions.CONFIG_PARSER.DUPLICATE_BUNDLE_CONFIG(dupes),
+                location: this.getLocationFromNode(node),
+            });
+        }
+    }
 }
 //# sourceMappingURL=app-config-context.js.map

package/build/es/validation/app-config.d.ts

@@ -4,7 +4,7 @@ export declare const SOURCE_BY_PHASE: {
     pre: string;
     post: string;
 };
-declare type ConfigPhase = 'file' | 'pre' | 'post';
+type ConfigPhase = 'file' | 'pre' | 'post';
 export declare function validateLwrAppConfig(config: string | LwrGlobalConfig, phase: ConfigPhase): void | never;
 export {};
 //# sourceMappingURL=app-config.d.ts.map

package/build/es/validation/app-config.js

@@ -2,6 +2,8 @@ import { parseTree, printParseErrorCode, findNodeAtLocation as findNode, } from
 import { createSingleDiagnosticError, descriptions, LwrConfigValidationError } from '@lwrjs/diagnostics';
 import { ASSET_DIR_ATTRIBUTE_KEYS, ASSET_FILE_ATTRIBUTE_KEYS, BOOTSTRAP_ATTRIBUTE_KEYS, ERROR_ROUTE_ATTRIBUTE_KEYS, LOCKER_ATTRIBUTE_KEYS, ROOT_ATTRIBUTE_KEYS, ROUTE_ATTRIBUTE_KEYS, ValidationContext, } from './app-config-context.js';
 import { calculatePositionFromSource } from './helpers.js';
+import { DEFAULT_ESM_BUNDLE_EXCLUSIONS, DEFAULT_AMD_BUNDLE_EXCLUSIONS } from '../defaults.js';
+import { ConfigSpan, getTracer } from '@lwrjs/instrumentation';
 export const SOURCE_BY_PHASE = {
     file: 'lwr.config.json',
     pre: 'argument passed to createServer',
@@ -63,7 +65,7 @@ function validateRouteCommon(node, validationContext, propPrefix) {
     validationContext.assertIsSpecifier(findNode(node, ['rootComponent']), `${propPrefix}.rootComponent`);
     validationContext.assertNotEmptyString(findNode(node, ['contentTemplate']), `${propPrefix}.contentTemplate`);
     validationContext.assertNotEmptyString(findNode(node, ['layoutTemplate']), `${propPrefix}.layoutTemplate`);
-    validationContext.assertNotEmptyString(findNode(node, ['routeHandler']), `${propPrefix}.routeHandler`);
+    validationContext.assertIsService(findNode(node, ['routeHandler']), `${propPrefix}.routeHandler`);
     validateBootstrap(findNode(node, ['bootstrap']), validationContext, `${propPrefix}.bootstrap`);
 }
 /**
@@ -93,6 +95,55 @@ function validateRoutes(node, validationContext, preMerge) {
         }
     }
 }
+function validateBundleConfig(node, validationContext) {
+    if (node) {
+        validationContext.assertIsObject(node, 'bundleConfig');
+        // keep track of dupes
+        const dupeMap = new Map();
+        const dupes = new Set();
+        const excludeNode = findNode(node, ['exclude']);
+        validationContext.assertArrayOfSpecifiers(excludeNode, 'bundleConfig.exclude');
+        excludeNode?.children?.forEach((n) => {
+            dupeMap.set(n.value, true);
+        });
+        const external = findNode(node, ['external']);
+        if (external) {
+            external?.children?.forEach((n) => {
+                const specifier = (n?.children && n.children[0])?.value;
+                if (specifier && dupeMap.has(specifier)) {
+                    dupes.add(specifier);
+                }
+                else {
+                    dupeMap.set(specifier, true);
+                }
+            });
+            // TODO: add RHS externals validation once we finish support for externals in <>
+        }
+        const groups = findNode(node, ['groups']);
+        if (groups) {
+            validationContext.assertIsObject(groups, 'bundleConfig.groups');
+            groups?.children?.forEach((n) => {
+                const groupKey = n?.children && n.children[0];
+                const group = n?.children && n.children[1];
+                if (group && groupKey) {
+                    validationContext.assertNotEmptyArray(group, `bundleConfig.groups.${groupKey.value}`);
+                    validationContext.assertArrayOfSpecifiers(group, `bundleConfig.groups.${groupKey.value}`);
+                    const groupies = group?.children;
+                    groupies?.forEach((n) => {
+                        if (dupeMap.has(n.value)) {
+                            dupes.add(n.value);
+                        }
+                    });
+                }
+            });
+        }
+        // For now, allow dupes w/ default excludes
+        // TODO W-13651948: remove this once we get rid of UNSAFE_lwrDefaultExcludes
+        const defaultExcludes = new Set([...DEFAULT_AMD_BUNDLE_EXCLUSIONS, ...DEFAULT_ESM_BUNDLE_EXCLUSIONS]);
+        const dupesFiltered = Array.from(dupes).filter((specifier) => !defaultExcludes.has(specifier));
+        validationContext.assertNoBundleConfigDupes(node, dupesFiltered);
+    }
+}
 /**
  * Check config.errorRoutes[]:
  *      - status: required 404 | 500
@@ -137,21 +188,29 @@ function validateAssets(node, validationContext, preMerge) {
             validationContext.assertNotEmptyArray(node, 'assets');
             if (node.children) {
                 node.children.forEach((n, index) => {
+                    const rootDirNode = findNode(n, ['root']);
                     const dirNode = findNode(n, ['dir']);
                     const fileNode = findNode(n, ['file']);
-                    if (dirNode?.type === 'string') {
+                    if (rootDirNode?.type === 'boolean') {
+                        validationContext.assertIsObject(n, 'assetDir');
+                        validationContext.assertValidKeys(n, 'assetDir', ASSET_DIR_ATTRIBUTE_KEYS);
+                    }
+                    else if (dirNode?.type === 'string') {
                         validationContext.assertIsObject(n, 'assetDir');
                         validationContext.assertValidKeys(n, 'assetDir', ASSET_DIR_ATTRIBUTE_KEYS);
+                        validationContext.assertRequiredKeys(n, `assets[${index}]`, ['urlPath']);
+                        validationContext.assertIsPath(findNode(n, ['urlPath']), `assets[${index}].urlPath`);
                     }
                     else if (fileNode?.type === 'string') {
                         validationContext.assertIsObject(n, 'assetFile');
                         validationContext.assertValidKeys(n, 'assetFile', ASSET_FILE_ATTRIBUTE_KEYS);
+                        validationContext.assertRequiredKeys(n, `assets[${index}]`, ['urlPath']);
+                        validationContext.assertIsPath(findNode(n, ['urlPath']), `assets[${index}].urlPath`);
                     }
-                    validationContext.assertRequiredKeys(n, `assets[${index}]`, ['urlPath']);
                     validationContext.assertHasOnlyOne(n, `assets[${index}]`, ['dir', 'file']);
                     validationContext.assertNotEmptyString(dirNode, `assets[${index}].dir`);
                     validationContext.assertNotEmptyString(fileNode, `assets[${index}].file`);
-                    validationContext.assertIsPath(findNode(n, ['urlPath']), `assets[${index}].urlPath`);
+                    validationContext.assertIsBoolean(rootDirNode, `assets[${index}].root`);
                     validationContext.assertNotEmptyString(findNode(n, ['alias']), `assets[${index}].alias`);
                 });
             }
@@ -178,6 +237,8 @@ function validateLocker(node, validationContext) {
  *      - routes...
  *      - errorRoutes...
  *      - assets...
+ *      - locker...
+ *      - SSR is only used with clientOnly locker (or locker is disabled)
  *      - route and errorRoute ids must be unique
  *      - apiVersion: string
  *      - lwrVersion: string
@@ -196,7 +257,6 @@ function validateLocker(node, validationContext) {
  *      - lwc.modules: array
  *      - basePath: valid subdomain part
  * Notes:
- *      - ignore `bundleConfig` because it is not yet RFCed
  *      - specifier strings are validated for type and shape only, NOT if they are resolvable
  */
 function validateRoot(node, validationContext, preMerge) {
@@ -206,11 +266,15 @@ function validateRoot(node, validationContext, preMerge) {
     const routes = findNode(node, ['routes']);
     const errorRoutes = findNode(node, ['errorRoutes']);
     validationContext.assertUniqueIds([...(routes?.children || []), ...(errorRoutes?.children || [])], 'routes');
+    const lockerNode = findNode(node, ['locker']);
+    const bundleConfigNode = findNode(node, ['bundleConfig']);
     validateRoutes(routes, validationContext, preMerge);
     validateErrorRoutes(errorRoutes, validationContext);
     validateRouteHandlers(findNode(node, ['routeHandlers']), validationContext);
     validateAssets(findNode(node, ['assets']), validationContext, preMerge);
-    validateLocker(findNode(node, ['locker']), validationContext);
+    validateLocker(lockerNode, validationContext);
+    validateBundleConfig(bundleConfigNode, validationContext);
+    validationContext.assertClientLockerSSR(routes, lockerNode);
     validationContext.assertNotEmptyString(findNode(node, ['apiVersion']), 'apiVersion');
     validationContext.assertNotEmptyString(findNode(node, ['lwrVersion']), 'lwrVersion');
     validationContext.assertIsSpecifier(findNode(node, ['amdLoader']), 'amdLoader');
@@ -235,6 +299,7 @@ function validateRoot(node, validationContext, preMerge) {
     validationContext.assertIsBasePath(findNode(node, ['basePath']), 'basePath');
 }
 export function validateLwrAppConfig(config, phase) {
+    const span = getTracer().startSpan({ name: ConfigSpan.ValidateConfig });
     try {
         const jsonSourceText = typeof config === 'string' ? config : JSON.stringify(config);
         const errors = [];
@@ -257,9 +322,11 @@ export function validateLwrAppConfig(config, phase) {
         if (validationContext.diagnostics.length) {
             throw new LwrConfigValidationError(`Configuration validation errors in ${SOURCE_BY_PHASE[phase]}`, validationContext.diagnostics);
         }
+        span.end();
         return;
     }
     catch (err) {
+        span.end();
         if (process.env.UNSAFE_IGNORE_CONFIG_VALIDATION === 'true') {
             console.warn('ignoring config validation errors due to UNSAFE_IGNORE_CONFIG_VALIDATION flag...proceed with caution');
             console.dir(err, { depth: null });

package/build/es/validation/helpers.d.ts

@@ -1,4 +1,4 @@
-import { SourceLocation } from '@lwrjs/diagnostics';
+import type { SourceLocation } from '@lwrjs/diagnostics';
 interface SourcePosition {
     offset: number;
     length: number;

package/package.cjs

@@ -16,9 +16,14 @@ let lwcVersion;
 if (globalThis.LWC_VERSION) {
     version = globalThis.LWC_VERSION;
 } else {
-    const packageJsonPath = resolve.sync(`lwc/package.json`);
-    const { version: packageVersion } = JSON.parse(fs.readFileSync(packageJsonPath), 'utf-8');
-    lwcVersion = packageVersion;
+    try {
+        const packageJsonPath = resolve.sync(`lwc/package.json`);
+        const { version: packageVersion } = JSON.parse(fs.readFileSync(packageJsonPath), 'utf-8');
+        lwcVersion = packageVersion;
+    } catch(err) {
+        console.log(`[config] peer dependency lwc was not provided`);
+        lwcVersion = 'not-provided';
+    }
 }
 
 module.exports = {

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.10.0-alpha.2",
+    "version": "0.10.0-alpha.20",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -35,20 +35,31 @@
         "build/**/*.d.ts",
         "package.cjs"
     ],
+    "scripts": {
+        "build": "tsc -b",
+        "clean": "rm -rf build node_modules",
+        "test": "jest"
+    },
     "dependencies": {
-        "@lwrjs/diagnostics": "0.10.0-alpha.2",
-        "@lwrjs/shared-utils": "0.10.0-alpha.2",
-        "fs-extra": "^11.1.0",
+        "@lwrjs/diagnostics": "0.10.0-alpha.20",
+        "@lwrjs/instrumentation": "0.10.0-alpha.20",
+        "@lwrjs/shared-utils": "0.10.0-alpha.20",
+        "fs-extra": "^11.1.1",
         "jsonc-parser": "^3.0.0"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.10.0-alpha.2"
+        "@lwrjs/types": "0.10.0-alpha.20",
+        "jest": "^26.6.3",
+        "ts-jest": "^26.5.6"
     },
     "peerDependencies": {
         "lwc": "2.x"
     },
     "engines": {
-        "node": ">=16.0.0 <20"
+        "node": ">=16.0.0"
+    },
+    "volta": {
+        "extends": "../../../package.json"
     },
-    "gitHead": "592cda0637513885477829beea35a86407b342d4"
+    "gitHead": "45a867fc54e98f77dd442ccd5f668e23027b9246"
 }