@h3ravel/router 1.13.6 → 1.15.0-alpha.1

package/dist/index.js

@@ -1,15 +1,172 @@
-import { Logger, Resolver } from "@h3ravel/shared";
-import { Command } from "@h3ravel/musket";
-import { readFile, readdir, stat } from "node:fs/promises";
-import { Container, Kernel, ServiceProvider } from "@h3ravel/core";
-import { Str } from "@h3ravel/support";
-import path, { join } from "node:path";
-import { serveStatic } from "h3";
-import { statSync } from "node:fs";
+import { Arr, Collection, Macroable, MacroableClass, Obj, RuntimeException, ServiceProvider, Str, Stringable, isCallable, isClass, optional, tap } from "@h3ravel/support";
+import { Injectable, LogicException, ModelNotFoundException, NotFoundHttpException, RouteNotFoundException, UrlGenerationException } from "@h3ravel/foundation";
+import { IApplication, ICallableDispatcher, IControllerDispatcher, IResponsable, IResponse, IRoute, IRouteUrlGenerator, IRouter, IUrlGenerator, UrlRoutable } from "@h3ravel/contracts";
 import "reflect-metadata";
-import { HttpContext as HttpContext$1, Request, Response } from "@h3ravel/http";
-import { Model } from "@h3ravel/database";
+import { Finalizable, Logger, Magic, UseMagic, internal, mix, trait, use } from "@h3ravel/shared";
+import { Command } from "@h3ravel/musket";
+import { JsonResponse, Middleware, Request, Response, UnexpectedValueException } from "@h3ravel/http";
+import { createRequire } from "module";
+import { existsSync } from "node:fs";
+import crypto from "crypto";
+
+//#region src/AbstractRouteCollection.ts
+var AbstractRouteCollection = class AbstractRouteCollection {
+	static verbs = [
+		"GET",
+		"HEAD",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE",
+		"OPTIONS"
+	];
+	/**
+	* Match a request against a set of routes belonging to one HTTP verb.
+	* 
+	* @param routes 
+	* @param req 
+	* @param includingMethod 
+	* @returns 
+	*/
+	matchAgainstRoutes(routes, req, includingMethod = true) {
+		const [fallbacks, routeList] = new Collection(routes).partition(function(route) {
+			return route.isFallback;
+		});
+		return new Collection({
+			...routeList.all(),
+			...fallbacks.all()
+		}).first((route) => route.matches(req, includingMethod));
+	}
+	/**
+	* Final handler for a matched route. Responsible for:
+	* - Throwing for not found
+	* - Throwing for method not allowed
+	* - Attaching params extracted from the match
+	* 
+	* @param req 
+	* @param route 
+	* @returns 
+	*/
+	handleMatchedRoute(req, route) {
+		if (route) return route.bind(req);
+		throw new NotFoundHttpException(`The route "${req.path()}" was not found.`, void 0, 404);
+	}
+	/**
+	* Determine if any routes match on another HTTP verb.
+	*
+	* @param  request
+	*/
+	checkForAlternateVerbs(request) {
+		return AbstractRouteCollection.verbs.filter((m) => m !== request.getMethod()).filter((method) => {
+			const routesForMethod = this.get(method);
+			return this.matchAgainstRoutes(routesForMethod, request) != null;
+		});
+	}
+	matchDomain(domain, host) {
+		if (!domain) return true;
+		if (domain === host) return true;
+		if (domain.includes("*")) {
+			const pattern = domain.replace("*", "(.*)");
+			return (/* @__PURE__ */ new RegExp(`^${pattern}$`)).test(host);
+		}
+		return false;
+	}
+	matchUri(route, path) {
+		return path === route.uri();
+	}
+	/**
+	* Count the number of items in the collection.
+	*/
+	count() {
+		return this.getRoutes().length;
+	}
+};
+
+//#endregion
+//#region src/Traits/RouteDependencyResolver.ts
+var RouteDependencyResolver = class {
+	constructor(container) {
+		this.container = container;
+	}
+	/**
+	* Resolve the object method's type-hinted dependencies.
+	*
+	* @param  parameters
+	* @param  instance
+	* @param  method
+	*/
+	async resolveClassMethodDependencies(parameters, instance, method) {
+		/**
+		* Ensure the method exists on the controller
+		*/
+		if (typeof instance[method] !== "function") throw new RuntimeException(`[${method}] not found on controller [${instance.constructor.name}]`);
+		/**
+		* Get param types for the controller method
+		*/
+		const paramTypes = Reflect.getMetadata("design:paramtypes", instance, method) || [];
+		/**
+		* Resolve the bound dependencies
+		*/
+		let args = await Promise.all(paramTypes.map(async (paramType) => {
+			const instance$1 = Object.values(parameters).find((e) => e instanceof paramType);
+			if (instance$1 && typeof instance$1 === "object") return instance$1;
+			return await this.container.make(paramType);
+		}));
+		/**
+		* Ensure that the HttpContext and Application instances are always available
+		*/
+		if (args.length < 1) args = [this.container.getHttpContext(), this.container];
+		/**
+		* Call the controller method, passing all resolved dependencies
+		*/
+		return this.resolveMethodDependencies([...args, ...Object.values(parameters)]);
+	}
+	/**
+	* Resolve the given method's type-hinted dependencies.
+	*
+	* @param  parameters
+	*/
+	resolveMethodDependencies(parameters) {
+		/**
+		* Call the route callback handler
+		*/
+		return parameters;
+	}
+};
+
+//#endregion
+//#region src/CallableDispatcher.ts
+var CallableDispatcher = class extends mix(ICallableDispatcher, RouteDependencyResolver) {
+	/**
+	* 
+	* @param container The container instance.
+	*/
+	constructor(container) {
+		super(container);
+		this.container = container;
+	}
+	/**
+	* Dispatch a request to a given callback.
+	*
+	* @param  route
+	* @param  handler
+	* @param  method
+	*/
+	async dispatch(route, handler) {
+		return handler(this.container.make("http.context"), ...Object.values(this.resolveParameters(route)));
+	}
+	/**
+	* Resolve the parameters for the callable.
+	*
+	* @param  route
+	* @param  handler
+	*/
+	resolveParameters(route) {
+		return this.resolveMethodDependencies(route.parametersWithoutNulls());
+	}
+};
 
+//#endregion
 //#region src/Commands/RouteListCommand.ts
 var RouteListCommand = class extends Command {
 	/**
@@ -21,6 +178,11 @@ var RouteListCommand = class extends Command {
         {list : List all registered routes. 
             | {--json : Output the route list as JSON}
             | {--r|reverse : Reverse the ordering of the routes}
+            | {--s|sort=uri : Sort the routes by a given column (uri, name, method)}
+            | {--m|method= : Filter the routes by a specific HTTP method}
+            | {--n|name= : Filter the routes by a specific name}
+            | {--p|path= : Filter the routes by a specific path}
+            | {--e|except-path= : Exclude routes with a specific path}
         }
     `;
 	/**
@@ -33,32 +195,101 @@ var RouteListCommand = class extends Command {
 	* Execute the console command.
 	*/
 	async handle() {
-		console.log("");
-		const command = this.dictionary.baseCommand ?? this.dictionary.name;
-		await this[command]();
+		this.newLine();
+		if (!this.app.make("router").getRoutes().count()) {
+			this.error("ERROR: Your application doesn't have any routes.").newLine();
+			return;
+		}
+		const routes = this.getRoutes();
+		if (routes.length === 0) {
+			this.error("ERROR: Your application doesn't have any routes matching the given criteria.").newLine();
+			return;
+		}
+		await this.showRoutes(routes);
 	}
 	/**
-	* List all registered routes.
+	* Compile the routes into a displayable format.
 	*/
-	async list() {
+	getRoutes() {
 		/**
-		* Log the route list
+		* Sort the routes alphabetically
 		*/
-		[...this.app.make("app.routes")].sort((a, b) => {
+		const list = this.app.make("router").getRoutes().getRoutes().sort((a, b) => {
 			if (a.path === "/" && b.path !== "/") return -1;
 			if (b.path === "/" && a.path !== "/") return 1;
 			return a.path.localeCompare(b.path);
-		}).filter((e) => !["head", "patch"].includes(e.method)).forEach((route) => {
-			const path$1 = route.path === "/" ? route.path : Logger.log(route.path.slice(1).split("/").map((e) => [(e.includes(":") ? Logger.log("/", "white", false) : "") + e, e.startsWith(":") ? "yellow" : "white"]), "", false);
-			const method = (route.method.startsWith("/") ? route.method.slice(1) : route.method).toUpperCase();
-			const name = route.signature[1] ? [
-				route.name ?? "",
-				route.name ? "›" : "",
-				route.signature.join("@")
-			].join(" ") : "";
-			const desc = Logger.describe(Logger.log(Logger.log(method + this.pair(method), this.color(method), false), "green", false), path$1, 15, false);
-			return Logger.twoColumnDetail(desc.join(""), name);
 		});
+		if (this.option("reverse")) list.reverse();
+		if (this.option("sort")) {
+			const sort = this.option("sort").toLowerCase();
+			list.sort((a, b) => {
+				switch (sort) {
+					case "uri": return a.path.localeCompare(b.path);
+					case "name": return (a.getName() ?? "").localeCompare(b.getName() ?? "");
+					case "method": return a.methods.join("|").localeCompare(b.methods.join("|"));
+					default: return 0;
+				}
+			});
+		}
+		if (this.option("method")) {
+			const method = this.option("method").toUpperCase();
+			list.splice(0, list.length, ...list.filter((route) => route.getMethods().includes(method)));
+		}
+		if (this.option("name")) {
+			const name = this.option("name");
+			list.splice(0, list.length, ...list.filter((route) => route.getName() === name));
+		}
+		if (this.option("path")) {
+			const path = this.option("path");
+			list.splice(0, list.length, ...list.filter((route) => route.path === path));
+		}
+		if (this.option("except-path")) {
+			const path = this.option("except-path");
+			list.splice(0, list.length, ...list.filter((route) => route.path !== path));
+		}
+		return list;
+	}
+	/**
+	* List all registered routes.
+	*/
+	async showRoutes(list) {
+		if (this.option("json")) return this.asJson(list);
+		return this.forCli(list);
+	}
+	forCli(list) {
+		/**
+		* Log the route list
+		*/
+		list.forEach((route) => {
+			const uri = route.uri();
+			const name = route.getName() ?? "";
+			const formatedPath = uri === "/" ? uri : uri.split("/").map((e) => [e, /\{.*\}/.test(e) ? "yellow" : "white"]).reduce((acc, [segment, color], i) => {
+				return acc + (i > 0 ? Logger.log("/", "white", false) : "") + Logger.log(segment, color, false);
+			}, "");
+			const formatedMethod = route.getMethods().map((method) => Logger.log(method, this.color(method), false)).join(Logger.log("|", "gray", false));
+			const formatedName = route.action.controller ? [
+				name,
+				name !== "" ? "›" : "",
+				route.action.controller
+			].join(" ") : name;
+			const desc = Logger.describe(Logger.log(formatedMethod, "green", false), formatedPath, 15, false);
+			return Logger.twoColumnDetail(desc.join(""), formatedName);
+		});
+		this.newLine(2);
+		Logger.split("", Logger.log(`Showing [${list.length}] routes`, ["blue", "bold"], false), "info", false, false, " ");
+	}
+	asJson(list) {
+		const routes = list.map((route) => ({
+			methods: route.getMethods(),
+			uri: route.uri(),
+			name: route.getName(),
+			action: route.action
+		}));
+		if (this.app.runningInConsole()) {
+			this.newLine();
+			console.log(JSON.stringify(routes, null, 2));
+			this.newLine();
+		} else return routes;
 	}
 	/**
 	* Get the color
@@ -82,13 +313,247 @@ var RouteListCommand = class extends Command {
 	*/
 	pair(method) {
 		switch (method.toLowerCase()) {
-			case "get": return Logger.log("|", "gray", false) + Logger.log("HEAD", this.color("head"), false);
-			case "put": return Logger.log("|", "gray", false) + Logger.log("PATCH", this.color("patch"), false);
+			case "get": return Logger.log("|", "gray", false) + Logger.log("HEAD", this.color("HEAD"), false);
+			case "put": return Logger.log("|", "gray", false) + Logger.log("PATCH", this.color("PATCH"), false);
 			default: return "";
 		}
 	}
 };
 
+//#endregion
+//#region src/CompiledRoute.ts
+var CompiledRoute = class {
+	path;
+	tokens;
+	variables;
+	paramNames;
+	optionalParams;
+	regex;
+	hostPattern;
+	hostRegex;
+	constructor(path, optionalParams, hostPattern) {
+		this.path = path;
+		this.variables = this.buildParams();
+		this.paramNames = this.variables;
+		this.optionalParams = optionalParams;
+		this.hostPattern = hostPattern;
+		this.tokens = this.tokenizePath();
+		this.regex = this.buildRegex(this.path, this.paramNames, this.optionalParams);
+		if (this.hostPattern) this.hostRegex = this.buildRegex(this.hostPattern, [], {});
+	}
+	/**
+	* Get the compiled path regex
+	*/
+	getRegex() {
+		return this.regex;
+	}
+	/**
+	* Get the compiled host regex (if any)
+	*/
+	getHostRegex() {
+		return this.hostRegex;
+	}
+	/**
+	* Returns list of all param names (including optional)
+	*/
+	getParamNames() {
+		return this.paramNames;
+	}
+	/**
+	* Returns list of all path variables
+	*/
+	getVariables() {
+		return this.variables;
+	}
+	/**
+	* Returns list of all compiled tokens
+	*/
+	getTokens() {
+		return this.tokens;
+	}
+	/**
+	* Returns optional params record
+	*/
+	getOptionalParams() {
+		return { ...this.optionalParams };
+	}
+	/**
+	* Build the route params
+	* 
+	* @returns 
+	*/
+	buildParams() {
+		const paramNames = [];
+		this.path.replace(/\{([\w]+)(?:[:][\w]+)?\??\}/g, (_, paramName) => {
+			paramNames.push(paramName);
+			return "";
+		});
+		return paramNames;
+	}
+	/**
+	* Build a regex from a path pattern
+	* 
+	* @param path 
+	* @param paramNames 
+	* @param optionalParams 
+	* @returns 
+	*/
+	buildRegex(path, paramNames, optionalParams) {
+		const regexStr = path.replace(/\/?\{([a-zA-Z0-9_]+)(\?)?(?::[a-zA-Z0-9_]+)?\}/g, (_, paramName, optionalMark) => {
+			if (optionalMark === "?" || optionalParams[paramName] === null) return "(?:/([^/]+))?";
+			else return "/([^/]+)";
+		});
+		return /* @__PURE__ */ new RegExp(`^${regexStr}$`);
+	}
+	/**
+	* Tokenize the the path
+	* 
+	* @param optionalParams 
+	* @returns 
+	*/
+	tokenizePath() {
+		const tokens = [];
+		const regex = /(\{([a-zA-Z0-9_]+)(\?)?(?::[a-zA-Z0-9_]+)?\})|([^{}]+)/g;
+		let match;
+		while ((match = regex.exec(this.path)) !== null) if (match[1]) {
+			const paramName = match[2];
+			const isOptional = match[3] === "?" || this.optionalParams[paramName] === null;
+			const prefix = match.index === 0 ? "" : "/";
+			tokens.push([
+				"variable",
+				prefix,
+				"[^/]++",
+				paramName,
+				!isOptional
+			]);
+		} else if (match[4]) tokens.push(["text", match[4]]);
+		return tokens;
+	}
+};
+
+//#endregion
+//#region src/Contracts/IRouteValidator.ts
+var IRouteValidator = class {};
+
+//#endregion
+//#region src/Traits/FiltersControllerMiddleware.ts
+var FiltersControllerMiddleware = class {
+	/**
+	* Determine if the given options exclude a particular method.
+	*
+	* @param  method
+	* @param  options
+	*/
+	static methodExcludedByOptions(method, options) {
+		return typeof options.only !== "undefined" && !options.only.includes(method) || !!options.except && options.except.length > 0 && options.except.includes(method);
+	}
+};
+
+//#endregion
+//#region src/ControllerDispatcher.ts
+var ControllerDispatcher = class ControllerDispatcher extends mix(IControllerDispatcher, RouteDependencyResolver, FiltersControllerMiddleware) {
+	/**
+	* 
+	* @param container The container instance.
+	*/
+	constructor(container) {
+		super(container);
+		this.container = container;
+	}
+	/**
+	* Dispatch a request to a given controller and method.
+	*
+	* @param  route
+	* @param  controller
+	* @param  method
+	*/
+	async dispatch(route, controller, method) {
+		const parameters = await this.resolveParameters(route, controller, method);
+		if (Object.prototype.hasOwnProperty.call(controller, "callAction")) return controller.callAction(method, Object.values(parameters));
+		return await controller[method].apply(controller, [...Object.values(parameters)]);
+	}
+	/**
+	* Resolve the parameters for the controller.
+	*
+	* @param  route
+	* @param  controller
+	* @param  method
+	*/
+	async resolveParameters(route, controller, method) {
+		return this.resolveClassMethodDependencies(route.parametersWithoutNulls(), controller, method);
+	}
+	/**
+	* Get the middleware for the controller instance.
+	*
+	* @param  controller
+	* @param  method
+	*/
+	getMiddleware(controller, method) {
+		if (!Object.prototype.hasOwnProperty.call(controller, "getMiddleware")) return [];
+		return new Collection(controller.getMiddleware?.() ?? {}).reject((data) => ControllerDispatcher.methodExcludedByOptions(method, data.options)).pluck("middleware").all();
+	}
+};
+
+//#endregion
+//#region src/Events/PreparingResponse.ts
+var PreparingResponse = class {
+	/**
+	* Create a new event instance.
+	*
+	* 
+	* @param $request  The request instance.
+	* @param $response  The response instance.
+	*/
+	constructor(request, response$1) {
+		this.request = request;
+		this.response = response$1;
+	}
+};
+
+//#endregion
+//#region src/Events/ResponsePrepared.ts
+var ResponsePrepared = class {
+	/**
+	* Create a new event instance.
+	*
+	* 
+	* @param $request  The request instance.
+	* @param $response  The response instance.
+	*/
+	constructor(request, response$1) {
+		this.request = request;
+		this.response = response$1;
+	}
+};
+
+//#endregion
+//#region src/Events/RouteMatched.ts
+var RouteMatched = class {
+	/**
+	* Create a new event instance.
+	*
+	* @param route  The route instance.
+	* @param request  The request instance.
+	*/
+	constructor(route, request) {
+		this.route = route;
+		this.request = request;
+	}
+};
+
+//#endregion
+//#region src/Events/Routing.ts
+var Routing = class {
+	/**
+	* Create a new event instance.
+	*
+	* @param request  The request instance.
+	*/
+	constructor(request) {
+		this.request = request;
+	}
+};
+
 //#endregion
 //#region src/Helpers.ts
 var Helpers = class Helpers {
@@ -102,11 +567,11 @@ var Helpers = class Helpers {
 	* @param path - The route path string (e.g. "/groups/:group/users/:user")
 	* @returns An array of parameter names (e.g. ["group", "user"])
 	*/
-	static extractParams(path$1) {
+	static extractParams(path) {
 		const regex = /:([^/]+)/g;
 		const params = [];
 		let match;
-		while ((match = regex.exec(path$1)) !== null) params.push(match[1]);
+		while ((match = regex.exec(path)) !== null) params.push(match[1]);
 		return params;
 	}
 	/**
@@ -123,7 +588,7 @@ var Helpers = class Helpers {
 	* @param model - The model instance to resolve bindings against
 	* @returns A resolved model instance or an object containing param values
 	*/
-	static async resolveRouteModelBinding(path$1, ctx, model) {
+	static async resolveRouteModelBinding(path, ctx, model) {
 		const name = model.constructor.name.toLowerCase();
 		/**
 		* Extract field (defaults to 'id' if not specified after '|')
@@ -132,7 +597,7 @@ var Helpers = class Helpers {
 		/**
 		* Iterate through extracted parameters from the path
 		*/
-		for await (const e of Helpers.extractParams(path$1)) {
+		for await (const e of Helpers.extractParams(path)) {
 			const value = ctx.request.params[e] ?? null;
 			if (e === name) return await model.resolveRouteBinding(value, field);
 			else return { [e]: ctx.request.params[e] ?? {} };
@@ -142,405 +607,4003 @@ var Helpers = class Helpers {
 };
 
 //#endregion
-//#region src/Providers/AssetsServiceProvider.ts
-/**
-* Handles public assets loading
-* 
-* Auto-Registered
-*/
-var AssetsServiceProvider = class extends ServiceProvider {
-	static priority = 996;
-	register() {
-		const app = this.app.make("router");
-		const publicPath = this.app.getPath("public");
-		/**
-		* Use a middleware to check if this request for for a file
-		*/
-		app.middleware((event) => {
-			const { pathname } = new URL(event.req.url);
-			/**
-			* Only serve if it looks like a static asset (has an extension)
-			* but skip dotfiles or sensitive files
-			*/
-			if (!/\.[a-zA-Z0-9]+$/.test(pathname)) return;
-			if (pathname.startsWith("/.") || pathname.includes("..")) return;
-			/**
-			* Serve the asset
-			*/
-			return serveStatic(event, {
-				indexNames: ["/index.html"],
-				getContents: (id) => {
-					return readFile(join(Str.before(publicPath, id), id));
-				},
-				getMeta: async (id) => {
-					const stats = await stat(join(Str.before(publicPath, id), id)).catch(() => {});
-					if (stats?.isFile()) return {
-						size: stats.size,
-						mtime: stats.mtimeMs
-					};
-				}
-			});
-		});
-		this.app.singleton("asset", () => {
-			return (key, def) => {
-				if (def) try {
-					statSync(join(Str.before(publicPath, key), key));
-				} catch {
-					key = def;
-				}
-				return key;
-			};
-		});
-	}
-};
-
-//#endregion
-//#region src/Route.ts
-var Router = class {
-	routes = [];
-	nameMap = [];
-	groupPrefix = "";
-	middlewareMap = [];
-	groupMiddleware = [];
-	constructor(h3App, app) {
-		this.h3App = h3App;
-		this.app = app;
-	}
+//#region src/ImplicitRouteBinding.ts
+var ImplicitRouteBinding = class {
 	/**
-	* Route Resolver
+	* Resolve the implicit route bindings for the given route.
 	* 
-	* @param handler 
-	* @param middleware 
-	* @returns 
+	* @param container 
+	* @param route 
 	*/
-	resolveHandler(handler, middleware = []) {
-		return async (event) => {
-			this.app.context ??= async (event$1) => {
-				if (event$1._h3ravelContext) return event$1._h3ravelContext;
-				Request.enableHttpMethodParameterOverride();
-				const ctx = HttpContext$1.init({
-					app: this.app,
-					request: await Request.create(event$1, this.app),
-					response: new Response(event$1, this.app)
-				});
-				event$1._h3ravelContext = ctx;
-				return ctx;
-			};
-			return new Kernel(this.app.context, middleware).handle(event, (ctx) => new Promise((resolve) => {
-				if (Resolver.isAsyncFunction(handler)) handler(ctx).then((response) => {
-					if (response instanceof Response) resolve(response.prepare(ctx.request).send());
-					else resolve(response);
-				});
-				else resolve(handler(ctx));
-			}));
-		};
+	static async resolveForRoute(container, route) {
+		const parameters = route.getParameters();
+		for (const parameter of route.signatureParameters({ subClass: UrlRoutable })) {
+			const parameterName = this.getParameterName(parameter.getName(), parameters);
+			if (!parameterName) continue;
+			const parameterValue = parameters[parameterName];
+			if (parameterValue instanceof UrlRoutable) continue;
+			const instanceClass = parameter.getType();
+			const instance = container.make(instanceClass);
+			const parent = route.parentOfParameter(parameterName);
+			const isSoftDeletable = typeof instanceClass.isSoftDeletable === "function" && instanceClass.isSoftDeletable();
+			const useSoftDelete = route.allowsTrashedBindings() && isSoftDeletable;
+			let model;
+			if (parent instanceof UrlRoutable && !route.preventsScopedBindings() && (route.enforcesScopedBindings() || parameterName in route.getBindingFields())) {
+				const childMethod = useSoftDelete ? "resolveSoftDeletableChildRouteBinding" : "resolveChildRouteBinding";
+				model = await Reflect.apply(parent[childMethod], parent, [
+					parameterName,
+					parameterValue,
+					route.bindingFieldFor(parameterName)
+				]);
+			} else {
+				const method = useSoftDelete ? "resolveSoftDeletableRouteBinding" : "resolveRouteBinding";
+				model = await Reflect.apply(instance[method], instance, [parameterValue, route.bindingFieldFor(parameterName)]);
+			}
+			if (!model) throw new ModelNotFoundException().setModel(instanceClass, [parameterValue]);
+			route.setParameter(parameterName, model);
+		}
 	}
 	/**
-	* Add a route to the stack
+	* Return the parameter name if it exists in the given parameters.
 	* 
-	* @param method
-	* @param path
-	* @param handler
-	* @param name
-	* @param middleware
+	* @param name 
+	* @param parameters 
+	* @returns 
 	*/
-	addRoute(method, path$1, handler, name, middleware = [], signature = ["", ""]) {
-		/**
-		* Join all defined route names to make a single route name
-		*/
-		if (this.nameMap.length > 0) name = this.nameMap.join(".");
-		/**
-		* Join all defined middlewares
-		*/
-		if (this.middlewareMap.length > 0) middleware = this.middlewareMap;
-		const fullPath = `${this.groupPrefix}${path$1}`.replace(/\/+/g, "/");
-		this.routes.push({
-			method,
-			path: fullPath,
-			name,
-			handler,
-			signature
-		});
-		this.h3App[method](fullPath, this.resolveHandler(handler, middleware));
-		this.app.singleton("app.routes", () => this.routes);
+	static getParameterName(name, parameters) {
+		if (name in parameters) return name;
+		const snakedName = Str.snake(name);
+		if (snakedName in parameters) return snakedName;
 	}
+};
+
+//#endregion
+//#region src/Matchers/HostValidator.ts
+var HostValidator = class extends IRouteValidator {
 	/**
-	* Resolves a route handler definition into an executable EventHandler.
-	*
-	* A handler can be:
-	*   - A function matching the EventHandler signature
-	*   - A controller class (optionally decorated for IoC resolution)
+	* Validate a given rule against a route and request.
 	*
-	* If it’s a controller class, this method will:
-	*   - Instantiate it (via IoC or manually)
-	*   - Call the specified method (defaults to `index`)
-	*
-	* @param handler     Event handler function OR controller class
-	* @param methodName  Method to invoke on the controller (defaults to 'index')
+	* @param  route
+	* @param  request
 	*/
-	resolveControllerOrHandler(handler, methodName, path$1) {
-		/**
-		* Checks if the handler is a function (either a plain function or a class constructor)
-		*/
-		if (typeof handler === "function" && typeof handler.prototype !== "undefined") return async (ctx) => {
-			let controller;
-			if (Container.hasAnyDecorator(handler))
- /**
-			* If the controller is decorated use the IoC container
-			*/
-			controller = this.app.make(handler);
-			else
- /**
-			* Otherwise instantiate manually so that we can at least
-			* pass the app instance
-			*/
-			controller = new handler(this.app);
-			/**
-			* The method to execute (defaults to 'index')
-			*/
-			const action = methodName || "index";
-			/**
-			* Ensure the method exists on the controller
-			*/
-			if (typeof controller[action] !== "function") throw new Error(`Method "${String(action)}" not found on controller ${handler.name}`);
-			/**
-			* Get param types for the controller method
-			*/
-			const paramTypes = Reflect.getMetadata("design:paramtypes", controller, action) || [];
-			/**
-			* Resolve the bound dependencies
-			*/
-			let args = await Promise.all(paramTypes.map(async (paramType) => {
-				switch (paramType?.name) {
-					case "Application": return this.app;
-					case "Request": return ctx.request;
-					case "Response": return ctx.response;
-					case "HttpContext": return ctx;
-					default: {
-						const inst = this.app.make(paramType);
-						if (inst instanceof Model) return await Helpers.resolveRouteModelBinding(path$1 ?? "", ctx, inst);
-						return inst;
-					}
-				}
-			}));
-			/**
-			* Ensure that the HttpContext is always available
-			*/
-			if (args.length < 1) args = [ctx];
-			/**
-			* Call the controller method, passing all resolved dependencies
-			*/
-			return await controller[action](...args);
-		};
-		return handler;
+	matches(route, request) {
+		const hostRegex = route.getCompiled()?.getHostRegex();
+		if (!hostRegex) return true;
+		return hostRegex.test(request.getHost());
 	}
+};
+
+//#endregion
+//#region src/Matchers/MethodValidator.ts
+var MethodValidator = class extends IRouteValidator {
 	/**
-	* Registers a route that responds to HTTP GET requests.
+	* Validate a given rule against a route and request.
 	*
-	* @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-	* @param definition  Either:
-	*                      - An EventHandler function
-	*                      - A tuple: [ControllerClass, methodName]
-	* @param name        Optional route name (for URL generation or referencing).
-	* @param middleware  Optional array of middleware functions to execute before the handler.
+	* @param  route
+	* @param  request
 	*/
-	get(path$1, definition, name, middleware = []) {
-		const handler = Array.isArray(definition) ? definition[0] : definition;
-		const methodName = Array.isArray(definition) ? definition[1] : void 0;
-		this.addRoute("get", path$1, this.resolveControllerOrHandler(handler, methodName, path$1), name, middleware, [handler.name, methodName]);
-		return this;
+	matches(route, request) {
+		return route.methods.includes(request.getMethod());
+	}
+};
+
+//#endregion
+//#region src/Matchers/SchemeValidator.ts
+var SchemeValidator = class extends IRouteValidator {
+	/**
+	* Validate a given rule against a route and request.
+	*
+	* @param  route
+	* @param  request
+	*/
+	matches(route, request) {
+		if (route.httpOnly()) return !request.secure();
+		else if (route.secure()) return request.secure();
+		return true;
+	}
+};
+
+//#endregion
+//#region src/Matchers/UriValidator.ts
+var UriValidator = class extends IRouteValidator {
+	/**
+	* Validate a given rule against a route and request.
+	*
+	* @param  route
+	* @param  request
+	*/
+	matches(route, request) {
+		const path = Str.of(request.getPathInfo()).ltrim("/").rtrim("/").toString() || "/";
+		return route.getCompiled().getRegex().test(decodeURIComponent(path));
+	}
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.99.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.99.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region src/Middleware/SubstituteBindings.ts
+var _ref$1, _ref2, _ref3;
+let SubstituteBindings = class SubstituteBindings$1 extends Middleware {
+	/**
+	* 
+	* @param router The router instance.
+	*/
+	constructor(app, router) {
+		super(app);
+		this.app = app;
+		this.router = router;
+	}
+	/**
+	* Handle an incoming request.
+	*
+	* @param  request
+	* @param  next
+	*/
+	async handle(request, next) {
+		const route = request.route();
+		try {
+			await this.router.substituteBindings(route);
+			await this.router.substituteImplicitBindings(route);
+		} catch (e) {
+			if (e instanceof ModelNotFoundException) {
+				const getMissing = route.getMissing();
+				if (typeof getMissing !== "undefined") return getMissing(request, e);
+			}
+			throw e;
+		}
+		return next(request);
+	}
+};
+__decorate([
+	Injectable(),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [typeof (_ref3 = typeof Request !== "undefined" && Request) === "function" ? _ref3 : Object, Function]),
+	__decorateMetadata("design:returntype", Promise)
+], SubstituteBindings.prototype, "handle", null);
+SubstituteBindings = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof (_ref$1 = typeof IApplication !== "undefined" && IApplication) === "function" ? _ref$1 : Object, typeof (_ref2 = typeof IRouter !== "undefined" && IRouter) === "function" ? _ref2 : Object])], SubstituteBindings);
+
+//#endregion
+//#region src/MiddlewareResolver.ts
+var MiddlewareResolver = class {
+	static app;
+	static setApp(app) {
+		this.app = app;
+		return this;
+	}
+	/**
+	* Resolve the middleware name to a class name(s) preserving passed parameters.
+	*/
+	static resolve(name, map, middlewareGroups) {
+		/**
+		* Inline middleware (closure)
+		*/
+		if (typeof name !== "string") return name;
+		/**
+		* Mapped closure
+		*/
+		if (map[name] && typeof map[name] === "function") return map[name];
+		/**
+		* Middleware group
+		*/
+		if (middlewareGroups[name]) return this.parseMiddlewareGroup(name, map, middlewareGroups);
+		/**
+		* Parse name + parameters
+		*/
+		const [base, parameters] = name.split(":", 2);
+		const resolved = map[base] ?? base;
+		return parameters ? `${resolved}:${parameters}` : resolved;
+	}
+	/**
+	* Parse the middleware group and format it for usage.
+	*/
+	static parseMiddlewareGroup(name, map, middlewareGroups) {
+		const results = [];
+		for (const middleware of middlewareGroups[name]) {
+			/**
+			* Nested group
+			*/
+			if (typeof middleware === "string" && middlewareGroups[middleware]) {
+				results.push(...this.parseMiddlewareGroup(middleware, map, middlewareGroups));
+				continue;
+			}
+			let resolved = "";
+			let parameters = "";
+			if (typeof middleware === "string") {
+				const base = middleware.split(":", 2)[0];
+				parameters = middleware.split(":", 2)[1];
+				resolved = map[base] ?? base;
+				results.push(parameters ? `${String(resolved)}:${parameters}` : String(resolved));
+				const bound = this.app.boundMiddlewares(resolved);
+				if (bound) results.push(bound);
+			} else {
+				const bound = this.app.boundMiddlewares(middleware);
+				if (bound) results.push(bound);
+			}
+		}
+		return results.filter((e) => typeof e !== "string");
+	}
+};
+
+//#endregion
+//#region src/Traits/CreatesRegularExpressionRouteConstraints.ts
+const CreatesRegularExpressionRouteConstraints = trait((Base) => {
+	return class CreatesRegularExpressionRouteConstraints$1 extends Base {
+		where(_wheres) {
+			return this;
+		}
+		/**
+		* Specify that the given route parameters must be alphabetic.
+		*
+		* @param  parameters
+		*/
+		whereAlpha(parameters) {
+			return this.assignExpressionToParameters(parameters, "[a-zA-Z]+");
+		}
+		/**
+		* Specify that the given route parameters must be alphanumeric.
+		*
+		* @param  parameters
+		*/
+		whereAlphaNumeric(parameters) {
+			return this.assignExpressionToParameters(parameters, "[a-zA-Z0-9]+");
+		}
+		/**
+		* Specify that the given route parameters must be numeric.
+		*
+		* @param  parameters
+		*/
+		whereNumber(parameters) {
+			return this.assignExpressionToParameters(parameters, "[0-9]+");
+		}
+		/**
+		* Specify that the given route parameters must be ULIDs.
+		*
+		* @param  parameters
+		*/
+		whereUlid(parameters) {
+			return this.assignExpressionToParameters(parameters, "[0-7][0-9a-hjkmnp-tv-zA-HJKMNP-TV-Z]{25}");
+		}
+		/**
+		* Specify that the given route parameters must be UUIDs.
+		*
+		* @param  parameters
+		*/
+		whereUuid(parameters) {
+			return this.assignExpressionToParameters(parameters, "[da-fA-F]{8}-[da-fA-F]{4}-[da-fA-F]{4}-[da-fA-F]{4}-[da-fA-F]{12}");
+		}
+		/**
+		* Specify that the given route parameters must be one of the given values.
+		*
+		* @param  parameters
+		* @param  values
+		*/
+		whereIn(parameters, values) {
+			return this.assignExpressionToParameters(parameters, new Collection(values).map((value) => value).implode("|"));
+		}
+		/**
+		* Apply the given regular expression to the given parameters.
+		*
+		* @param  parameters
+		* @param  expression
+		*/
+		assignExpressionToParameters(parameters, expression) {
+			return this.where(Collection.wrap(parameters).mapWithKeys((parameter) => ({ [parameter]: expression })).all());
+		}
+	};
+});
+
+//#endregion
+//#region src/RouteAction.ts
+var RouteAction = class {
+	/**
+	* The route action array.
+	*/
+	static action = {};
+	static parse(uri, action) {
+		/**
+		* If no action was provided return the missing action error handler
+		*/
+		if (!action) return this.missingAction(uri);
+		/**
+		* Handle closure
+		*/
+		if (isCallable(action)) return { uses: action };
+		/**
+		* Handle Controller class
+		*/
+		if (this.isClass(action)) return {
+			uses: action,
+			controller: action.name + "@index"
+		};
+		/**
+		* Handle [Controller, method] map
+		*/
+		if (Array.isArray(action)) {
+			const [uses, method] = action;
+			if (!this.isClass(uses)) throw new LogicException(`Invalid controller reference for route: ${uri}`);
+			return {
+				uses,
+				controller: uses.name + "@" + method
+			};
+		}
+		/**
+		* Handle an object with "uses" property
+		*/
+		if (typeof action === "object" && action.uses) {
+			this.action = action;
+			return this.normalizeUses(action.uses, uri);
+		}
+		throw new LogicException(`Unrecognized route action for URI: ${uri}`);
+	}
+	/**
+	* Normalize the "uses" field
+	*/
+	static normalizeUses(uses, uri) {
+		/**
+		* uses: function
+		*/
+		if (isCallable(uses)) return {
+			...this.action,
+			uses
+		};
+		/**
+		* uses: Controller
+		*/
+		if (this.isClass(uses)) return {
+			uses: this.action,
+			controller: this.action.name + "@index",
+			...this.action
+		};
+		/**
+		* uses: [Controller, 'method']
+		*/
+		if (Array.isArray(uses)) {
+			const [controller, method] = uses;
+			if (!this.isClass(controller)) throw new LogicException(`Invalid controller reference in 'uses' for route: ${uri}`);
+			return {
+				...this.action,
+				uses: controller,
+				controller: controller.name + "@" + method
+			};
+		}
+		throw new LogicException(`Invalid 'uses' value for route: ${uri}`);
+	}
+	/**
+	* Missing action fallback
+	*/
+	static missingAction(uri) {
+		return { handler: () => {
+			throw new LogicException(`Route for [${uri}] has no action.`);
+		} };
+	}
+	/**
+	* Make an action for an invokable controller.
+	*
+	* @param action
+	*
+	* @throws {UnexpectedValueException}
+	*/
+	static makeInvokable(action) {
+		if (!action["__invoke"]) throw new UnexpectedValueException(`Invalid route action: [${action}].`);
+		return action["__invoke"];
+	}
+	/**
+	* Detect if a value is a class constructor
+	*/
+	static isClass(value) {
+		return typeof value === "function" && value.prototype && value.prototype.constructor === value;
+	}
+};
+
+//#endregion
+//#region src/RouteParameterBinder.ts
+var RouteParameterBinder = class {
+	/**
+	* Create a new Route parameter binder instance.
+	*
+	* @param  route The route instance.
+	*/
+	constructor(route) {
+		this.route = route;
+	}
+	/**
+	* Get the parameters for the route.
+	*
+	* @param request
+	*/
+	parameters(request) {
+		let parameters = this.bindPathParameters(request);
+		if (this.route.compiled?.getHostRegex()) parameters = this.bindHostParameters(request, parameters);
+		return this.replaceDefaults(parameters);
+	}
+	/**
+	* Get the parameter matches for the path portion of the URI.
+	*
+	* @param  request
+	*/
+	bindPathParameters(request) {
+		const path = request.decodedPath().replace(/^\/+/, "");
+		const pathRegex = this.route.compiled?.getRegex() ?? "";
+		const matches = path.match(pathRegex) ?? [];
+		return this.matchToKeys(matches.slice(1));
+	}
+	/**
+	* Extract the parameter list from the host part of the request.
+	*
+	* @param  request
+	* @param parameters
+	*/
+	bindHostParameters(request, parameters) {
+		const host = request.getHost();
+		const hostRegex = this.route.compiled?.getHostRegex() ?? "";
+		const matches = host.match(hostRegex) ?? [];
+		return {
+			...this.matchToKeys(matches.slice(1)),
+			...parameters
+		};
+	}
+	/**
+	* Combine a set of parameter matches with the route's keys.
+	*
+	* @param   matches
+	*/
+	matchToKeys(matches) {
+		const parameterNames = this.route.parameterNames();
+		if (!parameterNames || parameterNames.length === 0) return {};
+		const parameters = {};
+		for (let i = 0; i < parameterNames.length; i++) {
+			const name = parameterNames[i];
+			const value = matches[i];
+			if (typeof value === "string" && value.length > 0) parameters[name] = value;
+		}
+		return parameters;
+	}
+	/**
+	* Replace null parameters with their defaults.
+	*
+	* @param parameters
+	* @return array
+	*/
+	replaceDefaults(parameters) {
+		for (const [key, value] of Object.entries(parameters)) parameters[key] = value ?? Obj.get(this.route._defaults, key);
+		for (const [key, value] of Object.entries(this.route._defaults)) if (!parameters[key]) parameters[key] = value;
+		return parameters;
+	}
+};
+
+//#endregion
+//#region src/RouteParameter.ts
+var RouteParameter = class {
+	constructor(name, type) {
+		this.name = name;
+		this.type = type;
+	}
+	/**
+	* Ge the route parameter name
+	*/
+	getName() {
+		return this.name;
+	}
+	/**
+	* Ge the route parameter type
+	*/
+	getType() {
+		return this.type;
+	}
+};
+
+//#endregion
+//#region src/RouteSignatureParameters.ts
+var RouteSignatureParameters = class {
+	static app;
+	static route;
+	/**
+	* set the current Application and Route instances
+	* 
+	* @param app 
+	*/
+	static setRequirements(app, route) {
+		this.app = app;
+		this.route = route;
+		return this;
+	}
+	/**
+	* Extract the route action's signature parameters.
+	* 
+	* @param action 
+	* @param conditions 
+	* @returns 
+	*/
+	static fromAction(action, conditions = {}) {
+		const uses = action.uses;
+		let target, methodName;
+		if (isClass(uses)) {
+			target = this.app.make(uses);
+			methodName = this.getControllerMethod(action);
+		} else if (Array.isArray(uses)) {
+			const [_target, _methodName] = uses;
+			target = target.prototype;
+			methodName = _methodName;
+		} else return [new RouteParameter("context", this.app.getHttpContext()), new RouteParameter("app", this.app)];
+		const types = Reflect.getMetadata("design:paramtypes", target, methodName) || [];
+		const routeParamNames = Object.keys(this.route.getParameters());
+		let routeParamIndex = 0;
+		const parameters = types.map((type) => {
+			let name = "unknown";
+			if (conditions.subClass && (type === conditions.subClass || type.prototype instanceof conditions.subClass)) name = routeParamNames[routeParamIndex++] || "unnamed_binding";
+			else name = type.name?.toLowerCase() || "injected";
+			return new RouteParameter(name, type);
+		});
+		if (conditions.subClass) {
+			const subClass = conditions.subClass;
+			return parameters.filter((p) => {
+				const type = p.getType();
+				return type === subClass || type.prototype instanceof subClass;
+			});
+		}
+		return parameters;
+	}
+	/**
+	* Get the controller method used for the route.
+	* 
+	* @param action 
+	* @returns 
+	*/
+	static getControllerMethod(action) {
+		const holder = isClass(action.uses) && typeof action.controller === "string" ? action.controller : "index";
+		return Str.parseCallback(holder).at(1);
+	}
+};
+
+//#endregion
+//#region src/RouteUri.ts
+var RouteUri = class RouteUri {
+	/**
+	* The route URI.
+	*/
+	uri;
+	/**
+	* The fields that should be used when resolving bindings.
+	*/
+	bindingFields = {};
+	/**
+	* Create a new route URI instance.
+	*
+	* @param uri  The route URI.
+	* @param bindingFields  The fields that should be used when resolving bindings.
+	*/
+	constructor(uri, bindingFields = {}) {
+		this.uri = uri;
+		this.bindingFields = bindingFields;
+	}
+	/**
+	* Parse the given URI.
+	*
+	* @param  uri  The route URI.
+	*/
+	static parse(uri) {
+		const matches = [...uri.matchAll(/\{([\w:]+?)\??\}/g)];
+		const bindingFields = {};
+		for (const match of matches) {
+			const fullMatch = match[0];
+			const inner = match[1];
+			if (!inner.includes(":")) continue;
+			const segments = inner.split(":");
+			bindingFields[segments[0]] = segments[1];
+			const replacement = fullMatch.includes("?") ? `{${segments[0]}?}` : `{${segments[0]}}`;
+			uri = uri.replace(fullMatch, replacement);
+		}
+		return new RouteUri(uri, bindingFields);
+	}
+};
+
+//#endregion
+//#region src/Route.ts
+var Route = class Route extends IRoute {
+	/**
+	* The URI pattern the route responds to.
+	*/
+	#uri;
+	/**
+	* The the matched parameters' original values object.
+	*/
+	#originalParameters;
+	/**
+	* The parameter names for the route.
+	*/
+	#parameterNames;
+	/**
+	* The default values for the route.
+	*/
+	_defaults = {};
+	/**
+	* The router instance used by the route.
+	*/
+	router;
+	/**
+	* The compiled version of the route.
+	*/
+	compiled = void 0;
+	/**
+	* The matched parameters object.
+	*/
+	parameters;
+	/**
+	* The container instance used by the route.
+	*/
+	container;
+	/**
+	* The fields that implicit binding should use for a given parameter.
+	*/
+	bindingFields;
+	/**
+	* Indicates "trashed" models can be retrieved when resolving implicit model bindings for this route.
+	*/
+	withTrashedBindings = false;
+	/**
+	* Indicates whether the route is a fallback route.
+	*/
+	isFallback = false;
+	/**
+	* The route action array.
+	*/
+	action;
+	/**
+	* The HTTP methods the route responds to.
+	*/
+	methods;
+	/**
+	* The route path that can be handled by H3.
+	*/
+	path = "";
+	/**
+	* The computed gathered middleware.
+	*/
+	computedMiddleware;
+	/**
+	* The controller instance.
+	*/
+	controller;
+	/**
+	* The validators used by the routes.
+	*/
+	static validators;
+	/**
+	* 
+	* @param methods The HTTP methods the route responds to.
+	* @param uri The URI pattern the route responds to.
+	*/
+	constructor(methods, uri, action) {
+		super();
+		this.#uri = uri;
+		this.methods = Arr.wrap(methods);
+		this.action = Arr.except(this.parseAction(action), ["prefix"]);
+		if (this.methods.includes("GET") && !this.methods.includes("HEAD")) this.methods.push("HEAD");
+		this.prefix(Obj.isPlainObject(action) ? Obj.get(action, "prefix") : "");
+	}
+	/**
+	* Set the router instance on the route.
+	*
+	* @param router
+	*/
+	setRouter(router) {
+		this.router = router;
+		return this;
+	}
+	/**
+	* Set the container instance on the route.
+	*
+	* @param container
+	*/
+	setContainer(container) {
+		this.container = container;
+		return this;
+	}
+	/**
+	* Set the URI that the route responds to.
+	*
+	* @param uri
+	*/
+	setUri(uri) {
+		this.#uri = this.parseUri(uri);
+		this.path = this.#uri.replace(/\{([^}]+)\}/g, ":$1").replace(/:([^/]+)\?\s*$/, "*").replace(/:([^/]+)\?(?=\/|$)/g, ":$1");
+		return this;
+	}
+	/**
+	* Parse the route URI and normalize / store any implicit binding fields.
+	*
+	* @param uri
+	*/
+	parseUri(uri) {
+		this.bindingFields = {};
+		const parsed = RouteUri.parse(uri);
+		this.bindingFields = parsed.bindingFields;
+		return parsed.uri;
+	}
+	/**
+	* Get the URI associated with the route.
+	*/
+	uri() {
+		return this.#uri;
+	}
+	/**
+	* Add a prefix to the route URI.
+	*
+	* @param prefix
+	*/
+	prefix(prefix) {
+		prefix ??= "";
+		this.updatePrefixOnAction(prefix);
+		const uri = Str.rtrim(prefix, "/") + "/" + Str.ltrim(this.#uri, "/");
+		return this.setUri(uri !== "/" ? Str.trim(uri, "/") : uri);
+	}
+	/**
+	* Update the "prefix" attribute on the action array.
+	*
+	* @param prefix
+	*/
+	updatePrefixOnAction(prefix) {
+		const newPrefix = Str.trim(Str.rtrim(prefix, "/") + "/" + Str.ltrim(this.action.prefix ?? "", "/"), "/");
+		if (newPrefix) this.action.prefix = newPrefix;
+	}
+	/**
+	* Get the name of the route instance.
+	*/
+	getName() {
+		return this.action.as ?? void 0;
+	}
+	/**
+	* Add or change the route name.
+	*
+	* @param  name
+	*
+	* @throws {InvalidArgumentException}
+	*/
+	name(name) {
+		this.action.as = this.action.as ? this.action.as + name : name;
+		return this;
+	}
+	/**
+	* Determine whether the route's name matches the given patterns.
+	*
+	* @param patterns
+	*/
+	named(...patterns) {
+		const routeName = this.getName();
+		if (!routeName) return false;
+		for (const pattern of patterns) if (Str.is(pattern, routeName)) return true;
+		return false;
+	}
+	/**
+	* Get the action name for the route.
+	*/
+	getActionName() {
+		return this.action.handler ?? "Closure";
+	}
+	/**
+	* Get the method name of the route action.
+	*
+	* @return string
+	*/
+	getActionMethod() {
+		const name = this.getActionName();
+		return typeof name === "string" ? Arr.last(name.split("@")) : name.name;
+	}
+	/**
+	* Get the action array or one of its properties for the route.
+	* @param key
+	*/
+	getAction(key) {
+		if (!key) return this.action;
+		return Obj.get(this.action, key);
+	}
+	/**
+	* Mark this route as a fallback route.
+	*/
+	fallback() {
+		this.isFallback = true;
+		return this;
+	}
+	/**
+	* Set the fallback value.
+	*
+	* @param  sFallback
+	*/
+	setFallback(isFallback) {
+		this.isFallback = isFallback;
+		return this;
+	}
+	/**
+	* Get the HTTP verbs the route responds to.
+	*/
+	getMethods() {
+		return this.methods;
+	}
+	/**
+	* Determine if the route only responds to HTTP requests.
+	*/
+	httpOnly() {
+		return Obj.has(this.action, "http");
+	}
+	/**
+	* Determine if the route only responds to HTTPS requests.
+	*/
+	httpsOnly() {
+		return this.secure();
+	}
+	middleware(middleware) {
+		if (!middleware) return Arr.wrap(this.action.middleware ?? []);
+		if (!Array.isArray(middleware)) middleware = Arr.wrap(middleware);
+		this.action.middleware = [...Arr.wrap(this.action.middleware ?? []), ...middleware];
+		return this;
+	}
+	/**
+	* Specify that the "Authorize" / "can" middleware should be applied to the route with the given options.
+	*
+	* @param  ability
+	* @param  models
+	*/
+	can(ability, models = []) {
+		return !models ? this.middleware(["can:" + ability]) : this.middleware(["can:" + ability + "," + Arr.wrap(models).join(",")]);
+	}
+	/**
+	* Set the action array for the route.
+	*
+	* @param action
+	*/
+	setAction(action) {
+		this.action = action;
+		if (this.action.domain) this.domain(this.action.domain);
+		if (this.action.can) for (const can of this.action.can) this.can(can[0], can[1] ?? []);
+		return this;
+	}
+	/**
+	* Determine if the route only responds to HTTPS requests.
+	*/
+	secure() {
+		return this.action.https === true;
+	}
+	/**
+	* Sync the current route with H3
+	* 
+	* @param h3App 
+	*/
+	sync(h3App) {
+		for (const method of this.methods) h3App[method.toLowerCase()](this.getPath(), () => response);
+	}
+	/**
+	* Bind the route to a given request for execution.
+	*
+	* @param request
+	*/
+	bind(request) {
+		this.compileRoute();
+		this.parameters = new RouteParameterBinder(this).parameters(request);
+		this.#originalParameters = this.parameters;
+		return this;
+	}
+	/**
+	* Get or set the domain for the route.
+	*
+	* @param domain
+	*
+	* @throws {InvalidArgumentException}
+	*/
+	domain(domain) {
+		if (!domain) return this.getDomain();
+		const parsed = RouteUri.parse(domain);
+		this.action.domain = parsed.uri ?? "";
+		this.bindingFields = Object.assign({}, this.bindingFields, parsed.bindingFields);
+		return this;
+	}
+	/**
+	* Parse the route action into a standard array.
+	*
+	* @param action
+	*
+	* @throws {UnexpectedValueException}
+	*/
+	parseAction(action) {
+		return RouteAction.parse(this.#uri, action);
+	}
+	/**
+	* Run the route action and return the response.
+	*/
+	async run() {
+		if (!this.container) {
+			const { Container } = await import("@h3ravel/core");
+			this.container = new Container();
+		}
+		try {
+			if (this.isControllerAction()) return await this.runController();
+			return this.runCallable();
+		} catch (e) {
+			if (typeof e.getResponse !== "undefined") return e.getResponse();
+			throw e;
+		}
+	}
+	/**
+	* Get the key / value list of parameters without empty values.
+	*/
+	parametersWithoutNulls() {
+		return Object.fromEntries(Object.entries(this.getParameters()).filter((e) => !!e));
+	}
+	/**
+	* Get the key / value list of original parameters for the route.
+	*
+	* @throws {LogicException}
+	*/
+	originalParameters() {
+		if (this.#originalParameters) return this.#originalParameters;
+		throw new LogicException("Route is not bound.");
+	}
+	/**
+	* Get the matched parameters object.
+	*/
+	getParameters() {
+		if (typeof this.parameters !== "undefined") return this.parameters;
+		throw new LogicException("Route is not bound.");
+	}
+	/**
+	* Get a given parameter from the route.
+	*
+	* @param  name
+	* @param  defaultParam
+	*/
+	parameter(name, defaultParam) {
+		return Obj.get(this.getParameters(), name, defaultParam);
+	}
+	/**
+	* Get the domain defined for the route.
+	*/
+	getDomain() {
+		if (this.action && this.action.domain) return this.action.domain.replace(/https?:\/\//, "");
+		return "";
+	}
+	/**
+	* Get the compiled version of the route.
+	*/
+	getCompiled() {
+		return this.compiled;
+	}
+	/**
+	* Get the binding field for the given parameter.
+	*
+	* @param  parameter
+	*/
+	bindingFieldFor(parameter) {
+		if (typeof parameter === "number") return Object.values(this.bindingFields)[parameter];
+		return this.bindingFields[parameter];
+	}
+	/**
+	* Get the binding fields for the route.
+	*/
+	getBindingFields() {
+		return this.bindingFields ?? {};
+	}
+	/**
+	* Set the binding fields for the route.
+	*
+	* @param  bindingFields
+	*/
+	setBindingFields(bindingFields) {
+		this.bindingFields = bindingFields;
+		return this;
+	}
+	/**
+	* Get the parent parameter of the given parameter.
+	*
+	* @param parameter
+	*/
+	parentOfParameter(parameter) {
+		const key = Object.keys(this.getParameters()).findIndex((e) => e == parameter);
+		if (!key || key === 0) return;
+		return Object.values(this.getParameters())[key - 1];
+	}
+	/**
+	* Determines if the route allows "trashed" models to be retrieved when resolving implicit model bindings. 
+	*/
+	allowsTrashedBindings() {
+		return this.withTrashedBindings;
+	}
+	/**
+	* Set a default value for the route.
+	*
+	* @param  key
+	* @param  value
+	*/
+	defaults(key, value) {
+		this._defaults[key] = value;
+		return this;
+	}
+	/**
+	* Set the default values for the route.
+	*
+	* @param  defaults
+	*/
+	setDefaults(defaults) {
+		this._defaults = defaults;
+		return this;
+	}
+	/**
+	* Get the optional parameter names for the route.
+	*/
+	getOptionalParameterNames() {
+		const matches = [...this.uri().matchAll(/\{([\w]+)(?:[:][\w]+)?(\?)?\}/g)];
+		const result = {};
+		for (const match of matches) {
+			const paramName = match[1];
+			if (!!match[2]) result[paramName] = null;
+		}
+		return result;
+	}
+	/**
+	* Get all of the parameter names for the route.
+	*/
+	parameterNames() {
+		if (this.#parameterNames) return this.#parameterNames;
+		return this.#parameterNames = this.compileParameterNames();
+	}
+	/**
+	* Checks whether the route's action is a controller.
+	*/
+	isControllerAction() {
+		return !!this.action.uses && isClass(this.action.uses);
+	}
+	compileParameterNames() {
+		return [...((this.getDomain() ?? "") + this.uri()).matchAll(/\{([\w]+)(?:[:][\w]+)?\??\}/g)].map((m) => m[1]);
+	}
+	/**
+	* Get the parameters that are listed in the route / controller signature.
+	*
+	* @param  conditions
+	*/
+	signatureParameters(conditions) {
+		if (isClass(conditions)) conditions = { subClass: conditions };
+		return RouteSignatureParameters.setRequirements(this.container, this).fromAction(this.action, conditions);
+	}
+	/**
+	* Compile the route once, cache the result, return compiled data
+	*/
+	compileRoute() {
+		if (!this.compiled) {
+			const optionalParams = this.getOptionalParameterNames();
+			this.compiled = new CompiledRoute(this.uri(), optionalParams);
+		}
+		return this.compiled;
+	}
+	/**
+	* Set a parameter to the given value.
+	*
+	* @param  name
+	* @param  value
+	*/
+	setParameter(name, value) {
+		this.getParameters();
+		this.parameters[name] = value;
+	}
+	/**
+	* Unset a parameter on the route if it is set.
+	*
+	* @param  name
+	*/
+	forgetParameter(name) {
+		this.getParameters();
+		delete this.parameters[name];
+	}
+	/**
+	* Get the value of the action that should be taken on a missing model exception.
+	*/
+	getMissing() {
+		return this.action["missing"] ?? void 0;
+	}
+	/**
+	* The route path that can be handled by H3.
+	*/
+	getPath() {
+		return this.path;
+	}
+	/**
+	* Define the callable that should be invoked on a missing model exception.
+	*
+	* @param  missing
+	*/
+	missing(missing) {
+		this.action["missing"] = missing;
+		return this;
+	}
+	/**
+	* Specify middleware that should be removed from the given route.
+	*
+	* @param  middleware
+	*/
+	withoutMiddleware(middleware) {
+		this.action.excluded_middleware = Object.assign({}, this.action.excluded_middleware ?? {}, Arr.wrap(middleware));
+		return this;
+	}
+	/**
+	* Get the middleware that should be removed from the route.
+	*/
+	excludedMiddleware() {
+		return this.action.excluded_middleware ?? {};
+	}
+	/**
+	* Get all middleware, including the ones from the controller.
+	*/
+	gatherMiddleware() {
+		if (this.computedMiddleware) return this.computedMiddleware;
+		this.computedMiddleware = Router.uniqueMiddleware([...this.middleware(), ...this.controllerMiddleware()]);
+		return this.computedMiddleware;
+	}
+	/**
+	* Indicate that the route should enforce scoping of multiple implicit Eloquent bindings.
+	*/
+	scopeBindings() {
+		this.action["scope_bindings"] = true;
+		return this;
+	}
+	/**
+	* Indicate that the route should not enforce scoping of multiple implicit Eloquent bindings.
+	*/
+	withoutScopedBindings() {
+		this.action["scope_bindings"] = false;
+		return this;
+	}
+	/**
+	* Determine if the route should enforce scoping of multiple implicit Eloquent bindings.
+	*/
+	enforcesScopedBindings() {
+		return this.action["scope_bindings"] ?? false;
+	}
+	/**
+	* Determine if the route should prevent scoping of multiple implicit Eloquent bindings.
+	*/
+	preventsScopedBindings() {
+		return typeof this.action["scope_bindings"] !== "undefined" && this.action["scope_bindings"] === false;
+	}
+	/**
+	* Get the dispatcher for the route's controller.
+	*
+	* @throws {BindingResolutionException}
+	*/
+	controllerDispatcher() {
+		if (this.container.bound(IControllerDispatcher)) return this.container.make(IControllerDispatcher);
+		return new ControllerDispatcher(this.container);
+	}
+	/**
+	* Get the route validators for the instance.
+	*
+	* @return array
+	*/
+	static getValidators() {
+		if (typeof this.validators !== "undefined") return this.validators;
+		return this.validators = [
+			new UriValidator(),
+			new MethodValidator(),
+			new SchemeValidator(),
+			new HostValidator()
+		];
+	}
+	/**
+	* Run the route action and return the response.
+	*
+	* @return mixed
+	* @throws  {NotFoundHttpException}
+	*/
+	async runController() {
+		return await this.controllerDispatcher().dispatch(this, this.getController(), this.getControllerMethod());
+	}
+	async runCallable() {
+		const callable = this.action.uses;
+		return this.container.make(ICallableDispatcher).dispatch(this, callable);
+	}
+	/**
+	* Get the controller instance for the route.
+	*
+	* @return mixed
+	*
+	* @throws {BindingResolutionException}
+	*/
+	getController() {
+		if (!this.isControllerAction()) return;
+		if (!this.controller) {
+			const instance = this.getControllerClass();
+			this.controller = this.container.make(instance);
+		}
+		return this.controller;
+	}
+	/**
+	* Flush the cached container instance on the route.
+	*/
+	flushController() {
+		this.computedMiddleware = void 0;
+		this.controller = void 0;
+	}
+	/**
+	* Determine if the route matches a given request.
+	* 
+	* @param request 
+	* @param includingMethod 
+	*/
+	matches(request, includingMethod = true) {
+		this.compileRoute();
+		for (const validator of Route.getValidators()) {
+			if (!includingMethod && validator instanceof MethodValidator) continue;
+			if (!validator.matches(this, request)) return false;
+		}
+		return true;
+	}
+	/**
+	* Get the controller class used for the route.
+	*/
+	getControllerClass() {
+		return this.isControllerAction() ? this.action.uses : void 0;
+	}
+	/**
+	* Get the controller method used for the route.
+	*/
+	getControllerMethod() {
+		const holder = isClass(this.action.uses) && typeof this.action.controller === "string" ? this.action.controller : "index";
+		return Str.parseCallback(holder).at(1);
+	}
+	/**
+	* Get the middleware for the route's controller.
+	*
+	* @return array
+	*/
+	controllerMiddleware() {
+		let controllerClass, ResourceMethod$1;
+		if (!this.isControllerAction()) return [];
+		if (typeof this.action.uses === "string") [controllerClass, ResourceMethod$1] = [this.getControllerClass(), this.getControllerMethod()];
+		return [];
+	}
+};
+
+//#endregion
+//#region src/RouteCollection.ts
+var RouteCollection = class extends AbstractRouteCollection {
+	/**
+	* An array of the routes keyed by method.
+	*/
+	routes = {};
+	/**
+	* A flattened array of all of the routes.
+	*/
+	allRoutes = {};
+	/**
+	* A look-up table of routes by their names.
+	*/
+	nameList = {};
+	/**
+	* A look-up table of routes by controller action.
+	*/
+	actionList = {};
+	/**
+	* Add a Route instance to the collection.
+	*/
+	add(route) {
+		this.addToCollections(route);
+		this.addLookups(route);
+		return route;
+	}
+	/**
+	* Add the given route to the arrays of routes.
+	*/
+	addToCollections(route) {
+		const domainAndUri = `${route.getDomain()}${route.uri()}`;
+		for (const method of route.methods) {
+			if (!this.routes[method]) this.routes[method] = {};
+			this.routes[method][domainAndUri] = route;
+		}
+		this.allRoutes[route.methods.join("|") + domainAndUri] = route;
+	}
+	/**
+	* Add the route to any look-up tables if necessary.
+	*/
+	addLookups(route) {
+		const name = route.getName();
+		if (name && !this.inNameLookup(name)) this.nameList[name] = route;
+		const action = route.getAction();
+		const controller = action.controller ?? void 0;
+		if (controller && !this.inActionLookup(controller)) this.addToActionList(action, route);
+	}
+	/**
+	* Add a route to the controller action dictionary.
+	*/
+	addToActionList(action, route) {
+		const key = (typeof action.controller === "string" ? action.controller : action.controller?.constructor.name) ?? "";
+		if (key) this.actionList[key] = route;
+	}
+	/**
+	* Determine if the given controller is in the action lookup table.
+	*/
+	inActionLookup(controller) {
+		return Object.prototype.hasOwnProperty.call(this.actionList, controller);
+	}
+	/**
+	* Determine if the given name is in the name lookup table.
+	*/
+	inNameLookup(name) {
+		return Object.prototype.hasOwnProperty.call(this.nameList, name);
+	}
+	/**
+	* Refresh the name look-up table.
+	*
+	* This is done in case any names are fluently defined or if routes are overwritten.
+	*/
+	refreshNameLookups() {
+		this.nameList = {};
+		for (const key of Object.keys(this.allRoutes)) {
+			const route = this.allRoutes[key];
+			const name = route.getName();
+			if (name && !this.inNameLookup(name)) this.nameList[name] = route;
+		}
+	}
+	/**
+	* Refresh the action look-up table.
+	*
+	* This is done in case any actions are overwritten with new controllers.
+	*/
+	refreshActionLookups() {
+		this.actionList = {};
+		for (const key of Object.keys(this.allRoutes)) {
+			const route = this.allRoutes[key];
+			const controller = route.getAction().controller ?? void 0;
+			if (controller && !this.inActionLookup(controller)) this.addToActionList(route.getAction(), route);
+		}
+	}
+	/**
+	* Find the first route matching a given request.
+	*
+	* May throw framework-specific exceptions (MethodNotAllowed / NotFound).
+	*/
+	match(request) {
+		const routes = this.get(request.getMethod());
+		const route = this.matchAgainstRoutes(routes, request);
+		return this.handleMatchedRoute(request, route);
+	}
+	get(method) {
+		if (typeof method === "undefined" || method === void 0) return this.getRoutes();
+		return this.routes[method] ?? {};
+	}
+	/**
+	* Determine if the route collection contains a given named route.
+	*/
+	hasNamedRoute(name) {
+		return this.getByName(name) !== void 0;
+	}
+	/**
+	* Get a route instance by its name.
+	*/
+	getByName(name) {
+		return this.nameList[name] ?? void 0;
+	}
+	/**
+	* Get a route instance by its controller action.
+	*/
+	getByAction(action) {
+		return this.actionList[action] ?? void 0;
+	}
+	/**
+	* Get all of the routes in the collection.
+	*/
+	getRoutes() {
+		return Object.values(this.allRoutes);
+	}
+	/**
+	* Get all of the routes keyed by their HTTP verb / method.
+	*/
+	getRoutesByMethod() {
+		return this.routes;
+	}
+	/**
+	* Get all of the routes keyed by their name.
+	*/
+	getRoutesByName() {
+		return this.nameList;
+	}
+};
+
+//#endregion
+//#region src/RouteGroup.ts
+var RouteGroup = class RouteGroup {
+	/**
+	* Merge route groups into a new array.
+	*
+	* @param  newAct
+	* @param  old
+	* @param  prependExistingPrefix
+	*/
+	static merge(newAct, old, prependExistingPrefix = true) {
+		if (newAct.domain) delete old.domain;
+		if (newAct.controller) delete old.controller;
+		newAct = Object.assign(RouteGroup.formatAs(newAct, old), {
+			namespace: RouteGroup.formatNamespace(newAct, old),
+			prefix: RouteGroup.formatPrefix(newAct, old, prependExistingPrefix),
+			where: RouteGroup.formatWhere(newAct, old)
+		});
+		return Obj.deepMerge(Arr.except(old, [
+			"namespace",
+			"prefix",
+			"where",
+			"as"
+		]), newAct);
+	}
+	/**
+	* Format the namespace for the new group attributes.
+	*
+	* @param  newAct
+	* @param  old
+	*/
+	static formatNamespace(newAct, old) {
+		if (newAct.namespace) return !!old.namespace && !!newAct.namespace ? Str.trim(old.namespace, "/") + "/" + Str.trim(newAct.namespace, "/") : Str.trim(newAct.namespace, "/");
+		return old.namespace ?? void 0;
+	}
+	/**
+	* Format the prefix for the new group attributes.
+	*
+	* @param  newAct
+	* @param  old
+	* @param  prependExistingPrefix
+	*/
+	static formatPrefix(newAct, old, prependExistingPrefix = true) {
+		const prefix = old.prefix ?? "";
+		if (prependExistingPrefix) return newAct.prefix ? Str.trim(prefix, "/") + "/" + Str.trim(newAct.prefix, "/") : prefix;
+		return newAct.prefix ? Str.trim(newAct["prefix"], "/") + "/" + Str.trim(prefix, "/") : prefix;
+	}
+	/**
+	* Format the "wheres" for the new group attributes.
+	*
+	* @param  newAct
+	* @param  old 
+	*/
+	static formatWhere(newAct, old) {
+		return Object.assign({}, old.where ?? {}, newAct.where ?? {});
+	}
+	/**
+	* Format the "as" clause of the new group attributes.
+	*
+	* @param  newAct
+	* @param  old
+	* @param  prependExistingPrefix
+	*/
+	static formatAs(newAct, old) {
+		if (old.as) newAct.as = old.as + (newAct.as ?? "");
+		return newAct;
+	}
+};
+
+//#endregion
+//#region src/Pipeline.ts
+var Pipeline = class {
+	/**
+	* The final callback to be executed after the pipeline ends regardless of the outcome.
+	*/
+	finally;
+	/**
+	* Indicates whether to wrap the pipeline in a database transaction.
+	*/
+	withinTransaction = false;
+	/**
+	* The container implementation.
+	*/
+	container;
+	/**
+	* The object being passed through the pipeline.
+	*/
+	passable;
+	/**
+	* The array of class pipes.
+	*/
+	pipes = [];
+	/**
+	* The method to call on each pipe.
+	*/
+	method = "handle";
+	constructor(app) {
+		this.container = app;
+	}
+	/**
+	* Set the method to call on the pipes.
+	*
+	* @param method
+	*/
+	via(method) {
+		this.method = method;
+		return this;
+	}
+	send(passable) {
+		this.passable = passable;
+		return this;
+	}
+	through(pipes) {
+		this.pipes = pipes;
+		return this;
+	}
+	/**
+	* Run the pipeline with a final destination callback.
+	*
+	* @param  destination
+	*/
+	async then(destination) {
+		const pipeline = [...this.pipes].reverse().reduce(this.carry(), this.prepareDestination(destination));
+		try {
+			if (this.withinTransaction !== false) return await this.getContainer().make("db").connection(this.withinTransaction).transaction(async () => {
+				return pipeline(this.passable);
+			});
+			return await pipeline(this.passable);
+		} finally {
+			if (this.finally) this.finally(this.passable);
+		}
+	}
+	/**
+	* Run the pipeline and return the result.
+	*/
+	async thenReturn() {
+		return await this.then(async function(passable) {
+			return passable;
+		});
+	}
+	carry() {
+		return (stack, pipe) => {
+			return async (passable) => {
+				try {
+					if (typeof pipe === "function" && isCallable(pipe)) return await pipe(passable, stack);
+					let instance = pipe;
+					let parameters = [passable, stack];
+					if (typeof pipe === "string") {
+						const [name, extras] = this.parsePipeString(pipe);
+						const bound = this.getContainer().boundMiddlewares(name);
+						if (bound) {
+							instance = this.getContainer().make(bound);
+							parameters = [
+								passable,
+								stack,
+								...extras
+							];
+						} else instance = async function(request, next) {
+							Logger.error(`Error: Middleware [${name}] requested by [${request.getRequestUri()}] not bound: Skipping...`, false);
+							return next;
+						};
+					} else if (typeof pipe === "function") instance = this.getContainer().make(pipe);
+					const handler = instance[this.method] ?? instance;
+					const result = Reflect.apply(handler, instance, parameters);
+					return await this.handleCarry(result);
+				} catch (e) {
+					return this.handleException(passable, e);
+				}
+			};
+		};
+	}
+	async handleCarry(carry) {
+		if (typeof carry?.then === "function") return await carry;
+		return carry;
+	}
+	/**
+	* Get the final piece of the Closure onion.
+	*
+	* @param  destination
+	*/
+	prepareDestination(destination) {
+		return async (passable) => {
+			try {
+				return await destination(passable ?? this.passable);
+			} catch (e) {
+				return this.handleException(passable ?? this.passable, e);
+			}
+		};
+	}
+	/**
+	* Handle the given exception.
+	*
+	* @param  _passable
+	* @param  e
+	* @throws {Error}
+	*/
+	handleException(_passable, e) {
+		throw e;
+	}
+	/**
+	* Parse full pipe string to get name and parameters.
+	*
+	* @param  pipe
+	*/
+	parsePipeString(pipe) {
+		const [name, paramString] = pipe.split(":");
+		return [name, paramString ? paramString.split(",") : []];
+	}
+	/**
+	* Set the container instance.
+	*
+	* @param  container
+	*/
+	setContainer(container) {
+		this.container = container;
+		return this;
+	}
+	/**
+	* Execute each pipeline step within a database transaction.
+	*
+	* @param  withinTransaction
+	*/
+	setWithinTransaction(withinTransaction) {
+		this.withinTransaction = withinTransaction;
+		return this;
+	}
+	/**
+	* Set a final callback to be executed after the pipeline ends regardless of the outcome.
+	*
+	* @param callback
+	*/
+	setFinally(callback) {
+		this.finally = callback;
+		return this;
+	}
+	/**
+	* Get the container instance.
+	*/
+	getContainer() {
+		if (!this.container) throw new RuntimeException("A container instance has not been passed to the Pipeline.");
+		return this.container;
+	}
+};
+
+//#endregion
+//#region ../support/src/Helpers.ts
+/**
+* Variadic helper function
+*
+* @param args
+*/
+function variadic(args) {
+	if (Array.isArray(args[0])) return args[0];
+	return args;
+}
+
+//#endregion
+//#region src/PendingSingletonResourceRegistration.ts
+var PendingSingletonResourceRegistration = class extends use(Finalizable, CreatesRegularExpressionRouteConstraints, Macroable) {
+	/**
+	* The resource registrar.
+	*/
+	registrar;
+	/**
+	* The resource name.
+	*/
+	name;
+	/**
+	* The resource controller.
+	*/
+	controller;
+	/**
+	* The resource options.
+	*/
+	options = {};
+	/**
+	* The resource's registration status.
+	*/
+	registered = false;
+	/**
+	* Create a new pending singleton resource registration instance.
+	*
+	* @param  registrar
+	* @param  name
+	* @param  controller
+	* @param  options
+	*/
+	constructor(registrar, name, controller, options) {
+		super();
+		this.name = name;
+		this.options = options;
+		this.registrar = registrar;
+		this.controller = controller;
+	}
+	/**
+	* Set the methods the controller should apply to.
+	*
+	* @param  methods
+	*/
+	only(...methods) {
+		this.options.only = variadic(methods);
+		return this;
+	}
+	/**
+	* Set the methods the controller should exclude.
+	*
+	* @param  methods
+	*/
+	except(...methods) {
+		this.options.except = variadic(methods);
+		return this;
+	}
+	/**
+	* Indicate that the resource should have creation and storage routes.
+	*
+	* @return  this
+	*/
+	creatable() {
+		this.options.creatable = true;
+		return this;
+	}
+	/**
+	* Indicate that the resource should have a deletion route.
+	*
+	* @return  this
+	*/
+	destroyable() {
+		this.options.destroyable = true;
+		return this;
+	}
+	/**
+	* Set the route names for controller actions.
+	*
+	* @param  names
+	*/
+	names(names) {
+		this.options.names = names;
+		return this;
+	}
+	/**
+	* Set the route name for a controller action.
+	*
+	* @param  method
+	* @param  name
+	*/
+	setName(method, name) {
+		if (this.options.names) this.options.names[method] = name;
+		else this.options.names = { [method]: name };
+		return this;
+	}
+	/**
+	* Override the route parameter names.
+	*
+	* @param  parameters
+	*/
+	parameters(parameters) {
+		this.options.parameters = parameters;
+		return this;
+	}
+	/**
+	* Override a route parameter's name.
+	*
+	* @param  previous
+	* @param  newValue
+	*/
+	parameter(previous, newValue) {
+		this.options.parameters[previous] = newValue;
+		return this;
+	}
+	/**
+	* Add middleware to the resource routes.
+	*
+	* @param  middleware
+	*/
+	middleware(middleware) {
+		const middlewares = Arr.wrap(middleware);
+		for (let key = 0; key < middlewares.length; key++) middlewares[key] = middlewares[key];
+		this.options.middleware = middlewares;
+		if (typeof this.options.middleware_for !== "undefined") for (const [method, value] of Object.entries(this.options.middleware_for ?? {})) this.options.middleware_for[method] = Router.uniqueMiddleware([...Arr.wrap(value), ...middlewares]);
+		return this;
+	}
+	/**
+	* Specify middleware that should be added to the specified resource routes.
+	*
+	* @param  methods
+	* @param  middleware
+	*/
+	middlewareFor(methods, middleware) {
+		methods = Arr.wrap(methods);
+		let middlewares = Arr.wrap(middleware);
+		if (typeof this.options.middleware !== "undefined") middlewares = Router.uniqueMiddleware([...this.options.middleware ?? [], ...middlewares]);
+		for (const method of methods) if (this.options.middleware_for) this.options.middleware_for[method] = middlewares;
+		else this.options.middleware_for = { [method]: middlewares };
+		return this;
+	}
+	/**
+	* Specify middleware that should be removed from the resource routes.
+	*
+	* @param  middleware
+	*/
+	withoutMiddleware(middleware) {
+		this.options.excluded_middleware = [...this.options.excluded_middleware ?? [], ...Arr.wrap(middleware)];
+		return this;
+	}
+	/**
+	* Specify middleware that should be removed from the specified resource routes.
+	*
+	* @param  methods
+	* @param  middleware
+	*/
+	withoutMiddlewareFor(methods, middleware) {
+		methods = Arr.wrap(methods);
+		const middlewares = Arr.wrap(middleware);
+		for (const method of methods) if (this.options.excluded_middleware_for) this.options.excluded_middleware_for[method] = middlewares;
+		else this.options.excluded_middleware_for = { [method]: middlewares };
+		return this;
+	}
+	/**
+	* Add "where" constraints to the resource routes.
+	*
+	* @param  wheres
+	*/
+	where(wheres) {
+		this.options.wheres = wheres;
+		return this;
+	}
+	/**
+	* Register the singleton resource route.
+	*/
+	register() {
+		this.registered = true;
+		return this.registrar.singleton(this.name, this.controller, this.options);
+	}
+	$finalize(e) {
+		if (!this.registered) (e ?? this).register();
+		return this ?? e;
+	}
+};
+
+//#endregion
+//#region src/ResourceRegistrar.ts
+var ResourceRegistrar = class ResourceRegistrar {
+	/**
+	* The router instance.
+	*/
+	router;
+	/**
+	* The default actions for a resourceful controller.
+	*/
+	resourceDefaults = [
+		"index",
+		"create",
+		"store",
+		"show",
+		"edit",
+		"update",
+		"destroy"
+	];
+	/**
+	* The default actions for a singleton resource controller.
+	*/
+	singletonResourceDefaults = [
+		"show",
+		"edit",
+		"update"
+	];
+	/**
+	* The parameters set for this resource instance.
+	*/
+	parameters;
+	/**
+	* The global parameter mapping.
+	*/
+	static parameterMap = {};
+	/**
+	* Singular global parameters.
+	*/
+	static _singularParameters = true;
+	/**
+	* The verbs used in the resource URIs.
+	*/
+	static _verbs = {
+		create: "create",
+		edit: "edit"
+	};
+	/**
+	* Create a new resource registrar instance.
+	*
+	* @param  router
+	*/
+	constructor(router) {
+		this.router = router;
+	}
+	/**
+	* Route a resource to a controller.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options
+	*/
+	register(name, controller, options = {}) {
+		if (typeof options.parameters !== "undefined" && this.parameters == null) this.parameters = options.parameters;
+		if (name.includes("/")) {
+			this.prefixedResource(name, controller, options);
+			return;
+		}
+		const base = this.getResourceWildcard(name.split("+").at(-1));
+		const defaults = this.resourceDefaults;
+		const collection = new RouteCollection();
+		const resourceMethods = this.getResourceMethods(defaults, options);
+		for (const m of resourceMethods) {
+			const optionsForMethod = options;
+			if (typeof optionsForMethod.middleware_for?.[m] !== "undefined") optionsForMethod.middleware = optionsForMethod.middleware_for?.[m];
+			if (typeof optionsForMethod.excluded_middleware_for?.[m] !== "undefined") optionsForMethod.excluded_middleware = Router.uniqueMiddleware([...optionsForMethod.excluded_middleware ?? [], ...optionsForMethod.excluded_middleware_for[m]]);
+			const route = this["addResource" + Str.ucfirst(m)](name, base, controller, optionsForMethod);
+			if (typeof options.bindingFields !== "undefined") this.setResourceBindingFields(route, options.bindingFields);
+			const allowed = options.trashed != null ? options.trashed : resourceMethods.filter((m$1) => [
+				"show",
+				"edit",
+				"update"
+			].includes(m$1));
+			if (typeof options.trashed !== "undefined" && allowed.includes(m)) route.withTrashed();
+			collection.add(route);
+		}
+		return collection;
+	}
+	/**
+	* Route a singleton resource to a controller.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options 
+	*/
+	singleton(name, controller, options = {}) {
+		if (typeof options.parameters !== "undefined" && this.parameters == null) this.parameters = options.parameters;
+		if (name.includes("/")) {
+			this.prefixedSingleton(name, controller, options);
+			return;
+		}
+		let defaults = this.singletonResourceDefaults;
+		if (typeof options.creatable !== "undefined") defaults = defaults.concat([
+			"create",
+			"store",
+			"destroy"
+		]);
+		else if (typeof options.destroyable !== "undefined") defaults = defaults.concat(["destroy"]);
+		const collection = new RouteCollection();
+		const resourceMethods = this.getResourceMethods(defaults, options);
+		for (const m of resourceMethods) {
+			const optionsForMethod = options;
+			if (typeof optionsForMethod.middleware_for?.[m] !== "undefined") optionsForMethod.middleware = optionsForMethod.middleware_for[m];
+			if (typeof optionsForMethod.excluded_middleware_for?.[m] !== "undefined") optionsForMethod.excluded_middleware = Router.uniqueMiddleware([...optionsForMethod.excluded_middleware ?? [], ...optionsForMethod.excluded_middleware_for[m]]);
+			const route = this["addSingleton" + Str.ucfirst(m)](name, controller, optionsForMethod);
+			if (typeof options.bindingFields !== "undefined") this.setResourceBindingFields(route, options.bindingFields);
+			collection.add(route);
+		}
+		return collection;
+	}
+	/**
+	* Build a set of prefixed resource routes.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options
+	*/
+	prefixedResource(name, controller, options) {
+		let prefix;
+		[name, prefix] = this.getResourcePrefix(name);
+		const callback = (me) => {
+			me.resource(name, controller, options);
+		};
+		return this.router.group({ prefix }, callback);
+	}
+	/**
+	* Build a set of prefixed singleton routes.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options
+	*/
+	prefixedSingleton(name, controller, options) {
+		let prefix;
+		[name, prefix] = this.getResourcePrefix(name);
+		const callback = function(me) {
+			me.singleton(name, controller, options);
+		};
+		return this.router.group({ prefix }, callback);
+	}
+	/**
+	* Extract the resource and prefix from a resource name.
+	*
+	* @param  name
+	* 
+	*/
+	getResourcePrefix(name) {
+		const segments = name.split("/");
+		const prefix = segments.slice(0, -1).join("/");
+		return [segments.at(-1), prefix];
+	}
+	/**
+	* Get the applicable resource methods.
+	*
+	* @param  defaults
+	* @param  options
+	* 
+	*/
+	getResourceMethods(defaults, options) {
+		let methods = defaults;
+		if (typeof options.only !== "undefined") methods = methods.filter((m) => new Set(options.only).has(m));
+		if (typeof options.except !== "undefined") methods = methods.filter((m) => !new Set(options.except).has(m));
+		return methods;
+	}
+	/**
+	* Add the index method for a resourceful route.
+	*
+	* @param  name
+	* @param  base
+	* @param  controller
+	* @param  options 
+	*/
+	addResourceIndex(name, _base, controller, options) {
+		const uri = this.getResourceUri(name);
+		delete options.missing;
+		const action = this.getResourceAction(name, controller, "index", options);
+		return this.router.get(uri, action);
+	}
+	/**
+	* Add the create method for a resourceful route.
+	*
+	* @param  name
+	* @param  base
+	* @param  controller
+	* @param  options
+	*/
+	addResourceCreate(name, base, controller, options) {
+		const uri = this.getResourceUri(name) + "/" + ResourceRegistrar._verbs["create"];
+		delete options.missing;
+		const action = this.getResourceAction(name, controller, "create", options);
+		return this.router.get(uri, action);
+	}
+	/**
+	* Add the store method for a resourceful route.
+	*
+	* @param  name
+	* @param  base
+	* @param  controller
+	* @param  options
+	*/
+	addResourceStore(name, base, controller, options) {
+		const uri = this.getResourceUri(name);
+		delete options.missing;
+		const action = this.getResourceAction(name, controller, "store", options);
+		return this.router.post(uri, action);
+	}
+	/**
+	* Add the show method for a resourceful route.
+	*
+	* @param  name
+	* @param  base
+	* @param  controller
+	* @param  options
+	*/
+	addResourceShow(name, base, controller, options) {
+		name = this.getShallowName(name, options);
+		const uri = this.getResourceUri(name) + "/{" + base + "}";
+		const action = this.getResourceAction(name, controller, "show", options);
+		return this.router.get(uri, action);
+	}
+	/**
+	* Add the edit method for a resourceful route.
+	*
+	* @param  name
+	* @param  base
+	* @param  controller
+	* @param  options 
+	*/
+	addResourceEdit(name, base, controller, options) {
+		name = this.getShallowName(name, options);
+		const uri = this.getResourceUri(name) + "/{" + base + "}/" + ResourceRegistrar._verbs["edit"];
+		const action = this.getResourceAction(name, controller, "edit", options);
+		return this.router.get(uri, action);
+	}
+	/**
+	* Add the update method for a resourceful route.
+	*
+	* @param  name
+	* @param  base
+	* @param  controller
+	* @param  options
+	*/
+	addResourceUpdate(name, base, controller, options) {
+		name = this.getShallowName(name, options);
+		const uri = this.getResourceUri(name) + "/{" + base + "}";
+		const action = this.getResourceAction(name, controller, "update", options);
+		return this.router.match(["PUT", "PATCH"], uri, action);
+	}
+	/**
+	* Add the destroy method for a resourceful route.
+	*
+	* @param  name
+	* @param  base
+	* @param  controller
+	* @param  options
+	*/
+	addResourceDestroy(name, base, controller, options) {
+		name = this.getShallowName(name, options);
+		const uri = this.getResourceUri(name) + "/{" + base + "}";
+		const action = this.getResourceAction(name, controller, "destroy", options);
+		return this.router.delete(uri, action);
+	}
+	/**
+	* Add the create method for a singleton route.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options 
+	*/
+	addSingletonCreate(name, controller, options) {
+		const uri = this.getResourceUri(name) + "/" + ResourceRegistrar._verbs["create"];
+		delete options.missing;
+		const action = this.getResourceAction(name, controller, "create", options);
+		return this.router.get(uri, action);
+	}
+	/**
+	* Add the store method for a singleton route.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options 
+	*/
+	addSingletonStore(name, controller, options) {
+		const uri = this.getResourceUri(name);
+		delete options.missing;
+		const action = this.getResourceAction(name, controller, "store", options);
+		return this.router.post(uri, action);
+	}
+	/**
+	* Add the show method for a singleton route.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options 
+	*/
+	addSingletonShow(name, controller, options) {
+		const uri = this.getResourceUri(name);
+		delete options.missing;
+		const action = this.getResourceAction(name, controller, "show", options);
+		return this.router.get(uri, action);
+	}
+	/**
+	* Add the edit method for a singleton route.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options 
+	*/
+	addSingletonEdit(name, controller, options) {
+		name = this.getShallowName(name, options);
+		const uri = this.getResourceUri(name) + "/" + ResourceRegistrar._verbs["edit"];
+		const action = this.getResourceAction(name, controller, "edit", options);
+		return this.router.get(uri, action);
+	}
+	/**
+	* Add the update method for a singleton route.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options 
+	*/
+	addSingletonUpdate(name, controller, options) {
+		name = this.getShallowName(name, options);
+		const uri = this.getResourceUri(name);
+		const action = this.getResourceAction(name, controller, "update", options);
+		return this.router.match(["PUT", "PATCH"], uri, action);
+	}
+	/**
+	* Add the destroy method for a singleton route.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options 
+	*/
+	addSingletonDestroy(name, controller, options) {
+		name = this.getShallowName(name, options);
+		const uri = this.getResourceUri(name);
+		const action = this.getResourceAction(name, controller, "destroy", options);
+		return this.router.delete(uri, action);
+	}
+	/**
+	* Get the name for a given resource with shallowness applied when applicable.
+	*
+	* @param  name
+	* @param  options
+	* 
+	*/
+	getShallowName(name, options) {
+		return typeof options.shallow !== "undefined" && options.shallow ? name.split("+").at(-1) : name;
+	}
+	/**
+	* Set the route's binding fields if the resource is scoped.
+	*
+	* @param  \Illuminate\Routing\Route  route
+	* @param  bindingFields
+	* 
+	*/
+	setResourceBindingFields(route, bindingFields) {
+		const matches = [...route.uri().matchAll(/(?<={).*?(?=})/g)];
+		const fields = Object.fromEntries(matches.map((m) => [m[0], null]));
+		const intersected = Object.fromEntries(Object.keys(fields).filter((k) => k in bindingFields).map((k) => [k, bindingFields[k]]));
+		route.setBindingFields({
+			...fields,
+			...intersected
+		});
+	}
+	/**
+	* Get the base resource URI for a given resource.
+	*
+	* @param  resource
+	* 
+	*/
+	getResourceUri(resource) {
+		if (!resource.includes("+")) return resource;
+		const segments = resource.split("+");
+		return this.getNestedResourceUri(segments).replaceAll("/{" + this.getResourceWildcard(segments.at(-1)) + "}", "");
+	}
+	/**
+	* Get the URI for a nested resource segment array.
+	*
+	* @param  segments
+	*/
+	getNestedResourceUri(segments) {
+		return segments.map((s) => {
+			return s + "/{" + this.getResourceWildcard(s) + "}";
+		}).join("/");
+	}
+	/**
+	* Format a resource parameter for usage.
+	*
+	* @param  value
+	*/
+	getResourceWildcard(value) {
+		if (typeof this.parameters === "object" && typeof this.parameters?.[value] !== "undefined") value = this.parameters[value];
+		else if (typeof ResourceRegistrar.parameterMap[value] !== "undefined") value = ResourceRegistrar.parameterMap[value];
+		else if (this.parameters === "singular" || ResourceRegistrar._singularParameters) value = Str.singular(value);
+		return value.replaceAll("-", "_");
+	}
+	/**
+	* Get the action array for a resource route.
+	*
+	* @param  resource
+	* @param  controller
+	* @param  method
+	* @param  options
+	* 
+	*/
+	getResourceAction(resource, controller, method, options) {
+		const name = this.getResourceRouteName(resource, method, options);
+		const action = {
+			"as": name,
+			"uses": controller,
+			"controller": controller.constructor.name + "@" + method
+		};
+		if (typeof options.middleware !== "undefined") action.middleware = options.middleware;
+		if (typeof options.excluded_middleware !== "undefined") action.excluded_middleware = options.excluded_middleware;
+		if (typeof options.wheres !== "undefined") action.where = options.wheres;
+		if (typeof options.missing !== "undefined") action.missing = options.missing;
+		return action;
+	}
+	/**
+	* Get the name for a given resource.
+	*
+	* @param  resource
+	* @param  method
+	* @param  options
+	* 
+	*/
+	getResourceRouteName(resource, method, options) {
+		let name = resource;
+		if (typeof options.names !== "undefined") {
+			if (typeof options.names === "string") name = options.names;
+			else if (typeof options.names[method] !== "undefined") return options.names[method];
+		}
+		return `${typeof options.as !== "undefined" ? options.as + "+" : ""}${name}.${method}`.replace(/^\++|\++$/g, "");
+	}
+	/**
+	* Set or unset the unmapped global parameters to singular.
+	*
+	* @param  singular
+	*/
+	static singularParameters(singular = true) {
+		this._singularParameters = singular;
+	}
+	/**
+	* Get the global parameter map.
+	*/
+	static getParameters() {
+		return this.parameterMap;
+	}
+	/**
+	* Set the global parameter mapping.
+	*
+	* @param  $parameters
+	* 
+	*/
+	static setParameters(parameters = []) {
+		this.parameterMap = parameters;
+	}
+	/**
+	* Get or set the action verbs used in the resource URIs.
+	*
+	* @param  verbs
+	* 
+	*/
+	static verbs(verbs = {}) {
+		if (Object.entries(verbs).length < 1) return ResourceRegistrar._verbs;
+		ResourceRegistrar._verbs = {
+			...ResourceRegistrar._verbs,
+			...verbs
+		};
+	}
+};
+
+//#endregion
+//#region src/RouteRegisterer.ts
+var _ref;
+const Inference = trait((e) => class extends e {});
+let RouteRegistrar = class RouteRegistrar$1 extends use(Inference, CreatesRegularExpressionRouteConstraints, Macroable, UseMagic) {
+	router;
+	attributes = {};
+	passthru = [
+		"get",
+		"post",
+		"put",
+		"patch",
+		"delete",
+		"options",
+		"any"
+	];
+	allowedAttributes = [
+		"as",
+		"can",
+		"controller",
+		"domain",
+		"middleware",
+		"missing",
+		"name",
+		"namespace",
+		"prefix",
+		"scopeBindings",
+		"where",
+		"withoutMiddleware",
+		"withoutScopedBindings"
+	];
+	aliases = {
+		name: "as",
+		scopeBindings: "scope_bindings",
+		withoutScopedBindings: "scope_bindings",
+		withoutMiddleware: "excluded_middleware"
+	};
+	constructor(router) {
+		super();
+		this.router = router;
+		this.group;
+	}
+	attribute(key, value) {
+		if (!this.allowedAttributes.includes(key)) throw new Error(`Attribute [${key}] does not exist.`);
+		if (key === "middleware") value = Arr.wrap(value).filter(Boolean).map(String);
+		const attributeKey = this.aliases[key] ?? key;
+		if (key === "withoutMiddleware") value = [...this.attributes[attributeKey] ?? [], ...Arr.wrap(value)];
+		if (key === "withoutScopedBindings") value = false;
+		this.attributes[attributeKey] = value;
+		return this;
+	}
+	resource(name, controller, options = {}) {
+		return this.router.resource(name, controller, {
+			...this.attributes,
+			...options
+		});
+	}
+	apiResource(name, controller, options = {}) {
+		return this.router.apiResource(name, controller, {
+			...this.attributes,
+			...options
+		});
+	}
+	singleton(name, controller, options = {}) {
+		return this.router.singleton(name, controller, {
+			...this.attributes,
+			...options
+		});
+	}
+	apiSingleton(name, controller, options = {}) {
+		return this.router.apiSingleton(name, controller, {
+			...this.attributes,
+			...options
+		});
+	}
+	group(callback) {
+		this.router.group(this.attributes, callback);
+		return this;
+	}
+	match(methods, uri, action) {
+		return this.router.match(methods, uri, this.compileAction(action));
+	}
+	registerRoute(method, uri, action) {
+		if (!Array.isArray(action)) action = {
+			...this.attributes,
+			...action ? { uses: action } : {}
+		};
+		return this.router[method](uri, this.compileAction(action));
+	}
+	compileAction(action) {
+		if (action == null) return this.attributes;
+		if (typeof action === "string" || typeof action === "function") action = { uses: action };
+		if (Array.isArray(action) && action.length === 2 && typeof action[0] === "string") {
+			const controller = action[0].startsWith("\\") ? action[0] : `\\${action[0]}`;
+			action = {
+				uses: `${controller}@${action[1]}`,
+				controller: `${controller}@${action[1]}`
+			};
+		}
+		return {
+			...this.attributes,
+			...action
+		};
+	}
+	/**
+	* PHP __call equivalent
+	* Handled via Proxy in Magic
+	*/
+	__call(method, parameters) {
+		if (this.constructor.hasMacro?.(method)) return this.macroCall(method, parameters);
+		if (this.passthru.includes(method)) return Reflect.apply(this.registerRoute, this, [method, ...parameters]);
+		if (this.allowedAttributes.includes(method)) {
+			if (method === "middleware") return this.attribute(method, Array.isArray(parameters[0]) ? parameters[0] : parameters);
+			if (method === "can") return this.attribute(method, [parameters]);
+			return this.attribute(method, parameters.length ? parameters[0] : true);
+		}
+		throw new Error(`Method ${this.constructor.name}::${method} does not exist.`);
+	}
+};
+RouteRegistrar = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof (_ref = typeof Router !== "undefined" && Router) === "function" ? _ref : Object])], RouteRegistrar);
+
+//#endregion
+//#region src/Router.ts
+var Router = class Router extends mix(IRouter, MacroableClass, Magic) {
+	DIST_DIR;
+	routes;
+	routeNames = [];
+	current;
+	currentRequest;
+	middlewareMap = [];
+	groupMiddleware = [];
+	/**
+	* The registered route value binders.
+	*/
+	binders = {};
+	/**
+	* All of the short-hand keys for middlewares.
+	*/
+	middlewares = {};
+	/**
+	* All of the middleware groups.
+	*/
+	middlewareGroups = {};
+	/**
+	* The route group attribute stack.
+	*/
+	groupStack = [];
+	/**
+	* The event dispatcher instance.
+	*/
+	events;
+	/**
+	* The priority-sorted list of middleware.
+	*
+	* Forces the listed middleware to always be in the given order.
+	*/
+	middlewarePriority = [];
+	/**
+	* The registered custom implicit binding callback.
+	*/
+	implicitBindingCallback;
+	/**
+	* All of the verbs supported by the router.
+	*/
+	static verbs = [
+		"GET",
+		"HEAD",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE",
+		"OPTIONS"
+	];
+	constructor(h3App, app) {
+		super();
+		this.h3App = h3App;
+		this.app = app;
+		this.events = app.has("app.events") ? app.make("app.events") : void 0;
+		this.routes = new RouteCollection();
+		this.DIST_DIR = env("DIST_DIR", "/.h3ravel/serve/");
+	}
+	/**
+	* Add a route to the underlying route collection.
+	* 
+	* @param method
+	* @param uri
+	* @param action
+	*/
+	addRoute(methods, uri, action) {
+		return this.routes.add(this.createRoute(methods, uri, action));
+	}
+	/**
+	* Get the currently dispatched route instance.
+	*/
+	getCurrentRoute() {
+		return this.current;
+	}
+	/**
+	* Check if a route with the given name exists.
+	*
+	* @param name
+	*/
+	has(...name) {
+		for (const value of name) if (!this.routes.hasNamedRoute(value)) return false;
+		return true;
+	}
+	/**
+	* Get the current route name.
+	*/
+	currentRouteName() {
+		return this.current?.getName();
+	}
+	/**
+	* Alias for the "currentRouteNamed" method.
+	*
+	* @param  patterns
+	*/
+	is(...patterns) {
+		return this.currentRouteNamed(...patterns);
+	}
+	/**
+	* Determine if the current route matches a pattern.
+	*
+	* @param patterns
+	*/
+	currentRouteNamed(...patterns) {
+		return !!this.current?.named(...patterns);
+	}
+	/**
+	* Get the underlying route collection.
+	*/
+	getRoutes() {
+		return this.routes;
+	}
+	/**
+	* Determine if the action is routing to a controller.
+	*
+	* @param action
+	*/
+	actionReferencesController(action) {
+		if (typeof action !== "function") return typeof action === "string" || action && !Array.isArray(action) && action.uses && typeof action === action.uses;
+		return false;
+	}
+	/**
+	* Create a new route instance.
+	*
+	* @param  methods
+	* @param  uri
+	* @param  action
+	*/
+	createRoute(methods, uri, action) {
+		const route = this.newRoute(methods, this.prefix(uri), action);
+		if (this.hasGroupStack()) this.mergeGroupAttributesIntoRoute(route);
+		return route;
+	}
+	/**
+	* Create a new Route object.
+	*
+	* @param  methods
+	* @param  uri
+	* @param  action
+	*/
+	newRoute(methods, uri, action) {
+		return new Route(methods, uri, action).setRouter(this).setContainer(this.app).setUri(uri);
+	}
+	/**
+	* Dispatch the request to the application.
+	*
+	* @param request
+	*/
+	async dispatch(request) {
+		this.currentRequest = request;
+		return await this.dispatchToRoute(request);
+	}
+	/**
+	* Dispatch the request to a route and return the response.
+	*
+	* @param request
+	*/
+	async dispatchToRoute(request) {
+		return await this.runRoute(request, this.findRoute(request));
+	}
+	/**
+	* Find the route matching a given request.
+	*
+	* @param request
+	*/
+	findRoute(request) {
+		this.events?.dispatch(new Routing(request));
+		const route = this.routes.match(request);
+		this.current = route;
+		route.setContainer(this.app);
+		this.app.instance(Route, route);
+		return route;
+	}
+	/**
+	* Return the response for the given route.
+	*
+	* @param  request
+	* @param  route
+	*/
+	async runRoute(request, route) {
+		request.setRouteResolver(() => route);
+		this.events?.dispatch(new RouteMatched(route, request));
+		return await this.prepareResponse(request, await this.runRouteWithinStack(route, request));
+	}
+	/**
+	* Run the given route within a Stack (onion) instance.
+	*
+	* @param  route
+	* @param  request
+	*/
+	async runRouteWithinStack(route, request) {
+		const middleware = this.app.bound("middleware.disable") && this.app.make("middleware.disable") === true ? [] : this.gatherRouteMiddleware(route);
+		return await new Pipeline(this.app).send(request).through(middleware).then(async (request$1) => {
+			return this.prepareResponse(request$1, await route.run());
+		});
+	}
+	/**
+	* Get all of the defined middleware short-hand names.
+	*/
+	getMiddleware() {
+		return this.middlewares;
+	}
+	/**
+	* Register a short-hand name for a middleware.
+	*
+	* @param  name
+	* @param  class
+	*/
+	aliasMiddleware(name, cls) {
+		this.middlewares[name] = cls;
+		return this;
+	}
+	/**
+	* Gather the middleware for the given route with resolved class names.
+	*
+	* @param  route
+	*/
+	gatherRouteMiddleware(route) {
+		return this.resolveMiddleware(route.gatherMiddleware(), route.excludedMiddleware());
+	}
+	/**
+	* Resolve a flat array of middleware classes from the provided array.
+	*
+	* @param middleware
+	* @param excluded
+	*/
+	resolveMiddleware(middleware, excluded = []) {
+		excluded = excluded.length === 0 ? excluded : new Collection(excluded).map((name) => MiddlewareResolver.setApp(this.app).resolve(name, this.middlewares, this.middlewareGroups)).flatten().values().all();
+		const middlewares = new Collection(middleware).map((name) => MiddlewareResolver.setApp(this.app).resolve(name, this.middlewares, this.middlewareGroups)).flatten();
+		middlewares.when(excluded.length > 0, (collection) => {
+			collection.reject((name) => {
+				if (typeof name === "function") return false;
+				if (excluded.includes(name)) return true;
+				if (!isClass(name)) return false;
+				const instance = this.app.make(name);
+				return new Collection(excluded).contains((exclude) => isClass(exclude) && instance instanceof exclude);
+			});
+			return collection;
+		}).values();
+		return this.sortMiddleware(middlewares);
+	}
+	/**
+	* Sort the given middleware by priority.
+	*
+	* @param  middlewares
+	*/
+	sortMiddleware(middlewares) {
+		return middlewares.all();
+	}
+	/**
+	* Register a group of middleware.
+	*
+	* @param  name
+	* @param  middleware
+	*/
+	middlewareGroup(name, middleware) {
+		this.middlewareGroups[name] = middleware;
+		return this;
+	}
+	/**
+	* Create a response instance from the given value.
+	*
+	* @param  request
+	* @param  response
+	*/
+	async prepareResponse(request, response$1) {
+		this.events?.dispatch(new PreparingResponse(request, response$1));
+		return tap(Router.toResponse(request, response$1), (response$2) => {
+			this.events?.dispatch(new ResponsePrepared(request, response$2));
+		});
+	}
+	/**
+	* Static version of prepareResponse.
+	*
+	* @param  request
+	* @param  response
+	*/
+	static toResponse(request, response$1) {
+		if (response$1 instanceof IResponsable) response$1 = response$1.toResponse(request);
+		if (response$1 instanceof Stringable || typeof response$1 === "string") response$1 = new Response(request.app, response$1.toString(), 200, { "Content-Type": "text/html" });
+		else if (!(response$1 instanceof IResponse) && !(response$1 instanceof Response)) response$1 = new JsonResponse(request.app, response$1);
+		if (response$1.getStatusCode() === Response.codes.HTTP_NOT_MODIFIED) response$1.setNotModified();
+		return response$1.prepare(request);
+	}
+	/**
+	* Substitute the route bindings onto the route.
+	*
+	* @param  route
+	*
+	* @throws {ModelNotFoundException<IModel>}
+	*/
+	async substituteBindings(route) {
+		for (const [key, value] of Object.entries(route.parameters ?? {})) if (typeof this.binders[key] !== "undefined") route.setParameter(key, await this.performBinding(key, value, route));
+		return route;
+	}
+	/**
+	* Substitute the implicit route bindings for the given route.
+	*
+	* @param  route
+	*
+	* @throws {ModelNotFoundException<IModel>}
+	*/
+	async substituteImplicitBindings(route) {
+		const defaultFn = () => ImplicitRouteBinding.resolveForRoute(this.app, route);
+		return await Reflect.apply(this.implicitBindingCallback ?? defaultFn, void 0, [
+			this.app,
+			route,
+			defaultFn
+		]);
+	}
+	/**
+	* Register a callback to run after implicit bindings are substituted.
+	*
+	* @param  callback
+	*/
+	substituteImplicitBindingsUsing(callback) {
+		this.implicitBindingCallback = callback;
+		return this;
+	}
+	/**
+	* Call the binding callback for the given key.
+	*
+	* @param  key
+	* @param  value
+	* @param  route
+	*
+	* @throws {ModelNotFoundException<IModel>}
+	*/
+	performBinding(key, value, route) {
+		return Reflect.apply(this.binders[key], void 0, [value, route]);
+	}
+	/**
+	* Remove any duplicate middleware from the given array.
+	*
+	* @param  middleware
+	*/
+	static uniqueMiddleware(middleware) {
+		return Array.from(new Set(middleware));
+	}
+	/**
+	* Registers a route that responds to HTTP GET requests.
+	* 
+	* @param uri - The route uri.
+	* @param action - The handler function or [controller class, method] array.
+	* @returns 
+	*/
+	get(uri, action) {
+		return this.addRoute(["GET"], uri, action);
+	}
+	/**
+	* Registers a route that responds to HTTP HEAD requests.
+	* 
+	* @param uri - The route uri.
+	* @param action - The handler function or [controller class, method] array.
+	* @returns 
+	*/
+	head(uri, action) {
+		return this.addRoute(["HEAD"], uri, action);
+	}
+	/**
+	* Registers a route that responds to HTTP POST requests.
+	* 
+	* @param uri - The route uri.
+	* @param action - The handler function or [controller class, method] array.
+	* @returns 
+	*/
+	post(uri, action) {
+		return this.addRoute(["POST"], uri, action);
+	}
+	/**
+	* Registers a route that responds to HTTP PUT requests.
+	* 
+	* @param uri - The route uri.
+	* @param action - The handler function or [controller class, method] array.
+	* @returns 
+	*/
+	put(uri, action) {
+		return this.addRoute(["PUT"], uri, action);
+	}
+	/**
+	* Registers a route that responds to HTTP PATCH requests.
+	* 
+	* @param uri - The route uri.
+	* @param action - The handler function or [controller class, method] array.
+	* @returns 
+	*/
+	patch(uri, action) {
+		return this.addRoute(["PATCH"], uri, action);
+	}
+	/**
+	* Registers a route that responds to HTTP OPTIONS requests.
+	* 
+	* @param uri - The route uri.
+	* @param action - The handler function or [controller class, method] array.
+	* @returns 
+	*/
+	options(uri, action) {
+		return this.addRoute(["OPTIONS"], uri, action);
+	}
+	/**
+	* Registers a route that responds to HTTP DELETE requests.
+	* 
+	* @param uri - The route uri.
+	* @param action - The handler function or [controller class, method] array.
+	* @returns 
+	*/
+	delete(uri, action) {
+		return this.addRoute(["DELETE"], uri, action);
+	}
+	/**
+	* Registers a route the matches the provided methods.
+	* 
+	* @param methods - The route methods to match.
+	* @param uri - The route uri.
+	* @param action - The handler function or [controller class, method] array.
+	*/
+	match(methods, uri, action) {
+		return this.addRoute(Arr.wrap(methods), uri, action);
+	}
+	/**
+	* Route a resource to a controller.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options
+	*/
+	resource(name, controller, options = {}) {
+		let registrar;
+		if (this.app && this.app.bound(ResourceRegistrar)) registrar = this.app.make(ResourceRegistrar);
+		else registrar = new ResourceRegistrar(this);
+		return new PendingResourceRegistration(registrar, name, controller, options).$finalize();
+	}
+	/**
+	* Register an array of API resource controllers.
+	*
+	* @param  resources
+	* @param  options
+	*/
+	apiResources(resources, options = {}) {
+		for (const [name, controller] of Object.entries(resources)) this.apiResource(name, controller, options);
+	}
+	/**
+	* Route an API resource to a controller.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options
+	*/
+	apiResource(name, controller, options = {}) {
+		let only = [
+			"index",
+			"show",
+			"store",
+			"update",
+			"destroy"
+		];
+		if (typeof options.except !== "undefined") only = only.filter((value) => !options.except?.includes(value));
+		return this.resource(name, controller, Object.assign({}, { only }, options));
+	}
+	/**
+	* Register an array of singleton resource controllers.
+	*
+	* @param  singletons
+	* @param  options
+	*/
+	singletons(singletons, options = {}) {
+		for (const [name, controller] of Object.entries(singletons)) this.singleton(name, controller, options);
+	}
+	/**
+	* Route a singleton resource to a controller.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options
+	*/
+	singleton(name, controller, options = {}) {
+		let registrar;
+		if (this.app && this.app.bound(ResourceRegistrar)) registrar = this.app.make(ResourceRegistrar);
+		else registrar = new ResourceRegistrar(this);
+		return new PendingSingletonResourceRegistration(registrar, name, controller, options).$finalize();
+	}
+	/**
+	* Register an array of API singleton resource controllers.
+	*
+	* @param  singletons
+	* @param  options
+	*/
+	apiSingletons(singletons, options = {}) {
+		for (const [name, controller] of Object.entries(singletons)) this.apiSingleton(name, controller, options);
+	}
+	/**
+	* Route an API singleton resource to a controller.
+	*
+	* @param  name
+	* @param  controller
+	* @param  options
+	*/
+	apiSingleton(name, controller, options = {}) {
+		let only = [
+			"store",
+			"show",
+			"update",
+			"destroy"
+		];
+		if (typeof options.except !== "undefined") only = only.filter((v) => !options.except?.includes(v));
+		return this.singleton(name, controller, Object.assign({ only }, options));
+	}
+	/**
+	* Create a route group with shared attributes.
+	*
+	* @param  attributes
+	* @param  routes
+	*/
+	group(attributes, routes) {
+		for (const groupRoutes of Arr.wrap(routes)) {
+			this.updateGroupStack(attributes);
+			this.loadRoutes(groupRoutes);
+			this.groupStack.pop();
+		}
+		return this;
+	}
+	/**
+	* Update the group stack with the given attributes.
+	*
+	* @param  attributes
+	*/
+	updateGroupStack(attributes) {
+		if (this.hasGroupStack()) attributes = this.mergeWithLastGroup(attributes);
+		this.groupStack.push(attributes);
+	}
+	/**
+	* Merge the given array with the last group stack.
+	*
+	* @param  newItems
+	* @param  prependExistingPrefix
+	*/
+	mergeWithLastGroup(newItems, prependExistingPrefix = true) {
+		return RouteGroup.merge(newItems, Arr.last(this.groupStack, true)[0], prependExistingPrefix);
+	}
+	/**
+	* Load the provided routes.
+	*
+	* @param  routes
+	*/
+	async loadRoutes(routes) {
+		const require = createRequire(import.meta.url);
+		if (typeof routes === "function") routes(this);
+		else if (existsSync(this.app.paths.distPath(routes))) require(this.app.paths.distPath(routes));
+	}
+	/**
+	* Get the prefix from the last group on the stack.
+	*/
+	getLastGroupPrefix() {
+		if (this.hasGroupStack()) return Arr.last(this.groupStack, true)[0].prefix ?? "";
+		return "";
+	}
+	/**
+	* Merge the group stack with the controller action.
+	*
+	* @param  route
+	*/
+	mergeGroupAttributesIntoRoute(route) {
+		route.setAction(this.mergeWithLastGroup(route.getAction(), false));
+	}
+	/**
+	* Determine if the router currently has a group stack.
+	*/
+	hasGroupStack() {
+		return this.groupStack.length > 0;
+	}
+	/**
+	* Set the name of the current route
+	* 
+	* @param name 
+	*/
+	name(name) {
+		this.routeNames.push(name);
+		return this;
+	}
+	/**
+	* Prefix the given URI with the last prefix.
+	*
+	* @param  uri
+	*/
+	prefix(uri) {
+		return Str.trim(Str.trim(this.getLastGroupPrefix(), "/") + "/" + Str.trim(uri, "/"), "/") || "/";
+	}
+	/**
+	* Registers H3 middleware for a specific path.
+	* 
+	* @param path - The middleware or path to apply the middleware.
+	* @param handler - The middleware handler.
+	* @param opts - Optional middleware options.
+	*/
+	h3middleware(path, handler, opts) {
+		opts = typeof handler === "object" ? handler : typeof opts === "function" ? opts : {};
+		handler = typeof path === "function" ? path : typeof handler === "function" ? handler : () => {};
+		if (Array.isArray(path)) this.middlewareMap.concat(path);
+		else if (typeof path === "function") this.h3App.use("/", () => {}).use(path);
+		else this.h3App.use(path, handler, opts);
+		return this;
+	}
+	/**
+	* Dynamically handle calls into the router instance.
+	*
+	* @param  method
+	* @param  parameters
+	*/
+	__call(method, parameters) {
+		if (Router.hasMacro(method)) return this.macroCall(method, parameters);
+		if (method === "middleware") return new RouteRegistrar(this).attribute(method, Array.isArray(parameters[0]) ? parameters[0] : parameters);
+		if (method === "can") return new RouteRegistrar(this).attribute(method, [parameters]);
+		if (method !== "where" && Str.startsWith(method, "where")) {
+			const registerer = new RouteRegistrar(this);
+			return Reflect.apply(registerer[method], registerer, parameters);
+		}
+		return new RouteRegistrar(this).attribute(method, parameters?.[0] ?? true);
+	}
+};
+__decorate([
+	internal,
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", void 0)
+], Router.prototype, "prefix", null);
+
+//#endregion
+//#region src/PendingResourceRegistration.ts
+var PendingResourceRegistration = class extends use(CreatesRegularExpressionRouteConstraints, Macroable) {
+	/**
+	* The resource registrar.
+	*/
+	registrar;
+	/**
+	* The resource name.
+	*/
+	name;
+	/**
+	* The resource controller.
+	*/
+	controller;
+	/**
+	* The resource options.
+	*/
+	options = {};
+	/**
+	* The resource's registration status.
+	*/
+	registered = false;
+	/**
+	* Create a new pending resource registration instance.
+	*
+	* @param  registrar
+	* @param  name
+	* @param  controller
+	* @param  options
+	*/
+	constructor(registrar, name, controller, options) {
+		super();
+		this.name = name;
+		this.options = options;
+		this.registrar = registrar;
+		this.controller = controller;
+	}
+	/**
+	* Set the methods the controller should apply to.
+	*
+	* @param  methods
+	*/
+	only(...methods) {
+		this.options.only = variadic(methods);
+		return this;
+	}
+	/**
+	* Set the methods the controller should exclude.
+	*
+	* @param  methods
+	*/
+	except(...methods) {
+		this.options.except = variadic(methods);
+		return this;
+	}
+	/**
+	* Set the route names for controller actions.
+	*
+	* @param  names
+	*/
+	names(names) {
+		this.options.names = names;
+		return this;
+	}
+	/**
+	* Set the route name for a controller action.
+	*
+	* @param  method
+	* @param  name 
+	*/
+	setName(method, name) {
+		if (this.options.names) this.options.names[method] = name;
+		else this.options.names = { [method]: name };
+		return this;
+	}
+	/**
+	* Override the route parameter names.
+	*
+	* @param  parameters 
+	*/
+	parameters(parameters) {
+		this.options.parameters = parameters;
+		return this;
+	}
+	/**
+	* Override a route parameter's name.
+	*
+	* @param  previous
+	* @param  newValue
+	*/
+	parameter(previous, newValue) {
+		this.options.parameters[previous] = newValue;
+		return this;
+	}
+	/**
+	* Add middleware to the resource routes.
+	*
+	* @param  middleware
+	*/
+	middleware(middleware) {
+		const middlewares = Arr.wrap(middleware);
+		for (let key = 0; key < middlewares.length; key++) middlewares[key] = middlewares[key];
+		this.options.middleware = middlewares;
+		if (typeof this.options.middleware_for !== "undefined") for (const [method, value] of Object.entries(this.options.middleware_for ?? {})) this.options.middleware_for[method] = Router.uniqueMiddleware([...Arr.wrap(value), ...middlewares]);
+		return this;
+	}
+	/**
+	* Specify middleware that should be added to the specified resource routes.
+	*
+	* @param  methods
+	* @param  middleware
+	*/
+	middlewareFor(methods, middleware) {
+		methods = Arr.wrap(methods);
+		let middlewares = Arr.wrap(middleware);
+		if (typeof this.options.middleware !== "undefined") middlewares = Router.uniqueMiddleware([...this.options.middleware ?? [], ...middlewares]);
+		for (const method of methods) if (this.options.middleware_for) this.options.middleware_for[method] = middlewares;
+		else this.options.middleware_for = { [method]: middlewares };
+		return this;
+	}
+	/**
+	* Specify middleware that should be removed from the resource routes.
+	*
+	* @param  middleware
+	*/
+	withoutMiddleware(middleware) {
+		this.options.excluded_middleware = [...this.options.excluded_middleware ?? [], ...Arr.wrap(middleware)];
+		return this;
+	}
+	/**
+	* Specify middleware that should be removed from the specified resource routes.
+	*
+	* @param  methods
+	* @param  middleware
+	*/
+	withoutMiddlewareFor(methods, middleware) {
+		methods = Arr.wrap(methods);
+		const middlewares = Arr.wrap(middleware);
+		for (const method of methods) if (this.options.excluded_middleware_for) this.options.excluded_middleware_for[method] = middlewares;
+		else this.options.excluded_middleware_for = { [method]: middlewares };
+		return this;
+	}
+	/**
+	* Add "where" constraints to the resource routes.
+	*
+	* @param  wheres
+	*/
+	where(wheres) {
+		this.options.wheres = wheres;
+		return this;
 	}
 	/**
-	* Registers a route that responds to HTTP POST requests.
+	* Indicate that the resource routes should have "shallow" nesting.
 	*
-	* @param path        The URL pattern to match (can include parameters, e.g., '/users').
-	* @param definition  Either:
-	*                      - An EventHandler function
-	*                      - A tuple: [ControllerClass, methodName]
-	* @param name        Optional route name (for URL generation or referencing).
-	* @param middleware  Optional array of middleware functions to execute before the handler.
+	* @param shallow 
 	*/
-	post(path$1, definition, name, middleware = []) {
-		const handler = Array.isArray(definition) ? definition[0] : definition;
-		const methodName = Array.isArray(definition) ? definition[1] : void 0;
-		this.addRoute("post", path$1, this.resolveControllerOrHandler(handler, methodName, path$1), name, middleware, [handler.name, methodName]);
+	shallow(shallow = true) {
+		this.options.shallow = shallow;
 		return this;
 	}
 	/**
-	* Registers a route that responds to HTTP PUT requests.
+	* Define the callable that should be invoked on a missing model exception.
 	*
-	* @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-	* @param definition  Either:
-	*                      - An EventHandler function
-	*                      - A tuple: [ControllerClass, methodName]
-	* @param name        Optional route name (for URL generation or referencing).
-	* @param middleware  Optional array of middleware functions to execute before the handler.
+	* @param  callback
 	*/
-	put(path$1, definition, name, middleware = []) {
-		const handler = Array.isArray(definition) ? definition[0] : definition;
-		const methodName = Array.isArray(definition) ? definition[1] : void 0;
-		this.addRoute("put", path$1, this.resolveControllerOrHandler(handler, methodName, path$1), name, middleware, [handler.name, methodName]);
+	missing(callback) {
+		this.options.missing = callback;
 		return this;
 	}
 	/**
-	* Registers a route that responds to HTTP PATCH requests.
+	* Indicate that the resource routes should be scoped using the given binding fields.
 	*
-	* @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-	* @param definition  Either:
-	*                      - An EventHandler function
-	*                      - A tuple: [ControllerClass, methodName]
-	* @param name        Optional route name (for URL generation or referencing).
-	* @param middleware  Optional array of middleware functions to execute before the handler.
+	* @param  fields 
 	*/
-	patch(path$1, definition, name, middleware = []) {
-		const handler = Array.isArray(definition) ? definition[0] : definition;
-		const methodName = Array.isArray(definition) ? definition[1] : void 0;
-		this.addRoute("patch", path$1, this.resolveControllerOrHandler(handler, methodName, path$1), name, middleware, [handler.name, methodName]);
+	scoped(fields = []) {
+		this.options.bindingFields = fields;
 		return this;
 	}
 	/**
-	* Registers a route that responds to HTTP DELETE requests.
+	* Define which routes should allow "trashed" models to be retrieved when resolving implicit model bindings.
 	*
-	* @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-	* @param definition  Either:
-	*                      - An EventHandler function
-	*                      - A tuple: [ControllerClass, methodName]
-	* @param name        Optional route name (for URL generation or referencing).
-	* @param middleware  Optional array of middleware functions to execute before the handler.
+	* @param  array  methods 
 	*/
-	delete(path$1, definition, name, middleware = []) {
-		const handler = Array.isArray(definition) ? definition[0] : definition;
-		const methodName = Array.isArray(definition) ? definition[1] : void 0;
-		this.addRoute("delete", path$1, this.resolveControllerOrHandler(handler, methodName, path$1), name, middleware, [handler.name, methodName]);
+	withTrashed(methods = []) {
+		this.options["trashed"] = methods;
 		return this;
 	}
 	/**
-	* API Resource support  
+	* Register the singleton resource route.
+	*/
+	register() {
+		this.registered = true;
+		return this.registrar.register(this.name, this.controller, this.options);
+	}
+	$finalize(e) {
+		if (!this.registered) (e ?? this).register();
+		return this ?? e;
+	}
+};
+
+//#endregion
+//#region src/RouteUrlGenerator.ts
+var RouteUrlGenerator = class extends IRouteUrlGenerator {
+	/**
+	* The URL generator instance.
+	*/
+	url;
+	/**
+	* The request instance.
+	*/
+	request;
+	/**
+	* The named parameter defaults.
+	*/
+	defaultParameters = {};
+	/**
+	* Characters that should not be URL encoded.
+	*/
+	dontEncode = {
+		"%2F": "/",
+		"%40": "@",
+		"%3A": ":",
+		"%3B": ";",
+		"%2C": ",",
+		"%3D": "=",
+		"%2B": "+",
+		"%21": "!",
+		"%2A": "*",
+		"%7C": "|",
+		"%3F": "?",
+		"%26": "&",
+		"%23": "#",
+		"%25": "%"
+	};
+	/**
+	* Create a new Route URL generator.
+	*
+	* @param  url
+	* @param  request
+	*/
+	constructor(url, request) {
+		super();
+		this.url = url;
+		this.request = request;
+	}
+	/**
+	* Generate a URL for the given route.
+	*
+	* @param  route
+	* @param  parameters
+	* @param  absolute
+	*/
+	to(route, parameters = {}, absolute = false) {
+		parameters = this.formatParameters(route, parameters);
+		const domain = this.getRouteDomain(route, parameters);
+		const root = this.replaceRootParameters(route, domain, parameters);
+		const path = this.replaceRouteParameters(route.uri(), parameters);
+		let uri = this.addQueryString(this.url.format(root, path, route), parameters);
+		const missingMatches = [...uri.matchAll(/\{([\w]+)(?:[:][\w]+)?\??\}/g)];
+		if (missingMatches.length) throw UrlGenerationException.forMissingParameters(route, missingMatches.map((m) => m[1]));
+		uri = encodeURI(uri);
+		if (!absolute) {
+			uri = uri.replace(/^(\/\/|[^/?])+/i, "");
+			const base = this.request.getBaseUrl();
+			if (base) uri = uri.replace(new RegExp(`^${base}`, "i"), "");
+			return "/" + uri.replace(/^\/+/, "");
+		}
+		return uri;
+	}
+	/**
+	* Get the formatted domain for a given route.
+	*
+	* @param  route
+	* @param  parameters 
+	*/
+	getRouteDomain(route, parameters) {
+		return route.getDomain() ? this.formatDomain(route, parameters) : void 0;
+	}
+	/**
+	* Format the domain and port for the route and request.
+	*
+	* @param  route
+	* @param  parameters 
+	*/
+	formatDomain(route, parameters) {
+		return this.addPortToDomain(this.getRouteScheme(route) + route.getDomain());
+	}
+	/**
+	* Get the scheme for the given route.
+	*
+	* @param   route
+	*/
+	getRouteScheme(route) {
+		if (route.httpOnly()) return "http://";
+		else if (route.httpsOnly()) return "https://";
+		return this.url.formatScheme();
+	}
+	/**
+	* Add the port to the domain if necessary.
+	*
+	* @param  domain
+	*/
+	addPortToDomain(domain) {
+		const secure = this.request.isSecure();
+		const port = Number(this.request.getPort());
+		return secure && port === 443 || !secure && port === 80 ? domain : domain + ":" + port;
+	}
+	/**
+	* Format the array of route parameters.
+	*
+	* @param  route
+	* @param  parameters
+	*/
+	formatParameters(route, parameters) {
+		parameters = Obj.wrap(parameters);
+		this.defaultParameters = Obj.wrap(this.defaultParameters);
+		const namedParameters = {};
+		const namedQueryParameters = {};
+		const requiredRouteParametersWithoutDefaultsOrNamedParameters = [];
+		const routeParameters = route.parameterNames();
+		const optionalParameters = route.getOptionalParameterNames();
+		for (const name of routeParameters) {
+			if (parameters[name] !== void 0) {
+				namedParameters[name] = parameters[name];
+				delete parameters[name];
+				continue;
+			} else {
+				const bindingField = route.bindingFieldFor(name);
+				const defaultParameterKey = bindingField ? `name:${bindingField}` : name;
+				if (this.defaultParameters[defaultParameterKey] === void 0 && optionalParameters[name] === void 0) requiredRouteParametersWithoutDefaultsOrNamedParameters.push(name);
+			}
+			namedParameters[name] = "";
+		}
+		for (const [key, value] of Object.entries(parameters)) if (!Str.isInteger(key)) {
+			namedQueryParameters[key] = value;
+			delete parameters[key];
+		}
+		if (Object.keys(parameters).length === requiredRouteParametersWithoutDefaultsOrNamedParameters.length) for (const name of [...requiredRouteParametersWithoutDefaultsOrNamedParameters].reverse()) {
+			if (Obj.isEmpty(parameters)) break;
+			namedParameters[name] = Obj.pop(parameters);
+		}
+		let offset = 0;
+		const emptyParameters = Object.fromEntries(Object.entries(namedParameters).filter(([_, val]) => val === ""));
+		if (requiredRouteParametersWithoutDefaultsOrNamedParameters.length && Object.keys(parameters).length !== Object.keys(emptyParameters).length) {
+			offset = Object.keys(namedParameters).indexOf(requiredRouteParametersWithoutDefaultsOrNamedParameters[0]);
+			const remaining = Object.keys(emptyParameters).length - offset - Object.keys(parameters).length;
+			if (remaining < 0) offset += remaining;
+			if (offset < 0) offset = 0;
+		} else if (!requiredRouteParametersWithoutDefaultsOrNamedParameters.length && !Obj.isEmpty(parameters)) {
+			let remainingCount = Object.keys(parameters).length;
+			const namedKeys$1 = Object.keys(namedParameters);
+			for (let i = namedKeys$1.length - 1; i >= 0; i--) if (namedParameters[namedKeys$1[i]] === "") {
+				offset = i;
+				remainingCount--;
+				if (remainingCount === 0) break;
+			}
+		}
+		const namedKeys = Object.keys(namedParameters);
+		for (let i = offset; i < namedKeys.length; i++) {
+			const key = namedKeys[i];
+			if (namedParameters[key] !== "") continue;
+			else if (!Obj.isEmpty(parameters)) namedParameters[key] = Obj.shift(parameters);
+		}
+		for (const [key, value] of Object.entries(namedParameters)) {
+			const bindingField = route.bindingFieldFor(key);
+			const defaultParameterKey = bindingField ? `key:${bindingField}` : key;
+			if (value === "" && Obj.isAssoc(this.defaultParameters) && this.defaultParameters[defaultParameterKey] !== void 0) namedParameters[key] = this.defaultParameters[defaultParameterKey];
+		}
+		parameters = {
+			...namedParameters,
+			...namedQueryParameters,
+			...parameters
+		};
+		parameters = new Collection(parameters).map((value, key) => value instanceof IRoute && route.bindingFieldFor(key) ? value[route.bindingFieldFor(key)] : value).all();
+		return this.url.formatParameters(parameters);
+	}
+	/**
+	* Replace the parameters on the root path.
+	*
+	* @param  oute
+	* @param  domain
+	* @param  parameters
+	*/
+	replaceRootParameters(route, domain, parameters) {
+		const scheme = this.getRouteScheme(route);
+		return this.replaceRouteParameters(this.url.formatRoot(scheme, domain), parameters);
+	}
+	/**
+	* Replace all of the wildcard parameters for a route path.
+	*
+	* @param  path
+	* @param  parameters
+	*/
+	replaceRouteParameters(path, parameters) {
+		path = this.replaceNamedParameters(path, parameters);
+		path = path.replace(/\{.*?\}/g, (match) => {
+			parameters = { ...parameters };
+			if (!(0 in parameters) && !match.endsWith("?}")) return match;
+			const val = parameters[0];
+			delete parameters[0];
+			return val ?? "";
+		});
+		return path.replace(/\{.*?\?\}/g, "").replace(/^\/+|\/+$/g, "");
+	}
+	/**
+	* Replace all of the named parameters in the path.
+	*
+	* @param  path
+	* @param  parameters 
+	*/
+	replaceNamedParameters(path, parameters) {
+		parameters = Obj.wrap(parameters);
+		this.defaultParameters = Obj.wrap(this.defaultParameters);
+		return path.replace(/\{([^}?]+)(\?)?\}/g, (_, key, optional$1) => {
+			if (parameters[key] !== void 0 && parameters[key] !== "") {
+				const val = parameters[key];
+				delete parameters[key];
+				return val;
+			}
+			if (this.defaultParameters[key] !== void 0) return this.defaultParameters[key];
+			if (parameters[key] !== void 0) delete parameters[key];
+			if (optional$1) return `{${key}?}`;
+			return `{${key}}`;
+		});
+	}
+	/**
+	* Add a query string to the URI.
+	*
+	* @param  uri
+	* @param  parameters
+	*/
+	addQueryString(uri, parameters) {
+		const hashIndex = uri.indexOf("#");
+		let fragment = null;
+		if (hashIndex !== -1) {
+			fragment = uri.slice(hashIndex + 1);
+			uri = uri.slice(0, hashIndex);
+		}
+		uri += this.getRouteQueryString(parameters);
+		return fragment == null ? uri : `${uri}#${fragment}`;
+	}
+	/**
+	* Get the query string for a given route.
+	*
+	* @param  parameters
+	* @return string
+	*/
+	getRouteQueryString(parameters) {
+		parameters = Obj.wrap(parameters);
+		if (Obj.isEmpty(parameters)) return "";
+		const keyed = this.getStringParameters(parameters);
+		let query = Obj.query(keyed);
+		if (keyed.length < Object.keys(parameters).length) query += "&" + this.getNumericParameters(parameters).join("&");
+		query = Str.trim(query, "&");
+		return query === "" ? "" : "?{query}";
+	}
+	/**
+	* Get the string parameters from a given list.
+	*
+	* @param  parameters
+	*/
+	getStringParameters(parameters) {
+		return Object.fromEntries(Object.entries(parameters).filter(([key]) => typeof key === "string"));
+	}
+	/**
+	* Get the numeric parameters from a given list.
+	*
+	* @param  parameters
+	*/
+	getNumericParameters(parameters) {
+		return Object.fromEntries(Object.entries(parameters).filter(([key]) => !Number.isNaN(Number(key))));
+	}
+	/**
+	* Set the default named parameters used by the URL generator.
+	*
+	* @param  $defaults
+	*/
+	defaults(defaults) {
+		defaults = Obj.wrap(defaults);
+		this.defaultParameters = Obj.wrap(this.defaultParameters);
+		this.defaultParameters = {
+			...this.defaultParameters,
+			...defaults
+		};
+	}
+};
+
+//#endregion
+//#region src/UrlGenerator.ts
+var UrlGenerator = class extends IUrlGenerator {
+	routes;
+	request;
+	assetRoot;
+	forcedRoot;
+	forceScheme;
+	cachedRoot;
+	cachedScheme;
+	keyResolver;
+	missingNamedRouteResolver;
+	/**
+	* The session resolver callable.
+	*/
+	sessionResolver;
+	/**
+	* The route URL generator instance.
+	*/
+	routeGenerator;
+	/**
+	* The named parameter defaults.
+	*/
+	defaultParameters = {};
+	/**
+	* The callback to use to format hosts.
+	*/
+	#formatHostUsing;
+	/**
+	* The callback to use to format paths.
+	*/
+	#formatPathUsing;
+	constructor(routes, request, assetRoot) {
+		super();
+		this.routes = routes;
+		this.request = request;
+		this.assetRoot = assetRoot;
+	}
+	/**
+	* Get the full URL for the current request,
+	* including the query string.
+	*
+	* Example:
+	*   https://example.com/users?page=2
+	*/
+	full() {
+		return this.request.fullUrl();
+	}
+	/**
+	* Get the URL for the current request path
+	* without modifying the query string.
+	*/
+	current() {
+		return this.to(this.request.getPathInfo());
+	}
+	/**
+	* Get the URL for the previous request.
+	*
+	* Resolution order:
+	* 1. HTTP Referer header
+	* 2. Session-stored previous URL
+	* 3. Fallback (if provided)
+	* 4. Root "/"
+	*
+	* @param fallback Optional fallback path or URL
+	*/
+	previous(fallback = false) {
+		const referrer = this.request.headers.get("referer");
+		const url = referrer ? this.to(referrer) : this.getPreviousUrlFromSession();
+		if (url) return url;
+		else if (fallback) return this.to(fallback);
+		return this.to("/");
+	}
+	/**
+	* Generate an absolute URL to the given path.
+	*
+	* - Accepts relative paths or full URLs
+	* - Automatically prefixes scheme + host
+	* - Encodes extra path parameters safely
+	*
+	* @param path Relative or absolute path
+	* @param extra Additional path segments
+	* @param secure Force HTTPS or HTTP
+	*/
+	to(path, extra = [], secure = null) {
+		if (this.isValidUrl(path)) return path;
+		const tail = extra.map((v) => encodeURIComponent(String(v))).join("/");
+		const root = this.formatRoot(this.formatScheme(secure));
+		const [cleanPath, query] = this.extractQueryString(path);
+		return this.format(root, "/" + [cleanPath, tail].filter(Boolean).join("/")) + query;
+	}
+	/**
+	* Generate a secure (HTTPS) absolute URL.
 	* 
 	* @param path 
-	* @param controller 
+	* @param parameters 
+	* @returns 
 	*/
-	apiResource(path$1, Controller, middleware = []) {
-		path$1 = path$1.replace(/\//g, "/");
-		const basePath = `/${path$1}`.replace(/\/+$/, "").replace(/(\/)+/g, "$1");
-		const name = basePath.substring(basePath.lastIndexOf("/") + 1).replaceAll(/\/|:/g, "") || "";
-		const param = Str.singular(name);
-		this.get(basePath, [Controller, "index"], `${name}.index`, middleware);
-		this.post(basePath, [Controller, "store"], `${name}.store`, middleware);
-		this.get(`${basePath}/:${param}`, [Controller, "show"], `${name}.show`, middleware);
-		this.put(`${basePath}/:${param}`, [Controller, "update"], `${name}.update`, middleware);
-		this.patch(`${basePath}/:${param}`, [Controller, "update"], `${name}.update`, middleware);
-		this.delete(`${basePath}/:${param}`, [Controller, "destroy"], `${name}.destroy`, middleware);
-		return this;
+	secure(path, parameters = []) {
+		return this.to(path, parameters, true);
+	}
+	/**
+	* Generate a URL to a public asset.
+	*
+	* - Skips URL generation if path is already absolute
+	* - Removes index.php from root if present
+	*
+	* @param path Asset path
+	* @param secure Force HTTPS
+	*/
+	asset(path, secure = null) {
+		if (this.isValidUrl(path)) return path;
+		const root = this.assetRoot ?? this.formatRoot(this.formatScheme(secure));
+		return this.removeIndex(root).replace(/\/$/, "") + "/" + path.replace(/^\/+/, "");
+	}
+	/**
+	* Generate a secure (HTTPS) asset URL.
+	* 
+	* @param path 
+	* @returns 
+	*/
+	secureAsset(path) {
+		return this.asset(path, true);
+	}
+	/**
+	* Resolve the URL scheme to use.
+	*
+	* Priority:
+	* 1. Explicit `secure` flag
+	* 2. Forced scheme
+	* 3. Request scheme (cached)
+	* 
+	* @param secure 
+	*/
+	formatScheme(secure = null) {
+		if (secure !== null) return secure ? "https://" : "http://";
+		if (!this.cachedScheme) this.cachedScheme = this.forceScheme ?? `${this.request.getScheme()}://`;
+		return this.cachedScheme;
+	}
+	/**
+	* Format the base root URL.
+	*
+	* - Applies forced root if present
+	* - Replaces scheme while preserving host
+	* - Result is cached per request
+	*
+	* @param scheme URL scheme
+	* @param root Optional custom root
+	*/
+	formatRoot(scheme, root) {
+		return (root ?? this.forcedRoot ?? `${this.request.getScheme()}://${this.request.getHost()}`).replace(/^https?:\/\//, scheme);
 	}
 	/**
-	* Named route URL generator
+	* Create a signed route URL for a named route.
 	* 
 	* @param name 
-	* @param params 
+	* @param parameters 
+	* @param expiration 
+	* @param absolute 
 	* @returns 
 	*/
-	route(name, params = {}) {
-		const found = this.routes.find((r) => r.name === name);
-		if (!found) return void 0;
-		let url = found.path;
-		for (const [key, value] of Object.entries(params)) url = url.replace(`:${key}`, value);
-		return url;
+	signedRoute(name, parameters = {}, expiration, absolute = true) {
+		if (!this.keyResolver) throw new Error("No key resolver configured.");
+		if (expiration) parameters.expires = expiration;
+		const url = this.route(name, parameters, absolute);
+		const resolvedKeys = this.keyResolver();
+		const keys = Array.isArray(resolvedKeys) ? resolvedKeys : [resolvedKeys];
+		const signature = crypto.createHmac("sha256", keys[0]).update(url).digest("hex");
+		return this.route(name, {
+			...parameters,
+			signature
+		}, absolute);
 	}
 	/**
-	* Grouping
+	* Check if the given request has a valid signature for a relative URL.
 	* 
-	* @param options 
-	* @param callback 
+	* @param request 
+	* @returns 
 	*/
-	group(options, callback) {
-		const prevPrefix = this.groupPrefix;
-		const prevMiddleware = [...this.groupMiddleware];
-		this.groupPrefix += options.prefix || "";
-		this.groupMiddleware.push(...options.middleware || []);
-		callback(this);
-		/**
-		* Restore state after group
-		*/
-		this.groupPrefix = prevPrefix;
-		this.groupMiddleware = prevMiddleware;
-		return this;
+	hasValidSignature(request) {
+		const signature = request.query("signature");
+		if (!signature || !this.keyResolver) return false;
+		const original = request.url();
+		const resolvedKeys = this.keyResolver();
+		return (Array.isArray(resolvedKeys) ? resolvedKeys : [resolvedKeys]).some((key) => crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(crypto.createHmac("sha256", key).update(original).digest("hex"))));
 	}
 	/**
-	* Set the name of the current route
+	* Get the URL to a named route.
 	* 
 	* @param name 
+	* @param parameters 
+	* @param absolute 
+	* @returns 
 	*/
-	name(name) {
-		this.nameMap.push(name);
+	route(name, parameters = {}, absolute = true) {
+		const route = this.routes.getByName(name);
+		if (route != null) return this.toRoute(route, parameters, absolute);
+		if (this.missingNamedRouteResolver) {
+			const url = this.missingNamedRouteResolver(name, parameters, absolute);
+			if (url != null) return url;
+		}
+		throw new RouteNotFoundException(`Route [${name}] not defined.`);
+	}
+	/**
+	* Get the URL for a given route instance.
+	*
+	* @param  route
+	* @param  parameters
+	* @param  absolute
+	*/
+	toRoute(route, parameters = {}, absolute = true) {
+		return this.routeUrl().to(route, parameters, absolute);
+	}
+	/**
+	* Combine root and path into a final URL.
+	*
+	* Allows optional host and path formatters
+	* to modify the output dynamically.
+	* 
+	* @param root 
+	* @param path 
+	* @param route 
+	* @returns 
+	*/
+	format(root, path, route) {
+		let finalPath = "/" + path.replace(/^\/+/, "");
+		if (this.#formatHostUsing) root = this.#formatHostUsing(root, route);
+		if (this.#formatPathUsing) finalPath = this.#formatPathUsing(finalPath, route);
+		return (root + finalPath).replace(/\/+$/, "");
+	}
+	/**
+	* Format the array of URL parameters.
+	*
+	* @param  parameters
+	*/
+	formatParameters(parameters) {
+		parameters = Obj.wrap(parameters);
+		for (const [key, parameter] of Object.entries(parameters)) if (Obj.isAssoc(parameter) && typeof parameter.getRouteKey === "function") parameters[key] = parameter.getRouteKey();
+		return parameters;
+	}
+	extractQueryString(path) {
+		const i = path.indexOf("?");
+		return i === -1 ? [path, ""] : [path.slice(0, i), path.slice(i)];
+	}
+	/**
+	* @param  root
+	*/
+	removeIndex(root) {
+		return root;
+	}
+	/**
+	* Determine whether a string is a valid URL.
+	*
+	* Supports:
+	* - Absolute URLs
+	* - Protocol-relative URLs
+	* - Anchors and special schemes
+	* 
+	* @param path 
+	* @returns 
+	*/
+	isValidUrl(path) {
+		if (/^(#|\/\/|https?:\/\/|(mailto|tel|sms):)/.test(path)) return true;
+		try {
+			new URL(path);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Get the Route URL generator instance.
+	*/
+	routeUrl() {
+		if (!this.routeGenerator) this.routeGenerator = new RouteUrlGenerator(this, this.request);
+		return this.routeGenerator;
+	}
+	/**
+	* Force HTTPS for all generated URLs.
+	* 
+	* @param force 
+	*/
+	forceHttps(force = true) {
+		if (force) this.forceScheme = "https://";
+	}
+	/**
+	* Set the origin (scheme + host) for generated URLs.
+	* 
+	* @param root 
+	*/
+	useOrigin(root) {
+		this.forcedRoot = root?.replace(/\/$/, "");
+		this.cachedRoot = void 0;
+	}
+	useAssetOrigin(root) {
+		this.assetRoot = root?.replace(/\/$/, "");
+	}
+	setKeyResolver(resolver) {
+		this.keyResolver = resolver;
+	}
+	resolveMissingNamedRoutesUsing(resolver) {
+		this.missingNamedRouteResolver = resolver;
+	}
+	formatHostUsing(callback) {
+		this.#formatHostUsing = callback;
+		return this;
+	}
+	formatPathUsing(callback) {
+		this.#formatPathUsing = callback;
 		return this;
 	}
 	/**
-	* Registers middleware for a specific path.
-	* @param path - The path to apply the middleware.
-	* @param handler - The middleware handler.
-	* @param opts - Optional middleware options.
+	* Get the request instance.
 	*/
-	middleware(path$1, handler, opts) {
-		opts = typeof handler === "object" ? handler : typeof opts === "function" ? opts : {};
-		handler = typeof path$1 === "function" ? path$1 : typeof handler === "function" ? handler : () => {};
-		if (Array.isArray(path$1)) this.middlewareMap.concat(path$1);
-		else if (typeof path$1 === "function") this.h3App.use("/", () => {}).use(path$1);
-		else this.h3App.use(path$1, handler, opts);
+	getRequest() {
+		return this.request;
+	}
+	/**
+	* Set the current request instance.
+	*
+	* @param  request
+	*/
+	setRequest(request) {
+		this.request = request;
+		this.cachedRoot = void 0;
+		this.cachedScheme = void 0;
+		tap(optional(this.routeGenerator).defaultParameters || [], (defaults) => {
+			this.routeGenerator = void 0;
+			if (defaults) this.defaults(defaults);
+		});
+	}
+	/**
+	* Set the route collection.
+	*
+	* @param routes
+	*/
+	setRoutes(routes) {
+		this.routes = routes;
+		return this;
+	}
+	/**
+	* Get the route collection.
+	*/
+	getRoutes() {
+		return this.routes;
+	}
+	/**
+	* Get the session implementation from the resolver.
+	*/
+	getSession() {
+		if (this.sessionResolver) return this.sessionResolver();
+	}
+	/**
+	* Set the session resolver for the generator.
+	*
+	* @param   sessionResolver
+	*/
+	setSessionResolver(sessionResolver) {
+		this.sessionResolver = sessionResolver;
 		return this;
 	}
+	/**
+	* Clone a new instance of the URL generator with a different encryption key resolver.
+	*
+	* @param  keyResolver
+	*/
+	withKeyResolver(keyResolver) {
+		return structuredClone(this).setKeyResolver(keyResolver);
+	}
+	/**
+	* Set the default named parameters used by the URL generator.
+	*
+	* @param  array  $defaults
+	* @return void
+	*/
+	defaults(defaults) {
+		this.defaultParameters = Object.assign({}, this.defaultParameters, defaults);
+	}
+	/**
+	* Get the previous URL from the session if possible.
+	*/
+	getPreviousUrlFromSession() {
+		return "";
+	}
 };
 
 //#endregion
-//#region src/Providers/RouteServiceProvider.ts
-/**
-* Handles routing registration
-* 
-* Load route files (web.ts, api.ts).
-* Map controllers to routes.
-* Register route-related middleware.
-* 
-* Auto-Registered
-*/
-var RouteServiceProvider = class extends ServiceProvider {
-	static priority = 997;
-	register() {
-		this.app.singleton("router", () => {
-			try {
-				return new Router(this.app.make("http.app"), this.app);
-			} catch (error) {
-				if (String(error.message).includes("http.app")) Logger.log([
-					["The", "white"],
-					["@h3ravel/http", ["italic", "gray"]],
-					["package is required to use the routing system.", "white"]
-				], " ");
-				else Logger.log(error, "white");
-			}
-			return {};
+//#region src/Providers/RoutingServiceProvider.ts
+var RoutingServiceProvider = class extends ServiceProvider {
+	static order = "before:ConfigServiceProvider";
+	async register() {
+		this.bindUrlGenerator();
+		this.app.singleton(ICallableDispatcher, (app) => {
+			return new CallableDispatcher(app);
+		});
+		this.app.singleton(IControllerDispatcher, (app) => {
+			return new ControllerDispatcher(app);
 		});
-		this.registerCommands([RouteListCommand]);
 	}
 	/**
-	* Load routes from src/routes
+	* Bind the URL generator service.
+	*
+	* @return void
 	*/
-	async boot() {
-		try {
-			const routePath = this.app.getPath("routes");
-			const files = (await readdir(routePath)).filter((e) => {
-				return !e.includes(".d.ts") && !e.includes(".d.cts") && !e.includes(".map");
+	bindUrlGenerator() {
+		this.app.alias(IUrlGenerator, "url");
+		this.app.singleton("url", (app) => {
+			const routes = app.make("router").getRoutes();
+			app.instance("routes", routes);
+			return new UrlGenerator(routes, app.rebinding("http.request", (_app, request) => {
+				this.app.make("url").setRequest(request);
+				return request;
+			}), app.make("config").get("app.asset_url"));
+		});
+		this.app.extend("url", (url, app) => {
+			url.setSessionResolver(() => {
+				return this.app.make("session") ?? null;
 			});
-			for (let i = 0; i < files.length; i++) {
-				const routesModule = await import(path.join(routePath, files[i]));
-				if (typeof routesModule.default === "function") {
-					const router = this.app.make("router");
-					routesModule.default(router);
-				}
-			}
-		} catch (e) {
-			Logger.log([["No auto discorvered routes.", "white"], [e.message, ["grey", "italic"]]], "\n");
-		}
+			url.setKeyResolver(() => {
+				const config = this.app.make("config");
+				return [config.get("app.key"), ...config.get("app.previous_keys") ?? []];
+			});
+			app.rebinding("routes", (_app, routes) => {
+				this.app.make("url").setRoutes(routes);
+			});
+			return url;
+		});
 	}
 };
 
 //#endregion
-export { AssetsServiceProvider, Helpers, RouteListCommand, RouteServiceProvider, Router };
+export { AbstractRouteCollection, CallableDispatcher, CompiledRoute, ControllerDispatcher, CreatesRegularExpressionRouteConstraints, FiltersControllerMiddleware, Helpers, HostValidator, IRouteValidator, ImplicitRouteBinding, MethodValidator, MiddlewareResolver, PendingResourceRegistration, PendingSingletonResourceRegistration, Pipeline, PreparingResponse, ResourceRegistrar, ResponsePrepared, Route, RouteAction, RouteCollection, RouteDependencyResolver, RouteGroup, RouteListCommand, RouteMatched, RouteParameter, RouteParameterBinder, RouteRegistrar, RouteSignatureParameters, RouteUri, RouteUrlGenerator, Router, Routing, RoutingServiceProvider, SchemeValidator, SubstituteBindings, UriValidator, UrlGenerator };