vinext 0.1.0 → 0.1.2

package/dist/server/socket-error-backstop.js

@@ -15,9 +15,10 @@
 * `uncaughtException`, where this listener filters it.
 *
 * Filters strictly on peer-disconnect codes (ECONNRESET / EPIPE /
-* ECONNABORTED) and synchronously re-throws everything else,
-* preserving Node's default crash semantics for genuine bugs. This
-* is more conservative than Next.js's equivalent
+* ECONNABORTED) plus benign static-asset `import()` rejections (see
+* `isBenignAssetImportError`), and synchronously re-throws everything
+* else, preserving Node's default crash semantics for genuine bugs.
+* This is more conservative than Next.js's equivalent
 * (`router-server.ts`'s log-only handler), which silently swallows
 * every uncaught — vinext keeps real bugs surfacing.
 *
@@ -89,6 +90,68 @@ function peerDisconnectCode(err) {
 	const code = err?.code;
 	return code === "ECONNRESET" || code === "EPIPE" || code === "ECONNABORTED" ? code : void 0;
 }
+const STATIC_ASSET_IMPORT_EXTENSIONS = new Set([
+	".css",
+	".scss",
+	".sass",
+	".less",
+	".styl",
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".svg",
+	".webp",
+	".avif",
+	".ico",
+	".bmp",
+	".woff",
+	".woff2",
+	".ttf",
+	".otf",
+	".eot",
+	".txt",
+	".md",
+	".csv",
+	".xml",
+	".pdf",
+	".wasm"
+]);
+/**
+* Pure predicate: returns `true` when `err` is a benign failure from a
+* dynamic `import()` of a static asset URL — the "URL dependency" pattern
+* that Next.js tolerates at build time. Two shapes are recognised:
+*
+*   - `ERR_UNKNOWN_FILE_EXTENSION`: the asset resolved on disk but is not an
+*     ES module (e.g. a co-located `./style.css`). The error message ends in
+*     the offending extension in quotes: `... extension ".css" for /path`.
+*   - `ERR_MODULE_NOT_FOUND`: the asset URL did not resolve (the chunk lives
+*     in `dist/server/` but the source asset does not). Node attaches the
+*     unresolved specifier on `err.url`; we match only when it points at a
+*     static-asset extension.
+*
+* Anything outside this allow-list (including missing `.js`/`.mjs`/`.ts`
+* modules with no extension) returns `false` so real bugs still crash.
+* Exported for unit testing in isolation.
+*/
+function isBenignAssetImportError(err) {
+	if (err === null || typeof err !== "object") return false;
+	const code = err.code;
+	if (code === "ERR_UNKNOWN_FILE_EXTENSION") {
+		const message = err.message ?? "";
+		const match = /extension\s+"([^"]+)"/.exec(message);
+		return match != null && STATIC_ASSET_IMPORT_EXTENSIONS.has(match[1].toLowerCase());
+	}
+	if (code === "ERR_MODULE_NOT_FOUND") {
+		const url = err.url;
+		if (typeof url !== "string") return false;
+		const pathname = url.split("?", 1)[0].split("#", 1)[0];
+		const dot = pathname.lastIndexOf(".");
+		if (dot === -1) return false;
+		return STATIC_ASSET_IMPORT_EXTENSIONS.has(pathname.slice(dot).toLowerCase());
+	}
+	return false;
+}
 /**
 * Test-only: returns whether the backstop has been installed in this
 * process. Used by the unit test to assert idempotent install via the
@@ -104,7 +167,16 @@ function installSocketErrorBackstop() {
 	proc[SOCKET_BACKSTOP_FLAG] = true;
 	const debug = process.env.VINEXT_DEBUG_SOCKET_ERRORS === "1";
 	if (debug) console.warn("[vinext] socket-error backstop installed");
+	const absorbBenignAssetImport = (reason, kind) => {
+		if (!isBenignAssetImportError(reason)) return false;
+		if (debug) {
+			const code = reason?.code;
+			console.warn(`[vinext] absorbed ${kind} ${code} (asset URL import)`);
+		}
+		return true;
+	};
 	process.on("uncaughtException", (err) => {
+		if (absorbBenignAssetImport(err, "uncaughtException")) return;
 		if (process.env.VINEXT_PRERENDER === "1") throw err;
 		const code = peerDisconnectCode(err);
 		if (code) {
@@ -114,6 +186,7 @@ function installSocketErrorBackstop() {
 		throw err;
 	});
 	process.on("unhandledRejection", (reason) => {
+		if (absorbBenignAssetImport(reason, "unhandledRejection")) return;
 		if (process.env.VINEXT_PRERENDER === "1") throw reason;
 		const code = peerDisconnectCode(reason);
 		if (code) {
@@ -124,4 +197,4 @@ function installSocketErrorBackstop() {
 	});
 }
 //#endregion
-export { installSocketErrorBackstop, isSocketErrorBackstopInstalled, peerDisconnectCode };
+export { installSocketErrorBackstop, isBenignAssetImportError, isSocketErrorBackstopInstalled, peerDisconnectCode };

package/dist/shims/app-router-scroll.js

@@ -49,14 +49,22 @@ function getHashFragmentDomNode(hash) {
 	const element = document.getElementById(fragment) ?? document.getElementsByName(fragment)[0];
 	return element instanceof HTMLElement ? element : null;
 }
+function isInDocumentHead(node) {
+	const head = node.ownerDocument?.head;
+	return head != null && head.contains(node);
+}
 function findNextScrollTarget(node) {
 	if (!(node instanceof Element)) return null;
+	if (isInDocumentHead(node)) return { kind: "document-top" };
 	let target = node;
 	while (!(target instanceof HTMLElement) || shouldSkipElement(target)) {
 		if (target.nextElementSibling === null) return null;
 		target = target.nextElementSibling;
 	}
-	return target;
+	return {
+		kind: "element",
+		element: target
+	};
 }
 function scrollToElement(target, hash) {
 	if (hash !== null) {
@@ -79,9 +87,19 @@ var AppRouterScrollTargetInner = class extends React$1.Component {
 		if (intent === null) return;
 		if (this.props.commitId === null || intent.commitId !== this.props.commitId) return;
 		let target;
-		if (intent.hash !== null) target = getHashFragmentDomNode(intent.hash);
-		else target = findNextScrollTarget(findDOMNode(this));
-		if (target === null) return;
+		if (intent.hash !== null) {
+			target = getHashFragmentDomNode(intent.hash);
+			if (target === null) return;
+		} else {
+			const next = findNextScrollTarget(findDOMNode(this));
+			if (next === null) return;
+			if (next.kind === "document-top") {
+				if (consumeAppRouterScrollIntent(intent, this.props.commitId) === null) return;
+				document.documentElement.scrollTop = 0;
+				return;
+			}
+			target = next.element;
+		}
 		const consumed = consumeAppRouterScrollIntent(intent, this.props.commitId);
 		if (consumed === null) return;
 		scrollToElement(target, consumed.hash);

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, getCurrentFetchSoftTags } from "./fetch-cache.js";
 //#region src/shims/cache-runtime.ts
 /**
 * "use cache" runtime
@@ -268,8 +269,13 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 		}
 		if (isDev) return executeWithContext(fn, args, cacheVariant);
 		const handler = getDataCacheHandler();
-		const existing = await handler.get(cacheKey, { kind: "FETCH" });
+		const softTags = getCurrentFetchSoftTags();
+		const existing = await handler.get(cacheKey, {
+			kind: "FETCH",
+			softTags
+		});
 		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 +288,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;
@@ -318,8 +325,11 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 		value: fn.length,
 		configurable: true
 	});
+	cachedFn[USE_CACHE_FUNCTION_SYMBOL] = true;
 	return cachedFn;
 }
+/** @internal Symbol used to identify "use cache" wrapper functions. */
+const USE_CACHE_FUNCTION_SYMBOL = Symbol.for("vinext.useCacheFunction");
 function throwPrivateUseCacheInsidePublicUseCacheError() {
 	const error = /* @__PURE__ */ new Error("\"use cache: private\" must not be used within \"use cache\". It can only be nested inside of another \"use cache: private\".");
 	const ctx = getRequestContext();
@@ -336,6 +346,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 +394,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/dynamic-preload-chunks.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+
+//#region src/shims/dynamic-preload-chunks.d.ts
+declare function DynamicPreloadChunks(props: {
+  moduleIds?: readonly string[];
+}): React.FunctionComponentElement<React.FragmentProps> | null;
+//#endregion
+export { DynamicPreloadChunks };

package/dist/shims/dynamic-preload-chunks.js

@@ -0,0 +1,77 @@
+"use client";
+import { useScriptNonce } from "./script-nonce-context.js";
+import React from "react";
+import * as ReactDOM from "react-dom";
+//#region src/shims/dynamic-preload-chunks.tsx
+/**
+* Preload links for rendered next/dynamic() boundaries.
+*
+* This MUST be a "use client" component. next/dynamic() can be called from
+* either a Server Component or a Client Component. If this rendered in the
+* environment of the call site, a Server-Component call site would render it in
+* the RSC environment, where the script-nonce React context is unavailable
+* (createContext is not callable in react-server), so emitted preload links
+* would drop the request CSP nonce — a CSP violation under
+* `script-src 'nonce-…' 'strict-dynamic'`.
+*
+* Marking it "use client" forces it into the SSR pass (where vinext installs
+* the ScriptNonceProvider via withScriptNonce()), so the nonce is available
+* regardless of whether the dynamic() call site is a Server or Client
+* Component. This mirrors Next.js's <PreloadChunks> ('use client') and vinext's
+* own next/script shim.
+*
+* Deliberate divergence from Next.js: for CSS we render
+* `<link rel="stylesheet">` WITHOUT `as="style"`. Next.js emits `as="style"`,
+* but per the HTML spec `as` is only meaningful on `rel="preload"`/`modulepreload`
+* — on `rel="stylesheet"` it is ignored by browsers and is semantically wrong.
+* React keys stylesheet resources on href + precedence, not `as`, so omitting it
+* is safe. This is an intentional, documented difference, not a parity bug.
+*/
+function dynamicPreloadHref(file) {
+	if (file.startsWith("/") || file.startsWith("http://") || file.startsWith("https://") || file.startsWith("//")) return file;
+	return `/${file}`;
+}
+function resolveDynamicPreloadFiles(moduleIds) {
+	if (!moduleIds || moduleIds.length === 0) return [];
+	const preloadMap = globalThis.__VINEXT_DYNAMIC_PRELOADS__;
+	if (!preloadMap) return [];
+	const files = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const moduleId of moduleIds) for (const file of preloadMap[moduleId] ?? []) {
+		if (seen.has(file)) continue;
+		seen.add(file);
+		files.push(file);
+	}
+	return files;
+}
+function DynamicPreloadChunks(props) {
+	const nonce = useScriptNonce();
+	if (typeof window !== "undefined") return null;
+	const files = resolveDynamicPreloadFiles(props.moduleIds);
+	if (files.length === 0) return null;
+	const stylesheets = [];
+	for (const file of files) {
+		const href = dynamicPreloadHref(file);
+		if (href.endsWith(".css")) {
+			stylesheets.push(React.createElement("link", {
+				key: href,
+				rel: "stylesheet",
+				href,
+				nonce,
+				precedence: "dynamic"
+			}));
+			continue;
+		}
+		if (href.endsWith(".js") && typeof ReactDOM.preload === "function") {
+			const preloadOptions = {
+				as: "script",
+				fetchPriority: "low",
+				nonce
+			};
+			ReactDOM.preload(href, preloadOptions);
+		}
+	}
+	return stylesheets.length > 0 ? React.createElement(React.Fragment, null, ...stylesheets) : null;
+}
+//#endregion
+export { DynamicPreloadChunks };

package/dist/shims/dynamic.d.ts

@@ -16,6 +16,10 @@ type LoaderFn<P> = () => LoaderComponent<P>;
 type DynamicOptions<P> = {
   loading?: ComponentType<DynamicLoadingProps>;
   loader?: Loader<P>;
+  loadableGenerated?: {
+    modules?: readonly string[];
+  };
+  modules?: readonly string[];
   ssr?: boolean;
 };
 type Loader<P> = LoaderFn<P> | LoaderComponent<P>;

package/dist/shims/dynamic.js

@@ -1,3 +1,4 @@
+import { DynamicPreloadChunks } from "./dynamic-preload-chunks.js";
 import React from "react";
 //#region src/shims/dynamic.ts
 /**
@@ -121,8 +122,9 @@ function flushPreloads() {
 	return Promise.all(pending);
 }
 function dynamic(dynamicInput, options) {
-	const { loader: dynamicLoader, loading: LoadingComponent, ssr = true } = normalizeDynamicOptions(dynamicInput, options);
+	const { loader: dynamicLoader, loadableGenerated, loading: LoadingComponent, modules, ssr = true } = normalizeDynamicOptions(dynamicInput, options);
 	const loader = dynamicLoader ? normalizeLoader(dynamicLoader) : () => Promise.resolve(() => null);
+	const preloadModuleIds = loadableGenerated?.modules ?? modules;
 	if (!ssr) {
 		if (isServer) {
 			const SSRFalse = (_props) => LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps({ pastDelay: false })) : null;
@@ -174,7 +176,7 @@ function dynamic(dynamicInput, options) {
 					resetKey: 0
 				}, lazyElement);
 			}
-			return React.createElement(React.Suspense, { fallback }, content);
+			return React.createElement(React.Fragment, null, React.createElement(DynamicPreloadChunks, { moduleIds: preloadModuleIds }), React.createElement(React.Suspense, { fallback }, content));
 		};
 		ServerDynamic.displayName = "DynamicServer";
 		return ServerDynamic;

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<{
@@ -58,6 +58,16 @@ declare function ErrorBoundary({
   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,11 +88,11 @@ 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> {
@@ -102,11 +112,11 @@ 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> {
@@ -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/error.js

@@ -1,5 +1,6 @@
+import { AppRouterContext } from "./internal/app-router-context.js";
 import { RouterContext } from "./internal/router-context.js";
-import { appRouterInstance, isNextRouterError } from "./navigation.js";
+import { isNextRouterError, usePathname } from "./navigation.js";
 import React from "react";
 //#region src/shims/error.tsx
 /**
@@ -39,33 +40,53 @@ function ErrorComponent({ statusCode, title }) {
 		margin: 0
 	} }, displayTitle + "."))));
 }
+const _CatchErrorAppRouterContext = AppRouterContext ?? React.createContext(null);
 var _CatchError = class extends React.Component {
-	static contextType = RouterContext;
+	static contextType = _CatchErrorAppRouterContext;
 	static displayName = "unstable_catchError(Next.CatchError)";
-	state = { error: null };
+	constructor(props) {
+		super(props);
+		this.state = {
+			error: null,
+			previousPathname: props.pathname
+		};
+	}
 	static getDerivedStateFromError(thrownValue) {
 		if (isNextRouterError(thrownValue)) throw thrownValue;
 		return { error: { thrownValue } };
 	}
+	static getDerivedStateFromProps(props, state) {
+		if (props.pathname !== state.previousPathname && state.error) return {
+			error: null,
+			previousPathname: props.pathname
+		};
+		return {
+			error: state.error,
+			previousPathname: props.pathname
+		};
+	}
 	reset = () => {
 		this.setState({ error: null });
 	};
 	unstable_retry = () => {
-		if (this.context !== null) throw new Error("`unstable_retry()` can only be used in the App Router. Use `reset()` in the Pages Router.");
-		if (typeof window === "undefined") throw new Error("`unstable_retry()` can only be used on the client. Call it from a user interaction handler inside the error fallback.");
+		if (this.props.isPagesRouter) throw new Error("`unstable_retry()` can only be used in the App Router. Use `reset()` in the Pages Router.");
 		React.startTransition(() => {
-			appRouterInstance.refresh();
+			this.context?.refresh();
 			this.reset();
 		});
 	};
 	render() {
 		if (this.state.error) {
+			const Fallback = this.props.fallback;
 			const errorInfo = {
 				error: this.state.error.thrownValue,
 				reset: this.reset,
 				unstable_retry: this.unstable_retry
 			};
-			return this.props.fallback(this.props.forwardedProps, errorInfo);
+			return React.createElement(Fallback, {
+				props: this.props.props,
+				errorInfo
+			});
 		}
 		return this.props.children;
 	}
@@ -79,13 +100,18 @@ var _CatchError = class extends React.Component {
 *   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/catch-error.tsx
 */
 function unstable_catchError(fallback) {
-	const TypedCatchError = _CatchError;
+	const Fallback = ({ props, errorInfo }) => fallback(props, errorInfo);
+	Fallback.displayName = fallback.name || "CatchErrorFallback";
 	function CatchErrorBoundary(allProps) {
 		const { children, ...rest } = allProps;
+		const pathname = usePathname();
+		const isPagesRouter = React.useContext(RouterContext) !== null;
 		const forwardedProps = rest;
-		return React.createElement(TypedCatchError, {
-			fallback,
-			forwardedProps
+		return React.createElement(_CatchError, {
+			fallback: Fallback,
+			isPagesRouter,
+			pathname,
+			props: forwardedProps
 		}, children);
 	}
 	CatchErrorBoundary.displayName = `unstable_catchError(${fallback.name || "CatchErrorFallback"})`;

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.
  *
@@ -62,6 +75,14 @@ declare function getCollectedFetchTags(): string[];
  * affected route, without permanently coupling a shared fetch entry to one path.
  */
 declare function setCurrentFetchSoftTags(tags: string[]): void;
+/**
+ * Read the path-derived soft tags for the current render.
+ *
+ * Used by the "use cache" runtime to pass soft tags to the cache handler
+ * so that `revalidatePath()` invalidates "use cache" entries during the
+ * affected route's next request, even when the entry carries no hard tags.
+ */
+declare function getCurrentFetchSoftTags(): string[];
 declare function setCurrentFetchCacheMode(mode: FetchCacheMode | null): void;
 /**
  * Install the patched fetch and reset per-request tag state.
@@ -110,4 +131,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, getCurrentFetchSoftTags, 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
@@ -352,6 +369,16 @@ function getCollectedFetchTags() {
 function setCurrentFetchSoftTags(tags) {
 	_getState().currentFetchSoftTags = [...tags];
 }
+/**
+* Read the path-derived soft tags for the current render.
+*
+* Used by the "use cache" runtime to pass soft tags to the cache handler
+* so that `revalidatePath()` invalidates "use cache" entries during the
+* affected route's next request, even when the entry carries no hard tags.
+*/
+function getCurrentFetchSoftTags() {
+	return _getState().currentFetchSoftTags;
+}
 function setCurrentFetchCacheMode(mode) {
 	_getState().currentFetchCacheMode = mode;
 }
@@ -711,4 +738,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, getCurrentFetchSoftTags, 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);
 	};