vinext 0.1.1 → 0.1.3

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

@@ -1,6 +1,6 @@
 "use client";
 import { decodeHashFragment } from "./hash-scroll.js";
-import { consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent } from "./app-router-scroll-state.js";
+import { consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent, markAppRouterScrollIntentHeadHoisted } from "./app-router-scroll-state.js";
 import * as React$1 from "react";
 import { jsx } from "react/jsx-runtime";
 import * as ReactDOM from "react-dom";
@@ -46,8 +46,7 @@ function topOfElementInViewport(element, viewportHeight) {
 function getHashFragmentDomNode(hash) {
 	const fragment = decodeHashFragment(hash.startsWith("#") ? hash.slice(1) : hash);
 	if (fragment === "top") return document.body;
-	const element = document.getElementById(fragment) ?? document.getElementsByName(fragment)[0];
-	return element instanceof HTMLElement ? element : null;
+	return document.getElementById(fragment) ?? document.getElementsByName(fragment)[0] ?? null;
 }
 function isInDocumentHead(node) {
 	const head = node.ownerDocument?.head;
@@ -55,7 +54,7 @@ function isInDocumentHead(node) {
 }
 function findNextScrollTarget(node) {
 	if (!(node instanceof Element)) return null;
-	if (isInDocumentHead(node)) return { kind: "document-top" };
+	if (isInDocumentHead(node)) return null;
 	let target = node;
 	while (!(target instanceof HTMLElement) || shouldSkipElement(target)) {
 		if (target.nextElementSibling === null) return null;
@@ -82,34 +81,45 @@ function scrollToElement(target, hash) {
 	});
 }
 var AppRouterScrollTargetInner = class extends React$1.Component {
+	scheduledCommitId = null;
+	schedulePotentialScroll = () => {
+		const commitId = this.props.commitId;
+		this.scheduledCommitId = commitId;
+		queueMicrotask(() => {
+			if (this.scheduledCommitId !== commitId) return;
+			this.handlePotentialScroll();
+		});
+	};
 	handlePotentialScroll = () => {
 		const intent = getPendingAppRouterScrollIntent();
 		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);
-			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;
+		let node;
+		if (intent.hash !== null) node = getHashFragmentDomNode(intent.hash);
+		else node = null;
+		if (node === null) {
+			node = findDOMNode(this);
+			if (node !== null && isInDocumentHead(node)) {
+				markAppRouterScrollIntentHeadHoisted(intent, this.props.commitId);
 				return;
 			}
-			target = next.element;
 		}
+		const next = findNextScrollTarget(node);
+		if (next === null) return;
+		const target = next.element;
 		const consumed = consumeAppRouterScrollIntent(intent, this.props.commitId);
 		if (consumed === null) return;
 		scrollToElement(target, consumed.hash);
-		target.focus({ preventScroll: true });
+		target.focus();
 	};
 	componentDidMount() {
-		this.handlePotentialScroll();
+		this.schedulePotentialScroll();
 	}
 	componentDidUpdate() {
-		this.handlePotentialScroll();
+		this.schedulePotentialScroll();
+	}
+	componentWillUnmount() {
+		this.scheduledCommitId = null;
 	}
 	render() {
 		return this.props.children;

package/dist/shims/cache-runtime.js

@@ -1,9 +1,10 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
 import { VINEXT_RSC_MARKER_HEADER } from "../server/headers.js";
+import { trackPprFallbackShellCacheTask } from "./ppr-fallback-shell.js";
 import { markDynamicUsage } from "./headers.js";
 import { _registerCacheContextAccessor, _setRequestScopedCacheLife, cacheLifeProfiles, getDataCacheHandler } from "./cache.js";
-import { addCollectedRequestTags } from "./fetch-cache.js";
+import { addCollectedRequestTags, getCurrentFetchSoftTags } from "./fetch-cache.js";
 //#region src/shims/cache-runtime.ts
 /**
 * "use cache" runtime
@@ -243,7 +244,7 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 	const cacheVariant = variant ?? "";
 	const omitAppPageSearchParamsFromFirstArg = options.appPageDefaultExport === true;
 	const isDev = typeof process !== "undefined" && process.env.NODE_ENV === "development";
-	const cachedFn = async (...args) => {
+	const cachedFn = (...args) => trackPprFallbackShellCacheTask(async () => {
 		const rsc = await getRscModule();
 		const keySeed = getUseCacheKeySeed();
 		let cacheKey;
@@ -269,7 +270,11 @@ 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") {
@@ -316,13 +321,16 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 			});
 		} catch {}
 		return result;
-	};
+	}, cacheVariant);
 	Object.defineProperty(cachedFn, "length", {
 		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();

package/dist/shims/cache.d.ts

@@ -53,6 +53,7 @@ type CachedPagesValue = {
   kind: "PAGES";
   html: string;
   pageData: object;
+  generatedFromDataRequest?: boolean;
   headers: Record<string, string | string[]> | undefined;
   status: number | undefined;
 };

package/dist/shims/cache.js

@@ -1,10 +1,10 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
 import { getRequestExecutionContext, runWithExecutionContext } from "./request-context.js";
+import { makeHangingPromise } from "./internal/make-hanging-promise.js";
 import { getHeadersAccessPhase, markDynamicUsage } from "./headers.js";
 import { fnv1a64 } from "../utils/hash.js";
 import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
-import { makeHangingPromise } from "./internal/make-hanging-promise.js";
 import { readCacheControlNumberField } from "../utils/cache-control-metadata.js";
 import { encodeCacheTag, encodeCacheTags } from "../utils/encode-cache-tag.js";
 import { getCdnCacheAdapter } from "./cdn-cache.js";

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

@@ -1,8 +1,8 @@
 import { CacheHandlerValue, IncrementalCacheValue } from "./cache.js";
 
 //#region src/shims/cdn-cache.d.ts
-/** A map of response header name -> value the adapter wants applied. */
-type CdnResponseHeaders = Record<string, string>;
+/** A map of response header name -> value the adapter wants applied or removed. */
+type CdnResponseHeaders = Record<string, string | null>;
 type CdnCacheableHeaderInput = {
   /**
    * The cacheable `Cache-Control` value the framework computed for shared
@@ -50,9 +50,9 @@ type CdnCacheAdapter = {
    */
   set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
   /**
-   * Build the response cache headers for a given cacheable policy. Returns a map
-   * so an adapter can emit more than one header (e.g. `Cache-Control` +
-   * `CDN-Cache-Control`).
+   * Build the response cache headers for a given policy. Returns a map so an
+   * adapter can emit more than one header (e.g. `Cache-Control` +
+   * `CDN-Cache-Control`) and remove stale adapter-owned headers with `null`.
    */
   buildResponseHeaders(input: CdnCacheableHeaderInput): CdnResponseHeaders;
   /**

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,79 @@
+"use client";
+import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
+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 assetHref = dynamicPreloadHref(file);
+		if (assetHref.endsWith(".css")) {
+			const href = appendAssetDeploymentIdQuery(assetHref);
+			stylesheets.push(React.createElement("link", {
+				key: href,
+				rel: "stylesheet",
+				href,
+				nonce,
+				precedence: "dynamic"
+			}));
+			continue;
+		}
+		if (assetHref.endsWith(".js") && typeof ReactDOM.preload === "function") {
+			const preloadOptions = {
+				as: "script",
+				fetchPriority: "low",
+				nonce
+			};
+			ReactDOM.preload(assetHref, 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,6 +17,7 @@ type RedirectBoundaryState = {
   redirectType: "push" | "replace" | null;
 };
 type ErrorBoundaryInnerProps = {
+  isImplicitRootErrorBoundary?: boolean;
   pathname: string | null;
 } & ErrorBoundaryProps;
 type ErrorBoundaryState = {
@@ -31,7 +32,7 @@ declare class RedirectErrorBoundary extends React.Component<{
     children?: React.ReactNode;
   });
   static getDerivedStateFromError(error: unknown): RedirectBoundaryState;
-  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;
+  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;
 }
 declare function RedirectBoundary({
   children
@@ -51,7 +52,7 @@ declare class ErrorBoundaryInner extends React.Component<ErrorBoundaryInnerProps
   componentDidMount(): void;
   componentWillUnmount(): void;
   reset: () => void;
-  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;
+  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;
 }
 declare function ErrorBoundary({
   fallback,
@@ -99,7 +100,7 @@ declare class ForbiddenBoundaryInner extends React.Component<ForbiddenBoundaryIn
   constructor(props: ForbiddenBoundaryInnerProps);
   static getDerivedStateFromProps(props: ForbiddenBoundaryInnerProps, state: ForbiddenBoundaryState): ForbiddenBoundaryState | null;
   static getDerivedStateFromError(error: unknown): Partial<ForbiddenBoundaryState>;
-  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;
+  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;
 }
 declare function ForbiddenBoundary({
   fallback,
@@ -123,7 +124,7 @@ declare class UnauthorizedBoundaryInner extends React.Component<UnauthorizedBoun
   constructor(props: UnauthorizedBoundaryInnerProps);
   static getDerivedStateFromProps(props: UnauthorizedBoundaryInnerProps, state: UnauthorizedBoundaryState): UnauthorizedBoundaryState | null;
   static getDerivedStateFromError(error: unknown): Partial<UnauthorizedBoundaryState>;
-  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;
+  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;
 }
 declare function UnauthorizedBoundary({
   fallback,
@@ -131,6 +132,7 @@ declare function UnauthorizedBoundary({
   resetKey
 }: UnauthorizedBoundaryProps): React.JSX.Element;
 type DevRecoveryBoundaryProps = {
+  isImplicitRootErrorBoundary?: boolean;
   resetKey: number;
   onCatch?: (resetKey: number) => void;
   children?: React.ReactNode;

package/dist/shims/error-boundary.js

@@ -1,5 +1,7 @@
 "use client";
+import { handleAppNavigationFailure } from "../client/app-nav-failure-handler.js";
 import { decodeRedirectError, isRedirectError, usePathname, useRouter } from "./navigation.js";
+import DefaultGlobalError from "./default-global-error.js";
 import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import React from "react";
@@ -98,6 +100,10 @@ var ErrorBoundaryInner = class extends React.Component {
 	}
 	static getDerivedStateFromProps(props, state) {
 		const nextResetState = readBoundaryResetState(props);
+		if (state.error && handleAppNavigationFailure(state.error.thrownValue)) return {
+			error: null,
+			...nextResetState
+		};
 		if (state.error && shouldResetBoundary(nextResetState, state)) return {
 			error: null,
 			...nextResetState
@@ -150,6 +156,7 @@ function GlobalErrorBoundary({ fallback, children }) {
 	return /* @__PURE__ */ jsx(ErrorBoundaryInner, {
 		pathname: usePathname(),
 		fallback,
+		isImplicitRootErrorBoundary: fallback === DefaultGlobalError,
 		children
 	});
 }

package/dist/shims/error.js

@@ -1,5 +1,7 @@
+import { AppRouterContext } from "./internal/app-router-context.js";
 import { RouterContext } from "./internal/router-context.js";
-import { appRouterInstance, isNextRouterError } from "./navigation.js";
+import { isNextRouterError } from "./navigation.js";
+import { useUntrackedPathname } from "./internal/navigation-untracked.js";
 import React from "react";
 //#region src/shims/error.tsx
 /**
@@ -39,33 +41,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 +101,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 = useUntrackedPathname();
+		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/error.react-server.d.ts

@@ -0,0 +1,9 @@
+//#region src/shims/error.react-server.d.ts
+type ErrorInfo = {
+  error: unknown;
+  reset: () => void;
+  unstable_retry: () => void;
+};
+declare function unstable_catchError(): never;
+//#endregion
+export { ErrorInfo, unstable_catchError };

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

@@ -0,0 +1,6 @@
+//#region src/shims/error.react-server.ts
+function unstable_catchError() {
+	throw new Error("`unstable_catchError` can only be used in Client Components.");
+}
+//#endregion
+export { unstable_catchError };

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

@@ -40,6 +40,7 @@ type FetchCacheState = {
   currentRequestTags: string[];
   currentFetchSoftTags: string[];
   currentFetchCacheMode: FetchCacheMode | null;
+  currentForceDynamicFetchDefault: boolean;
   dynamicFetchUrls: Set<string>;
   isFetchDedupeActive: boolean;
   currentFetchDedupeEntries: Map<string, FetchDedupeEntry[]>;
@@ -75,7 +76,16 @@ declare function addCollectedRequestTags(tags: readonly string[]): void;
  * 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;
+declare function setCurrentForceDynamicFetchDefault(enabled: boolean): void;
 /**
  * Install the patched fetch and reset per-request tag state.
  * Returns a cleanup function that clears tags.
@@ -123,4 +133,4 @@ declare function ensureFetchPatch(): void;
  */
 declare function getOriginalFetch(): typeof globalThis.fetch;
 //#endregion
-export { FetchCacheMode, FetchCacheState, _resetPendingRefetches, addCollectedRequestTags, 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, setCurrentForceDynamicFetchDefault, withFetchCache };