vinext 0.1.0 → 0.1.1

package/dist/shims/cache-runtime.js

@@ -3,6 +3,7 @@ import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation }
 import { VINEXT_RSC_MARKER_HEADER } from "../server/headers.js";
 import { markDynamicUsage } from "./headers.js";
 import { _registerCacheContextAccessor, _setRequestScopedCacheLife, cacheLifeProfiles, getDataCacheHandler } from "./cache.js";
+import { addCollectedRequestTags } from "./fetch-cache.js";
 //#region src/shims/cache-runtime.ts
 /**
 * "use cache" runtime
@@ -270,6 +271,7 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 		const handler = getDataCacheHandler();
 		const existing = await handler.get(cacheKey, { kind: "FETCH" });
 		if (existing?.value && existing.value.kind === "FETCH" && existing.cacheState !== "stale") try {
+			propagateCacheTagsToRequest(existing.value.tags);
 			if (rsc && existing.value.data.headers["x-vinext-rsc"] === "1") {
 				const stream = uint8ToStream(base64ToUint8(existing.value.data.body));
 				const result = await rsc.createFromReadableStream(stream);
@@ -282,6 +284,7 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 		} catch {}
 		const { result, ctx, effectiveLife } = await runCachedFunctionWithContext(fn, args, cacheVariant);
 		recordRequestScopedCacheLife(effectiveLife);
+		propagateCacheTagsToRequest(ctx.tags);
 		const revalidateSeconds = effectiveLife.revalidate ?? cacheLifeProfiles.default.revalidate ?? 900;
 		try {
 			let body;
@@ -336,6 +339,30 @@ function recordRequestScopedCacheControl(cacheControl) {
 function recordRequestScopedCacheLife(cacheLife) {
 	_setRequestScopedCacheLife(cacheLife);
 }
+/**
+* Bubble a `"use cache"` scope's tags toward where they can drive invalidation.
+*
+* When this cache is nested inside another (`parentCtx` present), the tags flow
+* into the parent scope so they end up on the outer cache entry — mirroring
+* Next.js's `propagateCacheLifeAndTagsToRevalidateStore`. The outermost scope
+* (no parent) instead records onto the surrounding request's collected tags, so
+* the enclosing page / route-handler ISR entry carries them and `revalidateTag`
+* can evict the rendered output (issue #1453).
+*
+* Used by both the data cache HIT and MISS paths. On MISS the parent-bubble for
+* the *executed* scope also happens in `runCachedFunctionWithContext`; this keeps
+* the HIT path (where that function never runs) correct without dropping a nested
+* inner entry's stored tags. Deduped to keep tag lists tidy.
+*/
+function propagateCacheTagsToRequest(tags) {
+	if (!tags || tags.length === 0) return;
+	const parentCtx = cacheContextStorage.getStore();
+	if (parentCtx) {
+		for (const tag of tags) if (!parentCtx.tags.includes(tag)) parentCtx.tags.push(tag);
+		return;
+	}
+	addCollectedRequestTags(tags);
+}
 async function executeWithContext(fn, args, variant) {
 	const { result, ctx: _ctx, effectiveLife } = await runCachedFunctionWithContext(fn, args, variant);
 	recordRequestScopedCacheLife(effectiveLife);
@@ -360,7 +387,10 @@ async function runCachedFunctionWithContext(fn, args, variant) {
 	const result = await cacheContextStorage.run(ctx, () => fn(...args));
 	if (ctx.invalidDynamicUsageError) throw ctx.invalidDynamicUsageError;
 	const effectiveLife = resolveCacheLife(ctx.lifeConfigs);
-	if (parentCtx) parentCtx.lifeConfigs.push(effectiveLife);
+	if (parentCtx) {
+		parentCtx.lifeConfigs.push(effectiveLife);
+		for (const tag of ctx.tags) if (!parentCtx.tags.includes(tag)) parentCtx.tags.push(tag);
+	}
 	if (parentCtx && eagerError && (effectiveLife.revalidate === 0 || effectiveLife.expire !== void 0 && effectiveLife.expire < DYNAMIC_EXPIRE)) parentCtx.dynamicNestedCacheError ??= eagerError;
 	if (typeof process !== "undefined" && (process.env.VINEXT_PRERENDER === "1" || process.env.NODE_ENV === "development") && ctx.dynamicNestedCacheError) {
 		if (effectiveLife.revalidate === 0 && !ctx.hasExplicitRevalidate) throw new Error(getNestedCacheZeroRevalidateErrorMessage(), { cause: ctx.dynamicNestedCacheError });

package/dist/shims/error-boundary.d.ts

@@ -17,11 +17,11 @@ type RedirectBoundaryState = {
   redirectType: "push" | "replace" | null;
 };
 type ErrorBoundaryInnerProps = {
-  pathname: string;
+  pathname: string | null;
 } & ErrorBoundaryProps;
 type ErrorBoundaryState = {
   error: CapturedError | null;
-  previousPathname: string;
+  previousPathname: string | null;
   previousResetKey: string | null;
 };
 declare class RedirectErrorBoundary extends React.Component<{
@@ -31,7 +31,7 @@ declare class RedirectErrorBoundary extends React.Component<{
     children?: React.ReactNode;
   });
   static getDerivedStateFromError(error: unknown): RedirectBoundaryState;
-  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+  render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
 }
 declare function RedirectBoundary({
   children
@@ -51,13 +51,23 @@ declare class ErrorBoundaryInner extends React.Component<ErrorBoundaryInnerProps
   componentDidMount(): void;
   componentWillUnmount(): void;
   reset: () => void;
-  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+  render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
 }
 declare function ErrorBoundary({
   fallback,
   children,
   resetKey
 }: ErrorBoundaryProps): React.JSX.Element;
+declare function GlobalErrorBoundary({
+  fallback,
+  children
+}: {
+  fallback: React.ComponentType<{
+    error: unknown;
+    reset: () => void;
+  }>;
+  children: React.ReactNode;
+}): React.JSX.Element;
 type NotFoundBoundaryProps = {
   fallback: React.ReactNode;
   children: React.ReactNode;
@@ -78,18 +88,18 @@ type ForbiddenBoundaryProps = {
   resetKey?: string | null;
 };
 type ForbiddenBoundaryInnerProps = {
-  pathname: string;
+  pathname: string | null;
 } & ForbiddenBoundaryProps;
 type ForbiddenBoundaryState = {
   forbidden: boolean;
-  previousPathname: string;
+  previousPathname: string | null;
   previousResetKey: string | null;
 };
 declare class ForbiddenBoundaryInner extends React.Component<ForbiddenBoundaryInnerProps, ForbiddenBoundaryState> {
   constructor(props: ForbiddenBoundaryInnerProps);
   static getDerivedStateFromProps(props: ForbiddenBoundaryInnerProps, state: ForbiddenBoundaryState): ForbiddenBoundaryState | null;
   static getDerivedStateFromError(error: unknown): Partial<ForbiddenBoundaryState>;
-  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+  render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
 }
 declare function ForbiddenBoundary({
   fallback,
@@ -102,18 +112,18 @@ type UnauthorizedBoundaryProps = {
   resetKey?: string | null;
 };
 type UnauthorizedBoundaryInnerProps = {
-  pathname: string;
+  pathname: string | null;
 } & UnauthorizedBoundaryProps;
 type UnauthorizedBoundaryState = {
   unauthorized: boolean;
-  previousPathname: string;
+  previousPathname: string | null;
   previousResetKey: string | null;
 };
 declare class UnauthorizedBoundaryInner extends React.Component<UnauthorizedBoundaryInnerProps, UnauthorizedBoundaryState> {
   constructor(props: UnauthorizedBoundaryInnerProps);
   static getDerivedStateFromProps(props: UnauthorizedBoundaryInnerProps, state: UnauthorizedBoundaryState): UnauthorizedBoundaryState | null;
   static getDerivedStateFromError(error: unknown): Partial<UnauthorizedBoundaryState>;
-  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+  render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
 }
 declare function UnauthorizedBoundary({
   fallback,
@@ -140,4 +150,4 @@ declare class DevRecoveryBoundary extends React.Component<DevRecoveryBoundaryPro
   render(): React.ReactNode;
 }
 //#endregion
-export { DevRecoveryBoundary, DevRecoveryBoundaryProps, ErrorBoundary, ErrorBoundaryInner, ErrorBoundaryProps, ErrorBoundaryState, ForbiddenBoundary, ForbiddenBoundaryInner, NotFoundBoundary, RedirectBoundary, RedirectErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };
+export { DevRecoveryBoundary, DevRecoveryBoundaryProps, ErrorBoundary, ErrorBoundaryInner, ErrorBoundaryProps, ErrorBoundaryState, ForbiddenBoundary, ForbiddenBoundaryInner, GlobalErrorBoundary, NotFoundBoundary, RedirectBoundary, RedirectErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };

package/dist/shims/error-boundary.js

@@ -146,6 +146,13 @@ function ErrorBoundary({ fallback, children, resetKey }) {
 		children
 	});
 }
+function GlobalErrorBoundary({ fallback, children }) {
+	return /* @__PURE__ */ jsx(ErrorBoundaryInner, {
+		pathname: usePathname(),
+		fallback,
+		children
+	});
+}
 /**
 * Inner class component that catches notFound() errors and renders the
 * not-found.tsx fallback. Resets on the caller's segment reset key when one is
@@ -323,4 +330,4 @@ var DevRecoveryBoundary = class extends React.Component {
 	}
 };
 //#endregion
-export { DevRecoveryBoundary, ErrorBoundary, ErrorBoundaryInner, ForbiddenBoundary, ForbiddenBoundaryInner, NotFoundBoundary, RedirectBoundary, RedirectErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };
+export { DevRecoveryBoundary, ErrorBoundary, ErrorBoundaryInner, ForbiddenBoundary, ForbiddenBoundaryInner, GlobalErrorBoundary, NotFoundBoundary, RedirectBoundary, RedirectErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };

package/dist/shims/fetch-cache.d.ts

@@ -54,6 +54,19 @@ declare function consumeDynamicFetchObservations(): string[];
  * fetch tags used during rendering.
  */
 declare function getCollectedFetchTags(): string[];
+/**
+ * Append cache tags to the current request's collected tags.
+ *
+ * Mirrors Next.js's `propagateCacheLifeAndTagsToRevalidateStore`: tags declared
+ * inside a `"use cache"` function (via `cacheTag()`, persisted on the data cache
+ * entry) must also bubble up to the surrounding page / route-handler ISR entry
+ * so `revalidateTag()` / `revalidatePath()` can evict the rendered output, not
+ * just the inner data cache entry. Without this, a cached `"use cache"` result
+ * keeps being served from a stale page/route entry after its tag is revalidated
+ * (issue #1453). Tags are already encoded by the caller; deduped to match the
+ * tagged-fetch path. A no-op for empty input.
+ */
+declare function addCollectedRequestTags(tags: readonly string[]): void;
 /**
  * Set path-derived implicit tags for fetch cache reads in the current render.
  *
@@ -110,4 +123,4 @@ declare function ensureFetchPatch(): void;
  */
 declare function getOriginalFetch(): typeof globalThis.fetch;
 //#endregion
-export { FetchCacheMode, FetchCacheState, _resetPendingRefetches, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, withFetchCache };
+export { FetchCacheMode, FetchCacheState, _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, withFetchCache };

package/dist/shims/fetch-cache.js

@@ -343,6 +343,23 @@ function getCollectedFetchTags() {
 	return [..._getState().currentRequestTags];
 }
 /**
+* Append cache tags to the current request's collected tags.
+*
+* Mirrors Next.js's `propagateCacheLifeAndTagsToRevalidateStore`: tags declared
+* inside a `"use cache"` function (via `cacheTag()`, persisted on the data cache
+* entry) must also bubble up to the surrounding page / route-handler ISR entry
+* so `revalidateTag()` / `revalidatePath()` can evict the rendered output, not
+* just the inner data cache entry. Without this, a cached `"use cache"` result
+* keeps being served from a stale page/route entry after its tag is revalidated
+* (issue #1453). Tags are already encoded by the caller; deduped to match the
+* tagged-fetch path. A no-op for empty input.
+*/
+function addCollectedRequestTags(tags) {
+	if (tags.length === 0) return;
+	const reqTags = _getState().currentRequestTags;
+	for (const tag of tags) if (!reqTags.includes(tag)) reqTags.push(tag);
+}
+/**
 * Set path-derived implicit tags for fetch cache reads in the current render.
 *
 * These are intentionally not persisted on fetch entries. They mirror Next.js
@@ -711,4 +728,4 @@ function getOriginalFetch() {
 	return originalFetch;
 }
 //#endregion
-export { _resetPendingRefetches, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, withFetchCache };
+export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, withFetchCache };

package/dist/shims/hash-scroll.d.ts

@@ -3,6 +3,7 @@ declare function decodeHashFragment(fragment: string): string;
 declare function scrollToHashTarget(hash: string): void;
 declare function scrollToHashTargetOnNextFrame(hash: string): void;
 declare function retryScrollTo(x: number, y: number, opts?: {
+  minFrames?: number;
   shouldContinue?: () => boolean;
 }): void;
 //#endregion

package/dist/shims/hash-scroll.js

@@ -25,12 +25,14 @@ function scrollToHashTargetOnNextFrame(hash) {
 	});
 }
 function retryScrollTo(x, y, opts) {
+	const minFrames = opts?.minFrames ?? 0;
 	const shouldContinue = opts?.shouldContinue ?? (() => true);
 	let attempts = 0;
 	const restore = () => {
 		if (!shouldContinue()) return;
 		window.scrollTo(x, y);
-		if (!shouldContinue() || Math.abs(window.scrollY - y) <= 1 || attempts >= 60) return;
+		const reachedTarget = Math.abs(window.scrollY - y) <= 1;
+		if (!shouldContinue() || reachedTarget && attempts >= minFrames || attempts >= 60) return;
 		attempts += 1;
 		requestAnimationFrame(restore);
 	};

package/dist/shims/internal/link-status-registry.d.ts

@@ -0,0 +1,43 @@
+//#region src/shims/internal/link-status-registry.d.ts
+/**
+ * Link-status pending registry.
+ *
+ * Tracks the single <Link> that started the most recent App Router navigation
+ * so its `useLinkStatus()` pending state can be reset when a *different*
+ * navigation begins — a different <Link> click, `router.push`/`router.replace`,
+ * a form submission, shallow routing via raw `history.pushState`, or browser
+ * back/forward. Without this, a Link's pending indicator stays "sticky" after
+ * an interrupting navigation, because the Link's own completion handler is the
+ * only thing that would otherwise clear it.
+ *
+ * Mirrors Next.js's `linkForMostRecentNavigation` /
+ * `setLinkForCurrentNavigation` in
+ * packages/next/src/client/components/links.ts, adapted to vinext's per-<Link>
+ * React state model: instead of an optimistic-status dispatcher, we hold the
+ * link's `setPending` setter.
+ */
+type PendingLinkSetter = (pending: boolean) => void;
+/**
+ * Mark `setter` as the link that started the most recent navigation, resetting
+ * the previously-tracked link's pending state to idle so only the last-clicked
+ * link shows a pending state.
+ */
+declare function setLinkForCurrentNavigation(setter: PendingLinkSetter): void;
+/**
+ * Stop tracking `setter` if it is the current navigation link. Called when a
+ * <Link> finishes its own navigation or unmounts so we never hold a stale
+ * reference to an unmounted component's setter.
+ */
+declare function clearLinkForCurrentNavigation(setter: PendingLinkSetter): void;
+/**
+ * Reset any link that is currently showing a pending state. Invoked at the
+ * start of every App Router navigation so that navigations not initiated by the
+ * tracked link — `router.push`/`router.replace`, form submissions, shallow
+ * routing, and browser back/forward — clear a stale pending indicator. A
+ * link-initiated navigation registers itself first via
+ * `setLinkForCurrentNavigation`; the matching call here consumes that marker and
+ * keeps the link pending.
+ */
+declare function notifyLinkNavigationStart(): void;
+//#endregion
+export { PendingLinkSetter, clearLinkForCurrentNavigation, notifyLinkNavigationStart, setLinkForCurrentNavigation };

package/dist/shims/internal/link-status-registry.js

@@ -0,0 +1,42 @@
+//#region src/shims/internal/link-status-registry.ts
+let linkSetterForMostRecentNavigation = null;
+let currentNavigationIsLinkInitiated = false;
+/**
+* Mark `setter` as the link that started the most recent navigation, resetting
+* the previously-tracked link's pending state to idle so only the last-clicked
+* link shows a pending state.
+*/
+function setLinkForCurrentNavigation(setter) {
+	if (linkSetterForMostRecentNavigation && linkSetterForMostRecentNavigation !== setter) linkSetterForMostRecentNavigation(false);
+	linkSetterForMostRecentNavigation = setter;
+	currentNavigationIsLinkInitiated = true;
+}
+/**
+* Stop tracking `setter` if it is the current navigation link. Called when a
+* <Link> finishes its own navigation or unmounts so we never hold a stale
+* reference to an unmounted component's setter.
+*/
+function clearLinkForCurrentNavigation(setter) {
+	if (linkSetterForMostRecentNavigation === setter) linkSetterForMostRecentNavigation = null;
+}
+/**
+* Reset any link that is currently showing a pending state. Invoked at the
+* start of every App Router navigation so that navigations not initiated by the
+* tracked link — `router.push`/`router.replace`, form submissions, shallow
+* routing, and browser back/forward — clear a stale pending indicator. A
+* link-initiated navigation registers itself first via
+* `setLinkForCurrentNavigation`; the matching call here consumes that marker and
+* keeps the link pending.
+*/
+function notifyLinkNavigationStart() {
+	if (currentNavigationIsLinkInitiated) {
+		currentNavigationIsLinkInitiated = false;
+		return;
+	}
+	if (linkSetterForMostRecentNavigation) {
+		linkSetterForMostRecentNavigation(false);
+		linkSetterForMostRecentNavigation = null;
+	}
+}
+//#endregion
+export { clearLinkForCurrentNavigation, notifyLinkNavigationStart, setLinkForCurrentNavigation };

package/dist/shims/internal/route-pattern-for-warning.d.ts

@@ -0,0 +1,27 @@
+//#region src/shims/internal/route-pattern-for-warning.d.ts
+/**
+ * Side-effect-free accessor for the current render's route pattern, used by
+ * Next.js-parity diagnostics such as the Link shim's
+ * "Invalid href ... in page: '...'" `console.error`.
+ *
+ * Mirrors Next.js's `router.pathname`, which is the *route pattern* (e.g.
+ * `/posts/[id]`), not the resolved URL. During Pages Router SSR the route
+ * pattern lives on the request-scoped SSR context; the server-only
+ * `router-state.ts` publishes an accessor for it under a well-known
+ * `Symbol.for` handle. We read it through that handle rather than importing
+ * `router.ts` directly — importing `router.ts` would pull its browser-only
+ * `installWindowNext()` side effect into every consumer of the Link shim
+ * (including the App Router client bundle), clobbering `window.next.router`.
+ *
+ * On the client (or when no accessor is registered, e.g. App Router) we fall
+ * back to `window.location.pathname`, then to `"/"`.
+ */
+/**
+ * Register the server-side route-pattern accessor. Called once by the
+ * server-only router-state module on import. Idempotent.
+ * @internal
+ */
+declare function registerRoutePatternForWarningAccessor(accessor: () => string | null): void;
+declare function getCurrentRoutePathnameForWarning(): string;
+//#endregion
+export { getCurrentRoutePathnameForWarning, registerRoutePatternForWarningAccessor };

package/dist/shims/internal/route-pattern-for-warning.js

@@ -0,0 +1,40 @@
+//#region src/shims/internal/route-pattern-for-warning.ts
+/**
+* Side-effect-free accessor for the current render's route pattern, used by
+* Next.js-parity diagnostics such as the Link shim's
+* "Invalid href ... in page: '...'" `console.error`.
+*
+* Mirrors Next.js's `router.pathname`, which is the *route pattern* (e.g.
+* `/posts/[id]`), not the resolved URL. During Pages Router SSR the route
+* pattern lives on the request-scoped SSR context; the server-only
+* `router-state.ts` publishes an accessor for it under a well-known
+* `Symbol.for` handle. We read it through that handle rather than importing
+* `router.ts` directly — importing `router.ts` would pull its browser-only
+* `installWindowNext()` side effect into every consumer of the Link shim
+* (including the App Router client bundle), clobbering `window.next.router`.
+*
+* On the client (or when no accessor is registered, e.g. App Router) we fall
+* back to `window.location.pathname`, then to `"/"`.
+*/
+const ROUTE_PATTERN_FOR_WARNING_ACCESSOR_KEY = Symbol.for("vinext.router.routePatternForWarningAccessor");
+/**
+* Register the server-side route-pattern accessor. Called once by the
+* server-only router-state module on import. Idempotent.
+* @internal
+*/
+function registerRoutePatternForWarningAccessor(accessor) {
+	globalThis[ROUTE_PATTERN_FOR_WARNING_ACCESSOR_KEY] = accessor;
+}
+function getCurrentRoutePathnameForWarning() {
+	if (typeof window === "undefined") {
+		const accessor = globalThis[ROUTE_PATTERN_FOR_WARNING_ACCESSOR_KEY];
+		if (accessor) try {
+			const pattern = accessor();
+			if (pattern) return pattern;
+		} catch {}
+		return "/";
+	}
+	return window.location?.pathname ?? "/";
+}
+//#endregion
+export { getCurrentRoutePathnameForWarning, registerRoutePatternForWarningAccessor };

package/dist/shims/internal/utils.d.ts

@@ -21,6 +21,7 @@ type NEXT_DATA = {
     statusCode: number;
     name?: string;
   };
+  isExperimentalCompile?: boolean;
   gsp?: boolean;
   gssp?: boolean;
   customServer?: boolean;

package/dist/shims/link.js

@@ -12,12 +12,14 @@ import { markAppRouteDetectedOnPrefetch } from "./internal/app-route-detection.j
 import { isAbsoluteOrProtocolRelativeUrl, normalizePathTrailingSlash, resolveRelativeHref, toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
 import { appendSearchParamsToUrl, urlQueryToSearchParams } from "../utils/query.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 { navigatePagesRouterLink } from "../client/pages-router-link-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";
 import React, { createContext, forwardRef, useCallback, useContext, useEffect, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region src/shims/link.tsx
@@ -37,6 +39,7 @@ const LinkStatusContext = createContext({ pending: false });
 function useLinkStatus() {
 	return useContext(LinkStatusContext);
 }
+if (typeof window !== "undefined") registerNavigationRuntimeFunctions({ notifyLinkNavigationStart });
 /** basePath from next.config.js, injected by the plugin at build time */
 const __basePath = process.env.__NEXT_ROUTER_BASEPATH ?? "";
 /** trailingSlash from next.config.js, injected by the plugin at build time */
@@ -45,7 +48,7 @@ const __prefetchInlining = process.env.__VINEXT_PREFETCH_INLINING === "true";
 const linkPrefetchRouteTrieCache = createRouteTrieCache();
 function resolveHref(href) {
 	if (typeof href === "string") return href;
-	let url = href.pathname ?? "/";
+	let url = href.pathname ?? "";
 	if (href.query) {
 		const params = urlQueryToSearchParams(href.query);
 		url = appendSearchParamsToUrl(url, params);
@@ -81,17 +84,19 @@ function normalizeRepeatedSlashes(url) {
 * `resolveHref`. We mirror that behaviour (no dedup) for exact parity.
 *
 * Note: Next.js uses `router.pathname` (the route pattern, e.g.
-* `/posts/[id]`) for the "in page" segment of the message. We do not have
-* cheap access to the route pattern from inside the Link shim, so we
-* fall back to `window.location.pathname` (or `"/"` during SSR). The text
-* is cosmetic and is not asserted by the Next.js compat test.
+* `/posts/[id]`) for the "in page" segment of the message. The Next.js
+* compat test asserts this exact text (`in page: '/my/path/[name]'`), so we
+* source it from the current render's route pattern via
+* `getCurrentRoutePathnameForWarning()`: the Pages Router SSR context's route
+* pattern on the server, `window.location.pathname` on the client, falling
+* back to `"/"`.
 */
 function warnAndNormalizeRepeatedSlashesInHref(urlAsString) {
 	if (urlAsString.startsWith("//")) return urlAsString;
 	const urlProtoMatch = urlAsString.match(/^[a-z][a-z0-9+.-]*:\/\//i);
 	const urlAsStringNoProto = urlProtoMatch ? urlAsString.slice(urlProtoMatch[0].length) : urlAsString;
 	if (!(urlAsStringNoProto.split("?", 1)[0] || "").match(/(\/\/|\\)/)) return urlAsString;
-	const pathname = typeof window !== "undefined" && window.location ? window.location.pathname : "/";
+	const pathname = getCurrentRoutePathnameForWarning();
 	console.error(`Invalid href '${urlAsString}' passed to next/router in page: '${pathname}'. Repeated forward-slashes (//) or backslashes \\ are not valid in the href.`);
 	const normalizedNoProto = normalizeRepeatedSlashes(urlAsStringNoProto);
 	return (urlProtoMatch ? urlProtoMatch[0] : "") + normalizedNoProto;
@@ -381,10 +386,16 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 	const fullHref = normalizePathTrailingSlash(withBasePath(normalizedHref, __basePath), __trailingSlash);
 	const [pending, setPending] = useState(false);
 	const mountedRef = useRef(true);
+	const setPendingRef = useRef(null);
+	if (setPendingRef.current === null) setPendingRef.current = (next) => {
+		if (mountedRef.current) setPending(next);
+	};
 	useEffect(() => {
 		mountedRef.current = true;
+		const setter = setPendingRef.current;
 		return () => {
 			mountedRef.current = false;
+			if (setter) clearLinkForCurrentNavigation(setter);
 		};
 	}, []);
 	const internalRef = useRef(null);
@@ -497,10 +508,13 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 			if (navEvent.defaultPrevented) return;
 		} catch {}
 		if (getNavigationRuntime()?.functions.navigate) {
+			const setter = setPendingRef.current;
+			if (setter) setLinkForCurrentNavigation(setter);
 			setPending(true);
 			React.startTransition(() => {
 				navigateClientSide(navigateHref, replace ? "replace" : "push", scroll, true).finally(() => {
 					if (mountedRef.current) setPending(false);
+					if (setter) clearLinkForCurrentNavigation(setter);
 				});
 			});
 			return;

package/dist/shims/navigation.d.ts

@@ -225,7 +225,7 @@ declare function clearPendingPathname(navId: number): void;
  * Returns the current pathname.
  * Server: from request context. Client: from window.location.
  */
-declare function usePathname(): string;
+declare function usePathname(): string | null;
 /**
  * Returns the current search params as a read-only URLSearchParams.
  */
@@ -233,7 +233,7 @@ declare function useSearchParams(): ReadonlyURLSearchParams;
 /**
  * Returns the dynamic params for the current route.
  */
-declare function useParams<T extends Record<string, string | string[]> = Record<string, string | string[]>>(): T;
+declare function useParams<T extends Record<string, string | string[]> = Record<string, string | string[]>>(): T | null;
 /**
  * Commit pending client navigation state to committed snapshots.
  *