@reckona/mreact-router 0.0.26 → 0.0.28

package/dist/build.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
-import { access, cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join, relative, sep } from "node:path";
-import { build as bundle } from "esbuild";
-import { collectTopLevelValueExportNames, formatDiagnostic, hasModuleDirective, transform, } from "@reckona/mreact-compiler";
+import { access, cp, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { builtinModules } from "node:module";
+import { dirname, extname, join, relative, sep } from "node:path";
+import { collectJsxComponentRootNames, collectStaticImportReferences, collectTopLevelValueExportNames, formatDiagnostic, hasModuleDirective, transform, } from "@reckona/mreact-compiler";
 import { buildClientRouteOutput, buildNavigationRuntimeBundle, clientScriptForPath, createClientRouteInferenceCache, detectClientNavigationHint, detectNavigationRuntimeHint, formatClientRouteInferenceDiagnostic, inferClientRouteModule, isClientRouteModule, routeIdForPath, } from "./client.js";
 import { bundleAppRouterSourceModule, importAppRouterSourceModule } from "./module-runner.js";
 import { scanAppRoutes } from "./routes.js";
@@ -10,7 +10,8 @@ import { resolveAppRouterProjectOptions, resolveBuildTargets, } from "./config.j
 import { routeCachePolicyFromSource } from "./cache.js";
 import { bundleMiddlewareModuleCode, renderAppRequest } from "./render.js";
 import { createAppRouterImportPolicyPlugin } from "./import-policy.js";
-import { hasGenerateStaticParamsExport, hasLoaderExport, hasPrerenderExport, isStreamRouteSource, stripRouteBuildExports, stripRouteClientOnlyExports, stripRouteLoaderOnlyExports, stripRouteMetadataOnlyExports, stripRouteRequestOnlyExports, } from "./route-source.js";
+import { hasGenerateStaticParamsExport, hasLoaderExport, hasPrerenderExport, isStreamRouteSource, mayUseAwaitBoundarySource, stripRouteBuildExports, stripRouteClientOnlyExports, stripRouteLoaderOnlyExports, stripRouteMetadataOnlyExports, stripRouteRequestOnlyExports, } from "./route-source.js";
+import { bundleRouterModule, } from "./bundle-pipeline.js";
 import { workspacePackageFile } from "./workspace-packages.js";
 const nativeEscapeTransform = {
     batchImportName: "escapeHtmlBatch",
@@ -20,11 +21,13 @@ export async function buildApp(options) {
     const project = resolveAppRouterProjectOptions(options);
     const buildTargets = resolveBuildTargets(options.targets ?? project.buildTargets);
     const shouldBuildCloudflare = buildTargets.includes("cloudflare");
+    const shouldBuildAwsLambda = buildTargets.includes("aws-lambda");
     const routes = await scanAppRoutes({ appDir: project.routesDir });
+    const files = await collectBuildFiles(project.projectRoot, project.allowedSourceDirs);
     const serverDir = join(options.outDir, "server");
     const clientDir = join(options.outDir, "client");
     const cloudflareDir = join(options.outDir, "cloudflare");
-    await validateProductionRoutes(routes);
+    await validateProductionRoutes({ files, projectRoot: project.projectRoot, routes });
     await rm(options.outDir, { force: true, recursive: true });
     await mkdir(serverDir, { recursive: true });
     await mkdir(clientDir, { recursive: true });
@@ -34,7 +37,8 @@ export async function buildApp(options) {
     await mkdir(join(clientDir, ".vite"), { recursive: true });
     await mkdir(join(clientDir, "assets", "routes"), { recursive: true });
     await copyPublicAssets(project.publicDir, join(clientDir, "public"));
-    const files = await collectBuildFiles(project.projectRoot, project.allowedSourceDirs);
+    await copyPublicAssets(project.publicDir, clientDir);
+    const publicAssets = await collectPublicAssetPaths(project.publicDir);
     const serverActionManifest = collectBuildServerActionManifest({
         files,
         projectRoot: project.projectRoot,
@@ -48,6 +52,12 @@ export async function buildApp(options) {
         projectRoot: project.projectRoot,
         routes,
     });
+    const generatedImportPolicy = buildGeneratedImportPolicy({
+        files,
+        projectRoot: project.projectRoot,
+        routes,
+        routesDir: project.routesDir,
+    });
     const serverModuleFiles = await writeServerModuleArtifactFiles(serverDir, serverModules);
     const serverRoutes = routes.map((route) => ({
         ...route,
@@ -74,9 +84,11 @@ export async function buildApp(options) {
         clientRoutes: clientManifestRoutes,
         routes,
     });
+    let cloudflareRouteModules;
     if (shouldBuildCloudflare) {
-        await writeCloudflareRouteModules({
+        cloudflareRouteModules = await writeCloudflareRouteModules({
             cloudflareDir,
+            files,
             prerenderedRoutes,
             projectRoot: project.projectRoot,
             routesDir: project.routesDir,
@@ -84,7 +96,7 @@ export async function buildApp(options) {
             serverModules,
         });
     }
-    await writeFile(join(serverDir, "manifest.json"), JSON.stringify({
+    const serverManifest = {
         allowedSourceDirs: project.allowedSourceDirs.map((directory) => relative(project.projectRoot, directory)),
         ...(project.assetBaseUrl === undefined ? {} : { assetBaseUrl: project.assetBaseUrl }),
         version: 1,
@@ -97,9 +109,26 @@ export async function buildApp(options) {
             : { publicAssetBaseUrl: project.publicAssetBaseUrl }),
         ...(serverActionManifest.length === 0 ? {} : { serverActionManifest }),
         ...(Object.keys(serverModuleFiles).length === 0 ? {} : { serverModuleFiles }),
-    }, null, 2));
-    await writeFile(join(clientDir, "manifest.json"), JSON.stringify({ routes: clientManifestRoutes }, null, 2));
+    };
+    const clientManifest = {
+        ...(publicAssets.length === 0 ? {} : { publicAssets }),
+        routes: clientManifestRoutes,
+    };
+    await writeFile(join(serverDir, "manifest.json"), JSON.stringify(serverManifest, null, 2));
+    await writeFile(join(serverDir, "import-policy.json"), JSON.stringify(generatedImportPolicy, null, 2));
+    await writeFile(join(clientDir, "manifest.json"), JSON.stringify(clientManifest, null, 2));
     await writeFile(join(clientDir, ".vite", "manifest.json"), JSON.stringify(viteManifestFromClientRoutes(clientManifestRoutes), null, 2));
+    if (shouldBuildAwsLambda) {
+        await writeAwsLambdaHandlerArtifact(options.outDir);
+    }
+    if (shouldBuildCloudflare) {
+        await writeCloudflareWorkerArtifact({
+            cloudflareDir,
+            clientManifest,
+            modulesFile: cloudflareRouteModules?.registryFile ?? "route-modules.mjs",
+            serverManifest,
+        });
+    }
     return { routes };
 }
 async function writeServerModuleArtifactFiles(serverDir, serverModules) {
@@ -114,6 +143,104 @@ async function writeServerModuleArtifactFiles(serverDir, serverModules) {
     }
     return files;
 }
+const nodeBuiltinPackages = new Set(builtinModules.flatMap((name) => [name, `node:${name}`]));
+const frameworkRuntimePackages = new Set([
+    "@reckona/mreact",
+    "@reckona/mreact-auth",
+    "@reckona/mreact-compiler",
+    "@reckona/mreact-query",
+    "@reckona/mreact-reactive-core",
+    "@reckona/mreact-router",
+    "@reckona/mreact-server",
+]);
+function buildGeneratedImportPolicy(options) {
+    const routePackages = new Map();
+    const allPackages = new Set();
+    const relativeRoutesDir = relative(options.projectRoot, options.routesDir);
+    for (const route of options.routes) {
+        const file = relative(options.projectRoot, route.file);
+        const packages = collectRuntimePackagesForFile({
+            file,
+            files: options.files,
+            projectRoot: options.projectRoot,
+            seen: new Set(),
+        });
+        if (packages.length > 0) {
+            routePackages.set(route.path, packages);
+            for (const packageName of packages) {
+                allPackages.add(packageName);
+            }
+        }
+    }
+    const middlewareFile = ["middleware.ts", "middleware.mreact.ts"]
+        .map((file) => (relativeRoutesDir === "" ? file : `${relativeRoutesDir}/${file}`))
+        .find((file) => options.files[file] !== undefined);
+    if (middlewareFile !== undefined) {
+        const packages = collectRuntimePackagesForFile({
+            file: middlewareFile,
+            files: options.files,
+            projectRoot: options.projectRoot,
+            seen: new Set(),
+        });
+        if (packages.length > 0) {
+            routePackages.set("middleware", packages);
+            for (const packageName of packages) {
+                allPackages.add(packageName);
+            }
+        }
+    }
+    return {
+        byRoute: Object.fromEntries([...routePackages.entries()].sort(([left], [right]) => left.localeCompare(right))),
+        runtimePackages: [...allPackages].sort(),
+        version: 1,
+    };
+}
+function collectRuntimePackagesForFile(options) {
+    if (options.seen.has(options.file)) {
+        return [];
+    }
+    const source = options.files[options.file];
+    if (source === undefined || hasModuleDirective({ code: source, directive: "use client" })) {
+        return [];
+    }
+    options.seen.add(options.file);
+    const packages = new Set();
+    for (const reference of collectStaticImportReferences({
+        code: source,
+        filename: join(options.projectRoot, options.file),
+    })) {
+        if (isRuntimePackageSpecifier(reference.source)) {
+            packages.add(runtimePackageNameForSpecifier(reference.source));
+            continue;
+        }
+        const localFile = resolveBuildLocalSourceImport(options.files, options.file, reference.source);
+        if (localFile === undefined) {
+            continue;
+        }
+        for (const packageName of collectRuntimePackagesForFile({
+            ...options,
+            file: localFile,
+        })) {
+            packages.add(packageName);
+        }
+    }
+    options.seen.delete(options.file);
+    return [...packages].sort();
+}
+function isRuntimePackageSpecifier(specifier) {
+    if (specifier.startsWith(".") || specifier.startsWith("/") || /^[A-Za-z][A-Za-z0-9+.-]*:/.test(specifier)) {
+        return false;
+    }
+    const packageName = runtimePackageNameForSpecifier(specifier);
+    return !nodeBuiltinPackages.has(specifier) && !frameworkRuntimePackages.has(packageName);
+}
+function runtimePackageNameForSpecifier(specifier) {
+    if (!specifier.startsWith("@")) {
+        return specifier.split("/")[0] ?? specifier;
+    }
+    const [scope, name] = specifier.split("/");
+    return scope !== undefined && name !== undefined ? `${scope}/${name}` : specifier;
+}
 function collectBuildServerActionManifest(options) {
     const entries = [];
     const relativeRoutesDir = relative(options.projectRoot, options.routesDir);
@@ -153,6 +280,36 @@ async function copyPublicAssets(publicDir, outDir) {
         throw error;
     }
 }
+async function collectPublicAssetPaths(publicDir) {
+    try {
+        const info = await stat(publicDir);
+        if (!info.isDirectory()) {
+            return [];
+        }
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    const paths = [];
+    await collectPublicAssetPathsInner(publicDir, "", paths);
+    return paths.sort();
+}
+async function collectPublicAssetPathsInner(publicDir, relativeDir, paths) {
+    const entries = await readdir(join(publicDir, relativeDir), { withFileTypes: true });
+    for (const entry of entries) {
+        const relativePath = relativeDir === "" ? entry.name : `${relativeDir}/${entry.name}`;
+        if (entry.isDirectory()) {
+            await collectPublicAssetPathsInner(publicDir, relativePath, paths);
+            continue;
+        }
+        if (entry.isFile()) {
+            paths.push(`/${relativePath}`);
+        }
+    }
+}
 function isNodeError(error) {
     return error instanceof Error && "code" in error;
 }
@@ -300,9 +457,14 @@ async function buildServerModuleArtifacts(options) {
             }
             continue;
         }
-        const serverOutputs = route !== undefined && isStreamRouteSource(source)
-            ? ["stream", "string"]
-            : ["string"];
+        const streamRoute = route !== undefined &&
+            shouldBuildRouteAsStream({
+                filename: file,
+                files: options.files,
+                projectRoot: options.projectRoot,
+                source,
+            });
+        const serverOutputs = streamRoute ? ["stream", "string"] : ["string"];
         const code = route === undefined ? source : stripRouteBuildExports(source);
         const clientInference = route === undefined
             ? { client: false, clientBoundaryImports: [], diagnostics: [] }
@@ -323,6 +485,7 @@ async function buildServerModuleArtifacts(options) {
                 route,
                 routeCode: code,
                 source,
+                streamRoute,
             });
         }
         for (const serverOutput of serverOutputs) {
@@ -337,6 +500,12 @@ async function buildServerModuleArtifacts(options) {
             });
             const fatalDiagnostics = output.diagnostics.filter((diagnostic) => diagnostic.code !== "MR_UNSUPPORTED_SERVER_EVENT_HANDLER");
             if (fatalDiagnostics.length > 0) {
+                if (serverOutput === "string" &&
+                    streamRoute &&
+                    route?.kind === "page" &&
+                    fatalDiagnostics.every((diagnostic) => diagnostic.code === "MR_UNSUPPORTED_AWAIT_INNER_COMPONENT")) {
+                    continue;
+                }
                 throw new Error(fatalDiagnostics.map((diagnostic) => formatDiagnostic(file, diagnostic)).join("\n"));
             }
             artifact[serverOutput] = {
@@ -360,10 +529,124 @@ function builtRouteSourceAnalysisSummary(options) {
         routeCode: options.routeCode,
         routePath: options.route.path,
         sourceHash: hashText(options.source),
-        streamRoute: isStreamRouteSource(options.source),
+        streamRoute: options.streamRoute,
         usesRuntimeCacheControl: usesRuntimeCacheControl(options.source),
     };
 }
+function shouldBuildRouteAsStream(options) {
+    return (isStreamRouteSource(options.source) ||
+        routeClosureMayUseAwaitBoundary({
+            filename: options.filename,
+            files: options.files,
+            projectRoot: options.projectRoot,
+            source: options.source,
+            seen: new Set(),
+        }));
+}
+function routeClosureMayUseAwaitBoundary(options) {
+    if (options.seen.has(options.filename) ||
+        hasModuleDirective({ code: options.source, directive: "use client" })) {
+        return false;
+    }
+    options.seen.add(options.filename);
+    try {
+        if (mayUseAwaitBoundarySource(options.source)) {
+            return true;
+        }
+        const jsxComponentRoots = new Set(collectJsxComponentRootNames({
+            code: options.source,
+            filename: join(options.projectRoot, options.filename),
+        }));
+        for (const reference of collectStaticImportReferences({
+            code: options.source,
+            filename: join(options.projectRoot, options.filename),
+        })) {
+            if (!isRenderedStaticImportReference(reference, jsxComponentRoots)) {
+                continue;
+            }
+            const resolved = resolveBuildLocalSourceImport(options.files, options.filename, reference.source);
+            if (resolved === undefined) {
+                continue;
+            }
+            const importedSource = options.files[resolved];
+            if (importedSource !== undefined &&
+                routeClosureMayUseAwaitBoundary({
+                    filename: resolved,
+                    files: options.files,
+                    projectRoot: options.projectRoot,
+                    seen: options.seen,
+                    source: importedSource,
+                })) {
+                return true;
+            }
+        }
+        return false;
+    }
+    finally {
+        options.seen.delete(options.filename);
+    }
+}
+function isRenderedStaticImportReference(reference, jsxComponentRoots) {
+    return reference.localNames.some((localName) => jsxComponentRoots.has(localName));
+}
+function resolveBuildLocalSourceImport(files, importer, specifier) {
+    if (!specifier.startsWith(".")) {
+        return undefined;
+    }
+    const base = join(dirname(importer), specifier);
+    for (const candidate of buildSourceModuleCandidates(base)) {
+        if (files[candidate] !== undefined) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function buildSourceModuleCandidates(base) {
+    if (hasSourceModuleExtension(base)) {
+        return [base, ...typescriptSourceModuleCandidates(base)];
+    }
+    if (extname(base) !== "") {
+        return [];
+    }
+    return [
+        `${base}.ts`,
+        `${base}.tsx`,
+        `${base}.mreact.tsx`,
+        `${base}.js`,
+        `${base}.jsx`,
+        `${base}.mjs`,
+        `${base}.mts`,
+        `${base}.cjs`,
+        `${base}.cts`,
+        join(base, "index.ts"),
+        join(base, "index.tsx"),
+        join(base, "index.mreact.tsx"),
+        join(base, "index.js"),
+        join(base, "index.jsx"),
+        join(base, "index.mjs"),
+        join(base, "index.mts"),
+        join(base, "index.cjs"),
+        join(base, "index.cts"),
+    ];
+}
+function hasSourceModuleExtension(path) {
+    return /\.(?:mreact\.tsx|tsx?|jsx?|mjs|mts|cjs|cts)$/.test(path);
+}
+function typescriptSourceModuleCandidates(path) {
+    if (path.endsWith(".js")) {
+        return [`${path.slice(0, -3)}.ts`, `${path.slice(0, -3)}.tsx`];
+    }
+    if (path.endsWith(".jsx")) {
+        return [`${path.slice(0, -4)}.tsx`];
+    }
+    if (path.endsWith(".mjs")) {
+        return [`${path.slice(0, -4)}.mts`];
+    }
+    if (path.endsWith(".cjs")) {
+        return [`${path.slice(0, -4)}.cts`];
+    }
+    return [];
+}
 function usesRuntimeCacheControl(code) {
     return /\bcacheControl\s*\(/.test(code);
 }
@@ -407,10 +690,9 @@ async function bundleRouteMetadataModuleCode(options) {
     });
 }
 async function bundleRouteRequestModuleCode(options) {
-    const output = await bundle({
-        bundle: true,
-        format: "esm",
-        logLevel: "silent",
+    const output = await bundleRouterModule({
+        code: options.code,
+        filename: options.filename,
         platform: "node",
         plugins: [
             createAppRouterImportPolicyPlugin({
@@ -419,18 +701,8 @@ async function bundleRouteRequestModuleCode(options) {
                 label: options.label,
             }),
         ],
-        write: false,
-        jsx: "transform",
-        jsxFactory: "__mreact_jsx",
-        jsxFragment: "__mreact_fragment",
-        stdin: {
-            contents: options.code,
-            loader: "tsx",
-            resolveDir: dirname(options.filename),
-            sourcefile: options.filename,
-        },
     });
-    const code = output.outputFiles[0]?.text;
+    const code = output.code;
     if (code === undefined) {
         throw new Error(`Failed to compile ${options.label.toLowerCase()} for ${options.filename}.`);
     }
@@ -467,7 +739,32 @@ async function writeCloudflareRouteModules(options) {
         const routeId = routeIdForPath(route.path);
         const routeModuleFile = `routes/${routeId}.mjs`;
         let routeModuleExports;
-        const serverOutput = isStreamRouteSource(source) ? "stream" : "string";
+        if (route.kind === "server") {
+            try {
+                const routeOutput = await buildCloudflareServerRouteModule({
+                    filename: route.file,
+                });
+                const serverRouteFile = `routes/${routeId}.${hashText(routeOutput).slice(0, 8)}.server.mjs`;
+                await writeFile(join(options.cloudflareDir, serverRouteFile), routeOutput);
+                const serverRouteImport = `./${serverRouteFile.split("/").pop() ?? serverRouteFile}`;
+                routeModuleExports = [`export * from ${JSON.stringify(serverRouteImport)};`];
+            }
+            catch (error) {
+                throw new Error(`Failed to build Cloudflare server route module for ${routeFile}: ${errorMessage(error)}`);
+            }
+            await writeFile(join(options.cloudflareDir, routeModuleFile), `${routeModuleExports.join("\n")}\n`);
+            registryEntries.push(`${JSON.stringify(routeFile)}: () => import(${JSON.stringify(`./${routeModuleFile}`)})`);
+            continue;
+        }
+        const serverOutput = options.serverModules[routeFile]?.analysis?.streamRoute === true ||
+            shouldBuildRouteAsStream({
+                filename: routeFile,
+                files: options.files,
+                projectRoot: options.projectRoot,
+                source,
+            })
+            ? "stream"
+            : "string";
         try {
             const componentOutput = serverOutput === "stream"
                 ? await buildCloudflareStreamRouteComponentModule({
@@ -518,6 +815,7 @@ async function writeCloudflareRouteModules(options) {
         ``,
     ].join("\n");
     await writeFile(join(options.cloudflareDir, "route-modules.mjs"), registrySource);
+    return { registryFile: "route-modules.mjs" };
 }
 async function buildCloudflareServerComponentModule(options) {
     const entry = `import * as routeModule from ${JSON.stringify(options.filename)};
@@ -819,24 +1117,37 @@ async function buildCloudflareRouteLoaderModule(options) {
         resolveDir: dirname(options.filename),
     });
 }
+async function buildCloudflareServerRouteModule(options) {
+    const entry = `import * as routeModule from ${JSON.stringify(options.filename)};
+
+export const GET = routeModule.GET;
+export const HEAD = routeModule.HEAD;
+export const POST = routeModule.POST;
+export const PUT = routeModule.PUT;
+export const PATCH = routeModule.PATCH;
+export const DELETE = routeModule.DELETE;
+export const OPTIONS = routeModule.OPTIONS;
+export const ALL = routeModule.ALL;
+const defaultHandler = routeModule.default;
+export default defaultHandler;`;
+    return bundleCloudflareModule({
+        entry,
+        filename: `${options.filename}.mreact-cloudflare-server-route.js`,
+        plugins: [cloudflareWorkspaceRuntimePlugin()],
+        resolveDir: dirname(options.filename),
+    });
+}
 async function bundleCloudflareModule(options) {
-    const output = await bundle({
-        bundle: true,
-        format: "esm",
-        logLevel: "silent",
+    const output = await bundleRouterModule({
+        code: options.entry,
+        filename: options.filename,
         minify: true,
         platform: "browser",
+        preserveExports: true,
         plugins: options.plugins,
         target: "es2022",
-        write: false,
-        stdin: {
-            contents: options.entry,
-            loader: "js",
-            resolveDir: options.resolveDir,
-            sourcefile: options.filename,
-        },
     });
-    const code = output.outputFiles[0]?.text;
+    const code = output.code;
     if (code === undefined) {
         throw new Error(`Failed to build Cloudflare route module for ${options.filename}.`);
     }
@@ -1039,9 +1350,10 @@ export { cookies, headers, html, json, next, notFound, redirect, redirectExterna
     };
 }
 function cloudflareRouteRequiresGeneratedModule(route, prerenderedRoutes) {
-    return (route.kind === "page" &&
-        (route.segments.some((segment) => segment.kind !== "static") ||
-            prerenderedRoutes[route.path] === undefined));
+    return (route.kind === "server" ||
+        (route.kind === "page" &&
+            (route.segments.some((segment) => segment.kind !== "static") ||
+                prerenderedRoutes[route.path] === undefined)));
 }
 function isServerComponentFile(file) {
     return /(?:^|\/)(?:page|layout|template|loading|error|not-found)(?:\.mreact)?\.tsx$/.test(file);
@@ -1153,18 +1465,139 @@ async function writeNavigationRuntimeBundle(clientDir) {
     await writeFile(join(clientDir, script), output.code);
     return script;
 }
-async function validateProductionRoutes(routes) {
-    for (const route of routes) {
+async function writeAwsLambdaHandlerArtifact(outDir) {
+    const awsLambdaDir = join(outDir, "aws-lambda");
+    await mkdir(awsLambdaDir, { recursive: true });
+    await writeFile(join(awsLambdaDir, "mreact-handler.mjs"), awsLambdaHandlerSource(".."));
+}
+async function writeCloudflareWorkerArtifact(options) {
+    await writeFile(join(options.cloudflareDir, "worker.mjs"), [
+        `import { createCloudflareBuiltRequestHandler, createCloudflareRouteModuleRenderer, createCloudflareStaticAssetLoader } from "@reckona/mreact-router/adapters/cloudflare";`,
+        `import { routeModules } from ${JSON.stringify(`./${options.modulesFile}`)};`,
+        ``,
+        `const serverManifest = ${JSON.stringify(options.serverManifest, null, 2)};`,
+        `const clientManifest = ${JSON.stringify(options.clientManifest, null, 2)};`,
+        ``,
+        `export default createCloudflareBuiltRequestHandler({`,
+        `  assets: createCloudflareStaticAssetLoader({`,
+        `    binding: (env) => env?.ASSETS,`,
+        `    clientManifest,`,
+        `  }),`,
+        `  clientManifest,`,
+        `  renderRoute: createCloudflareRouteModuleRenderer({ modules: routeModules }),`,
+        `  serverManifest,`,
+        `});`,
+        ``,
+    ].join("\n"));
+}
+export async function packageAwsLambdaArtifact(options) {
+    await assertRequiredBuildFile(join(options.fromDir, "server", "manifest.json"));
+    await assertRequiredBuildFile(join(options.fromDir, "server", "import-policy.json"));
+    await assertRequiredBuildFile(join(options.fromDir, "client", "manifest.json"));
+    await rm(options.outDir, { force: true, recursive: true });
+    await mkdir(options.outDir, { recursive: true });
+    await cp(options.fromDir, join(options.outDir, ".mreact"), {
+        force: true,
+        recursive: true,
+    });
+    await copyAwsLambdaProjectMetadata({
+        fromDir: dirname(options.fromDir),
+        outDir: options.outDir,
+    });
+    await writeFile(join(options.outDir, "mreact-handler.mjs"), awsLambdaHandlerSource(".mreact"));
+    const files = await collectAwsLambdaArtifactFiles(options.outDir, "");
+    const manifest = {
+        files,
+        handler: "mreact-handler.handler",
+        runtime: "aws-lambda",
+        totalBytes: files.reduce((total, file) => total + file.bytes, 0),
+        version: 1,
+    };
+    await writeFile(join(options.outDir, "mreact-lambda-artifact.json"), JSON.stringify(manifest, null, 2));
+    return manifest;
+}
+async function assertRequiredBuildFile(path) {
+    try {
+        const info = await stat(path);
+        if (info.isFile()) {
+            return;
+        }
+    }
+    catch {
+        // Throw the actionable error below.
+    }
+    throw new Error(`Missing required mreact build artifact: ${path}`);
+}
+async function copyAwsLambdaProjectMetadata(options) {
+    for (const file of [
+        "package.json",
+        "package-lock.json",
+        "npm-shrinkwrap.json",
+        "pnpm-lock.yaml",
+        "pnpm-workspace.yaml",
+        "bun.lock",
+    ]) {
+        try {
+            await cp(join(options.fromDir, file), join(options.outDir, file), { force: true });
+        }
+        catch (error) {
+            if (!isNodeError(error) || error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+}
+async function collectAwsLambdaArtifactFiles(rootDir, relativeDir) {
+    const entries = await readdir(join(rootDir, relativeDir), { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const relativePath = relativeDir === "" ? entry.name : `${relativeDir}/${entry.name}`;
+        const absolutePath = join(rootDir, relativePath);
+        if (entry.isDirectory()) {
+            files.push(...(await collectAwsLambdaArtifactFiles(rootDir, relativePath)));
+            continue;
+        }
+        if (entry.isFile()) {
+            const info = await stat(absolutePath);
+            files.push({ bytes: info.size, path: relativePath });
+        }
+    }
+    return files.sort((left, right) => right.bytes - left.bytes || left.path.localeCompare(right.path));
+}
+function awsLambdaHandlerSource(outDirRelativeToHandler) {
+    return `import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { createPreloadedAwsLambdaRequestHandler } from "@reckona/mreact-router/adapters/aws-lambda";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+export const handler = await createPreloadedAwsLambdaRequestHandler({
+  importPolicy: "generated",
+  outDir: resolve(here, ${JSON.stringify(outDirRelativeToHandler)}),
+  timings: process.env.MREACT_ROUTER_TIMINGS === "1",
+});
+`;
+}
+async function validateProductionRoutes(options) {
+    for (const route of options.routes) {
         if (route.kind !== "page") {
             continue;
         }
         const source = await readFile(route.file, "utf8");
+        const filename = relative(options.projectRoot, route.file);
         const output = transform({
             code: stripRouteBuildExports(source),
             dev: false,
             filename: route.file,
             serverEscape: nativeEscapeTransform,
-            serverOutput: isStreamRouteSource(source) ? "stream" : "string",
+            serverOutput: shouldBuildRouteAsStream({
+                filename,
+                files: options.files,
+                projectRoot: options.projectRoot,
+                source,
+            })
+                ? "stream"
+                : "string",
             target: "server",
         });
         const fatalDiagnostics = output.diagnostics.filter((diagnostic) => diagnostic.code !== "MR_UNSUPPORTED_SERVER_EVENT_HANDLER");