routup 5.2.0 → 6.0.0-beta.0

package/dist/{src-DX0rndew.mjs → src-gmPicCWT.mjs}

@@ -1,3 +1,4 @@
+import QuickLRU from "quick-lru";
 import { FastURL } from "srvx";
 import { hasInstanceof, markInstanceof } from "@ebec/core";
 import { HTTPError, isHTTPError } from "@ebec/http";
@@ -7,6 +8,42 @@ import { compile } from "proxy-addr";
 import { get, getType } from "mime-explorer";
 import Negotiator from "negotiator";
 import { pathToRegexp } from "path-to-regexp";
+//#region src/cache/lru.ts
+const DEFAULT_MAX_SIZE = 1024;
+/**
+* Default `ICache` implementation — a bounded LRU backed by
+* [`quick-lru`](https://github.com/sindresorhus/quick-lru). Picked for
+* its small footprint (~1kB), ESM-only build (matches routup), and
+* stable API.
+*
+* For TTL, size-based eviction, or dispose hooks, write your own
+* `ICache` (e.g. wrapping `lru-cache`) and pass it via the router's
+* `BaseRouterOptions.cache` slot.
+*/
+var LruCache = class LruCache {
+	options;
+	inner;
+	constructor(options = {}) {
+		this.options = options;
+		this.inner = new QuickLRU({ maxSize: options.maxSize ?? DEFAULT_MAX_SIZE });
+	}
+	get(key) {
+		return this.inner.get(key);
+	}
+	set(key, value) {
+		this.inner.set(key, value);
+	}
+	delete(key) {
+		this.inner.delete(key);
+	}
+	clear() {
+		this.inner.clear();
+	}
+	clone() {
+		return new LruCache({ ...this.options });
+	}
+};
+//#endregion
 //#region src/constants.ts
 const MethodName = {
 	GET: "GET",
@@ -51,6 +88,66 @@ const HeaderName = {
 	X_FORWARDED_PROTO: "x-forwarded-proto"
 };
 //#endregion
+//#region src/event/module.ts
+var AppEvent = class {
+	request;
+	params;
+	path;
+	method;
+	mountPath;
+	headers;
+	searchParams;
+	response;
+	store;
+	signal;
+	appOptions;
+	_context;
+	_nextCalled = false;
+	_nextResult;
+	_nextCalledDeferred;
+	constructor(context) {
+		this._context = context;
+		this.request = context.request;
+		this.params = context.params;
+		this.path = context.path;
+		this.method = context.method;
+		this.mountPath = context.mountPath;
+		this.headers = context.headers;
+		this.searchParams = context.searchParams;
+		this.response = context.response;
+		this.store = context.store;
+		this.signal = context.signal;
+		this.appOptions = context.appOptions;
+	}
+	get nextCalled() {
+		return this._nextCalled;
+	}
+	get nextResult() {
+		return this._nextResult;
+	}
+	whenNextCalled() {
+		if (!this._nextCalledDeferred) {
+			let resolve;
+			const promise = new Promise((r) => {
+				resolve = r;
+			});
+			this._nextCalledDeferred = {
+				promise,
+				resolve
+			};
+			if (this._nextCalled) resolve();
+		}
+		return this._nextCalledDeferred.promise;
+	}
+	async next(error) {
+		if (this._nextCalled) return this._nextResult;
+		this._nextCalled = true;
+		this._nextResult = this._context.next(this, error);
+		if (this._nextCalledDeferred) this._nextCalledDeferred.resolve();
+		return this._nextResult;
+	}
+};
+//#endregion
 //#region src/response/helpers/cache.ts
 function setResponseCacheHeaders(event, options) {
 	options = options || {};
@@ -64,11 +161,11 @@ function setResponseCacheHeaders(event, options) {
 }
 //#endregion
 //#region src/error/module.ts
-const ErrorSymbol = Symbol.for("RoutupError");
-var RoutupError = class extends HTTPError {
+const ErrorSymbol = Symbol.for("AppError");
+var AppError = class extends HTTPError {
 	constructor(input = {}) {
 		super(input);
-		this.name = "RoutupError";
+		this.name = "AppError";
 		markInstanceof(this, ErrorSymbol);
 	}
 };
@@ -91,7 +188,7 @@ function serializeEventStreamMessage(message) {
 //#region src/response/helpers/event-stream/module.ts
 function createEventStream(event, options) {
 	if (options?.maxMessageSize !== void 0) {
-		if (!Number.isInteger(options.maxMessageSize) || options.maxMessageSize < 0) throw new RoutupError("maxMessageSize must be a non-negative integer.");
+		if (!Number.isInteger(options.maxMessageSize) || options.maxMessageSize < 0) throw new AppError("maxMessageSize must be a non-negative integer.");
 	}
 	let controller;
 	let closed = false;
@@ -133,6 +230,30 @@ function createEventStream(event, options) {
 	return handle;
 }
 //#endregion
+//#region src/utils/accepts-json.ts
+/**
+* Check if the request accepts JSON responses.
+*
+* Parses the `Accept` header per RFC 7231 (media ranges + quality
+* params) rather than substring-matching, so:
+* - `application/json-seq` does NOT count as accepting `application/json`
+* - `application/json;q=0` is treated as an explicit rejection
+*
+* Returns true if no Accept header is present (API-first default).
+*/
+function acceptsJson(request) {
+	const accept = request.headers.get("accept");
+	if (!accept) return true;
+	return accept.toLowerCase().split(",").some((entry) => {
+		const parts = entry.split(";").map((part) => part.trim());
+		const mediaRange = parts[0];
+		const qParam = parts.slice(1).map((param) => param.split("=").map((s) => s.trim())).find(([key]) => key === "q");
+		const q = qParam ? Number.parseFloat(qParam[1] ?? "") : 1;
+		if (!Number.isFinite(q) || q <= 0) return false;
+		return mediaRange === "*/*" || mediaRange === "application/*" || mediaRange === "application/json" || mediaRange.endsWith("+json");
+	});
+}
+//#endregion
 //#region src/utils/header.ts
 function sanitizeHeaderValue(value) {
 	return value.replace(/[\r\n]/g, "");
@@ -180,6 +301,16 @@ function buildEtagFn(input) {
 		return createEtag(body, options);
 	};
 }
+/**
+* Default `EtagFn` used by `toResponse()` when `appOptions.etag` is
+* undefined. Module-scoped so we don't allocate per-request and so
+* all consumers share the same closure.
+*
+* `appOptions.etag === null` (explicitly disabled by the user)
+* remains distinct: consumers must check `=== undefined`, not
+* `== null`, before falling back to this default.
+*/
+const DEFAULT_ETAG_FN = buildEtagFn();
 //#endregion
 //#region src/utils/trust-proxy/module.ts
 function buildTrustProxyFn(input) {
@@ -189,6 +320,15 @@ function buildTrustProxyFn(input) {
 	if (typeof input === "string") input = input.split(",").map((value) => value.trim());
 	return compile(input || []);
 }
+/**
+* Default `TrustProxyFn` used by request helpers when neither the
+* call's `options.trustProxy` nor `event.appOptions.trustProxy` is
+* set. Trusts no addresses — the conservative default.
+*
+* Module-scoped so all helpers share the same reference and we don't
+* allocate per-request.
+*/
+const DEFAULT_TRUST_PROXY = buildTrustProxyFn();
 //#endregion
 //#region src/utils/mime.ts
 function getMimeType(type) {
@@ -226,18 +366,12 @@ function basename(input, extension) {
 	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
 }
 //#endregion
-//#region src/utils/url.ts
-const TRAILING_SLASH_RE = /\/$|\/\?/;
-function hasTrailingSlash(input = "", queryParams = false) {
-	if (!queryParams) return input.endsWith("/");
-	return TRAILING_SLASH_RE.test(input);
-}
-function withoutTrailingSlash(input = "", queryParams = false) {
-	if (!queryParams) return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
-	if (!hasTrailingSlash(input, true)) return input || "/";
-	const [s0, ...s] = input.split("?");
-	return (s0.slice(0, -1) || "/") + (s.length ? `?${s.join("?")}` : "");
+//#region src/utils/promise.ts
+function isPromise(p) {
+	return isObject(p) && (p instanceof Promise || typeof p.then === "function");
 }
+//#endregion
+//#region src/utils/url.ts
 function hasLeadingSlash(input = "") {
 	return input.startsWith("/");
 }
@@ -248,6 +382,33 @@ function cleanDoubleSlashes(input = "") {
 	if (input.includes("://")) return input.split("://").map((str) => cleanDoubleSlashes(str)).join("://");
 	return input.replace(/\/+/g, "/");
 }
+/**
+* Concatenate path parts into a single mount path.
+*
+* - Drops `undefined` and empty parts.
+* - A lone `'/'` part still contributes (so `joinPaths('/')` returns
+*   `'/'`, distinguishing "match the root exactly" from "no path").
+* - Returns `undefined` when every part is missing — callers
+*   interpret this as "no path" (always-match middleware).
+* - Joins remaining parts with `/`, normalizes the leading slash,
+*   collapses any inner `//`, and trims a trailing slash on results
+*   longer than `/`.
+*
+* Used at registration time to fold a handler / router's intrinsic
+* path into the mount path so the active `IRouter` is the
+* only place that builds path matchers.
+*/
+function joinPaths(...parts) {
+	const kept = [];
+	for (const part of parts) {
+		if (typeof part !== "string" || part === "") continue;
+		kept.push(part);
+	}
+	if (kept.length === 0) return;
+	const normalized = cleanDoubleSlashes(withLeadingSlash(kept.join("/")));
+	if (normalized.length > 1 && normalized.endsWith("/")) return normalized.slice(0, -1);
+	return normalized;
+}
 //#endregion
 //#region src/response/helpers/header.ts
 function appendResponseHeader(event, name, value) {
@@ -345,8 +506,8 @@ function isNativeError(input) {
 }
 /**
 * Create an internal error object by
-* - an existing RoutupError (returned as-is)
-* - an HTTPError (wrapped into a RoutupError preserving status)
+* - an existing AppError (returned as-is)
+* - an HTTPError (wrapped into a AppError preserving status)
 * - an Error (wrapped preserving message and cause)
 * - an options object (status, message, etc.)
 * - a message string
@@ -355,33 +516,51 @@ function isNativeError(input) {
 */
 function createError(input) {
 	if (isError(input)) return input;
-	if (typeof input === "string") return new RoutupError(input);
-	if (isHTTPError(input)) return new RoutupError({
+	if (typeof input === "string") return new AppError(input);
+	if (isHTTPError(input)) return new AppError({
 		message: input.message,
 		code: input.code,
 		status: input.status,
 		redirectURL: input.redirectURL,
 		cause: input
 	});
-	if (isNativeError(input)) return new RoutupError({
+	if (isNativeError(input)) return new AppError({
 		message: input.message,
 		cause: input
 	});
-	if (!isObject(input)) return new RoutupError();
+	if (!isObject(input)) return new AppError();
 	const options = { ...input };
 	if (options.cause === void 0) options.cause = input;
-	return new RoutupError(options);
+	return new AppError(options);
 }
 //#endregion
 //#region src/response/to-response.ts
 function stripWeakPrefix(etag) {
 	return etag.startsWith("W/") ? etag.slice(2) : etag;
 }
+/**
+* Resolve the effective etag fn for this request. `null` means the
+* user explicitly disabled ETag; `undefined` means the option was
+* never set, and we apply the framework default. Anything else is the
+* user's own fn.
+*/
+function effectiveEtagFn(event) {
+	const opt = event.appOptions.etag;
+	if (opt === null) return null;
+	if (typeof opt === "undefined") return DEFAULT_ETAG_FN;
+	return opt;
+}
+/**
+* Compute an ETag and conditionally return a 304, or set the header and
+* return undefined to let the caller emit the full response. Always
+* async because the ETag generator may be async (and typically is, via
+* `uncrypto`).
+*/
 async function applyEtag(body, event, headers) {
-	const etagFn = event.routerOptions.etag;
-	if (!etagFn) return void 0;
+	const etagFn = effectiveEtagFn(event);
+	if (!etagFn) return;
 	const etag = await etagFn(body);
-	if (!etag) return void 0;
+	if (!etag) return;
 	headers.set("etag", etag);
 	const ifNoneMatch = event.headers.get("if-none-match");
 	if (ifNoneMatch && (ifNoneMatch === "*" || ifNoneMatch.split(",").some((t) => stripWeakPrefix(t.trim()) === stripWeakPrefix(etag)))) return new Response(null, {
@@ -389,41 +568,60 @@ async function applyEtag(body, event, headers) {
 		headers
 	});
 }
-async function toResponse(value, event) {
+/**
+* Convert a handler's return value into a Web `Response`.
+*
+* Returns synchronously for the common cases (string, JSON object,
+* binary, stream, blob) when ETag generation is disabled. Returns a
+* `Promise` when an ETag must be computed (the generator is async).
+*
+* Callers that want the async return uniformly can `await` the result
+* — `await` on a non-Promise still works but pays a microtask hop.
+* The App fast path branches on `instanceof Promise` to keep the
+* sync return truly sync.
+*/
+function toResponse(value, event) {
 	if (value === void 0) return;
 	if (value === null) return new Response(null, {
 		status: event.response.status,
 		headers: event.response.headers
 	});
-	if (value instanceof Response) return value;
-	const { status, headers } = event.response;
-	if (typeof value === "string") {
+	const t = typeof value;
+	if (t === "string") {
+		const { status, headers } = event.response;
 		if (!headers.has("content-type")) headers.set("content-type", "text/plain; charset=utf-8");
-		const cached = await applyEtag(value, event, headers);
-		if (cached) return cached;
-		return new Response(value, {
+		if (event.appOptions.etag !== null) return applyEtag(value, event, headers).then((cached) => cached ?? new Response(value, {
 			status,
 			headers
-		});
-	}
-	if (value instanceof ArrayBuffer || value instanceof Uint8Array) {
-		if (!headers.has("content-type")) headers.set("content-type", "application/octet-stream");
+		}));
 		return new Response(value, {
 			status,
 			headers
 		});
 	}
-	if (value instanceof ReadableStream) return new Response(value, {
-		status,
-		headers
-	});
-	if (value instanceof Blob) {
-		if (!headers.has("content-type")) headers.set("content-type", value.type || "application/octet-stream");
-		return new Response(value, {
+	if (t === "object" && !Array.isArray(value)) {
+		if (value instanceof Response) return value;
+		const { status, headers } = event.response;
+		if (value instanceof ArrayBuffer || value instanceof Uint8Array) {
+			if (!headers.has("content-type")) headers.set("content-type", "application/octet-stream");
+			return new Response(value, {
+				status,
+				headers
+			});
+		}
+		if (value instanceof ReadableStream) return new Response(value, {
 			status,
 			headers
 		});
+		if (value instanceof Blob) {
+			if (!headers.has("content-type")) headers.set("content-type", value.type || "application/octet-stream");
+			return new Response(value, {
+				status,
+				headers
+			});
+		}
 	}
+	const { status, headers } = event.response;
 	if (!headers.has("content-type")) headers.set("content-type", "application/json; charset=utf-8");
 	let json;
 	try {
@@ -435,8 +633,10 @@ async function toResponse(value, event) {
 			cause: e
 		});
 	}
-	const cached = await applyEtag(json, event, headers);
-	if (cached) return cached;
+	if (event.appOptions.etag !== null) return applyEtag(json, event, headers).then((cached) => cached ?? new Response(json, {
+		status,
+		headers
+	}));
 	return new Response(json, {
 		status,
 		headers
@@ -576,7 +776,7 @@ function isAllowedRedirectUrl(location) {
 	}
 }
 function sendRedirect(event, location, statusCode = 302) {
-	if (!isAllowedRedirectUrl(location)) throw new RoutupError({
+	if (!isAllowedRedirectUrl(location)) throw new AppError({
 		status: 400,
 		message: "Invalid redirect URL scheme."
 	});
@@ -601,69 +801,6 @@ function sendStream(event, stream) {
 	});
 }
 //#endregion
-//#region src/event/module.ts
-var RoutupEvent = class {
-	request;
-	params;
-	path;
-	method;
-	mountPath;
-	headers;
-	searchParams;
-	response;
-	store;
-	signal;
-	_context;
-	_routerOptions;
-	_nextCalled = false;
-	_nextResult;
-	_nextCalledDeferred;
-	constructor(context) {
-		this._context = context;
-		this.request = context.request;
-		this.params = context.params;
-		this.path = context.path;
-		this.method = context.method;
-		this.mountPath = context.mountPath;
-		this.headers = context.headers;
-		this.searchParams = context.searchParams;
-		this.response = context.response;
-		this.store = context.store;
-		this.signal = context.signal;
-	}
-	get routerOptions() {
-		if (!this._routerOptions) this._routerOptions = this._context.routerOptions();
-		return this._routerOptions;
-	}
-	get nextCalled() {
-		return this._nextCalled;
-	}
-	get nextResult() {
-		return this._nextResult;
-	}
-	whenNextCalled() {
-		if (!this._nextCalledDeferred) {
-			let resolve;
-			const promise = new Promise((r) => {
-				resolve = r;
-			});
-			this._nextCalledDeferred = {
-				promise,
-				resolve
-			};
-			if (this._nextCalled) resolve();
-		}
-		return this._nextCalledDeferred.promise;
-	}
-	async next(error) {
-		if (this._nextCalled) return this._nextResult;
-		this._nextCalled = true;
-		this._nextResult = this._context.next(this, error);
-		if (this._nextCalledDeferred) this._nextCalledDeferred.resolve();
-		return this._nextResult;
-	}
-};
-//#endregion
 //#region src/dispatcher/module.ts
 var DispatcherEvent = class {
 	request;
@@ -676,7 +813,20 @@ var DispatcherEvent = class {
 	methodsAllowed;
 	mountPath;
 	error;
-	routerPath;
+	/**
+	* Options of the App currently dispatching this event. Set on
+	* entry to `App.dispatch` and restored on exit (so nested apps
+	* temporarily override). Initialized to `{}` so consumers
+	* reading before any dispatch get a valid (empty) shape.
+	*/
+	appOptions;
+	/**
+	* `true` while at least one `App.dispatch` is on the call stack
+	* for this event. `App.dispatch` reads this on entry to derive
+	* `isRoot` and writes it on entry/exit so nested calls see it
+	* already set.
+	*/
+	isDispatching;
 	_dispatched;
 	_response;
 	_store;
@@ -705,7 +855,8 @@ var DispatcherEvent = class {
 		this.path = this._url.pathname;
 		this.mountPath = "/";
 		this.params = {};
-		this.routerPath = [];
+		this.appOptions = {};
+		this.isDispatching = false;
 		this.methodsAllowed = /* @__PURE__ */ new Set();
 		this._dispatched = false;
 		this._nextCalled = false;
@@ -771,7 +922,7 @@ var DispatcherEvent = class {
 		this._nextResult = void 0;
 	}
 	build(signal) {
-		return new RoutupEvent({
+		return new AppEvent({
 			request: this.request,
 			params: this.params,
 			path: this.path,
@@ -782,7 +933,7 @@ var DispatcherEvent = class {
 			response: this.response,
 			store: this.store,
 			signal: signal ?? this.signal,
-			routerOptions: () => this.resolveOptions(),
+			appOptions: this.appOptions,
 			next: (event, error) => this.next(event, error)
 		});
 	}
@@ -790,23 +941,6 @@ var DispatcherEvent = class {
 		if (!this._store) this._store = Object.create(null);
 		return this._store;
 	}
-	resolveOptions() {
-		const resolved = {
-			trustProxy: () => false,
-			subdomainOffset: 2,
-			etag: buildEtagFn(),
-			proxyIpMax: 0
-		};
-		for (let i = 0; i < this.routerPath.length; i++) {
-			const node = this.routerPath[i];
-			const entries = Object.entries(node.options);
-			for (const entry of entries) {
-				const [key, value] = entry;
-				if (typeof value !== "undefined") resolved[key] = value;
-			}
-		}
-		return resolved;
-	}
 };
 //#endregion
 //#region src/handler/constants.ts
@@ -818,8 +952,17 @@ const HandlerSymbol = Symbol.for("Handler");
 //#endregion
 //#region src/hook/constants.ts
 const HookName = {
-	REQUEST: "request",
-	RESPONSE: "response",
+	/**
+	* Fired at the start of `App.dispatch`, before the pipeline walk.
+	* Once per router per request.
+	*/
+	START: "start",
+	/**
+	* Fired at the end of `App.dispatch`, after the pipeline walk
+	* (and OPTIONS auto-Allow synthesis) completes. Once per router per
+	* request.
+	*/
+	END: "end",
 	ERROR: "error",
 	CHILD_MATCH: "childMatch",
 	CHILD_DISPATCH_BEFORE: "childDispatchBefore",
@@ -829,8 +972,25 @@ const HookName = {
 //#region src/hook/module.ts
 var Hooks = class Hooks {
 	items;
+	/**
+	* Derived bit: `true` iff at least one entry exists across all
+	* hook names. Maintained on every `addListener` / `removeListener`
+	* so the dispatch hot path can short-circuit on a single boolean
+	* read rather than per-name lookup. Apps that never register a
+	* hook (the common case) pay one boolean check per request
+	* instead of a property access per pipeline step.
+	*/
+	_hasAny;
 	constructor() {
 		this.items = {};
+		this._hasAny = false;
+	}
+	hasAny() {
+		return this._hasAny;
+	}
+	hasListeners(name) {
+		if (!this._hasAny) return false;
+		return this.items[name] !== void 0;
 	}
 	addListener(name, fn, priority = 0) {
 		this.items[name] = this.items[name] || [];
@@ -841,6 +1001,7 @@ var Hooks = class Hooks {
 		let i = 0;
 		while (i < this.items[name].length && this.items[name][i].priority >= priority) i++;
 		this.items[name].splice(i, 0, entry);
+		this._hasAny = true;
 		return () => {
 			this.removeListener(name, fn);
 		};
@@ -849,6 +1010,7 @@ var Hooks = class Hooks {
 		if (!this.items[name]) return;
 		if (typeof fn === "undefined") {
 			delete this.items[name];
+			this.recomputeHasAny();
 			return;
 		}
 		if (typeof fn === "function") {
@@ -856,6 +1018,20 @@ var Hooks = class Hooks {
 			if (index !== -1) this.items[name].splice(index, 1);
 		}
 		if (this.items[name].length === 0) delete this.items[name];
+		this.recomputeHasAny();
+	}
+	/**
+	* Recompute `_hasAny` from the current `items` map. O(k) where k
+	* is the number of distinct hook names ever registered (≤ ~6) —
+	* effectively O(1). Called from `removeListener` so the fast-path
+	* flag stays in sync with registration state.
+	*/
+	recomputeHasAny() {
+		for (const name in this.items) if (this.items[name] && this.items[name].length > 0) {
+			this._hasAny = true;
+			return;
+		}
+		this._hasAny = false;
 	}
 	/**
 	* Create a new `Hooks` instance seeded with the same listeners as this
@@ -907,120 +1083,35 @@ var Hooks = class Hooks {
 	}
 };
 //#endregion
-//#region src/path/matcher.ts
-function decodeParam(val) {
-	/* istanbul ignore next */
-	if (typeof val !== "string" || val.length === 0) return val;
-	try {
-		return decodeURIComponent(val);
-	} catch {
-		return val;
+//#region src/handler/module.ts
+var Handler = class {
+	config;
+	hooks;
+	method;
+	constructor(handler) {
+		this.config = handler;
+		this.hooks = new Hooks();
+		this.mountHooks();
+		if (typeof handler.path === "string") this.config.path = withLeadingSlash(handler.path);
+		this.method = this.config.method ? toMethodName(this.config.method) : void 0;
+		markInstanceof(this, HandlerSymbol);
 	}
-}
-var PathMatcher = class {
-	path;
-	regexp;
-	regexpKeys = [];
-	regexpOptions;
-	constructor(path, options) {
-		this.path = path;
-		this.regexpOptions = options || {};
-		const regexp = pathToRegexp(path, options);
-		this.regexp = regexp.regexp;
-		this.regexpKeys = regexp.keys;
+	get type() {
+		return this.config.type;
 	}
-	test(path) {
-		return this.regexp.test(path);
-	}
-	exec(path) {
-		if (this.path === "/" && this.regexpOptions.end === false) return {
-			path: "/",
-			params: Object.create(null)
-		};
-		const match = this.regexp.exec(path);
-		if (!match) return;
-		const params = Object.create(null);
-		for (let i = 1; i < match.length; i++) {
-			const key = this.regexpKeys[i - 1];
-			if (!key) continue;
-			const prop = key.name;
-			const val = decodeParam(match[i]);
-			if (typeof val !== "undefined") params[prop] = val;
-		}
-		return {
-			path: match[0],
-			params
-		};
-	}
-};
-//#endregion
-//#region src/path/utils.ts
-function isPath(input) {
-	return typeof input === "string";
-}
-//#endregion
-//#region src/handler/utils.ts
-/**
-* Build a `PathMatcher` for a handler-side path.
-*
-* Returns `undefined` when no path is supplied. The `end` flag controls
-* whether the matcher requires a full match (`true` for method handlers
-* matching exact routes) or accepts a prefix (`false` for middleware).
-*/
-function buildHandlerPathMatcher(path, end) {
-	if (typeof path === "undefined") return;
-	return new PathMatcher(typeof path === "string" ? withLeadingSlash(path) : path, { end });
-}
-/**
-* Match a request method against a handler's bound method.
-*
-* - When the handler has no method bound, matches every request method.
-* - Otherwise matches when the request method is the same.
-* - HEAD requests additionally match GET handlers.
-*/
-function matchHandlerMethod(handlerMethod, requestMethod) {
-	return !handlerMethod || requestMethod === handlerMethod || requestMethod === MethodName.HEAD && handlerMethod === MethodName.GET;
-}
-//#endregion
-//#region src/handler/module.ts
-var Handler = class {
-	config;
-	hooks;
-	pathMatcher;
-	method;
-	constructor(handler) {
-		this.config = handler;
-		this.hooks = new Hooks();
-		this.mountHooks();
-		if (typeof handler.path === "string") this.config.path = withLeadingSlash(handler.path);
-		this.pathMatcher = buildHandlerPathMatcher(this.config.path, !!this.config.method);
-		this.method = this.config.method ? toMethodName(this.config.method) : void 0;
-		markInstanceof(this, HandlerSymbol);
-	}
-	get type() {
-		return this.config.type;
-	}
-	get path() {
-		return this.config.path;
+	get path() {
+		return this.config.path;
 	}
 	async dispatch(event) {
-		if (this.pathMatcher) {
-			const pathMatch = this.pathMatcher.exec(event.path);
-			if (pathMatch) event.params = {
-				...event.params,
-				...pathMatch.params
-			};
+		if (this.hooks.hasListeners(HookName.CHILD_DISPATCH_BEFORE)) {
+			await this.hooks.trigger(HookName.CHILD_DISPATCH_BEFORE, event);
+			if (event.dispatched) return;
 		}
-		await this.hooks.trigger(HookName.CHILD_DISPATCH_BEFORE, event);
-		if (event.dispatched) return;
 		let response;
 		try {
-			let result;
-			const previewEvent = event.build();
-			const effectiveTimeout = this.resolveTimeout(previewEvent.routerOptions);
+			const effectiveTimeout = this.resolveTimeout(event.appOptions);
 			let childController;
 			let cleanupParentListener;
-			let handlerEvent = previewEvent;
 			if (effectiveTimeout) {
 				const parentSignal = event.signal;
 				childController = new AbortController();
@@ -1030,37 +1121,44 @@ var Handler = class {
 					parentSignal.addEventListener("abort", onAbort, { once: true });
 					cleanupParentListener = () => parentSignal.removeEventListener("abort", onAbort);
 				}
-				handlerEvent = event.build(childController.signal);
 			}
+			const handlerEvent = childController ? event.build(childController.signal) : event.build();
+			let result;
 			try {
-				if (this.config.type === HandlerType.ERROR) {
-					if (event.error) {
-						const { fn } = this.config;
-						const { error } = event;
-						result = await this.executeWithTimeout(() => this.resolveHandlerResult(fn(error, handlerEvent), handlerEvent), handlerEvent.routerOptions, childController);
-					}
-				} else {
+				let skipFn = false;
+				let invocation;
+				if (this.config.type === HandlerType.ERROR) if (event.error) {
+					const { fn } = this.config;
+					invocation = fn(event.error, handlerEvent);
+				} else skipFn = true;
+				else {
 					const { fn } = this.config;
-					result = await this.executeWithTimeout(() => this.resolveHandlerResult(fn(handlerEvent), handlerEvent), handlerEvent.routerOptions, childController);
+					invocation = fn(handlerEvent);
 				}
+				if (skipFn) {} else if (effectiveTimeout) result = await this.executeWithTimeout(() => this.resolveHandlerResult(invocation, handlerEvent), effectiveTimeout, childController);
+				else if (isPromise(invocation)) {
+					const awaited = await invocation;
+					result = typeof awaited === "undefined" ? await this.resolveHandlerResult(void 0, handlerEvent) : awaited;
+				} else if (typeof invocation === "undefined") result = await this.resolveHandlerResult(void 0, handlerEvent);
+				else result = invocation;
 			} finally {
 				if (cleanupParentListener) cleanupParentListener();
 			}
-			response = await toResponse(result, handlerEvent);
-			if (response) event.dispatched = true;
+			const toResp = toResponse(result, handlerEvent);
+			response = isPromise(toResp) ? await toResp : toResp;
+			if (response) {
+				event.dispatched = true;
+				if (this.config.type === HandlerType.ERROR && event.error) event.error = void 0;
+			}
 		} catch (e) {
 			event.error = isError(e) ? e : createError(e);
-			await this.hooks.trigger(HookName.ERROR, event);
+			if (this.hooks.hasListeners(HookName.ERROR)) await this.hooks.trigger(HookName.ERROR, event);
 			if (event.dispatched) event.error = void 0;
 			else throw event.error;
 		}
-		await this.hooks.trigger(HookName.CHILD_DISPATCH_AFTER, event);
+		if (this.hooks.hasListeners(HookName.CHILD_DISPATCH_AFTER)) await this.hooks.trigger(HookName.CHILD_DISPATCH_AFTER, event);
 		return response;
 	}
-	matchPath(path) {
-		if (!this.pathMatcher) return true;
-		return this.pathMatcher.test(path);
-	}
 	/**
 	* Resolve a handler's return value into the final value handed to `toResponse`.
 	*
@@ -1096,8 +1194,7 @@ var Handler = class {
 			});
 		});
 	}
-	async executeWithTimeout(fn, routerOptions, controller) {
-		const effectiveTimeout = this.resolveTimeout(routerOptions);
+	async executeWithTimeout(fn, effectiveTimeout, controller) {
 		if (!effectiveTimeout) return fn();
 		let timerId;
 		try {
@@ -1114,13 +1211,13 @@ var Handler = class {
 			clearTimeout(timerId);
 		}
 	}
-	resolveTimeout(routerOptions) {
-		const routerDefault = routerOptions.handlerTimeout;
+	resolveTimeout(appOptions) {
+		const routerDefault = appOptions.handlerTimeout;
 		const handlerOverride = this.config.timeout;
 		if (!routerDefault && !handlerOverride) return;
 		if (!routerDefault) return handlerOverride;
 		if (!handlerOverride) return routerDefault;
-		if (routerOptions.handlerTimeoutOverridable) return handlerOverride;
+		if (appOptions.handlerTimeoutOverridable) return handlerOverride;
 		return Math.min(routerDefault, handlerOverride);
 	}
 	mountHooks() {
@@ -1226,10 +1323,10 @@ function callMiddleware(handler, req, res) {
 	});
 }
 function createNodeBridge(handler, isMiddleware) {
-	if (typeof handler !== "function") throw new RoutupError("fromNodeHandler/fromNodeMiddleware expects a function.");
+	if (typeof handler !== "function") throw new AppError("fromNodeHandler/fromNodeMiddleware expects a function.");
 	return defineCoreHandler({ fn: (async (event) => {
 		const node = event.request.runtime?.node;
-		if (!node?.req || !node?.res) throw new RoutupError("fromNodeHandler/fromNodeMiddleware requires a Node.js runtime.");
+		if (!node?.req || !node?.res) throw new AppError("fromNodeHandler/fromNodeMiddleware requires a Node.js runtime.");
 		const req = node.req;
 		const res = node.res;
 		if ((isMiddleware ? await callMiddleware(handler, req, res) : await callHandler(handler, req, res)) === kHandled) return null;
@@ -1277,7 +1374,7 @@ function isWebHandler(input) {
 //#region src/handler/adapters/web/define.ts
 function fromWebHandler(input) {
 	if (isWebHandlerProvider(input)) return fromWebHandler(input.fetch.bind(input));
-	if (typeof input !== "function") throw new RoutupError("fromWebHandler expects a function or an object with a fetch method.");
+	if (typeof input !== "function") throw new AppError("fromWebHandler expects a function or an object with a fetch method.");
 	return defineCoreHandler({ fn: (event) => input(event.request) });
 }
 //#endregion
@@ -1289,6 +1386,18 @@ function isHandler(input) {
 	return hasInstanceof(input, HandlerSymbol);
 }
 //#endregion
+//#region src/handler/utils.ts
+/**
+* Match a request method against a handler's bound method.
+*
+* - When the handler has no method bound, matches every request method.
+* - Otherwise matches when the request method is the same.
+* - HEAD requests additionally match GET handlers.
+*/
+function matchHandlerMethod(handlerMethod, requestMethod) {
+	return !handlerMethod || requestMethod === handlerMethod || requestMethod === MethodName.HEAD && handlerMethod === MethodName.GET;
+}
+//#endregion
 //#region src/request/helpers/cache.ts
 function isRequestCacheable(event, modifiedTime) {
 	const modifiedSince = event.headers.get(HeaderName.IF_MODIFIED_SINCE);
@@ -1343,7 +1452,7 @@ function matchRequestContentType(event, contentType) {
 function getRequestHostName(event, options = {}) {
 	let trustProxy;
 	if (typeof options.trustProxy !== "undefined") trustProxy = buildTrustProxyFn(options.trustProxy);
-	else trustProxy = event.routerOptions.trustProxy;
+	else trustProxy = event.appOptions.trustProxy ?? DEFAULT_TRUST_PROXY;
 	let hostname = event.headers.get(HeaderName.X_FORWARDED_HOST);
 	if (!hostname || !event.request.ip || !trustProxy(event.request.ip, 0)) hostname = event.headers.get(HeaderName.HOST);
 	else if (hostname && hostname.includes(",")) hostname = hostname.substring(0, hostname.indexOf(",")).trimEnd();
@@ -1366,7 +1475,7 @@ function getRequestHostName(event, options = {}) {
 function getRequestIP(event, options = {}) {
 	let trustProxy;
 	if (typeof options.trustProxy !== "undefined") trustProxy = buildTrustProxyFn(options.trustProxy);
-	else trustProxy = event.routerOptions.trustProxy;
+	else trustProxy = event.appOptions.trustProxy ?? DEFAULT_TRUST_PROXY;
 	const socketAddr = event.request.ip;
 	if (!socketAddr) return;
 	const forwarded = event.headers.get(HeaderName.X_FORWARDED_FOR);
@@ -1386,7 +1495,7 @@ function getRequestIP(event, options = {}) {
 function getRequestProtocol(event, options = {}) {
 	let trustProxy;
 	if (typeof options.trustProxy !== "undefined") trustProxy = buildTrustProxyFn(options.trustProxy);
-	else trustProxy = event.routerOptions.trustProxy;
+	else trustProxy = event.appOptions.trustProxy ?? DEFAULT_TRUST_PROXY;
 	let protocol;
 	try {
 		if (new URL(event.request.url).protocol === "https:") protocol = "https";
@@ -1403,6 +1512,58 @@ function getRequestProtocol(event, options = {}) {
 	return protocol;
 }
 //#endregion
+//#region src/path/matcher.ts
+function decodeParam(val) {
+	/* istanbul ignore next */
+	if (typeof val !== "string" || val.length === 0) return val;
+	try {
+		return decodeURIComponent(val);
+	} catch {
+		return val;
+	}
+}
+var PathMatcher = class {
+	path;
+	regexp;
+	regexpKeys = [];
+	regexpOptions;
+	constructor(path, options) {
+		this.path = path;
+		this.regexpOptions = options || {};
+		const regexp = pathToRegexp(path, options);
+		this.regexp = regexp.regexp;
+		this.regexpKeys = regexp.keys;
+	}
+	test(path) {
+		return this.regexp.test(path);
+	}
+	exec(path) {
+		if (this.path === "/" && this.regexpOptions.end === false) return {
+			path: "/",
+			params: Object.create(null)
+		};
+		const match = this.regexp.exec(path);
+		if (!match) return;
+		const params = Object.create(null);
+		for (let i = 1; i < match.length; i++) {
+			const key = this.regexpKeys[i - 1];
+			if (!key) continue;
+			const prop = key.name;
+			const val = decodeParam(match[i]);
+			if (typeof val !== "undefined") params[prop] = val;
+		}
+		return {
+			path: match[0],
+			params
+		};
+	}
+};
+//#endregion
+//#region src/path/utils.ts
+function isPath(input) {
+	return typeof input === "string";
+}
+//#endregion
 //#region src/plugin/error/constants.ts
 const PluginErrorCode = {
 	PLUGIN: "PLUGIN",
@@ -1419,7 +1580,7 @@ function isPluginError(input) {
 }
 //#endregion
 //#region src/plugin/error/module.ts
-var PluginError = class extends RoutupError {
+var PluginError = class extends AppError {
 	constructor(input = {}) {
 		const options = typeof input === "string" ? { message: input } : { ...input };
 		if (!("code" in options) || !options.code) options.code = PluginErrorCode.PLUGIN;
@@ -1477,22 +1638,795 @@ function isPlugin(input) {
 	return typeof input.install === "function" && input.install.length === 1;
 }
 //#endregion
-//#region src/router/options.ts
-function normalizeRouterOptions(input) {
-	if (typeof input.etag !== "undefined") input.etag = buildEtagFn(input.etag);
-	if (typeof input.trustProxy !== "undefined") input.trustProxy = buildTrustProxyFn(input.trustProxy);
+//#region src/router/utils.ts
+/**
+* Build a path-to-regexp-backed `PathMatcher` for the route's mount
+* path, applying the exact-vs-prefix convention every router should
+* agree on:
+*
+* - `route.method !== undefined` → exact match (method-bound route)
+* - `route.method === undefined` → prefix match (middleware / nested
+*   app)
+*
+* Returns `undefined` when the route has no mount path — middleware
+* registered without a path matches every request.
+*
+* Routers are free to ignore this helper and build their own match
+* mechanism (radix tree, single aggregated regex, etc.) — it's
+* provided as a convenience for routers that want path-to-regexp
+* semantics with minimal boilerplate.
+*/
+function buildRoutePathMatcher(route) {
+	if (typeof route.path === "undefined") return;
+	const end = typeof route.method !== "undefined";
+	if (!end && route.path === "/") return;
+	return new PathMatcher(route.path, { end });
+}
+//#endregion
+//#region src/router/linear/module.ts
+/**
+* Default router — walks registered routes linearly per request and
+* runs each route's mount-level matcher (built via `buildRoutePathMatcher`,
+* path-to-regexp-backed). Routes without a mount path (mount-less
+* middleware / nested apps registered via `.use(handler)`) match every
+* request directly — there is no per-route `matchPath()` fallback.
+*
+* Behaviour-preserving wrapper around the previous in-line stack walk
+* in `executePipelineStepLookup`. The matcher allocations live here
+* (not on the registered route), so routers using a different matching
+* strategy (radix tree, aggregated regex, …) can ignore this file
+* entirely.
+*
+* Optional per-router lookup cache: pass an `ICache` via
+* `BaseRouterOptions.cache` to skip the linear walk on repeated
+* requests for the same path. Default is no caching.
+*/
+var LinearRouter = class LinearRouter {
+	_routes;
+	_matchers;
+	cache;
+	constructor(options = {}) {
+		this._routes = [];
+		this._matchers = [];
+		this.cache = options.cache;
+	}
+	add(route) {
+		this._routes.push(route);
+		this._matchers.push(buildRoutePathMatcher(route));
+		this.cache?.clear();
+	}
+	lookup(path, _method) {
+		const cached = this.cache?.get(path);
+		if (typeof cached !== "undefined") return cached;
+		const matches = [];
+		for (let i = 0; i < this._routes.length; i++) {
+			const route = this._routes[i];
+			const matcher = this._matchers[i];
+			if (matcher) {
+				const output = matcher.exec(path);
+				if (typeof output === "undefined") continue;
+				matches.push({
+					route,
+					index: i,
+					params: output.params,
+					path: output.path
+				});
+				continue;
+			}
+			matches.push({
+				route,
+				index: i,
+				params: Object.create(null)
+			});
+		}
+		this.cache?.set(path, matches);
+		return matches;
+	}
+	clone() {
+		return new LinearRouter({ cache: this.cache?.clone() });
+	}
+};
+//#endregion
+//#region src/router/trie/parser.ts
+/**
+* Trie-native path parser.
+*
+* Replaces the call-out to `path-to-regexp` for the syntax surface
+* the trie advertises:
+*
+*   - Static segments: `users`, `v1`
+*   - Named params:    `:id`, `:slug`
+*   - Optional params: `:id?`            (T2 — expanded to two variants)
+*   - Optional groups: `{...}`           (T2 — expanded to two variants)
+*   - Bare splat:      `*`               (matches the rest of the path)
+*   - Named splat:     `*rest`
+*
+* Returns a list of `Segment[]` *variants* — one path string can
+* expand into multiple route variants when it contains optional
+* markers. The trie inserts every variant with the same registration
+* `index` so they dedupe naturally on the candidate list.
+*
+* Returns `null` when the path uses syntax outside this surface
+* (compound segments `/files/:n.ext`, escape sequences `\:`, regex
+* constraints, splat-not-last, …). The caller falls back to the
+* universal bucket so correctness is preserved via path-to-regexp.
+*
+* Variant cap: nested optional groups expand combinatorially. The
+* parser caps the variant count at `MAX_VARIANTS` and falls back to
+* the universal bucket above that — registration-time explosion
+* isn't worth the lookup-time win on degenerate paths.
+*/
+const MAX_VARIANTS = 16;
+const PARAM_NAME = /^[a-zA-Z_]\w*$/;
+/**
+* Tokenize a single path segment (the substring between two `/`).
+* Returns `null` if the segment uses syntax we don't handle.
+*
+* Each segment must yield exactly one token — compound segments
+* (`/files/:n.ext`, `/users-:id`) produce multiple tokens and so
+* trip this check, falling back to the universal bucket.
+*/
+function tokenizeSegment(segment) {
+	if (segment === "") return null;
+	if (segment === "*") return {
+		kind: "splat",
+		name: "*"
+	};
+	if (segment.charAt(0) === "*") {
+		const rest = segment.slice(1);
+		if (PARAM_NAME.test(rest)) return {
+			kind: "splat",
+			name: rest
+		};
+		return null;
+	}
+	if (segment.charAt(0) === ":") {
+		const optional = segment.charAt(segment.length - 1) === "?";
+		const nameRaw = optional ? segment.slice(1, -1) : segment.slice(1);
+		if (PARAM_NAME.test(nameRaw)) return {
+			kind: "param",
+			name: nameRaw,
+			optional
+		};
+		return null;
+	}
+	if (/^[a-zA-Z0-9_\-.~%]+$/.test(segment)) return {
+		kind: "literal",
+		value: segment
+	};
+	return null;
+}
+/**
+* Tokenize the full path into a token stream, recognizing slash-
+* spanning optional groups (`/users{/edit/:id}`).
+*
+* The group-open marker is emitted in place of the leading `/`
+* inside `{...}`; group-close before the trailing `}`. The walker
+* later expands by either keeping the run between markers or
+* dropping it.
+*/
+function tokenizePath(path) {
+	const trimmed = path.charAt(0) === "/" ? path.slice(1) : path;
+	if (trimmed === "") return [];
+	const tokens = [];
+	let i = 0;
+	const n = trimmed.length;
+	while (i < n) {
+		if (trimmed.charAt(i) === "{") {
+			let close = -1;
+			for (let j = i + 1; j < n; j++) {
+				const c = trimmed.charAt(j);
+				if (c === "{") return null;
+				if (c === "}") {
+					close = j;
+					break;
+				}
+			}
+			if (close === -1) return null;
+			const inner = trimmed.slice(i + 1, close);
+			if (inner.charAt(0) !== "/") return null;
+			const after = close + 1 < n ? trimmed.charAt(close + 1) : "";
+			if (after !== "" && after !== "/" && after !== "{") return null;
+			tokens.push({ kind: "groupOpen" });
+			const innerTokens = tokenizePath(inner);
+			if (innerTokens === null) return null;
+			for (const t of innerTokens) tokens.push(t);
+			tokens.push({ kind: "groupClose" });
+			i = close + 1;
+			continue;
+		}
+		let segEnd = i;
+		while (segEnd < n) {
+			const c = trimmed.charAt(segEnd);
+			if (c === "/" || c === "{") break;
+			segEnd++;
+		}
+		const segment = trimmed.slice(i, segEnd);
+		if (segment !== "") {
+			const token = tokenizeSegment(segment);
+			if (token === null) return null;
+			tokens.push(token);
+		}
+		i = segEnd;
+		if (i < n && trimmed.charAt(i) === "/") i++;
+	}
+	return tokens;
+}
+/**
+* Expand the token stream into one or more concrete `Token[]`
+* variants by:
+*   1. Splitting `groupOpen` … `groupClose` runs into a "with run"
+*      and a "without run" choice (one optional group → ×2 variants).
+*   2. Splitting `param.optional = true` into a "with" and "without"
+*      choice (one `:id?` → ×2 variants).
+*
+* Caps at `MAX_VARIANTS` — beyond that, returns `null` so the path
+* falls back to the universal bucket.
+*
+* Returns `Token[][]` (not `Segment[][]`) so the recursive
+* group-expansion can splice inner variants back into the outer
+* token stream without a lossy round-trip through `Segment`.
+* `parsePath` does the final `Token → Segment` projection.
+*/
+function expand(tokens) {
+	let variants = [[]];
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token.kind === "groupOpen") {
+			let depth = 1;
+			let close = -1;
+			for (let j = i + 1; j < tokens.length; j++) {
+				const t = tokens[j];
+				if (t.kind === "groupOpen") depth++;
+				else if (t.kind === "groupClose") {
+					depth--;
+					if (depth === 0) {
+						close = j;
+						break;
+					}
+				}
+			}
+			if (close === -1) return null;
+			const expandedInner = expand(tokens.slice(i + 1, close));
+			if (expandedInner === null) return null;
+			const next = [];
+			for (const v of variants) {
+				if (next.length >= MAX_VARIANTS) return null;
+				next.push(v.slice());
+				for (const innerVariant of expandedInner) {
+					if (next.length >= MAX_VARIANTS) return null;
+					next.push(v.concat(innerVariant));
+				}
+			}
+			variants = next;
+			i = close;
+			continue;
+		}
+		if (token.kind === "param" && token.optional) {
+			const stripped = {
+				kind: "param",
+				name: token.name,
+				optional: false
+			};
+			const next = [];
+			for (const v of variants) {
+				if (next.length >= MAX_VARIANTS) return null;
+				next.push(v.slice());
+				if (next.length >= MAX_VARIANTS) return null;
+				next.push(v.concat([stripped]));
+			}
+			variants = next;
+			continue;
+		}
+		for (const v of variants) v.push(token);
+	}
+	return variants;
+}
+function tokenToSegment(t) {
+	if (t.kind === "literal") return {
+		kind: "static",
+		value: t.value
+	};
+	if (t.kind === "param") return {
+		kind: "param",
+		name: t.name
+	};
+	if (t.kind === "splat") return {
+		kind: "splat",
+		name: t.name
+	};
+	return null;
+}
+/**
+* Stable, structural identity for a variant — used to drop duplicate
+* expansions like `/users{/:id?}` (which produces the bare-`/users`
+* variant twice: once from the "without group" branch and once from
+* the "with group, without optional param" branch).
+*/
+function variantKey(segs) {
+	let out = "";
+	for (const s of segs) if (s.kind === "static") out += `/s:${s.value}`;
+	else if (s.kind === "param") out += `/p:${s.name}`;
+	else out += `/*:${s.name}`;
+	return out;
+}
+function parsePath(path) {
+	const tokens = tokenizePath(path);
+	if (tokens === null) return null;
+	const variants = expand(tokens);
+	if (variants === null) return null;
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const v of variants) {
+		const segs = [];
+		for (const t of v) {
+			const s = tokenToSegment(t);
+			if (s === null) return null;
+			segs.push(s);
+		}
+		for (let i = 0; i < segs.length - 1; i++) if (segs[i].kind === "splat") return null;
+		const key = variantKey(segs);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(segs);
+	}
+	return result;
+}
+//#endregion
+//#region src/router/trie/node.ts
+function createMethodBuckets() {
+	return Object.create(null);
+}
+function createTrieNode() {
+	return {
+		staticChildren: /* @__PURE__ */ new Map(),
+		splatRoutes: createMethodBuckets(),
+		exactRoutes: createMethodBuckets(),
+		prefixRoutes: []
+	};
+}
+//#endregion
+//#region src/router/trie/module.ts
+function decodeOrRaw(s) {
+	try {
+		return decodeURIComponent(s);
+	} catch {
+		return s;
+	}
+}
+/**
+* Build a `params` object from a request's pre-split segments using
+* the variant's pre-computed `ParamCapture[]`. No regex execution —
+* each capture is one indexed read from `segments` (and a join for
+* splats). Replaces the `matcher.exec` confirm pass for trie-walked
+* routes (T3).
+*/
+function extractTrieParams(segments, indexMap) {
+	const out = Object.create(null);
+	for (const cap of indexMap) if (cap.kind === "segment") out[cap.name] = decodeOrRaw(segments[cap.depth]);
+	else {
+		const slice = segments.slice(cap.depth).join("/");
+		out[cap.name] = decodeOrRaw(slice);
+	}
+	return out;
+}
+/**
+* Compute `match.path` (the matched-prefix string) from the request's
+* segments and the variant's recorded depth.
+*
+* - Non-splat variants: prefix = `segments[0..matchDepth].join('/')` —
+*   exactly what the variant consumed (request length = variant
+*   length for exact, request length ≥ variant length for prefix).
+* - Splat variants: the splat absorbed every remaining segment, so
+*   the matched prefix is the entire request path. This mirrors what
+*   `path-to-regexp`'s `output.path` would have returned pre-Phase-2
+*   for `/files/*rest` matching `/files/a/b` (`/files/a/b`, not
+*   `/files`).
+*/
+function trieMatchedPath(segments, matchDepth, splatTerminated) {
+	const upTo = splatTerminated ? segments.length : matchDepth;
+	if (upTo === 0) return "/";
+	return `/${segments.slice(0, upTo).join("/")}`;
+}
+/**
+* Pre-compute the `ParamCapture[]` for a variant's segments. Walk
+* the segments in order; emit one entry per `param` segment and a
+* terminal one for `splat` (always last). Static segments are
+* structurally consumed by the trie walk; they don't appear here.
+*/
+function buildParamsIndexMap(segments) {
+	const out = [];
+	for (const [i, seg] of segments.entries()) if (seg.kind === "param") out.push({
+		kind: "segment",
+		depth: i,
+		name: seg.name
+	});
+	else if (seg.kind === "splat") {
+		out.push({
+			kind: "splat",
+			depth: i,
+			name: seg.name
+		});
+		break;
+	}
+	return out;
+}
+/**
+* Decide which method buckets a given request method should pull
+* from. Always includes `''` (method-agnostic). For HEAD also
+* includes GET (per `matchHandlerMethod`). For OPTIONS or no-method
+* lookups, returns `null` to signal "emit every bucket" — needed so
+* `event.methodsAllowed` is populated for OPTIONS auto-Allow and so
+* `IRouter.lookup(path)` (no method) keeps returning a complete
+* candidate set.
+*/
+function methodBucketKeys(method) {
+	if (typeof method === "undefined" || method === MethodName.OPTIONS) return null;
+	if (method === MethodName.HEAD) return [
+		"",
+		MethodName.HEAD,
+		MethodName.GET
+	];
+	return ["", method];
+}
+function emitBucket(buckets, method, out) {
+	const keys = methodBucketKeys(method);
+	if (keys === null) {
+		for (const k in buckets) {
+			const list = buckets[k];
+			for (const r of list) out.push(r);
+		}
+		return;
+	}
+	for (const k of keys) {
+		const list = buckets[k];
+		if (!list) continue;
+		for (const r of list) out.push(r);
+	}
+}
+function hasAnyBucket(buckets) {
+	for (const _k in buckets) return true;
+	return false;
+}
+function pushIntoBucket(buckets, methodKey, route) {
+	const bucket = buckets[methodKey];
+	if (bucket) bucket.push(route);
+	else buckets[methodKey] = [route];
+}
+/**
+* Radix-trie router — registers routes into a per-segment tree at
+* `add()` time and walks the tree at `lookup()` to collect
+* candidates by structure rather than by linear scan.
+*
+* Inspired by Hono's `TrieRouter` and rou3. The trie handles
+* routup's path vocabulary directly via its own parser
+* (`./parser.ts`):
+*
+*   - Static segments (`/users`)
+*   - Named params (`:id`)
+*   - Optional params (`:id?`) — expanded to two route variants at
+*     registration (T2)
+*   - Optional groups (`/users{/edit}`) — same expansion strategy
+*   - Bare and named splats (`/files/*`, `/files/*rest`)
+*
+* Per-leaf storage is bucketed by HTTP method (T4) so lookup
+* narrows to the request method's bucket(s) instead of emitting
+* every entry at the leaf and letting the dispatcher's filter
+* discard mismatches.
+*
+* Param extraction is `paramsIndexMap`-driven (T3): a pre-built
+* `Array<{ depth, name }>` per variant lets `extractTrieParams`
+* read params straight from the request's pre-split segments — no
+* regex execution per match.
+*
+* Paths the trie parser doesn't handle (compound segments like
+* `/files/:n.ext`, escape sequences `\:`, regex constraints) and
+* empty/root paths fall through to the `universal` bucket. That
+* bucket still uses `path-to-regexp` via `buildRoutePathMatcher`,
+* so correctness is preserved.
+*
+* Pure-static-spine fast path (`shortCircuit`): when the request
+* walks a static spine with no param/splat/prefix siblings on any
+* traversed node, the leaf's `exactRoutes` (filtered to the request
+* method's buckets) is the full answer — no need to walk the param
+* branch or collect prefix candidates at intermediate nodes.
+*/
+var TrieRouter = class TrieRouter {
+	/**
+	* Monotonic counter assigned as the registration `index` on each
+	* route — the dispatch loop uses it to preserve registration
+	* order across the candidate list. App owns the canonical
+	* `Route<T>[]` list (Plan 019); the trie no longer keeps a
+	* parallel copy.
+	*/
+	_routeCount;
+	root;
+	/**
+	* Routes that bypass the trie — registered with no path, with
+	* the root path `/`, or with a path containing syntax the
+	* parser doesn't recognise. Walked linearly on every lookup,
+	* merged into the result in registration order.
+	*/
+	universal;
+	cache;
+	constructor(options = {}) {
+		this._routeCount = 0;
+		this.root = createTrieNode();
+		this.universal = [];
+		this.cache = options.cache;
+	}
+	add(route) {
+		const index = this._routeCount++;
+		if (typeof route.path !== "string" || route.path === "" || route.path === "/") {
+			this.universal.push({
+				route,
+				index,
+				matcher: buildRoutePathMatcher(route)
+			});
+			this.cache?.clear();
+			return;
+		}
+		const variants = parsePath(route.path);
+		if (variants === null) {
+			this.universal.push({
+				route,
+				index,
+				matcher: buildRoutePathMatcher(route)
+			});
+			this.cache?.clear();
+			return;
+		}
+		for (const segments of variants) this.insertIntoTrie(segments, route, index);
+		this.cache?.clear();
+	}
+	lookup(path, method) {
+		const cacheKey = `${method ?? ""}\t${path}`;
+		const cached = this.cache?.get(cacheKey);
+		if (typeof cached !== "undefined") return cached;
+		const candidates = [];
+		for (const u of this.universal) candidates.push(u);
+		const segments = this.parseRequestPath(path);
+		const shortCircuit = this.shortCircuit(segments, method);
+		if (shortCircuit !== null) for (const c of shortCircuit) candidates.push(c);
+		else this.walk(this.root, segments, 0, candidates, method);
+		candidates.sort((a, b) => {
+			if (a.index !== b.index) return a.index - b.index;
+			const ad = a.matchDepth ?? -1;
+			return (b.matchDepth ?? -1) - ad;
+		});
+		const matches = [];
+		let lastIndex = -1;
+		for (const candidate of candidates) {
+			const { route, index, matcher, paramsIndexMap, matchDepth } = candidate;
+			if (index === lastIndex) continue;
+			if (matcher) {
+				const output = matcher.exec(path);
+				if (typeof output === "undefined") continue;
+				matches.push({
+					route,
+					index,
+					params: this.assignParams(output.params),
+					path: output.path
+				});
+				lastIndex = index;
+				continue;
+			}
+			if (paramsIndexMap && typeof matchDepth === "number") {
+				matches.push({
+					route,
+					index,
+					params: extractTrieParams(segments, paramsIndexMap),
+					path: trieMatchedPath(segments, matchDepth, candidate.splatTerminated === true)
+				});
+				lastIndex = index;
+				continue;
+			}
+			matches.push({
+				route,
+				index,
+				params: Object.create(null)
+			});
+			lastIndex = index;
+		}
+		this.cache?.set(cacheKey, matches);
+		return matches;
+	}
+	clone() {
+		return new TrieRouter({ cache: this.cache?.clone() });
+	}
+	/**
+	* T1: returns the pre-computed candidate list when the request's
+	* static spine has no param sibling, no prefix routes, and no
+	* splats along the way. The leaf node's `exactRoutes` (filtered
+	* to the request method's buckets) is then the complete answer —
+	* no need to walk the param branch or collect prefix/splat
+	* candidates from intermediate nodes. When any branch is
+	* encountered, returns `null` and the caller falls through to
+	* the regular `walk`.
+	*/
+	shortCircuit(segments, method) {
+		let node = this.root;
+		for (const segment of segments) {
+			if (node.paramChild || hasAnyBucket(node.splatRoutes) || node.prefixRoutes.length > 0) return null;
+			const child = node.staticChildren.get(segment);
+			if (!child) return null;
+			node = child;
+		}
+		if (node.paramChild || hasAnyBucket(node.splatRoutes) || node.prefixRoutes.length > 0) return null;
+		const out = [];
+		emitBucket(node.exactRoutes, method, out);
+		return out;
+	}
+	parseRequestPath(path) {
+		const trimmed = path.charAt(0) === "/" ? path.slice(1) : path;
+		if (trimmed === "") return [];
+		const parts = trimmed.split("/");
+		const result = [];
+		for (const part of parts) if (part !== "") result.push(part);
+		return result;
+	}
+	insertIntoTrie(segments, route, index) {
+		let node = this.root;
+		const exact = this.isExactMatchRoute(route);
+		const methodKey = route.method ?? "";
+		const paramsIndexMap = buildParamsIndexMap(segments);
+		for (const [i, segment] of segments.entries()) {
+			const seg = segment;
+			if (seg.kind === "splat") {
+				pushIntoBucket(node.splatRoutes, methodKey, {
+					route,
+					index,
+					paramsIndexMap,
+					matchDepth: i,
+					splatTerminated: true
+				});
+				return;
+			}
+			if (seg.kind === "param") {
+				if (!node.paramChild) node.paramChild = createTrieNode();
+				node = node.paramChild;
+				continue;
+			}
+			let child = node.staticChildren.get(seg.value);
+			if (!child) {
+				child = createTrieNode();
+				node.staticChildren.set(seg.value, child);
+			}
+			node = child;
+		}
+		const indexed = {
+			route,
+			index,
+			paramsIndexMap,
+			matchDepth: segments.length
+		};
+		if (exact) pushIntoBucket(node.exactRoutes, methodKey, indexed);
+		else node.prefixRoutes.push(indexed);
+	}
+	walk(node, segments, depth, collected, method) {
+		emitBucket(node.splatRoutes, method, collected);
+		if (depth === segments.length) {
+			emitBucket(node.exactRoutes, method, collected);
+			for (const p of node.prefixRoutes) collected.push(p);
+			return;
+		}
+		for (const p of node.prefixRoutes) collected.push(p);
+		const seg = segments[depth];
+		const staticChild = node.staticChildren.get(seg);
+		if (staticChild) this.walk(staticChild, segments, depth + 1, collected, method);
+		if (node.paramChild) this.walk(node.paramChild, segments, depth + 1, collected, method);
+	}
+	isExactMatchRoute(route) {
+		return typeof route.method !== "undefined";
+	}
+	/**
+	* T5: copy params onto a prototype-less object so downstream
+	* lookups skip prototype-chain traversal and avoid `__proto__` /
+	* `hasOwnProperty` shadowing from user-controlled segment values.
+	*/
+	assignParams(source) {
+		const out = Object.create(null);
+		for (const k in source) if (Object.prototype.hasOwnProperty.call(source, k)) out[k] = source[k];
+		return out;
+	}
+};
+//#endregion
+//#region src/router/smart/module.ts
+/**
+* Default crossover. Empirically `LinearRouter` wins for small route
+* counts (no per-request trie walk overhead, no static-spine setup);
+* `TrieRouter` wins past ~30 entries on typical workloads. Override
+* via `SmartRouterOptions.threshold` when a benchmark says otherwise
+* for your route shape.
+*/
+const DEFAULT_THRESHOLD = 30;
+/**
+* Auto-selecting router. Accumulates registered routes in a pending
+* buffer; on the first `lookup()` call, picks `LinearRouter` or
+* `TrieRouter` based on the registered route count and replays the
+* pending list onto the chosen inner router. Every subsequent call
+* — `add`, `lookup`, `clone` — forwards to the inner.
+*
+* Use this when you don't want to commit to a router family up-front
+* (e.g. a library that registers a variable number of routes
+* depending on configuration). For known workloads, prefer the
+* concrete router — `SmartRouter` adds one indirection per call.
+*
+* Inspired by Hono's `SmartRouter` (which auto-selects across more
+* candidates including `RegExpRouter`); ours covers the only choice
+* that matters in routup today: linear-vs-trie at the registration-
+* size crossover.
+*/
+var SmartRouter = class SmartRouter {
+	inner;
+	pending = [];
+	threshold;
+	/**
+	* Cache handed off to whichever inner router gets chosen. Stays
+	* `undefined` if the user didn't configure one.
+	*/
+	cache;
+	constructor(options = {}) {
+		this.threshold = options.threshold ?? DEFAULT_THRESHOLD;
+		this.cache = options.cache;
+	}
+	add(route) {
+		if (this.inner) {
+			this.inner.add(route);
+			return;
+		}
+		this.pending.push(route);
+	}
+	lookup(path, method) {
+		if (!this.inner) {
+			this.inner = this.choose();
+			for (const r of this.pending) this.inner.add(r);
+			this.pending = [];
+		}
+		return this.inner.lookup(path, method);
+	}
+	clone() {
+		return new SmartRouter({
+			threshold: this.threshold,
+			cache: this.cache?.clone()
+		});
+	}
+	/**
+	* Pick the inner router based on the registered route count.
+	* `LinearRouter` for tiny tables, `TrieRouter` past the
+	* configured threshold.
+	*
+	* @protected
+	*/
+	choose() {
+		if (this.pending.length < this.threshold) return new LinearRouter({ cache: this.cache });
+		return new TrieRouter({ cache: this.cache });
+	}
+};
+//#endregion
+//#region src/app/options.ts
+function normalizeAppOptions(input) {
+	let etag;
+	if (typeof input.etag !== "undefined") if (input.etag === null || input.etag === false) etag = null;
+	else etag = buildEtagFn(input.etag);
+	let trustProxy;
+	if (typeof input.trustProxy !== "undefined") trustProxy = buildTrustProxyFn(input.trustProxy);
 	if (typeof input.timeout !== "undefined") {
-		if (typeof input.timeout !== "number" || !Number.isFinite(input.timeout) || input.timeout <= 0) delete input.timeout;
+		if (!Number.isFinite(input.timeout) || input.timeout <= 0) delete input.timeout;
 	}
 	if (typeof input.handlerTimeout !== "undefined") {
-		if (typeof input.handlerTimeout !== "number" || !Number.isFinite(input.handlerTimeout) || input.handlerTimeout <= 0) delete input.handlerTimeout;
+		if (!Number.isFinite(input.handlerTimeout) || input.handlerTimeout <= 0) delete input.handlerTimeout;
 	}
-	return input;
+	return {
+		...input,
+		etag,
+		trustProxy
+	};
 }
 //#endregion
-//#region src/router/constants.ts
-const RouterSymbol = Symbol.for("Router");
-const RouterPipelineStep = {
+//#region src/app/constants.ts
+const AppSymbol = Symbol.for("App");
+const AppPipelineStep = {
 	START: 0,
 	LOOKUP: 1,
 	CHILD_BEFORE: 2,
@@ -1500,65 +2434,73 @@ const RouterPipelineStep = {
 	CHILD_AFTER: 4,
 	FINISH: 5
 };
-const RouterStackEntryType = {
-	ROUTER: "router",
+const RouteEntryType = {
+	APP: "app",
 	HANDLER: "handler"
 };
 //#endregion
-//#region src/router/utils.ts
-function isRouterInstance(input) {
-	return hasInstanceof(input, RouterSymbol);
+//#region src/app/check.ts
+function isAppInstance(input) {
+	return hasInstanceof(input, AppSymbol);
 }
+//#endregion
+//#region src/app/module.ts
 /**
-* Build a non-terminal `PathMatcher` for a router mount path.
-*
-* Returns `undefined` when the path is the root (`/`) or omitted entirely —
-* a router mounted at the root has no intrinsic path filter.
+* Merge resolver-supplied path params into `event.params` *only* when
+* `match.params` actually has keys. Skipping the object spread on the
+* empty-params path (every static route, every middleware match) saves
+* an allocation per match — the hottest path in static-route apps.
 */
-function buildRouterPathMatcher(value) {
-	if (value === "/" || typeof value === "undefined") return;
-	return new PathMatcher(withLeadingSlash(withoutTrailingSlash(`${value}`)), { end: false });
+function mergeMatchParams(event, matchParams) {
+	let hasKeys = false;
+	for (const _k in matchParams) {
+		hasKeys = true;
+		break;
+	}
+	if (!hasKeys) return;
+	event.params = {
+		...event.params,
+		...matchParams
+	};
 }
 /**
-* Check if the request accepts JSON responses.
-* Matches application/json and +json suffixes (e.g. application/vnd.api+json).
-* Returns true if no Accept header is present (API-first default).
+* Copy `source[key]` into `target[key]` when the target's value is
+* undefined; return whether a write happened.
+*
+* Bound to a single key `K` per call, so TypeScript can prove the
+* read and write hit the same property's value type — no `as` cast
+* needed. This is the standard escape hatch for the variance trap
+* you'd otherwise hit by writing `target[key] = source[key]` inside
+* a loop where `key: keyof AppOptions` is a *union* (read returns
+* the union of value types, write requires the intersection, which
+* collapses to `never`).
 */
-function acceptsJson(request) {
-	const accept = request.headers.get("accept");
-	if (!accept) return true;
-	return accept.includes("application/json") || accept.includes("+json") || accept.includes("*/*");
-}
-//#endregion
-//#region src/router/module.ts
-const METHOD_TO_REGISTER = {
-	[MethodName.GET]: "get",
-	[MethodName.POST]: "post",
-	[MethodName.PUT]: "put",
-	[MethodName.PATCH]: "patch",
-	[MethodName.DELETE]: "delete",
-	[MethodName.HEAD]: "head",
-	[MethodName.OPTIONS]: "options"
-};
-var Router = class Router {
+function copyOptionIfUnset(target, source, key) {
+	if (typeof target[key] !== "undefined") return false;
+	target[key] = source[key];
+	return true;
+}
+var App = class App {
 	/**
 	* A label for the router instance.
 	*/
 	name;
 	/**
-	* Array of mounted layers, routes & routers, each tagged by kind so the
-	* dispatch loop can discriminate without `isRouterInstance`/`isHandler`
-	* runtime checks.
+	* Registration-time path prefix for entries registered on this
+	* App. Local to this instance — never inherited from a parent.
 	*
 	* @protected
 	*/
-	stack = [];
+	_path;
 	/**
-	* Path matcher for the current mount path.
+	* Pluggable router (route table) — owns the "which entries match
+	* this path?" lookup. Defaults to `LinearRouter` (walks entries
+	* linearly per request); swap in via `AppContext.router`
+	* for a radix/trie implementation on apps with many routes.
 	*
 	* @protected
 	*/
-	pathMatcher;
+	router;
 	/**
 	* Lifecycle hook registry.
 	*
@@ -1566,7 +2508,14 @@ var Router = class Router {
 	*/
 	hooks;
 	/**
-	* Normalized options for this router instance.
+	* Normalized options for this App instance.
+	*
+	* Frozen on construction and on every `extendOptions` update —
+	* once published to `event.appOptions` it is shared across all
+	* requests, and a handler must not be able to mutate
+	* router-global state. `extendOptions` therefore uses a
+	* functional update (build a new object, freeze it, replace
+	* the slot) rather than mutating in place.
 	*/
 	_options;
 	/**
@@ -1575,18 +2524,51 @@ var Router = class Router {
 	* @protected
 	*/
 	plugins = /* @__PURE__ */ new Map();
+	/**
+	* Every route registered on this App, in registration order.
+	*
+	* App owns the canonical list — the `IRouter` contract has no
+	* `routes` field, so cascades / clones / `setRouter` replay
+	* read from here instead of asking the router. Routes are
+	* pushed alongside every `this.router.add()` via the `register`
+	* helper.
+	*
+	* @protected
+	*/
+	_routes = [];
 	constructor(input = {}) {
 		this.name = input.name;
-		const { hooks = new Hooks(), plugins = /* @__PURE__ */ new Map(), ...options } = input;
-		this.hooks = hooks;
-		this.plugins = new Map(plugins);
-		this._options = normalizeRouterOptions(options);
-		this.pathMatcher = buildRouterPathMatcher(options.path);
-		markInstanceof(this, RouterSymbol);
-	}
-	matchPath(path) {
-		if (this.pathMatcher) return this.pathMatcher.test(path);
-		return true;
+		this._path = input.path;
+		this.hooks = input.hooks ?? new Hooks();
+		this.plugins = new Map(input.plugins);
+		this.router = input.router ?? new LinearRouter();
+		this._options = Object.freeze(normalizeAppOptions(input.options ?? {}));
+		markInstanceof(this, AppSymbol);
+	}
+	/**
+	* Register a route with the active router and record it on the
+	* App so we can replay it onto a different router later (see
+	* `setRouter`) and so cascades / clones have a source of truth
+	* independent of the router instance.
+	*
+	* @protected
+	*/
+	register(route) {
+		this.router.add(route);
+		this._routes.push(route);
+	}
+	/**
+	* Swap the active router. Replays every previously-registered
+	* route onto the new router so lookups stay correct.
+	*
+	* Useful for picking a router after route shape is known (e.g.
+	* a SmartRouter-style decision), or for testing alternatives
+	* mid-flight without rebuilding the App. Any cache the previous
+	* router carried is dropped along with it.
+	*/
+	setRouter(router) {
+		for (const route of this._routes) router.add(route);
+		this.router = router;
 	}
 	/**
 	* Public entry point — creates a DispatcherEvent from the request,
@@ -1640,136 +2622,188 @@ var Router = class Router {
 			headers
 		});
 	}
+	/**
+	* Mount-time option inheritance — fill in any of this App's
+	* unset option keys from the supplied parent options. Called by
+	* `App.use(child)` after narrowing to `App` via `isAppInstance`.
+	*
+	* Public so callers don't need to reach into another App's
+	* protected fields: the parent passes its options by value and
+	* the child decides what to do with them.
+	*
+	* Shallow per-key merge. App-local concerns — `name`, `path`,
+	* `hooks`, `plugins`, `router`, and the router's cache — are
+	* deliberately not propagated; they sit on `AppContext`, not
+	* inside `AppOptions`.
+	*
+	* Cascades to any Apps already mounted on this one — a deeper
+	* grandchild gets the new keys too. Without this, mounting
+	* grandchild → child → parent in that order would leave the
+	* grandchild without parent's options (it adopted from child
+	* before child had them).
+	*
+	* Late mutation of the parent's options after this call does NOT
+	* propagate. `AppOptions` is configured at construction-and-mount;
+	* later changes are not a supported workflow.
+	*/
+	extendOptions(incoming) {
+		let next;
+		const keys = Object.keys(incoming);
+		for (const key of keys) {
+			if (typeof this._options[key] !== "undefined") continue;
+			if (typeof incoming[key] === "undefined") continue;
+			next ??= { ...this._options };
+			copyOptionIfUnset(next, incoming, key);
+		}
+		if (!next) return;
+		this._options = Object.freeze(next);
+		for (const route of this._routes) if (route.data.type === RouteEntryType.APP && isAppInstance(route.data.data)) route.data.data.extendOptions(this._options);
+	}
 	async executePipelineStep(context) {
-		while (context.step !== RouterPipelineStep.FINISH) switch (context.step) {
-			case RouterPipelineStep.START:
+		while (context.step !== AppPipelineStep.FINISH) switch (context.step) {
+			case AppPipelineStep.START:
 				await this.executePipelineStepStart(context);
 				break;
-			case RouterPipelineStep.LOOKUP:
+			case AppPipelineStep.LOOKUP:
 				await this.executePipelineStepLookup(context);
 				break;
-			case RouterPipelineStep.CHILD_BEFORE:
+			case AppPipelineStep.CHILD_BEFORE:
 				await this.executePipelineStepChildBefore(context);
 				break;
-			case RouterPipelineStep.CHILD_DISPATCH:
+			case AppPipelineStep.CHILD_DISPATCH:
 				await this.executePipelineStepChildDispatch(context);
 				break;
-			case RouterPipelineStep.CHILD_AFTER:
+			case AppPipelineStep.CHILD_AFTER:
 				await this.executePipelineStepChildAfter(context);
 				break;
 			default:
-				context.step = RouterPipelineStep.FINISH;
+				context.step = AppPipelineStep.FINISH;
 				break;
 		}
 		await this.executePipelineStepFinish(context);
 	}
 	async executePipelineStepStart(context) {
-		await this.hooks.trigger(HookName.REQUEST, context.event);
-		if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
-		else context.step = RouterPipelineStep.LOOKUP;
+		if (this.hooks.hasListeners(HookName.START)) await this.hooks.trigger(HookName.START, context.event);
+		if (context.event.dispatched) context.step = AppPipelineStep.FINISH;
+		else context.step = AppPipelineStep.LOOKUP;
 	}
 	async executePipelineStepLookup(context) {
-		while (!context.event.dispatched && context.stackIndex < this.stack.length) {
-			const entry = this.stack[context.stackIndex];
-			if (entry.type === RouterStackEntryType.HANDLER) {
-				const handler = entry.data;
+		if (typeof context.matches === "undefined" || context.matchesPath !== context.event.path) {
+			context.matches = this.router.lookup(context.event.path, context.event.method);
+			context.matchesPath = context.event.path;
+		}
+		const { matches } = context;
+		while (!context.event.dispatched && context.matchIndex < matches.length) {
+			const { route } = matches[context.matchIndex];
+			if (route.data.type === RouteEntryType.HANDLER) {
+				const handler = route.data.data;
 				if (context.event.error && handler.type === HandlerType.CORE || !context.event.error && handler.type === HandlerType.ERROR) {
-					context.stackIndex++;
+					context.matchIndex++;
 					continue;
 				}
-				if (entry.pathMatcher ? entry.pathMatcher.test(context.event.path) : handler.matchPath(context.event.path)) {
-					const method = entry.method ?? handler.method;
-					if (method) context.event.methodsAllowed.add(method);
-					if (matchHandlerMethod(method, context.event.method)) {
-						await this.hooks.trigger(HookName.CHILD_MATCH, context.event);
-						if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
-						else context.step = RouterPipelineStep.CHILD_BEFORE;
-						return;
-					}
+				const { method } = route;
+				if (method) context.event.methodsAllowed.add(method);
+				if (!matchHandlerMethod(method, context.event.method)) {
+					context.matchIndex++;
+					continue;
 				}
-				context.stackIndex++;
-				continue;
 			}
-			if (entry.pathMatcher ? entry.pathMatcher.test(context.event.path) : entry.data.matchPath(context.event.path)) {
-				await this.hooks.trigger(HookName.CHILD_MATCH, context.event);
-				if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
-				else context.step = RouterPipelineStep.CHILD_BEFORE;
+			if (this.hooks.hasListeners(HookName.CHILD_MATCH)) await this.hooks.trigger(HookName.CHILD_MATCH, context.event);
+			if (context.event.dispatched) {
+				context.step = AppPipelineStep.FINISH;
 				return;
 			}
-			context.stackIndex++;
+			if (context.event.path !== context.matchesPath) {
+				context.matches = void 0;
+				context.matchIndex = 0;
+				context.step = AppPipelineStep.LOOKUP;
+				return;
+			}
+			context.step = AppPipelineStep.CHILD_BEFORE;
+			return;
 		}
-		context.step = RouterPipelineStep.FINISH;
+		context.step = AppPipelineStep.FINISH;
 	}
 	async executePipelineStepChildBefore(context) {
-		await this.hooks.trigger(HookName.CHILD_DISPATCH_BEFORE, context.event);
-		if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
-		else context.step = RouterPipelineStep.CHILD_DISPATCH;
+		if (this.hooks.hasListeners(HookName.CHILD_DISPATCH_BEFORE)) await this.hooks.trigger(HookName.CHILD_DISPATCH_BEFORE, context.event);
+		if (context.event.dispatched) {
+			context.step = AppPipelineStep.FINISH;
+			return;
+		}
+		if (context.event.path !== context.matchesPath) {
+			context.matches = void 0;
+			context.matchIndex = 0;
+			context.step = AppPipelineStep.LOOKUP;
+			return;
+		}
+		context.step = AppPipelineStep.CHILD_DISPATCH;
 	}
 	async executePipelineStepChildAfter(context) {
-		await this.hooks.trigger(HookName.CHILD_DISPATCH_AFTER, context.event);
-		if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
-		else context.step = RouterPipelineStep.LOOKUP;
+		if (this.hooks.hasListeners(HookName.CHILD_DISPATCH_AFTER)) await this.hooks.trigger(HookName.CHILD_DISPATCH_AFTER, context.event);
+		if (context.event.dispatched) context.step = AppPipelineStep.FINISH;
+		else context.step = AppPipelineStep.LOOKUP;
 	}
 	async executePipelineStepChildDispatch(context) {
-		const entry = this.stack[context.stackIndex];
-		if (context.event.dispatched || typeof entry === "undefined") {
-			context.step = RouterPipelineStep.FINISH;
+		const match = context.matches?.[context.matchIndex];
+		if (context.event.dispatched || typeof match === "undefined") {
+			context.step = AppPipelineStep.FINISH;
 			return;
 		}
+		const { route } = match;
 		const { event } = context;
 		const savedPath = event.path;
 		const savedMountPath = event.mountPath;
 		const savedParams = event.params;
-		if (entry.type === RouterStackEntryType.ROUTER && entry.pathMatcher) {
-			const output = entry.pathMatcher.exec(event.path);
-			if (typeof output !== "undefined") {
-				event.mountPath = cleanDoubleSlashes(`${event.mountPath}/${output.path}`);
-				if (event.path === output.path) event.path = "/";
-				else event.path = withLeadingSlash(event.path.substring(output.path.length));
-				event.params = {
-					...event.params,
-					...output.params
-				};
-			}
-		} else if (entry.type === RouterStackEntryType.HANDLER && entry.pathMatcher) {
-			const output = entry.pathMatcher.exec(event.path);
-			if (typeof output !== "undefined") event.params = {
-				...event.params,
-				...output.params
-			};
-		}
+		if (route.data.type === RouteEntryType.APP && typeof match.path === "string") {
+			event.mountPath = cleanDoubleSlashes(`${event.mountPath}/${match.path}`);
+			if (event.path === match.path) event.path = "/";
+			else event.path = withLeadingSlash(event.path.substring(match.path.length));
+			mergeMatchParams(event, match.params);
+		} else if (route.data.type === RouteEntryType.HANDLER && typeof match.path === "string") mergeMatchParams(event, match.params);
 		try {
+			const parentMatches = context.matches;
+			const parentMatchesPath = context.matchesPath;
+			const nextMatchIndex = context.matchIndex + 1;
 			event.setNext(async (error) => {
 				if (error) event.error = createError(error);
-				const nextContext = {
-					step: RouterPipelineStep.LOOKUP,
-					event,
-					stackIndex: context.stackIndex + 1,
-					response: void 0
-				};
-				await this.executePipelineStep(nextContext);
-				return nextContext.response;
+				const pathChanged = event.path !== parentMatchesPath;
+				const savedStep = context.step;
+				const savedMatchIndex = context.matchIndex;
+				const savedMatches = context.matches;
+				const savedMatchesPath = context.matchesPath;
+				context.step = AppPipelineStep.LOOKUP;
+				context.matchIndex = pathChanged ? 0 : nextMatchIndex;
+				context.matches = pathChanged ? void 0 : parentMatches;
+				context.matchesPath = pathChanged ? void 0 : parentMatchesPath;
+				try {
+					await this.executePipelineStep(context);
+				} finally {
+					context.step = savedStep;
+					context.matchIndex = savedMatchIndex;
+					context.matches = savedMatches;
+					context.matchesPath = savedMatchesPath;
+				}
+				return context.response;
 			});
-			const response = await entry.data.dispatch(event);
+			const response = await route.data.data.dispatch(event);
 			if (response) {
 				context.response = response;
 				event.dispatched = true;
 			}
 		} catch (e) {
 			event.error = createError(e);
-			await this.hooks.trigger(HookName.ERROR, event);
+			if (this.hooks.hasListeners(HookName.ERROR)) await this.hooks.trigger(HookName.ERROR, event);
 		}
 		if (!event.dispatched) {
 			event.path = savedPath;
 			event.mountPath = savedMountPath;
 			event.params = savedParams;
 		}
-		context.stackIndex++;
-		context.step = RouterPipelineStep.CHILD_AFTER;
+		context.matchIndex++;
+		context.step = AppPipelineStep.CHILD_AFTER;
 	}
 	async executePipelineStepFinish(context) {
-		if (context.event.error || context.event.dispatched) return this.hooks.trigger(HookName.RESPONSE, context.event);
-		if (!context.event.dispatched && context.event.routerPath.length === 1 && context.event.method && context.event.method === MethodName.OPTIONS) {
+		if (!context.event.error && !context.event.dispatched && context.isRoot && context.event.method === MethodName.OPTIONS) {
 			if (context.event.methodsAllowed.has(MethodName.GET)) context.event.methodsAllowed.add(MethodName.HEAD);
 			const options = [...context.event.methodsAllowed].map((key) => key.toUpperCase()).join(",");
 			const optionsHeaders = new Headers(context.event.response.headers);
@@ -1780,37 +2814,28 @@ var Router = class Router {
 			});
 			context.event.dispatched = true;
 		}
-		return this.hooks.trigger(HookName.RESPONSE, context.event);
 	}
 	async dispatch(event) {
 		const savedPath = event.path;
 		const savedMountPath = event.mountPath;
 		const savedParams = event.params;
-		if (this.pathMatcher) {
-			const output = this.pathMatcher.exec(event.path);
-			if (typeof output !== "undefined") {
-				event.mountPath = cleanDoubleSlashes(`${event.mountPath}/${output.path}`);
-				if (event.path === output.path) event.path = "/";
-				else event.path = withLeadingSlash(event.path.substring(output.path.length));
-				event.params = {
-					...event.params,
-					...output.params
-				};
-			}
-		}
+		const savedAppOptions = event.appOptions;
+		const wasDispatching = event.isDispatching;
+		const isRoot = !wasDispatching;
 		const context = {
-			step: RouterPipelineStep.START,
+			step: AppPipelineStep.START,
 			event,
-			stackIndex: 0
+			isRoot,
+			matchIndex: 0
 		};
-		event.routerPath.push({
-			name: this.name,
-			options: this._options
-		});
+		event.appOptions = this._options;
+		event.isDispatching = true;
 		try {
 			await this.executePipelineStep(context);
+			if (this.hooks.hasListeners(HookName.END)) await this.hooks.trigger(HookName.END, event);
 		} finally {
-			event.routerPath.pop();
+			event.appOptions = savedAppOptions;
+			event.isDispatching = wasDispatching;
 			if (!event.dispatched) {
 				event.path = savedPath;
 				event.mountPath = savedMountPath;
@@ -1855,19 +2880,19 @@ var Router = class Router {
 				continue;
 			}
 			let handler;
-			if (isHandlerOptions(element)) handler = new Handler({
+			if (isHandler(element)) handler = element;
+			else if (isHandlerOptions(element)) handler = new Handler({
 				...element,
-				method,
-				path: path ?? element.path
+				method
 			});
-			else if (isHandler(element)) handler = element;
 			else continue;
-			this.stack.push({
-				type: RouterStackEntryType.HANDLER,
-				data: handler,
+			this.register({
+				path: joinPaths(this._path, path, handler.path),
 				method,
-				path,
-				pathMatcher: buildHandlerPathMatcher(path ?? handler.path, true)
+				data: {
+					type: RouteEntryType.HANDLER,
+					data: handler
+				}
 			});
 		}
 	}
@@ -1878,33 +2903,37 @@ var Router = class Router {
 				path = withLeadingSlash(item);
 				continue;
 			}
-			if (isRouterInstance(item)) {
-				this.stack.push({
-					type: RouterStackEntryType.ROUTER,
-					data: item,
-					path,
-					pathMatcher: buildRouterPathMatcher(path)
+			if (isAppInstance(item)) {
+				item.extendOptions(this._options);
+				this.register({
+					path: joinPaths(this._path, path),
+					data: {
+						type: RouteEntryType.APP,
+						data: item
+					}
 				});
 				continue;
 			}
-			if (isHandlerOptions(item)) {
-				const handler = new Handler({
-					...item,
-					path: path ?? item.path
-				});
-				this.stack.push({
-					type: RouterStackEntryType.HANDLER,
-					data: handler,
-					path
+			if (isHandler(item)) {
+				this.register({
+					path: joinPaths(this._path, path, item.path),
+					method: item.method,
+					data: {
+						type: RouteEntryType.HANDLER,
+						data: item
+					}
 				});
 				continue;
 			}
-			if (isHandler(item)) {
-				this.stack.push({
-					type: RouterStackEntryType.HANDLER,
-					data: item,
-					path,
-					pathMatcher: buildHandlerPathMatcher(path, !!item.method)
+			if (isHandlerOptions(item)) {
+				const handler = new Handler({ ...item });
+				this.register({
+					path: joinPaths(this._path, path, handler.path),
+					method: handler.method,
+					data: {
+						type: RouteEntryType.HANDLER,
+						data: handler
+					}
 				});
 				continue;
 			}
@@ -1928,7 +2957,10 @@ var Router = class Router {
 	}
 	install(plugin, context = {}) {
 		if (this.plugins.has(plugin.name)) throw new PluginAlreadyInstalledError(plugin.name);
-		const router = new Router({ name: plugin.name });
+		const router = new App({
+			name: plugin.name,
+			router: this.router.clone()
+		});
 		plugin.install(router);
 		if (context.path) this.use(context.path, router);
 		else this.use(router);
@@ -1936,7 +2968,7 @@ var Router = class Router {
 		return this;
 	}
 	/**
-	* Return a new `Router` that mirrors this one but owns independent
+	* Return a new `App` that mirrors this one but owns independent
 	* mountable state.
 	*
 	* The new router has:
@@ -1952,26 +2984,33 @@ var Router = class Router {
 	* mutations on one mount do not bleed into the others.
 	*/
 	clone() {
-		const next = new Router({
-			...this._options,
+		const next = new App({
+			name: this.name,
+			path: this._path,
+			options: { ...this._options },
 			hooks: this.hooks.clone(),
-			plugins: this.plugins
+			plugins: this.plugins,
+			router: this.router.clone()
 		});
-		for (const entry of this.stack) {
-			if (entry.type === RouterStackEntryType.ROUTER) {
-				const data = entry.data.clone();
-				if (entry.path) next.use(entry.path, data);
-				else next.use(data);
-				continue;
-			}
-			if (entry.method) {
-				const register = METHOD_TO_REGISTER[entry.method];
-				if (entry.path) next[register](entry.path, entry.data);
-				else next[register](entry.data);
+		for (const route of this._routes) {
+			if (route.data.type === RouteEntryType.APP) {
+				next.register({
+					path: route.path,
+					data: {
+						type: RouteEntryType.APP,
+						data: route.data.data.clone()
+					}
+				});
 				continue;
 			}
-			if (entry.path) next.use(entry.path, entry.data);
-			else next.use(entry.data);
+			next.register({
+				path: route.path,
+				method: route.method,
+				data: {
+					type: RouteEntryType.HANDLER,
+					data: route.data.data
+				}
+			});
 		}
 		return next;
 	}
@@ -1988,6 +3027,6 @@ var Router = class Router {
 	}
 };
 //#endregion
-export { setResponseHeaderAttachment as $, Handler as A, sendRedirect as B, fromWebHandler as C, fromNodeMiddleware as D, fromNodeHandler as E, HandlerSymbol as F, getRequestHeader as G, getRequestAcceptableContentType as H, HandlerType as I, sendAccepted as J, sendFile as K, DispatcherEvent as L, matchHandlerMethod as M, isPath as N, defineErrorHandler as O, PathMatcher as P, setResponseHeaderContentType as Q, RoutupEvent as R, isHandlerOptions as S, isWebHandlerProvider as T, getRequestAcceptableContentTypes as U, sendFormat as V, useRequestNegotiator as W, createError as X, toResponse as Y, isError as Z, getRequestAcceptableEncodings as _, PluginInstallError as a, serializeEventStreamMessage as at, isRequestCacheable as b, isPluginError as c, setResponseCacheHeaders as ct, getRequestIP as d, setResponseHeaderInline as et, getRequestHostName as f, getRequestAcceptableEncoding as g, getRequestAcceptableLanguages as h, PluginNotInstalledError as i, createEventStream as it, buildHandlerPathMatcher as j, defineCoreHandler as k, PluginErrorCode as l, HeaderName as lt, getRequestAcceptableLanguage as m, normalizeRouterOptions as n, appendResponseHeader as nt, PluginAlreadyInstalledError as o, ErrorSymbol as ot, matchRequestContentType as p, sendCreated as q, isPlugin as r, appendResponseHeaderDirective as rt, PluginError as s, RoutupError as st, Router as t, setResponseContentTypeByFileName as tt, getRequestProtocol as u, MethodName as ut, getRequestAcceptableCharset as v, isWebHandler as w, isHandler as x, getRequestAcceptableCharsets as y, sendStream as z };
+export { isError as $, fromWebHandler as A, DispatcherEvent as B, getRequestAcceptableEncodings as C, matchHandlerMethod as D, isRequestCacheable as E, defineErrorHandler as F, getRequestAcceptableContentTypes as G, sendRedirect as H, defineCoreHandler as I, sendFile as J, useRequestNegotiator as K, Handler as L, isWebHandlerProvider as M, fromNodeHandler as N, isHandler as O, fromNodeMiddleware as P, createError as Q, HandlerSymbol as R, getRequestAcceptableEncoding as S, getRequestAcceptableCharsets as T, sendFormat as U, sendStream as V, getRequestAcceptableContentType as W, sendAccepted as X, sendCreated as Y, toResponse as Z, getRequestIP as _, LinearRouter as a, appendResponseHeaderDirective as at, getRequestAcceptableLanguage as b, PluginNotInstalledError as c, AppError as ct, PluginError as d, AppEvent as dt, setResponseHeaderContentType as et, isPluginError as f, HeaderName as ft, getRequestProtocol as g, PathMatcher as h, TrieRouter as i, appendResponseHeader as it, isWebHandler as j, isHandlerOptions as k, PluginInstallError as l, ErrorSymbol as lt, isPath as m, LruCache as mt, normalizeAppOptions as n, setResponseHeaderInline as nt, buildRoutePathMatcher as o, createEventStream as ot, PluginErrorCode as p, MethodName as pt, getRequestHeader as q, SmartRouter as r, setResponseContentTypeByFileName as rt, isPlugin as s, serializeEventStreamMessage as st, App as t, setResponseHeaderAttachment as tt, PluginAlreadyInstalledError as u, setResponseCacheHeaders as ut, getRequestHostName as v, getRequestAcceptableCharset as w, getRequestAcceptableLanguages as x, matchRequestContentType as y, HandlerType as z };
 
-//# sourceMappingURL=src-DX0rndew.mjs.map
+//# sourceMappingURL=src-gmPicCWT.mjs.map