@textjs/app 0.0.0-stage → 1.0.3

package/src/server/adapters/cloudflare.ts

@@ -0,0 +1,111 @@
+/**
+ * `text build --adapter cloudflare`: Cloudflare Pages advanced mode.
+ * `dist/_worker.js` runs middleware and route handlers; `_routes.json` keeps
+ * hashed assets on Pages' static CDN; `env.ASSETS` serves everything else.
+ *
+ * Requires the `nodejs_compat` compatibility flag (the data cache uses
+ * `AsyncLocalStorage`).
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { matcherCouldMatch, middlewareMatchers } from "../middleware-runtime";
+import type { MiddlewareModule } from "../middleware";
+import { bundleServerEntry } from "./bundle";
+import { assertNoServerRoutes, removeServerBundle, serverEntry, type AdapterContext, type AdapterResult } from "./shared";
+
+export const CLOUDFLARE_COMPAT = { date: "2025-01-01", flags: ["nodejs_compat"] } as const;
+
+const BODY = `
+async function asset(env, url, request) {
+  const res = await env.ASSETS.fetch(new Request(url, { method: request.method, headers: request.headers }));
+  if (res.status === 404) return null;
+  if (!new URL(url).pathname.startsWith("/assets/") || !res.ok) return res;
+  // basePath apps serve hashed assets through the worker (they live at dist/assets, not dist/<base>/assets).
+  const out = new Response(res.body, res);
+  out.headers.set("cache-control", "public, max-age=31536000, immutable");
+  return out;
+}
+
+const handler = createRequestHandler({
+  ...options,
+  assets(pathname, request, context) {
+    return asset(context.env, new URL(pathname, request.url), request);
+  },
+  document(request, context) {
+    // Pages redirects /index.html to /, so ask for the directory index.
+    return asset(context.env, new URL("/", request.url), request);
+  },
+});
+
+export default {
+  async fetch(request, env, ctx) {
+    try {
+      return await handler(request, { env, waitUntil: (p) => ctx.waitUntil(p) });
+    } catch (error) {
+      console.error(error);
+      return new Response("500 | Internal Server Error", { status: 500 });
+    }
+  },
+};
+`;
+
+export interface CloudflareRoutes {
+  version: 1;
+  include: string[];
+  exclude: string[];
+}
+
+function listAssets(outDir: string): string[] {
+  const dir = join(outDir, "assets");
+  if (!existsSync(dir)) return [];
+  const out: string[] = [];
+  const walk = (d: string, rel: string): void => {
+    for (const name of readdirSync(d)) {
+      const p = join(d, name);
+      if (statSync(p).isDirectory()) walk(p, `${rel}/${name}`);
+      else out.push(`${rel}/${name}`);
+    }
+  };
+  walk(dir, "/assets");
+  return out;
+}
+
+/**
+ * `_routes.json`: invoke the worker for everything except hashed assets.
+ * Pages serves excluded paths straight from `dist/`, so the exclusion only
+ * applies without a basePath (files live at `dist/assets`, not
+ * `dist/<base>/assets`), and only when no middleware matcher could cover an
+ * asset (`has` / `missing` are request-time and ignored here).
+ */
+export function cloudflareRoutes(ctx: AdapterContext, middleware: MiddlewareModule | null): CloudflareRoutes {
+  const base = ctx.basePath;
+  const matchers = middleware ? middlewareMatchers(middleware) : null;
+  const assets = listAssets(ctx.outDir);
+  const assetsRun = middleware ? [...assets, "/assets/__probe.js"].some((p) => matcherCouldMatch(matchers, p)) : false;
+  return { version: 1, include: [`${base}/*`], exclude: assetsRun || base ? [] : ["/assets/*"] };
+}
+
+export async function adaptCloudflare(ctx: AdapterContext, middleware: MiddlewareModule | null): Promise<AdapterResult> {
+  assertNoServerRoutes(ctx, "cloudflare");
+  await bundleServerEntry({ root: ctx.root, config: ctx.config, code: serverEntry(ctx, { body: BODY }), outFile: join(ctx.outDir, "_worker.js"), target: "webworker" });
+  writeFileSync(join(ctx.outDir, "_routes.json"), `${JSON.stringify(cloudflareRoutes(ctx, middleware), null, 2)}\n`);
+  const headersFile = join(ctx.outDir, "_headers");
+  const rule = "/assets/*\n  Cache-Control: public, max-age=31536000, immutable\n";
+  if (!existsSync(headersFile)) writeFileSync(headersFile, rule);
+  else if (!/^\/assets\/\*\s*$/m.test(readFileSync(headersFile, "utf8"))) writeFileSync(headersFile, `${readFileSync(headersFile, "utf8").trimEnd()}\n\n${rule}`);
+  // Without a top-level 404.html, Pages answers unknown files with index.html (200), and missing assets would render the app.
+  const notFoundFile = join(ctx.outDir, "404.html");
+  if (!existsSync(notFoundFile)) writeFileSync(notFoundFile, "404 | This page could not be found.\n");
+  // Pages would publish dist/.text (server bundles, manifests) as static files.
+  removeServerBundle(ctx.outDir);
+  return {
+    adapter: "cloudflare",
+    output: ctx.outDir,
+    notes: [
+      `Requires the ${CLOUDFLARE_COMPAT.flags.join(", ")} compatibility flag (Pages → Settings → Runtime, or wrangler.toml).`,
+      `Preview: bunx wrangler pages dev ${ctx.config.outDir ?? "dist"} --compatibility-flags=nodejs_compat`,
+      `Deploy:  bunx wrangler pages deploy ${ctx.config.outDir ?? "dist"}`,
+    ],
+  };
+}

package/src/server/adapters/index.ts

@@ -0,0 +1,29 @@
+/**
+ * `text build --adapter <name>` dispatch.
+ */
+
+import { join } from "node:path";
+import type { MiddlewareModule } from "../middleware";
+import { adaptBun } from "./bun";
+import { adaptCloudflare } from "./cloudflare";
+import { adaptStatic } from "./static";
+import { adaptVercel } from "./vercel";
+import type { AdapterContext, AdapterName, AdapterResult } from "./shared";
+
+export { ADAPTERS, detectAdapter, isAdapterName, type AdapterContext, type AdapterName, type AdapterResult } from "./shared";
+
+/** `.text/server/` bundle paths written by `text build`. */
+export const SERVER_DIR = join(".text", "server");
+
+export async function runAdapter(name: AdapterName, ctx: AdapterContext, middleware: MiddlewareModule | null): Promise<AdapterResult> {
+  switch (name) {
+    case "static":
+      return adaptStatic(ctx, middleware, join(ctx.outDir, SERVER_DIR, "api.mjs"));
+    case "bun":
+      return adaptBun(ctx);
+    case "vercel":
+      return adaptVercel(ctx, middleware);
+    case "cloudflare":
+      return adaptCloudflare(ctx, middleware);
+  }
+}

package/src/server/adapters/runtime-node.ts

@@ -0,0 +1,34 @@
+/**
+ * `.text/server/runtime.mjs`: `middleware.ts` and the `cacheHandler` store,
+ * bundled by `text build` for `text start`.
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { setCacheStore, type CacheStore } from "../cache";
+import type { MiddlewareModule } from "../middleware";
+
+export const RUNTIME_BUNDLE = "runtime.mjs";
+
+export interface ServerRuntime {
+  middleware?: MiddlewareModule;
+  cacheStore?: CacheStore;
+}
+
+/** Entry source for `runtime.mjs`. */
+export function serverRuntimeEntry(middlewareFile: string | null, cacheHandlerFile: string | null): string {
+  const lines: string[] = [];
+  if (middlewareFile) lines.push(`import * as middleware from ${JSON.stringify(middlewareFile)};`, "export { middleware };");
+  if (cacheHandlerFile) lines.push(`import cacheStore from ${JSON.stringify(cacheHandlerFile)};`, "export { cacheStore };");
+  return lines.join("\n");
+}
+
+/** Load `runtime.mjs` from a build (installing its cache store). */
+export async function loadServerRuntime(outDir: string, fresh = false): Promise<ServerRuntime | null> {
+  const file = join(outDir, ".text", "server", RUNTIME_BUNDLE);
+  if (!existsSync(file)) return null;
+  const mod = (await import(pathToFileURL(file).href + (fresh ? `?t=${Date.now()}` : ""))) as ServerRuntime;
+  if (mod.cacheStore) setCacheStore(mod.cacheStore);
+  return mod;
+}

package/src/server/adapters/runtime.ts

@@ -0,0 +1,145 @@
+/**
+ * The Web-standard Text.js server (`(Request) => Response`) bundled into every
+ * deploy adapter: middleware → rewrites → route handlers (with the route
+ * cache) → static assets → the SPA document.
+ *
+ * No Node imports: this file runs on Bun, Node, Vercel and Cloudflare Workers.
+ */
+
+import type { Rewrite } from "../../config";
+import { matchAppRoutes, type RouteManifest, type RouteSegmentNode } from "../../routing";
+import { runRouteHandlerWithCache } from "../cache-route";
+import { setCacheStore, type CacheStore } from "../cache";
+import { applyRewrites, compileRewrite, isLoopbackUrl, normalizeRequestTarget, proxyFetch, type RouteHandlerModule } from "../http";
+import type { MiddlewareModule } from "../middleware";
+import { rebuild, runMiddleware, withMiddlewareHeaders, type MiddlewareMerge } from "../middleware-runtime";
+
+export interface RequestContext {
+  waitUntil?: (promise: Promise<unknown>) => void;
+  /** Platform bindings (Cloudflare `env`). */
+  env?: unknown;
+  /** The client's address, when the platform knows it. */
+  clientAddress?: string;
+}
+
+export interface RequestHandlerOptions {
+  /** API route manifest: leaf `files.page` values are keys into `handlers`. */
+  manifest: RouteManifest;
+  handlers: Record<string, RouteHandlerModule>;
+  middleware?: MiddlewareModule;
+  /** Skip middleware (it already ran at the edge, e.g. on Vercel). */
+  skipMiddleware?: boolean;
+  basePath?: string;
+  rewrites?: Rewrite[];
+  cacheStore?: CacheStore;
+  /** Serve a static file for `pathname` (without basePath), or `null`. */
+  assets?: (pathname: string, request: Request, context: RequestContext) => Promise<Response | null> | Response | null;
+  /** The SPA document (`index.html`) for page routes. */
+  document?: (request: Request, context: RequestContext) => Promise<Response | null> | Response | null;
+  /**
+   * Server-rendered routes (`runtime = "server"`) and prerendered shells, after
+   * middleware and rewrites. `url` is the path and query without basePath.
+   */
+  live?: (request: Request, url: string, context: RequestContext) => Promise<Response | null> | Response | null;
+}
+
+export type TextRequestHandler = (request: Request, context?: RequestContext) => Promise<Response>;
+
+function notFound(): Response {
+  return new Response("404 | This page could not be found.", { status: 404, headers: { "content-type": "text/plain; charset=utf-8" } });
+}
+
+function stripBase(pathname: string, basePath: string): string | null {
+  if (!basePath) return pathname;
+  if (pathname === basePath) return "/";
+  return pathname.startsWith(`${basePath}/`) ? pathname.slice(basePath.length) : null;
+}
+
+function matchApi(manifest: RouteManifest, pathname: string): { id: string; pattern: string; params: Record<string, string | string[]> } | null {
+  const m = matchAppRoutes(manifest, pathname);
+  if (!m) return null;
+  const leaf = m.chain[m.chain.length - 1] as RouteSegmentNode;
+  const id = leaf.files?.page;
+  return id ? { id, pattern: m.pattern, params: m.params } : null;
+}
+
+function safeDecode(pathname: string): string | null {
+  try {
+    return decodeURIComponent(pathname);
+  } catch {
+    return null;
+  }
+}
+
+export function createRequestHandler(options: RequestHandlerOptions): TextRequestHandler {
+  const basePath = options.basePath ?? "";
+  const rewrites = (options.rewrites ?? []).map(compileRewrite);
+  if (options.cacheStore) setCacheStore(options.cacheStore);
+
+  return async (raw, context = {}) => {
+    // `//evil.com/x` (and `/\evil.com/x`) must never resolve to another origin downstream.
+    const rawUrl = new URL(raw.url);
+    const normalized = normalizeRequestTarget(`${rawUrl.pathname}${rawUrl.search}`);
+    const incoming = normalized === `${rawUrl.pathname}${rawUrl.search}` ? raw : rebuild(raw, new Headers(raw.headers), new URL(normalized, rawUrl.origin));
+    const url = new URL(incoming.url);
+    const stripped = stripBase(url.pathname, basePath);
+    if (stripped === null) return notFound();
+    let pathname = stripped;
+    let search = url.search;
+    let request = incoming;
+    let extra: Headers | null = null;
+    let merge: MiddlewareMerge = {};
+    const finish = (response: Response): Response => (extra ? withMiddlewareHeaders(response, extra, merge) : response);
+
+    if (options.middleware && !options.skipMiddleware) {
+      const outcome = await runMiddleware(options.middleware, request, { basePath, waitUntil: context.waitUntil });
+      if (outcome.type === "response") return outcome.response;
+      request = outcome.request;
+      extra = outcome.headers;
+      merge = { status: outcome.status, private: outcome.private };
+      if (outcome.rewrite) {
+        if (outcome.rewrite.origin !== url.origin) return finish(await proxyFetch(request, outcome.rewrite, { stripCredentials: !isLoopbackUrl(outcome.rewrite.href) }));
+        const p = stripBase(outcome.rewrite.pathname, basePath);
+        pathname = p ?? outcome.rewrite.pathname;
+        search = outcome.rewrite.search;
+      }
+    }
+
+    if (rewrites.length > 0) {
+      const target = applyRewrites(rewrites, pathname + search);
+      if (target) {
+        if (/^[a-z]+:\/\//i.test(target)) return finish(await proxyFetch(request, target, { stripCredentials: !isLoopbackUrl(target) }));
+        const u = new URL(target, url.origin);
+        pathname = u.pathname;
+        search = u.search;
+      }
+    }
+
+    if (options.live) {
+      const live = await options.live(request, pathname + search, context);
+      if (live) return finish(live);
+    }
+
+    const decoded = safeDecode(pathname);
+    if (decoded === null) return finish(new Response("400 | Bad Request", { status: 400 }));
+    const api = matchApi(options.manifest, decoded);
+    const mod = api ? options.handlers[api.id] : undefined;
+    if (api && mod) {
+      const target = new URL(pathname + search, url.origin);
+      const req = target.href === request.url ? request : rebuild(request, new Headers(request.headers), target);
+      return finish(await runRouteHandlerWithCache(mod, req, { params: api.params, pattern: api.pattern, pathname: decoded, waitUntil: context.waitUntil }));
+    }
+
+    const method = request.method.toUpperCase();
+    if (method !== "GET" && method !== "HEAD") return finish(new Response(null, { status: 405, headers: { allow: "GET, HEAD" } }));
+    const hidden = decoded.split(/[/\\]/).some((p) => p.startsWith(".") && p.length > 1);
+    if (!hidden && options.assets) {
+      const asset = await options.assets(decoded, request, context);
+      if (asset) return finish(asset);
+    }
+    const last = decoded.split("/").pop() ?? "";
+    if (last.includes(".") || hidden || !options.document) return finish(notFound());
+    const doc = await options.document(request, context);
+    return finish(doc ?? notFound());
+  };
+}

package/src/server/adapters/shared.ts

@@ -0,0 +1,159 @@
+/**
+ * Shared adapter plumbing: the build context, generated server entries and
+ * route-pattern → regular-expression helpers.
+ */
+
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import type { Rewrite, TextConfig } from "../../config";
+import { parseSegment } from "../../routing";
+import { generateApiModule } from "../../vite-plugin";
+import type { ApiRoute, AppScan } from "../scan";
+import { txError } from "@textjs/core";
+import { compileMatcherSource, matcherKeys } from "../middleware-runtime";
+import { listServerPages } from "../live-routes";
+import { frameworkFile } from "./bundle";
+
+export const ADAPTERS = ["static", "bun", "vercel", "cloudflare"] as const;
+export type AdapterName = (typeof ADAPTERS)[number];
+
+export interface AdapterContext {
+  root: string;
+  /** The client build (`dist/`). */
+  outDir: string;
+  config: TextConfig;
+  scan: AppScan;
+  api: ApiRoute[];
+  basePath: string;
+  /** Config rewrites, resolved at build time. */
+  rewrites: Rewrite[];
+  middlewareFile: string | null;
+  cacheHandlerFile: string | null;
+  print(line?: string): void;
+}
+
+export interface AdapterResult {
+  adapter: AdapterName;
+  /** Deployable output directory. */
+  output: string;
+  /** Lines for the build summary. */
+  notes: string[];
+}
+
+export function isAdapterName(value: unknown): value is AdapterName {
+  return typeof value === "string" && (ADAPTERS as readonly string[]).includes(value);
+}
+
+/** The adapter implied by the build environment (`VERCEL=1`, `CF_PAGES=1`). */
+export function detectAdapter(env: Record<string, string | undefined> = process.env): AdapterName | undefined {
+  if (env.VERCEL === "1") return "vercel";
+  if (env.CF_PAGES === "1") return "cloudflare";
+  return undefined;
+}
+
+const json = JSON.stringify;
+
+export interface EntryOptions {
+  /** Extra source appended after `options` is declared. */
+  body: string;
+  /** Import the route handler modules (default `true`). */
+  handlers?: boolean;
+  /** Import `middleware.ts` (default `true`). */
+  middleware?: boolean;
+  /** Import `createRequestHandler` (default `true`). */
+  runtime?: boolean;
+}
+
+/**
+ * The common entry prelude: route handlers (`manifest`, `handlers`), the
+ * middleware module, the cache store and `options` for `createRequestHandler`.
+ */
+export function serverEntry(ctx: AdapterContext, opts: EntryOptions): string {
+  const lines: string[] = [];
+  const withHandlers = opts.handlers !== false;
+  const withMiddleware = opts.middleware !== false && ctx.middlewareFile !== null;
+  if (withHandlers) lines.push(generateApiModule(ctx.scan));
+  else lines.push("export const manifest = { segment: \"\" };", "export const handlers = {};");
+  if (opts.runtime !== false) lines.push(`import { createRequestHandler } from ${json(frameworkFile("server/adapters/runtime.ts"))};`);
+  if (withMiddleware) lines.push(`import * as middleware from ${json(ctx.middlewareFile)};`);
+  const withStore = ctx.cacheHandlerFile !== null && opts.runtime !== false;
+  if (withStore) lines.push(`import cacheStore from ${json(ctx.cacheHandlerFile)};`);
+  lines.push(
+    `const options = { manifest, handlers, basePath: ${json(ctx.basePath)}, rewrites: ${json(ctx.rewrites)}${withMiddleware ? ", middleware" : ""}${withStore ? ", cacheStore" : ""} };`,
+    opts.body,
+  );
+  return lines.join("\n");
+}
+
+export function escapeRegex(s: string): string {
+  return s.replace(/[.+*?^${}()|[\]\\/]/g, "\\$&");
+}
+
+/** App route pattern (`/api/posts/[id]`, `/api/[...slug]`) → anchored regex source with one outer capture. */
+export function patternRegex(pattern: string, basePath = ""): string {
+  let body = "";
+  for (const seg of pattern.split("/").filter(Boolean)) {
+    const p = parseSegment(seg);
+    if (p.kind === "group") continue;
+    if (p.kind === "static") body += `\\/${escapeRegex(p.name)}`;
+    else if (p.kind === "dynamic") body += "\\/[^/]+";
+    else if (p.kind === "catchAll") body += "\\/[^/]+(?:\\/[^/]+)*";
+    else body += "(?:\\/[^/]+(?:\\/[^/]+)*)?";
+  }
+  return `^(${escapeRegex(basePath)}${body})\\/?$`;
+}
+
+/** A middleware matcher, prefixed with basePath, as an anchored regex source. */
+export function matcherRegex(source: string, basePath = ""): string {
+  const re = compileMatcherSource(source);
+  return `^${escapeRegex(basePath)}${re.slice(1)}`;
+}
+
+/** Config rewrite `source` → `{ src, dest }` with `$n` substitutions. */
+export function rewriteRoute(rewrite: Rewrite, basePath = ""): { src: string; dest: string } {
+  // Capture order, including unnamed groups (`/(.*)`) and groups inside custom patterns.
+  const names = matcherKeys(rewrite.source);
+  const src = matcherRegex(rewrite.source, basePath);
+  const external = /^[a-z]+:\/\//i.test(rewrite.destination);
+  let dest = rewrite.destination.replace(/:([A-Za-z_]\w*)[*+?]?/g, (_, n: string) => {
+    const i = names.indexOf(n);
+    return i < 0 ? "" : `$${i + 1}`;
+  });
+  if (!external) dest = basePath + dest;
+  return { src, dest };
+}
+
+/** Copy `from` into `to`, skipping the `.text/` build metadata directory. */
+export function copyStatic(from: string, to: string, skip: (rel: string) => boolean = () => false): void {
+  mkdirSync(to, { recursive: true });
+  const walk = (dir: string, rel: string): void => {
+    for (const name of readdirSync(dir)) {
+      const r = rel ? `${rel}/${name}` : name;
+      if (r === ".text" || skip(r)) continue;
+      const src = join(dir, name);
+      const dest = join(to, r);
+      if (statSync(src).isDirectory()) {
+        mkdirSync(dest, { recursive: true });
+        walk(src, r);
+      } else cpSync(src, dest);
+    }
+  };
+  walk(from, "");
+}
+
+/** Remove `.text/` (server bundles and build manifests) from output a static host publishes as-is. */
+export function removeServerBundle(outDir: string): void {
+  const dir = join(outDir, ".text");
+  if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+}
+
+/** Patterns of `export const runtime = "server"` pages. */
+export function serverRoutePatterns(ctx: Pick<AdapterContext, "scan">): string[] {
+  return listServerPages(ctx.scan).map((p) => p.pattern);
+}
+
+/** Server-rendered routes keep a live session per tab: refuse platforms without a long-lived server. */
+export function assertNoServerRoutes(ctx: Pick<AdapterContext, "scan">, adapter: AdapterName): void {
+  const routes = serverRoutePatterns(ctx);
+  if (routes.length > 0) throw txError("TX030", routes.join(", "), adapter);
+}

package/src/server/adapters/static.ts

@@ -0,0 +1,68 @@
+/**
+ * `text build --adapter static`: a pure static export. Static `GET` route
+ * handlers (`dynamic = "force-static"` / `revalidate`) are prerendered into
+ * files; anything that needs a server is a build error.
+ */
+
+import { copyFileSync, existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { isDynamicPattern, matchAppRoutes, type RouteManifest, type RouteSegmentNode } from "../../routing";
+import { routeCacheConfig, runRouteHandlerWithCache } from "../cache-route";
+import type { RouteHandlerModule } from "../http";
+import type { MiddlewareModule } from "../middleware";
+import { removeServerBundle, serverRoutePatterns, type AdapterContext, type AdapterResult } from "./shared";
+
+export async function adaptStatic(ctx: AdapterContext, middleware: MiddlewareModule | null, apiBundle: string): Promise<AdapterResult> {
+  const problems: string[] = [];
+  if (middleware) problems.push("middleware.ts needs a server. Use --adapter bun, vercel or cloudflare (or `text start`).");
+  for (const pattern of serverRoutePatterns(ctx)) problems.push(`${pattern}: renders on the server (\`export const runtime = "server"\`). Use --adapter bun (or \`text start\`).`);
+  const notes: string[] = [];
+  if (ctx.rewrites.length > 0) notes.push("rewrites in text.config.ts are not applied by static hosts; configure them on your host.");
+
+  const written: string[] = [];
+  if (ctx.api.length > 0 && problems.length === 0) {
+    const bundle = (await import(`${pathToFileURL(apiBundle).href}?t=${Date.now()}`)) as { manifest: RouteManifest; handlers: Record<string, RouteHandlerModule> };
+    for (const route of ctx.api) {
+      if (isDynamicPattern(route.pattern)) {
+        problems.push(`${route.pattern}: dynamic segments need a server.`);
+        continue;
+      }
+      const m = matchAppRoutes(bundle.manifest, route.pattern);
+      const id = m ? (m.chain[m.chain.length - 1] as RouteSegmentNode).files?.page : undefined;
+      const mod = id ? bundle.handlers[id] : undefined;
+      if (!mod) continue;
+      const others = ["POST", "PUT", "PATCH", "DELETE"].filter((k) => typeof mod[k] === "function");
+      if (typeof mod.GET !== "function" || others.length > 0) {
+        problems.push(`${route.pattern}: only GET route handlers can be exported statically${others.length ? ` (found ${others.join(", ")})` : ""}.`);
+        continue;
+      }
+      if (!routeCacheConfig(mod, `${route.pattern}/route`).static) {
+        problems.push(`${route.pattern}: the route handler is dynamic. Add \`export const dynamic = "force-static"\` to prerender it.`);
+        continue;
+      }
+      const res = await runRouteHandlerWithCache(mod, new Request(`http://localhost${ctx.basePath}${route.pattern}`), { params: {}, pattern: route.pattern, pathname: route.pattern, cache: false });
+      if (!res.ok) {
+        problems.push(`${route.pattern}: prerendering returned ${res.status}.`);
+        continue;
+      }
+      const file = join(ctx.outDir, ...route.pattern.split("/").filter(Boolean));
+      if (existsSync(file) && statSync(file).isDirectory()) {
+        problems.push(`${route.pattern}: conflicts with a directory of the same name in the output.`);
+        continue;
+      }
+      mkdirSync(dirname(file), { recursive: true });
+      writeFileSync(file, new Uint8Array(await res.arrayBuffer()));
+      written.push(route.pattern);
+    }
+  }
+  if (problems.length > 0) {
+    throw new Error(`▼ Text.js: the static adapter can't export this app:\n${problems.map((p) => `  - ${p}`).join("\n")}`);
+  }
+  removeServerBundle(ctx.outDir);
+  // SPA fallback for hosts that serve 404.html for unknown paths (GitHub Pages, S3, …).
+  const fallback = join(ctx.outDir, "404.html");
+  if (!existsSync(fallback)) copyFileSync(join(ctx.outDir, "index.html"), fallback);
+  if (written.length > 0) notes.unshift(`Prerendered ${written.length} route handler${written.length === 1 ? "" : "s"}: ${written.join(", ")}`);
+  return { adapter: "static", output: ctx.outDir, notes };
+}