vinext 1.0.0 → 1.1.0

package/dist/plugins/typeof-window.js

@@ -1,13 +1,15 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { booleanLiteralValue, collectBindingNames, forEachAstChild, isIdentifierNamed, stringLiteralValue } from "./ast-utils.js";
+import { DYNAMIC_IMPORT_PRESCAN, booleanLiteralValue, collectBindingNames, forEachAstChild, isIdentifierNamed, stringLiteralValue } from "./ast-utils.js";
 import { magicStringTransformResult } from "./transform-result.js";
 import { stripViteModuleQuery } from "../utils/path.js";
 import { collectDirectScopeBindings, collectLoopScopeBindings, collectSwitchScopeBindings, collectVarScopeBindings, createAstScope, hasAstBinding, isFunctionNode } from "./ast-scope.js";
-import { parseAst } from "vite";
+import { parseSync } from "vite";
 import MagicString from "magic-string";
 //#region src/plugins/typeof-window.ts
 const sourceEscapePattern = /\\(?:\r\n|[\n\r\u2028\u2029]|[^\n\r\u2028\u2029])/;
 const consumerEnvironmentConditionFilter = new RegExp(String.raw`\btypeof\s+window\b|${/\\(?:u(?:[\da-fA-F]{4}|\{[\da-fA-F]+\})|x[\da-fA-F]{2})/.source}|\bprocess\b[\s)]*(?:(?:\?\.|\.)\s*(?:browser\b|\/[/*])|(?:\?\.\s*)?\[[\s(]*(?:["']browser["']|["'][^"'\\\n\r]*\\|\/[/*])|\/[/*])`);
+const SCANNED_IMPORT_FOLD_PRESCAN = new RegExp(String.raw`${DYNAMIC_IMPORT_PRESCAN.source}|\bimport\s*\.`);
+const NON_IMPORTING_IMPORT_META_RE = /\s*\.\s*(?:url|env)\b/y;
 function createChildScope(node, parent) {
 	if (node.type !== "Program" && node.type !== "BlockStatement" && node.type !== "StaticBlock" && node.type !== "TSModuleBlock" && node.type !== "CatchClause" && node.type !== "ForStatement" && node.type !== "ForInStatement" && node.type !== "ForOfStatement" && node.type !== "ClassDeclaration" && node.type !== "ClassExpression") return null;
 	const scope = createAstScope(parent);
@@ -110,6 +112,27 @@ function evaluateConsumerCondition(node, replacements, scope) {
 		effects: []
 	};
 }
+/**
+* Cheap pre-parse gate for import-scan builds. Over-inclusive by design; the
+* parser's module record in {@link moduleRecordHasScannedFoldTargets} is exact.
+*/
+function mayFoldChangeScannedImports(code) {
+	return SCANNED_IMPORT_FOLD_PRESCAN.test(code);
+}
+/**
+* Whether folding may change a scanned import: any dynamic or phase import, or
+* an `import.meta` expression other than a `.url`/`.env` read. Reads the parser's native module record, so no
+* ESTree is materialized.
+*/
+function moduleRecordHasScannedFoldTargets(code, module, lang) {
+	if ((lang === "ts" || lang === "tsx") && DYNAMIC_IMPORT_PRESCAN.test(code)) return true;
+	if (module.dynamicImports.length > 0) return true;
+	for (const importMeta of module.importMetas) {
+		NON_IMPORTING_IMPORT_META_RE.lastIndex = importMeta.end;
+		if (!NON_IMPORTING_IMPORT_META_RE.test(code)) return true;
+	}
+	return false;
+}
 function replaceTypeofWindow(code, replacement, id = "file.js") {
 	return replaceConsumerEnvironmentConditions(code, { typeofWindow: replacement }, id);
 }
@@ -119,12 +142,13 @@ function replaceConsumerEnvironmentConditions(code, replacements, id = "file.js"
 	if (!mayContainTypeofWindow && !mayContainProcessBrowser) return null;
 	const extension = path.extname(stripViteModuleQuery(id));
 	const lang = extension === ".ts" || extension === ".mts" || extension === ".cts" ? "ts" : extension === ".tsx" ? "tsx" : extension === ".jsx" ? "jsx" : "js";
-	let ast;
-	try {
-		ast = parseAst(code, { lang });
-	} catch {
-		return null;
-	}
+	const parsed = parseSync(id, code, {
+		lang,
+		preserveParens: false
+	});
+	if (parsed.errors.length > 0) return null;
+	if (replacements.onlyIfScannedImportsChange && !moduleRecordHasScannedFoldTargets(code, parsed.module, lang)) return null;
+	const ast = parsed.program;
 	const output = new MagicString(code);
 	let changed = false;
 	function overwriteGap(start, end, content) {
@@ -236,4 +260,4 @@ function replaceConsumerEnvironmentConditions(code, replacements, id = "file.js"
 	return magicStringTransformResult(output);
 }
 //#endregion
-export { consumerEnvironmentConditionFilter, getTypeofWindowReplacement, replaceConsumerEnvironmentConditions, replaceTypeofWindow };
+export { consumerEnvironmentConditionFilter, getTypeofWindowReplacement, mayFoldChangeScannedImports, replaceConsumerEnvironmentConditions, replaceTypeofWindow };

package/dist/routing/app-route-graph.d.ts

@@ -364,7 +364,6 @@ export type RouteManifest = {
   graphVersion: GraphVersion;
   segmentGraph: StaticSegmentGraph;
 };
-export declare function createAppRouteGraphInterceptionId(slotId: string, sourcePattern: string, targetPattern: string): string;
 /**
  * Build the App Router route graph by scanning `appDir`.
  */

package/dist/routing/app-route-graph.js

@@ -3,6 +3,7 @@ import { findFileWithExts, scanWithExtensions } from "./file-matcher.js";
 import { decodeRouteSegment, isInvisibleSegment, sortRoutes } from "./utils.js";
 import { validateRoutePatterns } from "./route-validation.js";
 import { compareStrings } from "../utils/compare.js";
+import { createAppRouteGraphInterceptionId } from "./app-route-ids.js";
 import fs from "node:fs";
 import { createHash } from "node:crypto";
 //#region src/routing/app-route-graph.ts
@@ -37,9 +38,6 @@ const SIBLING_INTERCEPT_SLOT_NAME = "__vinext_sibling_intercept";
 function createAppRouteGraphSiblingInterceptSlotId(sourcePattern) {
 	return createAppRouteGraphSlotId(SIBLING_INTERCEPT_SLOT_NAME, sourcePattern);
 }
-function createAppRouteGraphInterceptionId(slotId, sourcePattern, targetPattern) {
-	return `interception:${slotId}:${sourcePattern}->${targetPattern}`;
-}
 function createAppRouteGraphRootBoundaryId(treePath) {
 	return `root-boundary:${treePath}`;
 }
@@ -1753,4 +1751,4 @@ function computeAppRouteStaticSiblings(allRoutes, matchedRoute) {
 	return Array.from(siblings);
 }
 //#endregion
-export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, createAppRouteGraphInterceptionId, findOwnerRouteForDir, isInvisibleSegment, patternsStructurallyEquivalent };
+export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment, patternsStructurallyEquivalent };

package/dist/routing/app-route-ids.d.ts

@@ -0,0 +1,3 @@
+//#region src/routing/app-route-ids.d.ts
+export declare function createAppRouteGraphInterceptionId(slotId: string, sourcePattern: string, targetPattern: string): string;
+//#endregion

package/dist/routing/app-route-ids.js

@@ -0,0 +1,6 @@
+//#region src/routing/app-route-ids.ts
+function createAppRouteGraphInterceptionId(slotId, sourcePattern, targetPattern) {
+	return `interception:${slotId}:${sourcePattern}->${targetPattern}`;
+}
+//#endregion
+export { createAppRouteGraphInterceptionId };

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-bfcache-id.d.ts

@@ -1,4 +1,5 @@
 //#region src/server/app-bfcache-id.d.ts
 export declare const INITIAL_BFCACHE_ID = "0";
 export declare const PUBLIC_INITIAL_BFCACHE_ID = "_b_0_";
+export declare function isBfcacheSegmentId(id: string): boolean;
 //#endregion

package/dist/server/app-bfcache-id.js

@@ -1,5 +1,11 @@
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
 //#region src/server/app-bfcache-id.ts
 const INITIAL_BFCACHE_ID = "0";
 const PUBLIC_INITIAL_BFCACHE_ID = "_b_0_";
+function isBfcacheSegmentId(id) {
+	const parsed = AppElementsWire.parseElementKey(id);
+	return parsed?.kind === "layout" || parsed?.kind === "page" || parsed?.kind === "slot" || parsed?.kind === "template";
+}
 //#endregion
-export { INITIAL_BFCACHE_ID, PUBLIC_INITIAL_BFCACHE_ID };
+export { INITIAL_BFCACHE_ID, PUBLIC_INITIAL_BFCACHE_ID, isBfcacheSegmentId };

package/dist/server/app-bfcache-identity.js

@@ -1,8 +1,7 @@
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { isNestedBfcacheSlotSegmentIdFor } from "./bfcache-identity.js";
-import "./app-bfcache-id.js";
-import { isBfcacheSegmentId } from "./app-history-state.js";
+import { isBfcacheSegmentId } from "./app-bfcache-id.js";
 //#region src/server/app-bfcache-identity.ts
 let nextBfcacheId = 0;
 function rememberBfcacheId(value) {

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";
@@ -16,14 +16,14 @@ import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shi
 import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
 import { BfcacheIdentityMapContext, ElementsContext, Slot, bindAppElementsRenderedSearch, setAppElementsRenderedSearch } from "../shims/slot.js";
 import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
-import { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import "../client/instrumentation-client.js";
-import { isExternalHistoryState, readHistoryStateActiveRoutePaths, readHistoryStatePreviousNextUrl, resolveActiveRoutePaths } from "./app-history-state.js";
+import { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { createBfcacheSegmentIdentityMap, createInitialBfcacheIdMap } from "./app-bfcache-identity.js";
 import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, resolveServerActionOperationLane } from "./app-browser-action-result.js";
 import { createClientReuseManifestHeaderFromVisibleAppState } from "./app-browser-client-reuse-manifest.js";
 import { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext } from "./app-browser-interception-context.js";
+import { isExternalHistoryState, readHistoryStateActiveRoutePaths, readHistoryStatePreviousNextUrl, resolveActiveRoutePaths } from "./app-history-state.js";
 import { AppBrowserMpaNavigationScheduler } from "./app-browser-mpa-navigation.js";
 import { stripRscCompletionMetadataResponse } from "./rsc-completion-metadata.js";
 import { blockDangerousStreamedRscRedirect } from "./app-browser-rsc-redirect.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) {
@@ -1407,6 +1407,8 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 							primary: Promise.resolve(rscPayload),
 							signal: navigationAbortHandle.signal,
 							supplemental
+						}).finally(() => {
+							navigationAbortHandle.release();
 						}).then(requireCompleteSupplementalRefresh);
 					}
 					if (IS_STATIC_EXPORT) {
@@ -1503,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-hydration.d.ts

@@ -1,3 +1,4 @@
+import { RSC_FORM_STATE_GLOBAL } from "../client/browser-globals.js";
 import { ReactFormState, hydrateRoot } from "react-dom/client";
 //#region src/server/app-browser-hydration.d.ts
 type HydrateRootOptions = NonNullable<Parameters<typeof hydrateRoot>[2]>;
@@ -9,7 +10,6 @@ type HydrateRootCaughtErrorHandler = NonNullable<HydrateRootOptions["onCaughtErr
 type HydrateRootUncaughtErrorHandler = NonNullable<HydrateRootOptions["onUncaughtError"]>;
 type HydrateRootRecoverableErrorHandler = NonNullable<HydrateRootOptions["onRecoverableError"]>;
 type StartTransition = (action: () => void) => void;
-export declare const RSC_FORM_STATE_GLOBAL = "__VINEXT_RSC_FORM_STATE__";
 type FormStateGlobal = {
   [RSC_FORM_STATE_GLOBAL]?: ReactFormState;
 };

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

@@ -1,5 +1,5 @@
+import { RSC_FORM_STATE_GLOBAL } from "../client/browser-globals.js";
 //#region src/server/app-browser-hydration.ts
-const RSC_FORM_STATE_GLOBAL = "__VINEXT_RSC_FORM_STATE__";
 function consumeInitialFormState(global) {
 	const formState = global["__VINEXT_RSC_FORM_STATE__"] ?? null;
 	delete global[RSC_FORM_STATE_GLOBAL];
@@ -39,4 +39,4 @@ function resolveFetchedHydrationLocation(renderedPathAndSearch, location) {
 	};
 }
 //#endregion
-export { RSC_FORM_STATE_GLOBAL, consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition, resolveFetchedHydrationLocation };
+export { consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition, resolveFetchedHydrationLocation };

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 }: {