@sjcx/vorma 0.0.0-pre.6 → 0.0.0-pre.8

package/dist/build-Dy9VE6xO.js

@@ -1,3013 +0,0 @@
-import { t as VORMA_BUILD_PLUGIN_NAME } from "./build-invocation-D7Fu8gBK.js";
-import { Effect, FileSystem, Option, Record, Result, Schema } from "effect";
-import { build, normalizePath } from "vite";
-import { blake3 } from "@noble/hashes/blake3.js";
-import { utf8ToBytes } from "@noble/hashes/utils.js";
-import { base32nopad } from "@scure/base";
-import { ARTIFACT_PROTOCOL, FRAMEWORK_IDENTITY_PROTOCOL, matchesHttpMethod } from "@vorma/protocol";
-import { RolldownMagicString } from "rolldown";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-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, DiagnosticCategory, ElementFlags, SignatureKind, SymbolFlags } from "typescript/unstable/async";
-import { createTemplateHead, createTemplateMiddle, createTemplateTail } from "typescript/unstable/ast/factory";
-import { compileEndpointPattern, compileUiPattern, createNestedRouteChains, findConflictingDynamicParameterNames, parseUrlPathname } from "@vorma/protocol/path";
-import { VormaConfigSchema } from "@vorma/server/config";
-import * as FileSystem$1 from "effect/FileSystem";
-import { EFFECT_TRANSPORT_TYPES } from "@vorma/protocol/transport";
-import { pid, platform } from "node:process";
-import { transform } from "lightningcss";
-//#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,
-			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"
-];
-/** Projects each validated view declaration into one browser entry. */
-function getClientViewEntries(generation) {
-	return generation.model.clientViews.map((view) => {
-		return {
-			pattern: view.pattern,
-			id: view.filePath,
-			exportName: view.exportName
-		};
-	});
-}
-//#endregion
-//#region src/build/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/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/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}`);
-}
-/**
-* 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/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. */
-async function withoutAbsence(input) {
-	const members = input.type.isUnionType() ? await 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. */
-async function matchesLibrarySymbol(input) {
-	const declaration = input.symbol.declarations[0];
-	if (declaration === void 0) return false;
-	const declarationPath = String(declaration.path);
-	const metadata = await input.program.getSourceFileMetadata(declarationPath);
-	return metadata !== void 0 && (metadata.isDefaultLibrary || metadata.isFromExternalLibrary || declarationPath.includes("/node_modules/"));
-}
-async function createTypeRenderer(input) {
-	const { checker, program, emitter } = input;
-	const undefinedType = await checker.getUndefinedType();
-	const aliases = /* @__PURE__ */ new Map();
-	const rendered = [];
-	const visiting = /* @__PURE__ */ new Set();
-	const effectModules = /* @__PURE__ */ new Set();
-	const transportTypeNames = /* @__PURE__ */ new Set();
-	async function fail(type, reason) {
-		return Result.fail({
-			_tag: "UnrenderableContractType",
-			reason,
-			typeText: await 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`);
-		});
-	}
-	async function matchesReadonlyProperty(property) {
-		if ((property.checkFlags & CHECK_FLAG_READONLY) !== 0) return true;
-		const declaration = await 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;
-		});
-	}
-	async function renderTypeArguments(type, depth) {
-		const parts = [];
-		for (const argument of await checker.getTypeArguments(type)) {
-			const text = await renderNode(argument, depth);
-			if (Result.isFailure(text)) return text;
-			parts.push(text.success);
-		}
-		return Result.succeed(parts.length === 0 ? "" : `<${parts.join(", ")}>`);
-	}
-	async function renderNamedType(type, depth) {
-		const aliasSymbol = await type.getAliasSymbol();
-		const symbol = await 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 ? await type.getAliasTypeArguments() : type.isTypeReference() ? await checker.getTypeArguments(type) : [];
-				const parts = [];
-				for (const argument of argumentTypes) {
-					const text = await 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) && await matchesLibrarySymbol({
-			program,
-			symbol
-		})) {
-			const argumentsText = type.isTypeReference() ? await renderTypeArguments(type, depth) : Result.succeed("");
-			return Result.map(argumentsText, (text) => `${symbol.name}${text}`);
-		}
-		return Result.succeed(null);
-	}
-	async function renderProperty(input) {
-		if ((await checker.getSignaturesOfType(input.propertyType, SignatureKind.Call)).length > 0) return await 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 ? await renderOptionalType(input.propertyType, input.depth) : await renderNode(input.propertyType, input.depth);
-		if (Result.isFailure(text)) return text;
-		const readonly = await 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`. */
-	async function renderClassInstance(type, classSymbol, depth) {
-		const constructorType = await checker.getTypeOfSymbol(classSymbol);
-		const fields = constructorType === void 0 ? void 0 : await checker.getPropertyOfType(constructorType, "fields");
-		const fieldsType = fields === void 0 ? void 0 : await checker.getTypeOfSymbol(fields);
-		if (fieldsType === void 0) return await 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(await checker.getPropertiesOfType(fieldsType))) {
-			const property = await checker.getPropertyOfType(type, field.name);
-			const propertyType = property === void 0 ? void 0 : await checker.getTypeOfSymbol(property);
-			if (property === void 0 || propertyType === void 0) return await fail(type, `the class ${classSymbol.name} declares the field ${field.name} without a property of that name`);
-			const line = await 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"));
-	}
-	async function renderObject(type, depth) {
-		const symbol = await type.getSymbol();
-		if (symbol !== void 0 && (symbol.flags & SymbolFlags.Class) !== 0) return await renderClassInstance(type, symbol, depth);
-		if ((await checker.getSignaturesOfType(type, SignatureKind.Call)).length > 0 || (await checker.getSignaturesOfType(type, SignatureKind.Construct)).length > 0) return await fail(type, "a function cannot cross the wire");
-		const lines = [];
-		for (const property of sortProperties(await checker.getPropertiesOfType(type))) {
-			if (String(property.escapedName).startsWith("__@")) continue;
-			const propertyType = await checker.getTypeOfSymbol(property);
-			if (propertyType === void 0) return await fail(type, `the property ${property.name} has no type`);
-			const line = await renderProperty({
-				property,
-				propertyType,
-				depth: depth + 1
-			});
-			if (Result.isFailure(line)) return line;
-			lines.push(line.success);
-		}
-		for (const signature of await checker.getIndexInfosOfType(type)) {
-			const keyText = await renderNode(signature.keyType, depth + 1);
-			if (Result.isFailure(keyText)) return keyText;
-			const valueText = await 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"));
-	}
-	async function renderOptionalType(type, depth) {
-		const present = await withoutAbsence({
-			type,
-			undefinedType
-		});
-		return present === void 0 ? await renderNode(type, depth) : present.length === 1 && present[0] !== void 0 ? await renderNode(present[0], depth) : await renderUnion(present, depth, " | ");
-	}
-	async function renderTuple(type, depth) {
-		const target = await type.getTarget();
-		const members = [];
-		for (const [index, element] of (await checker.getTypeArguments(type)).entries()) {
-			const flags = target.elementFlags[index] ?? ElementFlags.Required;
-			const text = (flags & ElementFlags.Optional) !== 0 ? await renderOptionalType(element, depth) : await 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(", ")}]`);
-	}
-	async 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 = await 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. */
-	async function renderTemplateToken(node) {
-		return (await emitter.printNode(node)).replaceAll("\r", "\\r").replaceAll("\n", "\\n");
-	}
-	async function renderTemplateLiteral(type, depth) {
-		if (!type.isTemplateLiteralType()) return await fail(type, "not a template literal type");
-		const spans = [];
-		for (const span of await type.getTypes()) {
-			const text = await renderNode(span, depth);
-			if (Result.isFailure(text)) return text;
-			spans.push(text.success);
-		}
-		const [head, ...tail] = type.texts;
-		let text = await renderTemplateToken(createTemplateHead(head ?? "", "", TokenFlags.None));
-		for (const [index, span] of spans.entries()) {
-			const createLiteral = index === spans.length - 1 ? createTemplateTail : createTemplateMiddle;
-			text += span + await renderTemplateToken(createLiteral(tail[index] ?? "", "", TokenFlags.None));
-		}
-		return Result.succeed(text);
-	}
-	async 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 = await 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 : await renderTypeStructure(type, 0);
-		if (Result.isFailure(declared)) return declared;
-		rendered.push(`type ${createdAlias} = ${declared.success};`);
-		return Result.succeed(createdAlias);
-	}
-	async function renderTypeStructure(type, depth) {
-		if (type.isErrorType()) return await 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 = await 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 await renderTemplateLiteral(type, depth);
-		if (type.isUnionType()) return await renderUnion(await type.getTypes(), depth, " | ");
-		if (type.isIntersectionType()) return await renderUnion(await type.getTypes(), depth, " & ");
-		if (type.isTypeParameter()) return await fail(type, "a contract type cannot be generic");
-		if (!type.isObjectType()) return await fail(type, "the type has no wire form");
-		if (await checker.isArrayType(type) && type.isTypeReference()) {
-			const [element] = await checker.getTypeArguments(type);
-			if (element === void 0) return await fail(type, "an array type without an element type");
-			const text = await renderNode(element, depth);
-			if (Result.isFailure(text)) return text;
-			const wrapper = (await type.getSymbol())?.name === "ReadonlyArray" ? "ReadonlyArray" : "Array";
-			return Result.succeed(`${wrapper}<${text.success}>`);
-		}
-		if (await checker.isTupleType(type) && type.isTypeReference()) return await renderTuple(type, depth);
-		return await renderObject(type, depth);
-	}
-	return {
-		renderType: (input) => renderNode(input.type, input.depth),
-		renderAliases: () => rendered,
-		getEffectModules: () => [...effectModules].sort(),
-		getTransportTypeNames: () => transportTypeNames
-	};
-}
-//#endregion
-//#region src/build/resolve-config.ts
-/** The build excludes both projects' generated directories from application source. */
-function getGeneratedSourceDirectories(config) {
-	return [config.serverGeneratedDirectory, config.clientGeneratedDirectory];
-}
-/** Derives generated source, public assets, and build coordination from the tsconfig directories. */
-function getVormaOwnedPaths(input) {
-	const { path } = input;
-	const name = ARTIFACT_PROTOCOL.vormaDirectoryName;
-	const clientGeneratedDirectory = path.join(input.clientProjectDirectory, name);
-	const serverGeneratedDirectory = path.join(input.serverProjectDirectory, 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,
-		generatedRegistrationFilePath: path.join(serverGeneratedDirectory, ARTIFACT_PROTOCOL.registrationFileName),
-		generatedServerContractsFilePath: path.join(serverGeneratedDirectory, ARTIFACT_PROTOCOL.generatedServerContractsFileName)
-	};
-}
-/** 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 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,
-			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) },
-			publicAssetsBasePath: yield* Effect.fromResult(parsePublicAssetsBasePath(config.publicAssetsBasePath)),
-			bodySsr: config.bodySsr,
-			dev: config.dev,
-			...getVormaOwnedPaths({
-				path,
-				serverProjectDirectory: path.dirname(serverTsconfigFilePath),
-				clientProjectDirectory: path.dirname(clientTsconfigFilePath)
-			})
-		};
-	});
-}
-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/typescript-projects.ts
-/** Reads native project membership without loading programs or declaration types. */
-function readTypescriptProjectRoots(input) {
-	return withTypescriptApi({
-		configDirectory: input.configDirectory,
-		useFn: (api) => {
-			return runTypescriptOperation(async () => {
-				return {
-					server: (await api.parseConfigFile(input.serverTsconfigFilePath)).fileNames,
-					client: (await api.parseConfigFile(input.clientTsconfigFilePath)).fileNames
-				};
-			});
-		}
-	});
-}
-/** Checks actual compiler membership after generation, including restrictive files/include/exclude settings. */
-function checkGeneratedTypeInclusion(input) {
-	const serverFiles = input.serverFiles.filter((file) => !input.knownRootFiles?.server.has(normalizePath(file)));
-	const clientFiles = input.clientFiles.filter((file) => !input.knownRootFiles?.client.has(normalizePath(file)));
-	if (serverFiles.length === 0 && clientFiles.length === 0) return Effect.void;
-	return withTypescriptProjects({
-		...input,
-		useFn: (projects) => {
-			return Effect.gen(function* () {
-				const missing = yield* runTypescriptOperation(async () => {
-					const missing = [];
-					for (const [project, files, config] of [[
-						projects.server,
-						serverFiles,
-						input.serverTsconfigFilePath
-					], [
-						projects.client,
-						clientFiles,
-						input.clientTsconfigFilePath
-					]]) for (const file of files) if (await project.program.getSourceFileMetadata(file) === void 0) missing.push({
-						project: config,
-						file
-					});
-					return missing;
-				});
-				return yield* missing.length === 0 ? Effect.void : Effect.fail({
-					_tag: "TypescriptProjectError",
-					message: missing.map(({ project, file }) => `${project} does not include generated type file ${file}. Include the _vorma directory beside that tsconfig in its 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(runTypescriptOperation(() => {
-						return api.updateSnapshot({ openProjects: [input.serverTsconfigFilePath, input.clientTsconfigFilePath] });
-					}), (snapshot) => Effect.promise(() => snapshot.dispose())),
-					...input
-				});
-				if (Result.isFailure(projects)) return yield* Effect.fail(projects.failure);
-				const errors = (yield* runTypescriptOperation(() => {
-					return Promise.all([projects.success.server.program.getConfigFileParsingDiagnostics(), projects.success.client.program.getConfigFileParsingDiagnostics()]);
-				})).flat().filter((diagnostic) => {
-					return diagnostic.category === DiagnosticCategory.Error;
-				});
-				if (errors.length > 0) return yield* Effect.fail({
-					_tag: "TypescriptProjectError",
-					message: errors.map((error) => `${error.fileName}: TS${error.code}: ${error.text}`).join("\n")
-				});
-				return yield* input.useFn(projects.success);
-			}));
-		}
-	});
-}
-/** Native compiler operations have no cancellation API; settle each operation before its session can close. */
-function runTypescriptOperation(fn) {
-	return Effect.tryPromise({
-		try: fn,
-		catch: (cause) => {
-			return {
-				_tag: "TypescriptProjectError",
-				message: "Vorma could not read the application's TypeScript projects",
-				cause
-			};
-		}
-	}).pipe(Effect.uninterruptible);
-}
-function withTypescriptApi(input) {
-	return Effect.scoped(Effect.gen(function* () {
-		const api = yield* Effect.acquireRelease(runTypescriptOperation(async () => {
-			return new API({
-				cwd: input.configDirectory,
-				...input.fileSystem === void 0 ? {} : { fs: input.fileSystem }
-			});
-		}), (api) => Effect.promise(() => 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/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 = yield* runTypescriptOperation(() => {
-			return listOwnSourceFiles({
-				project: input.projects.server,
-				excludedDirectories,
-				path
-			});
-		});
-		const clientFiles = yield* runTypescriptOperation(() => {
-			return listOwnSourceFiles({
-				project: input.projects.client,
-				excludedDirectories,
-				path
-			});
-		});
-		const serverRenderer = yield* runTypescriptOperation(() => {
-			return createTypeRenderer({
-				checker: input.projects.server.checker,
-				program: input.projects.server.program,
-				emitter: input.projects.server.emitter
-			});
-		});
-		const serverDeclarations = yield* Effect.fromResult(yield* runTypescriptOperation(() => {
-			return inspectServerDeclarations({
-				checker: input.projects.server.checker,
-				program: input.projects.server.program,
-				files: serverFiles,
-				renderer: serverRenderer
-			});
-		}));
-		const client = yield* Effect.fromResult(yield* runTypescriptOperation(() => {
-			return 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. */
-async function listOwnSourceFiles(input) {
-	const { program } = input.project;
-	const files = [];
-	for (const fileName of await 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 = await program.getSourceFileMetadata(fileName);
-		if (metadata?.isDefaultLibrary || metadata?.isFromExternalLibrary) continue;
-		const sourceFile = await 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. */
-async function listModuleExports(input) {
-	const { checker, sourceFile } = input;
-	const moduleSymbol = await checker.getSymbolAtLocation(sourceFile);
-	if (moduleSymbol === void 0) return [];
-	const exports = [];
-	for (const exported of await checker.getExportsOfModule(moduleSymbol)) {
-		const symbol = (exported.flags & SymbolFlags.Alias) !== 0 ? await checker.getAliasedSymbol(exported) : exported;
-		if (await checker.isUnknownSymbol(symbol)) continue;
-		const type = await 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. */
-async function listRegistrationExports(input) {
-	const exports = /* @__PURE__ */ new Map();
-	for (const sourceFile of input.files) for (const moduleExport of await 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. */
-async function findPhantomProperty(input) {
-	const prefix = `__@${input.symbolName}@`;
-	return (await input.checker.getPropertiesOfType(input.type)).find((property) => String(property.escapedName).startsWith(prefix));
-}
-async function readPropertyType(input) {
-	const property = await input.checker.getPropertyOfType(input.type, input.name);
-	return property === void 0 ? void 0 : await input.checker.getTypeOfSymbol(property);
-}
-async function readLiteralProperty(input) {
-	const propertyType = await 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 ${await input.checker.typeToString(propertyType)}`);
-	return Result.succeed(propertyType.value);
-}
-function matchesUndefinedType(type) {
-	return type.isIntrinsicType() && type.intrinsicName === "undefined";
-}
-async function inspectServerDeclarations(input) {
-	const { checker, program, renderer } = input;
-	const declarations = [];
-	const candidates = [];
-	for (const { sourceFile, moduleExport } of await listRegistrationExports(input)) {
-		const source = {
-			filePath: sourceFile.fileName,
-			exportName: moduleExport.exportName
-		};
-		const phantom = await findPhantomProperty({
-			checker,
-			type: moduleExport.type,
-			symbolName: "DEFINITION_TYPES"
-		});
-		if (phantom === void 0) continue;
-		const tag = await readPropertyType({
-			checker,
-			type: moduleExport.type,
-			name: "_tag"
-		});
-		if (tag === void 0 || !tag.isStringLiteralType()) continue;
-		if (tag.value !== "UiLoader" && tag.value !== "Endpoint") continue;
-		const phantomType = await checker.getTypeOfSymbol(phantom);
-		const types = phantomType === void 0 ? void 0 : await checker.getNonNullableType(phantomType);
-		if (types === void 0) return Result.fail(makeIssue(source, "the definition carries no static types"));
-		const pattern = await readLiteralProperty({
-			checker,
-			type: moduleExport.type,
-			name: "pattern"
-		});
-		if (Result.isFailure(pattern)) return Result.fail(makeIssue(source, pattern.failure));
-		const method = await 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" ? await inspectUiLoader({
-			checker,
-			renderer,
-			source,
-			type,
-			types
-		}) : await 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}`
-	};
-}
-async function renderContract(input) {
-	return Result.mapError(await 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. */
-async function renderOptionalContract(input) {
-	const type = await readPropertyType({
-		checker: input.checker,
-		type: input.types,
-		name: input.field
-	});
-	if (type === void 0 || matchesUndefinedType(type)) return Result.succeed(void 0);
-	return await renderContract({
-		...input,
-		type
-	});
-}
-async function inspectUiLoader(input) {
-	const { checker, renderer, source } = input;
-	const pattern = await readLiteralProperty({
-		checker,
-		type: input.type,
-		name: "pattern"
-	});
-	if (Result.isFailure(pattern)) return Result.fail(makeIssue(source, pattern.failure));
-	const loaderInput = await renderOptionalContract({
-		checker,
-		renderer,
-		source,
-		field: "input",
-		types: input.types
-	});
-	if (Result.isFailure(loaderInput)) return Result.fail(loaderInput.failure);
-	const outputType = await 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 = await 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
-	});
-}
-async function inspectEndpoint(input) {
-	const { checker, program, renderer, source } = input;
-	const literals = {
-		kind: "",
-		method: "",
-		pattern: ""
-	};
-	for (const name of [
-		"kind",
-		"method",
-		"pattern"
-	]) {
-		const literal = await 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 !== "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 = await readPropertyType({
-		checker,
-		type: input.types,
-		name: "input"
-	});
-	const hasInput = inputType !== void 0 && !matchesUndefinedType(inputType);
-	const inputTransport = !hasInput ? "none" : method === "GET" ? "search" : await matchesFormInput({
-		checker,
-		program,
-		types: input.types
-	}) ? "formData" : "json";
-	const endpointInput = inputType === void 0 || !hasInput || inputTransport === "formData" ? Result.succeed(void 0) : await renderContract({
-		renderer,
-		source,
-		field: "input",
-		type: inputType
-	});
-	if (Result.isFailure(endpointInput)) return Result.fail(endpointInput.failure);
-	const outputType = await readPropertyType({
-		checker,
-		type: input.types,
-		name: "output"
-	});
-	if (outputType === void 0) return Result.fail(makeIssue(source, "an endpoint must have an output contract"));
-	const output = await renderContract({
-		renderer,
-		source,
-		field: "output",
-		type: outputType
-	});
-	if (Result.isFailure(output)) return Result.fail(output.failure);
-	const errors = await 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,
-		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.
-*/
-async function matchesFormInput(input) {
-	const symbol = await (await 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));
-	}) && await matchesLibrarySymbol({
-		program: input.program,
-		symbol
-	});
-}
-/** Each declared error: its decoded `_tag` and transportable schema fields. */
-async function inspectEndpointErrors(input) {
-	const { checker, renderer, source } = input;
-	const errorsType = await readPropertyType({
-		checker,
-		type: input.types,
-		name: "errors"
-	});
-	if (errorsType === void 0) return Result.succeed([]);
-	const numberType = await checker.getNumberType();
-	const elementType = (await checker.getIndexInfosOfType(errorsType)).find((index) => {
-		return index.keyType.id === numberType.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() ? await elementType.getTypes() : [elementType];
-	for (const element of elements) {
-		if (element.isIntrinsicType() && element.intrinsicName === "never") continue;
-		const schemaType = await readPropertyType({
-			checker,
-			type: element,
-			name: "schema"
-		});
-		const decodedType = schemaType === void 0 ? void 0 : await 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() ? await decodedType.getTypes() : [decodedType];
-		for (const variant of variants) {
-			const tag = await 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 = await 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);
-}
-async 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 await listRegistrationExports(input)) {
-		const source = {
-			filePath: sourceFile.fileName,
-			exportName: moduleExport.exportName
-		};
-		if (await findPhantomProperty({
-			checker,
-			type: moduleExport.type,
-			symbolName: "UI_VIEW_TYPES"
-		}) !== void 0) {
-			const pattern = await 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 await listModuleExports({
-				checker,
-				sourceFile
-			})) if (await findPhantomProperty({
-				checker,
-				type: moduleExport.type,
-				symbolName: "CLIENT_APPLICATION_TYPES"
-			}) !== void 0) applications.set(moduleExport.symbol.id, {
-				filePath: sourceFile.fileName,
-				exportName: moduleExport.exportName
-			});
-		}
-		const sites = await 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. */
-async function matchesPublicUrlSymbol(input) {
-	const symbol = (input.symbol.flags & SymbolFlags.Alias) !== 0 ? await input.checker.getAliasedSymbol(input.symbol) : input.symbol;
-	if (symbol.name !== "getPublicUrl") return false;
-	return (await symbol.getJsDocTags(input.checker)).some((tag) => tag.name === "vormaPublicAsset");
-}
-/** 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. */
-async 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}`
-			};
-		}
-	}
-	async 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) ? await getElementAccessSymbol({
-				checker,
-				node
-			}) : await checker.getSymbolAtLocation(node);
-			if (symbol !== void 0 && await 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;
-			}
-		}
-		const children = [];
-		node.forEachChild((child) => {
-			children.push(child);
-		});
-		for (const child of children) await visit(child);
-	}
-	await 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;
-}
-async function getElementAccessSymbol(input) {
-	const objectType = await input.checker.getTypeAtLocation(input.node.expression);
-	const keyType = await input.checker.getTypeAtLocation(input.node.argumentExpression);
-	return objectType !== void 0 && keyType?.isStringLiteralType() ? await input.checker.getPropertyOfType(objectType, keyType.value) : void 0;
-}
-//#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
-		});
-	}
-	for (const [pattern, sources] of viewSources) if (sources.length > 1) issues.push({
-		_tag: "DuplicateClientView",
-		pattern,
-		sources
-	});
-	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)),
-		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
-/** 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) => {
-				const specifier = moduleImport.specifier.split("/").map(encodeURIComponent).join("/");
-				return `import * as ${moduleImport.identifier} from ${JSON.stringify(specifier)};`;
-			}),
-			"",
-			"/** Every registerable declaration that the server project exports, in source order. */",
-			...input.declarations.length === 0 ? ["export const registeredDeclarations = [];"] : [
-				"export const registeredDeclarations = [",
-				...input.declarations.map((declaration) => {
-					return `\t${modules.getIdentifier(declaration.filePath)}[${JSON.stringify(declaration.exportName)}],`;
-				}),
-				"];"
-			],
-			""
-		].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,
-			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 function getTransportTypeEntries(): ReadonlyArray<TransportTypeEntry> {",
-			`  return [${entries.join(", ")}];`,
-			"}",
-			""
-		].join("\n")
-	};
-}
-//#endregion
-//#region src/build/generate-application.ts
-/** Writes correlated generated sources and verifies their native TypeScript inclusion. */
-function writeAndCheckApplicationGeneration(generation, knownRootFiles) {
-	return Effect.gen(function* () {
-		yield* Effect.all([writeApplicationGeneration(generation), writeGeneratedServerApplication({ generation })], {
-			concurrency: 2,
-			discard: true
-		});
-		yield* checkGeneratedTypeInclusion({
-			...generation.config,
-			...knownRootFiles === void 0 ? {} : { knownRootFiles },
-			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.generatedRegistrationFilePath,
-		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|\.mjs)$/;
-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 application startup.
-*/
-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,
-			filePath: config.generatedRegistrationFilePath,
-			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 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;
-		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
-		};
-	}).pipe(Effect.mapError((cause) => {
-		return {
-			_tag: "ArtifactPublicationIssue",
-			cause
-		};
-	}));
-}
-//#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 = {
-			serverRootDirectory: {
-				field: "serverTsconfigFile",
-				path: path.dirname(config.serverTsconfigFilePath),
-				expectedType: "Directory"
-			},
-			clientRootDirectory: {
-				field: "clientTsconfigFile",
-				path: path.dirname(config.clientTsconfigFilePath),
-				expectedType: "Directory"
-			},
-			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 { serverRootDirectory, clientRootDirectory, criticalCssEntryFilePath, ...canonical } = canonicalPaths.success;
-		if (serverRootDirectory === clientRootDirectory) return yield* Effect.fail({
-			_tag: "ApplicationSourceLayoutIssues",
-			issues: [{
-				field: "clientTsconfigFile",
-				path: config.clientTsconfigFilePath,
-				expectedType: "File",
-				message: `serverTsconfigFile and clientTsconfigFile must be in different directories. Both project roots resolve to ${serverRootDirectory} and would share the same _vorma output.`
-			}]
-		});
-		const canonicalConfig = {
-			...config,
-			...canonical,
-			serverProjectDirectory: path.dirname(canonical.serverTsconfigFilePath),
-			...criticalCssEntryFilePath === void 0 ? {} : { criticalCssEntryFilePath }
-		};
-		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),
-				exportName: module.exportName
-			}];
-		}));
-		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,
-				exportName: view.exportName
-			}]);
-		}).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();
-	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) {
-			return source === FRAMEWORK_IDENTITY_PROTOCOL.moduleSpecifiers.clientTransportTypes ? generation.clientTransport.filePath : 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);
-		return yield* publishApplicationArtifacts({
-			generation,
-			artifacts: yield* assembleApplicationArtifacts({
-				generation,
-				client: yield* bundleClient(generation)
-			})
-		});
-	}));
-}
-//#endregion
-export { projectBrowserContracts as C, getClientViewEntries as S, createCssPublicAssets as _, acquireOutputOwnership as a, toContentDigest as b, writeAndCheckApplicationGeneration as c, readTypescriptProjectRoots as d, runTypescriptOperation as f, containsRelativePath as g, resolveVormaConfig as h, publishApplicationArtifacts as i, collectPublicAssets as l, getGeneratedSourceDirectories as m, loadApplicationSourceLayout as n, checkOutputPath as o, withTypescriptProjects as p, preparePublicOutput as r, assembleApplicationGeneration as s, buildApplication as t, inspectProjects as u, createClientPublicUrlPlugin as v, CLIENT_SHARED_PACKAGES as x, encodeCanonicalJson as y };