@useavalon/avalon 0.1.23 → 0.1.25

package/dist/src/middleware/discovery.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Simplified Middleware Discovery
+ *
+ * This module provides a streamlined middleware discovery system that scans
+ * for _middleware.ts files in src/pages/ directories.
+ *
+ * Key features:
+ * - Scans src/pages/ for page middleware
+ * - Calculates priority based on directory depth (parent before child)
+ * - Creates URL patterns for route matching
+ *
+ * Note: API middleware is handled natively by Nitro and is not scanned here.
+ *
+ * Requirements: 3.1, 3.2, 3.3, 3.4
+ */
+import type { MiddlewareRoute, MiddlewareDiscoveryOptions } from './types.ts';
+/**
+ * Discovers route-scoped middleware files in the project
+ *
+ * Scans for _middleware.ts files in:
+ * - src/pages/ directory (and subdirectories) for page routes
+ *
+ * API middleware is handled natively by Nitro and is not scanned here.
+ *
+ * Middleware files are sorted by priority (directory depth), ensuring
+ * parent middleware executes before child middleware.
+ *
+ * @param options - Discovery options
+ * @returns Array of discovered middleware routes, sorted by priority
+ *
+ * @example
+ * ```ts
+ * const routes = await discoverScopedMiddleware({
+ *   baseDir: 'src',
+ *   devMode: true,
+ * });
+ *
+ * // Returns routes like:
+ * // [
+ * //   { pattern: URLPattern('/blog/*'), filePath: 'src/pages/blog/_middleware.ts', priority: 51, type: 'pages' },
+ * // ]
+ * ```
+ */
+export declare function discoverScopedMiddleware(options: MiddlewareDiscoveryOptions): Promise<MiddlewareRoute[]>;
+/**
+ * Gets middleware routes that match a given URL
+ *
+ * Filters discovered routes to only include those that match the URL,
+ * respecting type isolation (page middleware doesn't run for API routes
+ * and vice versa).
+ *
+ * @param routes - All discovered middleware routes
+ * @param url - URL to match against
+ * @returns Matching routes, sorted by priority
+ *
+ * @example
+ * ```ts
+ * const allRoutes = await discoverScopedMiddleware({ baseDir: 'src' });
+ * const matchingRoutes = getMatchingMiddleware(allRoutes, new URL('http://localhost/blog/post-1'));
+ * ```
+ */
+export declare function getMatchingMiddleware(routes: MiddlewareRoute[], url: URL): MiddlewareRoute[];
+/**
+ * Clears the middleware discovery cache
+ *
+ * This is a no-op in the simplified discovery module since we don't
+ * maintain a persistent cache. The function is provided for API
+ * compatibility with the executor module.
+ */
+export declare function clearDiscoveryCache(): void;

package/dist/src/middleware/executor.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Simplified Middleware Executor
+ *
+ * This module provides a streamlined middleware execution system that aligns
+ * with Nitro's conventions while supporting Avalon's route-scoped middleware.
+ *
+ * Key features:
+ * - Nitro-style handler signature: return void to continue, return Response to terminate
+ * - Middleware caching for performance
+
+ * - Error propagation to Nitro's error handling
+ * - Context preservation: event.context modifications persist through the chain
+ * - Development logging for context changes
+ *
+ * Requirements: 1.2, 1.3, 1.4, 2.1, 2.2
+ */
+import type { H3Event } from 'h3';
+import type { MiddlewareRoute, MiddlewareExecutorOptions } from './types.ts';
+/**
+ * Executes route-scoped middleware chain for a request
+ *
+ * 1. Finds middleware that matches the request URL
+ * 2. Executes them in priority order (parent before child)
+ * 3. Handles void return (continue) and Response return (terminate)
+ * 4. Propagates errors to Nitro's error handling
+ * 5. Preserves event.context modifications across the chain
+ * 6. Logs context changes in development mode
+ *
+ * @param event - H3 event object from Nitro
+ * @param routes - Discovered middleware routes from discoverScopedMiddleware
+ * @param options - Execution options
+ * @returns Response if middleware terminated the chain, undefined otherwise
+ */
+export declare function executeScopedMiddleware(event: H3Event, routes: MiddlewareRoute[], options?: MiddlewareExecutorOptions): Promise<Response | undefined>;
+/**
+ * Converts an absolute file path to a valid ESM import specifier.
+ * Windows absolute paths (C:\...) are converted to file:// URLs.
+ * On Unix, the path is returned as-is (no-op).
+ */
+export declare function toImportSpecifier(filePath: string): string;
+/** Clears the middleware cache (e.g. during hot reload) */
+export declare function clearMiddlewareCache(): void;
+/** Removes a specific middleware from the cache */
+export declare function invalidateMiddleware(filePath: string): boolean;
+/** Gets the current size of the middleware cache */
+export declare function getMiddlewareCacheSize(): number;
+/** Checks if a key exists in event.context */
+export declare function hasContextValue(event: H3Event, key: string): boolean;
+/** Gets a typed value from event.context */
+export declare function getContextValue<T>(event: H3Event, key: string): T | undefined;
+/** Sets a value in event.context with optional development logging */
+export declare function setContextValue<T>(event: H3Event, key: string, value: T, devMode?: boolean): void;

package/dist/src/middleware/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Avalon Middleware Module
+ *
+ * This module provides a Nitro-aligned middleware system for Avalon that supports
+ * both global middleware (via Nitro's middleware/ directory) and route-scoped
+ * middleware (via _middleware.ts files in page/API directories).
+ *
+ * Key features:
+ * - Nitro-compatible handler signature: return void to continue, return Response to terminate
+ * - Route-scoped middleware discovery in src/pages/ and src/api/
+ * - Priority-based execution order (parent before child)
+ * - Type-safe context augmentation for H3 events
+ *
+ * @example
+ * ```ts
+ * // Define middleware with proper typing
+ * import { defineMiddleware } from 'avalon/middleware';
+ * import { getHeader, createError } from 'h3';
+ *
+ * export default defineMiddleware(async (event) => {
+ *   const token = getHeader(event, 'Authorization');
+ *   if (!token) {
+ *     throw createError({ statusCode: 401, message: 'Unauthorized' });
+ *   }
+ *   event.context.user = await validateToken(token);
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Discover and execute middleware in your server
+ * import { discoverScopedMiddleware, executeScopedMiddleware } from 'avalon/middleware';
+ *
+ * const routes = await discoverScopedMiddleware({ baseDir: 'src', devMode: true });
+ * const response = await executeScopedMiddleware(event, routes);
+ * if (response) return response;
+ * ```
+ *
+ * Requirements: 4.3
+ */
+export type { MiddlewareHandler, MiddlewareFileExport, MiddlewareRoute, MiddlewareDiscoveryOptions, MiddlewareExecutorOptions, } from './types.ts';
+export { discoverScopedMiddleware, getMatchingMiddleware, clearDiscoveryCache } from './discovery.ts';
+export { executeScopedMiddleware, clearMiddlewareCache, invalidateMiddleware, getMiddlewareCacheSize, hasContextValue, getContextValue, setContextValue, } from './executor.ts';

package/dist/src/middleware/types.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Nitro-Aligned Middleware Types
+ *
+ * This module defines types for Avalon's middleware system that align with
+ * Nitro's conventions while preserving route-scoped middleware features.
+ *
+ * Key differences from old middleware system:
+ * - Handler signature: (event: H3Event) => void | Response | Promise<void | Response>
+ * - Return void to continue, return Response to terminate
+ * - Uses event.context for data passing instead of custom state/locals
+ *
+ * Requirements: 1.1
+ */
+import type { H3Event } from 'h3';
+/**
+ * Nitro-aligned middleware handler signature
+ *
+ * This signature matches Nitro's middleware conventions:
+ * - Return nothing (void/undefined) to continue to next middleware
+ * - Return a Response to terminate the chain and send that response
+ * - Throw an error to trigger Nitro's error handling
+ *
+ * @example
+ * ```ts
+ * const handler: MiddlewareHandler = async (event) => {
+ *   // Check auth
+ *   if (!event.context.user) {
+ *     return new Response('Unauthorized', { status: 401 });
+ *   }
+ *   // Continue to next middleware
+ * };
+ * ```
+ */
+export type MiddlewareHandler = (event: H3Event) => void | Response | Promise<void | Response>;
+/**
+ * Route-scoped middleware file export interface
+ *
+ * Middleware files should export a default function matching the MiddlewareHandler signature.
+ *
+ * @example
+ * ```ts
+ * // src/pages/admin/_middleware.ts
+ * export default async (event) => {
+ *   // middleware logic
+ * };
+ * ```
+ */
+export interface MiddlewareFileExport {
+    /** Default export must be a MiddlewareHandler function */
+    default: MiddlewareHandler;
+}
+/**
+ * Discovered middleware route configuration
+ *
+ * Represents a middleware file discovered during scanning, with its
+ * URL pattern, file path, execution priority, and type.
+ */
+export interface MiddlewareRoute {
+    /** URL pattern for matching requests */
+    pattern: URLPattern;
+    /** Absolute path to the middleware file */
+    filePath: string;
+    /** Execution priority (lower numbers execute first) */
+    priority: number;
+    /** Middleware type - determines which routes it applies to */
+    type: 'global' | 'pages';
+}
+/**
+ * Middleware discovery options
+ */
+export interface MiddlewareDiscoveryOptions {
+    /** Base directory to scan (e.g., 'src') */
+    baseDir: string;
+    /** File pattern to match (default: '_middleware.ts') */
+    filePattern?: string;
+    /** Directories to exclude from scanning */
+    excludeDirs?: string[];
+    /** Enable development mode logging */
+    devMode?: boolean;
+}
+/**
+ * Middleware execution options
+ */
+export interface MiddlewareExecutorOptions {
+    /** Enable development mode logging */
+    devMode?: boolean;
+    /** Timeout for middleware execution in milliseconds */
+    timeout?: number;
+}

package/dist/src/nitro/build-config.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Nitro Build Configuration Module for Avalon
+ *
+ * This module provides build configuration utilities for integrating Nitro
+ * with Avalon's Vite-based build pipeline. It handles:
+ * - Vite client build configuration
+ * - Nitro server build configuration
+ * - Preset-specific output configuration
+ * - Source map generation
+ *
+ * @module nitro/build-config
+ */
+import type { Plugin, UserConfig, BuildOptions } from "vite";
+import type { ResolvedAvalonConfig } from "../vite-plugin/types.ts";
+import type { AvalonNitroConfig } from "./config.ts";
+/**
+ * Build mode for the Avalon application
+ */
+export type BuildMode = "client" | "server" | "both";
+/**
+ * Sourcemap option type
+ */
+export type SourcemapOption = boolean | "inline" | "hidden";
+/**
+ * Minify option type
+ */
+export type MinifyOption = boolean | "oxc" | "esbuild" | "terser";
+/**
+ * Preset-specific build output configuration
+ */
+export interface PresetOutputConfig {
+    /** Output directory for the preset */
+    outputDir: string;
+    /** Server entry file name */
+    serverEntry: string;
+    /** Whether the preset supports streaming */
+    supportsStreaming: boolean;
+    /** Whether the preset requires bundled dependencies */
+    bundleDependencies: boolean;
+    /** Additional files to include in output */
+    additionalFiles?: string[];
+    /** Environment-specific configuration */
+    env?: Record<string, string>;
+}
+/**
+ * Avalon build configuration options
+ */
+export interface AvalonBuildConfig {
+    /** Build mode: client, server, or both */
+    mode: BuildMode;
+    /** Output directory for client assets */
+    clientOutDir: string;
+    /** Output directory for server bundle */
+    serverOutDir: string;
+    /** Enable source maps */
+    sourcemap: SourcemapOption;
+    /** Minify output */
+    minify: MinifyOption;
+    /** Target environment */
+    target: string | string[];
+    /** Enable SSR build */
+    ssr: boolean;
+    /** Nitro preset for deployment */
+    preset: string;
+    /** Enable verbose logging */
+    verbose: boolean;
+    /** Nitro v3: Compatibility date for preset features (YYYY-MM-DD) */
+    compatibilityDate?: string;
+    /** Nitro v3: Dependencies to trace instead of bundle */
+    traceDeps?: string[];
+    /** Nitro v3: Rolldown-specific configuration */
+    rolldownConfig?: Record<string, unknown>;
+    /** Nitro v3: Custom server entry point */
+    serverEntry?: string;
+}
+/**
+ * Default build configuration values
+ */
+export declare const DEFAULT_BUILD_CONFIG: AvalonBuildConfig;
+/**
+ * Preset-specific output configurations
+ */
+export declare const PRESET_OUTPUT_CONFIGS: Record<string, PresetOutputConfig>;
+/**
+ * Creates the Vite client build configuration
+ *
+ * @param avalonConfig - Resolved Avalon configuration
+ * @param buildConfig - Build configuration options
+ * @returns Vite build options for client build
+ */
+export declare function createClientBuildConfig(avalonConfig: ResolvedAvalonConfig, buildConfig?: Partial<AvalonBuildConfig>): BuildOptions;
+/**
+ * Creates the Vite server build configuration for Nitro
+ *
+ * @param avalonConfig - Resolved Avalon configuration
+ * @param nitroConfig - Nitro configuration
+ * @param buildConfig - Build configuration options
+ * @returns Vite build options for server build
+ */
+export declare function createServerBuildConfig(avalonConfig: ResolvedAvalonConfig, nitroConfig: AvalonNitroConfig, buildConfig?: Partial<AvalonBuildConfig>): BuildOptions;
+/**
+ * Gets the preset output configuration
+ *
+ * @param preset - Nitro preset name
+ * @returns Preset output configuration
+ */
+export declare function getPresetOutputConfig(preset: string): PresetOutputConfig;
+/**
+ * Checks if a preset supports streaming SSR
+ *
+ * @param preset - Nitro preset name
+ * @returns True if the preset supports streaming
+ */
+export declare function presetSupportsStreaming(preset: string): boolean;
+/**
+ * Creates the combined build configuration for both client and server
+ *
+ * @param avalonConfig - Resolved Avalon configuration
+ * @param nitroConfig - Nitro configuration
+ * @param buildConfig - Build configuration options
+ * @returns Combined Vite user config
+ */
+export declare function createCombinedBuildConfig(avalonConfig: ResolvedAvalonConfig, nitroConfig: AvalonNitroConfig, buildConfig?: Partial<AvalonBuildConfig>): Partial<UserConfig>;
+/**
+ * Creates a Vite plugin for Nitro build integration
+ */
+export declare function createNitroBuildPlugin(avalonConfig: ResolvedAvalonConfig, nitroConfig: AvalonNitroConfig): Plugin;
+/**
+ * Validates build configuration
+ */
+export declare function validateBuildConfig(config: Partial<AvalonBuildConfig>): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Source map configuration options
+ */
+export interface SourceMapConfig {
+    /** Enable source maps */
+    enabled: boolean;
+    /** Source map type: true for external, 'inline' for inline, 'hidden' for hidden */
+    type: SourcemapOption;
+    /** Include source content in source maps */
+    includeContent: boolean;
+    /** Source map URL prefix */
+    sourceRoot?: string;
+}
+/**
+ * Default source map configuration
+ */
+export declare const DEFAULT_SOURCEMAP_CONFIG: SourceMapConfig;
+/**
+ * Creates source map configuration based on environment and preset
+ */
+export declare function createSourceMapConfig(preset: string, isDev: boolean): SourceMapConfig;
+/**
+ * Gets the Vite sourcemap option from SourceMapConfig
+ */
+export declare function getViteSourceMapOption(config: SourceMapConfig): SourcemapOption;
+/**
+ * Creates a Vite plugin for source map handling
+ */
+export declare function createSourceMapPlugin(config: SourceMapConfig): Plugin;

package/dist/src/nitro/config.d.ts

@@ -0,0 +1,268 @@
+/**
+ * Nitro Configuration Module for Avalon
+ *
+ * This module provides configuration interfaces and utilities for integrating
+ * Nitro as Avalon's server runtime. It handles preset configuration, route rules,
+ * and merging Avalon-specific options with Nitro defaults.
+ *
+ * ## Static Asset Handling
+ *
+ * Nitro automatically serves static assets from the `public/` directory at the root path.
+ * The configuration supports:
+ * - `publicAssets`: Configures directories for static file serving
+ * - `routeRules`: Configures cache headers for different asset types
+ * - `staticAssets`: Avalon-specific static asset configuration
+ *
+ * Default route rules for static assets are generated by `createDefaultStaticAssetRouteRules()`:
+ * - `/assets/**`, `/islands/**`, `/chunks/**`: Long cache (1 year, immutable)
+ * - `/*.woff`, `/*.woff2`: Long cache for fonts
+ * - `/*.html`, `/*.css`: Short cache with revalidation
+ * - `/favicon.ico`: Medium cache (1 day)
+ */
+import type { ResolvedAvalonConfig } from '../vite-plugin/types.ts';
+/**
+ * Cache configuration options for route rules
+ */
+export interface CacheOptions {
+    /** Maximum age in seconds for cache validity */
+    maxAge?: number;
+    /** Maximum age in seconds for stale content */
+    staleMaxAge?: number;
+    /** Enable stale-while-revalidate behavior */
+    swr?: boolean;
+}
+/**
+ * Route rule configuration for caching, redirects, proxying, and headers
+ */
+export interface RouteRule {
+    /** Cache configuration or boolean to enable/disable */
+    cache?: CacheOptions | boolean;
+    /** Redirect destination URL */
+    redirect?: string;
+    /** Proxy destination URL */
+    proxy?: string;
+    /** Custom headers to set */
+    headers?: Record<string, string>;
+    /** Enable CORS for this route */
+    cors?: boolean;
+}
+/**
+ * Static asset serving configuration
+ */
+export interface StaticAssetsConfig {
+    /**
+     * Directory containing public static assets
+     * @default "public"
+     */
+    publicDir?: string;
+    /**
+     * Directory containing compiled build output
+     * @default "dist"
+     */
+    buildDir?: string;
+    /**
+     * Enable serving pre-compressed assets (gzip, brotli)
+     * @default true
+     */
+    compression?: boolean;
+    /**
+     * Default cache control header for immutable static assets
+     * @default "public, max-age=31536000, immutable"
+     */
+    cacheControl?: string;
+    /**
+     * Cache control header for mutable assets (HTML, etc.)
+     * @default "public, max-age=0, must-revalidate"
+     */
+    mutableCacheControl?: string;
+    /**
+     * Custom headers to add to all static asset responses
+     */
+    headers?: Record<string, string>;
+}
+/**
+ * Avalon-specific Nitro configuration options
+ */
+export interface AvalonNitroConfig {
+    /**
+     * Deployment preset (vercel, cloudflare, deno-deploy, node-server, netlify, etc.)
+     * @default "node-server"
+     */
+    preset?: string;
+    /**
+     * Directory containing server routes
+     * @default "server"
+     */
+    serverDir?: string;
+    /**
+     * Directory containing pages (overrides Avalon config if set)
+     */
+    pagesDir?: string;
+    /**
+     * Enable streaming SSR responses
+     * @default true
+     */
+    streaming?: boolean;
+    /**
+     * Route rules for caching, redirects, proxying, and headers
+     * Keys are route patterns (e.g., "/api/**", "/static/**")
+     */
+    routeRules?: Record<string, RouteRule>;
+    /**
+     * Runtime configuration accessible via useRuntimeConfig()
+     * Can be overridden by NITRO_ prefixed environment variables
+     */
+    runtimeConfig?: Record<string, unknown>;
+    /**
+     * Public runtime configuration (exposed to client)
+     */
+    publicRuntimeConfig?: Record<string, unknown>;
+    /**
+     * Static asset serving configuration
+     */
+    staticAssets?: StaticAssetsConfig;
+    /** Nitro v3: Compatibility date for preset features (YYYY-MM-DD) */
+    compatibilityDate?: string;
+    /** Nitro v3: Dependencies to trace instead of bundle */
+    traceDeps?: string[];
+    /** Nitro v3: Rolldown-specific configuration */
+    rolldownConfig?: Record<string, unknown>;
+    /** Nitro v3: Custom server entry point */
+    serverEntry?: string;
+    /** Nitro v3: Renderer configuration, or false to disable */
+    renderer?: {
+        handler: string;
+    } | false;
+    /** Nitro v3: Pre-compress public assets (gzip, brotli, zstd) */
+    compressPublicAssets?: boolean | {
+        gzip?: boolean;
+        brotli?: boolean;
+        zstd?: boolean;
+    };
+}
+/**
+ * Nitro configuration output structure
+ * This matches the expected NitroConfig interface from nitro/types
+ */
+export interface NitroConfigOutput {
+    /** Deployment preset */
+    preset: string;
+    /** Server directory */
+    serverDir: string;
+    /** Route rules */
+    routeRules: Record<string, RouteRule>;
+    /** Runtime configuration */
+    runtimeConfig: {
+        avalon: AvalonRuntimeConfig;
+        [key: string]: unknown;
+    };
+    /** Public runtime configuration */
+    publicRuntimeConfig?: Record<string, unknown>;
+    /** Renderer configuration, or false to disable */
+    renderer?: {
+        handler: string;
+    } | false;
+    /** Nitro v3: Compatibility date for preset features (YYYY-MM-DD) */
+    compatibilityDate?: string;
+    /** Nitro v3: Dependencies to trace instead of bundle */
+    traceDeps?: string[];
+    /** Nitro v3: Rolldown-specific configuration */
+    rolldownConfig?: Record<string, unknown>;
+    /** Nitro v3: Custom server entry point */
+    serverEntry?: string;
+    /** Nitro v3: Pre-compress public assets (gzip, brotli, zstd) */
+    compressPublicAssets?: boolean | {
+        gzip?: boolean;
+        brotli?: boolean;
+        zstd?: boolean;
+    };
+    /** Public assets directory */
+    publicAssets?: Array<{
+        dir: string;
+        baseURL?: string;
+        maxAge?: number;
+    }>;
+    /** Server assets configuration */
+    serverAssets?: Array<{
+        baseName: string;
+        dir: string;
+    }>;
+    /** Static assets configuration */
+    staticAssets?: StaticAssetsConfig;
+}
+/**
+ * Avalon-specific runtime configuration stored in Nitro's runtimeConfig
+ */
+export interface AvalonRuntimeConfig {
+    /** Enable streaming SSR */
+    streaming: boolean;
+    /** Pages directory path */
+    pagesDir: string;
+    /** Layouts directory path */
+    layoutsDir: string;
+    /** Source directory path */
+    srcDir?: string;
+}
+/**
+ * Default static assets configuration
+ */
+export declare const DEFAULT_STATIC_ASSETS_CONFIG: Required<StaticAssetsConfig>;
+/**
+ * All valid Nitro v3 preset names (underscore convention).
+ */
+export declare const VALID_V3_PRESETS: string[];
+/**
+ * Validates a preset name against the v3 preset list.
+ * Returns the preset name if valid, throws if unrecognized.
+ *
+ * @param preset - The preset name to validate (must be a v3 name)
+ * @returns The validated v3 preset name
+ * @throws Error if the preset is not recognized
+ */
+export declare function resolvePresetName(preset: string): string;
+/**
+ * Default Nitro configuration values
+ */
+export declare const DEFAULT_NITRO_CONFIG: Required<Pick<AvalonNitroConfig, 'preset' | 'serverDir' | 'streaming'>>;
+/**
+ * Creates a Nitro configuration from Avalon plugin config and Nitro-specific options
+ *
+ * This function merges Avalon's resolved configuration with Nitro-specific options
+ * to produce a complete Nitro configuration object. Avalon-specific settings are
+ * stored in `runtimeConfig.avalon` for access by handlers.
+ *
+ * @param avalonNitroConfig - Nitro-specific configuration options
+ * @param resolvedAvalonConfig - Resolved Avalon plugin configuration
+ * @returns Complete Nitro configuration object
+ *
+ * @example
+ * ```ts
+ * const nitroConfig = createNitroConfig(
+ *   { preset: 'vercel', streaming: true },
+ *   resolvedAvalonConfig
+ * );
+ * ```
+ */
+export declare function createNitroConfig(avalonNitroConfig: AvalonNitroConfig, resolvedAvalonConfig: ResolvedAvalonConfig): NitroConfigOutput;
+/**
+ * Creates default route rules for static asset caching
+ *
+ * @param config - Static assets configuration
+ * @returns Route rules for static assets
+ */
+export declare function createDefaultStaticAssetRouteRules(config: StaticAssetsConfig): Record<string, RouteRule>;
+/**
+ * Validates a Nitro preset name against the v3 preset list
+ *
+ * @param preset - The preset name to validate
+ * @returns True if the preset is a known valid v3 preset
+ */
+export declare function isValidPreset(preset: string): boolean;
+/**
+ * Merges route rules, with later rules taking precedence
+ *
+ * @param baseRules - Base route rules
+ * @param overrideRules - Override route rules
+ * @returns Merged route rules
+ */
+export declare function mergeRouteRules(baseRules: Record<string, RouteRule>, overrideRules: Record<string, RouteRule>): Record<string, RouteRule>;