@zenithbuild/cli 0.7.0 → 0.7.2

package/dist/server-output.js

@@ -0,0 +1,297 @@
+import { existsSync } from 'node:fs';
+import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { basename, dirname, extname, join, relative, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const PACKAGE_REQUIRE = createRequire(import.meta.url);
+const RELATIVE_SPECIFIER_RE = /((?:import|export)\s+(?:[^'"]*?\s+from\s+)?|import\s*\()\s*(['"])([^'"]+)\2/g;
+const SERVER_RUNTIME_FILES = [
+    {
+        from: new URL('./server-runtime/route-render.js', import.meta.url),
+        to: 'runtime/route-render.js'
+    },
+    {
+        from: new URL('./server-contract.js', import.meta.url),
+        to: 'server-contract.js'
+    },
+    {
+        from: new URL('./base-path.js', import.meta.url),
+        to: 'base-path.js'
+    },
+    {
+        from: new URL('./images/materialize.js', import.meta.url),
+        to: 'images/materialize.js'
+    },
+    {
+        from: new URL('./images/payload.js', import.meta.url),
+        to: 'images/payload.js'
+    },
+    {
+        from: new URL('./images/shared.js', import.meta.url),
+        to: 'images/shared.js'
+    }
+];
+function normalizeRouteName(routePath) {
+    if (routePath === '/') {
+        return 'index';
+    }
+    return routePath
+        .replace(/^\//, '')
+        .replace(/\/+/g, '_')
+        .replace(/:/g, 'param_')
+        .replace(/\*/g, 'splat_')
+        .replace(/\?/g, 'opt')
+        .replace(/[^a-zA-Z0-9_]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+function resolveTypeScriptApi(projectRoot) {
+    try {
+        const projectRequire = createRequire(join(projectRoot, '__zenith_server_output_loader__.js'));
+        return projectRequire('typescript');
+    }
+    catch {
+        try {
+            return PACKAGE_REQUIRE('typescript');
+        }
+        catch {
+            throw new Error('[Zenith:Build] Server-capable targets require the `typescript` package to transpile route modules.');
+        }
+    }
+}
+function withJsExtension(specifier) {
+    if (specifier.endsWith('.json')) {
+        return specifier;
+    }
+    return specifier.replace(/\.(tsx|ts|mts|cts|jsx|js|mjs|cjs)$/i, '.js');
+}
+function replaceSpecifier(source, original, nextValue) {
+    return source.replace(new RegExp(`(['"])${escapeRegex(original)}\\1`, 'g'), (_, quote) => `${quote}${nextValue}${quote}`);
+}
+function escapeRegex(value) {
+    return String(value).replace(/[|\\{}()[\]^$+*?.-]/g, '\\$&');
+}
+function isRelativeSpecifier(specifier) {
+    return (specifier.startsWith('./') ||
+        specifier.startsWith('../') ||
+        specifier.startsWith('/') ||
+        specifier.startsWith('file:'));
+}
+function resolveModuleCandidates(basePath) {
+    if (extname(basePath)) {
+        return [basePath];
+    }
+    return [
+        basePath,
+        `${basePath}.ts`,
+        `${basePath}.tsx`,
+        `${basePath}.mts`,
+        `${basePath}.cts`,
+        `${basePath}.js`,
+        `${basePath}.mjs`,
+        `${basePath}.cjs`,
+        `${basePath}.json`,
+        join(basePath, 'index.ts'),
+        join(basePath, 'index.tsx'),
+        join(basePath, 'index.mts'),
+        join(basePath, 'index.cts'),
+        join(basePath, 'index.js'),
+        join(basePath, 'index.mjs'),
+        join(basePath, 'index.cjs'),
+        join(basePath, 'index.json')
+    ];
+}
+function resolveImportedModule(specifier, sourceFile) {
+    if (!isRelativeSpecifier(specifier)) {
+        return null;
+    }
+    const baseDir = dirname(sourceFile);
+    const basePath = specifier.startsWith('file:')
+        ? new URL(specifier)
+        : resolve(baseDir, specifier);
+    const filePath = basePath instanceof URL ? fileURLToPath(basePath) : basePath;
+    const candidates = resolveModuleCandidates(filePath);
+    const found = candidates.find((candidate) => existsSync(candidate));
+    if (!found) {
+        throw new Error(`[Zenith:Build] Cannot resolve server import "${specifier}" from "${sourceFile}"`);
+    }
+    return found;
+}
+function gatherSpecifiers(source) {
+    const results = [];
+    for (const match of source.matchAll(RELATIVE_SPECIFIER_RE)) {
+        const specifier = String(match[3] || '');
+        results.push(specifier);
+    }
+    return results;
+}
+function transpileSource(ts, source, filePath) {
+    return ts.transpileModule(source, {
+        compilerOptions: {
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.ES2022,
+            moduleResolution: ts.ModuleResolutionKind.NodeNext,
+            esModuleInterop: true,
+            allowSyntheticDefaultImports: true
+        },
+        fileName: filePath
+    }).outputText;
+}
+function outputPathForSource(projectRoot, modulesRoot, sourcePath) {
+    const relativePath = relative(projectRoot, sourcePath).replaceAll('\\', '/');
+    const nextRelative = extname(relativePath) === '.json'
+        ? relativePath
+        : relativePath.replace(/\.(tsx|ts|mts|cts|jsx|js|mjs|cjs)$/i, '.js');
+    return join(modulesRoot, nextRelative);
+}
+async function compileImportedModule({ projectRoot, modulesRoot, sourcePath, ts, seen }) {
+    if (seen.has(sourcePath)) {
+        return outputPathForSource(projectRoot, modulesRoot, sourcePath);
+    }
+    seen.add(sourcePath);
+    const outPath = outputPathForSource(projectRoot, modulesRoot, sourcePath);
+    await mkdir(dirname(outPath), { recursive: true });
+    if (extname(sourcePath) === '.json') {
+        await cp(sourcePath, outPath, { force: true });
+        return outPath;
+    }
+    const source = await readFile(sourcePath, 'utf8');
+    let output = transpileSource(ts, source, sourcePath);
+    for (const specifier of gatherSpecifiers(output)) {
+        if (!isRelativeSpecifier(specifier)) {
+            continue;
+        }
+        const resolvedPath = resolveImportedModule(specifier, sourcePath);
+        if (!resolvedPath) {
+            continue;
+        }
+        const compiledDependencyPath = await compileImportedModule({
+            projectRoot,
+            modulesRoot,
+            sourcePath: resolvedPath,
+            ts,
+            seen
+        });
+        const nextSpecifier = relative(dirname(outPath), compiledDependencyPath).replaceAll('\\', '/');
+        output = replaceSpecifier(output, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
+    }
+    await writeFile(outPath, output, 'utf8');
+    return outPath;
+}
+async function writeRouteModulePackage({ projectRoot, routeDir, route }) {
+    const ts = resolveTypeScriptApi(projectRoot);
+    const modulesRoot = join(routeDir, 'modules');
+    const seen = new Set();
+    let entryOutput = transpileSource(ts, route.server_script || '', route.server_script_path || 'route-entry.ts');
+    for (const specifier of gatherSpecifiers(entryOutput)) {
+        if (!isRelativeSpecifier(specifier)) {
+            continue;
+        }
+        const resolvedPath = resolveImportedModule(specifier, route.server_script_path || projectRoot);
+        if (!resolvedPath) {
+            continue;
+        }
+        const compiledDependencyPath = await compileImportedModule({
+            projectRoot,
+            modulesRoot,
+            sourcePath: resolvedPath,
+            ts,
+            seen
+        });
+        const nextSpecifier = relative(join(routeDir, 'route'), compiledDependencyPath).replaceAll('\\', '/');
+        entryOutput = replaceSpecifier(entryOutput, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
+    }
+    const routeModulePath = join(routeDir, 'route', 'entry.js');
+    await mkdir(dirname(routeModulePath), { recursive: true });
+    await writeFile(routeModulePath, entryOutput, 'utf8');
+}
+async function copyRuntimeFiles(serverDir) {
+    for (const file of SERVER_RUNTIME_FILES) {
+        const targetPath = join(serverDir, file.to);
+        await mkdir(dirname(targetPath), { recursive: true });
+        await cp(file.from, targetPath, { force: true });
+    }
+}
+async function copyOptionalFile(sourcePath, targetPath) {
+    if (!sourcePath || !existsSync(sourcePath)) {
+        return false;
+    }
+    await mkdir(dirname(targetPath), { recursive: true });
+    await cp(sourcePath, targetPath, { force: true });
+    return true;
+}
+export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot, config, basePath = '/' }) {
+    const serverDir = join(coreOutputDir, 'server');
+    await rm(serverDir, { recursive: true, force: true });
+    let routerManifest = { routes: [] };
+    try {
+        routerManifest = JSON.parse(await readFile(join(staticDir, 'assets', 'router-manifest.json'), 'utf8'));
+    }
+    catch {
+        routerManifest = { routes: [] };
+    }
+    const routes = Array.isArray(routerManifest.routes) ? routerManifest.routes : [];
+    const serverRoutes = routes.filter((route) => route.server_script && route.prerender !== true);
+    await mkdir(serverDir, { recursive: true });
+    await copyRuntimeFiles(serverDir);
+    const imageManifestSource = join(staticDir, '_zenith', 'image', 'manifest.json');
+    const emittedRoutes = [];
+    for (const route of serverRoutes) {
+        const name = normalizeRouteName(route.path);
+        const routeDir = join(serverDir, 'routes', name);
+        await mkdir(routeDir, { recursive: true });
+        const htmlSourcePath = join(staticDir, String(route.output || '').replace(/^\//, ''));
+        await copyOptionalFile(htmlSourcePath, join(routeDir, 'route', 'page.html'));
+        let pageAssetFile = null;
+        if (typeof route.page_asset === 'string' && route.page_asset.length > 0) {
+            const assetSourcePath = join(staticDir, route.page_asset.replace(/^\//, ''));
+            const assetFileName = basename(assetSourcePath);
+            if (await copyOptionalFile(assetSourcePath, join(routeDir, 'route', assetFileName))) {
+                pageAssetFile = assetFileName;
+            }
+        }
+        let imageManifestFile = null;
+        if (await copyOptionalFile(imageManifestSource, join(routeDir, 'route', 'image-manifest.json'))) {
+            imageManifestFile = 'image-manifest.json';
+        }
+        await writeRouteModulePackage({
+            projectRoot,
+            routeDir,
+            route
+        });
+        const meta = {
+            name,
+            path: route.path,
+            output: route.output,
+            base_path: basePath,
+            page_asset: route.page_asset || null,
+            page_asset_file: pageAssetFile,
+            route_id: route.route_id || null,
+            server_script_path: route.server_script_path || null,
+            guard_module_ref: route.guard_module_ref || null,
+            load_module_ref: route.load_module_ref || null,
+            has_guard: route.has_guard === true,
+            has_load: route.has_load === true,
+            params: extractRouteParams(route.path),
+            image_manifest_file: imageManifestFile,
+            image_config: config?.images || {}
+        };
+        await writeFile(join(routeDir, 'route.json'), `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+        emittedRoutes.push(meta);
+    }
+    await writeFile(join(serverDir, 'manifest.json'), `${JSON.stringify({ base_path: basePath, routes: emittedRoutes }, null, 2)}\n`, 'utf8');
+    return {
+        serverDir,
+        routes: emittedRoutes
+    };
+}
+function extractRouteParams(routePath) {
+    return String(routePath || '')
+        .split('/')
+        .filter(Boolean)
+        .filter((segment) => segment.startsWith(':') || segment.startsWith('*'))
+        .map((segment) => {
+        const raw = segment.slice(1);
+        return raw.endsWith('?') ? raw.slice(0, -1) : raw;
+    });
+}

package/dist/server-runtime/node-server.d.ts

@@ -0,0 +1,2 @@
+export function createRequestHandler(options?: {}): Promise<(req: any, res: any) => Promise<void>>;
+export function createNodeServer(options?: {}): Promise<any>;

package/dist/server-runtime/node-server.js

@@ -0,0 +1,354 @@
+import { createServer } from 'node:http';
+import { Readable } from 'node:stream';
+import { access, readFile } from 'node:fs/promises';
+import { dirname, extname, join, normalize, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { appLocalRedirectLocation, imageEndpointPath, normalizeBasePath, routeCheckPath, stripBasePath } from '../base-path.js';
+import { handleImageRequest } from '../images/service.js';
+import { executeRouteRequest, renderRouteRequest } from './route-render.js';
+import { resolveRequestRoute } from './resolve-request-route.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const MIME_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'application/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.gif': 'image/gif',
+    '.txt': 'text/plain; charset=utf-8'
+};
+let runtimeContextPromise = null;
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(filePath, fallback) {
+    try {
+        return JSON.parse(await readFile(filePath, 'utf8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+function resolveWithinRoot(rootDir, requestPath) {
+    let decoded = requestPath;
+    try {
+        decoded = decodeURIComponent(requestPath);
+    }
+    catch {
+        return null;
+    }
+    const normalized = normalize(decoded).replace(/\\/g, '/');
+    const relativePath = normalized.replace(/^\/+/, '');
+    const root = resolve(rootDir);
+    const candidate = resolve(root, relativePath);
+    if (candidate === root || candidate.startsWith(`${root}${sep}`)) {
+        return candidate;
+    }
+    return null;
+}
+function toStaticFilePath(staticDir, pathname) {
+    let resolvedPath = pathname;
+    if (resolvedPath === '/') {
+        resolvedPath = '/index.html';
+    }
+    else if (!extname(resolvedPath)) {
+        resolvedPath += '/index.html';
+    }
+    return resolveWithinRoot(staticDir, resolvedPath);
+}
+function publicHost(host) {
+    if (host === '0.0.0.0' || host === '::') {
+        return '127.0.0.1';
+    }
+    return host;
+}
+function createRequestBase(req, fallbackOrigin) {
+    if (typeof req.headers.host === 'string' && req.headers.host.length > 0) {
+        return `http://${req.headers.host}`;
+    }
+    return fallbackOrigin;
+}
+async function createWebRequest(req, url) {
+    const init = {
+        method: req.method || 'GET',
+        headers: new Headers()
+    };
+    for (const [key, rawValue] of Object.entries(req.headers || {})) {
+        if (Array.isArray(rawValue)) {
+            for (const value of rawValue) {
+                init.headers.append(key, String(value));
+            }
+            continue;
+        }
+        if (rawValue !== undefined) {
+            init.headers.set(key, String(rawValue));
+        }
+    }
+    const method = String(init.method || 'GET').toUpperCase();
+    if (method !== 'GET' && method !== 'HEAD') {
+        const bodyChunks = [];
+        for await (const chunk of req) {
+            bodyChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        init.body = Readable.toWeb(Readable.from(bodyChunks));
+        init.duplex = 'half';
+    }
+    return new Request(url.toString(), init);
+}
+async function sendFetchResponse(res, response, method) {
+    res.statusCode = response.status;
+    for (const [key, value] of response.headers.entries()) {
+        res.setHeader(key, value);
+    }
+    if (String(method || 'GET').toUpperCase() === 'HEAD') {
+        res.end();
+        return;
+    }
+    const body = await response.arrayBuffer();
+    res.end(Buffer.from(body));
+}
+async function sendStaticFile(res, filePath, method) {
+    const body = await readFile(filePath);
+    const contentType = MIME_TYPES[extname(filePath)] || 'application/octet-stream';
+    res.writeHead(200, { 'Content-Type': contentType });
+    if (String(method || 'GET').toUpperCase() === 'HEAD') {
+        res.end();
+        return;
+    }
+    res.end(body);
+}
+function normalizeRouteCheckResult(result, targetUrl, basePath) {
+    if (!result || result.kind !== 'redirect') {
+        return result;
+    }
+    const location = appLocalRedirectLocation(result.location, basePath);
+    if (location.includes('://') || location.startsWith('//')) {
+        try {
+            const redirectUrl = new URL(location);
+            if (redirectUrl.origin !== targetUrl.origin) {
+                return { ...result, location: appLocalRedirectLocation('/', basePath) };
+            }
+        }
+        catch {
+            return { ...result, location: appLocalRedirectLocation('/', basePath) };
+        }
+    }
+    return { ...result, location };
+}
+async function loadRuntimeContext(options = {}) {
+    if (!options.distDir && runtimeContextPromise) {
+        return runtimeContextPromise;
+    }
+    const load = async () => {
+        const distDir = options.distDir ? resolve(options.distDir) : resolve(__dirname, '..', '..');
+        const serverDir = join(distDir, 'server');
+        const config = await readJson(join(serverDir, 'config.json'), {
+            base_path: '/',
+            static_dir: '../static',
+            build_manifest: '../manifest.json',
+            images: {}
+        });
+        const buildManifest = await readJson(join(serverDir, config.build_manifest || '../manifest.json'), {
+            routes: [],
+            base_path: '/'
+        });
+        const serverManifest = await readJson(join(serverDir, 'manifest.json'), { routes: [] });
+        return {
+            distDir,
+            serverDir,
+            staticDir: resolve(serverDir, config.static_dir || '../static'),
+            buildManifest,
+            buildRoutes: Array.isArray(buildManifest.routes) ? buildManifest.routes : [],
+            serverRoutes: Array.isArray(serverManifest.routes) ? serverManifest.routes : [],
+            images: config.images || {},
+            basePath: normalizeBasePath(config.base_path || '/')
+        };
+    };
+    const promise = load();
+    if (!options.distDir) {
+        runtimeContextPromise = promise;
+    }
+    return promise;
+}
+async function handleRouteCheck(req, res, url, context) {
+    if (req.headers['x-zenith-route-check'] !== '1') {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'forbidden', message: 'invalid request context' }));
+        return;
+    }
+    const targetPath = String(url.searchParams.get('path') || '/');
+    if (targetPath.includes('://') || targetPath.startsWith('//') || /[\r\n]/.test(targetPath)) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'invalid_path_format' }));
+        return;
+    }
+    const targetUrl = new URL(targetPath, url.origin);
+    if (targetUrl.origin !== url.origin) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'external_route_evaluation_forbidden' }));
+        return;
+    }
+    const canonicalPath = stripBasePath(targetUrl.pathname, context.basePath);
+    if (canonicalPath === null) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'route_not_found' }));
+        return;
+    }
+    const canonicalTargetUrl = new URL(targetUrl.toString());
+    canonicalTargetUrl.pathname = canonicalPath;
+    const buildResolved = resolveRequestRoute(canonicalTargetUrl, context.buildRoutes);
+    if (!buildResolved.matched || !buildResolved.route) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'route_not_found' }));
+        return;
+    }
+    let result = { kind: 'allow' };
+    let routeId = buildResolved.route.path || '';
+    const serverResolved = resolveRequestRoute(canonicalTargetUrl, context.serverRoutes);
+    if (serverResolved.matched && serverResolved.route) {
+        routeId = serverResolved.route.route_id || serverResolved.route.name || serverResolved.route.path || routeId;
+        try {
+            const request = await createWebRequest(req, targetUrl);
+            const routeDir = join(context.serverDir, 'routes', serverResolved.route.name);
+            const execution = await executeRouteRequest({
+                request,
+                route: serverResolved.route,
+                params: serverResolved.params,
+                routeModulePath: join(routeDir, 'route', 'entry.js'),
+                guardOnly: true
+            });
+            result = normalizeRouteCheckResult(execution.result, targetUrl, context.basePath);
+        }
+        catch (error) {
+            result = {
+                kind: 'deny',
+                status: 500,
+                message: String(error)
+            };
+        }
+    }
+    res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store, no-cache, must-revalidate, proxy-revalidate',
+        Pragma: 'no-cache',
+        Expires: '0',
+        Vary: 'Cookie'
+    });
+    res.end(JSON.stringify({
+        result,
+        routeId,
+        to: targetUrl.toString()
+    }));
+}
+async function handleNodeRequest(req, res, context, serverOrigin) {
+    const url = new URL(req.url || '/', createRequestBase(req, serverOrigin));
+    const canonicalPath = stripBasePath(url.pathname, context.basePath);
+    if (url.pathname === routeCheckPath(context.basePath)) {
+        await handleRouteCheck(req, res, url, context);
+        return;
+    }
+    if (url.pathname === imageEndpointPath(context.basePath)) {
+        await handleImageRequest(req, res, {
+            requestUrl: url,
+            projectRoot: context.distDir,
+            config: context.images
+        });
+        return;
+    }
+    if (canonicalPath === null) {
+        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end('404 Not Found');
+        return;
+    }
+    const canonicalUrl = new URL(url.toString());
+    canonicalUrl.pathname = canonicalPath;
+    if (extname(canonicalPath) && extname(canonicalPath) !== '.html') {
+        const assetPath = resolveWithinRoot(context.staticDir, canonicalPath);
+        if (!assetPath || !(await fileExists(assetPath))) {
+            res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+            res.end('404 Not Found');
+            return;
+        }
+        await sendStaticFile(res, assetPath, req.method);
+        return;
+    }
+    const serverResolved = resolveRequestRoute(canonicalUrl, context.serverRoutes);
+    if (serverResolved.matched && serverResolved.route) {
+        const routeDir = join(context.serverDir, 'routes', serverResolved.route.name);
+        const request = await createWebRequest(req, url);
+        const response = await renderRouteRequest({
+            request,
+            route: serverResolved.route,
+            params: serverResolved.params,
+            routeModulePath: join(routeDir, 'route', 'entry.js'),
+            shellHtmlPath: join(routeDir, 'route', 'page.html'),
+            pageAssetPath: serverResolved.route.page_asset_file
+                ? join(routeDir, 'route', serverResolved.route.page_asset_file)
+                : null,
+            imageManifestPath: serverResolved.route.image_manifest_file
+                ? join(routeDir, 'route', serverResolved.route.image_manifest_file)
+                : null,
+            imageConfig: serverResolved.route.image_config || context.images
+        });
+        await sendFetchResponse(res, response, req.method);
+        return;
+    }
+    const buildResolved = resolveRequestRoute(canonicalUrl, context.buildRoutes);
+    if (buildResolved.matched && buildResolved.route) {
+        const htmlPath = resolveWithinRoot(context.staticDir, buildResolved.route.html);
+        if (htmlPath && await fileExists(htmlPath)) {
+            await sendStaticFile(res, htmlPath, req.method);
+            return;
+        }
+    }
+    const fallbackHtmlPath = toStaticFilePath(context.staticDir, canonicalPath);
+    if (fallbackHtmlPath && await fileExists(fallbackHtmlPath)) {
+        await sendStaticFile(res, fallbackHtmlPath, req.method);
+        return;
+    }
+    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+    res.end('404 Not Found');
+}
+export async function createRequestHandler(options = {}) {
+    const context = await loadRuntimeContext(options);
+    const host = publicHost(options.host || '127.0.0.1');
+    const port = Number.isInteger(options.port) ? options.port : 3000;
+    const serverOrigin = `http://${host}:${port}`;
+    return async (req, res) => {
+        try {
+            await handleNodeRequest(req, res, context, serverOrigin);
+        }
+        catch (error) {
+            res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
+            res.end(String(error));
+        }
+    };
+}
+export async function createNodeServer(options = {}) {
+    const { port = 3000, host = '127.0.0.1' } = options;
+    const handler = await createRequestHandler({ ...options, port, host });
+    const server = createServer((req, res) => {
+        void handler(req, res);
+    });
+    return new Promise((resolveServer) => {
+        server.listen(port, host, () => {
+            resolveServer({
+                server,
+                port: server.address().port,
+                close: () => server.close()
+            });
+        });
+    });
+}