vinext 0.1.5 → 0.1.6

package/dist/shims/internal/interpolate-as.js

@@ -0,0 +1,196 @@
+import { removeTrailingSlash } from "../../utils/base-path.js";
+//#region src/shims/internal/interpolate-as.ts
+/**
+* Port of Next.js' Pages Router `interpolateAs` helper, plus the minimal
+* subset of its transitive dependencies (`getRouteRegex` + `getRouteMatcher`
+* and the parameter-pattern parsers they rely on).
+*
+* Upstream sources:
+*   - packages/next/src/shared/lib/router/utils/interpolate-as.ts
+*   - packages/next/src/shared/lib/router/utils/route-regex.ts
+*   - packages/next/src/shared/lib/router/utils/route-matcher.ts
+*   - packages/next/src/shared/lib/router/utils/get-dynamic-param.ts
+*   - packages/next/src/shared/lib/router/utils/remove-trailing-slash.ts
+*   - packages/next/src/shared/lib/escape-regexp.ts
+*
+* Used by the Pages Router shim to project a route pattern + `as` pathname +
+* query back into a fully-interpolated browser URL (the `<Link href as>`
+* masking path). Interception-route markers (`(.)`, `(..)`, `(...)`,
+* `(..)(..)`) are intentionally omitted — they only apply to App Router and
+* never appear in Pages Router patterns.
+*/
+function normalizeQuery(query) {
+	const normalized = {};
+	if (!query) return normalized;
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0) continue;
+		normalized[key] = Array.isArray(value) ? value.map(String) : String(value);
+	}
+	return normalized;
+}
+function parseRouteHrefQuery(routeHref, queryIndex, hashIndex) {
+	const query = {};
+	if (queryIndex === -1 || hashIndex !== -1 && queryIndex > hashIndex) return query;
+	const searchEnd = hashIndex === -1 ? routeHref.length : hashIndex;
+	for (const [key, value] of new URLSearchParams(routeHref.slice(queryIndex + 1, searchEnd))) {
+		const existing = query[key];
+		if (existing === void 0) query[key] = value;
+		else if (Array.isArray(existing)) existing.push(value);
+		else query[key] = [existing, value];
+	}
+	return query;
+}
+const reHasRegExp = /[|\\{}()[\]^$+*?.-]/;
+const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g;
+function escapeStringRegexp(str) {
+	if (reHasRegExp.test(str)) return str.replace(reReplaceRegExp, "\\$&");
+	return str;
+}
+/**
+* Regular expression pattern used to match route parameters.
+* Matches both single parameters and parameter groups.
+* Examples:
+*   - `[[...slug]]` matches parameter group with key 'slug', repeat: true, optional: true
+*   - `[...slug]` matches parameter group with key 'slug', repeat: true, optional: false
+*   - `[[foo]]` matches parameter with key 'foo', repeat: false, optional: true
+*   - `[bar]` matches parameter with key 'bar', repeat: false, optional: false
+*/
+const PARAMETER_PATTERN = /^([^[]*)\[((?:\[[^\]]*\])|[^\]]+)\](.*)$/;
+/**
+* Parses a matched parameter from the PARAMETER_PATTERN regex.
+* Examples:
+*   - `[...slug]` -> `{ key: 'slug', repeat: true, optional: true }`
+*   - `...slug`   -> `{ key: 'slug', repeat: true, optional: false }`
+*   - `[foo]`     -> `{ key: 'foo',  repeat: false, optional: true }`
+*   - `bar`       -> `{ key: 'bar',  repeat: false, optional: false }`
+*/
+function parseMatchedParameter(param) {
+	const optional = param.startsWith("[") && param.endsWith("]");
+	if (optional) param = param.slice(1, -1);
+	const repeat = param.startsWith("...");
+	if (repeat) param = param.slice(3);
+	return {
+		key: param,
+		repeat,
+		optional
+	};
+}
+function getParametrizedRoute(route) {
+	const groups = {};
+	let groupIndex = 1;
+	const segments = [];
+	for (const segment of removeTrailingSlash(route).slice(1).split("/")) {
+		const paramMatches = segment.match(PARAMETER_PATTERN);
+		if (paramMatches && paramMatches[2]) {
+			const { key, repeat, optional } = parseMatchedParameter(paramMatches[2]);
+			groups[key] = {
+				pos: groupIndex++,
+				repeat,
+				optional
+			};
+			const s = repeat ? optional ? "(?:/(.+?))?" : "/(.+?)" : "/([^/]+?)";
+			segments.push(s);
+		} else segments.push(`/${escapeStringRegexp(segment)}`);
+	}
+	return {
+		parameterizedRoute: segments.join(""),
+		groups
+	};
+}
+/**
+* From a normalized route this function generates a regular expression and a
+* corresponding groups object intended to be used to store matching groups
+* from the regular expression.
+*/
+function getRouteRegex(normalizedRoute) {
+	const { parameterizedRoute, groups } = getParametrizedRoute(normalizedRoute);
+	return {
+		re: new RegExp(`^${parameterizedRoute}(?:/)?$`),
+		groups
+	};
+}
+/**
+* Compile a route regex into a function that extracts decoded params from a
+* pathname. Returns `false` if the pathname does not match the route.
+*
+* The `safeRouteMatcher`/`stripParameterSeparators` wrapper that Next.js
+* applies (for adjacent-parameter normalization) is omitted — Pages Router
+* patterns never contain adjacent parameters, so the wrapper is a no-op for
+* this caller.
+*/
+function getRouteMatcher({ re, groups }) {
+	return (pathname) => {
+		const routeMatch = re.exec(pathname);
+		if (!routeMatch) return false;
+		const decode = (param) => {
+			try {
+				return decodeURIComponent(param);
+			} catch {
+				throw new Error("failed to decode param");
+			}
+		};
+		const params = {};
+		for (const [key, group] of Object.entries(groups)) {
+			const match = routeMatch[group.pos];
+			if (match !== void 0) if (group.repeat) params[key] = match.split("/").map((entry) => decode(entry));
+			else params[key] = decode(match);
+		}
+		return params;
+	};
+}
+/**
+* Project a `(route, asPathname, query)` triple back into a fully-interpolated
+* browser URL. Used by the `<Link href as>` masking path in the Pages Router
+* shim: extract param values from the rendered `as` path when it differs from
+* the route pattern, otherwise fall back to reading them from the href query.
+*
+* Returns `{ params, result }`. `result` is the interpolated URL, or the empty
+* string when one or more required params could not be resolved. Callers warn
+* (in dev) on the empty-string case; this helper deliberately stays silent —
+* matching Next.js' behavior, where `<Link>` itself owns the dev warning.
+*/
+function interpolateAs(route, asPathname, query) {
+	let interpolatedRoute = "";
+	const dynamicRegex = getRouteRegex(route);
+	const dynamicGroups = dynamicRegex.groups;
+	const dynamicMatches = (asPathname !== route ? getRouteMatcher(dynamicRegex)(asPathname) : "") || query;
+	interpolatedRoute = route;
+	const params = Object.keys(dynamicGroups);
+	if (!params.every((param) => {
+		let value = dynamicMatches[param] || "";
+		const { repeat, optional } = dynamicGroups[param];
+		let replaced = `[${repeat ? "..." : ""}${param}]`;
+		if (optional) replaced = `${!value ? "/" : ""}[${replaced}]`;
+		if (repeat && !Array.isArray(value)) value = [value];
+		return (optional || param in dynamicMatches) && (interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map((segment) => encodeURIComponent(segment)).join("/") : encodeURIComponent(value)) || "/");
+	})) interpolatedRoute = "";
+	return {
+		params,
+		result: interpolatedRoute
+	};
+}
+/**
+* Resolve a bracket-pattern route href against its displayed href. Query
+* values can be supplied directly (object-form hrefs) or parsed from the route
+* href (string-form hrefs). A `?` after `#` is part of the fragment, not a
+* query delimiter.
+*/
+function interpolateDynamicRouteHref(routeHref, asHref, queryInput) {
+	if (!routeHref.includes("[")) return null;
+	const hashIndex = routeHref.indexOf("#");
+	const queryIndex = routeHref.indexOf("?");
+	const pathEnd = [hashIndex, queryIndex].filter((index) => index !== -1).reduce((earliest, index) => Math.min(earliest, index), routeHref.length);
+	const routePathname = routeHref.slice(0, pathEnd);
+	const trailing = routeHref.slice(pathEnd);
+	const asPathname = asHref.split(/[?#]/, 1)[0];
+	const query = queryInput ? normalizeQuery(queryInput) : parseRouteHrefQuery(routeHref, queryIndex, hashIndex);
+	const { result, params } = interpolateAs(routePathname, asPathname, query);
+	return {
+		href: result ? `${result}${trailing}` : "",
+		params,
+		query,
+		routePathname
+	};
+}
+//#endregion
+export { interpolateDynamicRouteHref };

package/dist/shims/link.js

@@ -12,6 +12,7 @@ import { appendSearchParamsToUrl, urlQueryToSearchParams } from "../utils/query.
 import { resolveHybridClientRouteOwner } from "./internal/hybrid-client-route-owner.js";
 import { markAppRouteDetectedOnPrefetch } from "./internal/app-route-detection.js";
 import { isAbsoluteOrProtocolRelativeUrl, normalizePathTrailingSlash, toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
+import { interpolateDynamicRouteHref } from "./internal/interpolate-as.js";
 import { getCurrentBrowserLocale } from "./client-locale.js";
 import { getCurrentRoutePathnameForWarning } from "./internal/route-pattern-for-warning.js";
 import { createRscRequestHeaders, createRscRequestUrl, stripRscCacheBustingSearchParam, stripRscSuffix } from "../server/app-rsc-cache-busting.js";
@@ -391,11 +392,30 @@ function applyLocaleToHref(href, locale) {
 	}
 	return addLocalePrefix(href, resolvedLocale, defaultLocale);
 }
+/**
+* For the `<Link href="/blog/[slug]" as="/blog/test-post">` case, project the
+* bracket-pattern href + the resolved `as` back into a concrete route URL the
+* Pages Router can fetch (`/blog/test-post`). Returns null when:
+*   - `href` has no bracket params (already concrete; the existing forwarding
+*     path works as-is)
+*   - interpolation fails because a required param could not be resolved
+*     (caller falls back to `as`, matching pre-PR behavior)
+*
+* The query for interpolation is the href's own query — `as` is the matcher
+* input rather than the source of param values. For string hrefs the search
+* portion is parsed into the query record; for object hrefs we take
+* `href.query` directly.
+*/
+function resolveConcreteRouteHref(href, as) {
+	if (typeof as !== "string") return null;
+	return interpolateDynamicRouteHref(typeof href === "string" ? href : resolveHref(href), as, typeof href === "string" ? void 0 : href.query)?.href || null;
+}
 const Link = forwardRef(function Link({ href, as, replace = false, prefetch: prefetchProp, scroll = true, shallow = false, children: childrenProp, onClick, onMouseEnter, onTouchStart, onNavigate, unstable_dynamicOnHover = false, legacyBehavior = false, passHref = false, ...rest }, forwardedRef) {
 	const { locale, ...restWithoutLocale } = rest;
 	let children = childrenProp;
 	if (legacyBehavior && (typeof childrenProp === "string" || typeof childrenProp === "number")) children = React.createElement("a", null, childrenProp);
 	const rawResolvedHref = as ?? resolveHref(href);
+	const routeHrefRaw = resolveConcreteRouteHref(href, as) ?? (typeof href === "string" ? href : resolveHref(href));
 	const resolvedHref = typeof rawResolvedHref === "string" ? warnAndNormalizeRepeatedSlashesInHref(rawResolvedHref) : rawResolvedHref;
 	const isDangerous = typeof resolvedHref === "string" && isDangerousScheme(resolvedHref);
 	const normalizedHref = normalizePathTrailingSlash(applyLocaleToHref(isDangerous ? "/" : resolvedHref, locale), __trailingSlash);
@@ -508,6 +528,8 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 		e.preventDefault();
 		const hasAppNavigationRuntime = Boolean(getNavigationRuntime()?.functions.navigate);
 		const pagesNavigateHref = resolvedHref.startsWith("?") ? resolvePagesLinkNavigationHref(resolvedHref, locale) : navigateHref;
+		const pagesAsForLink = typeof as === "string" && typeof routeHrefRaw === "string" && as !== routeHrefRaw ? pagesNavigateHref : void 0;
+		const pagesHrefForLink = pagesAsForLink === void 0 ? pagesNavigateHref : routeHrefRaw;
 		const absoluteFullHref = toBrowserNavigationHref(hasAppNavigationRuntime ? navigateHref : pagesNavigateHref, window.location.href, __basePath);
 		if (onNavigate) try {
 			const navUrl = new URL(absoluteFullHref, window.location.origin);
@@ -546,7 +568,8 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 				router: Router && "reload" in Router ? Router : void 0,
 				loadRouter: async () => (await import("next/router.js")).default,
 				navigation: {
-					href: pagesNavigateHref,
+					href: pagesHrefForLink,
+					as: pagesAsForLink,
 					replace,
 					scroll,
 					shallow,

package/dist/shims/navigation.js

@@ -16,8 +16,8 @@ import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createRscRequestHeaders, createRscR
 import { getNavigationRuntime, hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import { PUBLIC_INITIAL_BFCACHE_ID } from "../server/app-bfcache-id.js";
-import { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata } from "../server/app-history-state.js";
 import { resolveManifestNavigationInterceptionContext } from "../server/app-browser-interception-context.js";
+import { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata } from "../server/app-history-state.js";
 import { hasPendingAppRouterPageRedirect } from "../server/app-browser-mpa-navigation.js";
 import { navigationPlanner } from "../server/navigation-planner.js";
 import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";

package/dist/shims/navigation.react-server.js

@@ -1,8 +1,8 @@
 import { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearServerInsertedHTML, flushServerInsertedHTML, getLayoutSegmentContext, getNavigationContext, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
 import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow } from "./navigation-errors.js";
 import "./navigation-server.js";
-import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
 import { throwClientHookError } from "./client-hook-error.js";
+import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
 //#region src/shims/navigation.react-server.ts
 function usePathname() {
 	throwClientHookError("usePathname()");

package/dist/shims/router.d.ts

@@ -6,9 +6,7 @@ import { ComponentType, ReactElement } from "react";
 type BeforePopStateCallback = (state: {
   url: string;
   as: string;
-  options: {
-    shallow: boolean;
-  };
+  options: TransitionOptions;
 }) => boolean;
 type NextRouter = {
   /** Current pathname */pathname: string; /** Current route pattern (e.g., "/posts/[id]") */

package/dist/shims/router.js

@@ -19,6 +19,7 @@ import { installWindowNext } from "../client/window-next.js";
 import { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
 import { scrollToHashTarget } from "./hash-scroll.js";
 import { installPagesRouterRuntime, setPagesRouterPopStateHandler, setStampInitialHistoryState } from "./pages-router-runtime.js";
+import { interpolateDynamicRouteHref } from "./internal/interpolate-as.js";
 import { getCurrentBrowserLocale } from "./client-locale.js";
 import { Component, Fragment, createElement, useContext, useEffect, useLayoutEffect, useMemo, useState } from "react";
 //#region src/shims/router.ts
@@ -1118,7 +1119,7 @@ async function navigateClientHtml(url, fetchUrl, controller, navId, assertStillC
 * fixups). The JSON path derives its own URL from the browser-facing `url`
 * because the data endpoint speaks the unprefixed path.
 */
-async function navigateClient(url, fetchUrl = url, options = {}) {
+async function navigateClient(url, fetchUrl = url, options = {}, routeUrl = url) {
 	if (typeof window === "undefined") return;
 	const previousAbortController = routerRuntimeState.activeAbortController;
 	if (previousAbortController) queueMicrotask(() => previousAbortController.abort());
@@ -1135,7 +1136,7 @@ async function navigateClient(url, fetchUrl = url, options = {}) {
 		else {
 			let browserUrl = url;
 			let htmlFetchUrl = fetchUrl;
-			let dataTarget = resolvePagesDataNavigationTarget(browserUrl, __basePath);
+			let dataTarget = resolvePagesDataNavigationTarget(routeUrl, __basePath);
 			let middlewareDataResponse;
 			if (!dataTarget) {
 				let middlewareEffect;
@@ -1178,9 +1179,9 @@ async function navigateClient(url, fetchUrl = url, options = {}) {
 * - "failed" — genuine error, caller should return false (hard nav is already
 *   scheduled as recovery)
 */
-async function runNavigateClient(fullUrl, resolvedUrl, fetchUrl = fullUrl, options = {}) {
+async function runNavigateClient(fullUrl, resolvedUrl, fetchUrl = fullUrl, options = {}, routeUrl = fullUrl) {
 	try {
-		await navigateClient(fullUrl, fetchUrl, options);
+		await navigateClient(fullUrl, fetchUrl, options, routeUrl);
 		return "completed";
 	} catch (err) {
 		routerEvents.emit("routeChangeError", err, resolvedUrl, { shallow: false });
@@ -1252,9 +1253,9 @@ function updateHistory(mode, fullUrl, navState) {
 	const previousKey = getRouterStateKey(window.history.state);
 	const key = mode === "push" ? createHistoryKey() : previousKey ?? routerRuntimeState.currentHistoryKey ?? createHistoryKey();
 	const state = {
-		url: navState?.url ?? fullUrl,
-		as: navState?.as ?? fullUrl,
-		options: navState?.options ?? {},
+		url: navState.url,
+		as: navState.as,
+		options: navState.options,
 		__N: true,
 		key
 	};
@@ -1300,8 +1301,13 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 	assertSafeNavigationUrl(resolveUrl(url));
 	if (as !== void 0) assertSafeNavigationUrl(String(as));
 	const navigationLocale = resolveTransitionLocale(options?.locale);
-	let resolved = resolveNavigationTarget(url, as, navigationLocale, as === void 0 && options?.locale !== void 0 && typeof url !== "string" && url.pathname === void 0 && (url.query !== void 0 && Object.keys(url.query).length > 0 || typeof url.search === "string" && url.search.length > 0 || typeof url.hash === "string" && url.hash.length > 0));
-	if (as === void 0 && (typeof url === "string" && options?._vinextInterpolateDynamicRoute === true || typeof url !== "string" && url.pathname === void 0 && (url.query !== void 0 && Object.keys(url.query).length > 0 || typeof url.search === "string" && url.search.length > 0))) resolved = interpolateCurrentDynamicRoute(resolved);
+	const replaceInheritedLocale = as === void 0 && options?.locale !== void 0 && typeof url !== "string" && url.pathname === void 0 && (url.query !== void 0 && Object.keys(url.query).length > 0 || typeof url.search === "string" && url.search.length > 0 || typeof url.hash === "string" && url.hash.length > 0);
+	let resolved = resolveNavigationTarget(url, as, navigationLocale, replaceInheritedLocale);
+	let resolvedRoute = applyNavigationLocale(resolveUrl(url), navigationLocale, replaceInheritedLocale);
+	if (as === void 0 && (typeof url === "string" && options?._vinextInterpolateDynamicRoute === true || typeof url !== "string" && url.pathname === void 0 && (url.query !== void 0 && Object.keys(url.query).length > 0 || typeof url.search === "string" && url.search.length > 0))) {
+		resolved = interpolateCurrentDynamicRoute(resolved);
+		resolvedRoute = interpolateCurrentDynamicRoute(resolvedRoute);
+	}
 	if (isExternalUrl(resolved)) {
 		const localPath = toSameOriginAppPath(resolved, __basePath);
 		if (localPath == null) {
@@ -1311,10 +1317,36 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 		}
 		resolved = localPath;
 	}
+	if (isExternalUrl(resolvedRoute)) {
+		const localPath = toSameOriginAppPath(resolvedRoute, __basePath);
+		if (localPath != null) resolvedRoute = localPath;
+	}
 	resolved = normalizePathTrailingSlash(resolved, __trailingSlash);
+	resolvedRoute = normalizePathTrailingSlash(resolvedRoute, __trailingSlash);
+	let interpolatedRoute = resolvedRoute;
+	if (resolvedRoute.includes("[")) {
+		const projection = interpolateDynamicRouteHref(resolvedRoute, resolved, typeof url === "string" ? void 0 : url.query);
+		if (projection?.href) {
+			interpolatedRoute = projection.href;
+			if (as === void 0 && stripHash(resolved).split("?", 1)[0] === projection.routePathname) {
+				const remaining = new URLSearchParams();
+				const consumed = new Set(projection.params);
+				for (const [k, v] of Object.entries(projection.query)) {
+					if (consumed.has(k)) continue;
+					if (v === void 0) continue;
+					if (Array.isArray(v)) v.forEach((entry) => remaining.append(k, entry));
+					else remaining.append(k, v);
+				}
+				const searchStr = remaining.toString();
+				const hashStr = extractHash(resolved);
+				resolved = normalizePathTrailingSlash(`${projection.href.split(/[?#]/, 1)[0]}${searchStr ? `?${searchStr}` : ""}${hashStr}`, __trailingSlash);
+			}
+		} else interpolatedRoute = resolved;
+	}
 	const full = normalizePathTrailingSlash(toBrowserNavigationHref(resolved, window.location.href, __basePath), __trailingSlash);
+	const fullRouteUrl = interpolatedRoute !== resolved ? normalizePathTrailingSlash(toBrowserNavigationHref(interpolatedRoute, window.location.href, __basePath), __trailingSlash) : full;
 	const errorRouteHtmlFetchUrl = resolvePagesErrorHtmlFetchUrl(url, navigationLocale);
-	const htmlFetchUrl = errorRouteHtmlFetchUrl ?? getPagesHtmlFetchUrl(full, navigationLocale);
+	const htmlFetchUrl = errorRouteHtmlFetchUrl ?? getPagesHtmlFetchUrl(fullRouteUrl, navigationLocale);
 	const shallow = options?.shallow ?? false;
 	const doScroll = options?.scroll !== false;
 	const hash = extractHash(resolved);
@@ -1330,15 +1362,17 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 		mode,
 		scroll: scrollTarget
 	};
+	const currentLocale = getCurrentUrlLocale();
+	if (mode === "push" && interpolatedRoute !== resolved && stripHash(full) === routerRuntimeState.lastPathnameAndSearch && navigationLocale === currentLocale) mode = "replace";
 	const navStateOptions = { shallow };
 	if (navigationLocale !== void 0) navStateOptions.locale = navigationLocale;
 	const resolvedNoHash = stripHash(resolved);
 	const navState = {
-		url: resolvedNoHash,
+		url: stripHash(interpolatedRoute),
 		as: resolvedNoHash,
 		options: navStateOptions
 	};
-	if (options?._h !== 1 && isHashOnlyChange(full)) {
+	if (options?._h !== 1 && interpolatedRoute === resolved && isHashOnlyChange(full)) {
 		if (mode === "push") saveScrollPosition();
 		const eventUrl = resolveHashUrl(full);
 		routerEvents.emit("hashChangeStart", eventUrl, { shallow });
@@ -1363,7 +1397,7 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 	routerEvents.emit("beforeHistoryChange", resolved, { shallow });
 	updateHistory(mode, full, navState);
 	if (!shallow) {
-		const result = await runNavigateClient(full, resolved, htmlFetchUrl, navigateOptions);
+		const result = await runNavigateClient(full, resolved, htmlFetchUrl, navigateOptions, fullRouteUrl);
 		if (result === "cancelled") return true;
 		if (result === "failed") return false;
 	} else if (doScroll) if (hash) scrollToHashTarget(hash);
@@ -1479,7 +1513,7 @@ function PagesRouterProvider({ children }) {
 	return AppRouterContext ? createElement(AppRouterContext.Provider, { value: appRouter }, content) : content;
 }
 function isNextRouterState(state) {
-	return typeof state === "object" && state !== null && "__N" in state && state.__N === true;
+	return typeof state === "object" && state !== null && "__N" in state && state.__N === true && "url" in state && typeof state.url === "string" && "as" in state && typeof state.as === "string" && "options" in state && typeof state.options === "object" && state.options !== null;
 }
 function getRouterStateKey(state) {
 	if (!isNextRouterState(state)) return void 0;
@@ -1508,11 +1542,16 @@ function handlePagesRouterPopState(e) {
 		};
 	}
 	if (routerRuntimeState.beforePopStateCb !== void 0) {
-		if (!routerRuntimeState.beforePopStateCb({
+		const beforePopStateState = isNextRouterState(state) ? {
+			url: state.url,
+			as: state.as,
+			options: state.options
+		} : {
 			url: appUrl,
 			as: appUrl,
 			options: { shallow: false }
-		})) return;
+		};
+		if (!routerRuntimeState.beforePopStateCb({ ...beforePopStateState })) return;
 	}
 	if (targetKey !== void 0) routerRuntimeState.currentHistoryKey = targetKey;
 	routerRuntimeState.lastPathnameAndSearch = browserUrl;
@@ -1524,7 +1563,8 @@ function handlePagesRouterPopState(e) {
 		dispatchNavigateEvent();
 		return;
 	}
-	const effectiveLocale = (isNextRouterState(state) ? state.options?.locale : void 0) ?? window.__VINEXT_LOCALE__;
+	const stateLocale = isNextRouterState(state) ? state.options?.locale : void 0;
+	const effectiveLocale = typeof stateLocale === "string" ? stateLocale : window.__VINEXT_LOCALE__;
 	const fullAppUrl = appUrl + window.location.hash;
 	routerEvents.emit("routeChangeStart", fullAppUrl, { shallow: false });
 	routerEvents.emit("beforeHistoryChange", fullAppUrl, { shallow: false });
@@ -1533,7 +1573,11 @@ function handlePagesRouterPopState(e) {
 			x: 0,
 			y: 0
 		} : readScrollPosition(state);
-		if (await runNavigateClient(browserUrl, fullAppUrl, getPagesHtmlFetchUrl(browserUrl, effectiveLocale), { scroll: scrollTarget }) === "completed") {
+		const stateRouteUrl = (() => {
+			if (isNextRouterState(state) && typeof state.url === "string" && typeof state.as === "string" && state.url !== state.as) return normalizePathTrailingSlash(withBasePath(state.url, __basePath), __trailingSlash);
+			return browserUrl;
+		})();
+		if (await runNavigateClient(browserUrl, fullAppUrl, getPagesHtmlFetchUrl(stateRouteUrl, effectiveLocale), { scroll: scrollTarget }, stateRouteUrl) === "completed") {
 			routerEvents.emit("routeChangeComplete", fullAppUrl, { shallow: false });
 			dispatchNavigateEvent();
 		}

package/dist/typegen.js

@@ -1,3 +1,4 @@
+import { findDir } from "./utils/project.js";
 import { decodeRouteSegment, isInvisibleSegment } from "./routing/utils.js";
 import { patternToNextFormat } from "./routing/route-validation.js";
 import { compareStrings } from "./utils/compare.js";
@@ -15,7 +16,7 @@ import "./.next/types/routes.d.ts";
 `;
 async function generateRouteTypes(options) {
 	const root = path.resolve(options.root);
-	const appDir = options.appDir ? path.resolve(options.appDir) : await findAppDir(root);
+	const appDir = options.appDir ? path.resolve(options.appDir) : findDir(root, "app", path.join("src", "app"));
 	const outPath = path.join(root, ".next", "types", "routes.d.ts");
 	const content = appDir ? renderRouteTypes(await collectRouteTypeModel(appDir, options.pageExtensions)) : renderRouteTypes(emptyRouteTypeModel());
 	await fs.mkdir(path.dirname(outPath), { recursive: true });
@@ -84,15 +85,6 @@ async function collectRouteTypeModel(appDir, pageExtensions) {
 	for (const slotNames of model.layoutSlots.values()) slotNames.sort(compareStrings);
 	return model;
 }
-async function findAppDir(root) {
-	for (const rel of ["app", path.join("src", "app")]) {
-		const candidate = path.join(root, rel);
-		try {
-			if ((await fs.stat(candidate)).isDirectory()) return candidate;
-		} catch {}
-	}
-	return null;
-}
 function renderRouteTypes(model) {
 	const allRoutes = uniqueSorted([
 		...model.pageRoutes,

package/dist/utils/project.d.ts

@@ -62,9 +62,15 @@ declare function findInNodeModules(start: string, subPath: string): string | nul
  * Check if a vite.config file exists in the project root.
  */
 declare function hasViteConfig(root: string): boolean;
+/**
+ * Return the first candidate directory (resolved against `root`) that exists,
+ * or null. Used to locate conventional `app`/`pages` directories that may live
+ * at the root or under `src/`.
+ */
+declare function findDir(root: string, ...candidates: string[]): string | null;
 /**
  * Check if the project uses App Router (has an app/ directory).
  */
 declare function hasAppDir(root: string): boolean;
 //#endregion
-export { detectPackageManager, detectPackageManagerName, ensureESModule, ensureViteConfigCompatibility, findInNodeModules, hasAppDir, hasViteConfig, renameCJSConfigs };
+export { detectPackageManager, detectPackageManagerName, ensureESModule, ensureViteConfigCompatibility, findDir, findInNodeModules, hasAppDir, hasViteConfig, renameCJSConfigs };

package/dist/utils/project.js

@@ -190,10 +190,24 @@ function hasViteConfig(root) {
 	return fs.existsSync(path.join(root, "vite.config.ts")) || fs.existsSync(path.join(root, "vite.config.js")) || fs.existsSync(path.join(root, "vite.config.mjs"));
 }
 /**
+* Return the first candidate directory (resolved against `root`) that exists,
+* or null. Used to locate conventional `app`/`pages` directories that may live
+* at the root or under `src/`.
+*/
+function findDir(root, ...candidates) {
+	for (const candidate of candidates) {
+		const full = path.join(root, candidate);
+		try {
+			if (fs.statSync(full).isDirectory()) return full;
+		} catch {}
+	}
+	return null;
+}
+/**
 * Check if the project uses App Router (has an app/ directory).
 */
 function hasAppDir(root) {
-	return fs.existsSync(path.join(root, "app")) || fs.existsSync(path.join(root, "src", "app"));
+	return findDir(root, "app", path.join("src", "app")) !== null;
 }
 //#endregion
-export { detectPackageManager, detectPackageManagerName, ensureESModule, ensureViteConfigCompatibility, findInNodeModules, hasAppDir, hasViteConfig, renameCJSConfigs };
+export { detectPackageManager, detectPackageManagerName, ensureESModule, ensureViteConfigCompatibility, findDir, findInNodeModules, hasAppDir, hasViteConfig, renameCJSConfigs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "license": "MIT",
   "repository": {
@@ -103,8 +103,8 @@
     "@vitejs/plugin-react": "^6.0.1",
     "@vitejs/plugin-rsc": "^0.5.27",
     "react-server-dom-webpack": "^19.2.7",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.1.24",
-    "vite-plus": "0.1.24",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.1",
+    "vite-plus": "0.2.1",
     "@vinext/cloudflare": "0.1.2"
   },
   "peerDependencies": {