@sjcx/vorma 0.0.0-pre.2 → 0.0.0-pre.4

package/dist/server/index.js

@@ -1,2311 +0,0 @@
-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 };