@lwrjs/core 0.12.0-alpha.2 → 0.12.0-alpha.21

package/build/es/index.js

@@ -1,7 +1,7 @@
 import { getFeatureFlags, DEFAULT_LWR_BOOTSTRAP_CONFIG } from '@lwrjs/shared-utils';
 import { createInternalServer } from '@lwrjs/server';
 import { LwrServerError, createSingleDiagnosticError, descriptions, logger } from '@lwrjs/diagnostics';
-import { loadConfig, executeConfigHooks, executeStartHooks, executeInstrumentationHooks, } from '@lwrjs/config';
+import { loadConfig, executeConfigHooks, executeStartHooks, executeInstrumentationHooks, executeContextHooks, } from '@lwrjs/config';
 import { loadHooks, loadServices, loadRouteHandlers } from '@lwrjs/config/modules';
 import SiteGenerator from './tools/static-generation.js';
 import { warmupServer } from './tools/server-warmup.js';
@@ -47,12 +47,18 @@ async function initContext(appConfig, runtimeEnvironment, globalData) {
         const skipValidation = true; // skip for config hook, since `executeStartHooks` hook will validate
         await executeConfigHooks(hooks, appConfig, runtimeEnvironment, globalData, skipValidation);
         executeInstrumentationHooks(hooks);
-        executeStartHooks(hooks, appConfig, runtimeEnvironment);
     }
     // load all configurable modules
     const services = await loadServices(appConfig);
     // create all framework components(ie. registries)
     const serverContext = getTracer().trace({ name: CoreSpan.CreateServerContext }, () => createServerContext(appConfig, runtimeEnvironment, globalData));
+    // set routes on server context
+    const routeHandlers = await loadRouteHandlers(appConfig);
+    serverContext.routeHandlers = routeHandlers;
+    if (hooks.length) {
+        await executeContextHooks(hooks, serverContext);
+        executeStartHooks(hooks, appConfig, runtimeEnvironment);
+    }
     // create public subset of configurations
     const providerContext = createProviderContext(serverContext);
     const { moduleRegistry, assetRegistry, resourceRegistry, viewRegistry, moduleBundler } = serverContext;
@@ -82,30 +88,26 @@ async function initContext(appConfig, runtimeEnvironment, globalData) {
     viewRegistry.addViewTransformers(viewTransformers);
     // invoke async initialization
     await serverContext.viewRegistry.initializeViewProviders();
-    // set routes on server context
-    const routeHandlers = await loadRouteHandlers(appConfig);
-    serverContext.routeHandlers = routeHandlers;
     return serverContext;
 }
 export class LwrApp {
-    constructor(config = {}) {
+    constructor(configs) {
         this.initialized = false;
         const span = getTracer().startSpan({ name: CoreSpan.CreateServer });
-        const { appConfig, runtimeEnvironment, globalData } = loadConfig(config);
+        const { appConfig, runtimeEnvironment, globalData } = configs;
         this.config = appConfig;
         this.runtimeEnvironment = runtimeEnvironment;
         this.globalData = globalData;
-        const { basePath } = this.config;
-        this.app = createInternalServer(this.config.serverType, { basePath });
+        const { basePath, serverType } = this.config;
+        this.serverType = serverType;
+        this.app = createInternalServer(serverType, { basePath });
         this.server = this.app.createHttpServer();
+        this.use = this.app.use.bind(this.app);
+        this.all = this.app.all.bind(this.app);
+        this.get = this.app.get.bind(this.app);
+        this.post = this.app.post.bind(this.app);
         span.end();
     }
-    setConfig(config) {
-        const { appConfig, runtimeEnvironment, globalData } = loadConfig(config);
-        this.config = appConfig;
-        this.runtimeEnvironment = runtimeEnvironment;
-        this.globalData = globalData;
-    }
     getConfig() {
         return this.config;
     }
@@ -163,26 +165,17 @@ export class LwrApp {
             });
         });
     }
-    async close() {
-        this.server?.close && (await this.server.close());
+    close() {
+        this.server?.close && this.server.close();
     }
     // Get the underlying server (e.g. express, koa...)
     getInternalServer() {
         return this.app.getImpl();
     }
-    // Return the public server interface which is compatible with all server types
-    getServer() {
-        return {
-            use: this.app.use.bind(this.app),
-            all: this.app.all.bind(this.app),
-            get: this.app.get.bind(this.app),
-            post: this.app.post.bind(this.app),
-            getRegexWildcard: this.app.getRegexWildcard.bind(this.app),
-        };
-    }
 }
 export function createServer(config) {
-    return new LwrApp(config);
+    const configs = loadConfig(config);
+    return new LwrApp(configs);
 }
 export async function generateStaticSite(config) {
     config = config || {};

package/build/es/info/route-handler.d.ts

@@ -0,0 +1,3 @@
+import type { HandlerContext, ViewRequest, ViewResponse } from '@lwrjs/types';
+export default function siteInfoHandler(_request: ViewRequest, context: HandlerContext): Promise<ViewResponse>;
+//# sourceMappingURL=route-handler.d.ts.map

package/build/es/info/route-handler.js

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

package/build/es/middleware/asset-middleware.js

@@ -3,6 +3,30 @@ import { DiagnosticsError } from '@lwrjs/diagnostics';
 import { RequestHandlerSpan, getTracer } from '@lwrjs/instrumentation';
 import { getAssetIdentity } from './utils/identity.js';
 import { handleErrors } from './utils/error-handling.js';
+import fs from 'fs-extra';
+export function assetMiddleware(app, context) {
+    const paths = context.appConfig.assets.map((config) => {
+        const assetDirConfig = config;
+        let urlPath = config.urlPath;
+        // If this is a root config add a /:filename path to match any file in the root.  The middleware will fall through if there is no match.
+        if (assetDirConfig.root) {
+            urlPath = '/:filename';
+        }
+        else if (assetDirConfig.dir) {
+            urlPath += app.getRegexWildcard();
+        }
+        return urlPath;
+    });
+    app.get([
+        // De-dupe paths (i.e. root path may have been added more than once)
+        ...[...new Set(paths)],
+        '/:apiVersion/:assetType(asset|content-asset)/:immutable?/s/:signature/' + app.getRegexWildcard(),
+        '/:apiVersion/:assetType(asset|content-asset)/:immutable?/' + app.getRegexWildcard(),
+    ], handleErrors(createAssetMiddleware(context)));
+}
+/**
+ * Create middleware function to handle get assets requests
+ */
 function createAssetMiddleware(context) {
     const { assetRegistry, runtimeEnvironment: { basePath }, } = context;
     return async (req, res, next) => {
@@ -12,24 +36,22 @@ function createAssetMiddleware(context) {
             assetId.specifier = path.join(basePath, assetId.specifier);
         }
         try {
-            // Redirect if this is an external asset
+            let asset;
             const assetUri = await assetRegistry.resolveAssetUri(assetId, runtimeEnvironment);
+            // Check if this asset is available externally
             if (assetUri.external) {
-                res.set({
-                    Location: assetUri.uri,
-                    'cache-control': 'public, max-age=60',
-                });
-                res.sendStatus(302);
-                return;
+                // This asset is marked external but hit the middleware anyway
+                // Check if we have this file locally, if not, send a 302 to
+                // redirect to the external URL
+                asset = await getAssetDefinition(assetId, req, assetRegistry, signature, runtimeEnvironment);
+                // Verify the content actually exists locally
+                if (!fs.existsSync(asset.entry) && assetUri.uri.startsWith('/mobify/bundle')) {
+                    return sendRedirect(res, assetUri);
+                }
+            }
+            else {
+                asset = await getAssetDefinition(assetId, req, assetRegistry, signature, runtimeEnvironment);
             }
-            const asset = await getTracer().trace({
-                name: RequestHandlerSpan.GetAsset,
-                attributes: {
-                    specifier: assetId.specifier,
-                },
-            }, () => {
-                return assetRegistry.getAsset({ ...assetId, signature }, runtimeEnvironment, req.isSiteGeneration());
-            });
             if (req.isSiteGeneration()) {
                 res.setSiteGenerationMetadata({ asset });
             }
@@ -58,24 +80,29 @@ function createAssetMiddleware(context) {
         }
     };
 }
-export function assetMiddleware(app, context) {
-    const paths = context.appConfig.assets.map((config) => {
-        const assetDirConfig = config;
-        let urlPath = config.urlPath;
-        // If this is a root config add a /:filename path to match any file in the root.  The middleware will fall through if there is no match.
-        if (assetDirConfig.root) {
-            urlPath = '/:filename';
-        }
-        else if (assetDirConfig.dir) {
-            urlPath += app.getRegexWildcard();
-        }
-        return urlPath;
+/**
+ * Get the asset definition if asset is local
+ */
+async function getAssetDefinition(assetId, req, assetRegistry, signature, runtimeEnvironment) {
+    const asset = await getTracer().trace({
+        name: RequestHandlerSpan.GetAsset,
+        attributes: {
+            specifier: assetId.specifier,
+            url: req.originalUrl,
+        },
+    }, () => {
+        return assetRegistry.getAsset({ ...assetId, signature }, runtimeEnvironment, req.isSiteGeneration());
     });
-    app.get([
-        // De-dupe paths (i.e. root path may have been added more than once)
-        ...[...new Set(paths)],
-        '/:apiVersion/:assetType(asset|content-asset)/:immutable?/s/:signature/' + app.getRegexWildcard(),
-        '/:apiVersion/:assetType(asset|content-asset)/:immutable?/' + app.getRegexWildcard(),
-    ], handleErrors(createAssetMiddleware(context)));
+    return asset;
+}
+/**
+ * Send a redirect (302) response
+ */
+function sendRedirect(res, assetUri) {
+    res.set({
+        Location: assetUri.uri,
+        'cache-control': 'public, max-age=60',
+    });
+    res.sendStatus(302);
 }
 //# sourceMappingURL=asset-middleware.js.map

package/build/es/middleware/bundle-middleware.js

@@ -20,6 +20,12 @@ function createBundleMiddleware(context) {
             res.send(descriptions.UNRESOLVABLE.INVALID_JSON().message);
             return;
         }
+        if (!req.validateApiVersion(appConfig)) {
+            res.status(400);
+            res.send(descriptions.UNRESOLVABLE.INVALID_API_VERSION(req.params.apiVersion, appConfig.apiVersion)
+                .message);
+            return;
+        }
         const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(defaultRuntimeEnvironment);
         const importer = req.query.importer
             ? await getRequestImporter(req, moduleRegistry, runtimeParams)
@@ -34,6 +40,7 @@ function createBundleMiddleware(context) {
             name: RequestHandlerSpan.GetBundle,
             attributes: {
                 specifier: moduleId.specifier,
+                url: req.originalUrl,
             },
         }, () => {
             return moduleBundler.getModuleBundle(moduleId, 

package/build/es/middleware/mapping-middleware.js

@@ -15,6 +15,9 @@ function createMappingMiddleware(context) {
         const { moduleIds } = getMappingIdentity(req);
         const importMetadata = await getTracer().trace({
             name: RequestHandlerSpan.GetMapping,
+            attributes: {
+                url: req.originalUrl,
+            },
         }, () => {
             return getImportMetadataMappings(moduleIds, runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler);
         });

package/build/es/middleware/module-middleware.js

@@ -19,6 +19,12 @@ function createModuleMiddleware(context) {
             res.send(descriptions.UNRESOLVABLE.INVALID_JSON().message);
             return;
         }
+        if (!req.validateApiVersion(appConfig)) {
+            res.status(400);
+            res.send(descriptions.UNRESOLVABLE.INVALID_API_VERSION(req.params.apiVersion, appConfig.apiVersion)
+                .message);
+            return;
+        }
         const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(defaultRuntimeEnvironment);
         const importer = req.query.importer
             ? await getRequestImporter(req, moduleRegistry, runtimeParams)
@@ -32,6 +38,7 @@ function createModuleMiddleware(context) {
             name: RequestHandlerSpan.GetModule,
             attributes: {
                 specifier: moduleId.specifier,
+                url: req.originalUrl,
             },
         }, () => {
             return moduleRegistry.getLinkedModule(moduleId, 

package/build/es/middleware/request-processor-middleware.js

@@ -7,15 +7,21 @@
  *
  */
 import { logger } from '@lwrjs/diagnostics';
+import { parseRequestDepthHeader } from '@lwrjs/shared-utils';
 const MRT_REQUEST_CLASS = 'X-Mobify-Request-Class';
 const MRT_REQUEST_CLASS_KEY = MRT_REQUEST_CLASS.toLowerCase();
 export function requestProcessorMiddleware(app, context) {
     const { basePath } = context.runtimeEnvironment;
-    app.use(async (req, _res, next) => {
+    app.use(async (req, res, next) => {
         let requestClass;
+        let requestDepth;
         if (req.headers) {
             // If debug print log all the headers
             if (logger.isDebugEnabled()) {
+                logger.debug({
+                    label: `request-processor-middleware`,
+                    message: `Request: ${req.originalUrl}`,
+                });
                 // Loop through and print each header
                 for (const headerName in req.headers) {
                     logger.debug({
@@ -25,6 +31,16 @@ export function requestProcessorMiddleware(app, context) {
                 }
             }
             requestClass = req.headers[MRT_REQUEST_CLASS_KEY];
+            requestDepth = parseRequestDepthHeader(req.headers);
+        }
+        // TODO Clean up once we have a long term solution
+        if (requestDepth && requestDepth > 0) {
+            logger.error({
+                label: 'request-processor-middleware',
+                message: `Lambda SSR request cycle detected: ${req.originalUrl}`,
+            });
+            // Return 400 Too Many Requests status
+            return res.status(400).send('Request depth limit reached');
         }
         if (req.headers && typeof requestClass === 'string') {
             const parsedRequestClass = parseRequestClass(requestClass);

package/build/es/middleware/utils/error-handling.js

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

package/build/es/middleware/utils/identity.js

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

package/build/es/middleware/view-middleware.js

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

package/build/es/tools/static-generation.d.ts

@@ -40,6 +40,10 @@ export default class SiteGenerator {
      * @param dispatcher - Network dispatcher
      */
     private handleJavascriptResource;
+    /**
+     * If this is a file based external copy it to the site folder and add it to the bundle metadata
+     */
+    private handleExternalBundle;
     private addBundleToSiteMetadata;
     private addResourceToSiteMetadata;
     private addAssetToSiteMetadata;

package/build/es/tools/static-generation.js

@@ -1,12 +1,13 @@
 import { performance } from 'perf_hooks';
 import { logger } from '@lwrjs/diagnostics';
-import { getSpecifier, getFeatureFlags, hashContent, isSelfUrl, getModuleUriPrefix, getMappingUriPrefix, isExternalUrl, mimeLookup, getViewUri, sortLocalesByFallback, } from '@lwrjs/shared-utils';
+import { getSpecifier, getFeatureFlags, hashContent, isSelfUrl, getModuleUriPrefix, getMappingUriPrefix, isExternalUrl, mimeLookup, getViewUri, sortLocalesByFallback, VERSION_NOT_PROVIDED, PROTOCOL_FILE, normalizeFromFileURL, } from '@lwrjs/shared-utils';
 import { SiteMetadataImpl } from '@lwrjs/static/site-metadata';
 import { join, dirname, extname, normalize } from 'path';
 import fs from 'fs-extra';
 import { writeResponse } from './utils/stream.js';
 import { createResourceDir } from './utils/dir.js';
 import { getRuntimeEnvironment } from '@lwrjs/config';
+import { fileURLToPath } from 'url';
 export default class SiteGenerator {
     /**
      * Build a static site in the configured directory
@@ -198,6 +199,14 @@ export default class SiteGenerator {
      */
     async handleJavascriptResource(url, context, siteConfig, dispatcher) {
         const { outputDir } = siteConfig;
+        const moduleDefinition = context.fs?.metadata?.moduleDefinition; // LinkedModuleDefinition | BundleDefinition
+        const externals = moduleDefinition?.config?.external || {};
+        const siteBundles = siteConfig?.siteMetadata?.getSiteBundles()?.bundles;
+        const specifier = moduleDefinition?.specifier;
+        if (externals && siteBundles && externals[specifier]) {
+            this.handleExternalBundle(specifier, siteBundles, externals, outputDir);
+            return;
+        }
         const normalizedUrl = decodeURIComponent(url);
         createResourceDir(dirname(normalizedUrl), outputDir);
         const ext = extname(normalizedUrl);
@@ -223,26 +232,33 @@ export default class SiteGenerator {
             siteConfig.urlRewriteMap.set(url.substring(0, url.indexOf('%2Fv%2F')), normalizedUrl);
         }
         // Recursively traverse dependencies
-        const moduleDefinition = context.fs?.metadata?.moduleDefinition; // LinkedModuleDefinition | BundleDefinition
         if (moduleDefinition) {
             // Imports
             const imports = moduleDefinition.linkedModuleRecord?.imports || moduleDefinition.bundleRecord?.imports || [];
             // /1/module/esm/0/l/en-US/mi/lwc
             for (const importModule of imports) {
-                const jsUri = importModule.specifier.startsWith('/')
-                    ? importModule.specifier
-                    : getSpecifier(importModule);
-                dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+                const specifier = importModule.specifier;
+                if (externals[specifier]) {
+                    this.handleExternalBundle(specifier, siteBundles, externals, outputDir);
+                }
+                else {
+                    const jsUri = specifier.startsWith('/') ? specifier : getSpecifier(importModule);
+                    dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+                }
             }
             // Dynamic imports
             const dynamicImports = moduleDefinition.linkedModuleRecord?.dynamicImports ||
                 moduleDefinition.bundleRecord?.dynamicImports ||
                 [];
             for (const importModule of dynamicImports) {
-                const jsUri = importModule.specifier.startsWith('/')
-                    ? importModule.specifier
-                    : getSpecifier(importModule);
-                dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+                const specifier = importModule.specifier;
+                if (externals[specifier]) {
+                    this.handleExternalBundle(specifier, siteBundles, externals, outputDir);
+                }
+                else {
+                    const jsUri = specifier.startsWith('/') ? specifier : getSpecifier(importModule);
+                    dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+                }
             }
             // If this is a bundle add it to the bundle metadata
             if (moduleDefinition.bundleRecord) {
@@ -257,6 +273,25 @@ export default class SiteGenerator {
         // -- Dispatch dependencies
         await Promise.all(dispatchRequests);
     }
+    /**
+     * If this is a file based external copy it to the site folder and add it to the bundle metadata
+     */
+    handleExternalBundle(specifier, siteBundles, externals, outputDir) {
+        if (siteBundles && externals[specifier]?.startsWith(PROTOCOL_FILE) && !siteBundles[specifier]) {
+            const path = normalizeFromFileURL(externals[specifier], process.cwd());
+            const normalizedPath = decodeURIComponent(path);
+            createResourceDir(dirname(normalizedPath), outputDir);
+            const ext = extname(normalizedPath);
+            const fullPath = join(outputDir, `${normalizedPath}${ext ? '' : '.js'}`);
+            fs.copyFileSync(fileURLToPath(externals[specifier]), fullPath);
+            const bundleMetadata = {
+                specifier,
+                path: normalizedPath,
+                imports: [],
+            };
+            siteBundles[specifier] = bundleMetadata;
+        }
+    }
     addBundleToSiteMetadata(bundleDefinition, url, siteConfig) {
         if (siteConfig.siteMetadata) {
             const locale = siteConfig.locale;
@@ -265,8 +300,9 @@ export default class SiteGenerator {
                 : `${bundleDefinition.specifier}|l/${locale}`;
             const imports = bundleDefinition.bundleRecord.imports?.map((moduleRef) => getSpecifier(moduleRef)) || [];
             const dynamicImports = bundleDefinition.bundleRecord.dynamicImports?.map((moduleRef) => getSpecifier(moduleRef));
+            const version = bundleDefinition.version === VERSION_NOT_PROVIDED ? undefined : bundleDefinition.version;
             const bundleMetadata = {
-                version: bundleDefinition.version,
+                version,
                 path: decodeURIComponent(url),
                 includedModules: bundleDefinition.bundleRecord.includedModules || [],
                 imports,