@sjcx/vorma 0.0.0-pre.0

package/dist/compile-Me8EOyMK.js

@@ -0,0 +1,870 @@
+import { c as compileUiPattern, p as makeNullPrototypeRecord, s as compileEndpointPattern, t as EFFECT_TRANSPORT_TYPES, v as FRAMEWORK_ERROR_TAGS } from "./value-transport-Bst4Hk-n.js";
+import { Result, Schema, SchemaAST, SchemaRepresentation } from "effect";
+import * as NativeHttpMethod from "effect/unstable/http/HttpMethod";
+import { Multipart } from "effect/unstable/http";
+//#region src/universal/http-method.ts
+function matchesHttpMethod(method) {
+	return NativeHttpMethod.isHttpMethod(method) && method !== "HEAD" && method !== "TRACE";
+}
+//#endregion
+//#region src/server/form-data.ts
+const FORM_DATA_IDENTIFIER = "vorma/server/FormData";
+/** Marks an endpoint's form transport; handlers receive Effect's parsed form record. */
+const FormData = Schema.Record(Schema.String, Schema.Union([
+	Schema.String,
+	Schema.Array(Schema.String),
+	Multipart.FilesSchema
+])).annotate({ identifier: FORM_DATA_IDENTIFIER });
+/** The schema at the end of an encoding chain: the form the wire carries. */
+function getEncodedLeaf(ast) {
+	let leaf = ast;
+	let encoding = leaf.encoding;
+	while (encoding !== void 0) {
+		for (const link of encoding) leaf = link.to;
+		encoding = leaf.encoding;
+	}
+	return leaf;
+}
+/**
+* Whether an input schema reads the request's form data. `FormData` and
+* every schema derived from it, such as `FormData.pipe(Schema.decodeTo(...))`,
+* encode to the native form record at the end of their chain, which
+* carries this module's identifier.
+*/
+function matchesFormInput(schema) {
+	return getEncodedLeaf(schema.ast).annotations?.["identifier"] === FORM_DATA_IDENTIFIER;
+}
+//#endregion
+//#region src/server/graph/declarations.ts
+function getInputTransport(declaration) {
+	if (declaration.input === void 0) return { kind: "none" };
+	if (declaration.method === "GET") return {
+		kind: "search",
+		schema: declaration.input
+	};
+	return matchesFormInput(declaration.input) ? {
+		kind: "formData",
+		schema: declaration.input
+	} : {
+		kind: "json",
+		schema: declaration.input
+	};
+}
+//#endregion
+//#region src/server/graph/literal-error-tag.ts
+/**
+* The literal tag a schema discriminates on, when it carries exactly one
+* usable one. A `_tag` field wins when several string literals are present,
+* which is the `Schema.TaggedError` shape; anything else ambiguous, and a
+* schema with no required string literal, has no static tag. Runtime matching
+* validates values against the declared schemas, so this is only the static
+* identity the build checks and the envelope carries.
+*/
+function getLiteralErrorTag(schema) {
+	const ast = schema.ast;
+	const nodes = ast._tag === "Declaration" ? ast.typeParameters : [ast];
+	const literals = [];
+	for (const node of nodes) {
+		if (node._tag !== "Objects") continue;
+		for (const property of node.propertySignatures) {
+			if (typeof property.name === "symbol") continue;
+			if (property.type.context?.isOptional === true) continue;
+			if (property.type._tag === "Literal" && typeof property.type.literal === "string") literals.push({
+				field: String(property.name),
+				tag: property.type.literal
+			});
+		}
+	}
+	if (literals.length === 1) return literals[0];
+	return literals.find((literal) => literal.field === "_tag");
+}
+//#endregion
+//#region src/server/graph/pattern-conflicts.ts
+function createPatternConflictIndex() {
+	return {
+		staticBranches: /* @__PURE__ */ new Map(),
+		dynamicBranch: void 0
+	};
+}
+/** Attributes each shared dynamic-branch name clash to the authored pattern identities that produce it. */
+function findConflictingDynamicParameterNames(input) {
+	const root = createPatternConflictIndex();
+	const seenMatcherPatterns = /* @__PURE__ */ new Set();
+	const conflicts = [];
+	for (const pattern of input.patterns) {
+		const matcherPattern = input.getMatcherPattern(pattern);
+		if (seenMatcherPatterns.has(matcherPattern)) continue;
+		let index = root;
+		const dynamicBranches = [];
+		let rejected = false;
+		for (const segment of input.getSegments(pattern)) {
+			if (segment.kind === "splat" || segment.kind === "index") break;
+			if (segment.kind === "static") {
+				let branch = index.staticBranches.get(segment.value);
+				if (branch === void 0) {
+					branch = createPatternConflictIndex();
+					index.staticBranches.set(segment.value, branch);
+				}
+				index = branch;
+				continue;
+			}
+			let branch = index.dynamicBranch;
+			if (branch === void 0) {
+				branch = {
+					parameterName: segment.parameterName,
+					patterns: [],
+					next: createPatternConflictIndex()
+				};
+				index.dynamicBranch = branch;
+			} else if (branch.parameterName !== segment.parameterName) {
+				conflicts.push({
+					patterns: [...branch.patterns, pattern],
+					attemptedPattern: pattern,
+					cause: input.makeCause({
+						conflict: {
+							existingParameterName: branch.parameterName,
+							attemptedParameterName: segment.parameterName
+						},
+						attemptedPattern: pattern
+					})
+				});
+				rejected = true;
+				break;
+			}
+			dynamicBranches.push(branch);
+			index = branch.next;
+		}
+		if (rejected) continue;
+		for (const branch of dynamicBranches) branch.patterns.push(pattern);
+		seenMatcherPatterns.add(matcherPattern);
+	}
+	return conflicts;
+}
+//#endregion
+//#region src/server/graph/search-schema.ts
+const SCALAR_DECLARATIONS = /* @__PURE__ */ new Map([
+	["effect/schema/Date", "date"],
+	["effect/schema/URL", "url"],
+	["effect/schema/URLSearchParams", "url-search-params"],
+	["effect/schema/RegExp", "regexp"]
+]);
+const EFFECT_KIND_BY_DECLARATION_ID = new Map(EFFECT_TRANSPORT_TYPES.map((type) => [type.representationId, type.name]));
+function deriveSearchContract(schema) {
+	const ast = schema.ast;
+	if (ast._tag !== "Objects") return failUnsupported({
+		path: "",
+		reason: "the search schema root must be a structural object; transformations belong on its fields"
+	});
+	const live = SchemaRepresentation.toRepresentation(SchemaAST.toType(ast));
+	return Result.map(projectNode({
+		node: live.representation,
+		references: live.references,
+		path: "",
+		visiting: /* @__PURE__ */ new Set()
+	}), (document) => {
+		return {
+			document,
+			fields: new Set(ast.propertySignatures.map((property) => String(property.name)))
+		};
+	});
+}
+function projectNode(input) {
+	if (input.visiting.has(input.node)) return failUnsupported({
+		path: input.path,
+		reason: "recursive schemas cannot be search parameters"
+	});
+	input.visiting.add(input.node);
+	const result = projectKnown(input);
+	input.visiting.delete(input.node);
+	return result;
+}
+function projectKnown(input) {
+	const { node, path } = input;
+	function child(node, childPath = path) {
+		return projectNode({
+			...input,
+			node,
+			path: childPath
+		});
+	}
+	switch (node._tag) {
+		case "Reference": {
+			const target = input.references[node.$ref];
+			return target === void 0 ? failUnsupported({
+				path,
+				reason: "the schema has a missing reference"
+			}) : child(target);
+		}
+		case "Suspend": return child(node.thunk);
+		case "String":
+		case "TemplateLiteral": return Result.succeed({
+			kind: "scalar",
+			type: "string"
+		});
+		case "Number": return Result.succeed({
+			kind: "scalar",
+			type: "number"
+		});
+		case "Boolean": return Result.succeed({
+			kind: "scalar",
+			type: "boolean"
+		});
+		case "BigInt": return Result.succeed({
+			kind: "scalar",
+			type: "bigint"
+		});
+		case "Literal": return typeof node.literal === "string" ? Result.succeed({
+			kind: "scalar",
+			type: "string",
+			values: [node.literal]
+		}) : failUnsupported({
+			path,
+			reason: "only string literals can be search parameters"
+		});
+		case "Enum": {
+			const values = node.enums.map(([, value]) => value);
+			return values.every((value) => typeof value === "string") ? Result.succeed({
+				kind: "scalar",
+				type: "string",
+				values
+			}) : failUnsupported({
+				path,
+				reason: "only string enums can be search parameters"
+			});
+		}
+		case "Union": {
+			const carried = node.types.filter((member) => member._tag !== "Undefined" && member._tag !== "Null");
+			const first = carried[0];
+			if (first === void 0) return failUnsupported({
+				path,
+				reason: "a union of only null and undefined carries nothing"
+			});
+			const values = [];
+			if (carried.length > 1) for (const member of carried) {
+				if (member._tag !== "Literal" || typeof member.literal !== "string") return failUnsupported({
+					path,
+					reason: "unions other than string literal enums cannot be search parameters"
+				});
+				values.push(member.literal);
+			}
+			const shape = carried.length === 1 ? child(first) : Result.succeed({
+				kind: "scalar",
+				type: "string",
+				values
+			});
+			return Result.map(shape, (value) => {
+				return {
+					...value,
+					...node.types.some((member) => member._tag === "Undefined") ? { optional: true } : {},
+					...node.types.some((member) => member._tag === "Null") ? { nullable: true } : {}
+				};
+			});
+		}
+		case "Arrays": {
+			const [item, ...more] = node.rest;
+			if (node.elements.length !== 0 || item === void 0 || more.length !== 0) return failUnsupported({
+				path,
+				reason: "only homogeneous arrays can be search parameters"
+			});
+			return Result.flatMap(child(item), (shape) => {
+				return Result.map(toScalar(shape, path), (item) => {
+					return {
+						kind: "array",
+						collection: "array",
+						item
+					};
+				});
+			});
+		}
+		case "Objects": {
+			const [index, ...more] = node.indexSignatures;
+			if (index !== void 0) {
+				if (node.propertySignatures.length !== 0 || more.length !== 0) return failUnsupported({
+					path,
+					reason: "a map cannot also have named fields"
+				});
+				return projectRecord({
+					...input,
+					key: index.parameter,
+					value: index.type,
+					collection: "record"
+				});
+			}
+			const fields = makeNullPrototypeRecord();
+			for (const property of node.propertySignatures) {
+				if (typeof property.name !== "string") return failUnsupported({
+					path,
+					reason: "field names must be strings"
+				});
+				const projected = child(property.type, path === "" ? property.name : `${path}.${property.name}`);
+				if (Result.isFailure(projected)) return projected;
+				fields[property.name] = property.isOptional ? {
+					...projected.success,
+					optional: true
+				} : projected.success;
+			}
+			return Result.succeed({
+				kind: "object",
+				fields
+			});
+		}
+		case "Declaration": return projectDeclaration(input, node);
+		default: return failUnsupported({
+			path,
+			reason: `${node._tag} has no URL spelling`
+		});
+	}
+}
+function projectDeclaration(input, node) {
+	const { path } = input;
+	const id = node.representation?.id;
+	const effectKind = id === void 0 ? void 0 : EFFECT_KIND_BY_DECLARATION_ID.get(id);
+	const type = (id === void 0 ? void 0 : SCALAR_DECLARATIONS.get(id)) ?? (effectKind === "duration" || effectKind === "big-decimal" || effectKind === "date-time-utc" || effectKind === "date-time-zoned" ? effectKind : void 0);
+	if (type !== void 0) return node.typeParameters.length === 0 ? Result.succeed({
+		kind: "scalar",
+		type
+	}) : failUnsupported({
+		path,
+		reason: `${id} has unexpected type parameters`
+	});
+	if (id === "effect/schema/ReadonlyMap" || effectKind === "hash-map") {
+		const [key, value, ...more] = node.typeParameters;
+		return key === void 0 || value === void 0 || more.length !== 0 ? failUnsupported({
+			path,
+			reason: `${id} needs key and value types`
+		}) : projectRecord({
+			...input,
+			key,
+			value,
+			collection: effectKind === "hash-map" ? "hash-map" : "map"
+		});
+	}
+	if (effectKind === "option" || effectKind === "redacted" || effectKind === "chunk" || effectKind === "hash-set" || id === "effect/schema/ReadonlySet") {
+		const [parameter, ...more] = node.typeParameters;
+		if (parameter === void 0 || more.length !== 0) return failUnsupported({
+			path,
+			reason: `${id} needs one value type`
+		});
+		return Result.flatMap(projectNode({
+			...input,
+			node: parameter
+		}), (value) => {
+			if (effectKind === "option") return Result.succeed({
+				kind: "option",
+				value
+			});
+			if (effectKind === "redacted") {
+				const payload = node.representation?.payload;
+				const label = payload !== null && typeof payload === "object" && "label" in payload ? payload["label"] : void 0;
+				if (label !== void 0 && typeof label !== "string") return failUnsupported({
+					path,
+					reason: "a Redacted label must be a string"
+				});
+				return Result.succeed({
+					kind: "redacted",
+					value,
+					...label === void 0 ? {} : { label }
+				});
+			}
+			return Result.map(toScalar(value, path), (item) => {
+				return {
+					kind: "array",
+					collection: effectKind === "chunk" || effectKind === "hash-set" ? effectKind : "set",
+					item
+				};
+			});
+		});
+	}
+	return failUnsupported({
+		path,
+		reason: `the declaration ${id ?? "without a representation identity"} has no URL spelling`
+	});
+}
+function projectRecord(input) {
+	const key = projectNode({
+		...input,
+		node: input.key
+	});
+	if (Result.isFailure(key)) return key;
+	if (key.success.kind !== "scalar" || key.success.type !== "string" || key.success.nullable || key.success.optional) return failUnsupported({
+		path: input.path,
+		reason: "record and map keys must be strings or string enums"
+	});
+	const keyShape = key.success;
+	return Result.map(projectNode({
+		...input,
+		node: input.value,
+		path: `${input.path}.*`
+	}), (value) => {
+		return {
+			kind: "record",
+			collection: input.collection,
+			key: keyShape,
+			value
+		};
+	});
+}
+function toScalar(shape, path) {
+	return shape.kind === "scalar" ? Result.succeed(shape) : failUnsupported({
+		path,
+		reason: "array and set items must have one scalar URL spelling"
+	});
+}
+function failUnsupported(input) {
+	return Result.fail({
+		_tag: "UnsupportedSearchSchema",
+		...input
+	});
+}
+//#endregion
+//#region src/server/graph/transport-schema.ts
+/** The representation identities of the declarations the transport carries by value. */
+const VOCABULARY_REPRESENTATION_IDS = /* @__PURE__ */ new Set([
+	"effect/schema/Date",
+	"effect/schema/URL",
+	"effect/schema/URLSearchParams",
+	"effect/schema/RegExp"
+]);
+/** Declarations whose type parameters are the member types the transport walks. */
+const COLLECTION_REPRESENTATION_IDS = /* @__PURE__ */ new Set(["effect/schema/ReadonlyMap", "effect/schema/ReadonlySet"]);
+const EFFECT_TRANSPORT_REPRESENTATION_IDS = new Set(EFFECT_TRANSPORT_TYPES.map((type) => type.representationId));
+function checkTransportSchema$1(input) {
+	const root = SchemaAST.toType(input.schema.ast);
+	const pending = input.allowClassRoot && root._tag === "Declaration" ? root.typeParameters.map((ast) => {
+		return {
+			ast,
+			path: ""
+		};
+	}) : [{
+		ast: root,
+		path: ""
+	}];
+	const visited = /* @__PURE__ */ new Set();
+	for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
+		const { ast, path } = next;
+		if (visited.has(ast)) continue;
+		visited.add(ast);
+		switch (ast._tag) {
+			case "Null":
+			case "Undefined":
+			case "Void":
+			case "String":
+			case "Number":
+			case "Boolean":
+			case "BigInt":
+			case "Literal":
+			case "Enum":
+			case "TemplateLiteral":
+			case "Never": break;
+			case "Declaration": {
+				const id = readRepresentationId(ast);
+				if (id !== void 0 && EFFECT_TRANSPORT_REPRESENTATION_IDS.has(id)) {
+					for (const parameter of ast.typeParameters) pending.push({
+						ast: parameter,
+						path
+					});
+					break;
+				}
+				if (id !== void 0 && VOCABULARY_REPRESENTATION_IDS.has(id)) break;
+				if (id !== void 0 && COLLECTION_REPRESENTATION_IDS.has(id)) {
+					for (const parameter of ast.typeParameters) pending.push({
+						ast: parameter,
+						path
+					});
+					break;
+				}
+				return refuseAt(path, "a class or an opaque declaration has no wire form; declare the value's structure");
+			}
+			case "Suspend":
+				pending.push({
+					ast: ast.thunk(),
+					path
+				});
+				break;
+			case "Union":
+				for (const member of ast.types) pending.push({
+					ast: member,
+					path
+				});
+				break;
+			case "Arrays":
+				for (const [index, element] of ast.elements.entries()) pending.push({
+					ast: element,
+					path: `${path}[${index}]`
+				});
+				for (const rest of ast.rest) pending.push({
+					ast: rest,
+					path: `${path}[]`
+				});
+				break;
+			case "Objects":
+				for (const property of ast.propertySignatures) {
+					if (typeof property.name === "symbol") return refuseAt(path, "a symbol-keyed property has no wire form");
+					const name = String(property.name);
+					pending.push({
+						ast: property.type,
+						path: path === "" ? name : `${path}.${name}`
+					});
+				}
+				for (const signature of ast.indexSignatures) {
+					if (!matchesStringKey(signature.parameter)) return refuseAt(path, "an index signature must be keyed by strings");
+					pending.push({
+						ast: signature.type,
+						path: `${path}[*]`
+					});
+				}
+				break;
+			case "Unknown":
+			case "Any":
+			case "ObjectKeyword":
+			case "Symbol":
+			case "UniqueSymbol": return refuseAt(path, `${ast._tag} leaves the value's structure open; declare it`);
+		}
+	}
+	return Result.succeed(void 0);
+}
+function refuseAt(path, reason) {
+	return Result.fail({
+		_tag: "UntransportableSchema",
+		path,
+		reason
+	});
+}
+function matchesStringKey(ast) {
+	return ast._tag === "String" || ast._tag === "TemplateLiteral" || ast._tag === "Literal" && typeof ast.literal === "string";
+}
+function readRepresentationId(ast) {
+	const representation = ast.annotations?.["representation"];
+	return typeof representation === "object" && representation !== null && "id" in representation && typeof representation.id === "string" ? representation.id : void 0;
+}
+//#endregion
+//#region src/server/graph/compile.ts
+function compileUiLoader(declaration, errors) {
+	const registered = compileUiPattern(declaration.pattern);
+	if (Result.isFailure(registered)) {
+		errors.push({
+			_tag: "InvalidPattern",
+			role: "uiLoader",
+			pattern: declaration.pattern,
+			cause: registered.failure
+		});
+		return null;
+	}
+	let search = null;
+	if (declaration.input !== void 0) {
+		const derived = deriveSearchContract(declaration.input);
+		if (Result.isFailure(derived)) errors.push({
+			_tag: "UnsupportedSearchSchema",
+			role: "uiLoader",
+			pattern: declaration.pattern,
+			path: derived.failure.path,
+			reason: derived.failure.reason
+		});
+		else search = {
+			schema: declaration.input,
+			...derived.success
+		};
+	}
+	checkTransportSchema({
+		schema: declaration.output,
+		role: "uiLoader",
+		pattern: declaration.pattern,
+		field: "output",
+		errors
+	});
+	return {
+		declaration,
+		registered: registered.success,
+		search
+	};
+}
+function compileEndpoint(declaration, errors) {
+	if (!(declaration.kind === "stream" ? declaration.method === "GET" : matchesHttpMethod(declaration.method))) {
+		errors.push({
+			_tag: "InvalidEndpointMethod",
+			pattern: declaration.pattern,
+			method: String(declaration.method),
+			kind: declaration.kind
+		});
+		return null;
+	}
+	const registered = compileEndpointPattern(declaration.pattern);
+	if (Result.isFailure(registered)) {
+		errors.push({
+			_tag: "InvalidPattern",
+			role: "endpoint",
+			pattern: declaration.pattern,
+			cause: registered.failure
+		});
+		return null;
+	}
+	const transport = getInputTransport(declaration);
+	if (transport.kind === "json") checkTransportSchema({
+		schema: transport.schema,
+		role: "endpoint",
+		pattern: declaration.pattern,
+		field: "input",
+		errors
+	});
+	if (declaration.output !== void 0) checkTransportSchema({
+		schema: declaration.output,
+		role: "endpoint",
+		pattern: declaration.pattern,
+		field: "output",
+		errors
+	});
+	if (declaration.event !== void 0) checkTransportSchema({
+		schema: declaration.event,
+		role: "endpoint",
+		pattern: declaration.pattern,
+		field: "event",
+		errors
+	});
+	checkEndpointErrors(declaration, errors);
+	let search = null;
+	if (declaration.method === "GET" && declaration.input !== void 0) {
+		const derived = deriveSearchContract(declaration.input);
+		if (Result.isFailure(derived)) errors.push({
+			_tag: "UnsupportedSearchSchema",
+			role: "endpoint",
+			pattern: declaration.pattern,
+			path: derived.failure.path,
+			reason: derived.failure.reason
+		});
+		else search = {
+			schema: declaration.input,
+			document: derived.success.document
+		};
+	}
+	return {
+		declaration,
+		registered: registered.success,
+		search
+	};
+}
+function compileMiddleware(declaration, index, errors) {
+	let ok = true;
+	if (declaration.patterns.length === 0) {
+		errors.push({
+			_tag: "EmptyMiddlewareSelector",
+			index,
+			field: "patterns"
+		});
+		ok = false;
+	}
+	if (declaration.methods.length === 0) {
+		errors.push({
+			_tag: "EmptyMiddlewareSelector",
+			index,
+			field: "methods"
+		});
+		ok = false;
+	}
+	const registered = [];
+	const patternIdentities = [];
+	for (const pattern of declaration.patterns) {
+		const result = compileEndpointPattern(pattern);
+		if (Result.isFailure(result)) {
+			errors.push({
+				_tag: "InvalidPattern",
+				role: "middleware",
+				pattern,
+				cause: result.failure
+			});
+			ok = false;
+		} else {
+			registered.push(result.success);
+			patternIdentities.push({
+				authoredPattern: pattern,
+				registered: result.success
+			});
+		}
+	}
+	for (const conflict of findFlatPatternRegistrationConflicts(patternIdentities)) {
+		errors.push({
+			_tag: "ConflictingMiddlewareParameters",
+			index,
+			patterns: conflict.patterns,
+			cause: conflict.cause
+		});
+		ok = false;
+	}
+	return ok ? {
+		declaration,
+		registered
+	} : null;
+}
+/** Groups endpoint nodes by method, preserving declaration order within each method. */
+function groupEndpointsByMethod(endpoints) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const endpoint of endpoints) {
+		const method = endpoint.declaration.method;
+		const entries = grouped.get(method);
+		if (entries === void 0) grouped.set(method, [endpoint]);
+		else entries.push(endpoint);
+	}
+	return grouped;
+}
+function checkEndpointPatternRegistrations(endpoints, errors) {
+	for (const [method, entries] of groupEndpointsByMethod(endpoints)) {
+		const conflicts = findFlatPatternRegistrationConflicts(entries.map((entry) => {
+			return {
+				authoredPattern: entry.declaration.pattern,
+				registered: entry.registered
+			};
+		}));
+		for (const conflict of conflicts) errors.push({
+			_tag: "ConflictingEndpointParameters",
+			method,
+			patterns: conflict.patterns,
+			cause: conflict.cause
+		});
+	}
+}
+function findFlatPatternRegistrationConflicts(patterns) {
+	return findConflictingDynamicParameterNames({
+		patterns,
+		getMatcherPattern: (pattern) => pattern.registered.pattern,
+		getSegments: (pattern) => pattern.registered.segments,
+		makeCause: ({ conflict, attemptedPattern }) => {
+			return {
+				_tag: "ConflictingDynamicParameterName",
+				...conflict,
+				pattern: attemptedPattern.authoredPattern
+			};
+		}
+	}).map((conflict) => {
+		return {
+			patterns: conflict.patterns.map((pattern) => pattern.authoredPattern),
+			cause: conflict.cause
+		};
+	});
+}
+/** Materializes each target's registered outer-to-inner route chain in time proportional to route depth. */
+function createNestedRouteChains(input) {
+	const branches = /* @__PURE__ */ new Map();
+	const exact = new Map(input.nodes.map((node) => [node.registered.pattern, node]));
+	for (const node of input.nodes) {
+		const terminal = node.registered.segments.at(-1)?.kind;
+		if (terminal !== "index" && terminal !== "splat") branches.set(getNestedRoutePathKey(node.registered.segments), node);
+	}
+	return input.nodes.map((target) => {
+		const consumingSegments = target.registered.segments.filter((segment) => segment.kind !== "index" && segment.kind !== "splat");
+		const chain = [];
+		for (let depth = 0; depth <= consumingSegments.length; depth++) {
+			const branch = branches.get(getNestedRoutePathKey(consumingSegments.slice(0, depth)));
+			if (branch !== void 0) chain.push(branch);
+		}
+		const terminal = target.registered.segments.at(-1)?.kind;
+		if (terminal === "index" || terminal === "splat") {
+			const leaf = exact.get(target.registered.pattern);
+			if (leaf !== void 0) chain.push(leaf);
+		}
+		return {
+			target,
+			chain
+		};
+	});
+}
+function getNestedRoutePathKey(segments) {
+	return JSON.stringify(segments.map((segment) => {
+		return segment.kind === "static" ? ["static", segment.value] : segment.kind === "dynamic" ? ["dynamic", segment.parameterName] : [segment.kind];
+	}));
+}
+function checkDuplicates(uiLoaders, endpoints, errors) {
+	reportDuplicateRegistrations({
+		nodes: uiLoaders,
+		readKeyFn: (node) => node.registered.pattern,
+		makeErrorFn: (node) => {
+			return {
+				_tag: "DuplicateUiLoader",
+				pattern: node.declaration.pattern
+			};
+		},
+		errors
+	});
+	reportDuplicateRegistrations({
+		nodes: endpoints,
+		readKeyFn: (node) => {
+			return `${node.declaration.method} ${node.registered.pattern}`;
+		},
+		makeErrorFn: (node) => {
+			return {
+				_tag: "DuplicateEndpoint",
+				method: node.declaration.method,
+				pattern: node.declaration.pattern
+			};
+		},
+		errors
+	});
+}
+function reportDuplicateRegistrations(input) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const node of input.nodes) {
+		const key = input.readKeyFn(node);
+		if (seen.has(key)) input.errors.push(input.makeErrorFn(node));
+		seen.add(key);
+	}
+}
+/** Declared error entries need transport structure, a real error status, and distinct usable tags. */
+function checkEndpointErrors(declaration, errors) {
+	const tags = /* @__PURE__ */ new Set();
+	for (const [index, entry] of declaration.errors.entries()) {
+		checkTransportSchema({
+			schema: entry.schema,
+			role: "endpoint",
+			pattern: declaration.pattern,
+			field: "errors",
+			errors
+		});
+		if (!Number.isInteger(entry.status) || entry.status < 400 || entry.status > 599) errors.push({
+			_tag: "InvalidErrorStatus",
+			role: "endpoint",
+			pattern: declaration.pattern,
+			status: entry.status
+		});
+		const tag = getLiteralErrorTag(entry.schema);
+		if (tag === void 0) {
+			errors.push({
+				_tag: "ErrorSchemaWithoutLiteralTag",
+				role: "endpoint",
+				pattern: declaration.pattern,
+				index
+			});
+			continue;
+		}
+		if (FRAMEWORK_ERROR_TAGS.includes(tag.tag)) errors.push({
+			_tag: "FrameworkErrorTagCollision",
+			role: "endpoint",
+			pattern: declaration.pattern,
+			tag: tag.tag
+		});
+		else if (tags.has(tag.tag)) errors.push({
+			_tag: "DuplicateErrorTag",
+			role: "endpoint",
+			pattern: declaration.pattern,
+			tag: tag.tag
+		});
+		else tags.add(tag.tag);
+	}
+}
+/** A contract crosses the wire by value, so its decoded side must be JSON plus the transport's vocabulary; an error's class root travels as its fields. */
+function checkTransportSchema(input) {
+	const checked = checkTransportSchema$1({
+		schema: input.schema,
+		allowClassRoot: input.field === "errors"
+	});
+	if (Result.isFailure(checked)) {
+		input.errors.push({
+			_tag: "UntransportableSchema",
+			role: input.role,
+			pattern: input.pattern,
+			field: input.field,
+			path: checked.failure.path,
+			reason: checked.failure.reason
+		});
+		return;
+	}
+}
+//#endregion
+export { compileUiLoader as a, findConflictingDynamicParameterNames as c, FormData as d, matchesHttpMethod as f, compileMiddleware as i, getLiteralErrorTag as l, checkEndpointPatternRegistrations as n, createNestedRouteChains as o, compileEndpoint as r, groupEndpointsByMethod as s, checkDuplicates as t, getInputTransport as u };