@useavalon/avalon 0.1.0

package/src/schemas/api.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+
+/**
+ * Supported HTTP methods for API routes
+ */
+export const ApiMethodSchema = z.enum([
+	'GET',
+	'POST',
+	'PUT',
+	'DELETE',
+	'PATCH',
+	'HEAD',
+	'OPTIONS',
+]);
+
+export type ApiMethod = z.infer<typeof ApiMethodSchema>;
+
+/**
+ * Discovered API route with metadata
+ */
+export interface ApiRoute {
+	/** URL pattern for matching requests */
+	pattern: URLPattern;
+	/** Route configuration with handlers */
+	config: unknown;
+	/** Original file path relative to src/api */
+	filePath: string;
+	/** Extracted dynamic parameter names */
+	paramNames: string[];
+}

package/src/schemas/core.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+
+/**
+ * Schema for meta tags
+ */
+export const MetaTagSchema = z.object({
+	name: z.string().min(1),
+	content: z.string(),
+});
+
+/**
+ * Script configuration schema - supports both simple URLs and complex script objects
+ */
+export const ScriptConfigSchema = z.union([
+	// Simple string URL (backward compatible)
+	z.string().min(1),
+	// Complex script object with attributes
+	z
+		.object({
+			src: z.string().min(1).optional(),
+			content: z.string().optional(), // For inline scripts
+			data: z.union([z.record(z.string(), z.unknown()), z.array(z.unknown()), z.string()]).optional(), // For structured data (JSON-LD)
+			type: z.string().optional(),
+			async: z.boolean().optional(),
+			defer: z.boolean().optional(),
+			crossorigin: z.enum(['anonymous', 'use-credentials']).optional(),
+			integrity: z.string().optional(),
+			nomodule: z.boolean().optional(),
+			referrerpolicy: z
+				.enum([
+					'no-referrer',
+					'no-referrer-when-downgrade',
+					'origin',
+					'origin-when-cross-origin',
+					'same-origin',
+					'strict-origin',
+					'strict-origin-when-cross-origin',
+					'unsafe-url',
+				])
+				.optional(),
+			// Allow custom attributes
+			attributes: z.record(z.string(), z.string()).optional(),
+		})
+		.refine(data => data.src || data.content || data.data, {
+			message: "Script must have either 'src', 'content', or 'data'",
+		}),
+]);
+
+/**
+ * Simplified render options for Vite-powered architecture
+ */
+export const RenderOptionsSchema = z.object({
+	title: z.string().optional(),
+	scripts: z.array(ScriptConfigSchema).optional(),
+	styles: z.array(z.string().min(1)).optional(),
+	meta: z.array(MetaTagSchema).optional(),
+});
+
+
+// === Simplified TypeScript types ===
+
+export type MetaTag = z.infer<typeof MetaTagSchema>;
+export type ScriptConfig = z.infer<typeof ScriptConfigSchema>;
+export type RenderOptions = z.infer<typeof RenderOptionsSchema>;

package/src/schemas/index.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+import { RenderOptionsSchema } from './core.ts';
+import {
+	LayoutContextSchema,
+	LayoutDataSchema,
+	LayoutHandlerSchema,
+	LayoutDiscoveryOptionsSchema as LayoutDiscoverySchema,
+	LayoutConfigSchema,
+	ResolvedLayoutSchema,
+} from './layout.ts';
+import {
+	FileSystemRouteSchema,
+	RoutePageModuleSchema,
+	RouteDiscoveryOptionsSchema,
+	FileSystemRouterConfigSchema,
+	MetadataSchema,
+	ResolvedMetadataSchema,
+} from './routing.ts';
+import type { RenderOptions } from './core.ts';
+import type {
+	LayoutContext,
+	LayoutData,
+	LayoutHandler,
+	LayoutDiscoveryOptions,
+	LayoutConfig,
+	ResolvedLayout,
+} from './layout.ts';
+import type {
+	FileSystemRoute,
+	RoutePageModule,
+	RouteDiscoveryOptions,
+	FileSystemRouterConfig,
+	Metadata,
+	ResolvedMetadata,
+} from './routing.ts';
+
+export * from './core.ts';
+export * from './api.ts';
+export * from './layout.ts';
+export * from './routing.ts';
+
+export interface ValidationSuccess<T> {
+	success: true;
+	data: T;
+}
+
+export interface ValidationFailure {
+	success: false;
+	error: ValidationError;
+}
+
+export type ValidationResult<T> = ValidationSuccess<T> | ValidationFailure;
+
+export class ValidationError extends Error {
+	constructor(message: string, public readonly zodError: z.ZodError) {
+		super(message);
+		this.name = 'ValidationError';
+	}
+
+	getFormattedErrors(): string[] {
+		return this.zodError.issues.map((issue): string => {
+			const path = issue.path.length > 0 ? `${issue.path.join('.')}: ` : '';
+			return `${path}${issue.message}`;
+		});
+	}
+
+	getErrorMessage(): string {
+		return this.getFormattedErrors().join('; ');
+	}
+}
+
+export function createValidationError(message: string, zodError: z.ZodError): ValidationError {
+	return new ValidationError(message, zodError);
+}
+
+export function safeValidate<TOutput>(
+	schema: z.ZodType<TOutput>,
+	data: unknown,
+	errorMessage = 'Validation failed'
+): ValidationResult<TOutput> {
+	const result = schema.safeParse(data);
+	if (result.success) {
+		return { success: true, data: result.data };
+	}
+	return { success: false, error: createValidationError(errorMessage, result.error) };
+}
+
+export function validate<TOutput>(
+	schema: z.ZodType<TOutput>,
+	data: unknown,
+	errorMessage = 'Validation failed'
+): TOutput {
+	const result = schema.safeParse(data);
+	if (result.success) {
+		return result.data;
+	}
+	throw createValidationError(errorMessage, result.error);
+}
+
+export const validators = {
+	renderOptions: (data: unknown): RenderOptions => validate(RenderOptionsSchema, data, 'Invalid render options'),
+	layoutContext: (data: unknown): LayoutContext => validate(LayoutContextSchema, data, 'Invalid layout context'),
+	layoutData: (data: unknown): LayoutData => validate(LayoutDataSchema, data, 'Invalid layout data'),
+	layoutHandler: (data: unknown): LayoutHandler => validate(LayoutHandlerSchema, data, 'Invalid layout handler'),
+	layoutDiscoveryOptions: (data: unknown): LayoutDiscoveryOptions => validate(LayoutDiscoverySchema, data, 'Invalid layout discovery options'),
+	layoutConfig: (data: unknown): LayoutConfig => validate(LayoutConfigSchema, data, 'Invalid layout config'),
+	resolvedLayout: (data: unknown): ResolvedLayout => validate(ResolvedLayoutSchema, data, 'Invalid resolved layout'),
+	fileSystemRoute: (data: unknown): FileSystemRoute => validate(FileSystemRouteSchema, data, 'Invalid file system route'),
+	routePageModule: (data: unknown): RoutePageModule => validate(RoutePageModuleSchema, data, 'Invalid route page module'),
+	routeDiscoveryOptions: (data: unknown): RouteDiscoveryOptions => validate(RouteDiscoveryOptionsSchema, data, 'Invalid route discovery options'),
+	fileSystemRouterConfig: (data: unknown): FileSystemRouterConfig => validate(FileSystemRouterConfigSchema, data, 'Invalid file system router config'),
+	metadata: (data: unknown): Metadata => validate(MetadataSchema, data, 'Invalid metadata'),
+	resolvedMetadata: (data: unknown): ResolvedMetadata => validate(ResolvedMetadataSchema, data, 'Invalid resolved metadata'),
+} as const;
+
+export const safeValidators = {
+	renderOptions: (data: unknown): ValidationResult<RenderOptions> => safeValidate(RenderOptionsSchema, data, 'Invalid render options'),
+	layoutContext: (data: unknown): ValidationResult<LayoutContext> => safeValidate(LayoutContextSchema, data, 'Invalid layout context'),
+	layoutData: (data: unknown): ValidationResult<LayoutData> => safeValidate(LayoutDataSchema, data, 'Invalid layout data'),
+	layoutHandler: (data: unknown): ValidationResult<LayoutHandler> => safeValidate(LayoutHandlerSchema, data, 'Invalid layout handler'),
+	layoutDiscoveryOptions: (data: unknown): ValidationResult<LayoutDiscoveryOptions> => safeValidate(LayoutDiscoverySchema, data, 'Invalid layout discovery options'),
+	layoutConfig: (data: unknown): ValidationResult<LayoutConfig> => safeValidate(LayoutConfigSchema, data, 'Invalid layout config'),
+	resolvedLayout: (data: unknown): ValidationResult<ResolvedLayout> => safeValidate(ResolvedLayoutSchema, data, 'Invalid resolved layout'),
+	fileSystemRoute: (data: unknown): ValidationResult<FileSystemRoute> => safeValidate(FileSystemRouteSchema, data, 'Invalid file system route'),
+	routePageModule: (data: unknown): ValidationResult<RoutePageModule> => safeValidate(RoutePageModuleSchema, data, 'Invalid route page module'),
+	routeDiscoveryOptions: (data: unknown): ValidationResult<RouteDiscoveryOptions> => safeValidate(RouteDiscoveryOptionsSchema, data, 'Invalid route discovery options'),
+	fileSystemRouterConfig: (data: unknown): ValidationResult<FileSystemRouterConfig> => safeValidate(FileSystemRouterConfigSchema, data, 'Invalid file system router config'),
+	metadata: (data: unknown): ValidationResult<Metadata> => safeValidate(MetadataSchema, data, 'Invalid metadata'),
+	resolvedMetadata: (data: unknown): ValidationResult<ResolvedMetadata> => safeValidate(ResolvedMetadataSchema, data, 'Invalid resolved metadata'),
+} as const;
+
+export const devValidators = {
+	renderOptionsSoft: (data: unknown, context = 'unknown'): boolean => {
+		const result = safeValidators.renderOptions(data);
+		if (!result.success) {
+			console.warn(`Render options validation warning in ${context}:`, result.error.getErrorMessage());
+			return false;
+		}
+		return true;
+	},
+} as const;
+
+export function isValidRenderOptions(data: unknown): data is RenderOptions {
+	return safeValidators.renderOptions(data).success;
+}
+export function isValidFileSystemRoute(data: unknown): data is FileSystemRoute {
+	return safeValidators.fileSystemRoute(data).success;
+}
+export function isValidRoutePageModule(data: unknown): data is RoutePageModule {
+	return safeValidators.routePageModule(data).success;
+}
+export function isValidRouteDiscoveryOptions(data: unknown): data is RouteDiscoveryOptions {
+	return safeValidators.routeDiscoveryOptions(data).success;
+}
+export function isValidFileSystemRouterConfig(data: unknown): data is FileSystemRouterConfig {
+	return safeValidators.fileSystemRouterConfig(data).success;
+}
+export function isValidMetadata(data: unknown): data is Metadata {
+	return safeValidators.metadata(data).success;
+}
+export function isValidResolvedMetadata(data: unknown): data is ResolvedMetadata {
+	return safeValidators.resolvedMetadata(data).success;
+}
+
+export function validateBatch<T extends Record<string, unknown>>(
+	schemas: { [K in keyof T]: z.ZodType<T[K]> },
+	data: { [K in keyof T]: unknown }
+): T {
+	const result: Partial<T> = {};
+	const errors: string[] = [];
+
+	for (const [key, schema] of Object.entries(schemas) as Array<[keyof T, z.ZodType<T[keyof T]>]>) {
+		try {
+			result[key] = validate(schema, data[key], `Invalid ${String(key)}`);
+		} catch (error) {
+			if (error instanceof ValidationError) {
+				errors.push(`${String(key)}: ${error.getErrorMessage()}`);
+			} else {
+				errors.push(`${String(key)}: Unknown validation error`);
+			}
+		}
+	}
+
+	if (errors.length > 0) {
+		throw new Error(`Batch validation failed: ${errors.join('; ')}`);
+	}
+
+	return result as T;
+}
+
+export function safeValidateBatch<T extends Record<string, unknown>>(
+	schemas: { [K in keyof T]: z.ZodType<T[K]> },
+	data: { [K in keyof T]: unknown }
+): ValidationResult<T> {
+	try {
+		const result = validateBatch(schemas, data);
+		return { success: true, data: result };
+	} catch (error) {
+		const validationError =
+			error instanceof ValidationError
+				? error
+				: createValidationError(
+						'Batch validation failed',
+						new z.ZodError([{ code: 'custom', message: String(error), path: [] }])
+					);
+		return { success: false, error: validationError };
+	}
+}
+
+export type ExtractValidationData<T> = T extends ValidationResult<infer U> ? U : never;
+export type ExtractSchemaInput<T> = T extends z.ZodType<infer U> ? U : never;
+export type ExtractSchemaOutput<T> = T extends z.ZodType<infer U> ? U : never;

package/src/schemas/layout.ts

@@ -0,0 +1,279 @@
+import { z } from 'zod';
+import type { ComponentChildren } from 'preact';
+
+/**
+ * Layout Context Schema - Contains request information and state for layout processing
+ */
+export const LayoutContextSchema = z.object({
+	request: z.instanceof(Request),
+	params: z.record(z.string(), z.string()),
+	query: z.instanceof(URLSearchParams),
+	state: z.instanceof(Map<string, unknown>),
+	middlewareContext: z.any().optional(), // MiddlewareContext type from middleware system
+});
+
+/**
+ * Layout Data Schema - Flexible data structure for layout loaders
+ */
+export const LayoutDataSchema = z.record(z.string(), z.unknown());
+
+/**
+ * Layout Route Schema - Represents a discovered layout file with routing information
+ */
+export const LayoutRouteSchema = z.object({
+	pattern: z.instanceof(URLPattern),
+	layoutPath: z.string().min(1),
+	priority: z.number().int().min(0),
+	type: z.enum(['root', 'nested']),
+	depth: z.number().int().min(0),
+});
+
+/**
+ * Layout Handler Schema - Complete layout information including component and loader
+ */
+export const LayoutHandlerSchema = z.object({
+	component: z.any(), // ComponentType<LayoutProps> - can't validate function types with Zod
+	loader: z.any().optional(), // LayoutLoader function - can't validate function signature with Zod
+	path: z.string().min(1),
+	priority: z.number().int().min(0),
+});
+
+/**
+ * Layout Props Schema - Props passed to layout components
+ */
+export const LayoutPropsSchema = z.object({
+	children: z.any(), // ComponentChildren - can't validate JSX with Zod
+	data: LayoutDataSchema,
+	frontmatter: z.record(z.string(), z.any()).optional(), // Frontmatter from MDX files
+	route: z.object({
+		path: z.string(),
+		params: z.record(z.string(), z.string()),
+		query: z.instanceof(URLSearchParams),
+	}),
+});
+
+/**
+ * Layout Discovery Options Schema
+ */
+export const LayoutDiscoveryOptionsSchema = z.object({
+	baseDirectory: z.string().min(1),
+	filePattern: z.string().min(1).optional().default('_layout.tsx'),
+	excludeDirectories: z.array(z.string()).optional().default([]),
+	enableWatching: z.boolean().optional().default(false),
+	developmentMode: z.boolean().optional().default(false),
+});
+
+/**
+ * Route Info Schema - Information about the current route for conditional rendering
+ */
+export const RouteInfoSchema = z.object({
+	path: z.string(),
+	params: z.record(z.string(), z.string()),
+	method: z.string(),
+	headers: z.instanceof(Headers),
+});
+
+/**
+ * Layout Rule Schema - Rules for conditional layout rendering
+ */
+export const LayoutRuleSchema = z.object({
+	matches: z.any(), // (layoutPath: string, route: RouteInfo) => boolean - can't validate function signature with Zod
+	apply: z.boolean(),
+	priority: z.number().int(),
+});
+
+/**
+ * Layout Config Schema - Page-level layout composition control
+ */
+export const LayoutConfigSchema = z.object({
+	skipLayouts: z.array(z.string()).optional(),
+	replaceLayout: z.boolean().optional(),
+	onlyLayouts: z.array(z.string()).optional(),
+	customLayout: z.string().optional(),
+});
+
+/**
+ * Island State Schema - State data for persistent islands
+ */
+export const IslandStateSchema = z.record(z.string(), z.unknown());
+
+/**
+ * Persistent Island Props Schema
+ */
+export const PersistentIslandPropsSchema = z.object({
+	persistentId: z.string().min(1),
+	children: z.any(), // ComponentChildren
+});
+
+/**
+ * Persistent Island Context Schema
+ */
+export const PersistentIslandContextSchema = z.object({
+	saveState: z.any(), // (state: IslandState) => void - can't validate function signature with Zod
+	loadState: z.any(), // () => IslandState | null - can't validate function signature with Zod
+	clearState: z.any(), // () => void - can't validate function signature with Zod
+});
+
+/**
+ * Layout Error Info Schema
+ */
+export const LayoutErrorInfoSchema = z.object({
+	layoutPath: z.string(),
+	errorType: z.enum(['component', 'loader', 'rendering', 'island']),
+	timestamp: z.number().int().positive(),
+	componentStack: z.string().optional(),
+	errorBoundary: z.string().optional(),
+});
+
+/**
+ * Layout Error Boundary Props Schema
+ */
+export const LayoutErrorBoundaryPropsSchema = z.object({
+	children: z.any(), // ComponentChildren
+	fallback: z.any(), // (error: Error, retry: () => void) => ComponentChildren - can't validate function signature with Zod
+	onError: z.any().optional(), // (error: Error, errorInfo: unknown) => void - can't validate function signature with Zod
+});
+
+/**
+ * Error Recovery Strategy Schema
+ */
+export const ErrorRecoveryStrategySchema = z.object({
+	type: z.enum(['retry', 'fallback', 'skip', 'redirect']),
+	maxRetries: z.number().int().positive().optional(),
+	fallbackComponent: z.any().optional(), // ComponentType
+	redirectUrl: z.url().optional(),
+});
+
+/**
+ * Streaming Layout Props Schema
+ */
+export const StreamingLayoutPropsSchema = z.object({
+	children: z.any(), // ComponentChildren
+	fallback: z.any().optional(), // ComponentChildren
+	priority: z.enum(['high', 'medium', 'low']).default('medium'),
+});
+
+/**
+ * Streaming Component Schema
+ */
+export const StreamingComponentSchema = z.object({
+	component: z.any(), // ComponentType
+	fallback: z.any(), // ComponentType
+	priority: z.number().int().min(0),
+	isReady: z.any(), // () => Promise<boolean> - can't validate function signature with Zod
+});
+
+/**
+ * Resolved Layout Schema - Complete layout resolution result
+ */
+export const ResolvedLayoutSchema = z.object({
+	handlers: z.array(LayoutHandlerSchema),
+	dataLoaders: z.array(z.any()), // LayoutLoader[] - can't validate function signature with Zod
+	errorBoundaries: z.array(z.any()), // LayoutErrorBoundary[]
+	streamingComponents: z.array(StreamingComponentSchema),
+	metadata: z.object({
+		totalLayouts: z.number().int().min(0),
+		resolutionTime: z.number().positive(),
+		cacheHit: z.boolean(),
+	}),
+});
+
+/**
+ * Layout Cache Schema
+ */
+export const LayoutCacheSchema = z.object({
+	resolved: z.instanceof(Map), // Map<string, ResolvedLayout>
+	handlers: z.instanceof(Map), // Map<string, LayoutHandler>
+	data: z.instanceof(Map), // Map<string, LayoutData>
+	ttl: z.instanceof(Map), // Map<string, number>
+});
+
+/**
+ * Enhanced Layout Context Schema - Extended context with layout-specific information
+ */
+export const EnhancedLayoutContextSchema = LayoutContextSchema.extend({
+	layouts: z.array(LayoutHandlerSchema),
+	parentData: z.array(LayoutDataSchema),
+	islandStates: z.instanceof(Map), // Map<string, IslandState>
+	streamingEnabled: z.boolean(),
+	errorBoundaries: z.array(z.any()), // LayoutErrorBoundary[]
+});
+
+// === TypeScript Type Definitions ===
+
+export type LayoutContext = z.infer<typeof LayoutContextSchema>;
+export type LayoutData = z.infer<typeof LayoutDataSchema>;
+export type LayoutRoute = z.infer<typeof LayoutRouteSchema>;
+export type LayoutHandler = z.infer<typeof LayoutHandlerSchema>;
+export type LayoutProps = z.infer<typeof LayoutPropsSchema>;
+export type LayoutDiscoveryOptions = z.infer<typeof LayoutDiscoveryOptionsSchema>;
+export type RouteInfo = z.infer<typeof RouteInfoSchema>;
+export type LayoutRule = z.infer<typeof LayoutRuleSchema>;
+export type LayoutConfig = z.infer<typeof LayoutConfigSchema>;
+export type IslandState = z.infer<typeof IslandStateSchema>;
+export type PersistentIslandProps = z.infer<typeof PersistentIslandPropsSchema>;
+export type PersistentIslandContext = z.infer<typeof PersistentIslandContextSchema>;
+export type LayoutErrorInfo = z.infer<typeof LayoutErrorInfoSchema>;
+export type LayoutErrorBoundaryProps = z.infer<typeof LayoutErrorBoundaryPropsSchema>;
+export type ErrorRecoveryStrategy = z.infer<typeof ErrorRecoveryStrategySchema>;
+export type StreamingLayoutProps = z.infer<typeof StreamingLayoutPropsSchema>;
+export type StreamingComponent = z.infer<typeof StreamingComponentSchema>;
+export type ResolvedLayout = z.infer<typeof ResolvedLayoutSchema>;
+export type LayoutCache = z.infer<typeof LayoutCacheSchema>;
+export type EnhancedLayoutContext = z.infer<typeof EnhancedLayoutContextSchema>;
+
+// === Function Type Definitions ===
+
+/**
+ * Layout Loader Function Type
+ * Loads data for a specific layout component
+ */
+export type LayoutLoader = (ctx: LayoutContext) => Promise<LayoutData>;
+
+/**
+ * Layout Matcher Function Type
+ * Determines if a layout should be applied based on route information and optional layout path
+ */
+export type LayoutMatcherFunction = (route: RouteInfo, layoutPath?: string) => boolean;
+
+/**
+ * Layout Error Handler Function Type
+ * Handles errors that occur during layout processing
+ */
+export type LayoutErrorHandler = (error: Error, errorInfo: LayoutErrorInfo) => void;
+
+/**
+ * Layout Retry Function Type
+ * Function to retry failed layout operations
+ */
+export type LayoutRetryFunction = () => void;
+
+/**
+ * Layout Fallback Renderer Function Type
+ * Renders fallback UI when layout errors occur
+ */
+export type LayoutFallbackRenderer = (error: Error, retry: LayoutRetryFunction) => ComponentChildren;
+
+/**
+ * Island State Saver Function Type
+ * Saves island state to persistence layer
+ */
+export type IslandStateSaver = (state: IslandState) => void;
+
+/**
+ * Island State Loader Function Type
+ * Loads island state from persistence layer
+ */
+export type IslandStateLoader = () => IslandState | null;
+
+/**
+ * Island State Clearer Function Type
+ * Clears island state from persistence layer
+ */
+export type IslandStateClearer = () => void;
+
+/**
+ * Streaming Component Ready Check Function Type
+ * Checks if a streaming component is ready to render
+ */
+export type StreamingReadyCheck = () => Promise<boolean>;

package/src/schemas/routing/index.ts

@@ -0,0 +1,38 @@
+// Re-export all routing schemas and types
+export * from '../routing.ts';
+
+// Export specific validators for routing
+import {
+	FileSystemRouteSchema,
+	RoutePageModuleSchema,
+	RouteDiscoveryOptionsSchema,
+	FileSystemRouterConfigSchema,
+	MetadataSchema,
+	ResolvedMetadataSchema,
+} from '../routing.ts';
+
+import { validate, safeValidate } from '../index.ts';
+
+// Routing-specific validators
+export const routingValidators = {
+	fileSystemRoute: (data: unknown) => validate(FileSystemRouteSchema, data, 'Invalid file system route'),
+	routePageModule: (data: unknown) => validate(RoutePageModuleSchema, data, 'Invalid route page module'),
+	routeDiscoveryOptions: (data: unknown) =>
+		validate(RouteDiscoveryOptionsSchema, data, 'Invalid route discovery options'),
+	fileSystemRouterConfig: (data: unknown) =>
+		validate(FileSystemRouterConfigSchema, data, 'Invalid file system router config'),
+	metadata: (data: unknown) => validate(MetadataSchema, data, 'Invalid metadata'),
+	resolvedMetadata: (data: unknown) => validate(ResolvedMetadataSchema, data, 'Invalid resolved metadata'),
+} as const;
+
+// Safe routing validators
+export const safeRoutingValidators = {
+	fileSystemRoute: (data: unknown) => safeValidate(FileSystemRouteSchema, data, 'Invalid file system route'),
+	routePageModule: (data: unknown) => safeValidate(RoutePageModuleSchema, data, 'Invalid route page module'),
+	routeDiscoveryOptions: (data: unknown) =>
+		safeValidate(RouteDiscoveryOptionsSchema, data, 'Invalid route discovery options'),
+	fileSystemRouterConfig: (data: unknown) =>
+		safeValidate(FileSystemRouterConfigSchema, data, 'Invalid file system router config'),
+	metadata: (data: unknown) => safeValidate(MetadataSchema, data, 'Invalid metadata'),
+	resolvedMetadata: (data: unknown) => safeValidate(ResolvedMetadataSchema, data, 'Invalid resolved metadata'),
+} as const;