@sjcx/vorma 0.0.0-pre.1 → 0.0.0-pre.3

package/dist/search-parse-0f7oqVsG.js

@@ -1,375 +0,0 @@
-import { a as restoreEffectTransportType, p as makeNullPrototypeRecord } from "./value-transport-Bst4Hk-n.js";
-import { a as EMPTY_ARRAY_MARKER, c as ESCAPED_KEY_SEPARATOR, d as ESCAPE_PREFIX, f as KEY_SEPARATOR, h as encodeScalar, l as ESCAPED_SCALAR_PREFIX, m as appendKey, o as EMPTY_KEY_SEGMENT, p as NULL_MARKER, s as EMPTY_OBJECT_MARKER, u as ESCAPED_TILDE } from "./href-Cqyax8Y0.js";
-import { Result } from "effect";
-//#region src/universal/search-parse.ts
-const ABSENT = Symbol("absent");
-function parseSearchParams(input) {
-	return Result.map(parseNode({
-		...input,
-		params: indexSearchFields(input.params),
-		node: input.document,
-		path: ""
-	}), (value) => value === ABSENT ? void 0 : value);
-}
-/** Indexes exact values and immediate encoded child keys once per parse. */
-function indexSearchFields(params) {
-	const values = /* @__PURE__ */ new Map();
-	const children = /* @__PURE__ */ new Map();
-	for (const [key, value] of params) {
-		const existing = values.get(key);
-		if (existing !== void 0) {
-			existing.push(value);
-			continue;
-		}
-		values.set(key, [value]);
-		if (key === "") continue;
-		let parent = "";
-		let start = 0;
-		while (true) {
-			const separator = key.indexOf(KEY_SEPARATOR, start);
-			const child = key.slice(start, separator === -1 ? void 0 : separator);
-			if (parent !== "" || start === 0) {
-				let names = children.get(parent);
-				if (names === void 0) {
-					names = /* @__PURE__ */ new Set();
-					children.set(parent, names);
-				}
-				names.add(child);
-			}
-			if (separator === -1) break;
-			parent = key.slice(0, separator);
-			start = separator + KEY_SEPARATOR.length;
-		}
-	}
-	return {
-		values,
-		children
-	};
-}
-function parseNode(input) {
-	const { node, path, params } = input;
-	const present = containsKey(path, params);
-	if (node.optional && !present) return Result.succeed(ABSENT);
-	if (node.nullable) {
-		if (!present) return Result.succeed(null);
-		const exact = params.values.get(path) ?? [];
-		if (exact.includes(NULL_MARKER)) return exact.length === 1 && !containsChildKey(path, params) ? Result.succeed(null) : failInvalidValue({
-			path,
-			expected: "an unambiguous null marker"
-		});
-	}
-	switch (node.kind) {
-		case "scalar": {
-			const raw = getOneValue(path, params);
-			return Result.isFailure(raw) ? raw : parseScalar({
-				...input,
-				node,
-				raw: raw.success
-			});
-		}
-		case "option":
-			if (!present) return restoreSearchEffectType({
-				...input,
-				kind: "option",
-				value: []
-			});
-			return Result.flatMap(parseNode({
-				...input,
-				node: node.value
-			}), (value) => {
-				return restoreSearchEffectType({
-					...input,
-					kind: "option",
-					value: [value]
-				});
-			});
-		case "redacted": return Result.flatMap(parseNode({
-			...input,
-			node: node.value
-		}), (value) => {
-			return restoreSearchEffectType({
-				...input,
-				kind: "redacted",
-				value: {
-					value,
-					...node.label === void 0 ? {} : { label: node.label }
-				}
-			});
-		});
-		case "array": return Result.flatMap(parseArray({
-			...input,
-			node: node.item
-		}), (values) => {
-			switch (node.collection) {
-				case "array": return Result.succeed(values);
-				case "set": return Result.succeed(new Set(values));
-				default: return restoreSearchEffectType({
-					...input,
-					kind: node.collection,
-					value: values
-				});
-			}
-		});
-		case "record": return Result.flatMap(parseRecord({
-			...input,
-			node
-		}), (value) => {
-			switch (node.collection) {
-				case "record": return Result.succeed(value);
-				case "map": return Result.succeed(new Map(Object.entries(value)));
-				case "hash-map": return restoreSearchEffectType({
-					...input,
-					kind: "hash-map",
-					value: Object.entries(value)
-				});
-			}
-		});
-		case "object": {
-			const exact = params.values.get(path) ?? [];
-			if (exact.length > 0 && (exact.length !== 1 || exact[0] !== EMPTY_OBJECT_MARKER || containsChildKey(path, params))) return failInvalidValue({
-				path,
-				expected: "an unambiguous empty-object marker or child fields"
-			});
-			const result = makeSearchObject();
-			for (const [name, child] of Object.entries(node.fields)) {
-				const value = parseNode({
-					...input,
-					node: child,
-					path: appendKey({
-						parent: path,
-						child: name
-					})
-				});
-				if (Result.isFailure(value)) return value;
-				if (value.success !== ABSENT) result[name] = value.success;
-			}
-			return Result.succeed(result);
-		}
-	}
-}
-function parseArray(input) {
-	const values = input.params.values.get(input.path) ?? [];
-	if (values.length === 0 || values.length === 1 && values[0] === EMPTY_ARRAY_MARKER) return Result.succeed([]);
-	if (values.includes(EMPTY_ARRAY_MARKER)) return failInvalidValue({
-		path: input.path,
-		expected: "an array without a mixed empty-array marker"
-	});
-	const result = [];
-	for (const raw of values) {
-		const value = parseScalar({
-			...input,
-			raw
-		});
-		if (Result.isFailure(value)) return Result.fail(value.failure);
-		result.push(value.success);
-	}
-	return Result.succeed(result);
-}
-function parseRecord(input) {
-	const { params, path, node } = input;
-	const exact = params.values.get(path) ?? [];
-	if (exact.length === 1 && exact[0] === EMPTY_OBJECT_MARKER && !containsChildKey(path, params)) return Result.succeed(makeSearchObject());
-	if (exact.length > 0) return failInvalidValue({
-		path,
-		expected: "an empty-object marker or dotted map entries"
-	});
-	const result = makeSearchObject();
-	for (const encodedKey of params.children.get(path) ?? []) {
-		if (encodedKey === "") continue;
-		const decoded = decodeKeySegment({
-			value: encodedKey,
-			path
-		});
-		if (Result.isFailure(decoded)) return Result.fail(decoded.failure);
-		const key = parseScalar({
-			...input,
-			node: node.key,
-			raw: encodeScalar(decoded.success)
-		});
-		if (Result.isFailure(key)) return Result.fail(key.failure);
-		if (typeof key.success !== "string") return failMalformedSchema(path);
-		const value = parseNode({
-			...input,
-			node: node.value,
-			path: path === "" ? encodedKey : `${path}${KEY_SEPARATOR}${encodedKey}`
-		});
-		if (Result.isFailure(value)) return Result.fail(value.failure);
-		if (value.success !== ABSENT) result[key.success] = value.success;
-	}
-	return Result.succeed(result);
-}
-function parseScalar(input) {
-	if (input.raw === NULL_MARKER && input.node.nullable) return Result.succeed(null);
-	const decoded = decodeScalar({
-		value: input.raw,
-		path: input.path
-	});
-	if (Result.isFailure(decoded)) return decoded;
-	const value = decoded.success;
-	switch (input.node.type) {
-		case "string": return input.node.values === void 0 || input.node.values.includes(value) ? Result.succeed(value) : failInvalidValue({
-			path: input.path,
-			expected: "a declared enum variant"
-		});
-		case "boolean": return value === "true" ? Result.succeed(true) : value === "false" ? Result.succeed(false) : failInvalidValue({
-			path: input.path,
-			expected: "true or false"
-		});
-		case "number": return parseNumber(value, input.path);
-		case "bigint": return parseBigInt(value, input.path);
-		default: return parsePlatformScalar({
-			...input,
-			type: input.node.type,
-			value
-		});
-	}
-}
-function restoreSearchEffectType(input) {
-	return Result.mapError(restoreEffectTransportType(input), (cause) => {
-		return {
-			_tag: "InvalidSearchParam",
-			path: input.path,
-			expected: cause.reason
-		};
-	});
-}
-function parsePlatformScalar(input) {
-	switch (input.type) {
-		case "date": {
-			const date = new Date(input.value);
-			return Number.isNaN(date.getTime()) ? failInvalidValue({
-				path: input.path,
-				expected: "an ISO 8601 date"
-			}) : Result.succeed(date);
-		}
-		case "url": return Result.try({
-			try: () => new URL(input.value),
-			catch: () => {
-				return {
-					_tag: "InvalidSearchParam",
-					path: input.path,
-					expected: "an absolute URL"
-				};
-			}
-		});
-		case "url-search-params": return Result.succeed(new URLSearchParams(input.value));
-		case "regexp": {
-			const match = /^\/([^]*)\/([a-z]*)$/.exec(input.value);
-			if (match === null || match[1] === void 0 || match[2] === void 0) return failInvalidValue({
-				path: input.path,
-				expected: "a regular expression as /source/flags"
-			});
-			const source = match[1];
-			const flags = match[2];
-			return Result.try({
-				try: () => new RegExp(source, flags),
-				catch: () => {
-					return {
-						_tag: "InvalidSearchParam",
-						path: input.path,
-						expected: "a valid regular expression"
-					};
-				}
-			});
-		}
-		default: {
-			const kind = input.type;
-			return kind === "duration" || kind === "big-decimal" || kind === "date-time-utc" || kind === "date-time-zoned" ? restoreSearchEffectType({
-				kind,
-				value: input.value,
-				path: input.path,
-				typeEntries: input.typeEntries
-			}) : failMalformedSchema(input.path);
-		}
-	}
-}
-function parseNumber(value, path) {
-	if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value)) return failInvalidValue({
-		path,
-		expected: "a finite decimal number"
-	});
-	const parsed = Number(value);
-	return Number.isFinite(parsed) ? Result.succeed(parsed === 0 ? 0 : parsed) : failInvalidValue({
-		path,
-		expected: "a finite decimal number"
-	});
-}
-function parseBigInt(value, path) {
-	return /^[+-]?\d+$/.test(value) ? Result.succeed(BigInt(value)) : failInvalidValue({
-		path,
-		expected: "a base-10 integer"
-	});
-}
-function decodeKeySegment(input) {
-	if (input.value === EMPTY_KEY_SEGMENT) return Result.succeed("");
-	let out = "";
-	for (let index = 0; index < input.value.length; index++) {
-		const character = input.value[index];
-		if (character !== ESCAPE_PREFIX) {
-			out += character;
-			continue;
-		}
-		const code = input.value[++index];
-		if (code === void 0) return failInvalidValue({
-			path: input.path,
-			expected: "a well-formed key escape"
-		});
-		const escape = `${ESCAPE_PREFIX}${code}`;
-		if (escape === ESCAPED_TILDE) out += ESCAPE_PREFIX;
-		else if (escape === ESCAPED_KEY_SEPARATOR) out += KEY_SEPARATOR;
-		else return failInvalidValue({
-			path: input.path,
-			expected: "a well-formed key escape"
-		});
-	}
-	return Result.succeed(out);
-}
-function decodeScalar(input) {
-	if (input.value.startsWith(ESCAPED_SCALAR_PREFIX)) {
-		const escaped = input.value.slice(ESCAPED_SCALAR_PREFIX.length);
-		return escaped.startsWith(ESCAPE_PREFIX) ? Result.succeed(escaped) : failInvalidValue({
-			path: input.path,
-			expected: "a well-formed escaped scalar"
-		});
-	}
-	return input.value.startsWith(ESCAPE_PREFIX) ? failInvalidValue({
-		path: input.path,
-		expected: "a scalar, not a reserved marker"
-	}) : Result.succeed(input.value);
-}
-function makeSearchObject() {
-	return makeNullPrototypeRecord();
-}
-function getOneValue(path, params) {
-	const values = params.values.get(path);
-	const only = values?.[0];
-	if (values === void 0 || only === void 0) return Result.fail({
-		_tag: "MissingSearchParam",
-		path
-	});
-	return values.length === 1 ? Result.succeed(only) : failInvalidValue({
-		path,
-		expected: "exactly one value"
-	});
-}
-function containsKey(path, params) {
-	return params.values.has(path) || containsChildKey(path, params);
-}
-function containsChildKey(path, params) {
-	return params.children.has(path);
-}
-function failMalformedSchema(path) {
-	return Result.fail({
-		_tag: "MalformedSearchSchema",
-		path
-	});
-}
-function failInvalidValue(input) {
-	return Result.fail({
-		_tag: "InvalidSearchParam",
-		path: input.path,
-		expected: input.expected
-	});
-}
-//#endregion
-export { parseSearchParams as t };

package/dist/server/config/index.d.ts

@@ -1,36 +0,0 @@
-import { Schema } from "effect";
-export declare const VormaConfigSchema: Schema.Struct<{
-    readonly importMeta: Schema.Struct<{
-        readonly url: Schema.NonEmptyString;
-    }>;
-    readonly serverEntry: Schema.NonEmptyString;
-    readonly serverTsconfigFile: Schema.NonEmptyString;
-    readonly clientEntry: Schema.NonEmptyString;
-    readonly clientTsconfigFile: Schema.NonEmptyString;
-    readonly publicAssetsDir: Schema.NonEmptyString;
-    readonly viteConfigFile: Schema.NonEmptyString;
-    readonly criticalCssEntry: Schema.optionalKey<Schema.NonEmptyString>;
-    readonly serverExternalPackages: Schema.optionalKey<Schema.$Array<Schema.String>>;
-    readonly publicAssetsBasePath: Schema.String;
-    readonly bodySsr: Schema.optionalKey<Schema.Boolean>;
-    readonly dev: Schema.optionalKey<Schema.Struct<{
-        readonly revalidateClientOnChange: Schema.optionalKey<Schema.$Array<Schema.String>>;
-    }>>;
-}>;
-/**
- * Every path is relative to the configuration file's directory.
- * `serverTsconfigFile` and `clientTsconfigFile` name the two TypeScript
- * projects: the build reads each project's own source files through the
- * TypeScript checker, and every export with a registerable declaration value
- * is registered. Server compilation leaves `effect` and all its subpaths as
- * runtime imports so generated code shares the application's Effect instance.
- * Other server dependencies retain ordinary resolution. The build never sets
- * Vite's `root`, so the author's `root` applies when set and Vite's own default applies
- * otherwise. Vorma owns `_vorma` beside each entry; the
- * client output also holds public assets and locks. Body SSR and critical CSS
- * are enabled explicitly; omission means off. serverExternalPackages names
- * additional packages left as runtime imports. Effect is always external;
- * omission means the server build bundles other package dependencies.
- */
-export type VormaConfig = typeof VormaConfigSchema.Type;
-export declare function defineConfig(config: VormaConfig): VormaConfig;

package/dist/server/config/index.js

@@ -1,30 +0,0 @@
-import { Schema } from "effect";
-//#region src/server/config/index.ts
-const PACKAGE_NAME = /^(?:@[a-z0-9\-~][a-z0-9\-._~]*\/)?[a-z0-9\-~][a-z0-9\-._~]*$/;
-/**
-* A bare npm package name, optionally scoped. A subpath, a trailing slash, a
-* relative or absolute path and a `node:` specifier all name something other
-* than an installed package, so they are not external packages.
-*/
-const ExternalPackageNameSchema = Schema.String.check(Schema.makeFilter((name) => {
-	return PACKAGE_NAME.test(name) ? void 0 : `externalPackages entries must be bare package names such as "sharp" or "@scope/sharp", got ${JSON.stringify(name)}`;
-}));
-const VormaConfigSchema = Schema.Struct({
-	importMeta: Schema.Struct({ url: Schema.NonEmptyString }),
-	serverEntry: Schema.NonEmptyString,
-	serverTsconfigFile: Schema.NonEmptyString,
-	clientEntry: Schema.NonEmptyString,
-	clientTsconfigFile: Schema.NonEmptyString,
-	publicAssetsDir: Schema.NonEmptyString,
-	viteConfigFile: Schema.NonEmptyString,
-	criticalCssEntry: Schema.optionalKey(Schema.NonEmptyString),
-	serverExternalPackages: Schema.optionalKey(Schema.Array(ExternalPackageNameSchema)),
-	publicAssetsBasePath: Schema.String,
-	bodySsr: Schema.optionalKey(Schema.Boolean),
-	dev: Schema.optionalKey(Schema.Struct({ revalidateClientOnChange: Schema.optionalKey(Schema.Array(Schema.String)) }))
-});
-function defineConfig(config) {
-	return config;
-}
-//#endregion
-export { VormaConfigSchema, defineConfig };

package/dist/server/development/metadata.d.ts

@@ -1,11 +0,0 @@
-import { Effect } from "effect";
-import type { ProductionMetadata } from "../../universal/protocol.ts";
-export type DevelopmentMetadataIssue = {
-    readonly _tag: "DevelopmentMetadataIssue";
-    readonly cause: unknown;
-};
-/** Reads each atomic development publication; unchanged bytes retain the same snapshot. */
-export declare function createDevelopmentMetadataReader(input: {
-    readonly url: URL;
-    readonly initial: ProductionMetadata;
-}): Effect.Effect<ProductionMetadata, DevelopmentMetadataIssue, never>;

package/dist/server/document.d.ts

@@ -1,37 +0,0 @@
-import { Result } from "effect";
-export type Attributes = Readonly<Record<string, string | true>>;
-/** Head content is escaped text or explicitly trusted HTML, without recursive element children. */
-export type Element = {
-    readonly tag: string;
-    readonly attributes?: Attributes;
-} & ({
-    readonly textContent?: string;
-    readonly dangerousInnerHtml?: never;
-} | {
-    readonly textContent?: never;
-    readonly dangerousInnerHtml: string;
-});
-export type RenderError = {
-    readonly _tag: "InvalidTagName";
-    readonly tag: string;
-} | {
-    readonly _tag: "InvalidAttributeName";
-    readonly attribute: string;
-    readonly tag: string;
-} | {
-    readonly _tag: "VoidElementWithContent";
-    readonly tag: string;
-} | {
-    readonly _tag: "MixedTextAndRawContent";
-    readonly tag: string;
-};
-/** Escapes ordinary text once, when producing HTML. */
-export declare function escapeText(value: string): string;
-/** Escapes a value for a double-quoted HTML attribute. */
-export declare function escapeAttributeValue(value: string): string;
-/** Escapes serialized JSON for insertion through a script element's dangerousInnerHtml. */
-export declare function escapeJsonForScript(serializedJson: string): string;
-export declare function renderElementContent(element: Element): Result.Result<string, RenderError>;
-/** Serializes one element without interpreting raw code or markup. */
-export declare function renderElement(element: Element): Result.Result<string, RenderError>;
-export declare function renderElements(elements: ReadonlyArray<Element>): Result.Result<string, RenderError>;

package/dist/server/form-data.d.ts

@@ -1,21 +0,0 @@
-import { Schema } from "effect";
-import { Multipart } from "effect/unstable/http";
-/** Native Effect form fields and request-scoped persisted uploads. */
-export type FormData = Multipart.Persisted;
-declare const FORM_DATA_TRANSPORT: unique symbol;
-/** Identifies form transport to the checker without changing native runtime values. */
-export interface FormDataEncoded extends Multipart.Persisted {
-    readonly [FORM_DATA_TRANSPORT]?: true;
-}
-/** Form inputs decode their encoded record; other transported values use the schema's service-free type side. */
-export type FormInputServices<S extends Schema.Top> = typeof FORM_DATA_TRANSPORT extends keyof S["Encoded"] ? S["DecodingServices"] : never;
-/** Marks an endpoint's form transport; handlers receive Effect's parsed form record. */
-export declare const FormData: Schema.Codec<Multipart.Persisted, FormDataEncoded>;
-/**
- * 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.
- */
-export declare function matchesFormInput(schema: Schema.Top): boolean;
-export {};

package/dist/server/graph/compile.d.ts

@@ -1,118 +0,0 @@
-import type { CompiledFlatPattern, CompiledNestedPattern, PatternCompileError } from "@vorma/primitives/matcher";
-import { type PathWireError } from "../../universal/path-wire.ts";
-import type { SearchContractDocument } from "../../universal/protocol-schemas.ts";
-import { type DeclaredSchema, type EndpointDeclaration, type HttpMethod, type TaskMiddlewareDeclaration, type UiLoaderDeclaration } from "./declarations.ts";
-import { type ConflictingDynamicParameterNameError } from "./pattern-conflicts.ts";
-import { type DerivedSearchContract } from "./search-schema.ts";
-/** A UI loader's search-parameter contract: the authored codec, the check-free document the URL parser reads, and its top-level fields. */
-export type UiSearchContract = DerivedSearchContract & {
-    readonly schema: DeclaredSchema;
-};
-export type UiLoaderNode = {
-    readonly declaration: UiLoaderDeclaration;
-    readonly registered: CompiledNestedPattern;
-    /** Null when the loader takes no search parameters. */
-    readonly search: UiSearchContract | null;
-};
-export type UiSearchOwner = UiLoaderNode & {
-    readonly search: UiSearchContract;
-};
-/** A GET endpoint's search-parameter contract: the authored codec and the check-free document the URL parser reads. */
-export type EndpointSearchContract = {
-    readonly schema: DeclaredSchema;
-    readonly document: SearchContractDocument;
-};
-export type EndpointNode = {
-    readonly declaration: EndpointDeclaration;
-    readonly registered: CompiledFlatPattern;
-    /** Null unless the endpoint is a GET with an input schema. */
-    readonly search: EndpointSearchContract | null;
-};
-export type MiddlewareNode = {
-    readonly declaration: TaskMiddlewareDeclaration;
-    readonly registered: ReadonlyArray<CompiledFlatPattern>;
-};
-export type DeclarationRole = "uiLoader" | "endpoint" | "middleware";
-export type GraphError = {
-    readonly _tag: "InvalidEndpointMethod";
-    readonly pattern: string;
-    readonly method: string;
-    readonly kind: string;
-} | {
-    readonly _tag: "InvalidPattern";
-    readonly role: DeclarationRole;
-    readonly pattern: string;
-    readonly cause: PatternCompileError | PathWireError;
-} | {
-    readonly _tag: "DuplicateUiLoader";
-    readonly pattern: string;
-} | {
-    readonly _tag: "DuplicateEndpoint";
-    readonly method: HttpMethod;
-    readonly pattern: string;
-} | {
-    readonly _tag: "ConflictingEndpointParameters";
-    readonly method: HttpMethod;
-    readonly patterns: ReadonlyArray<string>;
-    readonly cause: ConflictingDynamicParameterNameError;
-} | {
-    readonly _tag: "ConflictingMiddlewareParameters";
-    readonly index: number;
-    readonly patterns: ReadonlyArray<string>;
-    readonly cause: ConflictingDynamicParameterNameError;
-} | {
-    readonly _tag: "EmptyMiddlewareSelector";
-    readonly index: number;
-    readonly field: "patterns" | "methods";
-} | {
-    readonly _tag: "UnsupportedSearchSchema";
-    readonly role: "uiLoader" | "endpoint";
-    readonly pattern: string;
-    readonly path: string;
-    readonly reason: string;
-} | {
-    readonly _tag: "UntransportableSchema";
-    readonly role: DeclarationRole;
-    readonly pattern: string;
-    readonly field: "input" | "output" | "event" | "errors";
-    readonly path: string;
-    readonly reason: string;
-} | {
-    readonly _tag: "InvalidErrorStatus";
-    readonly role: "endpoint";
-    readonly pattern: string;
-    readonly status: number;
-} | {
-    readonly _tag: "ErrorSchemaWithoutLiteralTag";
-    readonly role: "endpoint";
-    readonly pattern: string;
-    readonly index: number;
-} | {
-    readonly _tag: "DuplicateErrorTag";
-    readonly role: "endpoint";
-    readonly pattern: string;
-    readonly tag: string;
-} | {
-    readonly _tag: "FrameworkErrorTagCollision";
-    readonly role: "endpoint";
-    readonly pattern: string;
-    readonly tag: string;
-};
-export declare function compileUiLoader(declaration: UiLoaderDeclaration, errors: Array<GraphError>): UiLoaderNode | null;
-export declare function compileEndpoint(declaration: EndpointDeclaration, errors: Array<GraphError>): EndpointNode | null;
-export declare function compileMiddleware(declaration: TaskMiddlewareDeclaration, index: number, errors: Array<GraphError>): MiddlewareNode | null;
-/** Groups endpoint nodes by method, preserving declaration order within each method. */
-export declare function groupEndpointsByMethod(endpoints: ReadonlyArray<EndpointNode>): ReadonlyMap<HttpMethod, ReadonlyArray<EndpointNode>>;
-export declare function checkEndpointPatternRegistrations(endpoints: ReadonlyArray<EndpointNode>, errors: Array<GraphError>): void;
-type NestedRouteNode = {
-    readonly registered: CompiledNestedPattern;
-};
-/** Materializes each target's registered outer-to-inner route chain in time proportional to route depth. */
-export declare function createNestedRouteChains<Node extends NestedRouteNode>(input: {
-    readonly nodes: ReadonlyArray<Node>;
-}): ReadonlyArray<{
-    readonly target: Node;
-    readonly chain: ReadonlyArray<Node>;
-}>;
-export declare function checkDuplicates(uiLoaders: ReadonlyArray<UiLoaderNode>, endpoints: ReadonlyArray<EndpointNode>, errors: Array<GraphError>): void;
-export {};