@sjcx/vorma 0.0.0-pre.0

package/dist/server/index.js

@@ -0,0 +1,2311 @@
+import { _ as DOCUMENT_PROTOCOL, b as HTTP_PROTOCOL, c as compileUiPattern, g as DEVELOPMENT_PROTOCOL, i as encodeTransportedValue, l as decodeMatchCaptures, m as ARTIFACT_PROTOCOL, o as canonicalizeRequestPathForMatcher, p as makeNullPrototypeRecord, r as decodeTransportedValue, x as PROCESS_ENVIRONMENT_PROTOCOL } from "../value-transport-Bst4Hk-n.js";
+import { a as compileUiLoader, d as FormData, i as compileMiddleware, l as getLiteralErrorTag, n as checkEndpointPatternRegistrations, o as createNestedRouteChains, r as compileEndpoint, s as groupEndpointsByMethod, t as checkDuplicates, u as getInputTransport } from "../compile-Me8EOyMK.js";
+import { n as getOwnEntries, r as projectSearchFields, t as buildHref } from "../href-Cqyax8Y0.js";
+import { a as bigDecimalTransportType, c as redactedTransportType, i as dateTimeUtcTransportType, l as optionTransportType, n as hashMapTransportType, o as durationTransportType, r as dateTimeZonedTransportType, s as chunkTransportType, t as hashSetTransportType } from "../hash-set-BPx3iXec.js";
+import { i as readTransportedValue, t as getStaticAssetDestination } from "../static-assets-BrH3O0M8.js";
+import { t as parseSearchParams } from "../search-parse-0f7oqVsG.js";
+import { Cause, Config, Context, Data, Deferred, Effect, Exit, Fiber, Layer, Option, Record, Ref, Result, Schema } from "effect";
+import { base64 } from "@scure/base";
+import * as Path$1 from "effect/Path";
+import { createFlatMatcher, createFlatValueMatcher, createNestedValueMatcher, findBestMatch, findBestValueMatch, findNestedValueMatches } from "@vorma/primitives/matcher";
+import { HttpServerError, HttpServerRequest, HttpServerResponse, UrlParams } from "effect/unstable/http";
+import { TaskContext, TaskRuntime } from "@vorma/primitives/tasks";
+import { sha256 } from "@noble/hashes/sha2.js";
+import * as HttpPlatform from "effect/unstable/http/HttpPlatform";
+import * as HttpServerRequest$1 from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse$1 from "effect/unstable/http/HttpServerResponse";
+import { memoize } from "effect/Function";
+import * as Cookies from "effect/unstable/http/Cookies";
+import * as Headers$1 from "effect/unstable/http/Headers";
+//#region src/server/runtime/startup-error.ts
+function createVormaStartupError(input) {
+	return {
+		_tag: "VormaStartupError",
+		operation: input.operation,
+		message: input.message,
+		...input.cause === void 0 ? {} : { cause: input.cause }
+	};
+}
+//#endregion
+//#region src/server/runtime/application.ts
+const ApplicationRuntime = Context.Service("vorma/server/ApplicationRuntime");
+const APPLICATION_RUNTIME = Symbol("vorma/server/ApplicationRuntimeLayer");
+/** One shared acquisition for an application's compiled registration and asset metadata. */
+function makeApplicationRuntime(config) {
+	return Layer.effect(ApplicationRuntime, Effect.tryPromise({
+		try: async () => {
+			const [registration, metadata] = await Promise.all([import(new URL(`./${ARTIFACT_PROTOCOL.compiledRuntimeFileName}`, config.importMeta.url).href), import(new URL(`./${ARTIFACT_PROTOCOL.productionMetadataFileName}`, config.importMeta.url).href, { with: { type: "json" } })]);
+			const initial = {
+				...metadata.default,
+				publicAssetDirectoryUrl: registration.publicAssetDirectoryUrl
+			};
+			return {
+				registeredDeclarations: registration.registeredDeclarations,
+				metadata: initial,
+				...initial.runtimeMode === "development" ? { readDevelopmentMetadata: (await import("../metadata-BoPKo-G2.js")).createDevelopmentMetadataReader({
+					url: new URL(`./${ARTIFACT_PROTOCOL.productionMetadataFileName}`, config.importMeta.url),
+					initial
+				}) } : {}
+			};
+		},
+		catch: (cause) => {
+			return createVormaStartupError({
+				operation: "loadApplicationRuntime",
+				message: "Vorma could not load its compiled application runtime. Build the application and start its compiled server entry.",
+				cause
+			});
+		}
+	}));
+}
+//#endregion
+//#region src/server/public-assets.ts
+/** A content-addressed public asset remains immutable at its published URL. */
+const IMMUTABLE_CACHE_CONTROL = "public, max-age=31536000, immutable";
+function resolvePublicAssetFilePaths(input) {
+	return Effect.gen(function* () {
+		const { metadata, path } = input;
+		const directoryUrl = yield* Schema.decodeUnknownEffect(Schema.URLFromString)(metadata.publicAssetDirectoryUrl).pipe(Effect.mapError((cause) => {
+			return createVormaStartupError({
+				operation: "resolvePublicAssetDirectory",
+				message: `Vorma production metadata does not carry a valid public asset directory URL: ${metadata.publicAssetDirectoryUrl}`,
+				cause
+			});
+		}));
+		const directory = yield* path.fromFileUrl(directoryUrl).pipe(Effect.mapError((cause) => {
+			return createVormaStartupError({
+				operation: "resolvePublicAssetDirectory",
+				message: `Vorma public asset bytes are not on a local filesystem: ${metadata.publicAssetDirectoryUrl}`,
+				cause
+			});
+		}));
+		const filePathsByUrl = /* @__PURE__ */ new Map();
+		for (const file of metadata.publicFiles) filePathsByUrl.set(file.url, {
+			filePath: path.join(directory, ...file.fileName.split("/")),
+			immutable: file.immutable
+		});
+		return filePathsByUrl;
+	});
+}
+function serveFile(input) {
+	return HttpServerResponse$1.file(input.file.filePath, { headers: input.file.immutable ? { "cache-control": IMMUTABLE_CACHE_CONTROL } : {} }).pipe(Effect.provideService(HttpPlatform.HttpPlatform, input.platform));
+}
+/**
+* Serves the build's public directory from the process filesystem. Requests for
+* URLs outside the published set, and every other method than `GET` and `HEAD`,
+* continue to the host's own router. The host passes its explicitly assembled
+* application so that this constructor can read the build metadata. The caller
+* explicitly registers the returned middleware through the host router.
+*/
+function makePublicAssetsFileMiddleware(input) {
+	return Effect.gen(function* () {
+		const path = yield* Path$1.Path;
+		const runtime = yield* ApplicationRuntime;
+		const { metadata } = runtime;
+		let resolvedMetadata = metadata;
+		let filePathsByUrl = yield* resolvePublicAssetFilePaths({
+			metadata,
+			path
+		});
+		const platform = yield* HttpPlatform.HttpPlatform;
+		return (httpEffect) => {
+			return Effect.gen(function* () {
+				const request = yield* HttpServerRequest$1.HttpServerRequest;
+				const method = request.method;
+				if (method !== "GET" && method !== "HEAD") return yield* httpEffect;
+				if (runtime.readDevelopmentMetadata !== void 0) {
+					const next = yield* runtime.readDevelopmentMetadata;
+					if (next !== resolvedMetadata) {
+						filePathsByUrl = yield* resolvePublicAssetFilePaths({
+							metadata: next,
+							path
+						});
+						resolvedMetadata = next;
+					}
+				}
+				const queryOffset = request.url.indexOf("?");
+				const file = filePathsByUrl.get(queryOffset === -1 ? request.url : request.url.slice(0, queryOffset));
+				if (file === void 0) return yield* httpEffect;
+				return yield* serveFile({
+					file,
+					platform
+				});
+			});
+		};
+	}).pipe(Effect.provide(input.app[APPLICATION_RUNTIME]));
+}
+//#endregion
+//#region src/server/runtime/effects.ts
+const empty = {
+	status: null,
+	terminal: null,
+	headerOps: [],
+	cookies: Cookies.empty,
+	headElements: []
+};
+/** Whether these effects end the response for everything after them. */
+function endsResponse(effects) {
+	return effects.terminal !== null;
+}
+function mergeResponseEffects(input) {
+	const { earlier, later } = input;
+	return {
+		status: later.status === null ? earlier.status : later.status,
+		terminal: later.terminal === null ? earlier.terminal : later.terminal,
+		headerOps: [...earlier.headerOps, ...later.headerOps],
+		cookies: Cookies.merge(earlier.cookies, later.cookies),
+		headElements: [...earlier.headElements, ...later.headElements]
+	};
+}
+function setStatus(input) {
+	return {
+		...input.effects,
+		status: input.status
+	};
+}
+function setHeader(input) {
+	return {
+		...input.effects,
+		headerOps: [...input.effects.headerOps, {
+			kind: "set",
+			name: input.name,
+			value: input.value
+		}]
+	};
+}
+function appendHeader(input) {
+	return {
+		...input.effects,
+		headerOps: [...input.effects.headerOps, {
+			kind: "append",
+			name: input.name,
+			value: input.value
+		}]
+	};
+}
+function setCookie(input) {
+	return {
+		...input.effects,
+		cookies: Cookies.setCookie(input.effects.cookies, input.cookie)
+	};
+}
+function appendHeadElements(input) {
+	return {
+		...input.effects,
+		headElements: [...input.effects.headElements, ...input.elements]
+	};
+}
+function setRedirect(input) {
+	return {
+		...input.effects,
+		status: input.client ? 200 : input.status,
+		terminal: {
+			_tag: "Redirect",
+			location: input.location,
+			status: input.status,
+			client: input.client
+		}
+	};
+}
+/** Made by the execute program from a handler's error, never by a handler. */
+function setTerminalError(input) {
+	return {
+		...input.effects,
+		status: input.status,
+		terminal: {
+			_tag: "Error",
+			status: input.status,
+			text: input.text,
+			...input.domain === void 0 ? {} : { domain: input.domain }
+		}
+	};
+}
+//#endregion
+//#region src/server/runtime/handler.ts
+/**
+* How any handler fails on purpose. In a UI loader: the response carries the
+* status and public message without the failed route's metadata or module.
+* An available ancestor boundary or the application boundary renders the error.
+* In an endpoint or
+* task middleware: the response is the status and the message. `cause` never
+* leaves the server.
+*/
+var HandlerError = class extends Data.TaggedError("HandlerError") {};
+/**
+* A declared domain failure on its way to the wire. A `HandlerError` with
+* the encoded domain payload beside it, so the execute program keeps its
+* single error channel while the response keeps the tag and data a generic
+* rejection cannot carry. Constructed only by the endpoint runner after it
+* matched the thrown value against the declaration's error schemas.
+*/
+var DeclaredDomainError = class extends HandlerError {
+	tag;
+	data;
+	constructor(input) {
+		super(input);
+		this.tag = input.tag;
+		this.data = input.data;
+	}
+};
+/** The public message for a status the application did not explain. */
+function getStatusText(status) {
+	switch (status) {
+		case 400: return "Bad Request";
+		case 401: return "Unauthorized";
+		case 403: return "Forbidden";
+		case 404: return "Not Found";
+		case 405: return "Method Not Allowed";
+		case 409: return "Conflict";
+		case 413: return "Payload Too Large";
+		case 415: return "Unsupported Media Type";
+		case 422: return "Unprocessable Content";
+		case 429: return "Too Many Requests";
+		case 500: return "Internal Server Error";
+		case 503: return "Service Unavailable";
+		default: return "Error";
+	}
+}
+const HANDLER_ENDED_INTERRUPT_ID = -1;
+/** Ends a handler without exposing private control flow in its error channel. */
+const interruptHandler = Effect.failCause(Cause.interrupt(HANDLER_ENDED_INTERRUPT_ID));
+function matchesHandlerEndInterruption(cause) {
+	const reason = cause.reasons[0];
+	return cause.reasons.length === 1 && reason !== void 0 && Cause.isInterruptReason(reason) && reason.fiberId === HANDLER_ENDED_INTERRUPT_ID;
+}
+//#endregion
+//#region src/server/runtime/transport-type-entries.ts
+const SERVER_TRANSPORT_TYPE_ENTRIES = [
+	optionTransportType,
+	redactedTransportType,
+	chunkTransportType,
+	durationTransportType,
+	bigDecimalTransportType,
+	dateTimeUtcTransportType,
+	dateTimeZonedTransportType,
+	hashMapTransportType,
+	hashSetTransportType
+];
+//#endregion
+//#region src/server/runtime/context.ts
+var ResponseInputError = class extends Data.TaggedError("ResponseInputError") {};
+function makeIncomingRequestFacts(source) {
+	return {
+		request: source.request,
+		clientBuildId: source.clientBuildId,
+		getCookie: (name) => source.request.cookies[name],
+		getPublicUrl: (key) => {
+			const normalized = key.startsWith("/") ? key.slice(1) : key;
+			const { publicFilemap } = source.metadata;
+			const url = Object.hasOwn(publicFilemap, normalized) ? publicFilemap[normalized] : void 0;
+			if (url === void 0) throw new Error(`Vorma: ${JSON.stringify(key)} is not a public asset of this build`);
+			return url;
+		}
+	};
+}
+function makeRequestFacts(source, facts) {
+	return {
+		...makeIncomingRequestFacts(source),
+		pattern: facts.pattern,
+		params: facts.params,
+		splatValues: facts.splatValues,
+		input: facts.input
+	};
+}
+function makeResponseOps(input) {
+	function updateEffects(f) {
+		return Ref.update(input.effects, f);
+	}
+	function redirectToLocation(location, status) {
+		return updateEffects((current) => {
+			return setRedirect({
+				effects: current,
+				location,
+				status,
+				client: input.acceptsClientRedirect
+			});
+		}).pipe(Effect.andThen(interruptHandler));
+	}
+	return {
+		setStatus: (status) => {
+			return updateEffects((current) => setStatus({
+				effects: current,
+				status
+			}));
+		},
+		setHeader: ({ name, value }) => {
+			return updateEffects((current) => {
+				return setHeader({
+					effects: current,
+					name,
+					value
+				});
+			});
+		},
+		appendHeader: ({ name, value }) => {
+			return updateEffects((current) => {
+				return appendHeader({
+					effects: current,
+					name,
+					value
+				});
+			});
+		},
+		setCookie: (cookie) => {
+			return updateEffects((current) => {
+				return setCookie({
+					effects: current,
+					cookie
+				});
+			});
+		},
+		expireCookie: (options) => {
+			const cookie = Cookies.makeCookie(options.name, "", {
+				maxAge: 0,
+				expires: /* @__PURE__ */ new Date(0),
+				...options.path === void 0 ? {} : { path: options.path },
+				...options.domain === void 0 ? {} : { domain: options.domain }
+			});
+			if (Result.isFailure(cookie)) return new ResponseInputError({
+				operation: "expireCookie",
+				message: "Cookie expiration options are invalid",
+				cause: cookie.failure
+			});
+			return updateEffects((current) => setCookie({
+				effects: current,
+				cookie: cookie.success
+			}));
+		},
+		redirectToUrl: ({ url, status }) => redirectToLocation(String(url), status),
+		redirectToPattern: ({ pattern, params, splatValues, input: routeInput, hash, status }) => {
+			return input.resolveRouteTargetFn({
+				pattern,
+				search: routeInput
+			}).pipe(Effect.mapError((cause) => {
+				return new ResponseInputError({
+					operation: "redirectToPattern",
+					message: "Route search input does not satisfy its contract",
+					cause
+				});
+			}), Effect.flatMap((target) => {
+				const href = buildHref({
+					kind: "ui",
+					pattern: target.pattern,
+					transportTypeEntries: SERVER_TRANSPORT_TYPE_ENTRIES,
+					...params === void 0 ? {} : { params },
+					...splatValues === void 0 ? {} : { splatValues },
+					...target.search === void 0 ? {} : { search: target.search },
+					...hash === void 0 ? {} : { hash }
+				});
+				return Result.isFailure(href) ? Effect.fail(new ResponseInputError({
+					operation: "redirectToPattern",
+					message: href.failure.reason,
+					cause: href.failure
+				})) : redirectToLocation(href.success, status);
+			}));
+		}
+	};
+}
+function makeHeadOps(effects) {
+	function appendHeadElements$1(elements) {
+		return Ref.update(effects, (current) => appendHeadElements({
+			effects: current,
+			elements
+		}));
+	}
+	return {
+		setTitle: (title) => {
+			return appendHeadElements$1([{
+				tag: "title",
+				textContent: title
+			}]);
+		},
+		setDescription: (description) => {
+			return appendHeadElements$1([{
+				tag: "meta",
+				attributes: {
+					name: "description",
+					content: description
+				}
+			}]);
+		},
+		addMeta: (attributes) => appendHeadElements$1([{
+			tag: "meta",
+			attributes
+		}]),
+		addHead: appendHeadElements$1
+	};
+}
+//#endregion
+//#region src/server/runtime/domain-errors.ts
+function matchDeclaredError(input) {
+	if (typeof input.value !== "object" || input.value === null) return;
+	for (const entry of input.errors) {
+		const tag = getLiteralErrorTag(entry.schema);
+		if (tag === void 0) continue;
+		const validated = Schema.decodeUnknownResult(Schema.toType(entry.schema))(input.value);
+		if (Result.isFailure(validated)) continue;
+		const data = encodeTransportedValue({
+			value: validated.success,
+			typeEntries: SERVER_TRANSPORT_TYPE_ENTRIES
+		});
+		if (Result.isFailure(data)) continue;
+		return {
+			tag: tag.tag,
+			status: entry.status,
+			data: data.success
+		};
+	}
+}
+//#endregion
+//#region src/server/runtime/execute.ts
+function executeEndpoint(input) {
+	return Effect.gen(function* () {
+		const endpoint = yield* Effect.forkScoped(observeInvocation(input.endpoint));
+		const outcome = yield* Fiber.join(endpoint);
+		if (outcome._tag === "Failed") return toTerminalFailure({
+			effects: mergeResponseEffects({
+				earlier: input.effects,
+				later: outcome.effects
+			}),
+			cause: outcome.cause
+		});
+		return mergeOutput(input.effects, outcome);
+	});
+}
+function executeUi(input) {
+	return Effect.gen(function* () {
+		const phase = yield* runPhase(input.positions, input.effects);
+		if (phase._tag === "Terminal") return phase;
+		if (phase._tag === "Completed") return {
+			_tag: "Ui",
+			effects: phase.effects,
+			positions: phase.positions
+		};
+		const error = getHandlerErrorOf(phase.failed.cause);
+		return {
+			_tag: "Ui",
+			effects: setStatus({
+				effects: phase.effects,
+				status: error.status
+			}),
+			positions: [
+				...phase.before,
+				{
+					_tag: "Failed",
+					owner: phase.failed.owner,
+					error: {
+						id: phase.failed.id,
+						pattern: phase.failed.pattern,
+						index: phase.failed.index,
+						...error
+					}
+				},
+				...phase.after.map((owner) => {
+					return {
+						_tag: "Suppressed",
+						owner
+					};
+				})
+			]
+		};
+	});
+}
+function executeMiddleware(invocations) {
+	return Effect.gen(function* () {
+		const phase = yield* runPhase(invocations.map((invocation) => {
+			return {
+				owner: void 0,
+				invocation
+			};
+		}), empty);
+		if (phase._tag === "Terminal") return phase;
+		if (phase._tag === "Failed") return toTerminalFailure({
+			effects: phase.effects,
+			cause: phase.failed.cause
+		});
+		return {
+			_tag: "Continue",
+			data: void 0,
+			effects: phase.effects
+		};
+	});
+}
+function runPhase(positions, initialEffects) {
+	return Effect.gen(function* () {
+		if (positions.length === 0) return {
+			_tag: "Completed",
+			effects: initialEffects,
+			positions: []
+		};
+		const fibersReady = yield* Deferred.make();
+		const forked = [];
+		for (const [index, { owner, invocation }] of positions.entries()) {
+			if (invocation === null) {
+				forked.push({
+					owner,
+					invocation: null,
+					fiber: null
+				});
+				continue;
+			}
+			const body = observeInvocation(invocation).pipe(Effect.flatMap((outcome) => {
+				return (marksBoundary(outcome) ? Effect.flatMap(Deferred.await(fibersReady), (all) => {
+					return Fiber.interruptAll(all.slice(index + 1).filter((fiber) => fiber !== null));
+				}) : Effect.void).pipe(Effect.as(outcome));
+			}));
+			forked.push({
+				owner,
+				invocation,
+				fiber: yield* Effect.forkScoped(body)
+			});
+		}
+		yield* Deferred.succeed(fibersReady, forked.map((entry) => entry.fiber));
+		let effects = initialEffects;
+		const completed = [];
+		for (const [index, position] of forked.entries()) {
+			if (position.fiber === null) {
+				completed.push({
+					_tag: "NoHandler",
+					owner: position.owner
+				});
+				continue;
+			}
+			const joined = yield* Effect.exit(Fiber.join(position.fiber));
+			if (Exit.isFailure(joined)) return yield* Effect.interrupt;
+			const outcome = joined.value;
+			if (outcome._tag === "Failed") return {
+				_tag: "Failed",
+				effects: mergeResponseEffects({
+					earlier: effects,
+					later: outcome.effects
+				}),
+				before: completed,
+				failed: {
+					owner: position.owner,
+					index,
+					id: position.invocation.id,
+					pattern: position.invocation.pattern,
+					cause: outcome.cause
+				},
+				after: forked.slice(index + 1).map((entry) => entry.owner)
+			};
+			const output = mergeOutput(effects, outcome);
+			if (output._tag === "Terminal") return output;
+			effects = output.effects;
+			completed.push({
+				_tag: "Completed",
+				owner: position.owner,
+				data: output.data
+			});
+		}
+		return {
+			_tag: "Completed",
+			effects,
+			positions: completed
+		};
+	});
+}
+/** Handler work stays interruptible; logging a produced failure completes before suppression can discard it. */
+function observeInvocation(invocation) {
+	return Effect.uninterruptibleMask((restore) => {
+		return Effect.flatMap(Effect.exit(restore(invocation.run)), (exit) => {
+			const outcome = Exit.isSuccess(exit) ? exit.value : {
+				_tag: "Failed",
+				cause: exit.cause,
+				effects: empty
+			};
+			if (outcome._tag === "Failed" && Cause.hasInterruptsOnly(outcome.cause)) return Effect.interrupt;
+			return logFailure(invocation, outcome).pipe(Effect.as(outcome));
+		});
+	});
+}
+function logFailure(invocation, outcome) {
+	if (outcome._tag !== "Failed") return Effect.void;
+	return Effect.logError("Vorma handler failed", {
+		handlerId: invocation.id,
+		role: invocation.role,
+		pattern: invocation.pattern
+	}, outcome.cause);
+}
+function marksBoundary(outcome) {
+	return outcome._tag !== "Continue";
+}
+function mergeOutput(earlier, output) {
+	const effects = mergeResponseEffects({
+		earlier,
+		later: output.effects
+	});
+	return output._tag === "Terminal" ? {
+		_tag: "Terminal",
+		effects: {
+			...effects,
+			terminal: output.effects.terminal
+		}
+	} : {
+		...output,
+		effects
+	};
+}
+function toTerminalFailure(input) {
+	const error = getHandlerErrorOf(input.cause);
+	const domain = getDeclaredDomainOf(input.cause);
+	return {
+		_tag: "Terminal",
+		effects: setTerminalError({
+			effects: input.effects,
+			status: error.status,
+			text: error.clientMessage,
+			...domain === void 0 ? {} : { domain }
+		})
+	};
+}
+/** The domain payload when the failure is a matched declared error. */
+function getDeclaredDomainOf(cause) {
+	const reason = cause.reasons[0];
+	if (cause.reasons.length === 1 && reason !== void 0 && Cause.isFailReason(reason) && reason.error instanceof DeclaredDomainError) return {
+		tag: reason.error.tag,
+		data: reason.error.data
+	};
+}
+/** The handler's public error when it failed on purpose; a generic 500 when it did not. */
+function getHandlerErrorOf(cause) {
+	const reason = cause.reasons[0];
+	if (cause.reasons.length === 1 && reason !== void 0 && Cause.isFailReason(reason) && reason.error instanceof HandlerError) {
+		const { status, clientMessage } = reason.error;
+		return {
+			status,
+			clientMessage: clientMessage === void 0 ? getStatusText(status) : clientMessage
+		};
+	}
+	return {
+		status: 500,
+		clientMessage: getStatusText(500)
+	};
+}
+//#endregion
+//#region src/server/runtime/finalize.ts
+const JSON_CONTENT_TYPE = "application/json; charset=utf-8";
+const HTML_CONTENT_TYPE = "text/html; charset=utf-8";
+const TEXT_CONTENT_TYPE = "text/plain; charset=utf-8";
+const UI_CACHE_CONTROL = "private, max-age=0, must-revalidate, no-cache";
+const FRAMEWORK_OWNED_HEADERS = /* @__PURE__ */ new Set([
+	HTTP_PROTOCOL.responseHeaders.clientBuildId,
+	HTTP_PROTOCOL.responseHeaders.buildSkew,
+	HTTP_PROTOCOL.responseHeaders.clientRedirect,
+	HTTP_PROTOCOL.responseHeaders.clientRedirectStatus
+]);
+/** Replays the header operations and adds the framework's own headers. */
+function getBaseHeaders(input) {
+	let headers = Headers$1.empty;
+	for (const op of input.effects.headerOps) {
+		const name = op.name.toLowerCase();
+		if (FRAMEWORK_OWNED_HEADERS.has(name)) return Result.fail({
+			_tag: "FrameworkOwnedHeader",
+			name
+		});
+		const existing = headers[name];
+		headers = Headers$1.set(headers, name, op.kind === "append" && existing !== void 0 ? `${existing}, ${op.value}` : op.value);
+	}
+	return Result.succeed(Headers$1.set(headers, HTTP_PROTOCOL.responseHeaders.clientBuildId, input.clientBuildId));
+}
+function finalizeWith(input) {
+	const baseHeaders = getBaseHeaders({
+		effects: input.effects,
+		clientBuildId: input.clientBuildId
+	});
+	if (Result.isFailure(baseHeaders)) return Result.fail(baseHeaders.failure);
+	let headers = baseHeaders.success;
+	const effects = input.effects;
+	let status = effects.status === null ? 200 : effects.status;
+	let body = input.body;
+	if (effects.terminal !== null) {
+		if (effects.terminal._tag === "Redirect") {
+			if (effects.terminal.client) {
+				status = 200;
+				headers = Headers$1.set(headers, HTTP_PROTOCOL.responseHeaders.clientRedirect, effects.terminal.location);
+				headers = Headers$1.set(headers, HTTP_PROTOCOL.responseHeaders.clientRedirectStatus, String(effects.terminal.status));
+			} else {
+				status = effects.terminal.status;
+				headers = Headers$1.set(headers, "location", effects.terminal.location);
+			}
+			body = null;
+		} else {
+			status = effects.terminal.status;
+			body = effects.terminal.text;
+			headers = Headers$1.set(headers, "content-type", TEXT_CONTENT_TYPE);
+		}
+	} else if (input.contentType !== null) headers = Headers$1.set(headers, "content-type", input.contentType);
+	const options = {
+		status,
+		headers,
+		cookies: effects.cookies
+	};
+	return Result.succeed(body === null ? HttpServerResponse$1.empty(options) : HttpServerResponse$1.text(body, options));
+}
+/** Prevents implicit reuse of request-dependent UI data without replacing an authored policy. */
+function withUiCacheControl(response) {
+	return Headers$1.has(response.headers, "cache-control") ? response : HttpServerResponse$1.setHeader(response, "cache-control", UI_CACHE_CONTROL);
+}
+/** A navigation's JSON payload response with its application or conservative cache policy. */
+function finalizeJson(input) {
+	return finalizeWith({
+		effects: input.effects,
+		clientBuildId: input.clientBuildId,
+		body: input.json,
+		contentType: JSON_CONTENT_TYPE
+	}).pipe(Result.map(withUiCacheControl));
+}
+/** A first load's HTML response with its application or conservative cache policy. */
+function finalizeHtml(input) {
+	return finalizeWith({
+		effects: input.effects,
+		clientBuildId: input.clientBuildId,
+		body: input.html,
+		contentType: HTML_CONTENT_TYPE
+	}).pipe(Result.map(withUiCacheControl));
+}
+/** An endpoint's JSON response. No cache-control is assumed for endpoints. */
+function finalizeEndpointJson(input) {
+	return finalizeWith({
+		effects: input.effects,
+		clientBuildId: input.clientBuildId,
+		body: input.json,
+		contentType: JSON_CONTENT_TYPE
+	});
+}
+/** An endpoint redirect, or its structured public handler rejection. */
+function finalizeEndpointTerminal(input) {
+	const terminal = input.effects.terminal;
+	if (terminal === null || terminal._tag !== "Error") return finalizeTerminal(input);
+	const envelope = {
+		error: {
+			status: terminal.status,
+			client_message: terminal.text
+		},
+		...terminal.domain === void 0 ? {} : { domain: {
+			tag: terminal.domain.tag,
+			data: terminal.domain.data
+		} }
+	};
+	return finalizeWith({
+		effects: {
+			...input.effects,
+			status: terminal.status,
+			terminal: null
+		},
+		clientBuildId: input.clientBuildId,
+		body: JSON.stringify(envelope),
+		contentType: JSON_CONTENT_TYPE
+	});
+}
+/** A response that ended before any body was produced: a redirect or an error. */
+function finalizeTerminal(input) {
+	return finalizeWith({
+		effects: input.effects,
+		clientBuildId: input.clientBuildId,
+		body: null,
+		contentType: null
+	});
+}
+/** The answer to a client whose build does not match the server's. */
+function finalizeBuildSkew(clientBuildId) {
+	return HttpServerResponse$1.text(HTTP_PROTOCOL.buildSkewBody, {
+		status: 200,
+		headers: [
+			["content-type", JSON_CONTENT_TYPE],
+			[HTTP_PROTOCOL.responseHeaders.clientBuildId, clientBuildId],
+			[HTTP_PROTOCOL.responseHeaders.buildSkew, "1"],
+			["cache-control", "no-store"]
+		]
+	});
+}
+/** A plain-text response for a Vorma protocol or execution failure. */
+function finalizeStatus(input) {
+	const headers = [["content-type", TEXT_CONTENT_TYPE], [HTTP_PROTOCOL.responseHeaders.clientBuildId, input.clientBuildId]];
+	return HttpServerResponse$1.text(input.text, {
+		status: input.status,
+		headers
+	});
+}
+//#endregion
+//#region src/server/document.ts
+const NAME_PATTERN = /^[A-Za-z][A-Za-z0-9:._-]*$/;
+const VOID_ELEMENTS = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"source",
+	"track",
+	"wbr"
+]);
+/** Escapes ordinary text once, when producing HTML. */
+function escapeText(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+/** Escapes a value for a double-quoted HTML attribute. */
+function escapeAttributeValue(value) {
+	return escapeText(value).replaceAll("\"", "&quot;");
+}
+/** Escapes serialized JSON for insertion through a script element's dangerousInnerHtml. */
+function escapeJsonForScript(serializedJson) {
+	return serializedJson.replaceAll("&", "\\u0026").replaceAll("<", "\\u003c").replaceAll(">", "\\u003e").replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+}
+function renderElementContent(element) {
+	const tag = element.tag;
+	if (!NAME_PATTERN.test(element.tag)) return Result.fail({
+		_tag: "InvalidTagName",
+		tag: element.tag
+	});
+	for (const name of Object.keys(element.attributes ?? {})) if (!NAME_PATTERN.test(name)) return Result.fail({
+		_tag: "InvalidAttributeName",
+		attribute: name,
+		tag: element.tag
+	});
+	if (element.textContent !== void 0 && element.dangerousInnerHtml !== void 0) return Result.fail({
+		_tag: "MixedTextAndRawContent",
+		tag
+	});
+	const content = element.dangerousInnerHtml ?? escapeText(element.textContent ?? "");
+	if (VOID_ELEMENTS.has(element.tag.toLowerCase()) && content !== "") return Result.fail({
+		_tag: "VoidElementWithContent",
+		tag: element.tag
+	});
+	return Result.succeed(content);
+}
+/** Serializes one element without interpreting raw code or markup. */
+function renderElement(element) {
+	return Result.map(renderElementContent(element), (content) => {
+		const attributes = Object.entries(element.attributes ?? {}).map(([name, value]) => {
+			return value === true ? ` ${name}` : ` ${name}="${escapeAttributeValue(value)}"`;
+		}).join("");
+		const start = `<${element.tag}${attributes}>`;
+		return VOID_ELEMENTS.has(element.tag.toLowerCase()) ? start : `${start}${content}</${element.tag}>`;
+	});
+}
+function renderElements(elements) {
+	const rendered = [];
+	for (const element of elements) {
+		const result = renderElement(element);
+		if (Result.isFailure(result)) return result;
+		rendered.push(result.success);
+	}
+	return Result.succeed(rendered.join("\n"));
+}
+//#endregion
+//#region src/server/runtime/assets.ts
+/** Combines static module metadata without running application code. */
+function prepareAssets(input) {
+	function collectUrls(key) {
+		const entry = new Set(input.clientEntry[key]);
+		const combined = new Set(entry);
+		for (const view of input.views) if (view !== null) for (const url of view[key]) combined.add(url);
+		const document = [...combined];
+		return {
+			document,
+			navigation: document.slice(entry.size)
+		};
+	}
+	const deps = collectUrls("depUrls");
+	const css = collectUrls("cssBundleUrls");
+	const assets = collectUrls("staticAssetUrls");
+	return {
+		navigationDepUrls: deps.navigation,
+		documentDepUrls: deps.document,
+		navigationCssBundleUrls: css.navigation,
+		documentCssBundleUrls: css.document,
+		navigationStaticAssetUrls: assets.navigation,
+		documentStaticAssetUrls: assets.document
+	};
+}
+//#endregion
+//#region src/server/runtime/head.ts
+/** The built-in identities. An element matches a rule when its tag matches and every listed attribute matches; `true` means present with any value. */
+const defaultDedupeRules = [
+	{
+		tag: "title",
+		attributes: {}
+	},
+	{
+		tag: "meta",
+		attributes: { name: "description" }
+	},
+	{
+		tag: "meta",
+		attributes: { name: "viewport" }
+	},
+	{
+		tag: "meta",
+		attributes: { name: "robots" }
+	},
+	{
+		tag: "meta",
+		attributes: { charset: true }
+	},
+	{
+		tag: "link",
+		attributes: { rel: "icon" }
+	},
+	{
+		tag: "link",
+		attributes: { rel: "canonical" }
+	},
+	{
+		tag: "meta",
+		attributes: { property: "og:title" }
+	},
+	{
+		tag: "meta",
+		attributes: { property: "og:description" }
+	},
+	{
+		tag: "meta",
+		attributes: { property: "og:url" }
+	},
+	{
+		tag: "meta",
+		attributes: { property: "og:type" }
+	},
+	{
+		tag: "meta",
+		attributes: { property: "og:locale" }
+	},
+	{
+		tag: "meta",
+		attributes: { property: "og:site_name" }
+	},
+	{
+		tag: "meta",
+		attributes: { property: "og:determiner" }
+	}
+];
+/** Normalizes the application's static rules once, preserving priority within each tag. */
+function compileHeadRules(rules) {
+	const byTag = /* @__PURE__ */ new Map();
+	for (const [index, rule] of rules.entries()) {
+		const tag = rule.tag.toLowerCase();
+		const compiled = {
+			index,
+			attributes: Object.entries(rule.attributes).map(([name, value]) => {
+				return [name.toLowerCase(), value];
+			})
+		};
+		const existing = byTag.get(tag);
+		if (existing === void 0) byTag.set(tag, [compiled]);
+		else existing.push(compiled);
+	}
+	return byTag;
+}
+/** Deduplicates managed defaults and ordered contributions before classification. */
+function prepareHead(input) {
+	const deduped = dedupeHeadElements(input);
+	let title = null;
+	const meta = [];
+	const rest = [];
+	for (const element of deduped) if (element.tag === "title") title = element;
+	else if (element.tag === "meta") meta.push(element);
+	else rest.push(element);
+	return {
+		title,
+		meta,
+		rest
+	};
+}
+function matchesRule(element, rule) {
+	for (const [name, expected] of rule.attributes) {
+		const actual = element.attributes?.[name];
+		if (actual === void 0 || expected !== true && actual !== expected) return false;
+	}
+	return true;
+}
+/** Later elements replace an identity's first position; unmatched identities use structural equality. */
+function dedupeHeadElements(input) {
+	const elements = [];
+	const indexByRule = /* @__PURE__ */ new Map();
+	const indexByShape = /* @__PURE__ */ new Map();
+	function appendElement(indexes, key, element) {
+		const index = indexes.get(key);
+		if (index === void 0) {
+			indexes.set(key, elements.length);
+			elements.push(element);
+		} else elements[index] = element;
+	}
+	for (const authored of input.elements) {
+		const element = {
+			...authored,
+			tag: authored.tag.toLowerCase(),
+			attributes: Object.fromEntries(Object.entries(authored.attributes ?? {}).map(([name, value]) => [name.toLowerCase(), value]))
+		};
+		const matchedRule = input.rules.get(element.tag)?.find((rule) => matchesRule(element, rule));
+		if (matchedRule !== void 0) appendElement(indexByRule, matchedRule.index, element);
+		else appendElement(indexByShape, toShapeKey(element), element);
+	}
+	return elements;
+}
+function toShapeKey(node) {
+	const attributes = Object.entries(node.attributes ?? {}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	return JSON.stringify([
+		"Element",
+		node.tag,
+		attributes,
+		node.textContent ?? null,
+		node.dangerousInnerHtml ?? null
+	]);
+}
+//#endregion
+//#region src/server/runtime/payload.ts
+function projectPayload(input) {
+	const { report } = input;
+	let serverError = null;
+	let allEligible = true;
+	const routes = [];
+	for (const executed of report.positions) {
+		if (executed._tag === "Suppressed") {
+			allEligible = false;
+			continue;
+		}
+		const { position, searchInput } = executed.owner;
+		const { node } = position;
+		if (executed._tag === "Failed") {
+			allEligible = false;
+			serverError = executed.error;
+			continue;
+		}
+		const module = node.clientViewModule;
+		const loaderData = executed._tag === "Completed" ? executed.data : executed._tag === "NoHandler" ? null : void 0;
+		routes.push({
+			pattern: node.pattern,
+			...Object.keys(position.params).length === 0 ? {} : { params: position.params },
+			...position.splatValues.length === 0 ? {} : { splat_values: position.splatValues },
+			compiled_pattern: {
+				...node.registered.pattern === node.pattern ? {} : { pattern: node.registered.pattern },
+				segments: node.registered.segments
+			},
+			...node.uiLoader === null || node.uiLoader.search === null ? {} : { search_contract: node.uiLoader.search.document },
+			...searchInput === null ? {} : { search_input: searchInput },
+			...module === void 0 ? {} : module === null ? { import_url: null } : {
+				import_url: module.importUrl,
+				export_names: module.exportNames
+			},
+			...loaderData === void 0 ? {} : { loader_data: loaderData }
+		});
+	}
+	const preparedHead = prepareHeadOf({
+		report,
+		headDefaults: input.headDefaults,
+		dedupeRules: input.dedupeRules
+	});
+	return {
+		route: {
+			routes,
+			...serverError === null ? {} : { server_error: {
+				index: serverError.index,
+				status: serverError.status,
+				client_message: serverError.clientMessage
+			} }
+		},
+		preparedHead,
+		...allEligible ? input.assets : prepareAssets({
+			clientEntry: input.clientEntry,
+			views: report.positions.flatMap((executed) => {
+				return executed._tag === "Failed" || executed._tag === "Suppressed" ? [] : [executed.owner.position.node.clientViewModule];
+			})
+		})
+	};
+}
+function toNavigationPayload(projection) {
+	return Result.map(toWireHead(projection.preparedHead), (head) => {
+		return {
+			...projection.route,
+			head,
+			...projection.navigationDepUrls.length === 0 ? {} : { deps: projection.navigationDepUrls },
+			...projection.navigationCssBundleUrls.length === 0 ? {} : { css_bundles: projection.navigationCssBundleUrls },
+			...projection.navigationStaticAssetUrls.length === 0 ? {} : { static_assets: projection.navigationStaticAssetUrls }
+		};
+	});
+}
+function toSsrPayload(input) {
+	return {
+		...input.projection.route,
+		client_build_id: input.clientBuildId,
+		...input.isDev ? { is_dev: true } : {},
+		...input.deploymentId === void 0 ? {} : { deployment_id: input.deploymentId }
+	};
+}
+/** The deduped head for a response, with later contributions replacing the first position of each identity. */
+function prepareHeadOf(input) {
+	const { effects } = input.report;
+	return prepareHead({
+		elements: [...input.headDefaults, ...effects.headElements],
+		rules: input.dedupeRules
+	});
+}
+/**
+* A head element on the wire: raw attribute values, which the client sets
+* through the DOM, and escaped text or trusted HTML, which the client sets
+* as inner HTML. The initial document uses the same serialization.
+*/
+function toWireHeadElement(element) {
+	const attrs = element.attributes ?? {};
+	const inner = renderElementContent(element);
+	if (Result.isFailure(inner)) return Result.fail({
+		_tag: "HeadRender",
+		tag: element.tag,
+		reason: inner.failure
+	});
+	const innerHtml = inner.success;
+	return Result.succeed({
+		tag: element.tag,
+		...Object.keys(attrs).length === 0 ? {} : { attrs },
+		...innerHtml === "" ? {} : { html: innerHtml }
+	});
+}
+function toWireHead(prepared) {
+	const sections = Result.all({
+		meta: toWireHeadElements(prepared.meta),
+		rest: toWireHeadElements(prepared.rest)
+	});
+	if (Result.isFailure(sections)) return Result.fail(sections.failure);
+	const title = prepared.title === null ? null : toWireHeadElement(prepared.title);
+	if (title !== null && Result.isFailure(title)) return Result.fail(title.failure);
+	return Result.succeed({
+		...title === null ? {} : { title: title.success },
+		...sections.success.meta.length === 0 ? {} : { meta: sections.success.meta },
+		...sections.success.rest.length === 0 ? {} : { rest: sections.success.rest }
+	});
+}
+function toWireHeadElements(elements) {
+	const out = [];
+	for (const element of elements) {
+		const wire = toWireHeadElement(element);
+		if (Result.isFailure(wire)) return Result.fail(wire.failure);
+		out.push(wire.success);
+	}
+	return Result.succeed(out);
+}
+//#endregion
+//#region src/server/runtime/plan.ts
+/** Compiles application declarations and server-side view metadata into request matchers. */
+function compileRequestPlan(input) {
+	const errors = [];
+	const uiLoaders = [];
+	const endpointNodes = [];
+	const middleware = [];
+	for (const declaration of new Set(input.handlers)) if (declaration._tag === "UiLoader") {
+		const node = compileUiLoader(declaration, errors);
+		if (node !== null) uiLoaders.push(node);
+	} else {
+		const node = compileEndpoint(declaration, errors);
+		if (node !== null) endpointNodes.push(node);
+	}
+	for (const [index, declaration] of input.middleware.entries()) {
+		const node = compileMiddleware(declaration, index, errors);
+		if (node !== null) middleware.push(node);
+	}
+	checkDuplicates(uiLoaders, endpointNodes, errors);
+	const viewErrors = [];
+	const uiNodes = linkSearchOwners(buildUiNodes({
+		uiLoaders,
+		clientViews: input.clientViews,
+		errors: viewErrors
+	}));
+	checkEndpointPatternRegistrations(endpointNodes, errors);
+	if (errors.length > 0) return Result.fail(errors);
+	const viewError = viewErrors[0];
+	if (viewError !== void 0) return Result.fail(viewError);
+	const endpoints = /* @__PURE__ */ new Map();
+	for (const [method, nodes] of groupEndpointsByMethod(endpointNodes)) endpoints.set(method, createFlatValueMatcher(nodes.map((node) => {
+		return {
+			pattern: node.registered,
+			value: node
+		};
+	})));
+	return Result.succeed({
+		clientEntry: input.clientEntry,
+		preparedRequests: /* @__PURE__ */ new Map(),
+		headDeduplicationRules: compileHeadRules([...defaultDedupeRules, ...input.document.headDeduplicationRules]),
+		document: input.document,
+		uiMatcher: createNestedValueMatcher(uiNodes.map((node) => {
+			return {
+				pattern: node.registered,
+				value: node
+			};
+		})),
+		uiByAuthoredPattern: new Map(uiNodes.map((node) => [node.pattern, node])),
+		endpoints,
+		middleware: middleware.map((node) => {
+			return {
+				node,
+				matcher: createFlatMatcher(node.registered)
+			};
+		})
+	});
+}
+function buildUiNodes(input) {
+	const nodes = /* @__PURE__ */ new Map();
+	for (const uiLoader of input.uiLoaders) nodes.set(uiLoader.registered.pattern, {
+		pattern: uiLoader.declaration.pattern,
+		registered: uiLoader.registered,
+		uiLoader,
+		clientViewModule: null
+	});
+	for (const [pattern, clientViewModule] of Object.entries(input.clientViews)) {
+		const registered = compileUiPattern(pattern);
+		if (Result.isFailure(registered)) {
+			input.errors.push({
+				_tag: "PlanError",
+				cause: registered.failure
+			});
+			continue;
+		}
+		const existing = nodes.get(registered.success.pattern);
+		nodes.set(registered.success.pattern, {
+			pattern,
+			registered: registered.success,
+			uiLoader: existing === void 0 ? null : existing.uiLoader,
+			clientViewModule
+		});
+	}
+	return [...nodes.values()];
+}
+/** Each UI position's search owners: the loaders above and at it whose search fields compose into its input. */
+function linkSearchOwners(nodes) {
+	return createNestedRouteChains({ nodes }).map(({ target, chain }) => {
+		const owners = chain.filter((node) => node.uiLoader !== null && node.uiLoader.search !== null);
+		return {
+			...target,
+			searchOwners: owners.map((owner) => owner.uiLoader)
+		};
+	});
+}
+/** Reuses only operation/pathname-derived data within this compiled application. */
+function getRequestPreparation(input) {
+	const { plan, operation, path } = input;
+	const key = operation._tag === "Ui" ? `Ui ${path}` : `Endpoint ${operation.method} ${path}`;
+	const cached = plan.preparedRequests.get(key);
+	if (cached !== void 0) {
+		plan.preparedRequests.delete(key);
+		plan.preparedRequests.set(key, cached);
+		return cached;
+	}
+	const prepared = Result.map(classifyRequest(input), (target) => {
+		return {
+			target,
+			middleware: target._tag === "NotFound" ? [] : getMiddlewareFor({
+				plan,
+				method: operation._tag === "Ui" ? "GET" : operation.method,
+				path
+			})
+		};
+	});
+	plan.preparedRequests.set(key, prepared);
+	if (plan.preparedRequests.size > 4096) {
+		const oldest = plan.preparedRequests.keys().next();
+		if (!oldest.done) plan.preparedRequests.delete(oldest.value);
+	}
+	return prepared;
+}
+function classifyRequest(input) {
+	const { plan, path, operation } = input;
+	return (operation._tag === "Ui" ? matchUi({
+		plan,
+		path
+	}) : matchEndpoint({
+		plan,
+		path,
+		method: operation.method
+	})).pipe(Result.map((target) => target ?? { _tag: "NotFound" }));
+}
+/** Selects task middleware for the mounted operation, in declaration order. */
+function getMiddlewareFor(input) {
+	const selected = [];
+	for (const entry of input.plan.middleware) {
+		if (!entry.node.declaration.methods.some((allowed) => allowed === input.method)) continue;
+		if (Option.isSome(findBestMatch(entry.matcher, input.path))) selected.push(entry.node);
+	}
+	return selected;
+}
+function matchEndpoint(input) {
+	const table = input.plan.endpoints.get(input.method);
+	if (table === void 0) return Result.succeed(null);
+	const best = findBestValueMatch(table, input.path);
+	if (Option.isNone(best)) return Result.succeed(null);
+	const node = best.value.value;
+	const captures = decodeMatchCaptures(best.value);
+	if (Result.isFailure(captures)) return Result.fail(captures.failure);
+	return Result.succeed({
+		_tag: "Endpoint",
+		node,
+		...captures.success
+	});
+}
+function matchUi(input) {
+	const matches = findNestedValueMatches(input.plan.uiMatcher, input.path);
+	if (Option.isNone(matches)) return Result.succeed(null);
+	const positions = [];
+	for (const match of matches.value) {
+		const node = match.value;
+		const captures = decodeMatchCaptures(match);
+		if (Result.isFailure(captures)) return Result.fail(captures.failure);
+		positions.push({
+			node,
+			...captures.success
+		});
+	}
+	return Result.succeed({
+		_tag: "Ui",
+		positions,
+		assets: prepareAssets({
+			clientEntry: input.plan.clientEntry,
+			views: positions.map((position) => position.node.clientViewModule)
+		})
+	});
+}
+//#endregion
+//#region src/server/runtime/render-document.ts
+/** Serializes the fixed document structure after head deduplication and classification. */
+function renderDocument(input) {
+	const assets = [];
+	if (input.criticalCss !== "") assets.push({
+		tag: "style",
+		attributes: { id: DOCUMENT_PROTOCOL.elementIds.criticalCss },
+		dangerousInnerHtml: input.criticalCss
+	});
+	for (const href of input.cssBundleUrls) assets.push({
+		tag: "link",
+		attributes: {
+			rel: "stylesheet",
+			href,
+			[DOCUMENT_PROTOCOL.attributes.cssBundle]: href
+		}
+	});
+	for (const href of input.modulePreloadUrls) assets.push({
+		tag: "link",
+		attributes: {
+			rel: "modulepreload",
+			href
+		}
+	});
+	for (const href of input.staticAssetUrls) {
+		const destination = getStaticAssetDestination(href);
+		assets.push({
+			tag: "link",
+			attributes: {
+				rel: "preload",
+				href,
+				as: destination,
+				...destination === "image" ? {} : { crossorigin: "anonymous" },
+				[DOCUMENT_PROTOCOL.attributes.staticAsset]: href
+			}
+		});
+	}
+	const sections = Result.all({
+		title: renderElements(input.prepared.title === null ? [] : [input.prepared.title]),
+		meta: renderElements(input.prepared.meta),
+		rest: renderElements(input.prepared.rest),
+		assets: renderElements(assets),
+		body: renderElements([
+			{
+				tag: "div",
+				attributes: { id: DOCUMENT_PROTOCOL.elementIds.root }
+			},
+			{
+				tag: "script",
+				attributes: {
+					id: DOCUMENT_PROTOCOL.elementIds.data,
+					type: "application/json"
+				},
+				dangerousInnerHtml: escapeJsonForScript(input.payloadJson)
+			},
+			{
+				tag: "script",
+				attributes: {
+					type: "module",
+					src: input.entryImportUrl
+				}
+			}
+		])
+	});
+	if (Result.isFailure(sections)) return Result.fail(sections.failure);
+	const headHtml = [
+		"title",
+		"meta",
+		"rest",
+		"assets"
+	].map((section) => `<!--${DOCUMENT_PROTOCOL.headComments[section]}-->\n${sections.success[section]}`).join("\n");
+	const document = Result.all({
+		head: renderElement({
+			tag: "head",
+			attributes: input.attributes.head,
+			dangerousInnerHtml: headHtml + (input.developmentHeadHtml ?? "")
+		}),
+		body: renderElement({
+			tag: "body",
+			attributes: input.attributes.body,
+			dangerousInnerHtml: sections.success.body
+		})
+	});
+	if (Result.isFailure(document)) return Result.fail(document.failure);
+	return Result.map(renderElement({
+		tag: "html",
+		attributes: input.attributes.html,
+		dangerousInnerHtml: document.success.head + document.success.body
+	}), (html) => `<!doctype html>\n${html}`);
+}
+//#endregion
+//#region src/server/runtime/pipeline.ts
+function handleRequest(input) {
+	return Effect.gen(function* () {
+		const { plan, metadata, request } = input;
+		const clientBuildId = metadata.clientBuildId;
+		const badRequest = finalizeStatus({
+			status: 400,
+			text: "Bad Request",
+			clientBuildId
+		});
+		const queryOffset = request.url.indexOf("?");
+		const rawPath = queryOffset === -1 ? request.url : request.url.slice(0, queryOffset);
+		const matcherPath = canonicalizeRequestPathForMatcher(rawPath);
+		if (Result.isFailure(matcherPath)) return badRequest;
+		const url = new URL(`${matcherPath.success}${queryOffset === -1 ? "" : request.url.slice(queryOffset)}`, "http://vorma.invalid");
+		const prepared = getRequestPreparation({
+			plan,
+			operation: input.operation,
+			path: matcherPath.success
+		});
+		if (Result.isFailure(prepared)) return badRequest;
+		const { target } = prepared.success;
+		if (target._tag === "NotFound") return yield* Effect.fail(new HttpServerError.HttpServerError({ reason: new HttpServerError.RouteNotFound({ request }) }));
+		const submittedClientBuildIds = target._tag === "Ui" ? url.searchParams.getAll(HTTP_PROTOCOL.queryKeys.viewPayload) : target._tag === "Endpoint" ? [request.headers[HTTP_PROTOCOL.requestHeaders.clientBuildId]].filter((value) => value !== void 0) : [];
+		if (submittedClientBuildIds.length > 1) return badRequest;
+		const submittedClientBuildId = submittedClientBuildIds[0];
+		const isJsonRequest = submittedClientBuildId !== void 0 && submittedClientBuildId !== "";
+		if (target._tag === "Ui" && isJsonRequest && submittedClientBuildId !== clientBuildId && submittedClientBuildId !== "_") return finalizeBuildSkew(clientBuildId);
+		if (target._tag === "Ui") {
+			url.searchParams.delete(HTTP_PROTOCOL.queryKeys.viewPayload);
+			url.searchParams.delete(HTTP_PROTOCOL.queryKeys.deployment);
+		}
+		const source = {
+			request,
+			clientBuildId: isJsonRequest && submittedClientBuildId !== "_" ? submittedClientBuildId : void 0,
+			acceptsClientRedirect: request.headers[HTTP_PROTOCOL.requestHeaders.clientAcceptsRedirect] !== void 0,
+			metadata
+		};
+		const requestContext = input.requestServices === void 0 ? Context.empty() : yield* Layer.buildWithMemoMap(input.requestServices, Layer.makeMemoMapUnsafe(), yield* Effect.scope);
+		const middleware = getMiddlewareInvocations({
+			pipeline: input,
+			source,
+			nodes: prepared.success.middleware
+		});
+		switch (target._tag) {
+			case "Endpoint": return yield* handleEndpoint({
+				pipeline: input,
+				source,
+				url,
+				middleware,
+				node: target.node,
+				params: target.params,
+				splatValues: target.splatValues
+			}).pipe(Effect.provideContext(requestContext));
+			case "Ui": return yield* handleUi({
+				pipeline: input,
+				source,
+				url,
+				isJsonRequest,
+				middleware,
+				positions: target.positions,
+				assets: target.assets
+			}).pipe(Effect.provideContext(requestContext));
+		}
+	});
+}
+function makeInternalError(input) {
+	return Effect.logError(input.message, input.detail).pipe(Effect.as(finalizeStatus({
+		status: 500,
+		text: "Internal Server Error",
+		clientBuildId: input.clientBuildId
+	})));
+}
+function describeFinalizeError(error) {
+	switch (error._tag) {
+		case "FrameworkOwnedHeader": return "a handler set a header the framework owns";
+	}
+}
+function finalizeResult(input) {
+	if (Result.isFailure(input.result)) return makeInternalError({
+		clientBuildId: input.clientBuildId,
+		message: describeFinalizeError(input.result.failure),
+		detail: input.result.failure
+	});
+	return Effect.succeed(input.result.success);
+}
+function runHandler(input) {
+	return Effect.gen(function* () {
+		const effects = yield* Ref.make(empty);
+		const context = input.makeContextFn(effects);
+		const body = input.fn(context);
+		const provided = Effect.provideContext(body, input.services);
+		const exit = yield* Effect.exit(provided);
+		const contributions = yield* Ref.get(effects);
+		if (Exit.isFailure(exit)) {
+			if (matchesHandlerEndInterruption(exit.cause) && endsResponse(contributions)) return {
+				_tag: "Terminal",
+				effects: contributions
+			};
+			return {
+				_tag: "Failed",
+				effects: contributions,
+				cause: resolveDeclaredCause({
+					cause: exit.cause,
+					errors: input.errors
+				})
+			};
+		}
+		const output = yield* Effect.exit(input.readOutputFn(exit.value));
+		if (Exit.isFailure(output)) return {
+			_tag: "Failed",
+			effects: contributions,
+			cause: output.cause
+		};
+		return endsResponse(contributions) ? {
+			_tag: "Terminal",
+			effects: contributions
+		} : {
+			_tag: "Continue",
+			effects: contributions,
+			data: output.value
+		};
+	});
+}
+/** Reuses schema preparation by identity; each invocation still validates its own value. */
+const getTypeDecoder = memoize((schema) => {
+	return Schema.decodeUnknownEffect(Schema.toType(schema));
+});
+/** Validates the decoded output before transporting its supported values. */
+function encodeHandlerOutput(input) {
+	return Effect.gen(function* () {
+		const validated = yield* getTypeDecoder(input.schema)(input.value).pipe(Effect.mapError((cause) => new HandlerError({
+			status: 500,
+			cause
+		})));
+		return yield* Effect.fromResult(encodeTransportedValue({
+			value: validated,
+			typeEntries: SERVER_TRANSPORT_TYPE_ENTRIES
+		})).pipe(Effect.mapError((cause) => new HandlerError({
+			status: 500,
+			cause
+		})));
+	});
+}
+function resolveDeclaredCause(input) {
+	const reason = input.cause.reasons[0];
+	if (input.cause.reasons.length === 1 && reason !== void 0 && Cause.isFailReason(reason) && !(reason.error instanceof HandlerError)) {
+		const matched = matchDeclaredError({
+			errors: input.errors,
+			value: reason.error
+		});
+		if (matched !== void 0) return Cause.fail(new DeclaredDomainError({
+			status: matched.status,
+			clientMessage: getStatusText(matched.status),
+			tag: matched.tag,
+			data: matched.data
+		}));
+	}
+	return input.cause;
+}
+/** The response operations every handler context shares: one effects ref, the request's redirect acceptance, and route targets resolved against the plan. */
+function makeSharedResponseOps(input) {
+	return makeResponseOps({
+		effects: input.effects,
+		acceptsClientRedirect: input.source.acceptsClientRedirect,
+		resolveRouteTargetFn: (options) => {
+			return resolveRouteTarget({
+				plan: input.plan,
+				...options
+			});
+		}
+	});
+}
+function makeRouteContext(input) {
+	return {
+		...makeRequestFacts(input.source, input.facts),
+		...makeSharedResponseOps(input)
+	};
+}
+function makeUiLoaderContext(input) {
+	return {
+		...makeRouteContext(input),
+		...makeHeadOps(input.effects)
+	};
+}
+function makeMiddlewareContext(input) {
+	return {
+		...makeIncomingRequestFacts(input.source),
+		...makeSharedResponseOps(input),
+		...makeHeadOps(input.effects)
+	};
+}
+/** A UI pattern an application names, with the search it supplies validated by the pattern's owners. */
+function resolveRouteTarget(input) {
+	const target = input.plan.uiByAuthoredPattern.get(`${input.pattern === "/" ? "" : input.pattern}/_index`) ?? input.plan.uiByAuthoredPattern.get(input.pattern);
+	if (target === void 0) return Effect.fail({
+		_tag: "UnknownRoutePattern",
+		pattern: input.pattern
+	});
+	const pattern = target.pattern;
+	const owners = target.searchOwners;
+	if (owners.length === 0) return input.search === void 0 ? Effect.succeed({
+		pattern,
+		search: void 0
+	}) : Effect.fail({
+		_tag: "UnexpectedRouteSearch",
+		pattern: input.pattern
+	});
+	const value = input.search === void 0 ? {} : input.search;
+	return Effect.forEach(owners, (owner) => {
+		return getTypeDecoder(owner.search.schema)(projectSearchFields(value, owner.search.fields.keys()));
+	}, { concurrency: "unbounded" }).pipe(Effect.flatMap((validated) => {
+		return Effect.gen(function* () {
+			const merged = makeNullPrototypeRecord();
+			for (const part of validated) {
+				if (typeof part !== "object" || part === null) return yield* Effect.fail({
+					_tag: "InvalidRouteSearchEncoding",
+					pattern: input.pattern
+				});
+				for (const [key, child] of getOwnEntries(part)) merged[key] = child;
+			}
+			return {
+				pattern,
+				search: merged
+			};
+		});
+	}));
+}
+function getMiddlewareInvocations(input) {
+	const { pipeline, source } = input;
+	return input.nodes.map((node, index) => {
+		return {
+			id: `middleware:${index}`,
+			role: "middleware",
+			pattern: node.declaration.patterns.join(" "),
+			run: runHandler({
+				makeContextFn: (effects) => {
+					return makeMiddlewareContext({
+						effects,
+						source,
+						plan: pipeline.plan
+					});
+				},
+				fn: node.declaration.fn,
+				readOutputFn: () => Effect.void,
+				errors: [],
+				services: pipeline.services.middleware
+			})
+		};
+	});
+}
+/** Parses a request's search through its check-free contract document; a grammar failure is the handler's 400. */
+function parseSearch(input) {
+	return Result.mapError(parseSearchParams({
+		document: input.document,
+		params: input.params,
+		typeEntries: SERVER_TRANSPORT_TYPE_ENTRIES
+	}), (cause) => {
+		return new HandlerError({
+			status: 400,
+			clientMessage: "Invalid search parameters",
+			cause
+		});
+	});
+}
+/** Validates a parsed search against the declared codec's decoded side; a contract failure is the handler's 400. */
+function decodeParsedSearch(input) {
+	return getTypeDecoder(input.schema)(input.parsed).pipe(Effect.mapError((cause) => {
+		return new HandlerError({
+			status: 400,
+			clientMessage: "Invalid search parameters",
+			cause
+		});
+	}));
+}
+function decodeSearch(input) {
+	if (input.search === null) return Effect.succeed(void 0);
+	return Effect.fromResult(parseSearch({
+		document: input.search.document,
+		params: input.params
+	})).pipe(Effect.flatMap((parsed) => {
+		return decodeParsedSearch({
+			schema: input.search.schema,
+			parsed
+		});
+	}));
+}
+function makeBadBodyError(cause) {
+	return new HandlerError({
+		status: 400,
+		clientMessage: "Invalid body",
+		cause
+	});
+}
+/** Acquires the body through native Effect readers and their request-context controls. */
+function readEndpointBody(input) {
+	const transport = getInputTransport(input.declaration);
+	if (transport.kind === "json") return input.request.json;
+	if (transport.kind === "formData") return input.request.headers["content-type"]?.toLowerCase().includes("multipart/form-data") ? input.request.multipart : input.request.urlParamsBody.pipe(Effect.map(UrlParams.toRecord));
+	return Effect.succeed(void 0);
+}
+function decodeBody(input) {
+	const transport = getInputTransport(input.declaration);
+	if (transport.kind !== "json" && transport.kind !== "formData") return Effect.succeed(void 0);
+	const raw = transport.kind === "formData" ? Effect.succeed(input.value) : Effect.fromResult(readTransportedValue(input.value)).pipe(Effect.flatMap((transported) => {
+		return Effect.fromResult(decodeTransportedValue({
+			transported,
+			typeEntries: SERVER_TRANSPORT_TYPE_ENTRIES
+		}));
+	}), Effect.mapError(makeBadBodyError));
+	const decode = transport.kind === "formData" ? Schema.decodeUnknownEffect(transport.schema) : getTypeDecoder(transport.schema);
+	return raw.pipe(Effect.flatMap((value) => {
+		return decode(value).pipe(Effect.mapError(makeBadBodyError));
+	}));
+}
+const SERVICES_FOR_ENDPOINT_KIND = {
+	query: "queries",
+	mutation: "mutations",
+	stream: "streams"
+};
+function getServicesForKind(input) {
+	return input.services[SERVICES_FOR_ENDPOINT_KIND[input.kind]];
+}
+function handleEndpoint(input) {
+	return Effect.gen(function* () {
+		const { pipeline, node, source } = input;
+		const { metadata, request } = pipeline;
+		const declaration = node.declaration;
+		const clientBuildId = metadata.clientBuildId;
+		if (declaration.kind === "stream") return yield* makeInternalError({
+			clientBuildId,
+			message: "stream endpoints are not implemented in this runtime yet",
+			detail: declaration.pattern
+		});
+		const middleware = yield* executeMiddleware(input.middleware);
+		if (middleware._tag === "Terminal") return yield* finalizeResult({
+			clientBuildId,
+			result: finalizeEndpointTerminal({
+				effects: middleware.effects,
+				clientBuildId
+			})
+		});
+		const value = declaration.method === "GET" ? void 0 : yield* readEndpointBody({
+			declaration,
+			request
+		});
+		const services = getServicesForKind({
+			services: pipeline.services,
+			kind: declaration.kind
+		});
+		const decodeInput = (declaration.method === "GET" ? decodeSearch({
+			search: node.search,
+			params: input.url.searchParams
+		}) : decodeBody({
+			declaration,
+			value
+		})).pipe(Effect.provideContext(services));
+		const invocation = {
+			id: `endpoint:${declaration.method} ${declaration.pattern}`,
+			role: "endpoint",
+			pattern: declaration.pattern,
+			run: decodeInput.pipe(Effect.flatMap((decoded) => {
+				return runHandler({
+					makeContextFn: (effects) => {
+						return makeRouteContext({
+							effects,
+							source,
+							plan: pipeline.plan,
+							facts: {
+								pattern: declaration.pattern,
+								params: { ...input.params },
+								splatValues: [...input.splatValues],
+								input: decoded
+							}
+						});
+					},
+					fn: declaration.fn,
+					readOutputFn: (value) => {
+						return encodeHandlerOutput({
+							schema: declaration.output,
+							value
+						});
+					},
+					errors: declaration.errors,
+					services
+				});
+			}))
+		};
+		return yield* executeEndpoint({
+			effects: middleware.effects,
+			endpoint: invocation
+		}).pipe(Effect.flatMap((report) => {
+			if (report._tag === "Terminal") return finalizeResult({
+				clientBuildId,
+				result: finalizeEndpointTerminal({
+					effects: report.effects,
+					clientBuildId
+				})
+			});
+			const serialized = serializeResponseJson(report.data);
+			if (Result.isFailure(serialized)) return makeInternalError({
+				clientBuildId,
+				message: "the endpoint response could not be serialized",
+				detail: serialized.failure
+			});
+			return finalizeResult({
+				clientBuildId,
+				result: finalizeEndpointJson({
+					json: serialized.success,
+					effects: report.effects,
+					clientBuildId
+				})
+			});
+		}));
+	});
+}
+function prepareDocumentValue(input) {
+	return Effect.suspend(() => {
+		return Effect.provideContext(input.fn(makeIncomingRequestFacts(input.source)), input.services);
+	}).pipe(Effect.catchCause((cause) => {
+		return Cause.hasInterruptsOnly(cause) ? Effect.interrupt : Effect.fail({
+			_tag: "DocumentPreparationError",
+			cause
+		});
+	}));
+}
+function handleUi(input) {
+	const { pipeline, source, positions } = input;
+	const { plan, metadata } = pipeline;
+	const executionPositions = positions.map((position) => {
+		const search = position.node.uiLoader === null ? null : position.node.uiLoader.search;
+		return {
+			position,
+			searchInput: search === null ? null : parseSearch({
+				document: search.document,
+				params: input.url.searchParams
+			})
+		};
+	}).map((owner) => {
+		const { position, searchInput } = owner;
+		const uiLoader = position.node.uiLoader;
+		if (uiLoader === null) return {
+			owner,
+			invocation: null
+		};
+		const search = uiLoader.search;
+		return {
+			owner,
+			invocation: {
+				id: `uiLoader:${uiLoader.declaration.pattern}`,
+				role: "uiLoader",
+				pattern: uiLoader.declaration.pattern,
+				run: (search === null || searchInput === null ? Effect.succeed(void 0) : Effect.fromResult(searchInput).pipe(Effect.flatMap((parsed) => {
+					return decodeParsedSearch({
+						schema: search.schema,
+						parsed
+					});
+				}))).pipe(Effect.flatMap((decoded) => {
+					return runHandler({
+						makeContextFn: (effects) => {
+							return makeUiLoaderContext({
+								effects,
+								source,
+								plan,
+								facts: {
+									pattern: uiLoader.declaration.pattern,
+									params: { ...position.params },
+									splatValues: [...position.splatValues],
+									input: decoded
+								}
+							});
+						},
+						fn: uiLoader.declaration.fn,
+						readOutputFn: (value) => {
+							return encodeHandlerOutput({
+								schema: uiLoader.declaration.output,
+								value
+							});
+						},
+						errors: [],
+						services: pipeline.services.uiLoaders
+					});
+				}))
+			}
+		};
+	});
+	return Effect.scoped(Effect.gen(function* () {
+		const middleware = yield* executeMiddleware(input.middleware);
+		if (middleware._tag === "Terminal") return yield* finalizeResult({
+			clientBuildId: metadata.clientBuildId,
+			result: finalizeTerminal({
+				effects: middleware.effects,
+				clientBuildId: metadata.clientBuildId
+			})
+		});
+		const defaults = yield* Effect.forkScoped(prepareDocumentValue({
+			fn: plan.document.defaultHeadFn,
+			source,
+			services: pipeline.services.document
+		}));
+		const attributes = input.isJsonRequest ? null : yield* Effect.forkScoped(prepareDocumentValue({
+			fn: plan.document.attributesFn,
+			source,
+			services: pipeline.services.document
+		}));
+		const routes = yield* Effect.forkScoped(executeUi({
+			effects: middleware.effects,
+			positions: executionPositions
+		}));
+		const report = yield* Fiber.join(routes);
+		if (report._tag === "Terminal") return yield* finalizeResult({
+			clientBuildId: metadata.clientBuildId,
+			result: finalizeTerminal({
+				effects: report.effects,
+				clientBuildId: metadata.clientBuildId
+			})
+		});
+		const headDefaults = yield* Fiber.join(defaults);
+		return yield* respondUi({
+			pipeline,
+			assets: input.assets,
+			output: attributes === null ? { kind: "navigation" } : {
+				kind: "document",
+				attributes: yield* Fiber.join(attributes)
+			},
+			report,
+			headDefaults
+		});
+	})).pipe(Effect.catchTag("DocumentPreparationError", (error) => {
+		return makeInternalError({
+			clientBuildId: metadata.clientBuildId,
+			message: "the document could not be prepared",
+			detail: error.cause
+		});
+	}));
+}
+function respondUi(input) {
+	const { pipeline, report } = input;
+	const { metadata } = pipeline;
+	const clientBuildId = metadata.clientBuildId;
+	const dedupeRules = pipeline.plan.headDeduplicationRules;
+	const positions = [];
+	for (const executed of report.positions) {
+		if (executed._tag === "Suppressed") continue;
+		const route = executed.owner;
+		let searchInput = null;
+		if (executed._tag !== "Failed" && route.searchInput !== null && Result.isSuccess(route.searchInput)) {
+			const transported = encodeTransportedValue({
+				value: route.searchInput.success,
+				typeEntries: SERVER_TRANSPORT_TYPE_ENTRIES
+			});
+			if (Result.isFailure(transported)) return makeInternalError({
+				clientBuildId,
+				message: "the route search input could not be transported",
+				detail: transported.failure
+			});
+			searchInput = transported.success;
+		}
+		positions.push({
+			...executed,
+			owner: {
+				position: route.position,
+				searchInput
+			}
+		});
+	}
+	const payload = projectPayload({
+		clientEntry: metadata.clientEntry,
+		assets: input.assets,
+		report: {
+			...report,
+			positions
+		},
+		headDefaults: input.headDefaults,
+		dedupeRules
+	});
+	if (input.output.kind === "navigation") {
+		const navigationPayload = toNavigationPayload(payload);
+		if (Result.isFailure(navigationPayload)) return makeInternalError({
+			clientBuildId,
+			message: "the navigation head could not be serialized",
+			detail: navigationPayload.failure
+		});
+		const serialized = serializeResponseJson(navigationPayload.success);
+		if (Result.isFailure(serialized)) return makeInternalError({
+			clientBuildId,
+			message: "the UI payload could not be serialized",
+			detail: serialized.failure
+		});
+		return finalizeResult({
+			clientBuildId,
+			result: finalizeJson({
+				json: serialized.success,
+				effects: report.effects,
+				clientBuildId
+			})
+		});
+	}
+	const serialized = serializeResponseJson(toSsrPayload({
+		projection: payload,
+		clientBuildId,
+		isDev: pipeline.isDev,
+		deploymentId: pipeline.deploymentId
+	}));
+	if (Result.isFailure(serialized)) return makeInternalError({
+		clientBuildId,
+		message: "the document payload could not be serialized",
+		detail: serialized.failure
+	});
+	const html = renderDocument({
+		attributes: input.output.attributes,
+		prepared: payload.preparedHead,
+		criticalCss: metadata.criticalCss,
+		...metadata.developmentHeadHtml === void 0 ? {} : { developmentHeadHtml: metadata.developmentHeadHtml },
+		cssBundleUrls: payload.documentCssBundleUrls,
+		staticAssetUrls: payload.documentStaticAssetUrls,
+		modulePreloadUrls: [
+			metadata.clientEntry.importUrl,
+			...payload.route.routes.flatMap((route) => {
+				return route.import_url === void 0 || route.import_url === null ? [] : [route.import_url];
+			}),
+			...payload.documentDepUrls
+		],
+		entryImportUrl: metadata.clientEntry.importUrl,
+		payloadJson: serialized.success
+	});
+	if (Result.isFailure(html)) return makeInternalError({
+		clientBuildId,
+		message: "the document failed to render",
+		detail: html.failure
+	});
+	return finalizeResult({
+		clientBuildId,
+		result: finalizeHtml({
+			html: html.success,
+			effects: report.effects,
+			clientBuildId
+		})
+	});
+}
+/** Application data has been captured and parsed; serialization can still exceed engine limits. */
+function serializeResponseJson(payload) {
+	return Result.flatMap(Result.try(() => JSON.stringify(payload)), (json) => {
+		return json === void 0 ? Result.fail("The response has no JSON representation") : Result.succeed(json);
+	});
+}
+//#endregion
+//#region src/server/runtime/vercel-deployment.ts
+const VERCEL_SKEW_PROTECTION_ENABLED = Config.option(Config.Boolean(PROCESS_ENVIRONMENT_PROTOCOL.vercelSkewProtectionEnabledVariable));
+const VERCEL_DEPLOYMENT_ID = Config.option(Config.String(PROCESS_ENVIRONMENT_PROTOCOL.vercelDeploymentIdVariable));
+const getVercelDeploymentId = Effect.gen(function* () {
+	const enabled = yield* VERCEL_SKEW_PROTECTION_ENABLED;
+	if (Option.isNone(enabled) || enabled.value === false) return;
+	return Option.getOrUndefined(yield* VERCEL_DEPLOYMENT_ID);
+});
+//#endregion
+//#region src/server/index.ts
+function makeUiLoader(definition) {
+	return {
+		_tag: "UiLoader",
+		pattern: definition.pattern,
+		input: definition.input,
+		output: definition.output,
+		fn: definition.fn
+	};
+}
+const UiLoader = { make: makeUiLoader };
+/** Query and mutation declarations have the same construction and HTTP method choices. */
+function makeResponseEndpointMaker(kind) {
+	function make(definition) {
+		return {
+			_tag: "Endpoint",
+			kind,
+			method: definition.method,
+			pattern: definition.pattern,
+			input: definition.input,
+			output: definition.output,
+			event: void 0,
+			errors: definition.errors === void 0 ? [] : definition.errors,
+			fn: definition.fn
+		};
+	}
+	return make;
+}
+function makeStreamEndpoint(definition) {
+	return {
+		_tag: "Endpoint",
+		kind: "stream",
+		method: definition.method,
+		pattern: definition.pattern,
+		input: definition.input,
+		output: void 0,
+		event: definition.event,
+		errors: [],
+		fn: definition.fn
+	};
+}
+const QueryEndpoint = { make: makeResponseEndpointMaker("query") };
+const MutationEndpoint = { make: makeResponseEndpointMaker("mutation") };
+/** Unimplemented declaration scaffold. The build rejects registered stream endpoints. */
+const StreamEndpoint = { make: makeStreamEndpoint };
+function makeTaskMiddleware(definition) {
+	return {
+		_tag: "TaskMiddleware",
+		patterns: definition.patterns,
+		methods: definition.methods,
+		fn: definition.fn
+	};
+}
+const TaskMiddleware = { make: makeTaskMiddleware };
+function makeHtmlDocument(definition) {
+	return {
+		_tag: "HtmlDocument",
+		attributesFn: definition.attributesFn,
+		defaultHeadFn: definition.defaultHeadFn,
+		headDeduplicationRules: definition.headDeduplicationRules ?? []
+	};
+}
+const HtmlDocument = { make: makeHtmlDocument };
+/**
+* Connects configuration, the document, and ordered task middleware without
+* starting execution. Explicit startup acquires the compiled declarations and
+* metadata through one shared application Layer.
+*/
+function makeApplication(input) {
+	return {
+		_tag: "Application",
+		[APPLICATION_RUNTIME]: makeApplicationRuntime(input.config),
+		document: input.document,
+		middleware: input.middleware
+	};
+}
+/** A startup failure: the deployment or its generated source is wrong, never a defect. */
+function failStartup(input) {
+	return Effect.fail(createVormaStartupError(input));
+}
+/**
+* Acquires handlers for application-controlled mounting. Per-kind Layers provide
+* application services, and the optional request Layer supplies request services.
+*/
+function makeHandlers(options) {
+	return Effect.gen(function* () {
+		const { app } = options;
+		const runtime = yield* ApplicationRuntime;
+		const { metadata } = runtime;
+		const isDev = metadata.runtimeMode === "development";
+		function toCriticalCssDigest(css) {
+			return base64.encode(sha256(new TextEncoder().encode(css)));
+		}
+		const criticalCssDigest = runtime.readDevelopmentMetadata === void 0 ? Effect.succeed(toCriticalCssDigest(metadata.criticalCss)) : runtime.readDevelopmentMetadata.pipe(Effect.map((current) => toCriticalCssDigest(current.criticalCss)));
+		const deploymentId = yield* getVercelDeploymentId.pipe(Effect.mapError((cause) => {
+			return createVormaStartupError({
+				operation: "readDeploymentConfiguration",
+				message: "Vorma could not read deployment configuration",
+				cause
+			});
+		}));
+		const plan = compileRequestPlan({
+			clientEntry: metadata.clientEntry,
+			document: app.document,
+			handlers: runtime.registeredDeclarations,
+			middleware: app.middleware,
+			clientViews: metadata.clientViews
+		});
+		if (Result.isFailure(plan)) {
+			const invalidDeclarations = Array.isArray(plan.failure);
+			return yield* failStartup({
+				operation: invalidDeclarations ? "validateApplicationGraph" : "buildRequestPlan",
+				message: invalidDeclarations ? "The Vorma application graph is invalid" : "Vorma could not build the request plan",
+				cause: plan.failure
+			});
+		}
+		const memoMap = Layer.CurrentMemoMap.forkOrCreate(yield* Effect.context());
+		const scope = yield* Effect.scope;
+		const serviceLayers = {
+			document: options.documentServices,
+			uiLoaders: options.uiLoaderServices,
+			queries: options.queryServices,
+			mutations: options.mutationServices,
+			streams: options.streamServices,
+			middleware: options.middlewareServices
+		};
+		const services = yield* Effect.all(Record.map(serviceLayers, (serviceLayer) => {
+			return Layer.buildWithMemoMap(serviceLayer === void 0 ? Layer.empty : serviceLayer, memoMap, scope);
+		}), { concurrency: "unbounded" });
+		const taskRuntime = yield* Layer.buildWithMemoMap(TaskRuntime.layer, memoMap, scope);
+		let compiledPlan = plan.success;
+		let plannedMetadata = metadata;
+		function forOperation(operation) {
+			return Effect.gen(function* () {
+				const request = yield* HttpServerRequest.HttpServerRequest;
+				const requestMetadata = runtime.readDevelopmentMetadata === void 0 ? metadata : yield* runtime.readDevelopmentMetadata;
+				if (requestMetadata !== plannedMetadata) {
+					const nextPlan = compileRequestPlan({
+						clientEntry: requestMetadata.clientEntry,
+						document: app.document,
+						handlers: runtime.registeredDeclarations,
+						middleware: app.middleware,
+						clientViews: requestMetadata.clientViews
+					});
+					if (Result.isFailure(nextPlan)) return yield* failStartup({
+						operation: "buildRequestPlan",
+						message: "Vorma could not prepare the development request plan",
+						cause: nextPlan.failure
+					});
+					compiledPlan = nextPlan.success;
+					plannedMetadata = requestMetadata;
+				}
+				return yield* handleRequest({
+					plan: compiledPlan,
+					operation,
+					metadata: requestMetadata,
+					request,
+					services,
+					...options.requestServices === void 0 ? {} : { requestServices: options.requestServices },
+					isDev,
+					...deploymentId === void 0 ? {} : { deploymentId }
+				});
+			}).pipe(Effect.provideServiceEffect(TaskContext, TaskContext.make), Effect.provideContext(taskRuntime));
+		}
+		const ui = forOperation({ _tag: "Ui" });
+		return {
+			ui: isDev ? Effect.gen(function* () {
+				const request = yield* HttpServerRequest.HttpServerRequest;
+				if (request.method === "GET" && request.url.split("?", 1)[0] === DEVELOPMENT_PROTOCOL.readinessPath) return HttpServerResponse.text("ok");
+				return yield* ui;
+			}) : ui,
+			/** Base64 SHA-256 of the exact inline critical CSS; use it in a CSP hash source. */
+			getCriticalCssContentSha256: () => {
+				return criticalCssDigest;
+			},
+			forEndpointMethod: (method) => forOperation({
+				_tag: "Endpoint",
+				method
+			})
+		};
+	}).pipe(Effect.provide(options.app[APPLICATION_RUNTIME]));
+}
+const Vorma = {
+	/** Inert application construction from configuration, a document, and ordered task middleware. */
+	makeApplication,
+	/**
+	* Acquires UI and endpoint handlers. The application selects each native
+	* registration's method and path and owns serving and service composition.
+	*/
+	makeHandlers,
+	/** Creates file-serving middleware that the application explicitly mounts. */
+	makePublicAssetsFileMiddleware
+};
+//#endregion
+export { FormData, HandlerError, HtmlDocument, MutationEndpoint, QueryEndpoint, ResponseInputError, StreamEndpoint, TaskMiddleware, UiLoader, Vorma, escapeJsonForScript };