@qzsy/vinext 0.1.7

package/dist/server/middleware-response-headers.js

@@ -0,0 +1,42 @@
+//#region src/server/middleware-response-headers.ts
+const ADDITIVE_RESPONSE_HEADER_NAMES = new Set(["set-cookie", "vary"]);
+function mergeVaryHeader(target, value) {
+	const existing = target.get("Vary");
+	const tokens = (existing ? `${existing}, ${value}` : value).split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+	if (tokens.some((token) => token === "*")) {
+		target.set("Vary", "*");
+		return;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const merged = [];
+	for (const token of tokens) {
+		const normalized = token.toLowerCase();
+		if (seen.has(normalized)) continue;
+		seen.add(normalized);
+		merged.push(token);
+	}
+	target.set("Vary", merged.join(", "));
+}
+/**
+* Merge middleware response headers into a target Headers object.
+*
+* Set-Cookie and Vary are accumulated (append) since multiple sources can
+* contribute values. All other headers use set() so middleware owns singular
+* response headers like Cache-Control.
+*/
+function mergeMiddlewareResponseHeaders(target, middlewareHeaders) {
+	if (!middlewareHeaders) return;
+	for (const [key, value] of middlewareHeaders) {
+		if (key.toLowerCase() === "vary") {
+			mergeVaryHeader(target, value);
+			continue;
+		}
+		if (ADDITIVE_RESPONSE_HEADER_NAMES.has(key.toLowerCase())) {
+			target.append(key, value);
+			continue;
+		}
+		target.set(key, value);
+	}
+}
+//#endregion
+export { mergeMiddlewareResponseHeaders, mergeVaryHeader };

package/dist/server/middleware-runtime.d.ts

@@ -0,0 +1,67 @@
+import { NextI18nConfig } from "../config/next-config.js";
+import { ExecutionContextLike } from "../shims/request-context.js";
+import { NextFetchEvent, NextRequest } from "../shims/server.js";
+
+//#region src/server/middleware-runtime.d.ts
+type MiddlewareModule = Record<string, unknown>;
+type MiddlewareResult = {
+  continue: boolean;
+  redirectUrl?: string;
+  redirectStatus?: number;
+  rewriteUrl?: string;
+  rewriteStatus?: number;
+  status?: number;
+  responseHeaders?: Headers;
+  response?: Response;
+  waitUntilPromises?: Promise<unknown>[];
+};
+type MiddlewareHandler = (request: NextRequest, event: NextFetchEvent) => Response | undefined | void | Promise<Response | undefined | void>;
+type ExecuteMiddlewareOptions = {
+  basePath?: string;
+  filePath?: string;
+  /**
+   * Whether the incoming request was inside the configured basePath. Drives
+   * the `nextUrl.basePath` the middleware observes: in-basePath requests are
+   * re-prefixed so NextURL reports the configured basePath, while
+   * out-of-basePath ("absolute path") requests stay un-prefixed so middleware
+   * sees `nextUrl.basePath === ""` (Next.js `getNextPathnameInfo` semantics —
+   * see test/e2e/middleware-base-path "should execute from absolute paths").
+   * When omitted it is derived from the request URL, which is correct for the
+   * Pages prod/deploy adapters because they pass the original (un-stripped)
+   * URL. Callers that pass an already-stripped URL (dev server, App Router)
+   * must set this explicitly.
+   */
+  hadBasePath?: boolean;
+  i18nConfig?: NextI18nConfig | null;
+  includeErrorDetails?: boolean;
+  /**
+   * Whether the incoming request was recognized as a Next.js `_next/data`
+   * fetch. Internal headers are stripped before middleware runs, so adapters
+   * must derive and forward this from trusted URL normalization.
+   */
+  isDataRequest?: boolean;
+  isProxy: boolean;
+  module: MiddlewareModule;
+  normalizedPathname?: string;
+  request: Request;
+  /**
+   * The user's `trailingSlash` config. Plumbed into the NextRequest's NextURL
+   * so `request.nextUrl.toString()` formats with the configured slash policy,
+   * which feeds into `NextResponse.redirect(request.nextUrl)` Location headers.
+   * Also used to normalize redirect Location pathnames returned via plain
+   * `new URL('/x', req.url)`.
+   */
+  trailingSlash?: boolean;
+};
+type RunGeneratedMiddlewareOptions = ExecuteMiddlewareOptions & {
+  ctx?: ExecutionContextLike;
+};
+declare function createMiddlewareMissingExportError(filePath: string | undefined, isProxy: boolean): Error;
+declare function resolveMiddlewareModuleHandler(mod: MiddlewareModule, options: {
+  filePath?: string;
+  isProxy: boolean;
+}): MiddlewareHandler;
+declare function executeMiddleware(options: ExecuteMiddlewareOptions): Promise<MiddlewareResult>;
+declare function runGeneratedMiddleware(options: RunGeneratedMiddlewareOptions): Promise<MiddlewareResult>;
+//#endregion
+export { MiddlewareModule, MiddlewareResult, createMiddlewareMissingExportError, executeMiddleware, resolveMiddlewareModuleHandler, runGeneratedMiddleware };

package/dist/server/middleware-runtime.js

@@ -0,0 +1,240 @@
+import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
+import { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
+import "./server-globals.js";
+import { getRequestExecutionContext, runWithExecutionContext } from "../shims/request-context.js";
+import { MIDDLEWARE_REWRITE_HEADER } from "./headers.js";
+import { shouldKeepMiddlewareHeader } from "./middleware-request-headers.js";
+import { NextFetchEvent, NextRequest } from "../shims/server.js";
+import { normalizePath } from "./normalize-path.js";
+import { matchesMiddleware } from "./middleware-matcher.js";
+import { badRequestResponse, internalServerErrorResponse } from "./http-error-responses.js";
+import { processMiddlewareHeaders } from "./request-pipeline.js";
+import path from "node:path";
+//#region src/server/middleware-runtime.ts
+function isMiddlewareHandler(value) {
+	return typeof value === "function";
+}
+function isMiddlewareConfigExport(value) {
+	return !!value && typeof value === "object";
+}
+function middlewareExpectedExport(isProxy) {
+	return isProxy ? "proxy" : "middleware";
+}
+function middlewareDisplayPath(filePath) {
+	const fileName = path.basename(filePath);
+	return path.basename(path.dirname(filePath)) === "src" ? `./src/${fileName}` : `./${fileName}`;
+}
+function createMiddlewareMissingExportError(filePath, isProxy) {
+	const expectedExport = middlewareExpectedExport(isProxy);
+	const displayPath = filePath ? middlewareDisplayPath(filePath) : void 0;
+	const resolvedPath = displayPath ? ` "${displayPath}"` : "";
+	const migrationReason = isProxy ? "- You are migrating from `middleware` to `proxy`, but haven't updated the exported function.\n" : "";
+	return /* @__PURE__ */ new Error(`The file${resolvedPath} must export a function, either as a default export or as a named "${expectedExport}" export.\nThis function is what Next.js runs for every request handled by this ${isProxy ? "proxy (previously called middleware)" : "middleware"}.\n\nWhy this happens:\n` + migrationReason + `- The file exists but doesn't export a function.
+- The export is not a function (e.g., an object or constant).
+- There's a syntax error preventing the export from being recognized.
+
+To fix it:
+- Ensure this file has either a default or "${expectedExport}" function export.\n\nLearn more: https://nextjs.org/docs/messages/middleware-to-proxy`);
+}
+function resolveMiddlewareModuleHandler(mod, options) {
+	const handler = options.isProxy ? mod.proxy ?? mod.default : mod.middleware ?? mod.default;
+	if (isMiddlewareHandler(handler)) return handler;
+	throw createMiddlewareMissingExportError(options.filePath, options.isProxy);
+}
+function middlewareMatcher(mod) {
+	const config = mod.config;
+	if (!isMiddlewareConfigExport(config)) return void 0;
+	return config.matcher;
+}
+function stripMiddlewareHeadersFromResponse(response) {
+	const headers = new Headers(response.headers);
+	processMiddlewareHeaders(headers);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+/**
+* Make a same-host URL relative to the request origin. Cross-origin URLs are
+* returned unchanged. Mirrors Next.js's `getRelativeURL` behaviour:
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/relativize-url.ts
+*/
+function relativizeLocation(location, requestUrl) {
+	let parsed;
+	try {
+		parsed = new URL(location, requestUrl);
+	} catch {
+		return location;
+	}
+	const base = new URL(requestUrl);
+	if (parsed.origin !== base.origin) return parsed.toString();
+	return parsed.pathname + parsed.search + parsed.hash;
+}
+/**
+* Translate a middleware redirect Response into the soft-redirect protocol
+* used by Next.js for `_next/data` requests: a 200 OK with the redirect target
+* carried in the `x-nextjs-redirect` header. The client router consumes this
+* header to perform the navigation, avoiding CORS issues that would arise from
+* an actual cross-origin HTTP redirect on a data fetch.
+*
+* Reference: packages/next/src/server/web/adapter.ts
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/server/web/adapter.ts
+*/
+function dataRedirectResponse(target, originalResponse) {
+	const headers = new Headers(originalResponse.headers);
+	processMiddlewareHeaders(headers);
+	headers.delete("Location");
+	headers.set("x-nextjs-redirect", target);
+	return new Response(null, {
+		status: 200,
+		headers
+	});
+}
+function collectMiddlewareHeaders(response) {
+	const responseHeaders = new Headers();
+	for (const [key, value] of response.headers) if (!key.startsWith("x-middleware-") || shouldKeepMiddlewareHeader(key)) responseHeaders.append(key, value);
+	return responseHeaders;
+}
+function drainFetchEvent(fetchEvent) {
+	const waitUntilPromises = fetchEvent.waitUntilPromises;
+	const drained = fetchEvent.drainWaitUntil();
+	const executionContext = getRequestExecutionContext();
+	if (executionContext) executionContext.waitUntil(drained);
+	return waitUntilPromises;
+}
+function resolveMiddlewarePathname(request) {
+	const url = new URL(request.url);
+	try {
+		return normalizePath(normalizePathnameForRouteMatchStrict(url.pathname));
+	} catch {
+		return badRequestResponse();
+	}
+}
+function createNextRequest(request, normalizedPathname, i18nConfig, basePath, trailingSlash, hadBasePath) {
+	const url = new URL(request.url);
+	let mwRequest = request.body && !request.bodyUsed ? request.clone() : request;
+	const mwPathname = basePath && hadBasePath ? addBasePathToPathname(normalizedPathname, basePath) : normalizedPathname;
+	if (mwPathname !== url.pathname) {
+		const mwUrl = new URL(url);
+		mwUrl.pathname = mwPathname;
+		mwRequest = new Request(mwUrl, mwRequest);
+	}
+	const nextConfig = basePath || i18nConfig || trailingSlash ? {
+		basePath: basePath ?? "",
+		i18n: i18nConfig ?? void 0,
+		trailingSlash: trailingSlash ?? void 0
+	} : void 0;
+	return mwRequest instanceof NextRequest ? mwRequest : new NextRequest(mwRequest, nextConfig ? { nextConfig } : void 0);
+}
+async function executeMiddleware(options) {
+	const middlewareFn = resolveMiddlewareModuleHandler(options.module, {
+		filePath: options.filePath,
+		isProxy: options.isProxy
+	});
+	const normalizedPathname = options.normalizedPathname ?? resolveMiddlewarePathname(options.request);
+	if (normalizedPathname instanceof Response) return {
+		continue: false,
+		response: normalizedPathname
+	};
+	const hadBasePath = options.hadBasePath ?? (!options.basePath || hasBasePath(new URL(options.request.url).pathname, options.basePath));
+	const matchPathname = options.basePath ? stripBasePath(normalizedPathname, options.basePath) : normalizedPathname;
+	if (!matchesMiddleware(matchPathname, middlewareMatcher(options.module), options.request, options.i18nConfig)) return { continue: true };
+	const nextRequest = createNextRequest(options.request, normalizedPathname, options.i18nConfig, options.basePath, options.trailingSlash, hadBasePath);
+	const fetchEvent = new NextFetchEvent({ page: removeTrailingSlash(matchPathname) });
+	let response;
+	try {
+		response = await middlewareFn(nextRequest, fetchEvent);
+	} catch (e) {
+		console.error("[vinext] Middleware error:", e);
+		const waitUntilPromises = drainFetchEvent(fetchEvent);
+		return {
+			continue: false,
+			response: internalServerErrorResponse(options.includeErrorDetails ? "Middleware Error: " + (e instanceof Error ? e.message : String(e)) : "Internal Server Error"),
+			waitUntilPromises
+		};
+	} finally {
+		if (process.env.NODE_ENV !== "development" && nextRequest.body) nextRequest.body.cancel().catch(() => {});
+	}
+	const waitUntilPromises = drainFetchEvent(fetchEvent);
+	if (!response) return {
+		continue: true,
+		waitUntilPromises
+	};
+	if (response.headers.get("x-middleware-next") === "1") return {
+		continue: true,
+		responseHeaders: collectMiddlewareHeaders(response),
+		status: response.status !== 200 ? response.status : void 0,
+		waitUntilPromises
+	};
+	if (response.status >= 300 && response.status < 400) {
+		const location = response.headers.get("Location") ?? response.headers.get("location");
+		if (location) {
+			const relativeLocation = relativizeLocation(location, options.request.url);
+			let normalizedLocation = relativeLocation;
+			if (options.trailingSlash !== void 0) try {
+				const loc = new URL(relativeLocation, options.request.url);
+				if (loc.origin === new URL(options.request.url).origin) {
+					const p = loc.pathname;
+					let normalized = null;
+					if (p !== "" && p !== "/") if (options.trailingSlash) normalized = p.endsWith("/") ? null : p + "/";
+					else normalized = p.endsWith("/") ? p.slice(0, -1) : null;
+					if (normalized !== null) normalizedLocation = normalized + loc.search + loc.hash;
+				}
+			} catch {}
+			if (options.isDataRequest) return {
+				continue: false,
+				response: dataRedirectResponse(normalizedLocation, response),
+				waitUntilPromises
+			};
+			const responseHeaders = new Headers();
+			for (const [key, value] of response.headers) if (!key.startsWith("x-middleware-") && key.toLowerCase() !== "location") responseHeaders.append(key, value);
+			const relativizedResponseHeaders = new Headers(response.headers);
+			relativizedResponseHeaders.set("Location", normalizedLocation);
+			const relativizedResponse = new Response(response.body, {
+				status: response.status,
+				statusText: response.statusText,
+				headers: relativizedResponseHeaders
+			});
+			return {
+				continue: false,
+				redirectUrl: normalizedLocation,
+				redirectStatus: response.status,
+				response: stripMiddlewareHeadersFromResponse(relativizedResponse),
+				responseHeaders,
+				waitUntilPromises
+			};
+		}
+	}
+	const rewriteUrl = response.headers.get(MIDDLEWARE_REWRITE_HEADER);
+	if (rewriteUrl) {
+		let rewritePath;
+		try {
+			const rewriteParsed = new URL(rewriteUrl, options.request.url);
+			const requestOrigin = new URL(options.request.url).origin;
+			if (rewriteParsed.origin === requestOrigin) rewritePath = (options.basePath ? stripBasePath(rewriteParsed.pathname, options.basePath) : rewriteParsed.pathname) + rewriteParsed.search;
+			else rewritePath = rewriteParsed.href;
+		} catch {
+			rewritePath = rewriteUrl;
+		}
+		return {
+			continue: true,
+			rewriteUrl: rewritePath,
+			rewriteStatus: response.status !== 200 ? response.status : void 0,
+			responseHeaders: collectMiddlewareHeaders(response),
+			status: response.status !== 200 ? response.status : void 0,
+			waitUntilPromises
+		};
+	}
+	return {
+		continue: false,
+		response: stripMiddlewareHeadersFromResponse(response),
+		waitUntilPromises
+	};
+}
+async function runGeneratedMiddleware(options) {
+	const run = () => executeMiddleware(options);
+	return options.ctx ? runWithExecutionContext(options.ctx, run) : run();
+}
+//#endregion
+export { createMiddlewareMissingExportError, executeMiddleware, resolveMiddlewareModuleHandler, runGeneratedMiddleware };

package/dist/server/middleware.d.ts

@@ -0,0 +1,62 @@
+import { NextI18nConfig } from "../config/next-config.js";
+import { ValidFileMatcher } from "../routing/file-matcher.js";
+import { MiddlewareModule, MiddlewareResult } from "./middleware-runtime.js";
+import { matchPattern, matchesMiddleware } from "./middleware-matcher.js";
+import { ModuleRunner } from "vite/module-runner";
+
+//#region src/server/middleware.d.ts
+/**
+ * Determine whether a middleware/proxy file path refers to a proxy file.
+ * proxy.ts files accept `proxy` or `default` exports.
+ * middleware.ts files accept `middleware` or `default` exports.
+ *
+ * Matches Next.js behavior where each file type only accepts its own
+ * named export or a default export:
+ * https://github.com/vercel/next.js/blob/canary/packages/next/src/build/templates/middleware.ts
+ */
+declare function isProxyFile(filePath: string): boolean;
+/**
+ * Resolve the middleware/proxy handler function from a module's exports.
+ * Matches Next.js behavior: for proxy files, check `proxy` then `default`;
+ * for middleware files, check `middleware` then `default`.
+ *
+ * Throws if the file exists but doesn't export a valid function, matching
+ * Next.js's ProxyMissingExportError behavior.
+ *
+ * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/build/templates/middleware.ts
+ * @see https://github.com/vercel/next.js/blob/canary/test/e2e/app-dir/proxy-missing-export/proxy-missing-export.test.ts
+ */
+declare function resolveMiddlewareHandler(mod: MiddlewareModule, filePath: string): (request: NextRequest, event: NextFetchEvent) => Response | undefined | void | Promise<Response | undefined | void>;
+/**
+ * Find the proxy or middleware file at the selected app/pages convention level.
+ * Checks for proxy.ts (Next.js 16) first, then falls back to middleware.ts.
+ * If middleware.ts is found, logs a deprecation warning.
+ *
+ * Note on log noise: this function is called from Vite's `config` hook, which
+ * fires once per build environment (RSC, SSR, client, …). That means a project
+ * still using `middleware.ts` will see this warning emitted 2–3 times per
+ * build. The warning is benign — it does not abort the build. Next.js itself
+ * emits the same message via `Log.warnOnce`; matching that parity would
+ * require either a per-root deduplication map or hoisting the warning out of
+ * this function (e.g. into the plugin's `configResolved` hook). Tracked as a
+ * follow-up; see the deploy-suite investigation in run 25870737355.
+ *
+ * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/build/index.ts
+ *   (search for "MIDDLEWARE_FILENAME" + "file convention is deprecated")
+ */
+declare function findMiddlewareFile(root: string, fileMatcher: ValidFileMatcher, conventionDir?: string): string | null;
+/**
+ * Load and execute middleware for a given request.
+ *
+ * @param runner - A ModuleRunner used to load the middleware module.
+ *   Must be a long-lived instance created once (e.g. in configureServer) via
+ *   createDirectRunner() — NOT recreated per request. Using server.ssrLoadModule
+ *   directly crashes with `outsideEmitter` when @cloudflare/vite-plugin is
+ *   present because SSRCompatModuleRunner reads environment.hot.api synchronously.
+ * @param middlewarePath - Absolute path to the middleware file
+ * @param request - The incoming Request object
+ * @returns Middleware result describing what action to take
+ */
+declare function runMiddleware(runner: ModuleRunner, middlewarePath: string, request: Request, i18nConfig?: NextI18nConfig | null, basePath?: string, trailingSlash?: boolean, isDataRequest?: boolean): Promise<MiddlewareResult>;
+//#endregion
+export { findMiddlewareFile, isProxyFile, matchPattern, matchesMiddleware, resolveMiddlewareHandler, runMiddleware };

package/dist/server/middleware.js

@@ -0,0 +1,114 @@
+import { matchPattern, matchesMiddleware } from "./middleware-matcher.js";
+import { resolveMiddlewareModuleHandler, runGeneratedMiddleware } from "./middleware-runtime.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/server/middleware.ts
+/**
+* Determine whether a middleware/proxy file path refers to a proxy file.
+* proxy.ts files accept `proxy` or `default` exports.
+* middleware.ts files accept `middleware` or `default` exports.
+*
+* Matches Next.js behavior where each file type only accepts its own
+* named export or a default export:
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/build/templates/middleware.ts
+*/
+function isProxyFile(filePath) {
+	const base = path.basename(filePath);
+	return base === "proxy" || base.startsWith("proxy.");
+}
+/**
+* Resolve the middleware/proxy handler function from a module's exports.
+* Matches Next.js behavior: for proxy files, check `proxy` then `default`;
+* for middleware files, check `middleware` then `default`.
+*
+* Throws if the file exists but doesn't export a valid function, matching
+* Next.js's ProxyMissingExportError behavior.
+*
+* @see https://github.com/vercel/next.js/blob/canary/packages/next/src/build/templates/middleware.ts
+* @see https://github.com/vercel/next.js/blob/canary/test/e2e/app-dir/proxy-missing-export/proxy-missing-export.test.ts
+*/
+function resolveMiddlewareHandler(mod, filePath) {
+	return resolveMiddlewareModuleHandler(mod, {
+		filePath,
+		isProxy: isProxyFile(filePath)
+	});
+}
+/**
+* Find the proxy or middleware file at the selected app/pages convention level.
+* Checks for proxy.ts (Next.js 16) first, then falls back to middleware.ts.
+* If middleware.ts is found, logs a deprecation warning.
+*
+* Note on log noise: this function is called from Vite's `config` hook, which
+* fires once per build environment (RSC, SSR, client, …). That means a project
+* still using `middleware.ts` will see this warning emitted 2–3 times per
+* build. The warning is benign — it does not abort the build. Next.js itself
+* emits the same message via `Log.warnOnce`; matching that parity would
+* require either a per-root deduplication map or hoisting the warning out of
+* this function (e.g. into the plugin's `configResolved` hook). Tracked as a
+* follow-up; see the deploy-suite investigation in run 25870737355.
+*
+* @see https://github.com/vercel/next.js/blob/canary/packages/next/src/build/index.ts
+*   (search for "MIDDLEWARE_FILENAME" + "file convention is deprecated")
+*/
+function findMiddlewareFile(root, fileMatcher, conventionDir = root) {
+	let proxyPath = null;
+	for (const ext of fileMatcher.dottedExtensions) {
+		const fullPath = path.join(conventionDir, `proxy${ext}`);
+		if (fs.existsSync(fullPath)) {
+			proxyPath = fullPath;
+			break;
+		}
+	}
+	let middlewarePath = null;
+	for (const ext of fileMatcher.dottedExtensions) {
+		const fullPath = path.join(conventionDir, `middleware${ext}`);
+		if (fs.existsSync(fullPath)) {
+			middlewarePath = fullPath;
+			break;
+		}
+	}
+	if (proxyPath && middlewarePath) {
+		const relativeProxyPath = `./${path.relative(root, proxyPath)}`;
+		const relativeMiddlewarePath = `./${path.relative(root, middlewarePath)}`;
+		throw new Error(`Both middleware file "${relativeMiddlewarePath}" and proxy file "${relativeProxyPath}" are detected. Please use "${relativeProxyPath}" only. Learn more: https://nextjs.org/docs/messages/middleware-to-proxy`);
+	}
+	if (proxyPath) return proxyPath;
+	if (middlewarePath) {
+		console.warn("The \"middleware\" file convention is deprecated. Please use \"proxy\" instead.\n\n  To migrate automatically, run:\n  npx @next/codemod@canary middleware-to-proxy .\n\n  Learn more: https://nextjs.org/docs/messages/middleware-to-proxy");
+		return middlewarePath;
+	}
+	return null;
+}
+function isMiddlewareModule(value) {
+	return !!value && typeof value === "object";
+}
+/**
+* Load and execute middleware for a given request.
+*
+* @param runner - A ModuleRunner used to load the middleware module.
+*   Must be a long-lived instance created once (e.g. in configureServer) via
+*   createDirectRunner() — NOT recreated per request. Using server.ssrLoadModule
+*   directly crashes with `outsideEmitter` when @cloudflare/vite-plugin is
+*   present because SSRCompatModuleRunner reads environment.hot.api synchronously.
+* @param middlewarePath - Absolute path to the middleware file
+* @param request - The incoming Request object
+* @returns Middleware result describing what action to take
+*/
+async function runMiddleware(runner, middlewarePath, request, i18nConfig, basePath, trailingSlash, isDataRequest) {
+	const mod = await runner.import(middlewarePath);
+	if (!isMiddlewareModule(mod)) throw new Error(`Middleware module "${middlewarePath}" did not evaluate to an object.`);
+	return runGeneratedMiddleware({
+		basePath,
+		filePath: middlewarePath,
+		hadBasePath: true,
+		i18nConfig,
+		includeErrorDetails: process.env.NODE_ENV !== "production",
+		isDataRequest,
+		isProxy: isProxyFile(middlewarePath),
+		module: mod,
+		request,
+		trailingSlash
+	});
+}
+//#endregion
+export { findMiddlewareFile, isProxyFile, matchPattern, matchesMiddleware, resolveMiddlewareHandler, runMiddleware };