vinext 0.1.4 → 0.1.6

package/dist/shims/font-google-base.js

@@ -206,27 +206,12 @@ function getSSRFontPreloads() {
 	return [...ssrFontPreloads];
 }
 /**
-* Extract font file URLs from @font-face CSS rules.
-* Parses url('...') references from the CSS text.
-*/
-function extractFontUrlsFromCSS(css) {
-	const urls = [];
-	const urlRegex = /url\(['"]?([^'")]+)['"]?\)/g;
-	let match;
-	while ((match = urlRegex.exec(css)) !== null) {
-		const url = match[1];
-		if (url && url.startsWith("/")) urls.push(url);
-	}
-	return urls;
-}
-/**
-* Collect font file URLs from self-hosted CSS for preload link generation.
+* Collect build-selected font file URLs for preload link generation.
 * Only collects on the server (SSR). Deduplicates by href using a Set for O(1) lookups.
 */
-function collectFontPreloadsFromCSS(css) {
+function collectFontPreloads(urls) {
 	if (typeof document !== "undefined") return;
-	const urls = extractFontUrlsFromCSS(css);
-	for (const href of urls) if (!ssrFontPreloadHrefs.has(href)) {
+	for (const href of urls) if (href.startsWith("/") && !ssrFontPreloadHrefs.has(href)) {
 		ssrFontPreloadHrefs.add(href);
 		ssrFontPreloads.push({
 			href,
@@ -240,10 +225,10 @@ const injectedSelfHosted = /* @__PURE__ */ new Set();
 * Inject self-hosted @font-face CSS (from the build plugin).
 * This replaces the CDN <link> tag with inline CSS.
 */
-function injectSelfHostedCSS(css) {
+function injectSelfHostedCSS(css, preloadUrls = []) {
+	collectFontPreloads(preloadUrls);
 	if (injectedSelfHosted.has(css)) return;
 	injectedSelfHosted.add(css);
-	collectFontPreloadsFromCSS(css);
 	if (typeof document === "undefined") {
 		ssrFontStyles.push(css);
 		return;
@@ -277,7 +262,7 @@ function createFontLoader(family) {
 			internalStyle: internal?.fontStyle,
 			google: true
 		});
-		if (internal?.selfHostedCSS) injectSelfHostedCSS(internal.selfHostedCSS);
+		if (internal?.selfHostedCSS) injectSelfHostedCSS(internal.selfHostedCSS, internal.preloadUrls);
 		else {
 			const url = buildGoogleFontsUrl(family, options);
 			injectFontStylesheet(url);

package/dist/shims/form.js

@@ -4,8 +4,8 @@ import { isDangerousScheme } from "./url-safety.js";
 import { AppElementsWire } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
 import { toSameOriginPath, withBasePath } from "./url-utils.js";
-import { hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { createRscRequestHeaders, createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
+import { hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { getMountedSlotsHeader, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, navigateClientSide, prefetchRscResponse } from "./navigation.js";
 import { useMergedRef } from "./use-merged-ref.js";
 import { forwardRef, useActionState, useCallback, useEffect, useRef } from "react";

package/dist/shims/image.js

@@ -243,7 +243,7 @@ function generateSrcSet(src, originalWidth, quality = 75) {
 	if (widths.length === 0) return `${imageOptimizationUrl(src, originalWidth, quality)} ${originalWidth}w`;
 	return widths.map((w) => `${imageOptimizationUrl(src, w, quality)} ${w}w`).join(", ");
 }
-const Image = forwardRef(function Image({ src: srcProp, alt, width, height, fill, preload, priority, quality, placeholder, blurDataURL, loader, sizes, className, style, onLoad, onLoadingComplete, onError, unoptimized: _unoptimized, overrideSrc: _overrideSrc, loading, ...rest }, ref) {
+const Image = forwardRef(function Image({ src: srcProp, alt, width, height, fill, preload, priority, quality, placeholder, blurDataURL, loader, sizes, className, style, onLoad, onLoadingComplete, onError, unoptimized: _unoptimized, overrideSrc, loading, ...rest }, ref) {
 	const lastLoadedSrcRef = useRef(void 0);
 	const lastErrorSrcRef = useRef(void 0);
 	const didInsertRef = useRef(false);
@@ -326,6 +326,40 @@ const Image = forwardRef(function Image({ src: srcProp, alt, width, height, fill
 		lastErrorSrcRef.current = src;
 		markBlurComplete();
 	} : void 0;
+	if (_unoptimized === true) {
+		const renderedSrc = overrideSrc || src;
+		const sanitizedBlur = imgBlurDataURL ? sanitizeBlurDataURL(imgBlurDataURL) : void 0;
+		const blurStyle = !blurComplete && placeholder === "blur" && sanitizedBlur ? {
+			backgroundImage: `url(${sanitizedBlur})`,
+			backgroundSize: "cover",
+			backgroundRepeat: "no-repeat",
+			backgroundPosition: "center"
+		} : void 0;
+		preloadImageResource({
+			shouldPreload,
+			src: renderedSrc,
+			fetchPriority: priorityFetchPriority
+		});
+		return /* @__PURE__ */ jsx("img", {
+			ref: mergedRef,
+			src: renderedSrc,
+			alt,
+			width: fill ? void 0 : imgWidth,
+			height: fill ? void 0 : imgHeight,
+			loading: imageLoading,
+			fetchPriority: priorityFetchPriority,
+			decoding: "async",
+			className,
+			"data-nimg": fill ? "fill" : "1",
+			onLoad: handleLoad,
+			onError: handleError,
+			style: fill ? getFillStyle(style, blurStyle) : {
+				...blurStyle,
+				...style
+			},
+			...rest
+		});
+	}
 	if (loader) {
 		const resolvedSrc = loader({
 			src,
@@ -371,11 +405,11 @@ const Image = forwardRef(function Image({ src: srcProp, alt, width, height, fill
 		} : void 0;
 		const bg = showBlur ? `url(${sanitizedBlur})` : void 0;
 		if (fill) {
-			const fillSizes = sizes ?? "100vw";
+			const imageSizes = sizes ?? "100vw";
 			preloadImageResource({
 				shouldPreload,
 				src,
-				sizes: fillSizes,
+				sizes: imageSizes,
 				fetchPriority: priorityFetchPriority
 			});
 			return /* @__PURE__ */ jsx("img", {
@@ -385,7 +419,7 @@ const Image = forwardRef(function Image({ src: srcProp, alt, width, height, fill
 				loading: imageLoading,
 				fetchPriority: priorityFetchPriority,
 				decoding: "async",
-				sizes: fillSizes,
+				sizes: imageSizes,
 				className,
 				"data-nimg": "fill",
 				onLoad: handleLoad,
@@ -421,8 +455,7 @@ const Image = forwardRef(function Image({ src: srcProp, alt, width, height, fill
 		}
 	}
 	const imgQuality = quality ?? 75;
-	const isSvg = isSvgUrl(src);
-	const skipOptimization = _unoptimized === true || isSvg && !__dangerouslyAllowSVG;
+	const skipOptimization = isSvgUrl(src) && !__dangerouslyAllowSVG;
 	const srcSet = imgWidth && !fill && !skipOptimization ? generateSrcSet(src, imgWidth, imgQuality) : imgWidth && !fill ? RESPONSIVE_WIDTHS.filter((w) => w <= imgWidth * 2).map((w) => `${src} ${w}w`).join(", ") || `${src} ${imgWidth}w` : void 0;
 	const optimizedSrc = skipOptimization ? src : imgWidth ? imageOptimizationUrl(src, imgWidth, imgQuality) : imageOptimizationUrl(src, RESPONSIVE_WIDTHS[0], imgQuality);
 	const sanitizedLocalBlur = imgBlurDataURL ? sanitizeBlurDataURL(imgBlurDataURL) : void 0;
@@ -467,7 +500,7 @@ const Image = forwardRef(function Image({ src: srcProp, alt, width, height, fill
 * Returns the props that would be passed to the underlying <img> element.
 */
 function getImageProps(props) {
-	const { src: srcProp, alt, width, height, fill, preload: _preload, priority, quality: _quality, placeholder, blurDataURL: blurDataURLProp, loader, sizes, className, style, onLoad: _onLoad, onLoadingComplete: _onLoadingComplete, unoptimized: _unoptimized, overrideSrc: _overrideSrc, loading, ...rest } = props;
+	const { src: srcProp, alt, width, height, fill, preload: _preload, priority, quality: _quality, placeholder, blurDataURL: blurDataURLProp, loader, sizes, className, style, onLoad: _onLoad, onLoadingComplete: _onLoadingComplete, unoptimized: _unoptimized, overrideSrc, loading, ...rest } = props;
 	const { src, width: imgWidth, height: imgHeight, blurDataURL: imgBlurDataURL } = resolveImageSource({
 		src: srcProp,
 		width,
@@ -475,6 +508,32 @@ function getImageProps(props) {
 		blurDataURL: blurDataURLProp
 	});
 	const shouldPreload = _preload === true || priority === true;
+	if (_unoptimized === true) {
+		const renderedSrc = overrideSrc || src;
+		const sanitizedBlurURL = imgBlurDataURL ? sanitizeBlurDataURL(imgBlurDataURL) : void 0;
+		const blurStyle = placeholder === "blur" && sanitizedBlurURL ? {
+			backgroundImage: `url(${sanitizedBlurURL})`,
+			backgroundSize: "cover",
+			backgroundRepeat: "no-repeat",
+			backgroundPosition: "center"
+		} : void 0;
+		return { props: {
+			src: renderedSrc,
+			alt,
+			width: fill ? void 0 : imgWidth,
+			height: fill ? void 0 : imgHeight,
+			loading: priority ? "eager" : shouldPreload ? loading : loading ?? "lazy",
+			fetchPriority: priority ? "high" : void 0,
+			decoding: "async",
+			className,
+			"data-nimg": fill ? "fill" : "1",
+			style: fill ? getFillStyle(style, blurStyle) : {
+				...blurStyle,
+				...style
+			},
+			...rest
+		} };
+	}
 	let blockedInProd = false;
 	if (isRemoteUrl(src)) {
 		const validation = validateRemoteUrl(src);
@@ -490,8 +549,7 @@ function getImageProps(props) {
 		width: imgWidth ?? 0,
 		quality: imgQuality
 	}) : src;
-	const isSvg = isSvgUrl(resolvedSrc);
-	const skipOpt = _unoptimized === true || isSvg && !__dangerouslyAllowSVG || blockedInProd || !!loader || isRemoteUrl(resolvedSrc);
+	const skipOpt = isSvgUrl(resolvedSrc) && !__dangerouslyAllowSVG || blockedInProd || !!loader || isRemoteUrl(resolvedSrc);
 	const optimizedSrc = skipOpt ? resolvedSrc : imgWidth ? imageOptimizationUrl(resolvedSrc, imgWidth, imgQuality) : imageOptimizationUrl(resolvedSrc, RESPONSIVE_WIDTHS[0], imgQuality);
 	const srcSet = imgWidth && !fill && !isRemoteUrl(resolvedSrc) && !loader && !skipOpt ? generateSrcSet(resolvedSrc, imgWidth, imgQuality) : void 0;
 	const sanitizedBlurURL = imgBlurDataURL ? sanitizeBlurDataURL(imgBlurDataURL) : void 0;

package/dist/shims/internal/app-page-props-cache-key.d.ts

@@ -0,0 +1,5 @@
+//#region src/shims/internal/app-page-props-cache-key.d.ts
+declare function markAppPagePropsForUseCache<T extends object>(props: T): T;
+declare function isMarkedAppPagePropsObject(value: object): boolean;
+//#endregion
+export { isMarkedAppPagePropsObject, markAppPagePropsForUseCache };

package/dist/shims/internal/app-page-props-cache-key.js

@@ -0,0 +1,16 @@
+//#region src/shims/internal/app-page-props-cache-key.ts
+const APP_PAGE_PROPS_CACHE_KEY_MARKER = Symbol.for("vinext.appPagePropsCacheKeyMarker");
+function markAppPagePropsForUseCache(props) {
+	Object.defineProperty(props, APP_PAGE_PROPS_CACHE_KEY_MARKER, {
+		configurable: false,
+		enumerable: false,
+		value: true,
+		writable: false
+	});
+	return props;
+}
+function isMarkedAppPagePropsObject(value) {
+	return Reflect.get(value, APP_PAGE_PROPS_CACHE_KEY_MARKER) === true;
+}
+//#endregion
+export { isMarkedAppPagePropsObject, markAppPagePropsForUseCache };

package/dist/shims/internal/interpolate-as.d.ts

@@ -0,0 +1,25 @@
+import { UrlQuery } from "../../utils/query.js";
+
+//#region src/shims/internal/interpolate-as.d.ts
+/**
+ * Wire-compatible alias for Node's `querystring.ParsedUrlQuery`. Inlined here
+ * so this module has no dependency on the `querystring` types package.
+ */
+type ParsedUrlQuery = {
+  [key: string]: string | string[] | undefined;
+};
+type DynamicRouteHrefProjection = {
+  href: string;
+  params: string[];
+  query: ParsedUrlQuery;
+  routePathname: string;
+};
+/**
+ * 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.
+ */
+declare function interpolateDynamicRouteHref(routeHref: string, asHref: string, queryInput?: UrlQuery): DynamicRouteHrefProjection | null;
+//#endregion
+export { DynamicRouteHrefProjection, interpolateDynamicRouteHref };

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/internal/navigation-untracked.js

@@ -1,5 +1,6 @@
+import { getNavigationContext } from "../navigation-context-state.js";
 import { getPagesNavigationContext } from "./pages-router-accessor.js";
-import { getClientNavigationState, getNavigationContext, useClientNavigationRenderSnapshot } from "../navigation.js";
+import { getClientNavigationState, useClientNavigationRenderSnapshot } from "../navigation.js";
 //#region src/shims/internal/navigation-untracked.ts
 /**
 * Internal navigation-untracked pathname hook.

package/dist/shims/layout-segment-context.d.ts

@@ -1,4 +1,4 @@
-import { SegmentMap } from "./navigation.js";
+import { SegmentMap } from "./navigation-context-state.js";
 import { ReactNode } from "react";
 
 //#region src/shims/layout-segment-context.d.ts

package/dist/shims/layout-segment-context.js

@@ -1,5 +1,6 @@
 "use client";
-import { getLayoutSegmentContext } from "./navigation.js";
+import { getLayoutSegmentContext } from "./navigation-context-state.js";
+import "./navigation-server.js";
 import { createElement } from "react";
 //#region src/shims/layout-segment-context.tsx
 /**

package/dist/shims/link.js

@@ -12,12 +12,13 @@ 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 { getNavigationRuntime, hasAppNavigationRuntime, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { createRscRequestHeaders, createRscRequestUrl, stripRscCacheBustingSearchParam, stripRscSuffix } from "../server/app-rsc-cache-busting.js";
-import { getMountedSlotsHeader, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, navigateClientSide, prefetchRscResponse } from "./navigation.js";
+import { getNavigationRuntime, hasAppNavigationRuntime, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { navigatePagesRouterLinkWithFallback, resolvePagesRouterQueryOnlyHref } from "../client/pages-router-link-navigation.js";
+import { getMountedSlotsHeader, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, navigateClientSide, prefetchRscResponse } from "./navigation.js";
 import { getI18nContext } from "./i18n-context.js";
 import { canLinkIntentPrefetch, canLinkPrefetch, getLinkPrefetchHref } from "./link-prefetch.js";
 import { clearLinkForCurrentNavigation, notifyLinkNavigationStart, setLinkForCurrentNavigation } from "./internal/link-status-registry.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-context-state.d.ts

@@ -0,0 +1,40 @@
+import * as React$1 from "react";
+
+//#region src/shims/navigation-context-state.d.ts
+/**
+ * Map of parallel route key to child segments below the current layout.
+ * The "children" key is always present.
+ */
+type SegmentMap = Readonly<Record<string, string[]>> & {
+  readonly children: string[];
+};
+type NavigationContext = {
+  pathname: string;
+  searchParams: URLSearchParams;
+  params: Record<string, string | string[]>;
+};
+declare const ServerInsertedHTMLContext: React$1.Context<((callback: () => unknown) => void) | null> | null;
+declare function getLayoutSegmentContext(): React$1.Context<SegmentMap> | null;
+declare function getBfcacheIdMapContext(): React$1.Context<Readonly<Record<string, string>> | null> | null;
+declare function getBfcacheSegmentIdContext(): React$1.Context<string | null> | null;
+type NavigationStateAccessors = {
+  getServerContext: () => NavigationContext | null;
+  setServerContext: (context: NavigationContext | null) => void;
+  getInsertedHTMLCallbacks: () => Array<() => unknown>;
+  clearInsertedHTMLCallbacks: () => void;
+};
+declare const GLOBAL_ACCESSORS_KEY: unique symbol;
+declare function clearClientHydrationContext(): void;
+/**
+ * Register request-scoped accessors supplied by navigation-state.ts.
+ * The global accessor key also bridges separate Vite module instances.
+ */
+declare function _registerStateAccessors(accessors: NavigationStateAccessors): void;
+declare function getNavigationContext(): NavigationContext | null;
+declare function setNavigationContext(context: NavigationContext | null): void;
+declare function registerServerInsertedHTMLCallback(callback: () => unknown): void;
+declare function flushServerInsertedHTML(): unknown[];
+declare function renderServerInsertedHTML(): unknown[];
+declare function clearServerInsertedHTML(): void;
+//#endregion
+export { GLOBAL_ACCESSORS_KEY, NavigationContext, NavigationStateAccessors, SegmentMap, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, flushServerInsertedHTML, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext };