@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/app/modules/server-entry/application/usecases/create-app-server.ts

@@ -0,0 +1,205 @@
+/**
+ * createAppServer
+ * One-call composition of the full request pipeline — server functions,
+ * actions, web-server API routes and the SSR render fallback
+ */
+
+import type { Route } from "@wrikka/web-server-toolkit";
+import { createActionHandler, isActionRequest } from "#actions/modules/action";
+import { type AiSurfaceOptions, createAiHandler } from "#app/modules/ai";
+import { createApiDocsHandler } from "#app/modules/api-docs";
+import { resolveConfig } from "#app/modules/config";
+import {
+	type ApiRouteModules,
+	createApiRouteHandler,
+	createLoaderHandler,
+	createRouteActionHandler,
+} from "#app/modules/file-routes";
+import type { RouteManifest } from "#app/modules/file-routes/domain/models";
+import { matchRouteRuleWithPattern } from "#app/modules/route-rules";
+import { checkRateLimit } from "#app/modules/route-rules/domain/operations/rate-limit";
+import {
+	createOgHandler,
+	createSeoHandler,
+	type OgParams,
+	type RobotsConfig,
+} from "#app/modules/seo";
+import type { AppMiddleware, SolidFrameworkConfig } from "#app/types";
+import { IMAGE_ENDPOINT } from "#assets/modules/assets/domain/operations";
+import { createIslandHandler } from "#render/modules/render/application/usecases/remote-island";
+import type { ServerEntryHandler } from "#render/presentation/entries";
+import type { Renderable, RenderMode } from "#render/types";
+import {
+	createFrameworkServerHandler,
+	type FrameworkFetchHandler,
+} from "#server/adapters/web-server";
+import type { ServerFnCsrfOptions } from "#server/modules/server-functions";
+import { createDevtoolsHandler } from "./devtools-handler";
+import { createImageHandler } from "./image-handler";
+import { createOpsHandler, type OpsOptions } from "./ops-handler";
+import { createRoutedServerEntry } from "./routed-entry";
+import { lazyStaticHandler } from "./static-handler";
+import { createZoneHandler } from "./zone-handler";
+
+export interface AppServerOptions {
+	/** Root renderable or a ready-made render handler */
+	app: Renderable | ServerEntryHandler;
+	/** API routes for @wrikka/web-server-toolkit */
+	routes?: Route[];
+	/**
+	 * Fallback API handler for fetch-based servers (Elysia `.fetch`, Hono,
+	 * or a composed web-server handler) — tried when no route matches
+	 */
+	apiHandler?: (request: Request) => Promise<Response>;
+	config?: Partial<SolidFrameworkConfig>;
+	renderMode?: RenderMode;
+	/** Client entry script url for csr-mode shells */
+	clientEntry?: string;
+	/** Server middleware — merged with config.middleware */
+	middleware?: AppMiddleware[];
+	/**
+	 * Same-origin guard for `/_server/*` endpoints — enabled by default;
+	 * pass `false` to disable or options to allow extra origins
+	 */
+	serverFnCsrf?: ServerFnCsrfOptions | false;
+	/**
+	 * File routes — pass the virtual module manifest + glob map so both
+	 * `*.api.ts` endpoints and `/_server/loader` (route `loader` exports)
+	 * are served:
+	 *   fileRoutes: { manifest, modules: routeModules }
+	 */
+	fileRoutes?: { manifest: RouteManifest; modules: ApiRouteModules };
+	/** sitemap.xml/robots.txt generation — needs fileRoutes.manifest */
+	seo?: { origin?: string; robots?: RobotsConfig };
+	/** `/_og` OpenGraph card endpoint — default params merge with query */
+	og?: OgParams;
+	/** `/_docs/openapi.json` — spec generated from *.api.ts exports */
+	apiDocs?: { title?: string; version?: string } | boolean;
+	/** `/llms.txt` + `/_server/mcp` — AI-facing surface (needs fileRoutes) */
+	ai?: AiSurfaceOptions | boolean;
+	/**
+	 * `/_health` + `/_ready` ops probes — pass a readiness fn for
+	 * dependency checks; `/_ready` returns 503 when it resolves false
+	 */
+	ops?: OpsOptions | boolean;
+	/** `/_devtools` standalone diagnostics page — enabled in dev by default */
+	devtools?: boolean;
+}
+
+export const createAppServer = (
+	options: AppServerOptions,
+): FrameworkFetchHandler => {
+	const config = resolveConfig(options.config);
+	if (options.middleware?.length) {
+		config.middleware = [...(config.middleware ?? []), ...options.middleware];
+	}
+
+	const render: ServerEntryHandler =
+		typeof options.app === "function" && options.app.length === 0
+			? createRoutedServerEntry(options.app as Renderable, config, {
+					clientEntry: options.clientEntry,
+					fileRoutes: options.fileRoutes,
+				})
+			: (options.app as ServerEntryHandler);
+
+	const handler = createFrameworkServerHandler({
+		routes: options.routes,
+		apiHandler: options.apiHandler,
+		render,
+		actionHandler: createActionHandler(),
+		// /_image optimization endpoint — only when config.images is set.
+		// SSRF guard: remote sources must match images.remotePatterns
+		imageHandler: config.images ? createImageHandler(config.images) : undefined,
+		imageEndpoint: config.images?.endpoint ?? IMAGE_ENDPOINT,
+		apiPrefixes: config.apiPrefixes,
+		serverFnCsrf: options.serverFnCsrf,
+		fileApiHandler: options.fileRoutes
+			? (() => {
+					const api = createApiRouteHandler(
+						options.fileRoutes.manifest,
+						options.fileRoutes.modules,
+					);
+					const actions = createRouteActionHandler(
+						options.fileRoutes.manifest,
+						options.fileRoutes.modules,
+					);
+					// *.api.ts first, then POST-to-page runs the `action` export
+					return async (request: Request) =>
+						(await api(request)) ?? (await actions(request));
+				})()
+			: undefined,
+		loaderHandler: options.fileRoutes
+			? createLoaderHandler(
+					options.fileRoutes.manifest,
+					options.fileRoutes.modules,
+				)
+			: undefined,
+		staticHandler: config.static ? lazyStaticHandler(config.static) : undefined,
+		seoHandler: options.fileRoutes
+			? createSeoHandler(options.fileRoutes.manifest, options.seo, config.rules)
+			: undefined,
+		ogHandler: options.og ? createOgHandler(options.og) : undefined,
+		docsHandler:
+			options.apiDocs && options.fileRoutes
+				? createApiDocsHandler(
+						options.fileRoutes.manifest,
+						options.fileRoutes.modules,
+						options.apiDocs === true ? {} : options.apiDocs,
+					)
+				: undefined,
+		// Multi-zone — prefix proxy (config.zones)
+		zoneHandler: config.zones?.length
+			? createZoneHandler(config.zones)
+			: undefined,
+		// `/_devtools` — full-page diagnostics (routes/queues/ops links)
+		devtoolsHandler:
+			(options.devtools ?? true) &&
+			(process.env.NODE_ENV !== "production" ||
+				process.env.SOLID_DEVTOOLS === "1")
+				? createDevtoolsHandler(options.fileRoutes?.manifest)
+				: undefined,
+		islandHandler: createIslandHandler(),
+		aiHandler:
+			options.ai && options.fileRoutes
+				? createAiHandler(
+						options.fileRoutes.manifest,
+						options.fileRoutes.modules,
+						options.ai === true ? {} : options.ai,
+					)
+				: undefined,
+		opsHandler: options.ops ? createOpsHandler(options.ops) : undefined,
+		// First gate — api routes + render paths both respect
+		// routeRules.rateLimit (adapter runs it before every dispatch)
+		rateLimitCheck: (request) => {
+			const m = matchRouteRuleWithPattern(
+				new URL(request.url).pathname,
+				config.rules,
+			);
+			return m ? checkRateLimit(m.rule, m.pattern, request) : undefined;
+		},
+	});
+
+	// Direct execution (`bun entry-server.tsx`, `solid start`) — self-listen
+	if (import.meta.main) {
+		const bun = (
+			globalThis as {
+				Bun?: {
+					serve: (options: {
+						fetch: FrameworkFetchHandler;
+						port: number;
+					}) => void;
+				};
+			}
+		).Bun;
+		if (bun) {
+			const port = Number(process.env.PORT ?? 3000);
+			bun.serve({ fetch: handler, port });
+			console.log(`[solid-framework] listening on :${port}`);
+		}
+	}
+
+	return handler;
+};
+
+export type { OpsOptions } from "./ops-handler";
+export { isActionRequest };

package/src/app/modules/server-entry/application/usecases/devtools-handler.ts

@@ -0,0 +1,31 @@
+/**
+ * Devtools Handler
+ * `/_devtools` standalone diagnostics page — route manifest listing
+ * plus links to the ops/docs/seo endpoints. Enabled in dev by default
+ * (or SOLID_DEVTOOLS=1 in production)
+ */
+
+import type { RouteManifest } from "#app/modules/file-routes/domain/models";
+
+export const createDevtoolsHandler = (
+	manifest: RouteManifest | undefined,
+): ((request: Request) => Response | null) => {
+	const routes = manifest
+		? manifest
+				.map(
+					(r) =>
+						`<li><code>${r.path}</code> — ${r.kind ?? "page"}${
+							r.slot ? ` <em>@${r.slot}</em>` : ""
+						}${r.intercepted ? " <em>(.)</em>" : ""}</li>`,
+				)
+				.join("")
+		: "<li>(no manifest)</li>";
+	const html = `<!doctype html><html><head><title>solid devtools</title><style>body{font-family:ui-monospace,monospace;background:#0f172a;color:#e2e8f0;padding:2rem}code{color:#38bdf8}em{color:#a78bfa;font-style:normal}a{color:#94a3b8}</style></head><body><h1>@wrikka/solid devtools</h1><h2>routes</h2><ul>${routes}</ul><h2>endpoints</h2><ul><li><a href="/_health">/_health</a> · <a href="/_ready">/_ready</a> · <a href="/llms.txt">/llms.txt</a> · <a href="/_docs/openapi.json">/_docs/openapi.json</a> · <a href="/sitemap.xml">/sitemap.xml</a></li></ul></body></html>`;
+	return (request) => {
+		const { pathname } = new URL(request.url);
+		if (pathname !== "/_devtools") return null;
+		return new Response(html, {
+			headers: { "Content-Type": "text/html; charset=utf-8" },
+		});
+	};
+};

package/src/app/modules/server-entry/application/usecases/image-handler.ts

@@ -0,0 +1,38 @@
+/**
+ * Image Handler
+ * `/_image` optimization endpoint — SSRF guard limits remote sources
+ * to config.images.remotePatterns; the configured transformer (or the
+ * default redirect) produces the optimized response
+ */
+
+import type { ImagesConfig } from "#app/types";
+import {
+	defaultImageTransformer,
+	parseImageRequest,
+} from "#assets/modules/assets/domain/operations";
+
+export const createImageHandler = (
+	images: ImagesConfig,
+): ((request: Request) => Promise<Response>) => {
+	const matchesRemote = (host: string): boolean =>
+		(images.remotePatterns ?? []).some((pattern) =>
+			pattern.startsWith("*.")
+				? host === pattern.slice(2) || host.endsWith(pattern.slice(1))
+				: host === pattern,
+		);
+	return async (request: Request): Promise<Response> => {
+		const params = parseImageRequest(new URL(request.url));
+		if (!params) {
+			return new Response("Bad image request", { status: 400 });
+		}
+		const src = new URL(params.src, request.url);
+		if (
+			src.origin !== new URL(request.url).origin &&
+			!matchesRemote(src.hostname)
+		) {
+			return new Response("Remote image not allowed", { status: 403 });
+		}
+		const transformer = images.transformer ?? defaultImageTransformer;
+		return transformer({ ...params, request });
+	};
+};

package/src/app/modules/server-entry/application/usecases/index.ts

@@ -0,0 +1,3 @@
+export * from "./create-app-server";
+export * from "./prerender-cache";
+export * from "./routed-entry";

package/src/app/modules/server-entry/application/usecases/ops-handler.ts

@@ -0,0 +1,55 @@
+/**
+ * Ops Handler
+ * `/_health`, `/_ready`, `/_metrics` probes — readiness gates on the
+ * user-provided `ready` fn; health merges extra `checks` and reports
+ * uptime/version. `/_metrics` renders the shared Prometheus registry
+ */
+
+import { renderMetrics } from "#server/modules/http/domain/operations/metrics";
+
+export interface OpsOptions {
+	ready?: () => boolean | Promise<boolean>;
+	/** Extra checks merged into `/_health` — `db: () => true` */
+	checks?: Record<string, () => boolean | Promise<boolean>>;
+	/** Version string reported by `/_health` */
+	version?: string;
+	/** `/_metrics` — Prometheus-text endpoint (shared registry) */
+	metrics?: boolean;
+}
+
+export const createOpsHandler = (
+	options: OpsOptions | true,
+): ((request: Request) => Promise<Response | null>) => {
+	const started = Date.now();
+	const ops = typeof options === "object" ? options : {};
+	return async (request: Request): Promise<Response | null> => {
+		const { pathname } = new URL(request.url);
+		if (pathname === "/_health") {
+			const checks: Record<string, boolean> = {};
+			for (const [k, fn] of Object.entries(ops.checks ?? {})) {
+				checks[k] = await Promise.resolve()
+					.then(() => fn())
+					.catch(() => false);
+			}
+			return Response.json({
+				status: Object.values(checks).every(Boolean) ? "ok" : "degraded",
+				uptime: Math.round((Date.now() - started) / 1000),
+				...(ops.version ? { version: ops.version } : {}),
+				...(Object.keys(checks).length ? { checks } : {}),
+			});
+		}
+		if (pathname === "/_ready") {
+			const ready = ops.ready ? await ops.ready() : true;
+			return Response.json(
+				{ status: ready ? "ready" : "unready" },
+				{ status: ready ? 200 : 503 },
+			);
+		}
+		if (pathname === "/_metrics" && ops.metrics) {
+			return new Response(renderMetrics(), {
+				headers: { "Content-Type": "text/plain; version=0.0.4" },
+			});
+		}
+		return null;
+	};
+};

package/src/app/modules/server-entry/application/usecases/prerender-cache.ts

@@ -0,0 +1,59 @@
+/**
+ * Prerender Cache (ISR)
+ * HTML cache for prerender/ssg routes over a pluggable CacheStore —
+ * fresh within maxAge, stale-while-revalidate beyond it when
+ * rule.cache.swr is on. Entries carry cache tags so
+ * revalidateTag()/revalidatePath() can bust them (Next.js tag-based
+ * invalidation equivalent)
+ */
+
+import { createMemoryStore } from "#app/modules/cache/adapters/memory";
+import type { CacheStore } from "#app/modules/cache/ports/store";
+
+export interface CachedPage {
+	html: string;
+	headers: Record<string, string>;
+	status: number;
+	cachedAt: number;
+	/** Cache tags from routeRules — invalidated by revalidateTag */
+	tags?: string[];
+}
+
+export interface PrerenderCache {
+	get(pathname: string): CachedPage | undefined;
+	set(pathname: string, page: Omit<CachedPage, "cachedAt">): void;
+	isFresh(page: CachedPage, maxAge: number): boolean;
+	/** Drop every entry carrying this tag — returns evicted count */
+	invalidateTag(tag: string): number;
+	/** Drop a single path entry */
+	invalidatePath(pathname: string): boolean;
+	clear(): void;
+}
+
+export const createPrerenderCache = (
+	now: () => number = Date.now,
+	store: CacheStore<CachedPage> = createMemoryStore<CachedPage>(),
+): PrerenderCache => ({
+	get: (pathname) => store.get(pathname),
+	set: (pathname, page) => store.set(pathname, { ...page, cachedAt: now() }),
+	isFresh: (page, maxAge) => (now() - page.cachedAt) / 1000 < maxAge,
+	invalidateTag: (tag) => {
+		let evicted = 0;
+		for (const key of store.keys()) {
+			if (store.get(key)?.tags?.includes(tag)) {
+				store.delete(key);
+				evicted++;
+			}
+		}
+		return evicted;
+	},
+	invalidatePath: (pathname) => store.delete(pathname),
+	clear: () => store.clear(),
+});
+
+/**
+ * Shared default store — createRoutedServerEntry writes here unless
+ * given its own cache, so revalidateTag()/revalidatePath() reach the
+ * entries serving live traffic
+ */
+export const sharedPrerenderCache: PrerenderCache = createPrerenderCache();

package/src/app/modules/server-entry/application/usecases/route-render.ts

@@ -0,0 +1,276 @@
+/**
+ * Route Render Modes
+ * Produces the response for a resolved render mode — csr/data-only
+ * shells, ISR-cached prerender/ssg/ppr, streaming, and full SSR —
+ * sharing one render-preparation pass (context, head, status,
+ * state serialization, providers) across the SSR/stream paths
+ */
+
+import { runFileRouteLoader } from "#app/modules/file-routes/domain/operations/loader";
+import {
+	preloadFileRoute,
+	type RouteModules,
+} from "#app/modules/file-routes/presentation/route-modules";
+import type { RouteStatus } from "#app/modules/file-routes/presentation/status";
+import { wrapAppProviders } from "#app/presentation/providers";
+import type { RouteRule, SolidFrameworkConfig } from "#app/types";
+import { createHeadManager } from "#head/modules/head/application/usecases";
+import { preloadTags, titleTag } from "#head/modules/head/domain";
+import { createSolidServerRenderer } from "#render/adapters/solid-web/renderer";
+import {
+	renderPage,
+	renderShellResponse,
+	streamPage,
+} from "#render/modules/render/application/usecases";
+import { createRenderContext } from "#render/modules/render/domain";
+import type { HydrationPayload, Renderable, RenderMode } from "#render/types";
+import type { PrerenderCache } from "./prerender-cache";
+import type { RoutedEntryOptions } from "./routed-entry";
+
+export type ResolvedRenderMode =
+	| RenderMode
+	| "ssg"
+	| "prerender"
+	| "data-only"
+	| "ppr";
+
+export interface RouteRenderDeps {
+	renderable: Renderable;
+	config: SolidFrameworkConfig;
+	options: RoutedEntryOptions;
+	prerender: PrerenderCache;
+}
+
+export interface RouteRenderInput {
+	/** Routed request — post-A/B rewrite */
+	request: Request;
+	/** Pathname to render — variant route when A/B bucketed */
+	pathname: string;
+	/** Middleware state bag — serialized into the hydration payload */
+	state: Record<string, unknown>;
+	rule: RouteRule | undefined;
+	mode: ResolvedRenderMode;
+	security: { headers: Record<string, string>; nonce?: string };
+}
+
+const applyRuleHeaders = (
+	base: HeadersInit | undefined,
+	rule: RouteRule | undefined,
+	mode: string,
+): Headers => {
+	const headers = new Headers(base);
+	headers.set("x-render-mode", mode);
+	for (const [key, value] of Object.entries(rule?.headers ?? {})) {
+		headers.set(key, value);
+	}
+	if (rule?.cache?.maxAge !== undefined) {
+		const swr = rule.cache.swr ? ", stale-while-revalidate=60" : "";
+		headers.set("Cache-Control", `public, max-age=${rule.cache.maxAge}${swr}`);
+	}
+	return headers;
+};
+
+export const createRouteRenderer = (deps: RouteRenderDeps) => {
+	const renderer = createSolidServerRenderer();
+	const { config, options, prerender, renderable } = deps;
+
+	// Shared render prep — render context, head collection (configured
+	// title first so component <Title> wins via last-write-wins dedupe,
+	// then preload tags), the 404/500 status slot FileRoutes writes
+	// into, middleware-state serialization into the hydration payload,
+	// and the provider-wrapped app tree
+	const prepareRender = async (
+		request: Request,
+		state: Record<string, unknown>,
+		renderMode: "ssr" | "stream" | "islands",
+	) => {
+		const context = createRenderContext(renderMode, request, state);
+		if (options.fileRoutes) {
+			await preloadFileRoute(
+				new URL(request.url).pathname,
+				options.fileRoutes.manifest,
+				options.fileRoutes.modules as RouteModules,
+			);
+		}
+		const head = createHeadManager();
+		const configuredTitle = options.title ?? config.head.title;
+		if (configuredTitle) head.add(titleTag(configuredTitle));
+		for (const tag of preloadTags(config.head.preloads ?? [])) {
+			head.add(tag);
+		}
+		const status: RouteStatus = { status: 200 };
+		for (const [key, value] of Object.entries(state)) {
+			try {
+				context.hydration.stores[key] = JSON.parse(JSON.stringify(value));
+			} catch {
+				// non-serializable state stays server-only
+			}
+		}
+		const app = wrapAppProviders(renderable, {
+			head,
+			request,
+			status,
+			hydration: context.hydration,
+			state,
+		});
+		return { context, head, status, app };
+	};
+
+	const renderFull = async (
+		request: Request,
+		state: Record<string, unknown>,
+		renderMode: "ssr" | "islands" = "ssr",
+	): Promise<{ html: string; status: number }> => {
+		const { context, head, status, app } = await prepareRender(
+			request,
+			state,
+			renderMode,
+		);
+		const { html } = await renderPage(renderer, {
+			renderable: app,
+			options: { context },
+			collectHead: () => head.renderToString(),
+			lang: options.lang ?? config.head.lang,
+			// islands mode emits no app entry — only island markers hydrate
+			entry:
+				renderMode === "islands"
+					? options.islandsEntry
+					: (options.clientEntry ?? "/src/entry-client.tsx"),
+			nonce: state.cspNonce as string | undefined,
+		});
+		return { html, status: status.status };
+	};
+
+	const serve = async (input: RouteRenderInput): Promise<Response> => {
+		const { request, pathname, state, rule, mode, security } = input;
+		const nonce = security.nonce;
+
+		if (mode === "csr" || mode === "data-only") {
+			// data-only — server runs the matched route's loader and ships
+			// the result in the CSR shell's hydration payload; the client
+			// renders immediately without a loader roundtrip
+			let hydration: HydrationPayload | undefined;
+			if (mode === "data-only" && options.fileRoutes) {
+				await preloadFileRoute(
+					pathname,
+					options.fileRoutes.manifest,
+					options.fileRoutes.modules as RouteModules,
+				);
+				const data = await runFileRouteLoader(
+					pathname,
+					options.fileRoutes.manifest,
+					options.fileRoutes.modules as never,
+					request,
+				);
+				if (data !== undefined) {
+					hydration = { loaders: { [pathname]: data }, stores: {} };
+				}
+			}
+			return renderShellResponse(
+				{
+					title: options.title ?? config.head.title,
+					lang: options.lang ?? config.head.lang,
+					entry: options.clientEntry ?? "/src/entry-client.tsx",
+					nonce,
+					hydration,
+				},
+				applyRuleHeaders(security.headers, rule, "csr"),
+			);
+		}
+
+		// ISR — prerender/ssg/ppr routes serve cached HTML within maxAge;
+		// swr serves stale and revalidates in the background.
+		// ppr = partial prerender: static shell from cache, dynamic
+		// regions opt in via <ServerComponent remote>
+		const isPrerender =
+			mode === "prerender" || mode === "ssg" || mode === "ppr";
+		// draftMode bypasses the ISR cache entirely
+		const draft = state.draft === true;
+		const maxAge = draft ? 0 : (rule?.cache?.maxAge ?? 0);
+		if (isPrerender && maxAge > 0) {
+			const cached = prerender.get(pathname);
+			if (cached) {
+				const headers = applyRuleHeaders(
+					{
+						"Content-Type": "text/html; charset=utf-8",
+						...cached.headers,
+						...security.headers,
+					},
+					rule,
+					mode,
+				);
+				if (prerender.isFresh(cached, maxAge)) {
+					headers.set("x-prerender-cache", "hit");
+					return new Response(cached.html, {
+						status: cached.status,
+						headers,
+					});
+				}
+				if (rule?.cache?.swr) {
+					headers.set("x-prerender-cache", "stale");
+					void renderFull(request, state)
+						.then((next) =>
+							prerender.set(pathname, {
+								html: next.html,
+								status: next.status,
+								headers: {},
+								tags: rule?.cache?.tags,
+							}),
+						)
+						.catch(() => {});
+					return new Response(cached.html, {
+						status: cached.status,
+						headers,
+					});
+				}
+			}
+		}
+
+		if (mode === "stream") {
+			const { context, head, status, app } = await prepareRender(
+				request,
+				state,
+				"stream",
+			);
+			// Status getter resolves after the synchronous render pass
+			// inside streamPage — FileRoutes has written 404/500 by then
+			return streamPage(renderer, {
+				renderable: app,
+				options: { context },
+				collectHead: () => head.renderToString(),
+				lang: options.lang ?? config.head.lang,
+				entry: options.clientEntry ?? "/src/entry-client.tsx",
+				status: () => status.status,
+				headers: applyRuleHeaders(security.headers, rule, "stream"),
+				nonce,
+			});
+		}
+
+		// "ssr" | "ssg" | "prerender" | "islands"
+		const { html, status } = await renderFull(
+			request,
+			state,
+			mode === "islands" ? "islands" : "ssr",
+		);
+		const headers = applyRuleHeaders(
+			{
+				"Content-Type": "text/html; charset=utf-8",
+				...security.headers,
+			},
+			rule,
+			mode,
+		);
+		if (isPrerender && !draft) {
+			prerender.set(pathname, {
+				html,
+				status,
+				headers: {},
+				tags: rule?.cache?.tags,
+			});
+			headers.set("x-prerender-cache", "miss");
+		}
+		return new Response(html, { status, headers });
+	};
+
+	return { renderFull, serve };
+};