@lwrjs/core 0.9.0-alpha.1 → 0.9.0-alpha.10

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

@@ -0,0 +1,64 @@
+import { explodeSpecifier, explodeSpecifiers, LATEST_SIGNATURE } from '@lwrjs/shared-utils';
+import { createSingleDiagnosticError, descriptions, LwrUnresolvableError } from '@lwrjs/diagnostics';
+function validateSpecifier(specifer) {
+    return specifer.indexOf('../') < 0;
+}
+export function getModuleIdentity(req, importer) {
+    const { specifier, signature } = req.params;
+    if (validateSpecifier(specifier) === false) {
+        throw createSingleDiagnosticError({
+            description: descriptions.UNRESOLVABLE.INVALID_SPECIFIER(specifier),
+        }, LwrUnresolvableError);
+    }
+    const moduleId = explodeSpecifier(specifier);
+    return {
+        moduleId: {
+            ...moduleId,
+            importer,
+        },
+        signature,
+    };
+}
+export function getMappingIdentity(req) {
+    const { specifiers } = req.params;
+    const moduleIds = explodeSpecifiers(specifiers).map((obj) => ({
+        ...obj,
+        importer: req.query.importer,
+    }));
+    return {
+        moduleIds,
+    };
+}
+export function getResourceIdentity(req) {
+    const { specifier, signature = LATEST_SIGNATURE } = req.params;
+    if (validateSpecifier(specifier) === false) {
+        throw createSingleDiagnosticError({
+            description: descriptions.UNRESOLVABLE.INVALID_SPECIFIER(specifier),
+        }, LwrUnresolvableError);
+    }
+    const resourceId = explodeSpecifier(specifier);
+    return {
+        resourceId,
+        signature,
+    };
+}
+export function getAssetIdentity(req) {
+    const { signature, immutable, assetType: type } = req.params;
+    const specifier = signature && type ? '/' + req.params[0] : req.originalUrl.split('?')[0];
+    if (immutable) {
+        // WIP: ?
+    }
+    if (validateSpecifier(specifier) === false) {
+        throw createSingleDiagnosticError({
+            description: descriptions.UNRESOLVABLE.INVALID_SPECIFIER(specifier),
+        }, LwrUnresolvableError);
+    }
+    return {
+        assetId: {
+            specifier,
+            type,
+        },
+        signature: signature || LATEST_SIGNATURE,
+    };
+}
+//# sourceMappingURL=identity.js.map

package/build/es/middleware/utils/metadata.d.ts

@@ -0,0 +1,3 @@
+import { BundleDefinition, ModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+export declare function normalizeResolvedUris(bundleDefinition: BundleDefinition, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams, moduleRegistry: ModuleRegistry): Promise<string[]>;
+//# sourceMappingURL=metadata.d.ts.map

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

@@ -0,0 +1,28 @@
+import { getVersionedModuleId } from '@lwrjs/shared-utils';
+export async function normalizeResolvedUris(bundleDefinition, runtimeEnvironment, runtimeParams, moduleRegistry) {
+    const resolvedUris = [];
+    // TODO might be able to remove this in the future but not sure how to properly send
+    // back bundleRecord imports with absolute uris (lwc is the main one)
+    if (bundleDefinition.bundleRecord.imports) {
+        for (const theImport of bundleDefinition.bundleRecord.imports) {
+            const childSpecifier = theImport.specifier;
+            // eslint-disable-next-line no-await-in-loop
+            const id = await getVersionedModuleId(childSpecifier, moduleRegistry);
+            // eslint-disable-next-line no-await-in-loop
+            const uri = await moduleRegistry.resolveModuleUri(id, runtimeEnvironment, runtimeParams);
+            resolvedUris.push(uri);
+        }
+    }
+    if (bundleDefinition.bundleRecord.dynamicImports) {
+        for (const theImport of bundleDefinition.bundleRecord.dynamicImports) {
+            const childSpecifier = theImport.specifier;
+            // eslint-disable-next-line no-await-in-loop
+            const id = await getVersionedModuleId(childSpecifier, moduleRegistry);
+            // eslint-disable-next-line no-await-in-loop
+            const uri = await moduleRegistry.resolveModuleUri(id, runtimeEnvironment, runtimeParams);
+            resolvedUris.push(uri);
+        }
+    }
+    return resolvedUris;
+}
+//# sourceMappingURL=metadata.js.map

package/build/es/middleware/utils/request.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import type { MiddlewareRequest, ModuleRegistry } from '@lwrjs/types';
+import http from 'http';
+import qs from 'qs';
+interface Params {
+    [key: string]: string;
+}
+export declare function getRequestProperties(pattern: string, req: http.IncomingMessage): {
+    url: string;
+    params: Params;
+    query: qs.ParsedQs;
+} | undefined;
+export declare function getRequestImporter(req: MiddlewareRequest, moduleRegistry: ModuleRegistry): Promise<string>;
+export {};
+//# sourceMappingURL=request.d.ts.map

package/build/es/{middlewares/utils.js → middleware/utils/request.js}

@@ -1,5 +1,12 @@
-import { pathToRegexp } from 'path-to-regexp';
 import qs from 'qs';
+import { pathToRegexp } from 'path-to-regexp';
+import { explodeSpecifier } from '@lwrjs/shared-utils';
+function decodeParam(val) {
+    if (typeof val !== 'string' || val.length === 0) {
+        return val;
+    }
+    return decodeURIComponent(val);
+}
 // Adapted from https://github.com/expressjs/express/blob/master/lib/router/layer.js
 export function getRequestProperties(pattern, req) {
     const { url = '/' } = req;
@@ -13,7 +20,7 @@ export function getRequestProperties(pattern, req) {
         for (let i = 1; i < matched.length; i++) {
             const key = keys[i - 1];
             const prop = key.name;
-            const val = decode_param(matched[i]);
+            const val = decodeParam(matched[i]);
             if (val !== undefined || !Object.hasOwnProperty.call(params, prop)) {
                 params[prop] = val;
             }
@@ -26,25 +33,10 @@ export function getRequestProperties(pattern, req) {
     }
     return;
 }
-/**
- * Check if the target environment is supported by the application
- *
- * @param environmentConfig - environment property from app config
- * @param targetEnvironment - environment value from module uri
- * @returns boolean
- */
-export function isSupportedEnvironment(environmentConfig, targetEnvironment) {
-    if (!!targetEnvironment &&
-        targetEnvironment !== environmentConfig?.default &&
-        !environmentConfig?.supported?.includes(targetEnvironment)) {
-        return false;
-    }
-    return true;
-}
-function decode_param(val) {
-    if (typeof val !== 'string' || val.length === 0) {
-        return val;
-    }
-    return decodeURIComponent(val);
+export async function getRequestImporter(req, moduleRegistry) {
+    const importerSpecifier = req.query.importer;
+    const importerModuleId = explodeSpecifier(importerSpecifier);
+    const { entry } = await moduleRegistry.getModuleEntry(importerModuleId);
+    return entry;
 }
-//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=request.js.map

package/build/es/middleware/view-middleware.d.ts

@@ -0,0 +1,3 @@
+import type { InternalAppServer, ServerContext, ServerTypes } from '@lwrjs/types';
+export declare function viewMiddleware<T extends ServerTypes>(app: InternalAppServer<T>, context: ServerContext): void;
+//# sourceMappingURL=view-middleware.d.ts.map

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

@@ -0,0 +1,139 @@
+import { descriptions } from '@lwrjs/diagnostics';
+import { getClientRoutes } from '@lwrjs/router';
+import { decodeViewPath, extractRequestParams, getClientBootstrapConfigurationRoutes, shortestTtl, } from '@lwrjs/shared-utils';
+import { handleErrors } from './utils/error-handling.js';
+import { LwrViewHandler } from '@lwrjs/view-registry';
+const CANONICAL_VIEW_ROUTES = [
+    `/:apiVersion/application/:format/l/:locale/ai/:appId`,
+    `/:apiVersion/application/:format/l/:locale/e/:environment/ai/:appId`,
+    `/:apiVersion/application/:format/ai/:appId`,
+    `/:apiVersion/application/:format/e/:environment/ai/:appId`,
+];
+function createViewMiddleware(route, context, viewHandler) {
+    const { appConfig } = context;
+    const errorRoute = appConfig.errorRoutes.find((route) => route.status === 500);
+    return async (req, res) => {
+        if (!req.validateEnvironmentRequest(context.appConfig)) {
+            res.status(400);
+            res.send(descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
+            return;
+        }
+        if (!req.validateJsonRequest()) {
+            res.status(400);
+            res.send(descriptions.UNRESOLVABLE.INVALID_JSON().message);
+            return;
+        }
+        const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(context.runtimeEnvironment);
+        // set the default environment if an environment is configured in the app config
+        const { environment: environmentConfig } = context.appConfig;
+        if (!runtimeParams.environment && environmentConfig?.default) {
+            runtimeParams.environment = environmentConfig.default;
+        }
+        const viewRequest = {
+            url: req.originalUrl,
+            params: req.params,
+            query: req.query,
+            requestPath: req.path,
+        };
+        const resolve = req.isJsonRequest() ? viewHandler.getViewJson : viewHandler.getViewContent;
+        let viewResponse;
+        let resolvedRoute;
+        try {
+            viewResponse = await resolve.call(viewHandler, viewRequest, route, runtimeEnvironment, runtimeParams);
+            resolvedRoute = route;
+        }
+        catch (err) {
+            if (!errorRoute) {
+                throw err;
+            }
+            viewResponse = await resolve.call(viewHandler, viewRequest, errorRoute, runtimeEnvironment, runtimeParams);
+            resolvedRoute = errorRoute;
+        }
+        if (req.isSiteGeneration()) {
+            res.setSiteGenerationMetadata(viewResponse.metadata);
+        }
+        // view response will be html by default
+        res.type('text/html');
+        // the default content type can be overridden if specified by the view response
+        if (viewResponse.headers) {
+            res.set(viewResponse.headers);
+        }
+        // pick the shortest TTL between the view response and route object
+        const cacheTtl = shortestTtl(viewResponse.cache?.ttl, resolvedRoute.cache?.ttl);
+        if (cacheTtl) {
+            res.setHeader('cache-control', `public, max-age=${cacheTtl}`);
+        }
+        const status = resolvedRoute.status || viewResponse.status || 200;
+        res.status(status);
+        res.send(viewResponse.body);
+    };
+}
+function createConfigMiddleware(context, viewHandler) {
+    const { appConfig } = context;
+    const { routes } = appConfig;
+    return async (req, res) => {
+        const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(context.runtimeEnvironment);
+        const { appId, encodedViewPath } = req.params;
+        // match the app id to a route
+        const route = routes.find((route) => route.id === appId);
+        if (!route) {
+            res.status(404).send(descriptions.UNRESOLVABLE.APP_CONFIG(appId).message);
+            return;
+        }
+        // decode the resolved view path and extract any params.
+        const url = decodeViewPath(encodedViewPath);
+        const requestPath = route.path;
+        const params = extractRequestParams(requestPath, url, req.params);
+        const viewRequest = {
+            url,
+            params,
+            query: req.query,
+            requestPath,
+        };
+        const viewResponse = await viewHandler.getViewConfiguration(viewRequest, route, runtimeEnvironment, runtimeParams);
+        if (!viewResponse) {
+            res.status(404).send(descriptions.UNRESOLVABLE.VIEW_CONFIG(url).message);
+            return;
+        }
+        // Pick the shortest TTL between the view response and route object
+        const cacheTtl = shortestTtl(viewResponse.cache?.ttl, route.cache?.ttl);
+        if (cacheTtl) {
+            res.setHeader('cache-control', `public, max-age=${cacheTtl}`);
+        }
+        res.status(200);
+        res.type('application/javascript');
+        res.status(viewResponse.status || 200);
+        res.send(viewResponse.body);
+    };
+}
+function createNotFoundMiddleware(context, viewHandler) {
+    const { errorRoutes } = context.appConfig;
+    const errorRoute = errorRoutes.find((route) => route.status === 404);
+    if (errorRoute) {
+        return createViewMiddleware(errorRoute, context, viewHandler);
+    }
+    return (req, res) => {
+        res.status(404).send(descriptions.UNRESOLVABLE.VIEW(req.originalUrl).message);
+    };
+}
+export function viewMiddleware(app, context) {
+    const { appConfig, viewRegistry, moduleRegistry } = context;
+    const viewHandler = new LwrViewHandler({ viewRegistry, moduleRegistry }, appConfig);
+    // create and attach middleware for each route
+    for (const route of appConfig.routes) {
+        const paths = [route.path];
+        const subRoutes = route.subRoutes && getClientRoutes(route.subRoutes);
+        if (subRoutes) {
+            const prefix = route.path === '/' ? '' : route.path;
+            subRoutes.routes.forEach((subRoute) => subRoute.uri !== route.path && paths.push(`${prefix}${subRoute.uri}`));
+        }
+        paths.forEach((routePath) => paths.push(...CANONICAL_VIEW_ROUTES.map((viewRoute) => viewRoute + routePath)));
+        app.get(paths, handleErrors(createViewMiddleware(route, context, viewHandler)));
+    }
+    // create and attach middleware for bootstrap configurations
+    app.get(getClientBootstrapConfigurationRoutes(), handleErrors(createConfigMiddleware(context, viewHandler)));
+    // create and attach a greedy middleware to handle unsupported paths
+    // NOTE: a greedy `all` is used over `use` due to the way middleware is mounted in the server abstraction
+    app.get('/' + app.getRegexWildcard(), handleErrors(createNotFoundMiddleware(context, viewHandler)));
+}
+//# sourceMappingURL=view-middleware.js.map

package/build/es/middleware.d.ts

@@ -0,0 +1,9 @@
+export { localeMiddleware } from './middleware/locale-middleware.js';
+export { hmrMiddleware } from './middleware/hmr-middleware.js';
+export { moduleMiddleware } from './middleware/module-middleware.js';
+export { bundleMiddleware } from './middleware/bundle-middleware.js';
+export { mappingMiddleware } from './middleware/mapping-middleware.js';
+export { assetMiddleware } from './middleware/asset-middleware.js';
+export { viewMiddleware } from './middleware/view-middleware.js';
+export { resourceMiddleware } from './middleware/resource-middleware.js';
+//# sourceMappingURL=middleware.d.ts.map

package/build/es/middleware.js

@@ -0,0 +1,13 @@
+// The middleware are exposed as a submodule to mitigate installing unnecessary dependency and minimize Lambda
+// handler bundle size. For example, importing `@lwrjs/core` will pull in ALL `@lwrjs/server` dependencies
+// which includes both `koa` and `express`. Importing `@lwrjs/core/middleware` will only pull in the
+// middleware dependencies.
+export { localeMiddleware } from './middleware/locale-middleware.js';
+export { hmrMiddleware } from './middleware/hmr-middleware.js';
+export { moduleMiddleware } from './middleware/module-middleware.js';
+export { bundleMiddleware } from './middleware/bundle-middleware.js';
+export { mappingMiddleware } from './middleware/mapping-middleware.js';
+export { assetMiddleware } from './middleware/asset-middleware.js';
+export { viewMiddleware } from './middleware/view-middleware.js';
+export { resourceMiddleware } from './middleware/resource-middleware.js';
+//# sourceMappingURL=middleware.js.map

package/build/es/tools/server-build.d.ts

@@ -0,0 +1,14 @@
+import { LwrGlobalConfig } from '@lwrjs/types';
+export interface BuildOptions {
+    target?: string;
+    outputDir?: string;
+}
+/**
+ * Resolve application configurations, generate a server context module, and bundle
+ * the LWR server.  The bundled server will be written to the filesystem.
+ *
+ * @param {LwrGlobalConfig} configArg - programmatic LWR application config
+ * @param {BuildOptions} options - server build configurations
+ */
+export declare function buildServer(configArg?: LwrGlobalConfig, options?: BuildOptions): Promise<void>;
+//# sourceMappingURL=server-build.d.ts.map

package/build/es/tools/server-build.js

@@ -0,0 +1,182 @@
+import path from 'path';
+import fs from 'fs-extra';
+import esbuild from 'esbuild';
+import { normalizeConfig } from '@lwrjs/config';
+import { resolveConfigurations } from '../context/configurations.js';
+import { createProviderContext } from '../context/provider.js';
+import { createServerContext } from '../context/server.js';
+function getBuildMetadata(appConfig) {
+    const moduleProviders = processServiceEntries('moduleProvider', appConfig.moduleProviders);
+    const resourceProviders = processServiceEntries('resourceProvider', appConfig.resourceProviders);
+    const viewProviders = processServiceEntries('viewProvider', appConfig.viewProviders);
+    const viewTransformers = processServiceEntries('viewTransformer', appConfig.viewTransformers);
+    const assetProviders = processServiceEntries('assetProvider', appConfig.assetProviders);
+    const assetTransformers = processServiceEntries('assetTransformer', appConfig.assetTransformers);
+    const imports = [
+        ...moduleProviders.imports,
+        ...resourceProviders.imports,
+        ...viewProviders.imports,
+        ...viewTransformers.imports,
+        ...assetProviders.imports,
+        ...assetTransformers.imports,
+    ];
+    return {
+        imports,
+        moduleProviders: moduleProviders.services,
+        resourceProviders: resourceProviders.services,
+        viewProviders: viewProviders.services,
+        viewTransformers: viewTransformers.services,
+        assetProviders: assetProviders.services,
+        assetTransformers: assetTransformers.services,
+    };
+}
+function processServiceEntries(serviceType, entries) {
+    const imports = [];
+    const services = [];
+    for (const [index, [pkg, config]] of entries.entries()) {
+        const name = serviceType + index;
+        imports.push(`import ${name} from '${pkg}';`);
+        services.push(`[${name}, ${JSON.stringify(config)}]`);
+    }
+    return {
+        imports,
+        services,
+    };
+}
+function generateServices(providerContext) {
+    return ([ServiceCtor, serviceConfig = {}]) => new ServiceCtor(serviceConfig, providerContext);
+}
+function isRemote() {
+    return process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined;
+}
+function generateServerContextModule(appConfig, runtimeEnvironment, globalData, metadata) {
+    const { imports, moduleProviders, resourceProviders, viewProviders, viewTransformers, assetProviders, assetTransformers, } = metadata;
+    // config will be resolved programmatically and relative to the current machine
+    const config = {
+        ...appConfig,
+        rootDir: undefined,
+        ignoreLwrConfigFile: true,
+    };
+    return [
+        `/* This module is generated */`,
+        `import { LwrCompiler } from '@lwrjs/compiler';`,
+        `import { LwrModuleBundler } from '@lwrjs/module-bundler';`,
+        `import { LwrModuleRegistry } from '@lwrjs/module-registry';`,
+        `import { LwrResourceRegistry } from '@lwrjs/resource-registry';`,
+        `import { LwrAssetRegistry } from '@lwrjs/asset-registry';`,
+        `import { LwrViewRegistry } from '@lwrjs/view-registry';`,
+        `import { LwrApplicationObserver, deepFreeze } from '@lwrjs/shared-utils';`,
+        `import { normalizeConfig } from '@lwrjs/config';`,
+        // all of the static imports for the services
+        ...imports,
+        // reusing context resolution utils
+        createServerContext.toString(),
+        createProviderContext.toString(),
+        // helper function for generically initializing the services
+        generateServices.toString(),
+        // helper function to check if running on lambda
+        isRemote.toString(),
+        `const config = ${JSON.stringify(config, null, 4)}`,
+        `const runtimeEnvironment = ${JSON.stringify(runtimeEnvironment, null, 4)}`,
+        `const globalData = ${JSON.stringify(globalData, null, 4)}`,
+        // build artifacts are placed into a build dir on MRT
+        `isRemote() && process.chdir(__dirname);`,
+        `isRemote() && (config.rootDir = __dirname);`,
+        // cache dir must be in tmp dir to be able to write to the filesystem on lambda
+        `isRemote() && (config.cacheDir = '/tmp/__lwr_cache__');`,
+        // resolve all config config paths relative to the current machine
+        `const normalizedConfig = normalizeConfig(config);`,
+        `const serverContext = createServerContext(normalizedConfig, runtimeEnvironment, globalData);`,
+        `const providerContext = createProviderContext(serverContext);`,
+        `const generate = generateServices(providerContext);`,
+        `const moduleProviders = [${moduleProviders}].map(generate);`,
+        `const resourceProviders = [${resourceProviders}].map(generate);`,
+        `const viewProviders = [${viewProviders}].map(generate);`,
+        `const viewTransformers = [${viewTransformers}].map(generate);`,
+        `const assetProviders = [${assetProviders}].map(generate);`,
+        `const assetTransformers = [${assetTransformers}].map(generate);`,
+        `serverContext.moduleRegistry.addModuleProviders(moduleProviders);`,
+        `serverContext.resourceRegistry.addResourceProviders(resourceProviders);`,
+        `serverContext.viewRegistry.addViewProviders(viewProviders);`,
+        `serverContext.viewRegistry.addViewTransformers(viewTransformers);`,
+        `serverContext.assetRegistry.addAssetProviders(assetProviders);`,
+        `serverContext.assetRegistry.addAssetTransformers(assetTransformers);`,
+        `export default serverContext;`,
+    ].join('\n');
+}
+function generateServerSource(target) {
+    // `lambda` is the only supported build target for now
+    if (target !== 'lambda') {
+        // TODO: move to diagnostic error
+        throw `Unsupported server build target: ${target}`;
+    }
+    return [
+        `/* This module is generated */`,
+        `import { createHandler } from '@lwrjs/lambda';`,
+        // Importing the server context module at this point enables support for ESM bundling.
+        // If the server context module was imported in `createHandler`, it would need to be exposed
+        // as CJS.
+        `import build from './lwr.build.js';`,
+        // The server context module MUST NOT require asynchronous initialization to support running on MRT
+        // Once MRT supports ESM, top-level await could be used at this point to perform some asynchronous
+        // initialization.
+        `const handler = createHandler(build);`,
+        // MRT expects the handler to be a named export: `get`
+        `export { handler as get };`,
+    ].join('\n');
+}
+async function bundleServer(entryPoint, outputPath) {
+    await esbuild.build({
+        entryPoints: [entryPoint],
+        bundle: true,
+        sourcemap: true,
+        logLevel: 'silent',
+        external: [
+            // issues with native dependencies
+            'node:*',
+            'fsevents',
+            'iltorb',
+            'esbuild*',
+            'esinstall',
+            'jsonc-parser',
+            'node-fetch',
+            'rollup',
+            'rollup-plugin-node-polyfills',
+            // issues resolving relative files after bundling
+            '@lwrjs/config',
+            '@lwrjs/loader',
+        ],
+        format: 'cjs',
+        platform: 'node',
+        outfile: outputPath,
+    });
+}
+/**
+ * Resolve application configurations, generate a server context module, and bundle
+ * the LWR server.  The bundled server will be written to the filesystem.
+ *
+ * @param {LwrGlobalConfig} configArg - programmatic LWR application config
+ * @param {BuildOptions} options - server build configurations
+ */
+export async function buildServer(configArg, options) {
+    // App config will be included in the generated server context module, but all of the config paths
+    // will not be normalized.  The config paths will be normalized at runtime to enable running the
+    // application on a different machine.
+    const config = normalizeConfig(configArg, { skipDirNormalization: true, skipCacheDirCreation: true });
+    // Config hooks are applied during generation because they enable asynchronous modification of
+    // the LWR configurations.  Since config hooks are run at build time, the config hooks MUST NOT be
+    // responsible for critical application initialization or have dependencies on normalized config paths.
+    const { appConfig, runtimeEnvironment, globalData } = await resolveConfigurations(config);
+    // All LWR services are processed and included in the generated server context module.  This module will
+    // statically import the services and initialize all LWR server components(ie. providers and registries).
+    const metadata = getBuildMetadata(appConfig);
+    const serverContext = generateServerContextModule(appConfig, runtimeEnvironment, globalData, metadata);
+    const outputDir = path.join(appConfig.rootDir, options?.outputDir || '/build');
+    const serverSource = generateServerSource(options?.target || 'lambda');
+    // HACK: writing the server context module and server entry to a file for debugging
+    await fs.ensureDir(outputDir);
+    await fs.writeFile(path.join(outputDir, 'lwr.build.js'), serverContext);
+    await fs.writeFile(path.join(outputDir, 'entry.js'), serverSource);
+    await bundleServer(path.join(outputDir, 'entry.js'), path.join(outputDir, 'ssr.js'));
+}
+//# sourceMappingURL=server-build.js.map