routup 6.0.0-beta.0 → 6.0.0-beta.2

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

@@ -20,11 +20,9 @@ const DEFAULT_MAX_SIZE = 1024;
 * `ICache` (e.g. wrapping `lru-cache`) and pass it via the router's
 * `BaseRouterOptions.cache` slot.
 */
-var LruCache = class LruCache {
-	options;
+var LruCache = class {
 	inner;
 	constructor(options = {}) {
-		this.options = options;
 		this.inner = new QuickLRU({ maxSize: options.maxSize ?? DEFAULT_MAX_SIZE });
 	}
 	get(key) {
@@ -39,9 +37,6 @@ var LruCache = class LruCache {
 	clear() {
 		this.inner.clear();
 	}
-	clone() {
-		return new LruCache({ ...this.options });
-	}
 };
 //#endregion
 //#region src/constants.ts
@@ -815,16 +810,17 @@ var DispatcherEvent = class {
 	error;
 	/**
 	* 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.
+	* entry to `App.dispatch` and restored on exit so re-entrant
+	* dispatch calls leave the caller's view intact. 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.
+	* `true` while an `App.dispatch` call is on the stack for this
+	* event. `App.dispatch` reads this on entry to derive `isRoot`
+	* and writes it on entry/exit so re-entrant calls behave
+	* correctly.
 	*/
 	isDispatching;
 	_dispatched;
@@ -950,148 +946,12 @@ const HandlerType = {
 };
 const HandlerSymbol = Symbol.for("Handler");
 //#endregion
-//#region src/hook/constants.ts
-const HookName = {
-	/**
-	* 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",
-	CHILD_DISPATCH_AFTER: "childDispatchAfter"
-};
-//#endregion
-//#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] || [];
-		const entry = {
-			fn,
-			priority
-		};
-		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);
-		};
-	}
-	removeListener(name, fn) {
-		if (!this.items[name]) return;
-		if (typeof fn === "undefined") {
-			delete this.items[name];
-			this.recomputeHasAny();
-			return;
-		}
-		if (typeof fn === "function") {
-			const index = this.items[name].findIndex((entry) => entry.fn === fn);
-			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
-	* one.
-	*
-	* Listener functions are shared by reference; priority and ordering are
-	* preserved. Future mutations on the returned instance do not affect this
-	* one (and vice versa).
-	*/
-	clone() {
-		const next = new Hooks();
-		const names = Object.keys(this.items);
-		for (const name of names) {
-			const entries = this.items[name];
-			for (const entry of entries) next.addListener(name, entry.fn, entry.priority);
-		}
-		return next;
-	}
-	async trigger(name, event) {
-		if (!this.items[name] || this.items[name].length === 0) return;
-		try {
-			for (let i = 0; i < this.items[name].length; i++) {
-				const { fn } = this.items[name][i];
-				await this.triggerListener(name, event, fn);
-				if (event.dispatched) {
-					if (event.error) event.error = void 0;
-					return;
-				}
-			}
-		} catch (e) {
-			if (!event.error) event.error = createError(e);
-			if (!this.isErrorListenerHook(name)) {
-				await this.trigger(HookName.ERROR, event);
-				if (event.dispatched) {
-					if (event.error) event.error = void 0;
-				}
-			}
-		}
-	}
-	triggerListener(name, event, listener) {
-		if (this.isErrorListenerHook(name)) {
-			if (event.error) return listener(event);
-			return;
-		}
-		return listener(event);
-	}
-	isErrorListenerHook(input) {
-		return input === HookName.ERROR;
-	}
-};
-//#endregion
 //#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);
@@ -1103,15 +963,12 @@ var Handler = class {
 		return this.config.path;
 	}
 	async dispatch(event) {
-		if (this.hooks.hasListeners(HookName.CHILD_DISPATCH_BEFORE)) {
-			await this.hooks.trigger(HookName.CHILD_DISPATCH_BEFORE, event);
-			if (event.dispatched) return;
-		}
 		let response;
+		let handlerEvent;
+		let cleanupParentListener;
 		try {
 			const effectiveTimeout = this.resolveTimeout(event.appOptions);
 			let childController;
-			let cleanupParentListener;
 			if (effectiveTimeout) {
 				const parentSignal = event.signal;
 				childController = new AbortController();
@@ -1122,41 +979,42 @@ var Handler = class {
 					cleanupParentListener = () => parentSignal.removeEventListener("abort", onAbort);
 				}
 			}
-			const handlerEvent = childController ? event.build(childController.signal) : event.build();
-			let result;
-			try {
-				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;
-					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();
+			handlerEvent = childController ? event.build(childController.signal) : event.build();
+			const skipFn = this.config.type === HandlerType.ERROR && !event.error;
+			if (!skipFn && this.config.onBefore) await this.config.onBefore(handlerEvent);
+			let invocation;
+			if (skipFn) {} else if (this.config.type === HandlerType.ERROR) {
+				const { fn } = this.config;
+				invocation = fn(event.error, handlerEvent);
+			} else {
+				const { fn } = this.config;
+				invocation = fn(handlerEvent);
 			}
+			let result;
+			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;
 			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;
 			}
+			if (!skipFn && this.config.onAfter) await this.config.onAfter(handlerEvent, response);
 		} catch (e) {
 			event.error = isError(e) ? e : createError(e);
-			if (this.hooks.hasListeners(HookName.ERROR)) await this.hooks.trigger(HookName.ERROR, event);
-			if (event.dispatched) event.error = void 0;
-			else throw event.error;
+			if (this.config.onError) try {
+				await this.config.onError(event.error, handlerEvent ?? event.build());
+			} catch (innerErr) {
+				event.error = isError(innerErr) ? innerErr : createError(innerErr);
+			}
+			throw event.error;
+		} finally {
+			if (cleanupParentListener) cleanupParentListener();
 		}
-		if (this.hooks.hasListeners(HookName.CHILD_DISPATCH_AFTER)) await this.hooks.trigger(HookName.CHILD_DISPATCH_AFTER, event);
 		return response;
 	}
 	/**
@@ -1220,11 +1078,6 @@ var Handler = class {
 		if (appOptions.handlerTimeoutOverridable) return handlerOverride;
 		return Math.min(routerDefault, handlerOverride);
 	}
-	mountHooks() {
-		if (this.config.onBefore) this.hooks.addListener(HookName.CHILD_DISPATCH_BEFORE, this.config.onBefore);
-		if (this.config.onAfter) this.hooks.addListener(HookName.CHILD_DISPATCH_AFTER, this.config.onAfter);
-		if (this.config.onError) this.hooks.addListener(HookName.ERROR, this.config.onError);
-	}
 };
 //#endregion
 //#region src/handler/core/define.ts
@@ -1681,7 +1534,7 @@ function buildRoutePathMatcher(route) {
 * `BaseRouterOptions.cache` to skip the linear walk on repeated
 * requests for the same path. Default is no caching.
 */
-var LinearRouter = class LinearRouter {
+var LinearRouter = class {
 	_routes;
 	_matchers;
 	cache;
@@ -1722,9 +1575,6 @@ var LinearRouter = class LinearRouter {
 		this.cache?.set(path, matches);
 		return matches;
 	}
-	clone() {
-		return new LinearRouter({ cache: this.cache?.clone() });
-	}
 };
 //#endregion
 //#region src/router/trie/parser.ts
@@ -2131,7 +1981,7 @@ function pushIntoBucket(buckets, methodKey, route) {
 * 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 {
+var TrieRouter = class {
 	/**
 	* Monotonic counter assigned as the registration `index` on each
 	* route — the dispatch loop uses it to preserve registration
@@ -2231,9 +2081,6 @@ var TrieRouter = class TrieRouter {
 		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
@@ -2345,7 +2192,7 @@ const DEFAULT_THRESHOLD = 30;
 * 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.
+* — `add`, `lookup` — 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
@@ -2357,7 +2204,7 @@ const DEFAULT_THRESHOLD = 30;
 * that matters in routup today: linear-vs-trie at the registration-
 * size crossover.
 */
-var SmartRouter = class SmartRouter {
+var SmartRouter = class {
 	inner;
 	pending = [];
 	threshold;
@@ -2385,12 +2232,6 @@ var SmartRouter = class SmartRouter {
 		}
 		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
@@ -2426,18 +2267,6 @@ function normalizeAppOptions(input) {
 //#endregion
 //#region src/app/constants.ts
 const AppSymbol = Symbol.for("App");
-const AppPipelineStep = {
-	START: 0,
-	LOOKUP: 1,
-	CHILD_BEFORE: 2,
-	CHILD_DISPATCH: 3,
-	CHILD_AFTER: 4,
-	FINISH: 5
-};
-const RouteEntryType = {
-	APP: "app",
-	HANDLER: "handler"
-};
 //#endregion
 //#region src/app/check.ts
 function isAppInstance(input) {
@@ -2463,26 +2292,9 @@ function mergeMatchParams(event, matchParams) {
 		...matchParams
 	};
 }
-/**
-* 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 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.
+	* A label for the App instance.
 	*/
 	name;
 	/**
@@ -2502,54 +2314,60 @@ var App = class App {
 	*/
 	router;
 	/**
-	* Lifecycle hook registry.
-	*
-	* @protected
-	*/
-	hooks;
-	/**
 	* 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.
+	* Frozen on construction — once published to `event.appOptions`
+	* it is shared across all requests, and a handler must not be
+	* able to mutate router-global state.
 	*/
 	_options;
 	/**
-	* Registry of installed plugins (name → version) on this router.
+	* Registry of installed plugins (name → version) on this App.
+	*
+	* Read by `use(otherApp)` (via the public `plugins` getter) so
+	* plugin registries merge into the parent at flatten time —
+	* `parent.hasPlugin('foo')` then reflects plugins installed on
+	* apps mounted into it.
 	*
 	* @protected
 	*/
-	plugins = /* @__PURE__ */ new Map();
+	_plugins;
 	/**
 	* 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
+	* Read by `use(otherApp)` to snapshot routes at flatten time.
+	* Late mutations to `_routes` after a flatten do not propagate.
 	*/
 	_routes = [];
 	constructor(input = {}) {
 		this.name = input.name;
 		this._path = input.path;
-		this.hooks = input.hooks ?? new Hooks();
-		this.plugins = new Map(input.plugins);
+		this._plugins = /* @__PURE__ */ new Map();
 		this.router = input.router ?? new LinearRouter();
 		this._options = Object.freeze(normalizeAppOptions(input.options ?? {}));
 		markInstanceof(this, AppSymbol);
 	}
 	/**
+	* Public read of the canonical route list. Used by `use(child)`
+	* to snapshot the child's routes at flatten time. Returned
+	* as `readonly` — callers must not mutate.
+	*/
+	get routes() {
+		return this._routes;
+	}
+	/**
+	* Public read of the installed-plugin registry. Used by
+	* `use(child)` to merge child plugins into the parent at
+	* flatten time. Returned as `ReadonlyMap` — callers must not
+	* mutate; go through `use(plugin)` to install.
+	*/
+	get plugins() {
+		return this._plugins;
+	}
+	/**
 	* 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.
+	* App so `setRouter` / `use(child)` can read the canonical list
+	* back.
 	*
 	* @protected
 	*/
@@ -2622,199 +2440,6 @@ var App = class App {
 			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 !== AppPipelineStep.FINISH) switch (context.step) {
-			case AppPipelineStep.START:
-				await this.executePipelineStepStart(context);
-				break;
-			case AppPipelineStep.LOOKUP:
-				await this.executePipelineStepLookup(context);
-				break;
-			case AppPipelineStep.CHILD_BEFORE:
-				await this.executePipelineStepChildBefore(context);
-				break;
-			case AppPipelineStep.CHILD_DISPATCH:
-				await this.executePipelineStepChildDispatch(context);
-				break;
-			case AppPipelineStep.CHILD_AFTER:
-				await this.executePipelineStepChildAfter(context);
-				break;
-			default:
-				context.step = AppPipelineStep.FINISH;
-				break;
-		}
-		await this.executePipelineStepFinish(context);
-	}
-	async executePipelineStepStart(context) {
-		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) {
-		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.matchIndex++;
-					continue;
-				}
-				const { method } = route;
-				if (method) context.event.methodsAllowed.add(method);
-				if (!matchHandlerMethod(method, context.event.method)) {
-					context.matchIndex++;
-					continue;
-				}
-			}
-			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;
-			}
-			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 = AppPipelineStep.FINISH;
-	}
-	async executePipelineStepChildBefore(context) {
-		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) {
-		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 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 (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 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 route.data.data.dispatch(event);
-			if (response) {
-				context.response = response;
-				event.dispatched = true;
-			}
-		} catch (e) {
-			event.error = createError(e);
-			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.matchIndex++;
-		context.step = AppPipelineStep.CHILD_AFTER;
-	}
-	async executePipelineStepFinish(context) {
-		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);
-			optionsHeaders.set(HeaderName.ALLOW, options);
-			context.response = new Response(options, {
-				status: context.event.response.status || 200,
-				headers: optionsHeaders
-			});
-			context.event.dispatched = true;
-		}
-	}
 	async dispatch(event) {
 		const savedPath = event.path;
 		const savedMountPath = event.mountPath;
@@ -2822,17 +2447,23 @@ var App = class App {
 		const savedAppOptions = event.appOptions;
 		const wasDispatching = event.isDispatching;
 		const isRoot = !wasDispatching;
-		const context = {
-			step: AppPipelineStep.START,
-			event,
-			isRoot,
-			matchIndex: 0
-		};
 		event.appOptions = this._options;
 		event.isDispatching = true;
+		let response;
 		try {
-			await this.executePipelineStep(context);
-			if (this.hooks.hasListeners(HookName.END)) await this.hooks.trigger(HookName.END, event);
+			const matches = this.router.lookup(event.path, event.method);
+			response = await this.runMatches(event, matches, event.path, 0);
+			if (!event.error && !event.dispatched && isRoot && event.method === MethodName.OPTIONS) {
+				if (event.methodsAllowed.has(MethodName.GET)) event.methodsAllowed.add(MethodName.HEAD);
+				const options = [...event.methodsAllowed].map((key) => key.toUpperCase()).join(",");
+				const optionsHeaders = new Headers(event.response.headers);
+				optionsHeaders.set(HeaderName.ALLOW, options);
+				response = new Response(options, {
+					status: event.response.status || 200,
+					headers: optionsHeaders
+				});
+				event.dispatched = true;
+			}
 		} finally {
 			event.appOptions = savedAppOptions;
 			event.isDispatching = wasDispatching;
@@ -2842,7 +2473,57 @@ var App = class App {
 				event.params = savedParams;
 			}
 		}
-		return context.response;
+		return response;
+	}
+	/**
+	* Walk the matched routes for the current event, dispatching each
+	* handler in order. Re-entered (recursively) from the `setNext`
+	* continuation so `event.next()` resumes from the next match.
+	*/
+	async runMatches(event, matches, matchesPath, startIndex) {
+		let i = startIndex;
+		let response;
+		while (!event.dispatched && i < matches.length) {
+			const match = matches[i];
+			const handler = match.route.data;
+			if (event.error && handler.type === HandlerType.CORE || !event.error && handler.type === HandlerType.ERROR) {
+				i++;
+				continue;
+			}
+			const { method } = match.route;
+			if (method) event.methodsAllowed.add(method);
+			if (!matchHandlerMethod(method, event.method)) {
+				i++;
+				continue;
+			}
+			mergeMatchParams(event, match.params);
+			const savedMountPath = event.mountPath;
+			if (typeof match.path === "string") event.mountPath = match.path;
+			const capturedMatches = matches;
+			const capturedMatchesPath = matchesPath;
+			const nextIndex = i + 1;
+			event.setNext(async (error) => {
+				if (error) event.error = createError(error);
+				const pathChanged = event.path !== capturedMatchesPath;
+				const nextMatches = pathChanged ? this.router.lookup(event.path, event.method) : capturedMatches;
+				const nextMatchesPath = pathChanged ? event.path : capturedMatchesPath;
+				const nextStart = pathChanged ? 0 : nextIndex;
+				return this.runMatches(event, nextMatches, nextMatchesPath, nextStart);
+			});
+			try {
+				const dispatchResponse = await handler.dispatch(event);
+				if (dispatchResponse) {
+					response = dispatchResponse;
+					event.dispatched = true;
+				}
+			} catch (e) {
+				event.error = createError(e);
+			} finally {
+				event.mountPath = savedMountPath;
+			}
+			i++;
+		}
+		return response;
 	}
 	delete(...input) {
 		this.useForMethod(MethodName.DELETE, ...input);
@@ -2889,10 +2570,7 @@ var App = class App {
 			this.register({
 				path: joinPaths(this._path, path, handler.path),
 				method,
-				data: {
-					type: RouteEntryType.HANDLER,
-					data: handler
-				}
+				data: handler
 			});
 		}
 	}
@@ -2904,24 +2582,14 @@ var App = class App {
 				continue;
 			}
 			if (isAppInstance(item)) {
-				item.extendOptions(this._options);
-				this.register({
-					path: joinPaths(this._path, path),
-					data: {
-						type: RouteEntryType.APP,
-						data: item
-					}
-				});
+				this.flatten(item, path);
 				continue;
 			}
 			if (isHandler(item)) {
 				this.register({
 					path: joinPaths(this._path, path, item.path),
 					method: item.method,
-					data: {
-						type: RouteEntryType.HANDLER,
-						data: item
-					}
+					data: item
 				});
 				continue;
 			}
@@ -2930,10 +2598,7 @@ var App = class App {
 				this.register({
 					path: joinPaths(this._path, path, handler.path),
 					method: handler.method,
-					data: {
-						type: RouteEntryType.HANDLER,
-						data: handler
-					}
+					data: handler
 				});
 				continue;
 			}
@@ -2943,90 +2608,48 @@ var App = class App {
 		return this;
 	}
 	/**
-	* Check if a plugin with the given name is installed on this router.
+	* Snapshot a child App's routes and plugin registry into this
+	* one. Each route's path is prefixed with `this._path`, the
+	* supplied mount `path`, and the route's own path (in that
+	* order); the resulting entry is registered on this App's
+	* router. The child app is not retained — late mutations on it
+	* after this call do not propagate.
+	*
+	* @protected
 	*/
-	hasPlugin(name) {
-		return this.plugins.has(name);
+	flatten(child, path) {
+		for (const name of child.plugins.keys()) if (this._plugins.has(name)) throw new PluginAlreadyInstalledError(name);
+		for (const [name, version] of child.plugins) this._plugins.set(name, version);
+		for (const route of child.routes) this.register({
+			path: joinPaths(this._path, path, route.path),
+			method: route.method,
+			data: route.data
+		});
 	}
 	/**
-	* Get the version of an installed plugin by name on this router,
-	* or `undefined` if the plugin is not installed here.
+	* Check if a plugin with the given name is installed on this App.
 	*/
-	getPluginVersion(name) {
-		return this.plugins.get(name);
-	}
-	install(plugin, context = {}) {
-		if (this.plugins.has(plugin.name)) throw new PluginAlreadyInstalledError(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);
-		this.plugins.set(plugin.name, plugin.version);
-		return this;
+	hasPlugin(name) {
+		return this._plugins.has(name);
 	}
 	/**
-	* Return a new `App` that mirrors this one but owns independent
-	* mountable state.
-	*
-	* The new router has:
-	* - a fresh `stack` array of shallow-copied entries (handlers and child
-	*   routers are shared by reference; only the wrapping entries are new)
-	* - the same `pathMatcher` reference (it is stateless)
-	* - a fresh `Hooks` instance seeded with the current listeners
-	* - a shallow copy of `_options`
-	* - a fresh `plugins` map with the same entries
-	*
-	* Use this when the same logical router needs to be mounted under
-	* multiple paths — each mount can receive its own clone so subsequent
-	* mutations on one mount do not bleed into the others.
+	* Get the version of an installed plugin by name, or `undefined`
+	* if the plugin is not installed.
 	*/
-	clone() {
-		const next = new App({
-			name: this.name,
-			path: this._path,
-			options: { ...this._options },
-			hooks: this.hooks.clone(),
-			plugins: this.plugins,
-			router: this.router.clone()
-		});
-		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;
-			}
-			next.register({
-				path: route.path,
-				method: route.method,
-				data: {
-					type: RouteEntryType.HANDLER,
-					data: route.data.data
-				}
-			});
-		}
-		return next;
-	}
-	on(name, fn, priority) {
-		return this.hooks.addListener(name, fn, priority);
+	getPluginVersion(name) {
+		return this._plugins.get(name);
 	}
-	off(name, fn) {
-		if (typeof fn === "undefined") {
-			this.hooks.removeListener(name);
-			return this;
-		}
-		this.hooks.removeListener(name, fn);
+	install(plugin, context = {}) {
+		if (this._plugins.has(plugin.name)) throw new PluginAlreadyInstalledError(plugin.name);
+		const scratch = new App({ name: plugin.name });
+		plugin.install(scratch);
+		if (context.path) this.use(context.path, scratch);
+		else this.use(scratch);
+		this._plugins.set(plugin.name, plugin.version);
 		return this;
 	}
 };
 //#endregion
 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-gmPicCWT.mjs.map
+//# sourceMappingURL=src-BfsqxIfL.mjs.map