@chidchanun/bcp 0.1.0

package/packages/server/src/production-server.ts

@@ -0,0 +1,1746 @@
+import fs from "node:fs/promises";
+import * as http from "node:http";
+import path from "node:path";
+import {
+    pathToFileURL,
+} from "node:url";
+
+import {
+    createElement,
+    type ComponentType,
+    type ReactElement,
+} from "react";
+
+import {
+    renderToString,
+} from "react-dom/server";
+
+import type {
+    ProductionBuildManifest,
+    ProductionRouteAsset,
+} from "../../bundler/src/production.js";
+
+import {
+    assertNoPageApiConflicts,
+    matchApiRoute,
+    matchRoute,
+    scanApiRoutes,
+    scanRoutes,
+    type ApiRoute,
+} from "../../router/src/index.js";
+
+import {
+    compressDynamicContent,
+    isCompressibleContentType,
+    selectContentEncoding,
+    type ContentEncoding,
+} from "./compression.js";
+
+import {
+    resolveNavigationPayload,
+    sendNavigationError,
+    sendNavigationPayload,
+} from "./navigation-payload.js";
+
+import {
+    getContentType,
+    readPublicAsset,
+    type StaticAsset,
+} from "./static-assets.js";
+
+export interface ProductionServerOptions {
+    port?: number;
+    hostname?: string;
+    rootDirectory?: string;
+}
+
+interface FrameworkData {
+    route: string;
+    params: Record<string, string>;
+}
+
+interface ApiContext {
+    params: Record<string, string>;
+}
+
+type ApiHandler = (
+    request: Request,
+    context: ApiContext
+) => Response | Promise<Response>;
+
+const HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "HEAD",
+    "OPTIONS",
+] as const;
+
+type HttpMethod =
+    typeof HTTP_METHODS[number];
+
+export function createProductionServer(
+    options: ProductionServerOptions = {}
+) {
+    const port =
+        options.port ??
+        3000;
+
+    const hostname =
+        options.hostname ??
+        "localhost";
+
+    const rootDirectory =
+        path.resolve(
+            options.rootDirectory ??
+            process.cwd()
+        );
+
+    const appDirectory =
+        path.join(
+            rootDirectory,
+            "app"
+        );
+
+    const buildDirectory =
+        path.join(
+            rootDirectory,
+            ".bcp-framework",
+            "build"
+        );
+
+    const clientDirectory =
+        path.join(
+            buildDirectory,
+            "client"
+        );
+
+    const manifestPath =
+        path.join(
+            buildDirectory,
+            "manifest.json"
+        );
+
+    let manifest:
+        ProductionBuildManifest | null =
+        null;
+
+    const routes =
+        scanRoutes(
+            appDirectory
+        );
+
+    const apiRoutes =
+        scanApiRoutes(
+            appDirectory
+        );
+
+    assertNoPageApiConflicts(
+        routes,
+        apiRoutes
+    );
+
+    const server =
+        http.createServer(
+            async (
+                req,
+                res
+            ) => {
+                const startedAt =
+                    performance.now();
+
+                let pathname =
+                    "/";
+
+                try {
+                    const requestUrl =
+                        new URL(
+                            req.url ?? "/",
+                            `http://${
+                                req.headers.host ??
+                                `${hostname}:${port}`
+                            }`
+                        );
+
+                    pathname =
+                        normalizePathname(
+                            requestUrl.pathname
+                        );
+
+                    res.once(
+                        "finish",
+                        () => {
+                            const duration =
+                                performance.now() -
+                                startedAt;
+
+                            console.log(
+                                `${req.method ?? "GET"} ${pathname} ${res.statusCode} ${duration.toFixed(2)}ms`
+                            );
+                        }
+                    );
+
+                    if (
+                        pathname ===
+                        "/_bcp/navigation"
+                    ) {
+                        await handleNavigationRequest(
+                            req,
+                            res,
+                            requestUrl,
+                            rootDirectory,
+                            requireManifest(
+                                manifest
+                            )
+                        );
+
+                        return;
+                    }
+
+                    if (
+                        pathname ===
+                        "/_bcp/dev-runtime.js"
+                    ) {
+                        sendJavaScript(
+                            res,
+                            Buffer.from(
+                                "/* BCP production: HMR disabled */"
+                            ),
+                            false
+                        );
+
+                        return;
+                    }
+
+                    if (
+                        pathname.startsWith(
+                            "/_bcp/client/"
+                        )
+                    ) {
+                        const served =
+                            await serveBuildAsset(
+                                req,
+                                res,
+                                clientDirectory,
+                                pathname
+                            );
+
+                        if (!served) {
+                            sendNotFound(
+                                res
+                            );
+                        }
+
+                        return;
+                    }
+
+                    const apiMatch =
+                        matchApiRoute(
+                            apiRoutes,
+                            pathname
+                        );
+
+                    if (apiMatch) {
+                        await handleApiRoute(
+                            req,
+                            res,
+                            requestUrl,
+                            apiMatch.route,
+                            apiMatch.params,
+                            requireManifest(
+                                manifest
+                            ).buildId
+                        );
+
+                        return;
+                    }
+
+                    const publicAsset =
+                        await readPublicAsset(
+                            rootDirectory,
+                            pathname
+                        );
+
+                    if (publicAsset) {
+                        sendPublicAsset(
+                            req,
+                            res,
+                            publicAsset
+                        );
+
+                        return;
+                    }
+
+                    const match =
+                        matchRoute(
+                            routes,
+                            pathname
+                        );
+
+                    if (!match) {
+                        sendNotFound(
+                            res
+                        );
+
+                        return;
+                    }
+
+                    const activeManifest =
+                        requireManifest(
+                            manifest
+                        );
+
+                    const routeAsset =
+                        activeManifest.routes[
+                            match.route.pathname
+                        ];
+
+                    if (!routeAsset) {
+                        throw new Error(
+                            `BCP Framework: production bundle was not found for route "${match.route.pathname}". Run bcp build again.`
+                        );
+                    }
+
+                    const Page =
+                        await importComponent(
+                            match.route.filePath,
+                            "Page",
+                            activeManifest.buildId
+                        );
+
+                    const Layouts:
+                        ComponentType<any>[] =
+                        [];
+
+                    for (
+                        const layoutFile
+                        of match.route.layouts
+                    ) {
+                        Layouts.push(
+                            await importComponent(
+                                layoutFile,
+                                "Layout",
+                                activeManifest.buildId
+                            )
+                        );
+                    }
+
+                    let element:
+                        ReactElement =
+                        createElement(
+                            Page,
+                            {
+                                params:
+                                    match.params,
+                            }
+                        );
+
+                    for (
+                        let index =
+                            Layouts.length - 1;
+                        index >= 0;
+                        index--
+                    ) {
+                        element =
+                            createElement(
+                                Layouts[index],
+                                {
+                                    params:
+                                        match.params,
+                                },
+                                element
+                            );
+                    }
+
+                    const content =
+                        renderToString(
+                            element
+                        );
+
+                    const frameworkData:
+                        FrameworkData = {
+                        route:
+                            match.route.pathname,
+                        params:
+                            match.params,
+                    };
+
+                    sendHtml(
+                        req,
+                        res,
+                        renderDocument(
+                            content,
+                            routeAsset,
+                            frameworkData
+                        )
+                    );
+                } catch (error) {
+                    console.error(
+                        "BCP Production Error:",
+                        error
+                    );
+
+                    if (
+                        res.headersSent
+                    ) {
+                        res.end();
+                        return;
+                    }
+
+                    sendInternalServerError(
+                        res,
+                        error
+                    );
+                }
+            }
+        );
+
+    return {
+        async start() {
+            process.env.NODE_ENV =
+                "production";
+
+            manifest =
+                await readManifest(
+                    manifestPath
+                );
+
+            await new Promise<void>(
+                (
+                    resolve,
+                    reject
+                ) => {
+                    const onError =
+                        (error: Error) => {
+                            server.off(
+                                "listening",
+                                onListening
+                            );
+                            reject(error);
+                        };
+
+                    const onListening =
+                        () => {
+                            server.off(
+                                "error",
+                                onError
+                            );
+                            resolve();
+                        };
+
+                    server.once(
+                        "error",
+                        onError
+                    );
+                    server.once(
+                        "listening",
+                        onListening
+                    );
+                    server.listen(
+                        port,
+                        hostname
+                    );
+                }
+            );
+
+            console.log("");
+            console.log(
+                "BCP Framework Production"
+            );
+            console.log(
+                `Local: http://${hostname}:${port}`
+            );
+            console.log(
+                `Build: ${manifest.buildId}`
+            );
+            console.log("");
+        },
+
+        async stop() {
+            if (!server.listening) {
+                return;
+            }
+
+            await new Promise<void>(
+                (
+                    resolve,
+                    reject
+                ) => {
+                    server.close(
+                        (error) => {
+                            if (error) {
+                                reject(error);
+                                return;
+                            }
+
+                            resolve();
+                        }
+                    );
+                }
+            );
+        },
+    };
+}
+
+async function readManifest(
+    manifestPath: string
+): Promise<ProductionBuildManifest> {
+    let content: string;
+
+    try {
+        content =
+            await fs.readFile(
+                manifestPath,
+                "utf8"
+            );
+    } catch {
+        throw new Error(
+            "BCP Framework: production build was not found. Run `bcp build` before `bcp start`."
+        );
+    }
+
+    const manifest =
+        JSON.parse(
+            content
+        ) as
+        Partial<ProductionBuildManifest>;
+
+    if (
+        typeof manifest.version !==
+            "number" ||
+        typeof manifest.buildId !==
+            "string" ||
+        typeof manifest.builtAt !==
+            "string" ||
+        !manifest.routes ||
+        typeof manifest.routes !==
+            "object" ||
+        !Array.isArray(
+            manifest.assets
+        ) ||
+        !Object.values(
+            manifest.routes
+        ).every(
+            isValidRouteAsset
+        )
+    ) {
+        throw new Error(
+            "BCP Framework: production manifest is invalid. Run `bcp build` again."
+        );
+    }
+
+    return manifest as
+        ProductionBuildManifest;
+}
+
+function isValidRouteAsset(
+    value: unknown
+): value is ProductionRouteAsset {
+    if (
+        !value ||
+        typeof value !== "object"
+    ) {
+        return false;
+    }
+
+    const route =
+        value as
+        Partial<ProductionRouteAsset>;
+
+    return (
+        typeof route.entry ===
+            "string" &&
+        Array.isArray(
+            route.imports
+        ) &&
+        route.imports.every(
+            (item) =>
+                typeof item ===
+                "string"
+        ) &&
+        Boolean(
+            route.size
+        ) &&
+        typeof route.size?.raw ===
+            "number" &&
+        typeof route.size?.gzip ===
+            "number" &&
+        typeof route.size?.brotli ===
+            "number"
+    );
+}
+
+function requireManifest(
+    manifest:
+        ProductionBuildManifest | null
+): ProductionBuildManifest {
+    if (!manifest) {
+        throw new Error(
+            "BCP Framework: production server has not loaded the build manifest."
+        );
+    }
+
+    return manifest;
+}
+
+async function handleNavigationRequest(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    requestUrl: URL,
+    rootDirectory: string,
+    manifest: ProductionBuildManifest
+): Promise<void> {
+    if (
+        req.method !== "GET"
+    ) {
+        sendNavigationError(
+            res,
+            405,
+            "Method Not Allowed"
+        );
+        return;
+    }
+
+    const targetPath =
+        requestUrl.searchParams.get(
+            "url"
+        );
+
+    if (!targetPath) {
+        sendNavigationError(
+            res,
+            400,
+            "Missing navigation target."
+        );
+        return;
+    }
+
+    let target: URL;
+
+    try {
+        target =
+            new URL(
+                targetPath,
+                requestUrl.origin
+            );
+    } catch {
+        sendNavigationError(
+            res,
+            400,
+            "Invalid navigation target."
+        );
+        return;
+    }
+
+    if (
+        target.origin !==
+        requestUrl.origin
+    ) {
+        sendNavigationError(
+            res,
+            400,
+            "Cross-origin navigation is not allowed."
+        );
+        return;
+    }
+
+    const payload =
+        await resolveNavigationPayload(
+            rootDirectory,
+            target.pathname,
+            {
+                resolveClientScript:
+                    (pathname) =>
+                        manifest.routes[
+                            pathname
+                        ]?.entry ??
+                        null,
+                resolveClientImports:
+                    (pathname) =>
+                        manifest.routes[
+                            pathname
+                        ]?.imports ??
+                        [],
+                version:
+                    manifest.version,
+            }
+        );
+
+    if (!payload) {
+        sendNavigationError(
+            res,
+            404,
+            "Route not found."
+        );
+        return;
+    }
+
+    sendNavigationPayload(
+        res,
+        payload
+    );
+}
+
+async function serveBuildAsset(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    clientDirectory: string,
+    pathname: string
+): Promise<boolean> {
+    const encodedRelative =
+        pathname.slice(
+            "/_bcp/client/".length
+        );
+
+    let relativePath: string;
+
+    try {
+        relativePath =
+            decodeURIComponent(
+                encodedRelative
+            );
+    } catch {
+        return false;
+    }
+
+    if (
+        !relativePath ||
+        relativePath.includes("\0")
+    ) {
+        return false;
+    }
+
+    const root =
+        path.resolve(
+            clientDirectory
+        );
+
+    const candidate =
+        path.resolve(
+            root,
+            relativePath.replaceAll(
+                "/",
+                path.sep
+            )
+        );
+
+    if (
+        !isPathInside(
+            root,
+            candidate
+        )
+    ) {
+        return false;
+    }
+
+    let stat:
+        Awaited<
+            ReturnType<typeof fs.stat>
+        >;
+
+    try {
+        stat =
+            await fs.stat(
+                candidate
+            );
+    } catch {
+        return false;
+    }
+
+    if (!stat.isFile()) {
+        return false;
+    }
+
+    const contentType =
+        getContentType(
+            candidate
+        );
+
+    const encoding =
+        selectContentEncoding(
+            req,
+            contentType,
+            stat.size,
+            {
+                br:
+                    await fileExists(
+                        `${candidate}.br`
+                    ),
+                gzip:
+                    await fileExists(
+                        `${candidate}.gz`
+                    ),
+            }
+        );
+
+    const sourceFile =
+        encoding === "br"
+            ? `${candidate}.br`
+            : encoding === "gzip"
+                ? `${candidate}.gz`
+                : candidate;
+
+    const content =
+        await fs.readFile(
+            sourceFile
+        );
+
+    const headers:
+        Record<string, string | number> = {
+        "Content-Type":
+            contentType,
+        "Cache-Control":
+            "public, max-age=31536000, immutable",
+        "X-Content-Type-Options":
+            "nosniff",
+        "Content-Length":
+            content.length,
+        Vary:
+            "Accept-Encoding",
+    };
+
+    if (encoding) {
+        headers[
+            "Content-Encoding"
+        ] =
+            encoding;
+    }
+
+    res.writeHead(
+        200,
+        headers
+    );
+
+    if (
+        req.method === "HEAD"
+    ) {
+        res.end();
+        return true;
+    }
+
+    res.end(
+        content
+    );
+
+    return true;
+}
+
+async function fileExists(
+    filePath: string
+): Promise<boolean> {
+    try {
+        const stat =
+            await fs.stat(
+                filePath
+            );
+
+        return stat.isFile();
+    } catch {
+        return false;
+    }
+}
+
+function sendPublicAsset(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    asset: StaticAsset
+): void {
+    const encoding =
+        selectContentEncoding(
+            req,
+            asset.contentType,
+            asset.content.length
+        );
+
+    const content =
+        compressDynamicContent(
+            asset.content,
+            encoding
+        );
+
+    const etag =
+        createVariantEtag(
+            asset.etag,
+            encoding
+        );
+
+    const ifNoneMatch =
+        req.headers[
+            "if-none-match"
+        ];
+
+    const values =
+        Array.isArray(
+            ifNoneMatch
+        )
+            ? ifNoneMatch
+            : ifNoneMatch
+                ? ifNoneMatch.split(",")
+                : [];
+
+    if (
+        values
+            .map(
+                (value) =>
+                    value.trim()
+            )
+            .includes(
+                etag
+            )
+    ) {
+        res.writeHead(
+            304,
+            {
+                ETag:
+                    etag,
+                "Cache-Control":
+                    "public, max-age=0, must-revalidate",
+                Vary:
+                    "Accept-Encoding",
+            }
+        );
+        res.end();
+        return;
+    }
+
+    const headers:
+        Record<string, string | number> = {
+        "Content-Type":
+            asset.contentType,
+        "Content-Length":
+            content.length,
+        ETag:
+            etag,
+        "Last-Modified":
+            asset.lastModified,
+        "Cache-Control":
+            "public, max-age=0, must-revalidate",
+        "X-Content-Type-Options":
+            "nosniff",
+    };
+
+    if (
+        isCompressibleContentType(
+            asset.contentType
+        )
+    ) {
+        headers.Vary =
+            "Accept-Encoding";
+    }
+
+    if (encoding) {
+        headers[
+            "Content-Encoding"
+        ] =
+            encoding;
+    }
+
+    res.writeHead(
+        200,
+        headers
+    );
+
+    if (
+        req.method === "HEAD"
+    ) {
+        res.end();
+        return;
+    }
+
+    res.end(
+        content
+    );
+}
+
+async function handleApiRoute(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    requestUrl: URL,
+    route: ApiRoute,
+    params: Record<string, string>,
+    buildId: string
+): Promise<void> {
+    const moduleUrl =
+        createVersionedModuleUrl(
+            route.filePath,
+            buildId
+        );
+
+    const apiModule =
+        await import(
+            moduleUrl
+        );
+
+    const method =
+        normalizeHttpMethod(
+            req.method
+        );
+
+    const allowedMethods =
+        getAllowedMethods(
+            apiModule
+        );
+
+    if (
+        method === "OPTIONS" &&
+        !getApiHandler(
+            apiModule,
+            "OPTIONS"
+        )
+    ) {
+        res.writeHead(
+            204,
+            {
+                Allow:
+                    allowedMethods.join(
+                        ", "
+                    ),
+            }
+        );
+        res.end();
+        return;
+    }
+
+    let handler =
+        getApiHandler(
+            apiModule,
+            method
+        );
+
+    if (
+        !handler &&
+        method === "HEAD"
+    ) {
+        handler =
+            getApiHandler(
+                apiModule,
+                "GET"
+            );
+    }
+
+    if (!handler) {
+        sendMethodNotAllowed(
+            res,
+            allowedMethods
+        );
+        return;
+    }
+
+    const response =
+        await handler(
+            await createWebRequest(
+                req,
+                requestUrl
+            ),
+            {
+                params,
+            }
+        );
+
+    if (
+        !(response instanceof Response)
+    ) {
+        throw new Error(
+            `API handler "${method} ${route.pathname}" must return a Response object.`
+        );
+    }
+
+    await sendWebResponse(
+        req,
+        res,
+        response,
+        method === "HEAD"
+    );
+}
+
+function normalizeHttpMethod(
+    method:
+        string | undefined
+): HttpMethod {
+    return (
+        (
+            method ??
+            "GET"
+        ).toUpperCase() as
+        HttpMethod
+    );
+}
+
+function getApiHandler(
+    module:
+        Record<string, unknown>,
+    method: string
+): ApiHandler | undefined {
+    const value =
+        module[
+            method
+        ];
+
+    return typeof value ===
+        "function"
+        ? value as ApiHandler
+        : undefined;
+}
+
+function getAllowedMethods(
+    module:
+        Record<string, unknown>
+): string[] {
+    const allowed:
+        string[] = [];
+
+    for (
+        const method
+        of HTTP_METHODS
+    ) {
+        if (
+            method === "OPTIONS"
+        ) {
+            continue;
+        }
+
+        if (
+            method === "HEAD"
+        ) {
+            if (
+                getApiHandler(
+                    module,
+                    "HEAD"
+                ) ||
+                getApiHandler(
+                    module,
+                    "GET"
+                )
+            ) {
+                allowed.push(
+                    "HEAD"
+                );
+            }
+            continue;
+        }
+
+        if (
+            getApiHandler(
+                module,
+                method
+            )
+        ) {
+            allowed.push(
+                method
+            );
+        }
+    }
+
+    allowed.push(
+        "OPTIONS"
+    );
+
+    return allowed;
+}
+
+async function createWebRequest(
+    req: http.IncomingMessage,
+    url: URL
+): Promise<Request> {
+    const headers =
+        new Headers();
+
+    for (
+        const [
+            key,
+            value,
+        ]
+        of Object.entries(
+            req.headers
+        )
+    ) {
+        if (
+            value ===
+            undefined
+        ) {
+            continue;
+        }
+
+        if (
+            Array.isArray(
+                value
+            )
+        ) {
+            for (
+                const item
+                of value
+            ) {
+                headers.append(
+                    key,
+                    item
+                );
+            }
+            continue;
+        }
+
+        headers.set(
+            key,
+            value
+        );
+    }
+
+    const method =
+        (
+            req.method ??
+            "GET"
+        ).toUpperCase();
+
+    const init:
+        RequestInit = {
+        method,
+        headers,
+    };
+
+    if (
+        method !== "GET" &&
+        method !== "HEAD"
+    ) {
+        const body =
+            await readRequestBody(
+                req
+            );
+
+        if (
+            body.length > 0
+        ) {
+            init.body =
+                body as unknown as
+                BodyInit;
+        }
+    }
+
+    return new Request(
+        url,
+        init
+    );
+}
+
+async function readRequestBody(
+    req: http.IncomingMessage
+): Promise<Buffer> {
+    const chunks:
+        Buffer[] = [];
+
+    for await (
+        const chunk
+        of req
+    ) {
+        chunks.push(
+            Buffer.isBuffer(
+                chunk
+            )
+                ? chunk
+                : Buffer.from(
+                    chunk
+                )
+        );
+    }
+
+    return Buffer.concat(
+        chunks
+    );
+}
+
+async function sendWebResponse(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    response: Response,
+    isHead: boolean
+): Promise<void> {
+    res.statusCode =
+        response.status;
+
+    response.headers.forEach(
+        (
+            value,
+            key
+        ) => {
+            if (
+                key.toLowerCase() ===
+                "set-cookie" ||
+            key.toLowerCase() ===
+                "content-length"
+            ) {
+                return;
+            }
+
+            res.setHeader(
+                key,
+                value
+            );
+        }
+    );
+
+    const responseHeaders =
+        response.headers as
+        Headers & {
+            getSetCookie?: () =>
+                string[];
+        };
+
+    const cookies =
+        responseHeaders
+            .getSetCookie?.();
+
+    if (
+        cookies &&
+        cookies.length > 0
+    ) {
+        res.setHeader(
+            "Set-Cookie",
+            cookies
+        );
+    }
+
+    if (
+        response.status === 204 ||
+        response.status === 304
+    ) {
+        res.end();
+        return;
+    }
+
+    const rawBody =
+        Buffer.from(
+            await response.arrayBuffer()
+        );
+
+    const contentType =
+        response.headers.get(
+            "content-type"
+        ) ??
+        "application/octet-stream";
+
+    const existingEncoding =
+        response.headers.get(
+            "content-encoding"
+        );
+
+    const encoding =
+        existingEncoding
+            ? null
+            : selectContentEncoding(
+                req,
+                contentType,
+                rawBody.length
+            );
+
+    const body =
+        existingEncoding
+            ? rawBody
+            : compressDynamicContent(
+                rawBody,
+                encoding
+            );
+
+    if (
+        encoding
+    ) {
+        res.setHeader(
+            "Content-Encoding",
+            encoding
+        );
+        res.setHeader(
+            "Vary",
+            "Accept-Encoding"
+        );
+    }
+
+    res.setHeader(
+        "Content-Length",
+        body.length
+    );
+
+    if (isHead) {
+        res.end();
+        return;
+    }
+
+    res.end(
+        body
+    );
+}
+
+async function importComponent(
+    filePath: string,
+    componentType: string,
+    buildId: string
+): Promise<ComponentType<any>> {
+    const module =
+        await import(
+            createVersionedModuleUrl(
+                filePath,
+                buildId
+            )
+        );
+
+    const Component =
+        module.default;
+
+    if (
+        typeof Component !==
+        "function"
+    ) {
+        throw new Error(
+            `${componentType} "${filePath}" does not export a default React component.`
+        );
+    }
+
+    return Component;
+}
+
+function createVersionedModuleUrl(
+    filePath: string,
+    buildId: string
+): string {
+    const url =
+        pathToFileURL(
+            filePath
+        );
+
+    url.searchParams.set(
+        "bcp-build",
+        buildId
+    );
+
+    return url.href;
+}
+
+function renderDocument(
+    content: string,
+    routeAsset: ProductionRouteAsset,
+    frameworkData: FrameworkData
+): string {
+    const modulePreloads =
+        routeAsset.imports
+            .map(
+                (importPath) =>
+                    `    <link rel="modulepreload" href="${escapeHtmlAttribute(
+                        importPath
+                    )}" />`
+            )
+            .join("\n");
+
+    return `
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1.0"
+    />
+    <title>BCP Framework</title>
+${modulePreloads}
+  </head>
+  <body>
+    <div id="root">${content}</div>
+
+    <script
+      id="__BCP_DATA__"
+      type="application/json"
+    >${serializeFrameworkData(frameworkData)}</script>
+
+    <script
+      data-bcp-client
+      type="module"
+      src="${escapeHtmlAttribute(
+          routeAsset.entry
+      )}"
+    ></script>
+  </body>
+</html>
+    `.trim();
+}
+
+function serializeFrameworkData(
+    value: unknown
+): string {
+    return JSON.stringify(
+        value
+    )
+        .replace(
+            /</g,
+            "\\u003c"
+        )
+        .replace(
+            /\u2028/g,
+            "\\u2028"
+        )
+        .replace(
+            /\u2029/g,
+            "\\u2029"
+        );
+}
+
+function sendHtml(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    html: string
+): void {
+    const contentType =
+        "text/html; charset=utf-8";
+
+    const rawBody =
+        Buffer.from(
+            html
+        );
+
+    const encoding =
+        selectContentEncoding(
+            req,
+            contentType,
+            rawBody.length
+        );
+
+    const body =
+        compressDynamicContent(
+            rawBody,
+            encoding
+        );
+
+    const headers:
+        Record<string, string | number> = {
+        "Content-Type":
+            contentType,
+        "Cache-Control":
+            "no-store",
+        "Content-Length":
+            body.length,
+        Vary:
+            "Accept-Encoding",
+    };
+
+    if (encoding) {
+        headers[
+            "Content-Encoding"
+        ] =
+            encoding;
+    }
+
+    res.writeHead(
+        200,
+        headers
+    );
+
+    if (
+        req.method === "HEAD"
+    ) {
+        res.end();
+        return;
+    }
+
+    res.end(
+        body
+    );
+}
+
+function sendJavaScript(
+    res: http.ServerResponse,
+    content: Buffer,
+    immutable = true
+): void {
+    res.writeHead(
+        200,
+        {
+            "Content-Type":
+                "text/javascript; charset=utf-8",
+            "Cache-Control":
+                immutable
+                    ? "public, max-age=31536000, immutable"
+                    : "no-store",
+            "Content-Length":
+                content.length,
+        }
+    );
+
+    res.end(
+        content
+    );
+}
+
+function sendMethodNotAllowed(
+    res: http.ServerResponse,
+    methods: string[]
+): void {
+    const body =
+        JSON.stringify({
+            error:
+                "Method Not Allowed",
+            allowedMethods:
+                methods,
+        });
+
+    res.writeHead(
+        405,
+        {
+            "Content-Type":
+                "application/json; charset=utf-8",
+            Allow:
+                methods.join(
+                    ", "
+                ),
+            "Content-Length":
+                Buffer.byteLength(
+                    body
+                ),
+        }
+    );
+
+    res.end(
+        body
+    );
+}
+
+function sendNotFound(
+    res: http.ServerResponse
+): void {
+    const body =
+        "<!DOCTYPE html><html><body><h1>404</h1><p>Page Not Found</p></body></html>";
+
+    res.writeHead(
+        404,
+        {
+            "Content-Type":
+                "text/html; charset=utf-8",
+            "Content-Length":
+                Buffer.byteLength(
+                    body
+                ),
+        }
+    );
+
+    res.end(
+        body
+    );
+}
+
+function sendInternalServerError(
+    res: http.ServerResponse,
+    error: unknown
+): void {
+    const message =
+        error instanceof Error
+            ? error.message
+            : "Unknown error";
+
+    const body =
+        `<!DOCTYPE html><html><body><h1>500</h1><p>Internal Server Error</p><pre>${escapeHtml(
+            message
+        )}</pre></body></html>`;
+
+    res.writeHead(
+        500,
+        {
+            "Content-Type":
+                "text/html; charset=utf-8",
+            "Cache-Control":
+                "no-store",
+            "Content-Length":
+                Buffer.byteLength(
+                    body
+                ),
+        }
+    );
+
+    res.end(
+        body
+    );
+}
+
+function createVariantEtag(
+    etag: string,
+    encoding: ContentEncoding
+): string {
+    if (!encoding) {
+        return etag;
+    }
+
+    const value =
+        etag
+            .replace(/^W\//, "")
+            .replace(/^"|"$/g, "");
+
+    return `W/"${value}-${encoding}"`;
+}
+
+function normalizePathname(
+    pathname: string
+): string {
+    if (
+        pathname.length > 1 &&
+        pathname.endsWith("/")
+    ) {
+        return pathname.slice(
+            0,
+            -1
+        );
+    }
+
+    return pathname || "/";
+}
+
+function isPathInside(
+    root: string,
+    candidate: string
+): boolean {
+    const relative =
+        path.relative(
+            root,
+            candidate
+        );
+
+    return (
+        relative === "" ||
+        (
+            relative !== ".." &&
+            !relative.startsWith(
+                `..${path.sep}`
+            ) &&
+            !path.isAbsolute(
+                relative
+            )
+        )
+    );
+}
+
+function escapeHtml(
+    value: string
+): string {
+    return value
+        .replaceAll(
+            "&",
+            "&amp;"
+        )
+        .replaceAll(
+            "<",
+            "&lt;"
+        )
+        .replaceAll(
+            ">",
+            "&gt;"
+        )
+        .replaceAll(
+            '"',
+            "&quot;"
+        )
+        .replaceAll(
+            "'",
+            "&#039;"
+        );
+}
+
+function escapeHtmlAttribute(
+    value: string
+): string {
+    return escapeHtml(
+        value
+    );
+}