@useavalon/avalon 0.1.10 → 0.1.12

package/src/schemas/api.ts

@@ -1,30 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,212 +0,0 @@
-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

@@ -1,279 +0,0 @@
-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

@@ -1,38 +0,0 @@
-// 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;