@sjcx/vorma 0.0.0-pre.0

package/dist/build-JgARonaY.js

@@ -0,0 +1,3214 @@
+import { c as compileUiPattern, m as ARTIFACT_PROTOCOL, s as compileEndpointPattern, t as EFFECT_TRANSPORT_TYPES, y as FRAMEWORK_IDENTITY_PROTOCOL } from "./value-transport-Bst4Hk-n.js";
+import { t as VORMA_BUILD_PLUGIN_NAME } from "./build-invocation-D7Fu8gBK.js";
+import { c as findConflictingDynamicParameterNames, f as matchesHttpMethod, o as createNestedRouteChains } from "./compile-Me8EOyMK.js";
+import { VormaConfigSchema } from "./server/config/index.js";
+import { Effect, FileSystem, Option, Record, Result, Schema } from "effect";
+import { build } from "vite";
+import { blake3 } from "@noble/hashes/blake3.js";
+import { utf8ToBytes } from "@noble/hashes/utils.js";
+import { base32nopad } from "@scure/base";
+import { isAbsolute, join } from "node:path";
+import { RolldownMagicString, build as build$1 } from "rolldown";
+import { readFile } from "node:fs/promises";
+import * as Path$1 from "effect/Path";
+import { SyntaxKind, TokenFlags, isAsExpression, isCallExpression, isElementAccessExpression, isExportSpecifier, isIdentifier, isImportClause, isImportSpecifier, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isParenthesizedExpression, isPropertyAccessExpression, isSatisfiesExpression, isStringLiteral, isTypeAssertion, isTypeNode } from "typescript/unstable/ast";
+import { API, ElementFlags, SignatureKind, SymbolFlags } from "typescript/unstable/sync";
+import { createTemplateHead, createTemplateMiddle, createTemplateTail } from "typescript/unstable/ast/factory";
+import * as FileSystem$1 from "effect/FileSystem";
+import { pid, platform } from "node:process";
+import { transform } from "lightningcss";
+//#region src/universal/content-digest.ts
+/** BLAKE3 content identity, encoded as lowercase base32 without padding. */
+function toContentDigest(source) {
+	return encodeContentDigest(blake3(typeof source === "string" ? utf8ToBytes(source) : source));
+}
+/** Encodes an already computed BLAKE3 digest. */
+function encodeContentDigest(digest) {
+	return base32nopad.encode(digest).toLowerCase();
+}
+/** Canonical object ordering; array order carries framework semantics. */
+function encodeCanonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(encodeCanonicalJson).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${encodeCanonicalJson(item)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+//#endregion
+//#region src/build/browser-contracts.ts
+/**
+* The static contracts on which browser code and learned routing depend.
+* Source locations, export names, and runtime implementations are not inputs.
+* This projection is hashed during the build and is never sent to the browser.
+*/
+function projectBrowserContracts(inspection) {
+	const declarations = inspection.serverDeclarations.map((declaration) => {
+		if (declaration.kind === "UiLoader") return [`UiLoader ${declaration.pattern}`, {
+			input: declaration.input ?? "undefined",
+			output: declaration.output
+		}];
+		return [`${declaration.method} ${declaration.pattern}`, {
+			operation: declaration.operation,
+			inputTransport: declaration.inputTransport,
+			input: declaration.inputTransport === "formData" ? "FormData" : declaration.input ?? "undefined",
+			output: declaration.output ?? "undefined",
+			event: declaration.event ?? "undefined",
+			errors: Object.fromEntries(declaration.errors.map((error) => {
+				return [error.tag, error.fields];
+			}))
+		}];
+	});
+	return {
+		declarations: Object.fromEntries(declarations),
+		typeAliases: inspection.typeAliases
+	};
+}
+//#endregion
+//#region src/build/client-inputs.ts
+/** Runtime peers that must have one browser identity in development and production. */
+const CLIENT_SHARED_PACKAGES = [
+	"effect",
+	"@effect/atom-react",
+	"react",
+	"react-dom"
+];
+/** Keeps value identity checks inside the selected route's normal module load. */
+function getClientViewEntries(generation) {
+	return [...generation.model.clientViewCandidates].flatMap(([pattern, candidates], index) => {
+		const first = candidates[0];
+		if (first === void 0) return [];
+		if (candidates.every((candidate) => candidate.filePath === first.filePath)) return [{
+			pattern,
+			id: first.filePath,
+			exportNames: candidates.map((candidate) => candidate.exportName),
+			source: void 0
+		}];
+		const exportNames = candidates.map((_candidate, candidateIndex) => `candidate${candidateIndex}`);
+		return [{
+			pattern,
+			id: `\0vorma:view-candidates:${index}`,
+			exportNames,
+			source: candidates.map((candidate, candidateIndex) => `export { ${JSON.stringify(candidate.exportName)} as ${exportNames[candidateIndex]} } from ${JSON.stringify(candidate.filePath)};`).join("\n")
+		}];
+	});
+}
+//#endregion
+//#region src/build/contained-path.ts
+/** True when a `path.relative` result names the root or a descendant of it. */
+function containsRelativePath(input) {
+	return input.relativePath === "" || !input.absolute && input.relativePath !== ".." && !input.relativePath.startsWith(`..${input.separator}`);
+}
+/**
+* True when a module specifier names a package or one of its subpaths.
+* Relative, absolute, builtin, scheme, drive-letter, and virtual-module
+* specifiers never match; only the caller decides which of those to exclude
+* first.
+*/
+function matchesPackageSpecifier(input) {
+	return input.source === input.packageName || input.source.startsWith(`${input.packageName}/`);
+}
+/**
+* A `path.relative` result with platform separators converted to POSIX
+* separators, for generated module specifiers, output keys, and build
+* identities, which are POSIX even when the build runs on Windows.
+*/
+function toPosixRelativePath(input) {
+	return input.path.relative(input.from, input.to).split(input.path.sep).join("/");
+}
+//#endregion
+//#region src/build/compile-server.ts
+/** Log codes reporting a specifier the compiler could not resolve. */
+const UNRESOLVED_LOG_CODE = /^UNRESOLVED/;
+const TERMINAL_STYLE = new RegExp(`${String.fromCharCode(27)}\\[[\\d;]*m`, "g");
+/** The plain first line of a compiler message, with the module it concerns. */
+function toLogSummary(log) {
+	const plain = log.message.replace(TERMINAL_STYLE, "");
+	const [firstLine] = plain.split("\n");
+	const summary = firstLine === void 0 ? plain : firstLine;
+	return log.id === void 0 ? summary : `${summary} (${log.id})`;
+}
+/**
+* Compiles the configured server entry and internal runtime
+* entry together into ECMAScript modules that run
+* without a TypeScript loader, a Vorma installation, or a bundler in the
+* target process. The compilation rewrites nothing in the application's
+* source. Effect remains a runtime peer shared with the containing application.
+*
+* Rolldown uses the configured server TypeScript project. The client's Vite
+* configuration does not configure server compilation.
+*
+* Production bytes must depend on the sources alone, so the debug comments
+* that name module paths relative to the build directory are off: the
+* checkout's location must not reach the artifact. Symlink resolution stays on
+* because an isolated package store reaches a package's own dependencies only
+* through the real path. Development source maps retain authored locations.
+*/
+function compileServerApplication(input) {
+	return Effect.gen(function* () {
+		const { generation } = input;
+		const { config } = generation;
+		const diagnostics = [];
+		const unresolvedImports = [];
+		let inputFilePaths = [];
+		const output = yield* Effect.tryPromise(() => {
+			return build$1({
+				input: {
+					entry: config.serverEntryFilePath,
+					runtime: config.generatedBuildFilePath
+				},
+				preserveEntrySignatures: "strict",
+				cwd: config.serverProjectDirectory,
+				platform: "node",
+				tsconfig: config.serverTsconfigFilePath,
+				write: false,
+				plugins: [{
+					name: "vorma:server-inputs",
+					generateBundle() {
+						inputFilePaths = [...this.getModuleIds()].filter(isAbsolute);
+					}
+				}],
+				external: (source, _importer, isResolved) => {
+					return !isResolved && (matchesPackageSpecifier({
+						source,
+						packageName: "effect"
+					}) || config.serverExternalPackages.some((packageName) => {
+						return matchesPackageSpecifier({
+							source,
+							packageName
+						});
+					}));
+				},
+				experimental: { attachDebugInfo: "none" },
+				onLog: (level, log) => {
+					const code = log.code === void 0 ? "" : log.code;
+					if (UNRESOLVED_LOG_CODE.test(code)) {
+						unresolvedImports.push(toLogSummary(log));
+						return;
+					}
+					diagnostics.push({
+						level,
+						code,
+						message: toLogSummary(log)
+					});
+				},
+				output: {
+					dir: config.serverGeneratedDirectory,
+					format: "es",
+					entryFileNames: (chunk) => {
+						return chunk.name === "runtime" ? ARTIFACT_PROTOCOL.compiledRuntimeFileName : ARTIFACT_PROTOCOL.compiledServerEntryFileName;
+					},
+					chunkFileNames: "[name]-[hash].mjs",
+					sourcemap: input.sourcemap
+				}
+			});
+		}).pipe(Effect.uninterruptible);
+		if (unresolvedImports.length > 0) return yield* Effect.fail(`The compiled server graph has unresolved imports: ${unresolvedImports.join("; ")}`);
+		const compiled = [];
+		for (const emitted of output.output) {
+			if (emitted.type !== "chunk") return yield* Effect.fail(`The server compilation emitted a file that is not a module: ${emitted.fileName}`);
+			if (!/^[^./][^/]*\.mjs$/.test(emitted.fileName)) return yield* Effect.fail(`The server compilation emitted a file outside its flat module directory: ${emitted.fileName}`);
+			compiled.push({
+				fileName: emitted.fileName,
+				source: emitted.code
+			});
+		}
+		const emittedFileNames = new Set(compiled.map((file) => file.fileName));
+		for (const entryFileName of [ARTIFACT_PROTOCOL.compiledServerEntryFileName, ARTIFACT_PROTOCOL.compiledRuntimeFileName]) if (!emittedFileNames.has(entryFileName)) return yield* Effect.fail(`The server compilation did not emit ${entryFileName}`);
+		return {
+			files: compiled,
+			diagnostics,
+			inputFilePaths
+		};
+	}).pipe(Effect.mapError((cause) => {
+		return {
+			_tag: "ServerCompilationIssue",
+			cause
+		};
+	}));
+}
+//#endregion
+//#region src/build/client-public-urls.ts
+/** The asset key as the public file map spells it: without a leading slash. */
+function normalizePublicAssetKey(key) {
+	return key.startsWith("/") ? key.slice(1) : key;
+}
+function createClientPublicUrlPlugin(input) {
+	let isDevelopment = false;
+	let projection = preparePublicUrlReplacements(input);
+	const referenceIds = /* @__PURE__ */ new Map();
+	const referenceUrls = /* @__PURE__ */ new Map();
+	return {
+		name: "vorma:client-public-urls",
+		api: { updateInputFn(next) {
+			projection = preparePublicUrlReplacements(next);
+		} },
+		enforce: "post",
+		configResolved(config) {
+			isDevelopment = config.command === "serve";
+		},
+		resolveFileUrl({ referenceId, chunkId, fileName }) {
+			const url = referenceUrls.get(referenceId);
+			if (url === void 0) return;
+			let references = input.referencedAssets.get(chunkId);
+			if (references === void 0) {
+				references = /* @__PURE__ */ new Set();
+				input.referencedAssets.set(chunkId, references);
+			}
+			references.add(fileName);
+			return JSON.stringify(url);
+		},
+		async load(id) {
+			const { assets, sitesByFile, sourceTexts, publicDirectory } = projection;
+			const queryIndex = id.indexOf("?");
+			const filePath = queryIndex === -1 ? id : id.slice(0, queryIndex);
+			const sites = sitesByFile.get(filePath);
+			if (sites === void 0) return null;
+			const inspected = sourceTexts.get(filePath);
+			const current = await readFile(filePath, "utf8");
+			if (current !== inspected) return this.error(`${filePath} changed after the build read it; run the build again`);
+			const code = new RolldownMagicString(current);
+			for (const site of sites) {
+				const asset = assets.get(normalizePublicAssetKey(site.key));
+				if (asset === void 0) return this.error(`Unknown public asset: ${site.key}`);
+				if (isDevelopment) {
+					code.overwrite(site.start, site.end, JSON.stringify(asset.url));
+					continue;
+				}
+				let referenceId = referenceIds.get(asset.url);
+				if (referenceId === void 0) {
+					referenceId = this.emitFile({
+						type: "asset",
+						fileName: asset.fileName,
+						source: await readFile(join(publicDirectory, asset.fileName))
+					});
+					referenceIds.set(asset.url, referenceId);
+					referenceUrls.set(referenceId, asset.url);
+				}
+				code.overwrite(site.start, site.end, `import.meta.ROLLUP_FILE_URL_${referenceId}`);
+			}
+			return {
+				code: code.toString(),
+				map: code.generateMap({
+					source: id,
+					includeContent: true,
+					hires: true
+				}).toString()
+			};
+		}
+	};
+}
+function preparePublicUrlReplacements(input) {
+	const assets = new Map(input.publicAssets.map((asset) => [asset.sourceKey, asset]));
+	const sitesByFile = /* @__PURE__ */ new Map();
+	for (const site of input.sites) {
+		const sites = sitesByFile.get(site.filePath);
+		if (sites === void 0) sitesByFile.set(site.filePath, [site]);
+		else sites.push(site);
+	}
+	return {
+		assets,
+		sitesByFile,
+		sourceTexts: input.sourceTexts,
+		publicDirectory: input.publicDirectory
+	};
+}
+//#endregion
+//#region src/build/css-public-assets.ts
+const CSS_URL_PATTERN = /"(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*'|\/\*[\s\S]*?\*\/|\burl\(\s*(?:"((?:\\[\s\S]|[^"\\])*)"|'((?:\\[\s\S]|[^'\\])*)'|((?:\\[\s\S]|[^)\\])*?))\s*\)/gi;
+/** Replaces public URLs before Vite hashes CSS; public files are already published. */
+function createCssPublicAssets(publicAssets) {
+	const cssAssets = /* @__PURE__ */ new Set();
+	const javascriptAssets = /* @__PURE__ */ new Map();
+	const externalUrls = /* @__PURE__ */ new Set();
+	function replaceValue(value) {
+		let error;
+		const replaced = value.replace(CSS_URL_PATTERN, (matched, doubleQuoted, singleQuoted, unquoted) => {
+			const token = doubleQuoted ?? singleQuoted ?? unquoted;
+			if (token === void 0) return matched;
+			const reference = decodeCssEscapes(token);
+			if (!reference.startsWith("@public/")) return matched;
+			const parsed = Result.try({
+				try: () => {
+					const url = new URL(reference.slice(8), "http://vorma.invalid/");
+					return {
+						key: decodeURIComponent(url.pathname.slice(1)),
+						suffix: url.search + url.hash
+					};
+				},
+				catch: () => "Invalid public asset URL: " + reference
+			});
+			if (Result.isFailure(parsed)) {
+				error = parsed.failure;
+				return matched;
+			}
+			const { key, suffix } = parsed.success;
+			const assetUrl = Object.hasOwn(publicAssets.publicFilemap, key) ? publicAssets.publicFilemap[key] : void 0;
+			if (assetUrl === void 0) {
+				error = "Unknown public asset: " + reference;
+				return matched;
+			}
+			const resolved = assetUrl + suffix;
+			externalUrls.add(resolved);
+			externalUrls.add(decodeURI(resolved));
+			externalUrls.add(assetUrl);
+			return "url(\"" + resolved.replace(/["\\\n\r\f]/g, (character) => "\\" + character.charCodeAt(0).toString(16) + " ") + "\")";
+		});
+		return error === void 0 ? Result.succeed(replaced) : Result.fail(error);
+	}
+	const postcssPlugin = {
+		postcssPlugin: "vorma:public-urls",
+		Once(root) {
+			let error;
+			root.walkDecls((declaration) => {
+				const result = replaceValue(declaration.value);
+				if (Result.isFailure(result)) error = result.failure;
+				else declaration.value = result.success;
+			});
+			return error === void 0 ? void 0 : Promise.reject(new Error(error));
+		}
+	};
+	return {
+		cssAssets,
+		javascriptAssets,
+		plugin: {
+			name: "vorma:css-public-assets",
+			enforce: "post",
+			config(config) {
+				const external = config.build?.rolldownOptions?.external;
+				const renderBuiltUrl = config.experimental?.renderBuiltUrl;
+				return {
+					css: { postcss: { plugins: [postcssPlugin] } },
+					build: { rolldownOptions: { external(source, importer, isResolved) {
+						if (externalUrls.has(source)) return true;
+						if (typeof external === "function") return external(source, importer, isResolved);
+						return (Array.isArray(external) ? external : [external]).some((entry) => {
+							return typeof entry === "string" ? entry === source : entry instanceof RegExp ? entry.test(source) : false;
+						});
+					} } },
+					experimental: { renderBuiltUrl(fileName, context) {
+						if (context.hostType === "css" && context.type === "asset") cssAssets.add(stripQueryAndFragment(fileName));
+						const renderedUrl = renderBuiltUrl?.(fileName, context);
+						if (context.hostType === "js") {
+							const references = javascriptAssets.get(context.hostId);
+							const reference = {
+								fileName,
+								renderedUrl
+							};
+							if (references === void 0) javascriptAssets.set(context.hostId, [reference]);
+							else references.push(reference);
+						}
+						return renderedUrl;
+					} }
+				};
+			}
+		},
+		updatePublicAssetsFn(next) {
+			publicAssets = next;
+		}
+	};
+}
+/** Decodes escapes inside an already identified CSS URL token. */
+function decodeCssEscapes(value) {
+	return value.replace(/\\(?:([0-9a-f]{1,6})(?:\r\n|[ \t\n\r\f])?|(\r\n|[\n\r\f])|([\s\S]))/gi, (_match, hex, newline, escaped) => {
+		if (hex !== void 0) {
+			const codePoint = Number.parseInt(hex, 16);
+			return codePoint === 0 || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343 ? "�" : String.fromCodePoint(codePoint);
+		}
+		return newline === void 0 ? escaped ?? "" : "";
+	});
+}
+function stripQueryAndFragment(fileName) {
+	const index = fileName.search(/[?#]/);
+	return index === -1 ? fileName : fileName.slice(0, index);
+}
+//#endregion
+//#region src/build/compare-text.ts
+/** Compares source-derived text by Unicode code units, independent of host locale. */
+function compareSourceText(input) {
+	return input.left < input.right ? -1 : input.left > input.right ? 1 : 0;
+}
+//#endregion
+//#region src/build/render-source-text.ts
+/** A tab-indented prefix, matching how a person writes generated source. */
+function toIndent(depth) {
+	return "	".repeat(depth);
+}
+/** Moves multi-line rendered text deeper by `depth` tabs; the first line keeps its position in the line that embeds it. */
+function indentRenderedText(text, depth) {
+	return text.split("\n").join(`\n${toIndent(depth)}`);
+}
+const IDENTIFIER_PROPERTY_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function renderPropertyName(name) {
+	if (name === "__proto__") return "[\"__proto__\"]";
+	return IDENTIFIER_PROPERTY_NAME.test(name) ? name : JSON.stringify(name);
+}
+/** A relative module specifier, explicitly relative even when the target's own name starts with a dot. */
+function getModuleSpecifier(input) {
+	return toRelativeSpecifier(toPosixRelativePath({
+		path: input.path,
+		from: input.path.dirname(input.fromFilePath),
+		to: input.toFilePath
+	}));
+}
+/** A path is a relative specifier only when it starts with `./` or `../`. */
+function toRelativeSpecifier(relativePath) {
+	return relativePath.startsWith("./") || relativePath.startsWith("../") ? relativePath : `./${relativePath}`;
+}
+//#endregion
+//#region src/build/render-types.ts
+/** Removes the checker's missing-value marker, which is distinct from the ordinary `undefined` type. */
+function withoutAbsence(input) {
+	const members = input.type.isUnionType() ? input.type.getTypes() : [input.type];
+	const present = members.filter((member) => {
+		return !(member.isIntrinsicType() && member.intrinsicName === "undefined" && member.id !== input.undefinedType.id);
+	});
+	return present.length === members.length ? void 0 : present;
+}
+/** The Effect data types the value transport carries, by the module and symbol that declare them. */
+const EFFECT_TYPES = [
+	{
+		module: "Option",
+		symbolName: "Option",
+		kind: "option",
+		printedName: "Option.Option"
+	},
+	{
+		module: "Redacted",
+		symbolName: "Redacted",
+		kind: "redacted",
+		printedName: "Redacted.Redacted"
+	},
+	{
+		module: "Chunk",
+		symbolName: "Chunk",
+		kind: "chunk",
+		printedName: "Chunk.Chunk"
+	},
+	{
+		module: "Duration",
+		symbolName: "Duration",
+		kind: "duration",
+		printedName: "Duration.Duration"
+	},
+	{
+		module: "BigDecimal",
+		symbolName: "BigDecimal",
+		kind: "big-decimal",
+		printedName: "BigDecimal.BigDecimal"
+	},
+	{
+		module: "DateTime",
+		symbolName: "Utc",
+		kind: "date-time-utc",
+		printedName: "DateTime.Utc"
+	},
+	{
+		module: "DateTime",
+		symbolName: "Zoned",
+		kind: "date-time-zoned",
+		printedName: "DateTime.Zoned"
+	},
+	{
+		module: "HashMap",
+		symbolName: "HashMap",
+		kind: "hash-map",
+		printedName: "HashMap.HashMap"
+	},
+	{
+		module: "HashSet",
+		symbolName: "HashSet",
+		kind: "hash-set",
+		printedName: "HashSet.HashSet"
+	}
+];
+/** Platform types the value transport carries by name; their generic arguments are rendered. */
+const PLATFORM_TYPE_NAMES = /* @__PURE__ */ new Set([
+	"Date",
+	"URL",
+	"URLSearchParams",
+	"RegExp",
+	"FormData",
+	"Map",
+	"ReadonlyMap",
+	"Set",
+	"ReadonlySet"
+]);
+/** TypeScript's transient-symbol flag for a readonly property of a mapped or instantiated type. */
+const CHECK_FLAG_READONLY = 8;
+/** Type member order does not depend on source property order. */
+function sortProperties(properties) {
+	return [...properties].sort((left, right) => {
+		return compareSourceText({
+			left: left.name,
+			right: right.name
+		});
+	});
+}
+/** True when a symbol is declared outside the application: in a default library or an installed package. */
+function matchesLibrarySymbol(input) {
+	const declaration = input.symbol.declarations[0];
+	if (declaration === void 0) return false;
+	const declarationPath = String(declaration.path);
+	const metadata = input.program.getSourceFileMetadata(declarationPath);
+	return metadata !== void 0 && (metadata.isDefaultLibrary || metadata.isFromExternalLibrary || declarationPath.includes("/node_modules/"));
+}
+function createTypeRenderer(input) {
+	const { checker, program, emitter } = input;
+	const undefinedType = checker.getUndefinedType();
+	const aliases = /* @__PURE__ */ new Map();
+	const rendered = [];
+	const visiting = /* @__PURE__ */ new Set();
+	const effectModules = /* @__PURE__ */ new Set();
+	const transportTypeNames = /* @__PURE__ */ new Set();
+	function fail(type, reason) {
+		return Result.fail({
+			_tag: "UnrenderableContractType",
+			reason,
+			typeText: checker.typeToString(type)
+		});
+	}
+	function getDeclarationPath(symbol) {
+		const declaration = symbol.declarations[0];
+		return declaration === void 0 ? void 0 : String(declaration.path);
+	}
+	function matchesEffectType(symbol) {
+		const declarationPath = getDeclarationPath(symbol);
+		if (declarationPath === void 0) return;
+		return EFFECT_TYPES.find((entry) => {
+			return entry.symbolName === symbol.name && declarationPath.endsWith(`/effect/dist/${entry.module}.d.ts`);
+		});
+	}
+	function matchesReadonlyProperty(property) {
+		if ((property.checkFlags & CHECK_FLAG_READONLY) !== 0) return true;
+		const declaration = property.valueDeclaration?.resolve();
+		if (declaration === void 0) return false;
+		const modifiers = declaration.modifiers;
+		return modifiers !== void 0 && modifiers.some((modifier) => {
+			return modifier.kind === SyntaxKind.ReadonlyKeyword;
+		});
+	}
+	function renderTypeArguments(type, depth) {
+		const parts = [];
+		for (const argument of checker.getTypeArguments(type)) {
+			const text = renderNode(argument, depth);
+			if (Result.isFailure(text)) return text;
+			parts.push(text.success);
+		}
+		return Result.succeed(parts.length === 0 ? "" : `<${parts.join(", ")}>`);
+	}
+	function renderNamedType(type, depth) {
+		const aliasSymbol = type.getAliasSymbol();
+		const symbol = type.getSymbol();
+		for (const candidate of [aliasSymbol, symbol]) {
+			if (candidate === void 0) continue;
+			const effectType = matchesEffectType(candidate);
+			if (effectType !== void 0) {
+				effectModules.add(effectType.module);
+				transportTypeNames.add(effectType.kind);
+				const argumentTypes = candidate === aliasSymbol ? type.getAliasTypeArguments() : type.isTypeReference() ? checker.getTypeArguments(type) : [];
+				const parts = [];
+				for (const argument of argumentTypes) {
+					const text = renderNode(argument, depth);
+					if (Result.isFailure(text)) return text;
+					parts.push(text.success);
+				}
+				return Result.succeed(parts.length === 0 ? effectType.printedName : `${effectType.printedName}<${parts.join(", ")}>`);
+			}
+		}
+		if (symbol !== void 0 && PLATFORM_TYPE_NAMES.has(symbol.name) && matchesLibrarySymbol({
+			program,
+			symbol
+		})) {
+			const argumentsText = type.isTypeReference() ? renderTypeArguments(type, depth) : Result.succeed("");
+			return Result.map(argumentsText, (text) => `${symbol.name}${text}`);
+		}
+		return Result.succeed(null);
+	}
+	function renderProperty(input) {
+		if (checker.getSignaturesOfType(input.propertyType, SignatureKind.Call).length > 0) return fail(input.propertyType, `the property ${input.property.name} is a function, which cannot cross the wire`);
+		const optional = (input.property.flags & SymbolFlags.Optional) !== 0;
+		const text = optional ? renderOptionalType(input.propertyType, input.depth) : renderNode(input.propertyType, input.depth);
+		if (Result.isFailure(text)) return text;
+		const readonly = matchesReadonlyProperty(input.property) ? "readonly " : "";
+		return Result.succeed(`${toIndent(input.depth)}${readonly}${renderPropertyName(input.property.name)}${optional ? "?" : ""}: ${text.success};`);
+	}
+	/** A class instance crosses the wire as the record of its schema fields; the fields come from the class's static `fields`. */
+	function renderClassInstance(type, classSymbol, depth) {
+		const constructorType = checker.getTypeOfSymbol(classSymbol);
+		const fields = constructorType === void 0 ? void 0 : checker.getPropertyOfType(constructorType, "fields");
+		const fieldsType = fields === void 0 ? void 0 : checker.getTypeOfSymbol(fields);
+		if (fieldsType === void 0) return fail(type, `the class ${classSymbol.name} is not an Effect Schema class, so its wire form is unknown`);
+		const lines = [];
+		for (const field of sortProperties(checker.getPropertiesOfType(fieldsType))) {
+			const property = checker.getPropertyOfType(type, field.name);
+			const propertyType = property === void 0 ? void 0 : checker.getTypeOfSymbol(property);
+			if (property === void 0 || propertyType === void 0) return fail(type, `the class ${classSymbol.name} declares the field ${field.name} without a property of that name`);
+			const line = renderProperty({
+				property,
+				propertyType,
+				depth: depth + 1
+			});
+			if (Result.isFailure(line)) return line;
+			lines.push(line.success);
+		}
+		return Result.succeed(lines.length === 0 ? "{}" : [
+			"{",
+			...lines,
+			`${toIndent(depth)}}`
+		].join("\n"));
+	}
+	function renderObject(type, depth) {
+		const symbol = type.getSymbol();
+		if (symbol !== void 0 && (symbol.flags & SymbolFlags.Class) !== 0) return renderClassInstance(type, symbol, depth);
+		if (checker.getSignaturesOfType(type, SignatureKind.Call).length > 0 || checker.getSignaturesOfType(type, SignatureKind.Construct).length > 0) return fail(type, "a function cannot cross the wire");
+		const lines = [];
+		for (const property of sortProperties(checker.getPropertiesOfType(type))) {
+			if (String(property.escapedName).startsWith("__@")) continue;
+			const propertyType = checker.getTypeOfSymbol(property);
+			if (propertyType === void 0) return fail(type, `the property ${property.name} has no type`);
+			const line = renderProperty({
+				property,
+				propertyType,
+				depth: depth + 1
+			});
+			if (Result.isFailure(line)) return line;
+			lines.push(line.success);
+		}
+		for (const signature of checker.getIndexInfosOfType(type)) {
+			const keyText = renderNode(signature.keyType, depth + 1);
+			if (Result.isFailure(keyText)) return keyText;
+			const valueText = renderNode(signature.valueType, depth + 1);
+			if (Result.isFailure(valueText)) return valueText;
+			lines.push(`${toIndent(depth + 1)}${signature.isReadonly ? "readonly " : ""}[key: ${keyText.success}]: ${valueText.success};`);
+		}
+		return Result.succeed(lines.length === 0 ? "{}" : [
+			"{",
+			...lines,
+			`${toIndent(depth)}}`
+		].join("\n"));
+	}
+	function renderOptionalType(type, depth) {
+		const present = withoutAbsence({
+			type,
+			undefinedType
+		});
+		return present === void 0 ? renderNode(type, depth) : present.length === 1 && present[0] !== void 0 ? renderNode(present[0], depth) : renderUnion(present, depth, " | ");
+	}
+	function renderTuple(type, depth) {
+		const target = type.getTarget();
+		const members = [];
+		for (const [index, element] of checker.getTypeArguments(type).entries()) {
+			const flags = target.elementFlags[index] ?? ElementFlags.Required;
+			const text = (flags & ElementFlags.Optional) !== 0 ? renderOptionalType(element, depth) : renderNode(element, depth);
+			if (Result.isFailure(text)) return text;
+			if ((flags & ElementFlags.Rest) !== 0) members.push(`...Array<${text.success}>`);
+			else if ((flags & ElementFlags.Variadic) !== 0) members.push(`...(${text.success})`);
+			else if ((flags & ElementFlags.Optional) !== 0) members.push(`(${text.success})?`);
+			else members.push(text.success);
+		}
+		return Result.succeed(`${target.readonly ? "readonly " : ""}[${members.join(", ")}]`);
+	}
+	function renderUnion(members, depth, separator) {
+		const parts = [];
+		let sawTrue = false;
+		let sawFalse = false;
+		for (const member of members) {
+			if (member.isBooleanLiteralType()) {
+				if (member.value) sawTrue = true;
+				else sawFalse = true;
+				continue;
+			}
+			const text = renderNode(member, depth);
+			if (Result.isFailure(text)) return text;
+			parts.push(separator === " & " && member.isUnionType() ? `(${text.success})` : text.success);
+		}
+		if (sawTrue && sawFalse) parts.push("boolean");
+		else if (sawTrue) parts.push("true");
+		else if (sawFalse) parts.push("false");
+		parts.sort((left, right) => {
+			return compareSourceText({
+				left,
+				right
+			});
+		});
+		return Result.succeed(parts.length === 0 ? "never" : parts.join(separator));
+	}
+	/** Keeps literal contents independent of indentation in the containing declaration. */
+	function renderTemplateToken(node) {
+		return emitter.printNode(node).replaceAll("\r", "\\r").replaceAll("\n", "\\n");
+	}
+	function renderTemplateLiteral(type, depth) {
+		if (!type.isTemplateLiteralType()) return fail(type, "not a template literal type");
+		const spans = [];
+		for (const span of type.getTypes()) {
+			const text = renderNode(span, depth);
+			if (Result.isFailure(text)) return text;
+			spans.push(text.success);
+		}
+		const [head, ...tail] = type.texts;
+		let text = renderTemplateToken(createTemplateHead(head ?? "", "", TokenFlags.None));
+		for (const [index, span] of spans.entries()) {
+			const createLiteral = index === spans.length - 1 ? createTemplateTail : createTemplateMiddle;
+			text += span + renderTemplateToken(createLiteral(tail[index] ?? "", "", TokenFlags.None));
+		}
+		return Result.succeed(text);
+	}
+	function renderNode(type, depth) {
+		const existingAlias = aliases.get(type.id);
+		if (existingAlias !== void 0) return Result.succeed(existingAlias);
+		if (visiting.has(type.id)) {
+			const name = `Recursive${aliases.size}`;
+			aliases.set(type.id, name);
+			return Result.succeed(name);
+		}
+		visiting.add(type.id);
+		const text = renderTypeStructure(type, depth);
+		visiting.delete(type.id);
+		if (Result.isFailure(text)) return text;
+		const createdAlias = aliases.get(type.id);
+		if (createdAlias === void 0) return text;
+		const declared = depth === 0 ? text : renderTypeStructure(type, 0);
+		if (Result.isFailure(declared)) return declared;
+		rendered.push(`type ${createdAlias} = ${declared.success};`);
+		return Result.succeed(createdAlias);
+	}
+	function renderTypeStructure(type, depth) {
+		if (type.isErrorType()) return fail(type, "the type could not be resolved");
+		if (type.isStringLiteralType()) return Result.succeed(JSON.stringify(type.value));
+		if (type.isNumberLiteralType()) return Result.succeed(String(type.value));
+		if (type.isBigIntLiteralType()) return Result.succeed(`${type.value}n`);
+		if (type.isBooleanLiteralType()) return Result.succeed(type.value ? "true" : "false");
+		if (type.isIntrinsicType()) return Result.succeed(type.intrinsicName);
+		const named = renderNamedType(type, depth);
+		if (Result.isFailure(named)) return Result.fail(named.failure);
+		if (named.success !== null) return Result.succeed(named.success);
+		if (type.isTemplateLiteralType()) return renderTemplateLiteral(type, depth);
+		if (type.isUnionType()) return renderUnion(type.getTypes(), depth, " | ");
+		if (type.isIntersectionType()) return renderUnion(type.getTypes(), depth, " & ");
+		if (type.isTypeParameter()) return fail(type, "a contract type cannot be generic");
+		if (!type.isObjectType()) return fail(type, "the type has no wire form");
+		if (checker.isArrayType(type) && type.isTypeReference()) {
+			const [element] = checker.getTypeArguments(type);
+			if (element === void 0) return fail(type, "an array type without an element type");
+			const text = renderNode(element, depth);
+			if (Result.isFailure(text)) return text;
+			const wrapper = type.getSymbol()?.name === "ReadonlyArray" ? "ReadonlyArray" : "Array";
+			return Result.succeed(`${wrapper}<${text.success}>`);
+		}
+		if (checker.isTupleType(type) && type.isTypeReference()) return renderTuple(type, depth);
+		return renderObject(type, depth);
+	}
+	return {
+		renderType: (input) => renderNode(input.type, input.depth),
+		renderAliases: () => rendered,
+		getEffectModules: () => [...effectModules].sort(),
+		getTransportTypeNames: () => transportTypeNames
+	};
+}
+//#endregion
+//#region src/server/url-pathname.ts
+const URL_PATHNAME_PARSER_ORIGIN = "https://vorma.invalid";
+function parseHref(input) {
+	return new URL(input.value, input.base);
+}
+/** Parses the exact pathname representation used for request classification. */
+function parseUrlPathname(value) {
+	const parsed = Result.try({
+		try: () => parseHref({
+			value,
+			base: URL_PATHNAME_PARSER_ORIGIN
+		}),
+		catch: (cause) => makeUrlPathnameParseError({
+			value,
+			cause
+		})
+	});
+	if (Result.isFailure(parsed)) return Result.fail(parsed.failure);
+	if (!value.startsWith("/") || parsed.success.origin !== URL_PATHNAME_PARSER_ORIGIN || parsed.success.pathname !== value || parsed.success.search !== "" || parsed.success.hash !== "") return Result.fail(makeUrlPathnameParseError({ value }));
+	return Result.succeed(value);
+}
+function makeUrlPathnameParseError(input) {
+	return {
+		_tag: "UrlPathnameParseError",
+		value: input.value,
+		...input.cause === void 0 ? {} : { cause: input.cause }
+	};
+}
+//#endregion
+//#region src/build/resolve-config.ts
+/** The build reads no Vorma directory, in either entry directory, as application source. */
+function getGeneratedSourceDirectories(config) {
+	return [config.serverGeneratedDirectory, config.clientGeneratedDirectory];
+}
+/** Derives generated source, public assets, and build coordination from the entry directories. */
+function getVormaOwnedPaths(input) {
+	const { path } = input;
+	const name = ARTIFACT_PROTOCOL.vormaDirectoryName;
+	const clientGeneratedDirectory = path.join(input.clientEntryDirectory, name);
+	const serverGeneratedDirectory = path.join(input.serverEntryDirectory, name);
+	return {
+		publicDirectory: path.join(clientGeneratedDirectory, ARTIFACT_PROTOCOL.publicDirectoryName),
+		ignoreFilePaths: [.../* @__PURE__ */ new Set([serverGeneratedDirectory, clientGeneratedDirectory])].map((directory) => path.join(directory, ARTIFACT_PROTOCOL.ignoreFileName)),
+		serverGeneratedDirectory,
+		clientGeneratedDirectory,
+		generatedBuildFilePath: path.join(serverGeneratedDirectory, ARTIFACT_PROTOCOL.generatedBuildFileName),
+		generatedServerContractsFilePath: path.join(serverGeneratedDirectory, ARTIFACT_PROTOCOL.generatedServerContractsFileName),
+		compiledServerEntryFilePath: path.join(serverGeneratedDirectory, ARTIFACT_PROTOCOL.compiledServerEntryFileName)
+	};
+}
+/** Resolves every configured path once against the configuration file's directory. */
+function resolveVormaConfig(input) {
+	return Effect.gen(function* () {
+		const config = yield* Schema.decodeUnknownEffect(VormaConfigSchema)(input.config).pipe(Effect.mapError((cause) => {
+			return {
+				_tag: "ConfigResolutionError",
+				field: "config",
+				message: `Invalid Vorma configuration: ${cause.message}`,
+				cause
+			};
+		}));
+		if (config.bodySsr === true) return yield* Effect.fail({
+			_tag: "ConfigResolutionError",
+			field: "bodySsr",
+			message: "bodySsr: true requires server body rendering and hydration, which this runtime does not provide; omit bodySsr or set it to false"
+		});
+		const path = yield* Path$1.Path;
+		if (!path.isAbsolute(input.configFilePath)) return yield* Effect.fail({
+			_tag: "ConfigResolutionError",
+			field: "configFilePath",
+			message: `configFilePath must be absolute, got ${JSON.stringify(input.configFilePath)}`
+		});
+		const configDirectory = path.dirname(path.normalize(input.configFilePath));
+		const serverEntryFilePath = path.resolve(configDirectory, config.serverEntry);
+		const serverTsconfigFilePath = path.resolve(configDirectory, config.serverTsconfigFile);
+		const clientEntryFilePath = path.resolve(configDirectory, config.clientEntry);
+		const clientTsconfigFilePath = path.resolve(configDirectory, config.clientTsconfigFile);
+		return {
+			configFilePath: path.normalize(input.configFilePath),
+			configDirectory,
+			serverEntryFilePath,
+			serverTsconfigFilePath,
+			serverProjectDirectory: path.dirname(serverTsconfigFilePath),
+			clientEntryFilePath,
+			clientTsconfigFilePath,
+			publicAssetsSourceDirectory: path.resolve(configDirectory, config.publicAssetsDir),
+			viteConfigFilePath: path.resolve(configDirectory, config.viteConfigFile),
+			...config.criticalCssEntry === void 0 ? {} : { criticalCssEntryFilePath: path.resolve(configDirectory, config.criticalCssEntry) },
+			serverExternalPackages: config.serverExternalPackages === void 0 ? [] : config.serverExternalPackages,
+			publicAssetsBasePath: yield* Effect.fromResult(parsePublicAssetsBasePath(config.publicAssetsBasePath)),
+			bodySsr: config.bodySsr,
+			dev: config.dev,
+			...getVormaOwnedPaths({
+				path,
+				serverEntryDirectory: path.dirname(serverEntryFilePath),
+				clientEntryDirectory: path.dirname(clientEntryFilePath)
+			})
+		};
+	});
+}
+function parsePublicAssetsBasePath(value) {
+	const parsed = parseUrlPathname(value);
+	if (Result.isFailure(parsed)) return Result.fail(makePublicAssetsBasePathError(parsed.failure));
+	if (!matchesPublicAssetsBasePath(parsed.success)) return Result.fail(makePublicAssetsBasePathError());
+	return Result.succeed(parsed.success);
+}
+/** The root, or an absolute path with a trailing slash. */
+function matchesPublicAssetsBasePath(value) {
+	return value === "/" || value.startsWith("/") && value.endsWith("/");
+}
+function makePublicAssetsBasePathError(cause) {
+	return {
+		_tag: "ConfigResolutionError",
+		field: "publicAssetsBasePath",
+		message: "publicAssetsBasePath must be a normalized absolute URL path ending in \"/\" without an authority, query, or fragment",
+		...cause === void 0 ? {} : { cause }
+	};
+}
+//#endregion
+//#region src/build/inspect-projects.ts
+/** Reads every registerable declaration, view, the client application, and every public URL call from the two projects. */
+function inspectProjects(input) {
+	return Effect.gen(function* () {
+		const path = yield* Path$1.Path;
+		const excludedDirectories = getGeneratedSourceDirectories(input.layout);
+		const serverFiles = listOwnSourceFiles({
+			project: input.projects.server,
+			excludedDirectories,
+			path
+		});
+		const clientFiles = listOwnSourceFiles({
+			project: input.projects.client,
+			excludedDirectories,
+			path
+		});
+		const serverRenderer = createTypeRenderer({
+			checker: input.projects.server.checker,
+			program: input.projects.server.program,
+			emitter: input.projects.server.emitter
+		});
+		const serverDeclarations = yield* Effect.fromResult(inspectServerDeclarations({
+			checker: input.projects.server.checker,
+			program: input.projects.server.program,
+			files: serverFiles,
+			renderer: serverRenderer
+		}));
+		const client = yield* Effect.fromResult(inspectClientProject({
+			checker: input.projects.client.checker,
+			files: clientFiles,
+			clientEntryFilePath: input.layout.clientEntryFilePath
+		}));
+		return {
+			serverDeclarations,
+			clientViews: client.views,
+			clientApplication: client.application,
+			publicUrlSites: client.publicUrlSites,
+			clientSourceTexts: client.sourceTexts,
+			typeAliases: serverRenderer.renderAliases(),
+			effectModules: serverRenderer.getEffectModules(),
+			transportTypeNames: serverRenderer.getTransportTypeNames()
+		};
+	});
+}
+/** The project's own modules: not a library, not a declaration file, and not under a Vorma output directory. */
+function listOwnSourceFiles(input) {
+	const { program } = input.project;
+	const files = [];
+	for (const fileName of program.getSourceFileNames()) {
+		if (fileName.includes("/node_modules/") || input.excludedDirectories.some((directory) => {
+			const relativePath = input.path.relative(directory, fileName);
+			return containsRelativePath({
+				relativePath,
+				separator: input.path.sep,
+				absolute: input.path.isAbsolute(relativePath)
+			});
+		})) continue;
+		const metadata = program.getSourceFileMetadata(fileName);
+		if (metadata?.isDefaultLibrary || metadata?.isFromExternalLibrary) continue;
+		const sourceFile = program.getSourceFile(fileName);
+		if (sourceFile === void 0 || sourceFile.isDeclarationFile) continue;
+		files.push(sourceFile);
+	}
+	return files.sort((left, right) => {
+		return compareSourceText({
+			left: left.fileName,
+			right: right.fileName
+		});
+	});
+}
+/** Export bindings retain their public names while aliases resolve to one declaration identity. */
+function listModuleExports(input) {
+	const { checker, sourceFile } = input;
+	const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+	if (moduleSymbol === void 0) return [];
+	const exports = [];
+	for (const exported of checker.getExportsOfModule(moduleSymbol)) {
+		const symbol = (exported.flags & SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(exported) : exported;
+		if (checker.isUnknownSymbol(symbol)) continue;
+		const type = checker.getTypeOfSymbol(symbol);
+		if (type === void 0) continue;
+		exports.push({
+			exportName: exported.name,
+			symbol,
+			type
+		});
+	}
+	return exports;
+}
+/** Prefer a declaration's own exported module so a re-export barrel does not enlarge a view's import closure. */
+function listRegistrationExports(input) {
+	const exports = /* @__PURE__ */ new Map();
+	for (const sourceFile of input.files) for (const moduleExport of listModuleExports({
+		checker: input.checker,
+		sourceFile
+	})) {
+		const own = moduleExport.symbol.declarations.some((declaration) => {
+			return String(declaration.path) === String(sourceFile.path);
+		});
+		if (!exports.has(moduleExport.symbol.id) || own) exports.set(moduleExport.symbol.id, {
+			sourceFile,
+			moduleExport
+		});
+	}
+	return [...exports.values()];
+}
+/** The phantom property that carries a definition's static types, by the unique symbol that keys it. */
+function findPhantomProperty(input) {
+	const prefix = `__@${input.symbolName}@`;
+	return input.checker.getPropertiesOfType(input.type).find((property) => String(property.escapedName).startsWith(prefix));
+}
+function readPropertyType(input) {
+	const property = input.checker.getPropertyOfType(input.type, input.name);
+	return property === void 0 ? void 0 : input.checker.getTypeOfSymbol(property);
+}
+function readLiteralProperty(input) {
+	const propertyType = readPropertyType(input);
+	if (propertyType === void 0) return Result.fail(`the declaration has no ${input.name} property`);
+	if (!propertyType.isStringLiteralType()) return Result.fail(`${input.name} must have a literal type; its type is ${input.checker.typeToString(propertyType)}`);
+	return Result.succeed(propertyType.value);
+}
+function matchesUndefinedType(type) {
+	return type.isIntrinsicType() && type.intrinsicName === "undefined";
+}
+function inspectServerDeclarations(input) {
+	const { checker, program, renderer } = input;
+	const declarations = [];
+	const candidates = [];
+	for (const { sourceFile, moduleExport } of listRegistrationExports(input)) {
+		const source = {
+			filePath: sourceFile.fileName,
+			exportName: moduleExport.exportName
+		};
+		const phantom = findPhantomProperty({
+			checker,
+			type: moduleExport.type,
+			symbolName: "DEFINITION_TYPES"
+		});
+		if (phantom === void 0) continue;
+		const tag = readPropertyType({
+			checker,
+			type: moduleExport.type,
+			name: "_tag"
+		});
+		if (tag === void 0 || !tag.isStringLiteralType()) continue;
+		if (tag.value !== "UiLoader" && tag.value !== "Endpoint") continue;
+		const phantomType = checker.getTypeOfSymbol(phantom);
+		const types = phantomType === void 0 ? void 0 : checker.getNonNullableType(phantomType);
+		if (types === void 0) return Result.fail(makeIssue(source, "the definition carries no static types"));
+		const pattern = readLiteralProperty({
+			checker,
+			type: moduleExport.type,
+			name: "pattern"
+		});
+		if (Result.isFailure(pattern)) return Result.fail(makeIssue(source, pattern.failure));
+		const method = readPropertyType({
+			checker,
+			type: moduleExport.type,
+			name: "method"
+		});
+		candidates.push({
+			source,
+			kind: tag.value,
+			type: moduleExport.type,
+			types,
+			key: JSON.stringify([
+				tag.value,
+				pattern.success,
+				method?.isStringLiteralType() === true ? method.value : ""
+			])
+		});
+	}
+	candidates.sort((left, right) => {
+		return compareSourceText({
+			left: left.key,
+			right: right.key
+		});
+	});
+	for (const { source, kind, type, types } of candidates) {
+		const inspected = kind === "UiLoader" ? inspectUiLoader({
+			checker,
+			renderer,
+			source,
+			type,
+			types
+		}) : inspectEndpoint({
+			checker,
+			program,
+			renderer,
+			source,
+			type,
+			types
+		});
+		if (Result.isFailure(inspected)) return Result.fail(inspected.failure);
+		declarations.push(inspected.success);
+	}
+	return Result.succeed(declarations);
+}
+/** An issue at a declaration; the message names the file and export so a report is complete on its own. */
+function makeIssue(source, message) {
+	return {
+		_tag: "InspectionIssue",
+		...source,
+		message: `${source.filePath} (export ${source.exportName}): ${message}`
+	};
+}
+function renderContract(input) {
+	return Result.mapError(input.renderer.renderType({
+		type: input.type,
+		depth: 2
+	}), (issue) => {
+		return makeIssue(input.source, `the ${input.field} contract cannot cross the wire: ${issue.reason} (${issue.typeText})`);
+	});
+}
+/** A contract's text, or `undefined` for the absent contract that the type `undefined` denotes. */
+function renderOptionalContract(input) {
+	const type = readPropertyType({
+		checker: input.checker,
+		type: input.types,
+		name: input.field
+	});
+	if (type === void 0 || matchesUndefinedType(type)) return Result.succeed(void 0);
+	return renderContract({
+		...input,
+		type
+	});
+}
+function inspectUiLoader(input) {
+	const { checker, renderer, source } = input;
+	const pattern = readLiteralProperty({
+		checker,
+		type: input.type,
+		name: "pattern"
+	});
+	if (Result.isFailure(pattern)) return Result.fail(makeIssue(source, pattern.failure));
+	const loaderInput = renderOptionalContract({
+		checker,
+		renderer,
+		source,
+		field: "input",
+		types: input.types
+	});
+	if (Result.isFailure(loaderInput)) return Result.fail(loaderInput.failure);
+	const outputType = readPropertyType({
+		checker,
+		type: input.types,
+		name: "output"
+	});
+	if (outputType === void 0) return Result.fail(makeIssue(source, "a UI loader must have an output contract"));
+	const output = renderContract({
+		renderer,
+		source,
+		field: "output",
+		type: outputType
+	});
+	if (Result.isFailure(output)) return Result.fail(output.failure);
+	return Result.succeed({
+		...source,
+		kind: "UiLoader",
+		pattern: pattern.success,
+		input: loaderInput.success,
+		output: output.success
+	});
+}
+function inspectEndpoint(input) {
+	const { checker, program, renderer, source } = input;
+	const literals = {
+		kind: "",
+		method: "",
+		pattern: ""
+	};
+	for (const name of [
+		"kind",
+		"method",
+		"pattern"
+	]) {
+		const literal = readLiteralProperty({
+			checker,
+			type: input.type,
+			name
+		});
+		if (Result.isFailure(literal)) return Result.fail(makeIssue(source, literal.failure));
+		literals[name] = literal.success;
+	}
+	const operation = literals.kind;
+	if (operation === "stream") return Result.fail(makeIssue(source, "StreamEndpoint is an unimplemented declaration scaffold and cannot be built. Mount native Effect streaming handlers on the application's server."));
+	if (operation !== "query" && operation !== "mutation") return Result.fail(makeIssue(source, `unknown endpoint kind ${operation}`));
+	const method = literals.method;
+	if (!matchesHttpMethod(method)) return Result.fail(makeIssue(source, `unknown endpoint method ${method}`));
+	const inputType = readPropertyType({
+		checker,
+		type: input.types,
+		name: "input"
+	});
+	const hasInput = inputType !== void 0 && !matchesUndefinedType(inputType);
+	const inputTransport = !hasInput ? "none" : method === "GET" ? "search" : matchesFormInput({
+		checker,
+		program,
+		types: input.types
+	}) ? "formData" : "json";
+	const endpointInput = inputType === void 0 || !hasInput || inputTransport === "formData" ? Result.succeed(void 0) : renderContract({
+		renderer,
+		source,
+		field: "input",
+		type: inputType
+	});
+	if (Result.isFailure(endpointInput)) return Result.fail(endpointInput.failure);
+	const output = renderOptionalContract({
+		checker,
+		renderer,
+		source,
+		field: "output",
+		types: input.types
+	});
+	if (Result.isFailure(output)) return Result.fail(output.failure);
+	const event = renderOptionalContract({
+		checker,
+		renderer,
+		source,
+		field: "event",
+		types: input.types
+	});
+	if (Result.isFailure(event)) return Result.fail(event.failure);
+	const errors = inspectEndpointErrors({
+		checker,
+		renderer,
+		source,
+		types: input.types
+	});
+	if (Result.isFailure(errors)) return Result.fail(errors.failure);
+	return Result.succeed({
+		...source,
+		kind: "Endpoint",
+		operation,
+		method,
+		pattern: literals.pattern,
+		input: endpointInput.success,
+		inputTransport,
+		output: output.success,
+		event: event.success,
+		errors: errors.success
+	});
+}
+/**
+* Whether an endpoint's input arrives as a form: its schema encodes to the
+* form-transport marker carried by Vorma's FormData schema and its derived
+* codecs. The runtime recognizes the same factory's schema annotation.
+*/
+function matchesFormInput(input) {
+	const symbol = readPropertyType({
+		checker: input.checker,
+		type: input.types,
+		name: "inputEncoded"
+	})?.getSymbol();
+	return symbol !== void 0 && symbol.name === "FormDataEncoded" && symbol.declarations.some((declaration) => {
+		return /\/vorma\/(?:src|dist)\/server\/form-data\.(?:d\.)?ts$/.test(String(declaration.path));
+	}) && matchesLibrarySymbol({
+		program: input.program,
+		symbol
+	});
+}
+/** Each declared error: its decoded `_tag` and transportable schema fields. */
+function inspectEndpointErrors(input) {
+	const { checker, renderer, source } = input;
+	const errorsType = readPropertyType({
+		checker,
+		type: input.types,
+		name: "errors"
+	});
+	if (errorsType === void 0) return Result.succeed([]);
+	const elementType = checker.getIndexInfosOfType(errorsType).find((index) => {
+		return index.keyType.id === checker.getNumberType().id;
+	})?.valueType;
+	if (elementType === void 0) return Result.fail(makeIssue(source, "declared errors must have an array element type"));
+	const errors = [];
+	const variantsByTag = [];
+	const elements = elementType.isUnionType() ? elementType.getTypes() : [elementType];
+	for (const element of elements) {
+		if (element.isIntrinsicType() && element.intrinsicName === "never") continue;
+		const schemaType = readPropertyType({
+			checker,
+			type: element,
+			name: "schema"
+		});
+		const decodedType = schemaType === void 0 ? void 0 : readPropertyType({
+			checker,
+			type: schemaType,
+			name: "Type"
+		});
+		if (decodedType === void 0) return Result.fail(makeIssue(source, "each declared error's schema must expose its decoded Type"));
+		const variants = decodedType.isUnionType() ? decodedType.getTypes() : [decodedType];
+		for (const variant of variants) {
+			const tag = readLiteralProperty({
+				checker,
+				type: variant,
+				name: "_tag"
+			});
+			if (Result.isFailure(tag)) return Result.fail(makeIssue(source, `a declared error needs a literal _tag: ${tag.failure}`));
+			variantsByTag.push({
+				tag: tag.success,
+				type: variant
+			});
+		}
+	}
+	variantsByTag.sort((left, right) => {
+		return compareSourceText({
+			left: left.tag,
+			right: right.tag
+		});
+	});
+	for (const variant of variantsByTag) {
+		const fields = renderContract({
+			renderer,
+			source,
+			field: `error ${variant.tag}`,
+			type: variant.type
+		});
+		if (Result.isFailure(fields)) return Result.fail(fields.failure);
+		errors.push({
+			tag: variant.tag,
+			fields: fields.success
+		});
+	}
+	return Result.succeed(errors);
+}
+function inspectClientProject(input) {
+	const { checker } = input;
+	const views = [];
+	const applications = /* @__PURE__ */ new Map();
+	const publicUrlSites = [];
+	const sourceTexts = /* @__PURE__ */ new Map();
+	for (const { sourceFile, moduleExport } of listRegistrationExports(input)) {
+		const source = {
+			filePath: sourceFile.fileName,
+			exportName: moduleExport.exportName
+		};
+		if (findPhantomProperty({
+			checker,
+			type: moduleExport.type,
+			symbolName: "UI_VIEW_TYPES"
+		}) !== void 0) {
+			const pattern = readLiteralProperty({
+				checker,
+				type: moduleExport.type,
+				name: "pattern"
+			});
+			if (Result.isFailure(pattern)) return Result.fail(makeIssue(source, pattern.failure));
+			views.push({
+				...source,
+				pattern: pattern.success
+			});
+		}
+	}
+	for (const sourceFile of input.files) {
+		if (sourceFile.fileName === input.clientEntryFilePath) {
+			for (const moduleExport of listModuleExports({
+				checker,
+				sourceFile
+			})) if (findPhantomProperty({
+				checker,
+				type: moduleExport.type,
+				symbolName: "CLIENT_APPLICATION_TYPES"
+			}) !== void 0) applications.set(moduleExport.symbol.id, {
+				filePath: sourceFile.fileName,
+				exportName: moduleExport.exportName
+			});
+		}
+		const sites = collectPublicUrlSites({
+			checker,
+			sourceFile
+		});
+		if (Result.isFailure(sites)) return Result.fail(sites.failure);
+		if (sites.success.length > 0) {
+			publicUrlSites.push(...sites.success);
+			sourceTexts.set(sourceFile.fileName, sourceFile.text);
+		}
+	}
+	const [application, ...moreApplications] = applications.values();
+	if (application === void 0 || moreApplications.length > 0) return Result.fail({
+		_tag: "InspectionIssue",
+		filePath: input.clientEntryFilePath,
+		message: `${input.clientEntryFilePath}: the client entry must export exactly one ClientApplication.make value, which the generated client declaration reads for the application's service types`
+	});
+	return Result.succeed({
+		views,
+		application,
+		publicUrlSites,
+		sourceTexts
+	});
+}
+/** Whether a symbol is the `getPublicUrl` declared by `vorma/client`, however the module reached it. */
+function matchesPublicUrlSymbol(input) {
+	const symbol = (input.symbol.flags & SymbolFlags.Alias) !== 0 ? input.checker.getAliasedSymbol(input.symbol) : input.symbol;
+	if (symbol.name !== "getPublicUrl") return false;
+	const declaration = symbol.declarations[0];
+	return declaration !== void 0 && String(declaration.path).endsWith("/vorma/dist/client/index.d.ts");
+}
+/** Every call of `getPublicUrl` in one file. A use that is not a direct call with a string literal cannot be replaced by the build. */
+function collectPublicUrlSites(input) {
+	const { checker, sourceFile } = input;
+	const sites = [];
+	let issue;
+	function report(node, message) {
+		if (issue === void 0) {
+			const position = node.getStart(sourceFile);
+			const { line, character } = sourceFile.getLineAndCharacterOfPosition(position);
+			issue = {
+				_tag: "InspectionIssue",
+				filePath: sourceFile.fileName,
+				position,
+				message: `${sourceFile.fileName}:${line + 1}:${character + 1}: ${message}`
+			};
+		}
+	}
+	function visit(node) {
+		if (issue !== void 0 || isTypeNode(node)) return;
+		if (isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node)) {
+			const parent = node.parent;
+			if (isImportSpecifier(parent) || isImportClause(parent) || isNamespaceImport(parent) || isExportSpecifier(parent)) return;
+			const symbol = isElementAccessExpression(node) ? getElementAccessSymbol({
+				checker,
+				node
+			}) : checker.getSymbolAtLocation(node);
+			if (symbol !== void 0 && matchesPublicUrlSymbol({
+				checker,
+				symbol
+			})) {
+				let callee = node;
+				while (matchesTransparentExpression(callee.parent) && callee.parent.expression === callee) callee = callee.parent;
+				const call = callee.parent;
+				if (!isCallExpression(call) || call.expression !== callee) {
+					report(node, "getPublicUrl must be called directly with a string literal so the build can replace the call");
+					return;
+				}
+				const [authoredArgument, ...moreArguments] = call.arguments;
+				const argument = authoredArgument === void 0 ? void 0 : unwrapExpression(authoredArgument);
+				if (argument === void 0 || moreArguments.length > 0 || !(isStringLiteral(argument) || isNoSubstitutionTemplateLiteral(argument))) {
+					report(call, "getPublicUrl requires exactly one string literal argument, so the build can replace the call with the hashed URL");
+					return;
+				}
+				sites.push({
+					filePath: sourceFile.fileName,
+					start: call.getStart(sourceFile),
+					end: call.getEnd(),
+					key: argument.text
+				});
+				return;
+			}
+		}
+		node.forEachChild(visit);
+	}
+	visit(sourceFile);
+	return issue === void 0 ? Result.succeed(sites) : Result.fail(issue);
+}
+/** Parentheses and erased TypeScript wrappers preserve the underlying expression. */
+function matchesTransparentExpression(node) {
+	return isParenthesizedExpression(node) || isAsExpression(node) || isTypeAssertion(node) || isSatisfiesExpression(node) || isNonNullExpression(node);
+}
+function unwrapExpression(node) {
+	while (matchesTransparentExpression(node)) node = node.expression;
+	return node;
+}
+function getElementAccessSymbol(input) {
+	const objectType = input.checker.getTypeAtLocation(input.node.expression);
+	const keyType = input.checker.getTypeAtLocation(input.node.argumentExpression);
+	return objectType !== void 0 && keyType?.isStringLiteralType() ? input.checker.getPropertyOfType(objectType, keyType.value) : void 0;
+}
+//#endregion
+//#region src/build/typescript-projects.ts
+/** Reads native project membership without loading programs or declaration types. */
+function readTypescriptProjectRoots(input) {
+	return withTypescriptApi({
+		configDirectory: input.configDirectory,
+		useFn: (api) => {
+			return openCompilerResource(() => {
+				return {
+					server: api.parseConfigFile(input.serverTsconfigFilePath).fileNames,
+					client: api.parseConfigFile(input.clientTsconfigFilePath).fileNames
+				};
+			});
+		}
+	});
+}
+/** Checks actual compiler membership after generation, including restrictive files/include/exclude settings. */
+function checkGeneratedTypeInclusion(input) {
+	return withTypescriptProjects({
+		...input,
+		useFn: (projects) => {
+			const missing = [...input.serverFiles.filter((file) => {
+				return projects.server.program.getSourceFileMetadata(file) === void 0;
+			}).map((file) => {
+				return {
+					project: input.serverTsconfigFilePath,
+					file
+				};
+			}), ...input.clientFiles.filter((file) => {
+				return projects.client.program.getSourceFileMetadata(file) === void 0;
+			}).map((file) => {
+				return {
+					project: input.clientTsconfigFilePath,
+					file
+				};
+			})];
+			return missing.length === 0 ? Effect.void : Effect.fail({
+				_tag: "TypescriptProjectError",
+				message: missing.map(({ project, file }) => `${project} does not include generated type file ${file}. Include the entry's _vorma directory in that TypeScript project.`).join("\n")
+			});
+		}
+	});
+}
+/** Opens the two configured TypeScript projects for the duration of `useFn`, then closes the checker session. */
+function withTypescriptProjects(input) {
+	return withTypescriptApi({
+		...input,
+		useFn: (api) => {
+			return Effect.scoped(Effect.gen(function* () {
+				const projects = findProjects({
+					snapshot: yield* Effect.acquireRelease(openCompilerResource(() => {
+						return api.updateSnapshot({ openProjects: [input.serverTsconfigFilePath, input.clientTsconfigFilePath] });
+					}), (snapshot) => Effect.sync(() => snapshot.dispose())),
+					...input
+				});
+				return yield* Result.isFailure(projects) ? Effect.fail(projects.failure) : input.useFn(projects.success);
+			}));
+		}
+	});
+}
+function openCompilerResource(fn) {
+	return Effect.try({
+		try: fn,
+		catch: (cause) => {
+			return {
+				_tag: "TypescriptProjectError",
+				message: "Vorma could not read the application's TypeScript projects",
+				cause
+			};
+		}
+	});
+}
+function withTypescriptApi(input) {
+	return Effect.scoped(Effect.gen(function* () {
+		const api = yield* Effect.acquireRelease(openCompilerResource(() => {
+			return new API({
+				cwd: input.configDirectory,
+				...input.fileSystem === void 0 ? {} : { fs: input.fileSystem }
+			});
+		}), (api) => Effect.sync(() => api.close()));
+		return yield* input.useFn(api);
+	}));
+}
+function findProjects(input) {
+	const server = input.snapshot.getProject(input.serverTsconfigFilePath);
+	const client = input.snapshot.getProject(input.clientTsconfigFilePath);
+	if (server === void 0 || client === void 0) return Result.fail({
+		_tag: "TypescriptProjectError",
+		message: `TypeScript did not load ${server === void 0 ? input.serverTsconfigFilePath : input.clientTsconfigFilePath}`
+	});
+	return Result.succeed({
+		server,
+		client
+	});
+}
+//#endregion
+//#region src/build/compile-application.ts
+function compareSources(left, right) {
+	const byPath = compareSourceText({
+		left: left.filePath,
+		right: right.filePath
+	});
+	return byPath === 0 ? compareSourceText({
+		left: left.exportName,
+		right: right.exportName
+	}) : byPath;
+}
+function getSegmentSources(segment) {
+	return [...segment.loader === void 0 ? [] : [segment.loader], ...segment.view === void 0 ? [] : [segment.view]];
+}
+/** Joins the inspected declarations and views into one validated model. */
+function compileApplicationModel(inspection) {
+	const issues = [];
+	const serverDeclarations = [...inspection.serverDeclarations].sort(compareSources);
+	const clientViews = [...inspection.clientViews].sort(compareSources);
+	const uiLoaders = serverDeclarations.filter((declaration) => {
+		return declaration.kind === "UiLoader";
+	});
+	const endpoints = serverDeclarations.filter((declaration) => {
+		return declaration.kind === "Endpoint";
+	});
+	const segments = /* @__PURE__ */ new Map();
+	const loaderSources = /* @__PURE__ */ new Map();
+	for (const loader of uiLoaders) {
+		const registered = compileUiPattern(loader.pattern);
+		if (Result.isFailure(registered)) {
+			issues.push({
+				_tag: "InvalidPattern",
+				role: "uiLoader",
+				pattern: loader.pattern,
+				source: loader,
+				cause: registered.failure
+			});
+			continue;
+		}
+		const key = registered.success.pattern;
+		const sources = loaderSources.get(key);
+		if (sources === void 0) {
+			loaderSources.set(key, [loader]);
+			segments.set(key, {
+				pattern: loader.pattern,
+				registered: registered.success,
+				loader,
+				view: void 0
+			});
+		} else sources.push(loader);
+	}
+	const viewSources = /* @__PURE__ */ new Map();
+	for (const view of clientViews) {
+		const registered = compileUiPattern(view.pattern);
+		if (Result.isFailure(registered)) {
+			issues.push({
+				_tag: "InvalidPattern",
+				role: "clientView",
+				pattern: view.pattern,
+				source: view,
+				cause: registered.failure
+			});
+			continue;
+		}
+		const key = registered.success.pattern;
+		const sources = viewSources.get(key);
+		if (sources !== void 0) {
+			sources.push(view);
+			continue;
+		}
+		viewSources.set(key, [view]);
+		const existing = segments.get(key);
+		segments.set(key, {
+			pattern: existing === void 0 ? view.pattern : existing.pattern,
+			registered: registered.success,
+			loader: existing === void 0 ? void 0 : existing.loader,
+			view
+		});
+	}
+	const endpointSources = /* @__PURE__ */ new Map();
+	for (const endpoint of endpoints) {
+		const registered = compileEndpointPattern(endpoint.pattern);
+		if (Result.isFailure(registered)) {
+			issues.push({
+				_tag: "InvalidPattern",
+				role: "endpoint",
+				pattern: endpoint.pattern,
+				source: endpoint,
+				cause: registered.failure
+			});
+			continue;
+		}
+		const key = `${endpoint.method} ${registered.success.pattern}`;
+		const sources = endpointSources.get(key);
+		if (sources === void 0) endpointSources.set(key, [endpoint]);
+		else sources.push(endpoint);
+	}
+	const orderedSegments = [...segments.values()].sort((left, right) => {
+		return compareSourceText({
+			left: left.pattern,
+			right: right.pattern
+		});
+	});
+	for (const conflict of findConflictingDynamicParameterNames({
+		patterns: orderedSegments,
+		getMatcherPattern: (segment) => segment.registered.pattern,
+		getSegments: (segment) => segment.registered.segments,
+		makeCause: ({ conflict, attemptedPattern }) => {
+			return {
+				_tag: "ConflictingDynamicParameterName",
+				...conflict,
+				pattern: attemptedPattern.pattern
+			};
+		}
+	})) issues.push({
+		_tag: "ConflictingUiPatternParameters",
+		patterns: conflict.patterns.map((segment) => segment.pattern),
+		sources: conflict.patterns.flatMap(getSegmentSources).sort(compareSources),
+		cause: conflict.cause
+	});
+	if (issues.length > 0) return Result.fail(issues);
+	const linkedSegments = createNestedRouteChains({ nodes: orderedSegments }).map(({ target, chain }) => {
+		return {
+			...target,
+			searchOwnerInputs: chain.flatMap((node) => {
+				return node.loader === void 0 || node.loader.input === void 0 ? [] : [node.loader.input];
+			})
+		};
+	});
+	return Result.succeed({
+		serverDeclarations,
+		uiLoaders: [...loaderSources.values()].flatMap((sources) => sources.slice(0, 1)),
+		endpoints: [...endpointSources.values()].flatMap((sources) => sources.slice(0, 1)),
+		clientViews: [...viewSources.values()].flatMap((sources) => sources.slice(0, 1)),
+		clientViewCandidates: new Map([...viewSources.values()].flatMap((sources) => {
+			const first = sources[0];
+			return first === void 0 ? [] : [[first.pattern, sources]];
+		})),
+		clientViewModules: [...new Set(clientViews.map((view) => view.filePath))].sort((left, right) => compareSourceText({
+			left,
+			right
+		})),
+		clientApplication: inspection.clientApplication,
+		segments: linkedSegments
+	});
+}
+//#endregion
+//#region src/build/output-files.ts
+/** Atomically replaces generated source that TypeScript and build tools can read. */
+function writeOutputFile(input) {
+	return Effect.gen(function* () {
+		const fileSystem = yield* FileSystem$1.FileSystem;
+		const path = yield* Path$1.Path;
+		const directory = path.dirname(input.filePath);
+		yield* fileSystem.makeDirectory(directory, { recursive: true });
+		const bytes = typeof input.source === "string" ? new TextEncoder().encode(input.source) : input.source;
+		yield* Effect.acquireUseRelease(fileSystem.makeTempDirectory({
+			directory,
+			prefix: "_vorma-write-"
+		}), (tempDirectory) => {
+			return Effect.gen(function* () {
+				const temporary = path.join(tempDirectory, "output");
+				yield* fileSystem.writeFile(temporary, bytes);
+				yield* fileSystem.rename(temporary, input.filePath);
+			});
+		}, (tempDirectory) => {
+			return fileSystem.remove(tempDirectory, {
+				force: true,
+				recursive: true
+			}).pipe(Effect.catch((cause) => {
+				return Effect.logWarning("Could not remove the temporary output directory " + tempDirectory, cause);
+			}));
+		});
+	}).pipe(Effect.uninterruptible);
+}
+//#endregion
+//#region src/build/public-assets.ts
+/** Hashes and publishes each public file's exact bytes, retaining only metadata and erased key types. */
+function collectPublicAssets(config) {
+	return Effect.gen(function* () {
+		const fileSystem = yield* FileSystem$1.FileSystem;
+		const path = yield* Path$1.Path;
+		const root = config.publicAssetsSourceDirectory;
+		const pending = [{
+			directory: root,
+			ancestors: /* @__PURE__ */ new Set([root])
+		}];
+		const files = [];
+		while (pending.length > 0) {
+			const directories = pending.splice(0);
+			const inspections = yield* Effect.forEach(directories, ({ directory, ancestors }) => {
+				return Effect.gen(function* () {
+					const names = yield* atAssetPath({
+						sourcePath: directory,
+						message: "Cannot list public assets",
+						effect: fileSystem.readDirectory(directory)
+					});
+					return {
+						entries: yield* Effect.forEach(names, (name) => {
+							const sourcePath = path.join(directory, name);
+							return atAssetPath({
+								sourcePath,
+								message: "Cannot inspect public asset",
+								effect: Effect.gen(function* () {
+									const canonicalPath = yield* fileSystem.realPath(sourcePath);
+									const stat = yield* fileSystem.stat(canonicalPath);
+									return {
+										sourcePath,
+										canonicalPath,
+										type: stat.type
+									};
+								})
+							});
+						}, { concurrency: "unbounded" }),
+						ancestors
+					};
+				});
+			}, { concurrency: "unbounded" });
+			for (const { entries, ancestors } of inspections) for (const entry of entries) if (entry.type === "File") files.push(entry);
+			else if (entry.type === "Directory") {
+				if (ancestors.has(entry.canonicalPath)) return yield* Effect.fail({
+					_tag: "PublicAssetIssue",
+					sourcePath: entry.sourcePath,
+					message: "Public asset directories must not contain symbolic-link cycles"
+				});
+				pending.push({
+					directory: entry.sourcePath,
+					ancestors: /* @__PURE__ */ new Set([...ancestors, entry.canonicalPath])
+				});
+			} else return yield* Effect.fail({
+				_tag: "PublicAssetIssue",
+				sourcePath: entry.sourcePath,
+				message: `Public assets must be regular files or directories; found ${entry.type}`
+			});
+		}
+		files.sort((left, right) => {
+			return compareSourceText({
+				left: left.sourcePath,
+				right: right.sourcePath
+			});
+		});
+		const assets = yield* Effect.forEach(files, ({ sourcePath, canonicalPath }) => {
+			return atAssetPath({
+				sourcePath,
+				message: "Cannot publish public asset",
+				effect: Effect.gen(function* () {
+					const source = yield* fileSystem.readFile(canonicalPath);
+					const digest = blake3(source);
+					const sourceKey = toPosixRelativePath({
+						path,
+						from: root,
+						to: sourcePath
+					});
+					const pathBytes = new TextEncoder().encode(sourceKey);
+					const identity = new Uint8Array(pathBytes.length + 1 + 32);
+					identity.set(pathBytes);
+					identity.set(digest, pathBytes.length + 1);
+					const suffix = toContentDigest(identity).slice(0, 12);
+					const basename = path.basename(sourceKey);
+					const dot = basename.lastIndexOf(".");
+					const extension = dot < 0 ? "" : basename.slice(dot);
+					const stem = sourceKey.slice(0, sourceKey.length - extension.length).replaceAll("/", "_");
+					const fileName = `${ARTIFACT_PROTOCOL.publicOutputFileNamePrefix}${stem}_${suffix}${extension}`.replaceAll(/[<>:"/\\|?*\u0000-\u001f]/g, "_").replace(/[. ]+$/, (tail) => "_".repeat(tail.length));
+					const url = `${config.publicAssetsBasePath}${encodeURIComponent(fileName)}`;
+					yield* fileSystem.writeFile(path.join(config.publicDirectory, fileName), source);
+					return {
+						sourceKey,
+						sourcePath,
+						digest: encodeContentDigest(digest),
+						url,
+						fileName
+					};
+				})
+			});
+		}, { concurrency: 16 });
+		return {
+			assets,
+			publicFilemap: Object.fromEntries(assets.map((asset) => [asset.sourceKey, asset.url])),
+			publicFilepaths: [...new Set(assets.map((asset) => asset.url))],
+			types: {
+				filePath: path.join(config.clientGeneratedDirectory, ARTIFACT_PROTOCOL.generatedAssetKeysFileName),
+				source: [
+					"// Code generated by Vorma. DO NOT EDIT.",
+					"",
+					"import \"vorma/client\";",
+					"",
+					renderAssetKeyDeclaration({
+						assets,
+						depth: 0,
+						prefix: "export type PublicAssetKey ="
+					}),
+					"",
+					"declare module \"vorma/client\" {",
+					"	interface ClientApplicationContracts {",
+					"		readonly assets: PublicAssetKey;",
+					"	}",
+					"}",
+					""
+				].join("\n")
+			}
+		};
+	});
+}
+function renderAssetKeyDeclaration(input) {
+	const [only, ...more] = input.assets;
+	if (only === void 0) return `${input.prefix} never;`;
+	if (more.length === 0) return `${input.prefix} ${JSON.stringify(only.sourceKey)};`;
+	return input.prefix + "\n" + input.assets.map((asset) => `${"	".repeat(input.depth + 1)}| ${JSON.stringify(asset.sourceKey)}`).join("\n") + ";";
+}
+function atAssetPath(input) {
+	return input.effect.pipe(Effect.mapError((cause) => {
+		return {
+			_tag: "PublicAssetIssue",
+			sourcePath: input.sourcePath,
+			message: input.message,
+			cause
+		};
+	}));
+}
+//#endregion
+//#region src/build/render-server-generated.ts
+/**
+* The URL of the published public directory relative to a compiled server
+* module. Every compiled module sits directly in the server entry's Vorma
+* directory, so one relative URL locates the bytes from all of them.
+*/
+function getPublicDirectoryRelativeUrl(input) {
+	return `${input.path.relative(input.serverGeneratedDirectory, input.publicDirectory).split(input.path.sep).map((segment) => encodeURIComponent(segment)).join("/")}/`;
+}
+/** One namespace import per source file that exports a registered declaration, in a stable order. */
+function createModuleNamespaces(input) {
+	const identifiers = /* @__PURE__ */ new Map();
+	const filePaths = [...new Set(input.declarations.map((declaration) => declaration.filePath))].sort((left, right) => compareSourceText({
+		left,
+		right
+	}));
+	for (const filePath of filePaths) identifiers.set(filePath, `serverModule${identifiers.size}`);
+	return {
+		imports: filePaths.map((filePath) => {
+			return {
+				identifier: identifiers.get(filePath) ?? "",
+				specifier: getModuleSpecifier({
+					path: input.path,
+					fromFilePath: input.filePath,
+					toFilePath: filePath
+				})
+			};
+		}),
+		getIdentifier: (filePath) => identifiers.get(filePath) ?? ""
+	};
+}
+/** Renders registration imports independently of final browser output. */
+function renderGeneratedBuildModule(input) {
+	const modules = createModuleNamespaces({
+		declarations: input.declarations,
+		filePath: input.filePath,
+		path: input.path
+	});
+	return {
+		filePath: input.filePath,
+		source: [
+			"// Code generated by Vorma. DO NOT EDIT.",
+			"",
+			...modules.imports.map((moduleImport) => {
+				return `import * as ${moduleImport.identifier} from ${JSON.stringify(moduleImport.specifier)};`;
+			}),
+			"",
+			"/** Every registerable declaration that the server project exports, in source order. */",
+			...input.declarations.length === 0 ? ["export const registeredDeclarations = [] as const;"] : [
+				"export const registeredDeclarations = [",
+				...input.declarations.map((declaration) => {
+					return `\t${modules.getIdentifier(declaration.filePath)}[${JSON.stringify(declaration.exportName)}],`;
+				}),
+				"] as const;"
+			],
+			"",
+			"/** Resolves public files relative to this compiled deployment. */",
+			"export const publicAssetDirectoryUrl = new URL(",
+			`\t${JSON.stringify(input.publicDirectoryRelativeUrl)},`,
+			"	import.meta.url,",
+			").href;",
+			""
+		].join("\n")
+	};
+}
+/** Renders the declaration that augments `vorma/server` with this application's patterns, search types, and asset keys. */
+function renderGeneratedServerContracts(input) {
+	const serverModuleSpecifier = JSON.stringify(FRAMEWORK_IDENTITY_PROTOCOL.moduleSpecifiers.server);
+	const routeSearchTypes = input.model.segments.map((segment) => {
+		const search = segment.searchOwnerInputs.length === 0 ? "undefined" : segment.searchOwnerInputs.map((text) => indentRenderedText(text, 1)).join(" &\n				");
+		return `\t\t\treadonly ${JSON.stringify(segment.pattern)}: ${search};`;
+	});
+	const modules = createModuleNamespaces({
+		declarations: input.model.serverDeclarations,
+		filePath: input.filePath,
+		path: input.path
+	});
+	return {
+		filePath: input.filePath,
+		source: [
+			"// Code generated by Vorma. DO NOT EDIT.",
+			"",
+			`import ${serverModuleSpecifier};`,
+			...modules.imports.map((moduleImport) => {
+				return `import type * as ${moduleImport.identifier} from ${JSON.stringify(moduleImport.specifier)};`;
+			}),
+			...renderEffectModuleImports(input.effectModules),
+			"",
+			...input.typeAliases.length === 0 ? [] : [...input.typeAliases, ""],
+			`declare module ${serverModuleSpecifier} {`,
+			"	interface Register {",
+			"		readonly declarations: readonly [",
+			...input.model.serverDeclarations.map((declaration) => {
+				return `\t\t\t(typeof ${modules.getIdentifier(declaration.filePath)})[${JSON.stringify(declaration.exportName)}],`;
+			}),
+			"		];",
+			...renderPatternRegistration(input.model.segments.map((segment) => segment.pattern)),
+			"		readonly routeSearch: {",
+			...routeSearchTypes,
+			"		};",
+			renderAssetKeyDeclaration({
+				assets: input.publicAssets.assets,
+				depth: 2,
+				prefix: "		readonly assets:"
+			}),
+			"	}",
+			"}",
+			""
+		].join("\n")
+	};
+}
+/** One type-only namespace import per Effect module that rendered contract types name. */
+function renderEffectModuleImports(effectModules) {
+	return effectModules.map((moduleName) => {
+		return `import type * as ${moduleName} from ${JSON.stringify(`effect/${moduleName}`)};`;
+	});
+}
+function renderPatternRegistration(patterns) {
+	if (patterns.length === 0) return ["		readonly patterns: never;"];
+	return ["		readonly patterns:", ...patterns.map((pattern, index) => {
+		const terminator = index === patterns.length - 1 ? ";" : "";
+		return `\t\t\t| ${JSON.stringify(pattern)}${terminator}`;
+	})];
+}
+//#endregion
+//#region src/build/render-client-contracts.ts
+function renderGeneratedClientContracts(input) {
+	function toSpecifier(filePath) {
+		return JSON.stringify(getModuleSpecifier({
+			path: input.path,
+			fromFilePath: input.filePath,
+			toFilePath: filePath
+		}));
+	}
+	const viewModuleIdentifiers = new Map(input.model.clientViewModules.map((filePath, index) => {
+		return [filePath, `ClientViewModule${index}`];
+	}));
+	const uiTypes = input.model.segments.map((segment) => {
+		const moduleIdentifier = segment.view === void 0 ? void 0 : viewModuleIdentifiers.get(segment.view.filePath);
+		return renderTypeEntry(segment.pattern, {
+			input: segment.loader?.input ?? "undefined",
+			output: segment.loader?.output ?? "undefined",
+			search: segment.searchOwnerInputs.length === 0 ? "undefined" : segment.searchOwnerInputs.join(" &\n			"),
+			clientLoader: segment.view === void 0 || moduleIdentifier === void 0 ? "undefined" : `GetUiViewClientLoaderContract<(typeof ${moduleIdentifier})[${JSON.stringify(segment.view.exportName)}]>`
+		});
+	});
+	const endpointTypes = input.model.endpoints.map((endpoint) => {
+		return renderTypeEntry(`${endpoint.method} ${endpoint.pattern}`, {
+			kind: JSON.stringify(endpoint.operation),
+			input: endpoint.inputTransport === "formData" ? "FormData" : endpoint.input ?? "undefined",
+			output: endpoint.output ?? "undefined",
+			event: endpoint.event ?? "undefined",
+			errors: renderErrorTypes(endpoint.errors)
+		});
+	});
+	const application = input.model.clientApplication;
+	const entryImport = application.exportName === "default" ? `import type ClientEntry from ${toSpecifier(application.filePath)};` : `import type { ${application.exportName} as ClientEntry } from ${toSpecifier(application.filePath)};`;
+	return {
+		filePath: input.filePath,
+		source: [
+			"// Code generated by Vorma. DO NOT EDIT.",
+			"",
+			"import type {",
+			"	GetClientApplicationServiceContracts,",
+			...input.model.clientViewModules.length === 0 ? [] : ["	GetUiViewClientLoaderContract,"],
+			`} from ${JSON.stringify(FRAMEWORK_IDENTITY_PROTOCOL.moduleSpecifiers.clientReact)};`,
+			entryImport,
+			...input.model.clientViewModules.map((filePath) => {
+				return `import type * as ${viewModuleIdentifiers.get(filePath)} from ${toSpecifier(filePath)};`;
+			}),
+			...renderEffectModuleImports(input.inspection.effectModules),
+			"",
+			"type ApplicationServiceContracts =",
+			"	GetClientApplicationServiceContracts<typeof ClientEntry>;",
+			"",
+			...input.inspection.typeAliases.length === 0 ? [] : [...input.inspection.typeAliases, ""],
+			"export type UiContracts = {",
+			...uiTypes,
+			"};",
+			"",
+			"export type EndpointContracts = {",
+			...endpointTypes,
+			"};",
+			"",
+			...renderAugmentation(FRAMEWORK_IDENTITY_PROTOCOL.moduleSpecifiers.client),
+			""
+		].join("\n")
+	};
+}
+function renderAugmentation(moduleSpecifier) {
+	return [
+		`declare module ${JSON.stringify(moduleSpecifier)} {`,
+		"	interface ClientApplicationContracts {",
+		"		readonly ui: UiContracts;",
+		"		readonly endpoints: EndpointContracts;",
+		"		readonly clientOnlyServices: ApplicationServiceContracts[\"clientOnlyServices\"];",
+		"		readonly universalServices: ApplicationServiceContracts[\"universalServices\"];",
+		"	}",
+		"}"
+	];
+}
+/** One keyed entry of a contract map, its properties one per line. */
+function renderTypeEntry(key, properties) {
+	return [
+		`\treadonly ${JSON.stringify(key)}: {`,
+		...Object.entries(properties).map(([name, type]) => {
+			return `\t\treadonly ${name}: ${type};`;
+		}),
+		"	};"
+	].join("\n");
+}
+/** An operation's declared errors, keyed by their literal tags. */
+function renderErrorTypes(errors) {
+	if (errors.length === 0) return "{}";
+	return [
+		"{",
+		...errors.map((error) => {
+			return `\t\t\treadonly ${JSON.stringify(error.tag)}: ${indentRenderedText(error.fields, 1)};`;
+		}),
+		"		}"
+	].join("\n");
+}
+//#endregion
+//#region src/build/render-client-transport.ts
+const ADAPTER_EXPORT_BY_TYPE = {
+	option: "optionTransportType",
+	redacted: "redactedTransportType",
+	chunk: "chunkTransportType",
+	duration: "durationTransportType",
+	"big-decimal": "bigDecimalTransportType",
+	"date-time-utc": "dateTimeUtcTransportType",
+	"date-time-zoned": "dateTimeZonedTransportType",
+	"hash-map": "hashMapTransportType",
+	"hash-set": "hashSetTransportType"
+};
+/**
+* Selects generic value adapters without generating application schemas or route
+* metadata. The shared adapters use pure initializers so that unused Effect
+* export reads do not retain optional data modules in the browser bundle.
+*/
+function renderGeneratedClientTransport(input) {
+	const entries = EFFECT_TRANSPORT_TYPES.flatMap(({ name }) => {
+		return input.typeNames.has(name) ? [ADAPTER_EXPORT_BY_TYPE[name]] : [];
+	});
+	const moduleSpecifier = JSON.stringify(FRAMEWORK_IDENTITY_PROTOCOL.moduleSpecifiers.client);
+	return {
+		filePath: input.filePath,
+		source: [
+			"// Code generated by Vorma. DO NOT EDIT.",
+			"",
+			...entries.length === 0 ? [] : [`import { ${entries.join(", ")} } from ${moduleSpecifier};`],
+			`import type { TransportTypeEntry } from ${moduleSpecifier};`,
+			"",
+			`export const transportTypeEntries = [${entries.join(", ")}] satisfies ReadonlyArray<TransportTypeEntry>;`,
+			""
+		].join("\n")
+	};
+}
+//#endregion
+//#region src/build/generate-application.ts
+/** Writes correlated generated sources and verifies their native TypeScript inclusion. */
+function writeAndCheckApplicationGeneration(generation) {
+	return Effect.gen(function* () {
+		yield* Effect.all([writeApplicationGeneration(generation), writeGeneratedServerApplication({ generation })], {
+			concurrency: 2,
+			discard: true
+		});
+		yield* checkGeneratedTypeInclusion({
+			...generation.config,
+			serverFiles: [generation.config.generatedServerContractsFilePath],
+			clientFiles: [generation.clientContracts.filePath, generation.publicAssets.types.filePath]
+		});
+	});
+}
+/** Reads both projects through the checker, captures public assets, and prepares generated build inputs without publishing them. */
+function prepareApplicationGeneration(sourceLayout) {
+	return Effect.gen(function* () {
+		return yield* assembleApplicationGeneration({
+			sourceLayout,
+			...yield* Effect.all({
+				inspection: inspectApplicationSources(sourceLayout),
+				publicAssets: collectPublicAssets(sourceLayout)
+			}, { concurrency: "unbounded" })
+		});
+	});
+}
+/** Reads declarations and public URL call sites independently of public asset hashing. */
+function inspectApplicationSources(sourceLayout) {
+	return withTypescriptProjects({
+		configDirectory: sourceLayout.configDirectory,
+		serverTsconfigFilePath: sourceLayout.serverTsconfigFilePath,
+		clientTsconfigFilePath: sourceLayout.clientTsconfigFilePath,
+		useFn: (projects) => {
+			return inspectProjects({
+				projects,
+				layout: sourceLayout
+			});
+		}
+	});
+}
+/** Prepares correlated build inputs from an inspection and a captured public directory. */
+function assembleApplicationGeneration(input) {
+	return Effect.gen(function* () {
+		const path = yield* Path$1.Path;
+		const { sourceLayout, inspection, publicAssets } = input;
+		const model = compileApplicationModel(inspection);
+		if (Result.isFailure(model)) return yield* Effect.fail({
+			_tag: "ApplicationModelIssues",
+			issues: model.failure
+		});
+		const { publicFilemap } = publicAssets;
+		for (const site of inspection.publicUrlSites) if (!Object.hasOwn(publicFilemap, normalizePublicAssetKey(site.key))) return yield* Effect.fail({
+			_tag: "UnknownPublicAssetKey",
+			filePath: site.filePath,
+			position: site.start,
+			key: site.key
+		});
+		return {
+			config: sourceLayout,
+			model: model.success,
+			inspection,
+			publicAssets,
+			clientContracts: renderGeneratedClientContracts({
+				model: model.success,
+				inspection,
+				filePath: path.join(sourceLayout.clientGeneratedDirectory, ARTIFACT_PROTOCOL.generatedClientContractsFileName),
+				path
+			}),
+			clientTransport: renderGeneratedClientTransport({
+				typeNames: inspection.transportTypeNames,
+				filePath: path.join(sourceLayout.clientGeneratedDirectory, ARTIFACT_PROTOCOL.generatedClientTransportFileName)
+			})
+		};
+	});
+}
+/**
+* Writes the client's generated declarations, transport adapters, and an ignore
+* file in each owned output directory. Cleanup uses the complete client/server
+* output plan, so server source can be written concurrently with this work.
+*/
+function writeApplicationGeneration(generation) {
+	const outputs = [
+		generation.publicAssets.types,
+		generation.clientContracts,
+		generation.clientTransport
+	];
+	const plannedSourceFiles = [
+		...outputs.map((output) => output.filePath),
+		generation.config.generatedBuildFilePath,
+		generation.config.generatedServerContractsFilePath
+	];
+	return Effect.forEach([...generation.config.ignoreFilePaths.map((filePath) => {
+		return {
+			filePath,
+			source: ARTIFACT_PROTOCOL.ignoreFileSource
+		};
+	}), ...outputs], writeGeneratedSource, {
+		concurrency: 16,
+		discard: true
+	}).pipe(Effect.andThen(Effect.forEach([.../* @__PURE__ */ new Set([generation.config.clientGeneratedDirectory, generation.config.serverGeneratedDirectory])], (directory) => {
+		return removeStaleGeneratedSource({
+			directory,
+			plannedSourceFiles
+		});
+	}, {
+		concurrency: 2,
+		discard: true
+	})));
+}
+/** Matches the generated source files the build owns by name, so a name an earlier build used and this one does not is removed. */
+const GENERATED_SOURCE_FILE_NAME = /\.gen\.(d\.)?ts$/;
+function removeStaleGeneratedSource(input) {
+	return Effect.gen(function* () {
+		const fileSystem = yield* FileSystem$1.FileSystem;
+		const path = yield* Path$1.Path;
+		const plannedSourceFiles = new Set(input.plannedSourceFiles);
+		const stale = (yield* fileSystem.readDirectory(input.directory)).map((entry) => path.join(input.directory, entry)).filter((filePath) => {
+			return GENERATED_SOURCE_FILE_NAME.test(filePath) && !plannedSourceFiles.has(filePath);
+		}).sort((left, right) => compareSourceText({
+			left,
+			right
+		}));
+		yield* Effect.forEach(stale, (filePath) => fileSystem.remove(filePath), {
+			concurrency: 16,
+			discard: true
+		});
+	}).pipe(Effect.mapError((cause) => {
+		return {
+			_tag: "GeneratedApplicationWriteError",
+			filePath: input.directory,
+			cause
+		};
+	}));
+}
+/**
+* Writes the internal registration module and the application
+* contract types before server compilation.
+*/
+function writeGeneratedServerApplication(input) {
+	return Effect.gen(function* () {
+		const path = yield* Path$1.Path;
+		const { config, model, inspection } = input.generation;
+		const buildModule = renderGeneratedBuildModule({
+			declarations: model.serverDeclarations,
+			publicDirectoryRelativeUrl: getPublicDirectoryRelativeUrl({
+				path,
+				serverGeneratedDirectory: config.serverGeneratedDirectory,
+				publicDirectory: config.publicDirectory
+			}),
+			filePath: config.generatedBuildFilePath,
+			path
+		});
+		const contracts = renderGeneratedServerContracts({
+			model,
+			publicAssets: input.generation.publicAssets,
+			typeAliases: inspection.typeAliases,
+			effectModules: inspection.effectModules,
+			filePath: config.generatedServerContractsFilePath,
+			path
+		});
+		yield* Effect.forEach([buildModule, contracts], writeGeneratedSource, {
+			concurrency: 2,
+			discard: true
+		});
+	});
+}
+function writeGeneratedSource(output) {
+	return writeOutputFile(output).pipe(Effect.mapError((cause) => {
+		return {
+			_tag: "GeneratedApplicationWriteError",
+			filePath: output.filePath,
+			cause
+		};
+	}));
+}
+//#endregion
+//#region src/build/output-ownership.ts
+const Owner = Schema.fromJsonString(Schema.Struct({
+	pid: Schema.Int.check(Schema.isGreaterThan(0)),
+	kind: Schema.Literals(["build", "dev"]),
+	directories: Schema.NonEmptyArray(Schema.String)
+}));
+function getRemovalCommand(lockPath) {
+	if (platform === "win32") return `PowerShell: Remove-Item -LiteralPath '${lockPath.replaceAll("'", "''")}'`;
+	return `rm -- '${lockPath.replaceAll("'", "'\"'\"'")}'`;
+}
+function removeOwnedLock(input) {
+	return input.fileSystem.remove(input.lockPath, { force: true }).pipe(Effect.catch((cause) => {
+		return Effect.logError(`Could not remove Vorma lock ${input.lockPath}. If the owner has stopped, run ${getRemovalCommand(input.lockPath)}`, cause);
+	}));
+}
+/** Resolves aliases even when the output directory has not been created. */
+function canonicalizeOutputPath(filePath) {
+	return Effect.gen(function* () {
+		const fileSystem = yield* FileSystem.FileSystem;
+		const path = yield* Path$1.Path;
+		let current = path.resolve(filePath);
+		const suffix = [];
+		while (true) {
+			const resolved = yield* Effect.result(fileSystem.realPath(current));
+			if (Result.isSuccess(resolved)) return path.join(resolved.success, ...suffix);
+			if (resolved.failure.reason._tag !== "NotFound" || path.dirname(current) === current) return yield* Effect.fail({
+				_tag: "OutputOwnershipIssue",
+				directory: filePath,
+				message: `Cannot resolve output path ${filePath}`,
+				cause: resolved.failure
+			});
+			const parent = path.dirname(current);
+			suffix.unshift(path.relative(parent, current));
+			current = parent;
+		}
+	});
+}
+/** Checks canonical containment before removing or replacing generated output. */
+function checkOutputPath(input) {
+	return Effect.gen(function* () {
+		const path = yield* Path$1.Path;
+		const relativePath = path.relative(input.rootDirectory, input.filePath);
+		const [root, target] = yield* Effect.all([canonicalizeOutputPath(input.rootDirectory), canonicalizeOutputPath(input.filePath)], { concurrency: 2 });
+		if (!containsRelativePath({
+			relativePath,
+			separator: path.sep,
+			absolute: path.isAbsolute(relativePath)
+		}) || target !== path.join(root, relativePath)) return yield* Effect.fail({
+			_tag: "OutputOwnershipIssue",
+			directory: input.filePath,
+			message: `Generated output path leaves its directory: ${input.filePath}`
+		});
+	});
+}
+/** Owns the application's generated output until the build or development scope closes. */
+function acquireOutputOwnership(input) {
+	return Effect.gen(function* () {
+		const fileSystem = yield* FileSystem.FileSystem;
+		const path = yield* Path$1.Path;
+		function toOwnedRoot(directory) {
+			return fileSystem.makeDirectory(directory, { recursive: true }).pipe(Effect.andThen(canonicalizeOutputPath(directory)));
+		}
+		const lockRoot = yield* toOwnedRoot(input.lockDirectory);
+		const boundaryRoots = yield* Effect.forEach(input.boundaryDirectories, toOwnedRoot, { concurrency: "unbounded" });
+		const lockPath = path.join(lockRoot, "build.lock");
+		const owner = {
+			pid,
+			kind: input.kind,
+			directories: [lockRoot, ...boundaryRoots]
+		};
+		yield* Effect.acquireRelease(Effect.scoped(fileSystem.open(lockPath, {
+			flag: "wx",
+			mode: 384
+		})).pipe(Effect.catch((cause) => {
+			return Effect.gen(function* () {
+				if (cause.reason._tag !== "AlreadyExists") return yield* Effect.fail(cause);
+				const recorded = Option.getOrUndefined(yield* fileSystem.readFileString(lockPath).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Owner)), Effect.option));
+				return yield* Effect.fail({
+					_tag: "OutputOwnershipIssue",
+					directory: lockRoot,
+					message: [
+						`Cannot start ${input.kind}: generated output is locked.`,
+						`Lockfile: ${lockPath}`,
+						`Recorded owner PID: ${recorded?.pid ?? "unavailable"}`,
+						`Recorded operation: ${recorded?.kind ?? "unavailable"}`,
+						`Requested outputs: ${owner.directories.join(", ")}`,
+						"Wait for the owning process to finish. If it has stopped, remove the leftover lock and retry:",
+						`  ${getRemovalCommand(lockPath)}`
+					].join("\n")
+				});
+			});
+		})), () => removeOwnedLock({
+			fileSystem,
+			lockPath
+		}));
+		yield* fileSystem.writeFileString(lockPath, JSON.stringify(owner));
+	}).pipe(Effect.mapError((cause) => {
+		return cause._tag === "OutputOwnershipIssue" ? cause : {
+			_tag: "OutputOwnershipIssue",
+			directory: input.lockDirectory,
+			message: "Cannot acquire Vorma output ownership",
+			cause
+		};
+	}));
+}
+//#endregion
+//#region src/build/publish-artifacts.ts
+/** Prepares one public output before Vite adds its browser files to it. */
+function preparePublicOutput(config) {
+	return Effect.gen(function* () {
+		const fileSystem = yield* FileSystem$1.FileSystem;
+		const directory = config.publicDirectory;
+		yield* checkOutputPath({
+			filePath: directory,
+			rootDirectory: config.clientGeneratedDirectory
+		});
+		yield* fileSystem.remove(directory, {
+			force: true,
+			recursive: true
+		});
+		yield* fileSystem.makeDirectory(directory, { recursive: true });
+	});
+}
+/** Publishes compiled server modules and private metadata for the completed browser build. */
+function publishApplicationArtifacts(input) {
+	return Effect.gen(function* () {
+		const fileSystem = yield* FileSystem$1.FileSystem;
+		const path = yield* Path$1.Path;
+		const config = input.generation.config;
+		if (input.server !== void 0) yield* removeCompiledServerModules(config.serverGeneratedDirectory);
+		const files = (input.server?.files ?? []).map((file) => {
+			return {
+				filePath: path.join(config.serverGeneratedDirectory, file.fileName),
+				source: file.source
+			};
+		});
+		yield* Effect.forEach(files, (file) => {
+			return Effect.gen(function* () {
+				yield* fileSystem.makeDirectory(path.dirname(file.filePath), { recursive: true });
+				yield* typeof file.source === "string" ? fileSystem.writeFileString(file.filePath, file.source) : fileSystem.writeFile(file.filePath, file.source);
+			});
+		}, {
+			concurrency: 16,
+			discard: true
+		});
+		const metadataPath = path.join(config.serverGeneratedDirectory, ARTIFACT_PROTOCOL.productionMetadataFileName);
+		const temporaryPath = `${metadataPath}.tmp`;
+		yield* fileSystem.writeFileString(temporaryPath, JSON.stringify(input.artifacts.metadata));
+		yield* fileSystem.rename(temporaryPath, metadataPath);
+		return {
+			clientBuildId: input.artifacts.metadata.clientBuildId,
+			publicDirectory: config.publicDirectory,
+			serverEntryPath: config.compiledServerEntryFilePath
+		};
+	}).pipe(Effect.mapError((cause) => {
+		return {
+			_tag: "ArtifactPublicationIssue",
+			cause
+		};
+	}));
+}
+/** Generated TypeScript source shares this directory and is not compiled output. */
+function removeCompiledServerModules(directory) {
+	return Effect.gen(function* () {
+		const fileSystem = yield* FileSystem$1.FileSystem;
+		const path = yield* Path$1.Path;
+		if (!(yield* fileSystem.exists(directory))) return;
+		const fileNames = (yield* fileSystem.readDirectory(directory)).filter((fileName) => {
+			return fileName.endsWith(ARTIFACT_PROTOCOL.compiledServerModuleExtension);
+		});
+		yield* Effect.forEach(fileNames, (fileName) => {
+			const filePath = path.join(directory, fileName);
+			return checkOutputPath({
+				filePath,
+				rootDirectory: directory
+			}).pipe(Effect.andThen(fileSystem.remove(filePath)));
+		}, {
+			concurrency: 16,
+			discard: true
+		});
+	});
+}
+//#endregion
+//#region src/build/source-layout.ts
+/** Loads the configured source layout before any application module executes. */
+function loadApplicationSourceLayout(config) {
+	return Effect.gen(function* () {
+		const fileSystem = yield* FileSystem$1.FileSystem;
+		const path = yield* Path$1.Path;
+		const requiredPaths = {
+			serverEntryFilePath: {
+				field: "serverEntry",
+				path: config.serverEntryFilePath,
+				expectedType: "File"
+			},
+			serverTsconfigFilePath: {
+				field: "serverTsconfigFile",
+				path: config.serverTsconfigFilePath,
+				expectedType: "File"
+			},
+			clientEntryFilePath: {
+				field: "clientEntry",
+				path: config.clientEntryFilePath,
+				expectedType: "File"
+			},
+			clientTsconfigFilePath: {
+				field: "clientTsconfigFile",
+				path: config.clientTsconfigFilePath,
+				expectedType: "File"
+			},
+			publicAssetsSourceDirectory: {
+				field: "publicAssetsDir",
+				path: config.publicAssetsSourceDirectory,
+				expectedType: "Directory"
+			},
+			viteConfigFilePath: {
+				field: "viteConfigFile",
+				path: config.viteConfigFilePath,
+				expectedType: "File"
+			}
+		};
+		const criticalCssRequirement = config.criticalCssEntryFilePath === void 0 ? void 0 : {
+			field: "criticalCssEntry",
+			path: config.criticalCssEntryFilePath,
+			expectedType: "File"
+		};
+		function inspectSourcePath(requirement) {
+			return Effect.all({
+				stat: Effect.result(fileSystem.stat(requirement.path)),
+				canonicalPath: Effect.result(fileSystem.realPath(requirement.path))
+			}).pipe(Effect.map((inspection) => {
+				if (Result.isFailure(inspection.stat)) return Result.fail({
+					...requirement,
+					cause: inspection.stat.failure
+				});
+				if (inspection.stat.success.type !== requirement.expectedType) return Result.fail({
+					...requirement,
+					actualType: inspection.stat.success.type
+				});
+				if (Result.isFailure(inspection.canonicalPath)) return Result.fail({
+					...requirement,
+					cause: inspection.canonicalPath.failure
+				});
+				return Result.succeed(inspection.canonicalPath.success);
+			}));
+		}
+		const inspections = yield* Effect.all({
+			...Record.map(requiredPaths, inspectSourcePath),
+			criticalCssEntryFilePath: criticalCssRequirement === void 0 ? Effect.succeed(Result.succeed(void 0)) : inspectSourcePath(criticalCssRequirement)
+		}, { concurrency: "unbounded" });
+		const issues = Object.values(inspections).flatMap((inspection) => {
+			return Result.isFailure(inspection) ? [inspection.failure] : [];
+		});
+		const canonicalPaths = Result.all(inspections);
+		if (Result.isFailure(canonicalPaths)) return yield* Effect.fail({
+			_tag: "ApplicationSourceLayoutIssues",
+			issues
+		});
+		const { criticalCssEntryFilePath, ...canonical } = canonicalPaths.success;
+		const canonicalConfig = {
+			...config,
+			...canonical,
+			serverProjectDirectory: path.dirname(canonical.serverTsconfigFilePath),
+			...criticalCssEntryFilePath === void 0 ? {} : { criticalCssEntryFilePath },
+			...getVormaOwnedPaths({
+				path,
+				serverEntryDirectory: path.dirname(canonical.serverEntryFilePath),
+				clientEntryDirectory: path.dirname(canonical.clientEntryFilePath)
+			})
+		};
+		const publicSource = canonicalConfig.publicAssetsSourceDirectory;
+		const publicOutput = canonicalConfig.publicDirectory;
+		if ([path.relative(publicSource, publicOutput), path.relative(publicOutput, publicSource)].some((relativePath) => {
+			return containsRelativePath({
+				relativePath,
+				separator: path.sep,
+				absolute: path.isAbsolute(relativePath)
+			});
+		})) return yield* Effect.fail({
+			_tag: "ApplicationSourceLayoutIssues",
+			issues: [{
+				field: "publicAssetsDir",
+				path: publicSource,
+				expectedType: "Directory",
+				message: `Public asset source ${publicSource} overlaps generated output ${publicOutput}; the build cannot replace its own input or capture its own output.`
+			}]
+		});
+		return canonicalConfig;
+	});
+}
+//#endregion
+//#region src/build/inspect-css-artifacts.ts
+/** Records dependencies from compiled stylesheets for nonblocking preload hints. */
+function inspectCssArtifacts(input) {
+	const references = /* @__PURE__ */ new Map();
+	for (const stylesheet of input.stylesheets) {
+		const urls = [];
+		references.set(stylesheet.url, urls);
+		const name = stylesheet.url === null ? "critical CSS" : stylesheet.url;
+		const parsed = Result.try({
+			try: () => {
+				return transform({
+					filename: name,
+					code: Buffer.from(stylesheet.source),
+					analyzeDependencies: true
+				});
+			},
+			catch: (cause) => `Cannot inspect ${name}: ${String(cause)}`
+		});
+		if (Result.isFailure(parsed)) return Result.fail(parsed.failure);
+		const dependencies = parsed.success.dependencies;
+		if (dependencies === void 0) continue;
+		for (const dependency of dependencies) {
+			if (dependency.type !== "url" && dependency.type !== "import") continue;
+			const reference = dependency.url;
+			if (reference.startsWith("#") || reference.startsWith("data:")) continue;
+			const resolved = Result.try({
+				try: () => {
+					return new URL(reference, `https://vorma.invalid${stylesheet.url === null ? "/" : stylesheet.url}`);
+				},
+				catch: () => `Invalid CSS URL: ${reference}`
+			});
+			if (Result.isFailure(resolved)) return Result.fail(resolved.failure);
+			const absolute = resolved.success;
+			urls.push({
+				url: absolute.origin === "https://vorma.invalid" ? stylesheet.url === null && !reference.startsWith("/") ? reference : absolute.pathname + absolute.search + absolute.hash : reference.startsWith("//") ? reference : absolute.href,
+				kind: dependency.type
+			});
+		}
+	}
+	return Result.succeed(references);
+}
+//#endregion
+//#region src/build/assemble-artifacts.ts
+/** Joins published file metadata and checks paths, collisions, and module projections. */
+function assembleApplicationArtifacts(input) {
+	return Effect.gen(function* () {
+		const { generation, client } = input;
+		const base = generation.config.publicAssetsBasePath;
+		function toPublicUrl(fileName) {
+			return base + fileName.split("/").map(encodeURIComponent).join("/");
+		}
+		const byFile = /* @__PURE__ */ new Map();
+		const byUrl = /* @__PURE__ */ new Map();
+		const directories = /* @__PURE__ */ new Set();
+		/** Records one output, or the artifact already recorded for the same bytes at the same file. */
+		function addFile(output) {
+			const parsed = parseArtifactFileName(output.fileName);
+			if (Result.isFailure(parsed)) return Result.fail(parsed.failure);
+			if (output.immutable && !output.fileName.startsWith(ARTIFACT_PROTOCOL.publicOutputFileNamePrefix)) return Result.fail(`Hashed public asset must start with ${ARTIFACT_PROTOCOL.publicOutputFileNamePrefix}: ${output.fileName}`);
+			const digest = output.digest;
+			const existing = byFile.get(output.fileName);
+			if (existing !== void 0) {
+				if (existing.digest !== digest || existing.url !== output.url || existing.immutable !== output.immutable) return Result.fail(`Conflicting artifact outputs: ${output.fileName}`);
+				return Result.succeed(existing);
+			}
+			if (byUrl.has(output.url)) return Result.fail(`Conflicting artifact URL: ${output.url}`);
+			const parts = output.fileName.split("/");
+			const parents = parts.slice(0, -1).map((_part, index) => parts.slice(0, index + 1).join("/"));
+			if (directories.has(output.fileName) || parents.some((parent) => byFile.has(parent))) return Result.fail(`Artifact file and directory conflict: ${output.fileName}`);
+			const artifact = output;
+			byFile.set(output.fileName, artifact);
+			byUrl.set(output.url, artifact);
+			for (const parent of parents) directories.add(parent);
+			return Result.succeed(artifact);
+		}
+		for (const asset of generation.publicAssets.assets) yield* Effect.fromResult(addFile({
+			fileName: asset.fileName,
+			url: asset.url,
+			digest: asset.digest,
+			immutable: true
+		}));
+		const bundleArtifacts = [];
+		for (const output of client.outputs) {
+			const source = typeof output.source === "string" ? new TextEncoder().encode(output.source) : output.source;
+			const artifact = yield* Effect.fromResult(addFile({
+				fileName: output.fileName,
+				digest: toContentDigest(source),
+				url: toPublicUrl(output.fileName),
+				immutable: byFile.get(output.fileName)?.immutable ?? output.immutable
+			}));
+			bundleArtifacts.push({
+				...artifact,
+				source
+			});
+		}
+		const cssReferences = yield* Effect.fromResult(inspectCssArtifacts({ stylesheets: [{
+			url: null,
+			source: new TextEncoder().encode(client.criticalCss)
+		}, ...bundleArtifacts.filter((artifact) => artifact.fileName.endsWith(".css")).map((artifact) => {
+			return {
+				url: artifact.url,
+				source: artifact.source
+			};
+		})] }));
+		const publicFilemap = generation.publicAssets.publicFilemap;
+		function collectCssAssets(stylesheets) {
+			const visited = /* @__PURE__ */ new Set();
+			const assets = /* @__PURE__ */ new Set();
+			const pending = [...stylesheets];
+			while (pending.length > 0) {
+				const stylesheet = pending.pop();
+				if (stylesheet === void 0 || visited.has(stylesheet)) continue;
+				visited.add(stylesheet);
+				for (const reference of cssReferences.get(stylesheet) ?? []) if (reference.kind === "import") pending.push(reference.url);
+				else assets.add(reference.url);
+			}
+			return [...assets];
+		}
+		function addCssAssetUrls(module) {
+			return {
+				...module,
+				staticAssetUrls: [.../* @__PURE__ */ new Set([...module.staticAssetUrls, ...collectCssAssets(module.cssBundleUrls)])]
+			};
+		}
+		const entryModule = addCssAssetUrls(client.clientEntry);
+		const clientEntry = {
+			...entryModule,
+			staticAssetUrls: [.../* @__PURE__ */ new Set([...entryModule.staticAssetUrls, ...collectCssAssets([null])])]
+		};
+		const clientViews = Object.fromEntries(Object.entries(client.clientViews).map(([pattern, module]) => {
+			return [pattern, {
+				...addCssAssetUrls(module),
+				exportNames: module.exportNames
+			}];
+		}));
+		const files = [...byFile.values()].sort((left, right) => compareSourceText({
+			left: left.url,
+			right: right.url
+		}));
+		const metadata = {
+			runtimeMode: "production",
+			publicFiles: files.map((file) => {
+				return {
+					url: file.url,
+					fileName: file.fileName,
+					immutable: file.immutable
+				};
+			}),
+			publicFilemap,
+			criticalCss: client.criticalCss,
+			clientEntry,
+			clientViews
+		};
+		const { publicFiles: _publicFiles, ...browserMetadata } = metadata;
+		return { metadata: {
+			...metadata,
+			clientBuildId: toContentDigest(encodeCanonicalJson({
+				version: 3,
+				metadata: browserMetadata,
+				contracts: projectBrowserContracts(generation.inspection),
+				files: files.filter((file) => file.immutable).map((file) => {
+					return {
+						url: file.url,
+						digest: file.digest
+					};
+				})
+			})).slice(0, 24)
+		} };
+	}).pipe(Effect.mapError((reason) => {
+		return {
+			_tag: "ArtifactAssemblyIssue",
+			reason
+		};
+	}));
+}
+function parseArtifactFileName(fileName) {
+	if (fileName.split("/").some((part) => {
+		return part === "" || part === "." || part === ".." || /[\\:\0]/.test(part);
+	})) return Result.fail(`Invalid artifact output path: ${fileName}`);
+	return Result.succeed(fileName);
+}
+//#endregion
+//#region src/build/client-output-hashing.ts
+/** Native naming retains Vite's content hashing and dependency URL rewriting. */
+function createClientOutputHashingPlugin(immutableFiles) {
+	return {
+		name: "vorma:client-output-hashing",
+		enforce: "post",
+		outputOptions: {
+			order: "post",
+			handler(options) {
+				return {
+					...options,
+					entryFileNames: ARTIFACT_PROTOCOL.publicModuleFileNamePattern,
+					chunkFileNames: ARTIFACT_PROTOCOL.publicModuleFileNamePattern,
+					assetFileNames: ARTIFACT_PROTOCOL.publicAssetFileNamePattern
+				};
+			}
+		},
+		generateBundle: {
+			order: "post",
+			handler(_options, bundle) {
+				for (const output of Object.values(bundle)) {
+					if (output.type !== "chunk") continue;
+					if (output.preliminaryFileName !== output.fileName) immutableFiles.add(output.fileName);
+					for (const file of [...output.viteMetadata?.importedCss ?? [], ...output.viteMetadata?.importedAssets ?? []]) immutableFiles.add(file);
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/build/critical-css.ts
+/** Finds the configured critical stylesheet through Vite's module-to-CSS association. */
+function findCriticalCssFileName(input) {
+	if (input.sourcePath === void 0) return Result.succeed(void 0);
+	const sourcePath = input.sourcePath;
+	const stylesheets = new Set(input.outputs.flatMap((output) => {
+		return output.type === "chunk" && Object.hasOwn(output.modules, sourcePath) ? [...output.viteMetadata?.importedCss ?? []] : [];
+	}));
+	const stylesheet = [...stylesheets][0];
+	if (stylesheets.size !== 1 || stylesheet === void 0) return Result.fail("The configured critical CSS entry must produce one stylesheet in the client build");
+	return Result.succeed(stylesheet);
+}
+//#endregion
+//#region src/build/bundle-client.ts
+/** Builds browser entries directly into Vorma's prepared public directory. */
+function bundleClient(generation) {
+	return Effect.gen(function* () {
+		const viewEntries = getClientViewEntries(generation);
+		const publicCss = createCssPublicAssets(generation.publicAssets);
+		const { result, criticalCss, cssAssets, referencedAssets, javascriptAssets, manifestFiles, immutableFiles } = yield* Effect.tryPromise(() => runClientBuild(generation, publicCss, viewEntries)).pipe(Effect.uninterruptible);
+		if (result === void 0) return yield* Effect.fail("The Vite application build did not produce Vorma's client environment");
+		const fileSystem = yield* FileSystem$1.FileSystem;
+		const path = yield* Path$1.Path;
+		yield* Effect.forEach(manifestFiles, (fileName) => {
+			return checkOutputPath({
+				filePath: path.join(generation.config.publicDirectory, fileName),
+				rootDirectory: generation.config.publicDirectory
+			}).pipe(Effect.andThen(fileSystem.remove(path.join(generation.config.publicDirectory, fileName), { force: true })));
+		}, {
+			concurrency: 2,
+			discard: true
+		});
+		const outputs = result.output.filter((output) => !manifestFiles.has(output.fileName));
+		for (const fileName of cssAssets) immutableFiles.add(fileName);
+		const chunkFiles = new Set(outputs.flatMap((output) => {
+			return output.type === "chunk" ? [output.fileName] : [];
+		}));
+		const modules = /* @__PURE__ */ new Map();
+		for (const output of outputs) {
+			if (output.type !== "chunk") continue;
+			const assetUrls = [];
+			for (const hostId of /* @__PURE__ */ new Set([output.preliminaryFileName, output.fileName])) for (const reference of javascriptAssets.get(hostId) ?? []) {
+				if (!output.viteMetadata?.importedAssets.has(reference.fileName.replace(/[?#].*$/s, ""))) continue;
+				const url = toJavascriptAssetUrl({
+					reference,
+					base: generation.config.publicAssetsBasePath
+				});
+				if (url !== void 0) assetUrls.push(url);
+			}
+			modules.set(output.fileName, {
+				file: output.fileName,
+				imports: output.imports.filter((file) => chunkFiles.has(file)),
+				css: [...output.viteMetadata?.importedCss ?? []],
+				assets: [...output.viteMetadata?.importedAssets ?? []],
+				assetUrls
+			});
+		}
+		const referencedFiles = new Map(outputs.flatMap((output) => {
+			return output.type === "chunk" ? [[output.fileName, [...referencedAssets.get(output.preliminaryFileName) ?? []]]] : [];
+		}));
+		const files = new Set(outputs.map((output) => output.fileName));
+		for (const [key, entry] of modules) for (const file of [
+			entry.file,
+			...entry.css,
+			...entry.assets
+		]) if (!files.has(file)) return yield* Effect.fail(`Client module ${key} references a missing output: ${file}`);
+		const frameworkEntries = /* @__PURE__ */ new Set([generation.config.clientEntryFilePath, ...viewEntries.map((entry) => entry.id)]);
+		const entries = /* @__PURE__ */ new Map();
+		for (const output of outputs) {
+			if (output.type !== "chunk" || !output.isEntry || output.facadeModuleId === null || !frameworkEntries.has(output.facadeModuleId)) continue;
+			entries.set(output.facadeModuleId, yield* Effect.fromResult(projectClientModule({
+				modules,
+				referencedFiles,
+				immutableFiles,
+				key: output.fileName,
+				base: generation.config.publicAssetsBasePath
+			})));
+		}
+		const clientEntry = entries.get(generation.config.clientEntryFilePath);
+		if (clientEntry === void 0) return yield* Effect.fail("Vite did not preserve the configured client entry");
+		const clientViews = yield* Effect.forEach(viewEntries, (view) => {
+			const module = entries.get(view.id);
+			return module === void 0 ? Effect.fail(`Vite did not preserve the view module ${view.id}`) : Effect.succeed([view.pattern, {
+				...module,
+				exportNames: view.exportNames
+			}]);
+		}).pipe(Effect.map(Object.fromEntries));
+		return {
+			criticalCss,
+			outputs: outputs.map((output) => {
+				return {
+					fileName: output.fileName,
+					immutable: immutableFiles.has(output.fileName),
+					source: output.type === "chunk" ? output.code : typeof output.source === "string" ? output.source : Uint8Array.from(output.source)
+				};
+			}),
+			chunks: outputs.flatMap((output) => {
+				return output.type === "chunk" ? [{
+					fileName: output.fileName,
+					sourceModules: Object.keys(output.modules),
+					renderedLengths: Object.fromEntries(Object.entries(output.modules).map(([id, module]) => {
+						return [id, module.renderedLength];
+					})),
+					imports: [...output.imports],
+					dynamicImports: [...output.dynamicImports]
+				}] : [];
+			}),
+			clientEntry,
+			clientViews
+		};
+	}).pipe(Effect.mapError((cause) => {
+		return {
+			_tag: "ClientBundleIssue",
+			cause
+		};
+	}));
+}
+/** The entry's module and, dependencies first, every static import it reaches with their stylesheets. */
+function projectClientModule(input) {
+	const root = input.modules.get(input.key);
+	if (root === void 0) return Result.fail(`Client output has no module: ${input.key}`);
+	const visited = /* @__PURE__ */ new Set();
+	const dependencies = /* @__PURE__ */ new Set();
+	const css = /* @__PURE__ */ new Set();
+	const assets = /* @__PURE__ */ new Set();
+	const pending = [{
+		key: input.key,
+		collect: false
+	}];
+	for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
+		const entry = input.modules.get(next.key);
+		if (entry === void 0) return Result.fail(`Client output has no module: ${next.key}`);
+		if (!input.immutableFiles.has(entry.file)) return Result.fail(`Browser module ${entry.file} must use Vite's content-hashed output naming`);
+		if (next.collect) {
+			if (next.key !== input.key) dependencies.add(entry.file);
+			for (const file of entry.css) css.add(file);
+			for (const url of entry.assetUrls) assets.add(url);
+			for (const file of input.referencedFiles.get(entry.file) ?? []) assets.add(toUrl(file));
+			continue;
+		}
+		if (visited.has(next.key)) continue;
+		visited.add(next.key);
+		pending.push({
+			key: next.key,
+			collect: true
+		});
+		const imports = entry.imports;
+		for (const dependency of [...imports].reverse()) pending.push({
+			key: dependency,
+			collect: false
+		});
+	}
+	function toUrl(fileName) {
+		return input.base + fileName.split("/").map(encodeURIComponent).join("/");
+	}
+	return Result.succeed({
+		importUrl: toUrl(root.file),
+		depUrls: [...dependencies].map(toUrl),
+		cssBundleUrls: [...css].map(toUrl),
+		staticAssetUrls: [...assets]
+	});
+}
+/** Vite encodes a literal built URL's path, leaving its query and fragment intact. */
+function toJavascriptAssetUrl(input) {
+	const { fileName, renderedUrl } = input.reference;
+	if (typeof renderedUrl === "object" && renderedUrl.runtime) return;
+	const usesRenderedUrl = typeof renderedUrl === "string" && renderedUrl.length > 0;
+	const url = usesRenderedUrl ? renderedUrl : fileName;
+	const prefix = usesRenderedUrl ? "" : input.base;
+	if (url.startsWith("data:")) return;
+	const suffixIndex = url.search(/[?#]/);
+	return prefix + (suffixIndex < 0 ? encodeURI(url) : encodeURI(url.slice(0, suffixIndex)) + url.slice(suffixIndex));
+}
+async function runClientBuild(generation, publicCss, viewEntries) {
+	const manifestFiles = /* @__PURE__ */ new Set();
+	const immutableFiles = /* @__PURE__ */ new Set();
+	const virtualViewSources = new Map(viewEntries.flatMap((entry) => {
+		return entry.source === void 0 ? [] : [[entry.id, entry.source]];
+	}));
+	let criticalCss = "";
+	let criticalCssFileName;
+	const captured = {};
+	const entries = [
+		{
+			name: "entry",
+			id: generation.config.clientEntryFilePath
+		},
+		...[...new Set(viewEntries.map((entry) => entry.id))].map((id, index) => {
+			return {
+				name: `view-${index}`,
+				id
+			};
+		}),
+		...generation.config.criticalCssEntryFilePath === void 0 ? [] : [{
+			name: "critical",
+			id: generation.config.criticalCssEntryFilePath
+		}]
+	];
+	let hasDeclaration = false;
+	const plugin = {
+		name: VORMA_BUILD_PLUGIN_NAME,
+		api: { registerDeclarationFn: () => {
+			hasDeclaration = true;
+		} },
+		enforce: "post",
+		applyToEnvironment: (environment) => environment.name === "client",
+		configResolved: {
+			order: "post",
+			handler() {
+				if (!hasDeclaration) return this.error("Vorma's build requires vorma() from vorma/vite in the configured Vite plugins list.");
+			}
+		},
+		buildStart() {
+			for (const entry of entries) this.emitFile({
+				type: "chunk",
+				...entry,
+				preserveSignature: "strict"
+			});
+		},
+		resolveId(source) {
+			if (virtualViewSources.has(source)) return source;
+			return source === FRAMEWORK_IDENTITY_PROTOCOL.moduleSpecifiers.clientTransportTypes ? generation.clientTransport.filePath : null;
+		},
+		load(id) {
+			return virtualViewSources.get(id) ?? null;
+		},
+		config(config) {
+			const workerPlugins = config.worker?.plugins;
+			return {
+				base: generation.config.publicAssetsBasePath,
+				publicDir: false,
+				resolve: { dedupe: CLIENT_SHARED_PACKAGES },
+				worker: { plugins: () => {
+					return [...workerPlugins?.() ?? [], createClientOutputHashingPlugin(immutableFiles)];
+				} }
+			};
+		},
+		configEnvironment(name, config) {
+			if (name !== "client") return;
+			const build = config.build;
+			const output = build?.rolldownOptions?.output;
+			if (Array.isArray(output)) return this.error("Vorma requires one output for its client environment");
+			return { build: {
+				outDir: generation.config.publicDirectory,
+				emptyOutDir: false,
+				write: true,
+				cssCodeSplit: true,
+				rolldownOptions: {
+					input: build?.rolldownOptions?.input ?? { entry: generation.config.clientEntryFilePath },
+					output: {
+						...output,
+						format: "es"
+					}
+				}
+			} };
+		},
+		generateBundle: {
+			order: "post",
+			handler(_options, bundle) {
+				const config = this.environment.config;
+				if (config.build.watch || config.build.lib || config.build.ssr) return this.error("Vorma requires a non-watching browser client environment");
+				if (captured.bundle !== void 0) return this.error("Vorma requires one completed client output");
+				captured.bundle = bundle;
+				if (criticalCssFileName !== void 0) {
+					const stylesheet = bundle[criticalCssFileName];
+					if (stylesheet === void 0 || stylesheet.type !== "asset") return this.error("Vite did not preserve the compiled critical stylesheet");
+					criticalCss = typeof stylesheet.source === "string" ? stylesheet.source : new TextDecoder().decode(stylesheet.source);
+					const sourcePath = generation.config.criticalCssEntryFilePath;
+					const source = sourcePath === void 0 ? null : this.getModuleInfo(sourcePath);
+					if (!((source?.importers.length ?? 0) > 0 || (source?.dynamicImporters.length ?? 0) > 0 || Object.values(bundle).some((output) => {
+						return output.type === "chunk" && (output.viteMetadata?.importedCss.has(stylesheet.fileName) || output.viteMetadata?.importedAssets.has(stylesheet.fileName));
+					}))) delete bundle[stylesheet.fileName];
+					else immutableFiles.add(stylesheet.fileName);
+				}
+				for (const [setting, defaultName] of [[config.build.manifest, ".vite/manifest.json"], [config.build.ssrManifest, ".vite/ssr-manifest.json"]]) if (setting) manifestFiles.add(typeof setting === "string" ? setting : defaultName);
+			}
+		}
+	};
+	const referencedAssets = /* @__PURE__ */ new Map();
+	function forClient(plugin) {
+		return {
+			...plugin,
+			applyToEnvironment: (environment) => environment.name === "client"
+		};
+	}
+	await build({
+		configFile: generation.config.viteConfigFilePath,
+		mode: "production",
+		plugins: [
+			plugin,
+			forClient({
+				name: "vorma:critical-css",
+				generateBundle: {
+					order: "pre",
+					handler(_options, bundle) {
+						const critical = findCriticalCssFileName({
+							sourcePath: generation.config.criticalCssEntryFilePath,
+							outputs: Object.values(bundle)
+						});
+						if (Result.isFailure(critical)) return this.error(critical.failure);
+						criticalCssFileName = critical.success;
+					}
+				}
+			}),
+			forClient(publicCss.plugin),
+			forClient(createClientPublicUrlPlugin({
+				sites: generation.inspection.publicUrlSites,
+				sourceTexts: generation.inspection.clientSourceTexts,
+				publicAssets: generation.publicAssets.assets,
+				publicDirectory: generation.config.publicDirectory,
+				referencedAssets
+			})),
+			forClient(createClientOutputHashingPlugin(immutableFiles))
+		]
+	});
+	return {
+		result: captured.bundle === void 0 ? void 0 : { output: Object.values(captured.bundle) },
+		criticalCss,
+		manifestFiles,
+		immutableFiles,
+		referencedAssets,
+		cssAssets: publicCss.cssAssets,
+		javascriptAssets: publicCss.javascriptAssets
+	};
+}
+//#endregion
+//#region src/build/index.ts
+/**
+* Builds and publishes one production application while holding all generated
+* output ownership. `configFilePath` is the absolute path of the configuration
+* file; every configured path resolves against its directory.
+*/
+function buildApplication(input) {
+	return Effect.scoped(Effect.gen(function* () {
+		const resolved = yield* resolveVormaConfig(input).pipe(Effect.flatMap(loadApplicationSourceLayout));
+		yield* acquireOutputOwnership({
+			lockDirectory: resolved.clientGeneratedDirectory,
+			boundaryDirectories: [resolved.serverGeneratedDirectory],
+			kind: "build"
+		});
+		yield* preparePublicOutput(resolved);
+		const generation = yield* prepareApplicationGeneration(resolved);
+		yield* writeAndCheckApplicationGeneration(generation);
+		const { artifacts, server } = yield* Effect.all({
+			artifacts: bundleClient(generation).pipe(Effect.flatMap((client) => {
+				return assembleApplicationArtifacts({
+					generation,
+					client
+				});
+			})),
+			server: compileServerApplication({
+				generation,
+				sourcemap: false
+			})
+		}, { concurrency: 2 });
+		yield* Effect.forEach(server.diagnostics, (diagnostic) => {
+			return Effect.logWarning(`Server compilation ${diagnostic.level}${diagnostic.code === "" ? "" : ` (${diagnostic.code})`}: ${diagnostic.message}`);
+		}, { discard: true });
+		return yield* publishApplicationArtifacts({
+			generation,
+			artifacts,
+			server
+		});
+	}));
+}
+//#endregion
+export { toContentDigest as C, encodeCanonicalJson as S, compileServerApplication as _, acquireOutputOwnership as a, getClientViewEntries as b, writeAndCheckApplicationGeneration as c, withTypescriptProjects as d, inspectProjects as f, createClientPublicUrlPlugin as g, createCssPublicAssets as h, publishApplicationArtifacts as i, collectPublicAssets as l, resolveVormaConfig as m, loadApplicationSourceLayout as n, checkOutputPath as o, getGeneratedSourceDirectories as p, preparePublicOutput as r, assembleApplicationGeneration as s, buildApplication as t, readTypescriptProjectRoots as u, containsRelativePath as v, projectBrowserContracts as x, CLIENT_SHARED_PACKAGES as y };