routup 6.0.0-beta.2 → 6.0.0-beta.4

package/dist/service-worker.d.mts

@@ -1,4 +1,4 @@
-import { $ as AppOptions, $t as HandlerType, A as sendFormat, At as NodeHandler, B as setResponseHeaderAttachment, Bt as HandlerAfterListener, C as getRequestAcceptableContentTypes, Ct as isWebHandler, D as setResponseContentTypeByFileName, Dt as WebHandlerProvider, E as toResponse, Et as WebHandler, F as SendFileStats, Ft as Handler, G as EventStreamHandle, Gt as PathMatcher, H as appendResponseHeader, Ht as HandlerBeforeListener, I as sendFile, It as HandlerOptions, J as EventStreamListener, Jt as PathMatcherExecResult, K as EventStreamOptions, Kt as IPathMatcher, L as sendCreated, Lt as defineErrorHandler, M as SendFileContentOptions, Mt as defineCoreHandler, N as SendFileDisposition, Nt as CoreHandler, O as sendStream, Ot as fromNodeHandler, P as SendFileOptions, Pt as CoreHandlerOptions, Q as AppContext, Qt as HandlerSymbol, R as sendAccepted, Rt as ErrorHandler, S as getRequestAcceptableContentType, St as isHandlerOptions, T as isRequestCacheable, Tt as fromWebHandler, U as appendResponseHeaderDirective, Ut as HandlerErrorListener, V as setResponseHeaderInline, Vt as HandlerBaseOptions, W as serializeEventStreamMessage, Wt as isPath, X as ResponseCacheHeadersOptions, Xt as isError, Y as EventStreamMessage, Yt as PathMatcherOptions, Z as setResponseCacheHeaders, Zt as createError, _ as getRequestAcceptableLanguages, _t as isPluginError, a as SmartRouter, an as AppRequest, at as Route, b as getRequestAcceptableCharset, bt as matchHandlerMethod, c as RequestProtocolOptions, cn as NextFn, ct as LruCacheOptions, d as RequestIpOptions, dn as MethodNameLike, dt as Plugin, en as DispatcherEvent, et as AppOptionsInput, f as getRequestIP, fn as AppError, ft as PluginInstallContext, g as getRequestAcceptableLanguage, gt as PluginAlreadyInstalledError, h as matchRequestContentType, ht as PluginInstallError, i as TrieRouter, in as AppEventCreateContext, it as ObjectLiteral, j as SendFileContent, jt as NodeMiddleware, k as sendRedirect, kt as fromNodeMiddleware, l as getRequestProtocol, ln as HeaderName, lt as ICache, m as getRequestHostName, mn as HTTPErrorInput, mt as PluginNotInstalledError, n as App, nn as IDispatcherEvent, nt as BaseRouterOptions, o as SmartRouterOptions, on as AppResponse, ot as RouteMatch, p as RequestHostNameOptions, pn as ErrorSymbol, pt as PluginInstallFn, q as createEventStream, qt as Path, r as buildRoutePathMatcher, rn as AppEvent, rt as IRouter, s as LinearRouter, sn as IAppEvent, st as LruCache, t as normalizeAppOptions, tn as IDispatcher, tt as IApp, u as useRequestNegotiator, un as MethodName, ut as isPlugin, v as getRequestAcceptableEncoding, vt as PluginError, w as getRequestHeader, wt as isWebHandlerProvider, x as getRequestAcceptableCharsets, xt as isHandler, y as getRequestAcceptableEncodings, yt as PluginErrorCode, z as setResponseHeaderContentType, zt as ErrorHandlerOptions } from "./index-6qjxyFZh.mjs";
+import { $ as AppOptions, $t as DispatcherEvent, A as sendFormat, At as NodeMiddleware, B as setResponseHeaderAttachment, Bt as HandlerBaseOptions, C as getRequestAcceptableContentTypes, Ct as isWebHandlerProvider, D as setResponseContentTypeByFileName, Dt as fromNodeHandler, E as toResponse, Et as WebHandlerProvider, F as SendFileStats, Ft as HandlerOptions, G as EventStreamHandle, Gt as IPathMatcher, H as appendResponseHeader, Ht as HandlerErrorListener, I as sendFile, It as defineErrorHandler, J as EventStreamListener, Jt as PathMatcherOptions, K as EventStreamOptions, Kt as Path, L as sendCreated, Lt as ErrorHandler, M as SendFileContentOptions, Mt as CoreHandler, N as SendFileDisposition, Nt as CoreHandlerOptions, O as sendStream, Ot as fromNodeMiddleware, P as SendFileOptions, Pt as Handler, Q as AppContext, Qt as HandlerType, R as sendAccepted, Rt as ErrorHandlerOptions, S as getRequestAcceptableContentType, St as isWebHandler, T as isRequestCacheable, Tt as WebHandler, U as appendResponseHeaderDirective, Ut as isPath, V as setResponseHeaderInline, Vt as HandlerBeforeListener, W as serializeEventStreamMessage, Wt as PathMatcher, X as ResponseCacheHeadersOptions, Xt as createError, Y as EventStreamMessage, Yt as isError, Z as setResponseCacheHeaders, Zt as HandlerSymbol, _ as getRequestAcceptableLanguages, _t as PluginError, a as SmartRouter, an as AppResponse, at as Route, b as getRequestAcceptableCharset, bt as isHandler, c as RequestProtocolOptions, cn as HeaderName, ct as LruCacheOptions, d as RequestIpOptions, dn as AppError, dt as Plugin, en as IDispatcher, et as AppOptionsInput, f as getRequestIP, fn as ErrorSymbol, ft as PluginInstallContext, g as getRequestAcceptableLanguage, gt as isPluginError, h as matchRequestContentType, ht as PluginInstallError, i as TrieRouter, in as AppRequest, it as ObjectLiteral, j as SendFileContent, jt as defineCoreHandler, k as sendRedirect, kt as NodeHandler, l as getRequestProtocol, ln as MethodName, lt as ICache, m as getRequestHostName, mt as PluginNotInstalledError, n as App, nn as AppEvent, nt as BaseRouterOptions, o as SmartRouterOptions, on as IAppEvent, ot as RouteMatch, p as RequestHostNameOptions, pn as HTTPErrorInput, pt as PluginInstallFn, q as createEventStream, qt as PathMatcherExecResult, r as buildRoutePathMatcher, rn as AppEventCreateContext, rt as IRouter, s as LinearRouter, sn as NextFn, st as LruCache, t as normalizeAppOptions, tn as IDispatcherEvent, tt as IApp, u as useRequestNegotiator, un as MethodNameLike, ut as isPlugin, v as getRequestAcceptableEncoding, vt as PluginErrorCode, w as getRequestHeader, wt as fromWebHandler, x as getRequestAcceptableCharsets, xt as isHandlerOptions, y as getRequestAcceptableEncodings, yt as matchHandlerMethod, z as setResponseHeaderContentType, zt as HandlerAfterListener } from "./index-colifb1o.mjs";
 import * as _$srvx from "srvx";
 import { ServerOptions } from "srvx";
 import * as _$srvx_service_worker0 from "srvx/service-worker";
@@ -6,5 +6,5 @@ import * as _$srvx_service_worker0 from "srvx/service-worker";
 //#region src/_entries/service-worker.d.ts
 declare function serve(app: IApp, options?: Omit<ServerOptions, 'fetch'>): _$srvx.Server<_$srvx_service_worker0.ServiceWorkerHandler>;
 //#endregion
-export { App, AppContext, AppError, AppEvent, AppEventCreateContext, AppOptions, AppOptionsInput, AppRequest, AppResponse, BaseRouterOptions, CoreHandler, CoreHandlerOptions, DispatcherEvent, ErrorHandler, ErrorHandlerOptions, ErrorSymbol, EventStreamHandle, EventStreamListener, EventStreamMessage, EventStreamOptions, HTTPErrorInput, Handler, HandlerAfterListener, HandlerBaseOptions, HandlerBeforeListener, HandlerErrorListener, HandlerOptions, HandlerSymbol, HandlerType, HeaderName, IApp, IAppEvent, ICache, IDispatcher, IDispatcherEvent, IPathMatcher, IRouter, LinearRouter, LruCache, LruCacheOptions, MethodName, MethodNameLike, NextFn, NodeHandler, NodeMiddleware, ObjectLiteral, Path, PathMatcher, PathMatcherExecResult, PathMatcherOptions, Plugin, PluginAlreadyInstalledError, PluginError, PluginErrorCode, PluginInstallContext, PluginInstallError, PluginInstallFn, PluginNotInstalledError, RequestHostNameOptions, RequestIpOptions, RequestProtocolOptions, ResponseCacheHeadersOptions, Route, RouteMatch, SendFileContent, SendFileContentOptions, SendFileDisposition, SendFileOptions, SendFileStats, SmartRouter, SmartRouterOptions, TrieRouter, WebHandler, WebHandlerProvider, appendResponseHeader, appendResponseHeaderDirective, buildRoutePathMatcher, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isPluginError, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchHandlerMethod, matchRequestContentType, normalizeAppOptions, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, setResponseHeaderInline, toResponse, useRequestNegotiator };
+export { App, AppContext, AppError, AppEvent, AppEventCreateContext, AppOptions, AppOptionsInput, AppRequest, AppResponse, BaseRouterOptions, CoreHandler, CoreHandlerOptions, DispatcherEvent, ErrorHandler, ErrorHandlerOptions, ErrorSymbol, EventStreamHandle, EventStreamListener, EventStreamMessage, EventStreamOptions, HTTPErrorInput, Handler, HandlerAfterListener, HandlerBaseOptions, HandlerBeforeListener, HandlerErrorListener, HandlerOptions, HandlerSymbol, HandlerType, HeaderName, IApp, IAppEvent, ICache, IDispatcher, IDispatcherEvent, IPathMatcher, IRouter, LinearRouter, LruCache, LruCacheOptions, MethodName, MethodNameLike, NextFn, NodeHandler, NodeMiddleware, ObjectLiteral, Path, PathMatcher, PathMatcherExecResult, PathMatcherOptions, Plugin, PluginError, PluginErrorCode, PluginInstallContext, PluginInstallError, PluginInstallFn, PluginNotInstalledError, RequestHostNameOptions, RequestIpOptions, RequestProtocolOptions, ResponseCacheHeadersOptions, Route, RouteMatch, SendFileContent, SendFileContentOptions, SendFileDisposition, SendFileOptions, SendFileStats, SmartRouter, SmartRouterOptions, TrieRouter, WebHandler, WebHandlerProvider, appendResponseHeader, appendResponseHeaderDirective, buildRoutePathMatcher, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isPluginError, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchHandlerMethod, matchRequestContentType, normalizeAppOptions, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, setResponseHeaderInline, toResponse, useRequestNegotiator };
 //# sourceMappingURL=service-worker.d.mts.map

package/dist/service-worker.mjs

@@ -1,4 +1,4 @@
-import { $ as isError, A as fromWebHandler, B as DispatcherEvent, C as getRequestAcceptableEncodings, D as matchHandlerMethod, E as isRequestCacheable, F as defineErrorHandler, G as getRequestAcceptableContentTypes, H as sendRedirect, I as defineCoreHandler, J as sendFile, K as useRequestNegotiator, L as Handler, M as isWebHandlerProvider, N as fromNodeHandler, O as isHandler, P as fromNodeMiddleware, Q as createError, R as HandlerSymbol, S as getRequestAcceptableEncoding, T as getRequestAcceptableCharsets, U as sendFormat, V as sendStream, W as getRequestAcceptableContentType, X as sendAccepted, Y as sendCreated, Z as toResponse, _ as getRequestIP, a as LinearRouter, at as appendResponseHeaderDirective, b as getRequestAcceptableLanguage, c as PluginNotInstalledError, ct as AppError, d as PluginError, dt as AppEvent, et as setResponseHeaderContentType, f as isPluginError, ft as HeaderName, g as getRequestProtocol, h as PathMatcher, i as TrieRouter, it as appendResponseHeader, j as isWebHandler, k as isHandlerOptions, l as PluginInstallError, lt as ErrorSymbol, m as isPath, mt as LruCache, n as normalizeAppOptions, nt as setResponseHeaderInline, o as buildRoutePathMatcher, ot as createEventStream, p as PluginErrorCode, pt as MethodName, q as getRequestHeader, r as SmartRouter, rt as setResponseContentTypeByFileName, s as isPlugin, st as serializeEventStreamMessage, t as App, tt as setResponseHeaderAttachment, u as PluginAlreadyInstalledError, ut as setResponseCacheHeaders, v as getRequestHostName, w as getRequestAcceptableCharset, x as getRequestAcceptableLanguages, y as matchRequestContentType, z as HandlerType } from "./src-BfsqxIfL.mjs";
+import { $ as setResponseHeaderContentType, A as isWebHandler, B as sendStream, C as getRequestAcceptableCharset, D as isHandler, E as matchHandlerMethod, F as defineCoreHandler, G as useRequestNegotiator, H as sendFormat, I as Handler, J as sendCreated, K as getRequestHeader, L as HandlerSymbol, M as fromNodeHandler, N as fromNodeMiddleware, O as isHandlerOptions, P as defineErrorHandler, Q as isError, R as HandlerType, S as getRequestAcceptableEncodings, T as isRequestCacheable, U as getRequestAcceptableContentType, V as sendRedirect, W as getRequestAcceptableContentTypes, X as toResponse, Y as sendAccepted, Z as createError, _ as getRequestHostName, a as LinearRouter, at as createEventStream, b as getRequestAcceptableLanguages, c as PluginNotInstalledError, ct as ErrorSymbol, d as isPluginError, dt as HeaderName, et as setResponseHeaderAttachment, f as PluginErrorCode, ft as MethodName, g as getRequestIP, h as getRequestProtocol, i as TrieRouter, it as appendResponseHeaderDirective, j as isWebHandlerProvider, k as fromWebHandler, l as PluginInstallError, lt as setResponseCacheHeaders, m as PathMatcher, n as normalizeAppOptions, nt as setResponseContentTypeByFileName, o as buildRoutePathMatcher, ot as serializeEventStreamMessage, p as isPath, pt as LruCache, q as sendFile, r as SmartRouter, rt as appendResponseHeader, s as isPlugin, st as AppError, t as App, tt as setResponseHeaderInline, u as PluginError, ut as AppEvent, v as matchRequestContentType, w as getRequestAcceptableCharsets, x as getRequestAcceptableEncoding, y as getRequestAcceptableLanguage, z as DispatcherEvent } from "./src-DE8cCC5t.mjs";
 import { serve as serve$1 } from "srvx/service-worker";
 //#region src/_entries/service-worker.ts
 function serve(app, options) {
@@ -8,6 +8,6 @@ function serve(app, options) {
 	});
 }
 //#endregion
-export { App, AppError, AppEvent, DispatcherEvent, ErrorSymbol, Handler, HandlerSymbol, HandlerType, HeaderName, LinearRouter, LruCache, MethodName, PathMatcher, PluginAlreadyInstalledError, PluginError, PluginErrorCode, PluginInstallError, PluginNotInstalledError, SmartRouter, TrieRouter, appendResponseHeader, appendResponseHeaderDirective, buildRoutePathMatcher, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isPluginError, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchHandlerMethod, matchRequestContentType, normalizeAppOptions, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, setResponseHeaderInline, toResponse, useRequestNegotiator };
+export { App, AppError, AppEvent, DispatcherEvent, ErrorSymbol, Handler, HandlerSymbol, HandlerType, HeaderName, LinearRouter, LruCache, MethodName, PathMatcher, PluginError, PluginErrorCode, PluginInstallError, PluginNotInstalledError, SmartRouter, TrieRouter, appendResponseHeader, appendResponseHeaderDirective, buildRoutePathMatcher, createError, createEventStream, defineCoreHandler, defineErrorHandler, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isError, isHandler, isHandlerOptions, isPath, isPlugin, isPluginError, isRequestCacheable, isWebHandler, isWebHandlerProvider, matchHandlerMethod, matchRequestContentType, normalizeAppOptions, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, serializeEventStreamMessage, serve, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, setResponseHeaderInline, toResponse, useRequestNegotiator };
 
 //# sourceMappingURL=service-worker.mjs.map

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

@@ -1421,7 +1421,6 @@ function isPath(input) {
 const PluginErrorCode = {
 	PLUGIN: "PLUGIN",
 	NOT_INSTALLED: "PLUGIN_NOT_INSTALLED",
-	ALREADY_INSTALLED: "PLUGIN_ALREADY_INSTALLED",
 	INSTALL: "PLUGIN_INSTALL"
 };
 //#endregion
@@ -1442,19 +1441,6 @@ var PluginError = class extends AppError {
 	}
 };
 //#endregion
-//#region src/plugin/error/sub/already-installed.ts
-var PluginAlreadyInstalledError = class extends PluginError {
-	pluginName;
-	constructor(pluginName) {
-		super({
-			message: `Plugin "${pluginName}" is already installed on this router.`,
-			code: PluginErrorCode.ALREADY_INSTALLED
-		});
-		this.name = "PluginAlreadyInstalledError";
-		this.pluginName = pluginName;
-	}
-};
-//#endregion
 //#region src/plugin/error/sub/install.ts
 var PluginInstallError = class extends PluginError {
 	pluginName;
@@ -2269,8 +2255,26 @@ function normalizeAppOptions(input) {
 const AppSymbol = Symbol.for("App");
 //#endregion
 //#region src/app/check.ts
+/**
+* Discriminate an `IApp` argument from handlers, plugins, and other
+* inputs `App.use()` accepts. Two-stage check:
+*
+*   1. Fast path: brand check (`hasInstanceof` against `AppSymbol`).
+*      Hits for every instance of the bundled `App` class and any
+*      subclass that calls `markInstanceof(this, AppSymbol)` — that's
+*      the common case, so we want it to be a single property lookup
+*      with no key-by-key probing.
+*
+*   2. Fallback: structural check for the `IApp` surface `flatten()`
+*      reads at mount time (`fetch`, `routes`, `plugins`,
+*      `pluginSingletons`). Lets any object implementing the `IApp`
+*      contract — not just instances of the bundled `App` class — be
+*      mounted via `app.use(child)`.
+*/
 function isAppInstance(input) {
-	return hasInstanceof(input, AppSymbol);
+	if (hasInstanceof(input, AppSymbol)) return true;
+	if (!isObject(input)) return false;
+	return typeof input.fetch === "function" && Array.isArray(input.routes) && isObject(input.plugins) && isObject(input.pluginSingletons);
 }
 //#endregion
 //#region src/app/module.ts
@@ -2322,17 +2326,35 @@ var App = class App {
 	*/
 	_options;
 	/**
-	* Registry of installed plugins (name → version) on this App.
+	* Registry of installed plugins on this App, keyed by plugin name
+	* then by canonical mount key (the joined `this._path` +
+	* install-time `path`, falling back to `'/'` for a root install).
+	* Inner-map value is the plugin version (or `undefined`).
+	*
+	* Per-path keying lets `hasPluginAt` answer "is plugin X mounted at
+	* /api?" precisely. By default `install()` is permissive and
+	* appends — same `(name, key)` writes the latest version. Plugins
+	* opt into deduplication via `singleton` (any-path) or
+	* `singletonByPath` (same-path) flags.
 	*
-	* 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.
+	* Read by `flatten()` when merging a child's registry into this
+	* one, so `parent.hasPlugin('foo')` reflects plugins installed on
+	* mounted children too.
 	*
 	* @protected
 	*/
 	_plugins;
 	/**
+	* Names of plugins installed with `singleton: true`. Re-installing
+	* any of these names — even at a different mount path — is a
+	* silent no-op. The claim is sticky: once a name is in here, it
+	* stays for the lifetime of the App. Propagated through
+	* `flatten()` so a child's singleton claim survives the mount.
+	*
+	* @protected
+	*/
+	_pluginSingletons;
+	/**
 	* Every route registered on this App, in registration order.
 	*
 	* Read by `use(otherApp)` to snapshot routes at flatten time.
@@ -2343,6 +2365,7 @@ var App = class App {
 		this.name = input.name;
 		this._path = input.path;
 		this._plugins = /* @__PURE__ */ new Map();
+		this._pluginSingletons = /* @__PURE__ */ new Set();
 		this.router = input.router ?? new LinearRouter();
 		this._options = Object.freeze(normalizeAppOptions(input.options ?? {}));
 		markInstanceof(this, AppSymbol);
@@ -2356,15 +2379,31 @@ var App = class App {
 		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.
+	* Public read of the installed-plugin registry. Used by `flatten()`
+	* to merge a child's plugins into this App without reaching into
+	* the child's protected fields.
+	*
+	* Outer key: plugin name. Inner key: canonical mount path (`'/'`
+	* for root mounts). Inner value: installed version (or `undefined`).
+	*
+	* Returned as nested `ReadonlyMap` — callers must not mutate; go
+	* through `app.use(plugin)` to install.
 	*/
 	get plugins() {
 		return this._plugins;
 	}
 	/**
+	* Public read of the sticky singleton-claim set. Once a plugin
+	* name is claimed singleton on an App, every subsequent install
+	* of that name is a silent no-op. Used by `flatten()` to
+	* propagate child claims forward at mount time.
+	*
+	* Returned as `ReadonlySet` — callers must not mutate.
+	*/
+	get pluginSingletons() {
+		return this._pluginSingletons;
+	}
+	/**
 	* Register a route with the active router and record it on the
 	* App so `setRouter` / `use(child)` can read the canonical list
 	* back.
@@ -2452,7 +2491,7 @@ var App = class App {
 		let response;
 		try {
 			const matches = this.router.lookup(event.path, event.method);
-			response = await this.runMatches(event, matches, event.path, 0);
+			response = await this.runMatches(event, matches, 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(",");
@@ -2479,8 +2518,16 @@ var App = class App {
 	* 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.
+	*
+	* The match list is captured once per dispatch — there is no
+	* mid-walk path-rewrite refresh. `IAppEvent.path` is a snapshot
+	* on the handler's facade event (see `event/module.ts`), so user
+	* middleware cannot mutate the dispatcher's path before calling
+	* `event.next()`. If a future API surface lets middleware rewrite
+	* paths end-to-end, this loop will need a per-call refresh + a
+	* `methodsAllowed` reset (see closed issue #913).
 	*/
-	async runMatches(event, matches, matchesPath, startIndex) {
+	async runMatches(event, matches, startIndex) {
 		let i = startIndex;
 		let response;
 		while (!event.dispatched && i < matches.length) {
@@ -2500,15 +2547,10 @@ var App = class App {
 			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);
+				return this.runMatches(event, capturedMatches, nextIndex);
 			});
 			try {
 				const dispatchResponse = await handler.dispatch(event);
@@ -2618,38 +2660,104 @@ var App = class App {
 	* @protected
 	*/
 	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
 		});
+		const namesBeforeMerge = new Set(this._plugins.keys());
+		for (const [name, childPaths] of child.plugins) {
+			if (this._pluginSingletons.has(name)) continue;
+			let entry = this._plugins.get(name);
+			for (const [childKey, version] of childPaths) {
+				const composedKey = joinPaths(this._path, path, childKey) ?? "/";
+				if (entry && entry.has(composedKey)) continue;
+				if (!entry) {
+					entry = /* @__PURE__ */ new Map();
+					this._plugins.set(name, entry);
+				}
+				entry.set(composedKey, version);
+			}
+		}
+		for (const name of child.pluginSingletons) if (!namesBeforeMerge.has(name)) this._pluginSingletons.add(name);
 	}
 	/**
-	* Check if a plugin with the given name is installed on this App.
+	* Check if a plugin with the given name is installed on this App at
+	* *any* mount path.
 	*/
 	hasPlugin(name) {
-		return this._plugins.has(name);
+		const entry = this._plugins.get(name);
+		return !!entry && entry.size > 0;
+	}
+	/**
+	* Check if a plugin with the given name is installed at the given
+	* install-time `path`. `path` is interpreted the same way as the
+	* argument to `app.use(path, plugin)` — relative to this App. Omit
+	* `path` to check the root install.
+	*/
+	hasPluginAt(name, path) {
+		const entry = this._plugins.get(name);
+		if (!entry) return false;
+		const key = joinPaths(this._path, path) ?? "/";
+		return entry.has(key);
 	}
 	/**
 	* Get the version of an installed plugin by name, or `undefined`
-	* if the plugin is not installed.
+	* when the plugin is not installed. When the plugin is mounted at
+	* several paths, returns the version of an arbitrary mount —
+	* typical usage installs the same plugin object at every mount, so
+	* the version is identical. Use `getPluginVersionAt` to read the
+	* version of a specific mount.
 	*/
 	getPluginVersion(name) {
-		return this._plugins.get(name);
+		const entry = this._plugins.get(name);
+		if (!entry) return;
+		const first = entry.values().next();
+		return first.done ? void 0 : first.value;
+	}
+	/**
+	* Get the version of a plugin installed at the given install-time
+	* `path`, or `undefined` when no install matches. `path` is
+	* interpreted relative to this App (same convention as
+	* `app.use(path, plugin)`); omit it to read the root install.
+	*/
+	getPluginVersionAt(name, path) {
+		const entry = this._plugins.get(name);
+		if (!entry) return;
+		return entry.get(joinPaths(this._path, path) ?? "/");
+	}
+	/**
+	* List every canonical mount path the named plugin is installed
+	* at. Returns an empty array when the plugin is not installed.
+	* Each path is the joined `app._path` + install-time path,
+	* normalized to `'/'` for root mounts.
+	*/
+	getPluginMountPaths(name) {
+		const entry = this._plugins.get(name);
+		if (!entry) return [];
+		return Array.from(entry.keys());
 	}
 	install(plugin, context = {}) {
-		if (this._plugins.has(plugin.name)) throw new PluginAlreadyInstalledError(plugin.name);
+		const mountKey = joinPaths(this._path, context.path) ?? "/";
+		const existing = this._plugins.get(plugin.name);
+		if (this._pluginSingletons.has(plugin.name)) return this;
+		if (plugin.singleton && existing && existing.size > 0) return this;
+		if (plugin.singletonByPath && existing && existing.has(mountKey)) return this;
 		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);
+		let entry = this._plugins.get(plugin.name);
+		if (!entry) {
+			entry = /* @__PURE__ */ new Map();
+			this._plugins.set(plugin.name, entry);
+		}
+		entry.set(mountKey, plugin.version);
+		if (plugin.singleton) this._pluginSingletons.add(plugin.name);
 		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 };
+export { setResponseHeaderContentType as $, isWebHandler as A, sendStream as B, getRequestAcceptableCharset as C, isHandler as D, matchHandlerMethod as E, defineCoreHandler as F, useRequestNegotiator as G, sendFormat as H, Handler as I, sendCreated as J, getRequestHeader as K, HandlerSymbol as L, fromNodeHandler as M, fromNodeMiddleware as N, isHandlerOptions as O, defineErrorHandler as P, isError as Q, HandlerType as R, getRequestAcceptableEncodings as S, isRequestCacheable as T, getRequestAcceptableContentType as U, sendRedirect as V, getRequestAcceptableContentTypes as W, toResponse as X, sendAccepted as Y, createError as Z, getRequestHostName as _, LinearRouter as a, createEventStream as at, getRequestAcceptableLanguages as b, PluginNotInstalledError as c, ErrorSymbol as ct, isPluginError as d, HeaderName as dt, setResponseHeaderAttachment as et, PluginErrorCode as f, MethodName as ft, getRequestIP as g, getRequestProtocol as h, TrieRouter as i, appendResponseHeaderDirective as it, isWebHandlerProvider as j, fromWebHandler as k, PluginInstallError as l, setResponseCacheHeaders as lt, PathMatcher as m, normalizeAppOptions as n, setResponseContentTypeByFileName as nt, buildRoutePathMatcher as o, serializeEventStreamMessage as ot, isPath as p, LruCache as pt, sendFile as q, SmartRouter as r, appendResponseHeader as rt, isPlugin as s, AppError as st, App as t, setResponseHeaderInline as tt, PluginError as u, AppEvent as ut, matchRequestContentType as v, getRequestAcceptableCharsets as w, getRequestAcceptableEncoding as x, getRequestAcceptableLanguage as y, DispatcherEvent as z };
 
-//# sourceMappingURL=src-BfsqxIfL.mjs.map
+//# sourceMappingURL=src-DE8cCC5t.mjs.map