@lwrjs/config 0.9.0-alpha.9 → 0.9.0

package/build/es/modules.d.ts

@@ -0,0 +1,32 @@
+import type { HooksPlugin, NormalizedLwrGlobalConfig, RouteHandlers, Services } from '@lwrjs/types';
+/**
+ * Import and instantiate hooks defined in the global config
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load hook modules.
+ *
+ * @param config - global config
+ * @returns {HooksPlugin[]} all instantiated hooks
+ */
+export declare function loadHooks(config: NormalizedLwrGlobalConfig): Promise<HooksPlugin[]>;
+/**
+ * Load service modules from the filepaths configured in the global config
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load service modules.
+ *
+ * @param config - global config
+ * @returns {Services} all of the imported service constructors
+ */
+export declare function loadServices(config: NormalizedLwrGlobalConfig): Promise<Services>;
+/**
+ * Load all route handlers from the filepaths configured in the global config
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load route handler modules.
+ *
+ * @param config - global config
+ * @returns {Routes} resolved route handlers mapped by id
+ */
+export declare function loadRouteHandlers(config: NormalizedLwrGlobalConfig): Promise<RouteHandlers>;
+//# sourceMappingURL=modules.d.ts.map

package/build/es/modules.js

@@ -0,0 +1,92 @@
+import path from 'path';
+import { normalizeDirectory, resolveFileExtension } from '@lwrjs/shared-utils';
+import { transpileTs } from '@lwrjs/shared-utils/typescript';
+async function importModule(filepath, rootDir, cacheDir) {
+    // ensure paths are fully resolved before loading source
+    let resolvedFilePath = normalizeDirectory(filepath, rootDir);
+    const resolvedCacheDir = normalizeDirectory(cacheDir, rootDir);
+    try {
+        if (resolvedFilePath.endsWith('.ts')) {
+            const fullPath = resolveFileExtension(resolvedFilePath);
+            resolvedFilePath = await transpileTs(fullPath, { rootDir, cacheDir: resolvedCacheDir });
+        }
+        const moduleEntry = await import(resolvedFilePath);
+        const output = moduleEntry.default || moduleEntry;
+        return output;
+    }
+    catch (err) {
+        console.log(err);
+        throw new Error(`Unable to load configurable module: ${filepath}`);
+    }
+}
+async function loadServiceEntries(entries, rootDir, cacheDir) {
+    return Promise.all(entries.map(async ([entry, config]) => {
+        const ctor = await importModule(entry, rootDir, path.join(cacheDir, 'services'));
+        return [ctor, config];
+    }));
+}
+/**
+ * Import and instantiate hooks defined in the global config
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load hook modules.
+ *
+ * @param config - global config
+ * @returns {HooksPlugin[]} all instantiated hooks
+ */
+export async function loadHooks(config) {
+    if (!config.hooks) {
+        return [];
+    }
+    const hookCtors = await loadServiceEntries(config.hooks, config.rootDir, config.cacheDir);
+    const hooks = hookCtors.map(([hookCtor, hookConfig = {}]) => {
+        return new hookCtor(hookConfig);
+    });
+    return hooks;
+}
+/**
+ * Load service modules from the filepaths configured in the global config
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load service modules.
+ *
+ * @param config - global config
+ * @returns {Services} all of the imported service constructors
+ */
+export async function loadServices(config) {
+    const moduleProviders = await loadServiceEntries(config.moduleProviders, config.rootDir, config.cacheDir);
+    const bundleProviders = await loadServiceEntries(config.bundleProviders, config.rootDir, config.cacheDir);
+    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 viewProviders = await loadServiceEntries(config.viewProviders, config.rootDir, config.cacheDir);
+    const viewTransformers = await loadServiceEntries(config.viewTransformers, config.rootDir, config.cacheDir);
+    return {
+        moduleProviders,
+        bundleProviders,
+        assetProviders,
+        assetTransformers,
+        resourceProviders,
+        viewProviders,
+        viewTransformers,
+    };
+}
+/**
+ * Load all route handlers from the filepaths configured in the global config
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load route handler modules.
+ *
+ * @param config - global config
+ * @returns {Routes} resolved route handlers mapped by id
+ */
+export async function loadRouteHandlers(config) {
+    const routeHandlers = {};
+    await Promise.all(Object.keys(config.routeHandlers).map(async (id) => {
+        const handlerPath = config.routeHandlers[id];
+        const handler = await importModule(handlerPath, config.rootDir, path.join(config.cacheDir, 'routeHandlers'));
+        routeHandlers[id] = handler;
+    }));
+    return routeHandlers;
+}
+//# sourceMappingURL=modules.js.map

package/build/es/runtime-config.d.ts

@@ -1,12 +1,19 @@
-import { ServerModeConfig } from '@lwrjs/types';
+import type { ServerModeConfig, NormalizedLwrGlobalConfig, RuntimeEnvironment } from '@lwrjs/types';
 export declare const RUNTIME_CONFIGS: Record<string, ServerModeConfig>;
 /**
- * Get the runtime environment config for the mode.
+ * Get server mode config by name
  *
  * @throws {LwrServerError} Mode must be supported by LWR.
  *
- * @param {string} mode - the name of the server mode
- * @returns {ServerModeConfig} the runtime environment config for the mode
+ * @param {string} serverMode - the name of the server mode
+ * @returns {ServerModeConfig} the server mode config
  */
-export declare function getServerModeConfig(mode: string): ServerModeConfig;
+export declare function getServerModeConfig(serverMode: string): ServerModeConfig;
+/**
+ * Get runtime environment
+ *
+ * @param {NormalizedLwrGlobalConfig} config - the normalized global config object
+ * @returns {RuntimeEnvironment} the complete runtime environment
+ */
+export declare function getRuntimeEnvironment(config: NormalizedLwrGlobalConfig): RuntimeEnvironment;
 //# sourceMappingURL=runtime-config.d.ts.map

package/build/es/runtime-config.js

@@ -1,10 +1,12 @@
 import { createSingleDiagnosticError, descriptions, LwrServerError } from '@lwrjs/diagnostics';
+import { getFeatureFlags } from '@lwrjs/shared-utils';
 export const RUNTIME_CONFIGS = {
     dev: {
         bundle: false,
         minify: false,
         format: 'esm',
         compat: '0',
+        debug: false,
         watchFiles: true,
         defaultLocale: 'en_US',
         hmrEnabled: true,
@@ -18,6 +20,7 @@ export const RUNTIME_CONFIGS = {
         minify: true,
         format: 'esm',
         compat: '0',
+        debug: false,
         watchFiles: false,
         defaultLocale: 'en_US',
         hmrEnabled: false,
@@ -31,6 +34,7 @@ export const RUNTIME_CONFIGS = {
         minify: false,
         format: 'amd',
         compat: '1',
+        debug: false,
         watchFiles: true,
         defaultLocale: 'en_US',
         hmrEnabled: false,
@@ -44,6 +48,7 @@ export const RUNTIME_CONFIGS = {
         minify: true,
         format: 'amd',
         compat: '1',
+        debug: false,
         watchFiles: false,
         defaultLocale: 'en_US',
         hmrEnabled: false,
@@ -54,18 +59,37 @@ export const RUNTIME_CONFIGS = {
     },
 };
 /**
- * Get the runtime environment config for the mode.
+ * Get server mode config by name
  *
  * @throws {LwrServerError} Mode must be supported by LWR.
  *
- * @param {string} mode - the name of the server mode
- * @returns {ServerModeConfig} the runtime environment config for the mode
+ * @param {string} serverMode - the name of the server mode
+ * @returns {ServerModeConfig} the server mode config
  */
-export function getServerModeConfig(mode) {
-    const selectedMode = RUNTIME_CONFIGS[mode];
+export function getServerModeConfig(serverMode) {
+    const selectedMode = RUNTIME_CONFIGS[serverMode];
     if (!selectedMode) {
-        throw createSingleDiagnosticError({ description: descriptions.SERVER.INVALID_MODE(mode) }, LwrServerError);
+        throw createSingleDiagnosticError({ description: descriptions.SERVER.INVALID_MODE(serverMode) }, LwrServerError);
     }
     return selectedMode;
 }
+/**
+ * Get runtime environment
+ *
+ * @param {NormalizedLwrGlobalConfig} config - the normalized global config object
+ * @returns {RuntimeEnvironment} the complete runtime environment
+ */
+export function getRuntimeEnvironment(config) {
+    const { serverMode, lwrVersion, apiVersion, basePath, minify } = config;
+    const serverModeConfig = getServerModeConfig(config.serverMode);
+    return {
+        ...serverModeConfig,
+        minify: minify !== null ? minify : serverModeConfig.minify,
+        featureFlags: getFeatureFlags(),
+        serverMode,
+        lwrVersion,
+        apiVersion,
+        basePath,
+    };
+}
 //# sourceMappingURL=runtime-config.js.map

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

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

package/build/es/utils/global-data.js

@@ -0,0 +1,29 @@
+import fs from 'fs';
+import path from 'path';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function recursiveJsonCollector(resources, currentPath, collector) {
+    for (const resource of resources) {
+        const resourcePath = path.join(currentPath, resource);
+        if (resource.endsWith('.json')) {
+            const resourceName = path.basename(resource, '.json');
+            const jsonSource = JSON.parse(fs.readFileSync(resourcePath, 'utf-8'));
+            collector[resourceName] = jsonSource;
+        }
+        else if (fs.statSync(resourcePath).isDirectory()) {
+            const dirContentList = fs.readdirSync(resourcePath);
+            collector[resource] = recursiveJsonCollector(dirContentList, resourcePath, {});
+        }
+    }
+    return collector;
+}
+export function getGlobalData(globalDataDir, defaultData = {}) {
+    if (!fs.existsSync(globalDataDir) || !fs.statSync(globalDataDir).isDirectory()) {
+        return defaultData;
+    }
+    const dirContentList = fs.readdirSync(globalDataDir);
+    return {
+        ...recursiveJsonCollector(dirContentList, globalDataDir, {}),
+        ...defaultData,
+    };
+}
+//# sourceMappingURL=global-data.js.map

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

@@ -1,7 +1,7 @@
 import type { BundleConfig, LwcConfig, LwrGlobalConfig, LwrLockerConfig, StaticSiteGenerator } from '@lwrjs/types';
 export declare function trimLwrConfig(config: LwrGlobalConfig): LwrGlobalConfig;
 export declare function mergeLwcConfig(config1: LwrGlobalConfig | undefined, config2: LwrGlobalConfig | undefined): LwcConfig;
-export declare function mergeBundleConfig(jsonConfig: LwrGlobalConfig | undefined, config: LwrGlobalConfig | undefined): BundleConfig;
+export declare function mergeBundleConfig(config1: LwrGlobalConfig | undefined, config2: LwrGlobalConfig | undefined): BundleConfig;
 export declare function mergeLockerConfig(jsonConfig: LwrGlobalConfig | undefined, config: LwrGlobalConfig | undefined): LwrLockerConfig;
 export declare function mergeStaticGenerationConfig(configFile?: LwrGlobalConfig, configArg?: LwrGlobalConfig): StaticSiteGenerator;
 //# sourceMappingURL=merge.d.ts.map

package/build/es/utils/merge.js

@@ -1,5 +1,8 @@
 import { DEFAULT_LOCKER_TRUSTED_CMP, DEFAULT_LWR_LOCKER_CONFIG } from '@lwrjs/shared-utils';
-import { DEFAULT_BUNDLE_EXCLUSIONS, DEFAULT_GENERATOR_CONFIG, DEFAULT_LWR_MODULES } from '../defaults.js';
+import { getDefaultBundleConfig, DEFAULT_GENERATOR_CONFIG, DEFAULT_LWR_MODULES } from '../defaults.js';
+function isNormalizedLwrGlobalConfig(config) {
+    return config?.lwrVersion !== undefined;
+}
 export function trimLwrConfig(config) {
     Object.keys(config).forEach((k) => {
         if (config[k] === undefined)
@@ -9,6 +12,10 @@ export function trimLwrConfig(config) {
 }
 // deep merge LWC configs
 export function mergeLwcConfig(config1, config2) {
+    // normalized config already contains the defaults
+    const defaultModules = !isNormalizedLwrGlobalConfig(config1) && !isNormalizedLwrGlobalConfig(config2)
+        ? DEFAULT_LWR_MODULES
+        : [];
     const modules1 = config1?.lwc?.modules || [];
     const modules2 = config2?.lwc?.modules || [];
     const interchangeable1 = config1?.lwc?.interchangeable || [];
@@ -18,7 +25,7 @@ export function mergeLwcConfig(config1, config2) {
     const interchangeableModules2 = config2?.lwc?.interchangeableModules || [];
     const mergedInterchangeableModules = [...interchangeableModules1, ...interchangeableModules2];
     return {
-        modules: [...DEFAULT_LWR_MODULES, ...modules1, ...modules2],
+        modules: [...defaultModules, ...modules1, ...modules2],
         interchangeable: mergedInterchangeable.length ? mergedInterchangeable : undefined,
         interchangeableModules: mergedInterchangeableModules.length
             ? mergedInterchangeableModules
@@ -26,15 +33,21 @@ export function mergeLwcConfig(config1, config2) {
     };
 }
 // merge default bundle exclusions with any bundle exclusions specified in config
-export function mergeBundleConfig(jsonConfig, config) {
-    const defaultExclusions = config?.bundleConfig?.UNSAFE_lwrDefaultExclude ||
-        jsonConfig?.bundleConfig?.UNSAFE_lwrDefaultExclude ||
-        DEFAULT_BUNDLE_EXCLUSIONS;
-    const configExclusions = config?.bundleConfig?.exclude || jsonConfig?.bundleConfig?.exclude || [];
+export function mergeBundleConfig(config1, config2) {
+    const mode = config2?.serverMode || config1?.serverMode;
+    const DEFAULT_BUNDLE_CONFIG = getDefaultBundleConfig(mode);
+    const defaultExclusions = config2?.bundleConfig?.UNSAFE_lwrDefaultExclude ||
+        config1?.bundleConfig?.UNSAFE_lwrDefaultExclude ||
+        DEFAULT_BUNDLE_CONFIG.exclude ||
+        [];
+    const configExclusions = config2?.bundleConfig?.exclude || config1?.bundleConfig?.exclude || [];
+    const configExternals = config2?.bundleConfig?.external || config1?.bundleConfig?.external || {};
     return {
-        ...jsonConfig?.bundleConfig,
-        ...config?.bundleConfig,
+        ...config1?.bundleConfig,
+        ...config2?.bundleConfig,
         exclude: [...new Set([...defaultExclusions, ...configExclusions])],
+        // Merge default externals with configured externals
+        external: { ...DEFAULT_BUNDLE_CONFIG.external, ...configExternals },
     };
 }
 // merge default locker trusted namespaces/cmps with any trusted namespaces/cmps specified in config
@@ -49,10 +62,16 @@ export function mergeLockerConfig(jsonConfig, config) {
     };
 }
 export function mergeStaticGenerationConfig(configFile, configArg) {
+    const fileAdditionalModules = configFile?.staticSiteGenerator?._additionalModules || [];
+    const argAdditionalModules = configArg?.staticSiteGenerator?._additionalModules || [];
+    const fileAdditionalPaths = configFile?.staticSiteGenerator?._additionalRoutePaths || [];
+    const argAdditionalPaths = configArg?.staticSiteGenerator?._additionalRoutePaths || [];
     return {
         ...DEFAULT_GENERATOR_CONFIG,
         ...configFile?.staticSiteGenerator,
         ...configArg?.staticSiteGenerator,
+        _additionalModules: [...new Set([...fileAdditionalModules, ...argAdditionalModules])],
+        _additionalRoutePaths: [...new Set([...fileAdditionalPaths, ...argAdditionalPaths])],
     };
 }
 //# sourceMappingURL=merge.js.map

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

@@ -1,7 +1,8 @@
-import type { LwrErrorRoute, LwrRoute, NormalizedLwrErrorRoute, NormalizedLwrRoute, ResourcePaths } from '@lwrjs/types';
+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;
-export declare function normalizeRoutes<T extends ViewOrErrorRoute>(routes?: T[]): NormalizedRoute<T>[];
+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 {};
 //# sourceMappingURL=routes.d.ts.map

package/build/es/utils/routes.js

@@ -1,25 +1,42 @@
 import path from 'path';
 import { DEFAULT_LWR_BOOTSTRAP_CONFIG, normalizeDirectory, normalizeResourcePath } from '@lwrjs/shared-utils';
-export function normalizeRoutes(routes = []) {
-    return routes.map((route) => ({
-        ...route,
-        bootstrap: {
-            ...DEFAULT_LWR_BOOTSTRAP_CONFIG,
-            ...route.bootstrap,
-        },
-    }));
+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;
+        }
+        return {
+            ...route,
+            bootstrap: {
+                ...DEFAULT_LWR_BOOTSTRAP_CONFIG,
+                ...route.bootstrap,
+            },
+        };
+    });
 }
 export function normalizeRoutePaths(routes = [], resourcePaths) {
     return routes.map((route) => {
-        const { routeHandler, contentTemplate, layoutTemplate, subRoutes } = route;
-        route.routeHandler =
-            routeHandler && path.resolve(normalizeDirectory(routeHandler, resourcePaths.rootDir));
-        route.contentTemplate =
-            contentTemplate && path.resolve(normalizeResourcePath(contentTemplate, resourcePaths));
-        route.layoutTemplate =
-            layoutTemplate && path.resolve(normalizeResourcePath(layoutTemplate, resourcePaths));
-        route.subRoutes = subRoutes && path.resolve(normalizeResourcePath(subRoutes, resourcePaths));
+        // route handler paths are NOT normalized here to maintain the id lookup for route handler invocation
+        const { contentTemplate, layoutTemplate, subRoutes } = route;
+        if (contentTemplate) {
+            route.contentTemplate = path.resolve(normalizeResourcePath(contentTemplate, resourcePaths));
+        }
+        if (layoutTemplate) {
+            route.layoutTemplate = path.resolve(normalizeResourcePath(layoutTemplate, resourcePaths));
+        }
+        if (subRoutes) {
+            route.subRoutes = path.resolve(normalizeResourcePath(subRoutes, resourcePaths));
+        }
         return route;
     });
 }
+export function normalizeRouteHandlerPaths(routeHandlers, resourcePaths) {
+    for (const [id, handlerPath] of Object.entries(routeHandlers)) {
+        routeHandlers[id] = path.resolve(normalizeDirectory(handlerPath, resourcePaths.rootDir));
+    }
+    return routeHandlers;
+}
 //# sourceMappingURL=routes.js.map

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

@@ -1,4 +1,4 @@
-import { AssetDirConfig, AssetFileConfig, LwrErrorRoute, LwrRoute, NormalizedLwrGlobalConfig, NormalizedLwrAppBootstrapConfig, LwrLockerConfig } from '@lwrjs/types';
+import { AssetDirConfig, AssetFileConfig, LwrErrorRoute, LwrRoute, NormalizedLwrGlobalConfig, NormalizedLwrAppBootstrapConfig, LwrLockerConfig, RouteHandlersConfig } from '@lwrjs/types';
 import { Node } from 'jsonc-parser';
 import { Diagnostic } from '@lwrjs/diagnostics';
 declare type RequiredAssetDirConfig = Required<AssetDirConfig>;
@@ -12,16 +12,17 @@ interface ConfigMap {
     assetFile: RequiredAssetFileConfig;
     routes: RequiredLwrRoute;
     errorRoutes: RequiredLwrErrorRoute;
+    routeHandlers: RouteHandlersConfig;
     bootstrap: NormalizedLwrAppBootstrapConfig;
     locker: RequiredLwrLockerConfig;
 }
-export declare const ROOT_ATTRIBUTE_KEYS: ["amdLoader", "apiVersion", "assets", "assetProviders", "assetTransformers", "bundleConfig", "cacheDir", "contentDir", "environment", "errorRoutes", "esmLoader", "staticSiteGenerator", "globalData", "globalDataDir", "hooks", "ignoreLwrConfigFile", "lwrConfigFile", "layoutsDir", "locker", "lwc", "lwrVersion", "moduleProviders", "port", "basePath", "resourceProviders", "rootDir", "routes", "serverMode", "serverType", "templateEngine", "viewProviders", "viewTransformers"];
+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 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"];
 export declare const ERROR_ROUTE_ATTRIBUTE_KEYS: ["bootstrap", "subRoutes", "contentTemplate", "id", "layoutTemplate", "rootComponent", "routeHandler", "status", "properties", "cache"];
-export declare const BOOTSTRAP_ATTRIBUTE_KEYS: ["autoBoot", "syntheticShadow", "workers", "services", "configAsSrc", "ssr"];
+export declare const BOOTSTRAP_ATTRIBUTE_KEYS: ["autoBoot", "syntheticShadow", "workers", "services", "configAsSrc", "ssr", "module", "preloadModules"];
 export declare const BASE_PATH_REGEX: RegExp;
 export declare class ValidationContext {
     diagnostics: Diagnostic[];

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

@@ -13,6 +13,7 @@ export const ROOT_ATTRIBUTE_KEYS = createKeys('root', [
     'assetProviders',
     'assetTransformers',
     'bundleConfig',
+    'bundleProviders',
     'cacheDir',
     'contentDir',
     'environment',
@@ -33,10 +34,11 @@ export const ROOT_ATTRIBUTE_KEYS = createKeys('root', [
     'basePath',
     'resourceProviders',
     'rootDir',
+    'routeHandlers',
     'routes',
     'serverMode',
+    'minify',
     'serverType',
-    'templateEngine',
     'viewProviders',
     'viewTransformers',
 ]);
@@ -75,6 +77,8 @@ export const BOOTSTRAP_ATTRIBUTE_KEYS = createKeys('bootstrap', [
     'services',
     'configAsSrc',
     'ssr',
+    'module',
+    'preloadModules',
 ]);
 const SPECIFIER_REGEX = /^@?[\w-]+(\/[\w-]+)*$/;
 function isNotEmptyString(node) {

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

@@ -13,16 +13,20 @@ export const SOURCE_BY_PHASE = {
  *      - autoBoot: optional boolean
  *      - syntheticShadow: optional boolean
  *      - workers: optional map of string:specifier pairs
+ *      - ssr: optional boolean
  *      - configAsSrc: optional boolean to include the client bootstrap config as src via in-lined
+ *      - module: optional string specifier
  */
 function validateBootstrap(node, validationContext, propPrefix) {
     if (node) {
         validationContext.assertIsObject(node, 'bootstrap');
         validationContext.assertValidKeys(node, 'bootstrap', BOOTSTRAP_ATTRIBUTE_KEYS);
         validationContext.assertArrayOfSpecifiers(findNode(node, ['services']), `${propPrefix}.services`);
+        validationContext.assertArrayOfSpecifiers(findNode(node, ['preloadModules']), `${propPrefix}.preloadModules`);
         validationContext.assertIsBoolean(findNode(node, ['autoBoot']), `${propPrefix}.autoBoot`);
         validationContext.assertIsBoolean(findNode(node, ['ssr']), `${propPrefix}.ssr`);
         validationContext.assertIsBoolean(findNode(node, ['configAsSrc']), `${propPrefix}.configAsSrc`);
+        validationContext.assertIsSpecifier(findNode(node, ['module']), `${propPrefix}.module`);
         validationContext.assertIsBoolean(findNode(node, ['syntheticShadow']), `${propPrefix}.syntheticShadow`);
         // Each value in the worker map msut be a specifier
         const workers = findNode(node, ['workers']);
@@ -68,9 +72,14 @@ function validateRouteCommon(node, validationContext, propPrefix) {
  *      - path: required path segment string
  *      - method: optional 'get' | 'post'
  */
-function validateRoutes(node, validationContext) {
+function validateRoutes(node, validationContext, preMerge) {
     if (node) {
-        validationContext.assertNotEmptyArray(node, 'routes');
+        // routes may not be defined until after config hooks are applied
+        // note: there are 2 "post" hooks (onConfig/onStart) that routes can be applied.
+        // We need to ensure that we only validate after the last one (if both are used)
+        if (!preMerge) {
+            validationContext.assertNotEmptyArray(node, 'routes');
+        }
         if (node.children) {
             node.children.forEach((n, index) => {
                 const propPrefix = `routes[${index}]`;
@@ -103,6 +112,11 @@ function validateErrorRoutes(node, validationContext) {
         }
     }
 }
+function validateRouteHandlers(node, validationContext) {
+    if (node) {
+        validationContext.assertIsObject(node, 'routeHandlers');
+    }
+}
 /**
  * Check string config.asset OR
  * Check array config.assets[]:
@@ -174,7 +188,7 @@ function validateLocker(node, validationContext) {
  *      - serverType: string
  *      - rootDir, cacheDir, contentDir, layoutsDir, globalDataDir: strings
  *      - hooks: array of strings
- *      - templateEngine: string
+ *      - bundleProviders: array of services
  *      - moduleProviders: array of services
  *      - viewProviders: array of services
  *      - resourceProviders: array of services
@@ -192,8 +206,9 @@ function validateRoot(node, validationContext, preMerge) {
     const routes = findNode(node, ['routes']);
     const errorRoutes = findNode(node, ['errorRoutes']);
     validationContext.assertUniqueIds([...(routes?.children || []), ...(errorRoutes?.children || [])], 'routes');
-    validateRoutes(routes, validationContext);
+    validateRoutes(routes, validationContext, preMerge);
     validateErrorRoutes(errorRoutes, validationContext);
+    validateRouteHandlers(findNode(node, ['routeHandlers']), validationContext);
     validateAssets(findNode(node, ['assets']), validationContext, preMerge);
     validateLocker(findNode(node, ['locker']), validationContext);
     validationContext.assertNotEmptyString(findNode(node, ['apiVersion']), 'apiVersion');
@@ -210,7 +225,7 @@ function validateRoot(node, validationContext, preMerge) {
     validationContext.assertNotEmptyString(findNode(node, ['layoutsDir']), 'layoutsDir');
     validationContext.assertNotEmptyString(findNode(node, ['globalDataDir']), 'globalDataDir');
     validationContext.assertArrayOfServices(findNode(node, ['hooks']), 'hooks');
-    validationContext.assertNotEmptyString(findNode(node, ['templateEngine']), 'templateEngine');
+    validationContext.assertArrayOfServices(findNode(node, ['bundleProviders']), 'bundleProviders');
     validationContext.assertArrayOfServices(findNode(node, ['moduleProviders']), 'moduleProviders');
     validationContext.assertArrayOfServices(findNode(node, ['viewProviders']), 'viewProviders');
     validationContext.assertArrayOfServices(findNode(node, ['resourceProviders']), 'resourceProviders');

package/package.cjs

@@ -1,9 +1,28 @@
 const fs = require('fs');
 const path = require('path');
+const resolve = require('resolve');
 const rootPath = path.join(__dirname, './');
-const version = JSON.parse(fs.readFileSync(path.join(rootPath, 'package.json'), 'utf-8')).version;
+
+// Get the LWR Version
+let version;
+if (globalThis.LWR_VERSION) {
+    version = globalThis.LWR_VERSION;
+} else {
+    version = JSON.parse(fs.readFileSync(path.join(rootPath, 'package.json'), 'utf-8')).version;
+}
+
+// Get the LWC Version
+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;
+}
 
 module.exports = {
     rootPath,
-    version
+    version,
+    lwcVersion
 };

package/package.json

@@ -4,15 +4,15 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.9.0-alpha.9",
+    "version": "0.9.0",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
-        "url": "https://github.com/salesforce/lwr.git",
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr.git",
         "directory": "packages/@lwrjs/config"
     },
     "bugs": {
-        "url": "https://github.com/salesforce/lwr/issues"
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr/issues"
     },
     "type": "module",
     "types": "build/es/index.d.ts",
@@ -23,6 +23,10 @@
             "import": "./build/es/index.js",
             "require": "./build/cjs/index.cjs"
         },
+        "./modules": {
+            "import": "./build/es/modules.js",
+            "require": "./build/cjs/modules.cjs"
+        },
         "./package": "./package.cjs"
     },
     "files": [
@@ -32,16 +36,19 @@
         "package.cjs"
     ],
     "dependencies": {
-        "@lwrjs/diagnostics": "0.9.0-alpha.9",
-        "@lwrjs/shared-utils": "0.9.0-alpha.9",
-        "fs-extra": "^10.1.0",
+        "@lwrjs/diagnostics": "0.9.0",
+        "@lwrjs/shared-utils": "0.9.0",
+        "fs-extra": "^11.1.0",
         "jsonc-parser": "^3.0.0"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.9.0-alpha.9"
+        "@lwrjs/types": "0.9.0"
+    },
+    "peerDependencies": {
+        "lwc": "2.x"
     },
     "engines": {
-        "node": ">=14.15.4 <19"
+        "node": ">=16.0.0 <20"
     },
-    "gitHead": "93522592d25375bb20da156f864d153ffcd3ec88"
+    "gitHead": "4e42b0dc5453f92b36b42aa8132c5bc281e616b7"
 }