@lwrjs/config 0.9.0-alpha.17 → 0.9.0-alpha.18

package/build/cjs/defaults.cjs

@@ -119,6 +119,7 @@ var DEFAULT_LWR_CONFIG = {
   lwc: {modules: []},
   routes: [],
   errorRoutes: [],
+  routeHandlers: {},
   bundleConfig: {exclude: DEFAULT_BUNDLE_EXCLUSIONS},
   serverType: DEFAULT_SERVER_TYPE,
   locker: import_shared_utils.DEFAULT_LWR_LOCKER_CONFIG

package/build/cjs/global-config.cjs

@@ -90,8 +90,8 @@ function normalizeConfig(config) {
     resourceProviders: (0, import_services.normalizeServices)(config.resourceProviders),
     viewProviders: (0, import_services.normalizeServices)(config.viewProviders),
     viewTransformers: (0, import_services.normalizeServices)(config.viewTransformers),
-    routes: (0, import_routes.normalizeRoutes)(config.routes),
-    errorRoutes: (0, import_routes.normalizeRoutes)(config.errorRoutes)
+    routes: (0, import_routes.normalizeRoutes)(config.routes, config.routeHandlers),
+    errorRoutes: (0, import_routes.normalizeRoutes)(config.errorRoutes, config.routeHandlers)
   };
 }
 function normalizeConfigPaths(config) {
@@ -120,7 +120,8 @@ function normalizeConfigPaths(config) {
     viewProviders: (0, import_services.normalizeServicePaths)(config.viewProviders, rootDir),
     viewTransformers: (0, import_services.normalizeServicePaths)(config.viewTransformers, rootDir),
     routes: (0, import_routes.normalizeRoutePaths)(config.routes, resourcePaths),
-    errorRoutes: (0, import_routes.normalizeRoutePaths)(config.errorRoutes, resourcePaths)
+    errorRoutes: (0, import_routes.normalizeRoutePaths)(config.errorRoutes, resourcePaths),
+    routeHandlers: (0, import_routes.normalizeRouteHandlerPaths)(config.routeHandlers, resourcePaths)
   };
 }
 function resolveGlobalConfig(configArg, options) {

package/build/cjs/hooks.cjs

@@ -39,8 +39,8 @@ async function executeConfigHooks(hooks, globalConfig, runtimeEnvironment, globa
     }
     await hook.initConfigs(globalConfig, globalData, runtimeEnvironment);
   }
-  globalConfig.routes = (0, import_routes.normalizeRoutes)(globalConfig.routes);
-  globalConfig.errorRoutes = (0, import_routes.normalizeRoutes)(globalConfig.errorRoutes);
+  globalConfig.routes = (0, import_routes.normalizeRoutes)(globalConfig.routes, globalConfig.routeHandlers);
+  globalConfig.errorRoutes = (0, import_routes.normalizeRoutes)(globalConfig.errorRoutes, globalConfig.routeHandlers);
   (0, import_app_config.validateLwrAppConfig)(globalConfig, "post");
 }
 function executeStartHooks(hooks, globalConfig) {
@@ -53,6 +53,6 @@ function executeStartHooks(hooks, globalConfig) {
     }
     hook.onStart(globalConfig.routes);
   }
-  globalConfig.routes = (0, import_routes.normalizeRoutes)(globalConfig.routes);
+  globalConfig.routes = (0, import_routes.normalizeRoutes)(globalConfig.routes, globalConfig.routeHandlers);
   (0, import_app_config.validateLwrAppConfig)(globalConfig, "post");
 }

package/build/cjs/modules.cjs

@@ -25,7 +25,7 @@ var __toModule = (module2) => {
 __markAsModule(exports);
 __export(exports, {
   loadHooks: () => loadHooks,
-  loadRoutes: () => loadRoutes,
+  loadRouteHandlers: () => loadRouteHandlers,
   loadServices: () => loadServices
 });
 var import_path = __toModule(require("path"));
@@ -57,26 +57,6 @@ async function loadServiceEntries(entries, rootDir, cacheDir) {
     return [ctor, config];
   }));
 }
-async function loadRouteHandlers(routes, rootDir, cacheDir) {
-  const cache = {};
-  return Promise.all(routes.map(async (route) => {
-    if (!route.routeHandler) {
-      return route;
-    }
-    if (cache[route.routeHandler]) {
-      return {
-        ...route,
-        routeHandler: cache[route.routeHandler]
-      };
-    }
-    const routeHandler = await importModule(route.routeHandler, rootDir, import_path.default.join(cacheDir, "routeHandlers"));
-    cache[route.routeHandler] = routeHandler;
-    return {
-      ...route,
-      routeHandler
-    };
-  }));
-}
 async function loadHooks(config) {
   if (!config.hooks) {
     return [];
@@ -105,11 +85,12 @@ async function loadServices(config) {
     viewTransformers
   };
 }
-async function loadRoutes(config) {
-  const routes = await loadRouteHandlers(config.routes, config.rootDir, config.cacheDir);
-  const errorRoutes = await loadRouteHandlers(config.errorRoutes, config.rootDir, config.cacheDir);
-  return {
-    routes,
-    errorRoutes
-  };
+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, import_path.default.join(config.cacheDir, "routeHandlers"));
+    routeHandlers[id] = handler;
+  }));
+  return routeHandlers;
 }

package/build/cjs/utils/routes.cjs

@@ -24,27 +24,45 @@ var __toModule = (module2) => {
 // packages/@lwrjs/config/src/utils/routes.ts
 __markAsModule(exports);
 __export(exports, {
+  normalizeRouteHandlerPaths: () => normalizeRouteHandlerPaths,
   normalizeRoutePaths: () => normalizeRoutePaths,
   normalizeRoutes: () => normalizeRoutes
 });
 var import_path = __toModule(require("path"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-function normalizeRoutes(routes = []) {
-  return routes.map((route) => ({
-    ...route,
-    bootstrap: {
-      ...import_shared_utils.DEFAULT_LWR_BOOTSTRAP_CONFIG,
-      ...route.bootstrap
+function normalizeRoutes(routes, routeHandlers) {
+  return routes.map((route) => {
+    if (route.routeHandler && !routeHandlers[route.routeHandler]) {
+      const handlerPath = route.routeHandler;
+      routeHandlers[handlerPath] = handlerPath;
     }
-  }));
+    return {
+      ...route,
+      bootstrap: {
+        ...import_shared_utils.DEFAULT_LWR_BOOTSTRAP_CONFIG,
+        ...route.bootstrap
+      }
+    };
+  });
 }
 function normalizeRoutePaths(routes = [], resourcePaths) {
   return routes.map((route) => {
-    const {routeHandler, contentTemplate, layoutTemplate, subRoutes} = route;
-    route.routeHandler = routeHandler && import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(routeHandler, resourcePaths.rootDir));
-    route.contentTemplate = contentTemplate && import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(contentTemplate, resourcePaths));
-    route.layoutTemplate = layoutTemplate && import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(layoutTemplate, resourcePaths));
-    route.subRoutes = subRoutes && import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(subRoutes, resourcePaths));
+    const {contentTemplate, layoutTemplate, subRoutes} = route;
+    if (contentTemplate) {
+      route.contentTemplate = import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(contentTemplate, resourcePaths));
+    }
+    if (layoutTemplate) {
+      route.layoutTemplate = import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(layoutTemplate, resourcePaths));
+    }
+    if (subRoutes) {
+      route.subRoutes = import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(subRoutes, resourcePaths));
+    }
     return route;
   });
 }
+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));
+  }
+  return routeHandlers;
+}

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

@@ -67,6 +67,7 @@ var ROOT_ATTRIBUTE_KEYS = createKeys("root", [
   "basePath",
   "resourceProviders",
   "rootDir",
+  "routeHandlers",
   "routes",
   "serverMode",
   "serverType",

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

@@ -101,6 +101,11 @@ function validateErrorRoutes(node, validationContext) {
     }
   }
 }
+function validateRouteHandlers(node, validationContext) {
+  if (node) {
+    validationContext.assertIsObject(node, "routeHandlers");
+  }
+}
 function validateAssets(node, validationContext, preMerge) {
   if (node) {
     if (preMerge && node.type === "string") {
@@ -147,6 +152,7 @@ function validateRoot(node, validationContext, preMerge) {
   validationContext.assertUniqueIds([...routes?.children || [], ...errorRoutes?.children || []], "routes");
   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);
   validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["apiVersion"]), "apiVersion");

package/build/es/defaults.js

@@ -83,6 +83,7 @@ export const DEFAULT_LWR_CONFIG = {
     lwc: { modules: [] },
     routes: [],
     errorRoutes: [],
+    routeHandlers: {},
     bundleConfig: { exclude: DEFAULT_BUNDLE_EXCLUSIONS },
     serverType: DEFAULT_SERVER_TYPE,
     locker: DEFAULT_LWR_LOCKER_CONFIG,

package/build/es/global-config.js

@@ -6,7 +6,7 @@ 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 { normalizeRoutePaths, normalizeRoutes } from './utils/routes.js';
+import { normalizeRouteHandlerPaths, normalizeRoutePaths, normalizeRoutes } 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';
@@ -118,9 +118,9 @@ function normalizeConfig(config) {
         resourceProviders: normalizeServices(config.resourceProviders),
         viewProviders: normalizeServices(config.viewProviders),
         viewTransformers: normalizeServices(config.viewTransformers),
-        // normalize all routes
-        routes: normalizeRoutes(config.routes),
-        errorRoutes: normalizeRoutes(config.errorRoutes),
+        // normalize routes and capture all route handlers
+        routes: normalizeRoutes(config.routes, config.routeHandlers),
+        errorRoutes: normalizeRoutes(config.errorRoutes, config.routeHandlers),
     };
 }
 /**
@@ -162,6 +162,7 @@ function normalizeConfigPaths(config) {
         // normalize all route paths
         routes: normalizeRoutePaths(config.routes, resourcePaths),
         errorRoutes: normalizeRoutePaths(config.errorRoutes, resourcePaths),
+        routeHandlers: normalizeRouteHandlerPaths(config.routeHandlers, resourcePaths),
     };
 }
 /**

package/build/es/hooks.js

@@ -25,8 +25,8 @@ export async function executeConfigHooks(hooks, globalConfig, runtimeEnvironment
         // eslint-disable-next-line no-await-in-loop
         await hook.initConfigs(globalConfig, globalData, runtimeEnvironment);
     }
-    globalConfig.routes = normalizeRoutes(globalConfig.routes);
-    globalConfig.errorRoutes = normalizeRoutes(globalConfig.errorRoutes);
+    globalConfig.routes = normalizeRoutes(globalConfig.routes, globalConfig.routeHandlers);
+    globalConfig.errorRoutes = normalizeRoutes(globalConfig.errorRoutes, globalConfig.routeHandlers);
     validateLwrAppConfig(globalConfig, 'post');
 }
 /**
@@ -53,7 +53,7 @@ export function executeStartHooks(hooks, globalConfig) {
         }
         hook.onStart(globalConfig.routes);
     }
-    globalConfig.routes = normalizeRoutes(globalConfig.routes);
+    globalConfig.routes = normalizeRoutes(globalConfig.routes, globalConfig.routeHandlers);
     validateLwrAppConfig(globalConfig, 'post');
 }
 //# sourceMappingURL=hooks.js.map

package/build/es/modules.d.ts

@@ -1,8 +1,4 @@
-import type { HooksPlugin, NormalizedLwrErrorRoute, NormalizedLwrGlobalConfig, NormalizedLwrRoute, Route, Services } from '@lwrjs/types';
-export interface Routes {
-    routes: Route<NormalizedLwrRoute>[];
-    errorRoutes: Route<NormalizedLwrErrorRoute>[];
-}
+import type { HooksPlugin, NormalizedLwrGlobalConfig, RouteHandlers, Services } from '@lwrjs/types';
 /**
  * Import and instantiate hooks defined in the global config
  *
@@ -30,7 +26,7 @@ export declare function loadServices(config: NormalizedLwrGlobalConfig): Promise
  * The optional dependency `esbuild` MUST be installed to load route handler modules.
  *
  * @param config - global config
- * @returns {Routes} all routes with resolved route handlers
+ * @returns {Routes} resolved route handlers mapped by id
  */
-export declare function loadRoutes(config: NormalizedLwrGlobalConfig): Promise<Routes>;
+export declare function loadRouteHandlers(config: NormalizedLwrGlobalConfig): Promise<RouteHandlers>;
 //# sourceMappingURL=modules.d.ts.map

package/build/es/modules.js

@@ -30,26 +30,6 @@ async function loadServiceEntries(entries, rootDir, cacheDir) {
         return [ctor, config];
     }));
 }
-async function loadRouteHandlers(routes, rootDir, cacheDir) {
-    const cache = {};
-    return Promise.all(routes.map(async (route) => {
-        if (!route.routeHandler) {
-            return route;
-        }
-        if (cache[route.routeHandler]) {
-            return {
-                ...route,
-                routeHandler: cache[route.routeHandler],
-            };
-        }
-        const routeHandler = await importModule(route.routeHandler, rootDir, path.join(cacheDir, 'routeHandlers'));
-        cache[route.routeHandler] = routeHandler;
-        return {
-            ...route,
-            routeHandler,
-        };
-    }));
-}
 /**
  * Import and instantiate hooks defined in the global config
  *
@@ -103,14 +83,15 @@ export async function loadServices(config) {
  * The optional dependency `esbuild` MUST be installed to load route handler modules.
  *
  * @param config - global config
- * @returns {Routes} all routes with resolved route handlers
+ * @returns {Routes} resolved route handlers mapped by id
  */
-export async function loadRoutes(config) {
-    const routes = await loadRouteHandlers(config.routes, config.rootDir, config.cacheDir);
-    const errorRoutes = await loadRouteHandlers(config.errorRoutes, config.rootDir, config.cacheDir);
-    return {
-        routes,
-        errorRoutes,
-    };
+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/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,10 +12,11 @@ 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", "viewProviders", "viewTransformers"];
+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", "routeHandlers", "routes", "serverMode", "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"];

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

@@ -33,6 +33,7 @@ export const ROOT_ATTRIBUTE_KEYS = createKeys('root', [
     'basePath',
     'resourceProviders',
     'rootDir',
+    'routeHandlers',
     'routes',
     'serverMode',
     'serverType',

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

@@ -106,6 +106,11 @@ function validateErrorRoutes(node, validationContext) {
         }
     }
 }
+function validateRouteHandlers(node, validationContext) {
+    if (node) {
+        validationContext.assertIsObject(node, 'routeHandlers');
+    }
+}
 /**
  * Check string config.asset OR
  * Check array config.assets[]:
@@ -196,6 +201,7 @@ function validateRoot(node, validationContext, preMerge) {
     validationContext.assertUniqueIds([...(routes?.children || []), ...(errorRoutes?.children || [])], 'routes');
     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');

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.9.0-alpha.17",
+    "version": "0.9.0-alpha.18",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -36,16 +36,16 @@
         "package.cjs"
     ],
     "dependencies": {
-        "@lwrjs/diagnostics": "0.9.0-alpha.17",
-        "@lwrjs/shared-utils": "0.9.0-alpha.17",
+        "@lwrjs/diagnostics": "0.9.0-alpha.18",
+        "@lwrjs/shared-utils": "0.9.0-alpha.18",
         "fs-extra": "^10.1.0",
         "jsonc-parser": "^3.0.0"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.9.0-alpha.17"
+        "@lwrjs/types": "0.9.0-alpha.18"
     },
     "engines": {
         "node": ">=14.15.4 <19"
     },
-    "gitHead": "447417ff091802927b25cfc1bcb01da02264f41b"
+    "gitHead": "0d612ec0c74c679ce422f7bbae9fae14134f7d9f"
 }