vinext 1.0.1 → 1.1.0

package/dist/plugins/commonjs-esm-facade.js

@@ -0,0 +1,80 @@
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/commonjs-esm-facade.ts
+const EXPORT_FACADE_START = "/* [vite-plugin-commonjs] export-statement-S */";
+const EXPORT_FACADE_END = "/* [vite-plugin-commonjs] export-statement-E */";
+const EXPORT_KEYWORD_RE = /\bexport\b(?!-)/;
+/** Whether `code` has a top-level ESM export statement. */
+function hasEsmExports(code) {
+	if (!EXPORT_KEYWORD_RE.test(code)) return false;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		return false;
+	}
+	return ast.body.some((statement) => statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" || statement.type === "ExportAllDeclaration");
+}
+/**
+* Removes the export facade vite-plugin-commonjs appended to `output` when the
+* module it transformed is ESM. Returns `undefined` when there is nothing to
+* remove.
+*
+* Next.js treats a module with ESM syntax as ESM: `require()` still works, but
+* `module` / `exports` never become its exports. The plugin's analyzer is not
+* scope-aware, so for bundled ESM that inlines CommonJS wrappers
+* (`__commonJS((exports, module) => …)`) it exports the wrappers' assignments
+* too, which duplicates the module's own exports. Its `require()` rewrite and
+* its local `module` / `exports` polyfill stay, so free CommonJS assignments
+* still run without becoming exports.
+*
+* Besides the facade, the plugin only prepends imports and its polyfill and
+* rewrites `require()` calls, so the module's own top-level exports are still
+* in `output`. Classifying the output rather than rereading the source keeps
+* the decision tied to the exact code the plugin transformed.
+*
+* The facade is appended after the module's code (only dynamic-require
+* runtimes, which have no source mappings, may follow it), so removing it
+* leaves the plugin's source map valid.
+*/
+function stripEsmCommonJsExportFacade(output) {
+	const facade = findEsmCommonJsExportFacade(output);
+	return facade && output.slice(0, facade[0]) + output.slice(facade[1]);
+}
+/** The `[start, end)` range of the facade {@link stripEsmCommonJsExportFacade} removes. */
+function findEsmCommonJsExportFacade(output) {
+	const start = output.lastIndexOf(EXPORT_FACADE_START);
+	if (start === -1) return void 0;
+	const end = output.indexOf(EXPORT_FACADE_END, start);
+	if (end === -1) return void 0;
+	const facadeEnd = end + 47;
+	return hasEsmExports(output.slice(0, start) + output.slice(facadeEnd)) ? [start, facadeEnd] : void 0;
+}
+/**
+* Applies {@link stripEsmCommonJsExportFacade} in the client dependency
+* optimizer's Rolldown builds (scan and pre-bundle). vite-plugin-commonjs's
+* pre-bundle plugin loads and converts files there without vinext's transform
+* wrapper, so its output reaches this hook as the loaded code. That code is
+* the optimizer's source, so the removal needs its own map for anything the
+* plugin appended after the facade.
+*/
+const commonJsEsmFacadeOptimizeDepsPlugin = {
+	name: "vinext:commonjs-esm-facade:optimize-deps",
+	transform: {
+		filter: { code: { include: EXPORT_FACADE_START } },
+		handler(code, id) {
+			const facade = findEsmCommonJsExportFacade(code);
+			if (!facade) return null;
+			const output = new MagicString(code).remove(facade[0], facade[1]);
+			return {
+				code: output.toString(),
+				map: output.generateMap({
+					source: id,
+					hires: "boundary"
+				})
+			};
+		}
+	}
+};
+//#endregion
+export { commonJsEsmFacadeOptimizeDepsPlugin, stripEsmCommonJsExportFacade };

package/dist/plugins/fonts.d.ts

@@ -3,9 +3,10 @@ import { Plugin } from "vite";
 export declare const VIRTUAL_GOOGLE_FONTS = "virtual:vinext-google-fonts";
 export declare const RESOLVED_VIRTUAL_GOOGLE_FONTS: string;
 /**
- * Rewrite absolute filesystem paths in cached Google Fonts CSS so the
- * `@font-face { src: url(...) }` references point at the served URL the
- * plugin's `writeBundle` hook copies the font files to.
+ * Point the `@font-face { src: url(...) }` references of cached Google Fonts
+ * CSS at the served URL the plugin's `writeBundle` hook copies the font
+ * files to (and the dev middleware serves them from), by replacing
+ * `CACHED_FONT_DIR_TOKEN` with `/<assetsDir>/_vinext_fonts`.
  *
  * This is called once per transform, before the CSS string is embedded in
  * the bundle as `_vinext.font.selfHostedCSS`. Every downstream consumer reads
@@ -14,9 +15,9 @@ export declare const RESOLVED_VIRTUAL_GOOGLE_FONTS: string;
  * in `shims/font-google-base.ts`), and the HTTP `Link:` response header
  * (via `buildAppPageFontLinkHeader` in `server/app-page-execution.ts`).
  *
- * Without this rewrite, all three emit the dev-machine filesystem path
- * (e.g. `/home/user/project/.vinext/fonts/geist-<hash>/geist-<hash>.woff2`)
- * and any production request fetches `<origin>/home/user/...` → 404.
+ * The token is substituted with plain split/join: it is a fixed string
+ * vinext wrote itself, so nothing about the checkout's path (spaces, quotes,
+ * parentheses, regex metacharacters, Windows separators) is parsed here.
  *
  * `assetsDir` must match whatever Vite has resolved for
  * `build.assetsDir` on the client environment — otherwise the embedded
@@ -26,12 +27,8 @@ export declare const RESOLVED_VIRTUAL_GOOGLE_FONTS: string;
  * passes the resolved value through from plugin state. The default is
  * kept only so the exported helper can be driven directly from unit
  * tests without synthesizing a full plugin context.
- *
- * Uses split/join rather than regex because `cacheDir` is an absolute
- * filesystem path that may contain regex metacharacters on unusual
- * filesystems.
  */
-export declare function _rewriteCachedFontCssToServedUrls(css: string, cacheDir: string, assetsDir?: string): string;
+export declare function _rewriteCachedFontCssToServedUrls(css: string, assetsDir?: string): string;
 /**
  * Safely parse a static JS object literal string into a plain object.
  * Uses Vite's parseAst (Rollup/acorn) so no code is ever evaluated.

package/dist/plugins/fonts.js

@@ -43,15 +43,15 @@ const GOOGLE_FONT_UTILITY_EXPORTS = /* @__PURE__ */ new Set([
 /**
 * Served URL prefix for self-hosted Google Font files.
 *
-* `fetchAndCacheFont()` downloads .woff2 files into `<root>/.vinext/fonts/`
+* `fetchAndCacheFont()` downloads font files into `<root>/.vinext/fonts/`
 * and writes an `@font-face` CSS snippet whose `src: url(...)` references
-* the files by absolute filesystem path — convenient for disk, unusable at
-* runtime because browsers resolve relative to the origin. Before the CSS
-* is embedded in the bundle as `_vinext.font.selfHostedCSS`, the filesystem
-* prefix is rewritten to this URL prefix by `_rewriteCachedFontCssToServedUrls()`,
-* and the matching `writeBundle` hook in `createGoogleFontsPlugin` copies
-* the font files into `<clientOutDir>/<assetsDir>/_vinext_fonts/` so the
-* rewritten URL actually resolves against the origin at request time.
+* name each file relative to that cache directory, behind
+* `CACHED_FONT_DIR_TOKEN`. Before the CSS is embedded in the bundle as
+* `_vinext.font.selfHostedCSS`, `_rewriteCachedFontCssToServedUrls()`
+* replaces the token with this URL prefix, and the matching `writeBundle`
+* hook in `createGoogleFontsPlugin` copies the font files into
+* `<clientOutDir>/<assetsDir>/_vinext_fonts/` so the URL actually resolves
+* against the origin at request time.
 *
 * The leading `_` keeps the namespace distinct from Vite's content-hashed
 * asset names (which are emitted flat into `<assetsDir>/`) and from any
@@ -59,6 +59,25 @@ const GOOGLE_FONT_UTILITY_EXPORTS = /* @__PURE__ */ new Set([
 */
 const VINEXT_FONT_URL_NAMESPACE = "_vinext_fonts";
 const MAX_GOOGLE_FONTS_ERROR_BODY_LENGTH = 500;
+/**
+* Stands in for the font cache directory in every `url()` of a cached
+* stylesheet, so the file on disk holds no absolute path and reads the same
+* wherever the checkout's `.vinext/` ends up: a moved or copied project, a
+* CI cache restored into another workspace, or a Docker build that copies
+* in a host's `.vinext/`. Next.js has no such cache (its Google font loader
+* keeps fetched CSS in memory and emits `/_next/static/media` URLs), so the
+* parity target is output that does not depend on where the cache was
+* written.
+*/
+const CACHED_FONT_DIR_TOKEN = "__VINEXT_FONT_CACHE_DIR__";
+/**
+* Cached stylesheet whose `url()` references use `CACHED_FONT_DIR_TOKEN`.
+* The suffix ties the cache to that format: a `style.css` written by an
+* earlier vinext holds the writing checkout's absolute paths, which would
+* 404 once embedded, so it is never read and the font is fetched again.
+* Change the suffix whenever the cached CSS format changes.
+*/
+const CACHED_FONT_CSS_FILE = "style-q7f3kd.css";
 function formatGoogleFontsErrorBody(body) {
 	const trimmed = body.trim();
 	if (!trimmed) return "(empty response body)";
@@ -67,9 +86,10 @@ function formatGoogleFontsErrorBody(body) {
 	return `${trimmed.slice(0, MAX_GOOGLE_FONTS_ERROR_BODY_LENGTH)}\n... (truncated ${omitted} characters)`;
 }
 /**
-* Rewrite absolute filesystem paths in cached Google Fonts CSS so the
-* `@font-face { src: url(...) }` references point at the served URL the
-* plugin's `writeBundle` hook copies the font files to.
+* Point the `@font-face { src: url(...) }` references of cached Google Fonts
+* CSS at the served URL the plugin's `writeBundle` hook copies the font
+* files to (and the dev middleware serves them from), by replacing
+* `CACHED_FONT_DIR_TOKEN` with `/<assetsDir>/_vinext_fonts`.
 *
 * This is called once per transform, before the CSS string is embedded in
 * the bundle as `_vinext.font.selfHostedCSS`. Every downstream consumer reads
@@ -78,9 +98,9 @@ function formatGoogleFontsErrorBody(body) {
 * in `shims/font-google-base.ts`), and the HTTP `Link:` response header
 * (via `buildAppPageFontLinkHeader` in `server/app-page-execution.ts`).
 *
-* Without this rewrite, all three emit the dev-machine filesystem path
-* (e.g. `/home/user/project/.vinext/fonts/geist-<hash>/geist-<hash>.woff2`)
-* and any production request fetches `<origin>/home/user/...` → 404.
+* The token is substituted with plain split/join: it is a fixed string
+* vinext wrote itself, so nothing about the checkout's path (spaces, quotes,
+* parentheses, regex metacharacters, Windows separators) is parsed here.
 *
 * `assetsDir` must match whatever Vite has resolved for
 * `build.assetsDir` on the client environment — otherwise the embedded
@@ -90,16 +110,9 @@ function formatGoogleFontsErrorBody(body) {
 * passes the resolved value through from plugin state. The default is
 * kept only so the exported helper can be driven directly from unit
 * tests without synthesizing a full plugin context.
-*
-* Uses split/join rather than regex because `cacheDir` is an absolute
-* filesystem path that may contain regex metacharacters on unusual
-* filesystems.
 */
-function _rewriteCachedFontCssToServedUrls(css, cacheDir, assetsDir = DEFAULT_ASSETS_DIR) {
-	const normalizedCacheDir = toSlash(cacheDir);
-	if (!normalizedCacheDir || !css.includes(normalizedCacheDir)) return css;
-	const prefix = assetsDir || DEFAULT_ASSETS_DIR;
-	return css.split(normalizedCacheDir).join(`/${prefix}/${VINEXT_FONT_URL_NAMESPACE}`);
+function _rewriteCachedFontCssToServedUrls(css, assetsDir = DEFAULT_ASSETS_DIR) {
+	return css.split(CACHED_FONT_DIR_TOKEN).join(`/${assetsDir || DEFAULT_ASSETS_DIR}/${VINEXT_FONT_URL_NAMESPACE}`);
 }
 /**
 * Default `build.assetsDir` — matches vinext's resolved default in
@@ -274,24 +287,49 @@ function propertyNameToGoogleFontFamily(prop) {
 }
 /**
 * Fetch Google Fonts CSS, download .woff2 files, cache locally, and return
-* @font-face CSS with local file references.
+* @font-face CSS whose `url()` references use `CACHED_FONT_DIR_TOKEN`.
 *
 * Cache dir structure: .vinext/fonts/<family-hash>/
-*   - style.css (the rewritten @font-face CSS)
+*   - style-<suffix>.css (the rewritten @font-face CSS, see `CACHED_FONT_CSS_FILE`)
 *   - *.woff2 (downloaded font files)
 */
 async function fetchAndCacheFont(cssUrl, family, cacheDir) {
 	const { createHash } = await import("node:crypto");
 	const urlHash = createHash("md5").update(cssUrl).digest("hex").slice(0, 12);
-	const fontDir = path.join(cacheDir, `${family.toLowerCase().replace(/\s+/g, "-")}-${urlHash}`);
-	const cachedCSSPath = path.join(fontDir, "style.css");
+	const fontDirName = `${family.toLowerCase().replace(/\s+/g, "-")}-${urlHash}`;
+	const fontDir = path.join(cacheDir, fontDirName);
+	const cachedCSSPath = path.join(fontDir, CACHED_FONT_CSS_FILE);
 	if (fs.existsSync(cachedCSSPath)) return fs.readFileSync(cachedCSSPath, "utf-8");
+	const css = await downloadGoogleFont(cssUrl, family, fontDir, fontDirName);
+	try {
+		writeFileAtomically(cachedCSSPath, css);
+	} catch {}
+	return css;
+}
+/**
+* Write-then-rename, so a write that fails midway never leaves a partial
+* file for a later build to trust: both font files and the stylesheet are
+* reused as soon as they exist.
+*/
+function writeFileAtomically(filePath, data) {
+	const tempPath = `${filePath}.${process.pid}.tmp`;
+	try {
+		fs.writeFileSync(tempPath, data);
+		fs.renameSync(tempPath, filePath);
+	} catch (err) {
+		fs.rmSync(tempPath, { force: true });
+		throw err;
+	}
+}
+async function downloadGoogleFont(cssUrl, family, fontDir, fontDirName) {
+	const { createHash } = await import("node:crypto");
 	const cssResponse = await fetch(cssUrl, { headers: { "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36" } });
 	if (!cssResponse.ok) {
 		const body = await cssResponse.text().catch(() => "");
 		throw new GoogleFontsHttpError(cssUrl, cssResponse.status, body);
 	}
 	let css = await cssResponse.text();
+	if (!css.trim()) throw new Error(`Google Fonts returned an empty stylesheet: ${cssUrl}`);
 	const urlRe = /url\((https:\/\/fonts\.gstatic\.com\/[^)]+)\)/g;
 	const urls = /* @__PURE__ */ new Map();
 	let urlMatch;
@@ -308,14 +346,13 @@ async function fetchAndCacheFont(cssUrl, family, cacheDir) {
 		const filePath = path.join(fontDir, filename);
 		if (!fs.existsSync(filePath)) {
 			const fontResponse = await fetch(fontUrl);
-			if (fontResponse.ok) {
-				const buffer = Buffer.from(await fontResponse.arrayBuffer());
-				fs.writeFileSync(filePath, buffer);
-			}
+			if (!fontResponse.ok) throw new Error(`Font file download failed with HTTP ${fontResponse.status}: ${fontUrl}`);
+			const buffer = Buffer.from(await fontResponse.arrayBuffer());
+			if (buffer.byteLength === 0) throw new Error(`Font file download returned an empty body: ${fontUrl}`);
+			writeFileAtomically(filePath, buffer);
 		}
-		css = css.split(fontUrl).join(filePath);
+		css = css.split(fontUrl).join(`${CACHED_FONT_DIR_TOKEN}/${fontDirName}/${filename}`);
 	}
-	fs.writeFileSync(cachedCSSPath, css);
 	return css;
 }
 /**
@@ -546,7 +583,7 @@ function createGoogleFontsPlugin(fontGoogleShimPath, shimsDir) {
 						if (err instanceof GoogleFontsHttpError) throw new Error(`[vinext:google-fonts] ${id}: Google Fonts returned HTTP ${err.status} for ${err.url}.\n${formatGoogleFontsErrorBody(err.responseBody)}`);
 						return;
 					}
-					const servedCSS = _rewriteCachedFontCssToServedUrls(localCSS, cacheDir, transformAssetsDir);
+					const servedCSS = _rewriteCachedFontCssToServedUrls(localCSS, transformAssetsDir);
 					const preloadUrls = findFontFilesInCss(servedCSS, validated.preload ? validated.subsets : void 0).filter((file) => file.preloadFontFile).map((file) => file.googleFontFileUrl);
 					const fallbackMetrics = validated.adjustFontFallback === false ? void 0 : getFallbackFontOverrideMetrics(family);
 					const adjustedFallbackCSS = fallbackMetrics ? buildFallbackFontFace(family, fallbackMetrics) : void 0;

package/dist/routing/file-matcher.d.ts

@@ -1,4 +1,5 @@
 //#region src/routing/file-matcher.d.ts
+export declare const DEFAULT_PAGE_EXTENSIONS: readonly ["tsx", "ts", "jsx", "js"];
 export declare function normalizePageExtensions(pageExtensions?: readonly string[] | null): string[];
 export type ValidFileMatcher = {
   extensions: string[];

package/dist/routing/file-matcher.js

@@ -152,4 +152,4 @@ async function* scanWithExtensions(stem, cwd, extensions, exclude) {
 	})) yield toSlash(file);
 }
 //#endregion
-export { buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };
+export { DEFAULT_PAGE_EXTENSIONS, buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };

package/dist/server/api-handler.js

@@ -11,6 +11,7 @@ import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { attachPagesPreviewApi, attachPagesRequestCookies } from "./pages-node-compat.js";
 import { finalizeEdgeApiResponse, isEdgeApiRuntime } from "./edge-api-runtime.js";
+import { signalFromNodeResponse } from "./node-response-signal.js";
 import { Buffer } from "node:buffer";
 import { decode } from "node:querystring";
 //#region src/server/api-handler.ts
@@ -89,7 +90,7 @@ function readEdgeRequestBody(req) {
 		req.on("error", (error) => controller.error(error));
 	} });
 }
-function createEdgeApiRequest(req, url, params, nextConfig) {
+function createEdgeApiRequest(req, res, url, params, nextConfig) {
 	const headers = new Headers();
 	for (const [name, value] of Object.entries(req.headers)) {
 		if (name.startsWith(":")) continue;
@@ -103,10 +104,12 @@ function createEdgeApiRequest(req, url, params, nextConfig) {
 	if (basePath && !hasBasePath(requestUrl.pathname, basePath)) requestUrl.pathname = `${basePath}${requestUrl.pathname}`;
 	const query = mergeRouteParamsIntoQuery(parseQueryString(url), params);
 	requestUrl.search = urlQueryToSearchParams(query).toString();
-	const body = readEdgeRequestBody(req);
+	const signal = signalFromNodeResponse(res);
+	const body = signal.aborted ? void 0 : readEdgeRequestBody(req);
 	const init = {
 		headers,
-		method: req.method
+		method: req.method,
+		signal
 	};
 	if (body) {
 		init.body = body;
@@ -138,12 +141,17 @@ function waitForWritableDrain(res) {
 		res.once("close", onClose);
 	});
 }
-async function writeEdgeApiResponseBody(res, body) {
+async function writeEdgeApiResponseBody(res, body, signal) {
 	if (!body) {
 		res.end();
 		return;
 	}
 	const reader = body.getReader();
+	const cancel = () => {
+		reader.cancel(signal.reason).catch(() => {});
+	};
+	if (signal.aborted) cancel();
+	else signal.addEventListener("abort", cancel, { once: true });
 	try {
 		while (true) {
 			const result = await reader.read();
@@ -151,11 +159,13 @@ async function writeEdgeApiResponseBody(res, body) {
 			if (result.value.byteLength === 0) continue;
 			if (!res.write(Buffer.from(result.value))) await waitForWritableDrain(res);
 		}
-		res.end();
+		if (!signal.aborted) res.end();
 	} catch (error) {
+		if (signal.aborted) return;
 		res.destroy(error instanceof Error ? error : new Error(String(error)));
 		throw error;
 	} finally {
+		signal.removeEventListener("abort", cancel);
 		reader.releaseLock();
 	}
 }
@@ -224,7 +234,7 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 	try {
 		const apiModule = await importModule(runner, route.filePath);
 		if (isEdgeApiRouteModule(apiModule)) {
-			const nextRequest = new NextRequest(createEdgeApiRequest(req, url, params, nextConfig), nextConfig ? { nextConfig: {
+			const nextRequest = new NextRequest(createEdgeApiRequest(req, res, url, params, nextConfig), nextConfig ? { nextConfig: {
 				basePath: nextConfig.basePath,
 				i18n: nextConfig.i18n ?? void 0,
 				trailingSlash: nextConfig.trailingSlash
@@ -239,7 +249,7 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 				if (name !== "set-cookie") res.setHeader(name, value);
 			});
 			if (setCookieHeaders.length) res.setHeader("set-cookie", setCookieHeaders);
-			await writeEdgeApiResponseBody(res, response.body);
+			await writeEdgeApiResponseBody(res, response.body, nextRequest.signal);
 			return true;
 		}
 		const handler = apiModule.default;

package/dist/server/app-browser-entry.js

@@ -1,12 +1,12 @@
 import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { addBasePathToPathname, stripBasePath } from "../utils/base-path.js";
 import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
-import { AppElementsWire } from "./app-elements-wire.js";
-import { getMountedSlotIdsHeader, resolveVisitedResponseInterceptionContext } from "./app-elements.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
 import { matchRoutePattern } from "../routing/route-pattern.js";
 import { installWindowNext, setWindowNextInternalSourcePage } from "../client/window-next.js";
 import { retryScrollTo, scrollToHashTargetOnNextFrame } from "../shims/hash-scroll.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import { getMountedSlotIdsHeader, resolveVisitedResponseInterceptionContext } from "./app-elements.js";
 import { getBfcacheIdMapContext, getNavigationContext, setNavigationContext } from "../shims/navigation-context-state.js";
 import { decodeRedirectError, isRedirectError } from "../shims/navigation-errors.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
@@ -362,22 +362,22 @@ function createActionInitiationSnapshot() {
 }
 function createNavigationCommitEffect(options) {
 	const { activeRoutePaths, bfcacheIds, href, historyUpdateMode, navId, params, previousNextUrl, targetHistoryIndex } = options;
-	return () => {
+	return ({ keepCurrentUrl, releaseSnapshot }) => {
 		if (!browserNavigationController.isCurrentNavigation(navId)) {
-			commitClientNavigationState(void 0, { releaseSnapshot: true });
+			commitClientNavigationState(void 0, { releaseSnapshot });
 			return;
 		}
 		historyController.commitNavigationHistory({
 			activeRoutePaths,
 			bfcacheIds,
 			href,
-			historyUpdateMode,
+			historyUpdateMode: keepCurrentUrl ? void 0 : historyUpdateMode,
 			previousNextUrl,
 			stageClientParams: () => stageClientParams(params),
 			targetHistoryIndex
 		});
 		clearAppNavigationFailureTarget(href);
-		commitClientNavigationState(navId);
+		commitClientNavigationState(navId, { releaseSnapshot });
 	};
 }
 async function renderNavigationPayload(options) {
@@ -1505,7 +1505,11 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 		},
 		preparePrefetchResponse: (response) => decodeAppElementsPromise(createFromFetch(Promise.resolve(response))),
 		claimCurrentHistoryTreeSnapshot: (historyUpdateMode, previousHistoryState) => historyController.claimCurrentHistoryTreeSnapshot(historyUpdateMode, previousHistoryState),
-		commitAppOwnedHistoryStateWrite: (historyUpdateMode, previousHistoryState) => historyController.commitAppOwnedHistoryStateWrite(historyUpdateMode, previousHistoryState)
+		commitAppOwnedHistoryStateWrite: (historyUpdateMode, previousHistoryState) => historyController.commitAppOwnedHistoryStateWrite(historyUpdateMode, previousHistoryState),
+		discardPendingNavigation: () => {
+			if (browserNavigationController.discardPendingNavigation(historyController.readCurrentTreeSnapshot())) navigationAbortCoordinator.abortActive();
+		},
+		flushCommittingNavigationUrl: () => browserNavigationController.flushCommittingNavigationUrl()
 	});
 	const handlePopstate = createPopstateRestoreHandler({
 		getActiveNavigationId: browserNavigationController.getActiveNavigationId.bind(browserNavigationController),

package/dist/server/app-browser-history-controller.d.ts

@@ -79,6 +79,8 @@ export declare class AppBrowserHistoryController {
   beginCacheInvalidationGuard(): () => void;
   invalidateRestorableClientState(): void;
   rememberHistoryStateSnapshot(state: AppRouterState): void;
+  /** The router state of the most recently committed render, if any. */
+  readCurrentTreeSnapshot(): AppRouterState | null;
   isCurrentExternalHistoryTree(historyState: unknown): boolean;
   /** Records the raw/hash history entry that now claims the live tree. */
   claimCurrentHistoryTreeSnapshot(historyUpdateMode: HistoryUpdateMode, previousHistoryState: unknown): void;

package/dist/server/app-browser-history-controller.js

@@ -96,6 +96,9 @@ var AppBrowserHistoryController = class {
 		this.#treeSnapshotIdPendingFreshState = historyTreeSnapshotId !== null && this.#treeSnapshots.has(historyTreeSnapshotId) ? historyTreeSnapshotId : null;
 	}
 	rememberHistoryStateSnapshot(state) {
+		const previousState = this.readCurrentTreeSnapshot();
+		const previousOperation = previousState?.activeOperation;
+		if (previousState && previousOperation?.navigationCommitKind === "detached" && state.activeOperation?.navigationCommitKind === "authoritative" && state.activeOperation.navigationId === previousOperation.navigationId) this.#restorableClientState.replaceHistoryStateSnapshots(previousState, state);
 		this.#restorableClientState.rememberHistoryStateSnapshot({
 			historyIndex: this.#currentHistoryTraversalIndex,
 			state
@@ -109,6 +112,11 @@ var AppBrowserHistoryController = class {
 		if (previousTreeSnapshotId !== null && previousTreeSnapshotId !== treeSnapshotId && !this.#treeSnapshotClaimCounts.has(previousTreeSnapshotId)) this.#treeSnapshots.delete(previousTreeSnapshotId);
 		if (historyTreeSnapshotId !== treeSnapshotId) this.#replaceHistoryState(createHistoryStateWithTreeSnapshotId(this.#readHistoryState(), treeSnapshotId));
 	}
+	/** The router state of the most recently committed render, if any. */
+	readCurrentTreeSnapshot() {
+		if (this.#currentTreeSnapshotId === null) return null;
+		return this.#treeSnapshots.get(this.#currentTreeSnapshotId) ?? null;
+	}
 	isCurrentExternalHistoryTree(historyState) {
 		const treeSnapshotId = readHistoryStateTreeSnapshotId(historyState);
 		return treeSnapshotId !== null && treeSnapshotId === this.#currentTreeSnapshotId;

package/dist/server/app-browser-interception-context.js

@@ -1,5 +1,6 @@
-import { splitPathnameForRouteMatch } from "../routing/utils.js";
+import { normalizePathnameForRouteMatch, splitPathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
+import { normalizePath } from "./normalize-path.js";
 import { matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments } from "../routing/route-pattern.js";
 //#region src/server/app-browser-interception-context.ts
 /**
@@ -37,9 +38,32 @@ function resolveMiddlewareRewriteNavigationInterceptionContext(options) {
 	for (const interception of options.routeManifest.segmentGraph.interceptions.values()) {
 		if (!matchRoutePatternWithOptionalDynamicSegments(targetParts, interception.targetPatternParts)) continue;
 		if (matchRoutePatternPrefix(sourceParts, interception.sourcePatternParts)) return currentPathname;
-		if (currentMatchedPathname !== null && matchedSourceParts !== null && matchRoutePatternPrefix(matchedSourceParts, interception.sourcePatternParts)) return currentMatchedPathname;
+		if (currentMatchedPathname !== null && matchedSourceParts !== null && matchRoutePatternPrefix(matchedSourceParts, interception.sourcePatternParts)) return encodeMatchedPathname(currentMatchedPathname);
 	}
 	return null;
 }
+/**
+* The matched route pathname is the matched URL decoded once per segment, with
+* path delimiters (and literal `%2F`-style text) re-escaped. The server matches
+* the context on its raw segments, so undo that: keep the escaped delimiters and
+* encode every other `%`, then let the URL parser encode the rest (`café`
+* becomes `caf%C3%A9`). An escaped ASCII character comes back unescaped (`%61`
+* as `a`), like Next.js's `Next-Url`, which it builds from the router tree's
+* canonical params; both spellings match the same params. `%252F` is
+* ambiguous, since both a literal `%2F` and a literal `%252F` produce it. That
+* case, and a result that does not reproduce the same matched pathname because
+* the URL parser changed it (stripping a control character, say), navigate
+* without interception instead of naming a different source.
+*/
+function encodeMatchedPathname(pathname) {
+	if (/%25(?:2f|23|3f|5c)/i.test(pathname)) return null;
+	let encoded;
+	try {
+		encoded = new URL(pathname.replace(/%(?!(?:25)?(?:2f|23|3f|5c))/gi, "%25"), "http://n").pathname;
+	} catch {
+		return null;
+	}
+	return normalizePath(normalizePathnameForRouteMatch(encoded)) === pathname ? encoded : null;
+}
 //#endregion
 export { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext };

package/dist/server/app-browser-navigation-controller.d.ts

@@ -17,7 +17,10 @@ export type PendingBrowserRouterState = {
 };
 export type NavigationPayloadOutcome = "committed" | "no-commit" | "hard-navigate";
 type HardNavigationMode = "assign" | "replace";
-type BrowserNavigationCommitEffect = () => void;
+type BrowserNavigationCommitEffect = (options: {
+  keepCurrentUrl: boolean;
+  releaseSnapshot: boolean;
+}) => void;
 type BrowserNavigationCommitEffectFactory = (options: {
   activeRoutePaths: readonly string[];
   bfcacheIds: Readonly<Record<string, string>>;
@@ -78,6 +81,8 @@ type BrowserNavigationController = {
   attachBrowserRouterState(setter: Dispatch<AppRouterState | Promise<AppRouterState>>, stateRef: BrowserRouterStateRef): () => void;
   beginPendingBrowserRouterState(): PendingBrowserRouterState;
   finalizeNavigation(navId: number, pending: PendingBrowserRouterState | null | undefined): void;
+  discardPendingNavigation(visibleState: AppRouterState | null): boolean;
+  flushCommittingNavigationUrl(): void;
   restoreHistorySnapshotVisibleState(options: {
     restoreCopiedExternalHistoryEntry?: boolean;
     beforeCommit?: () => void;
@@ -100,6 +105,7 @@ type BrowserNavigationController = {
    * navigation would otherwise be lost.
    */
   drainPrePaintEffects(renderId: number): void;
+  beginNavigationRenderCommit(renderId: number): void;
   commitNavigationRender(renderId: number): void;
   clearCommittedNavigationFailureTargets(renderId: number): void;
   NavigationCommitSignal(this: void, { renderId, children }: {