vinext 1.2.1 → 1.3.0

package/dist/shims/cache-runtime.js

@@ -3,17 +3,19 @@ import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation }
 import { VINEXT_RSC_MARKER_HEADER } from "../server/headers.js";
 import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
 import { isRouteCacheabilityProbe, recordRouteCacheabilityProbeBailout } from "./cacheability-classification.js";
+import { shareIsolatePromise } from "../server/isolate-shared-promise.js";
 import { getDataCacheHandler } from "./cache-handler.js";
 import { addCollectedRequestTags, getCurrentFetchSoftTags, runWithDetachedFetchObservations } from "./fetch-cache-state.js";
 import { suppressHangingPromiseAbortRejections } from "./internal/make-hanging-promise.js";
 import { createPprFallbackShellSuspensePromise, trackPprFallbackShellCacheTask } from "./ppr-fallback-shell.js";
-import { markDynamicUsage, throwIfInsideCacheScope } from "./internal/headers-state.js";
+import { createUseCacheAccessError, markDynamicUsage, recordInvalidDynamicUsageError } from "./internal/headers-state.js";
 import { isDraftModeEnabled } from "./headers.js";
 import { _registerCacheContextAccessor } from "./internal/cache-context-accessor.js";
 import { _hasPendingRevalidatedTag, _setRequestScopedCacheLife, cacheLifeProfiles, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 import "./fetch-cache.js";
 import { hasUseCacheLayoutMarker, hasUseCachePageMarker, isUseCacheFunctionReference, withoutUseCacheSegmentMarker } from "./internal/app-page-props-cache-key.js";
-import { getFallbackParamsSnapshot, makeThenableParams, restoreThenableParams } from "./thenable-params.js";
+import { isWellKnownProperty } from "./internal/thenable-well-known-properties.js";
+import { getFallbackParamsSnapshot, restoreThenableParams } from "./thenable-params.js";
 import { getCurrentRootParams } from "./root-params.js";
 import { flightArgumentsKey, restoreFlightReply, snapshotFlightReply } from "./cache-flight-arguments.js";
 import { cache } from "react";
@@ -132,7 +134,7 @@ function buildUseCacheKey(id, keySeed, argsKey) {
 }
 let _rscModule;
 function getRscModule() {
-	return _rscModule ??= import("@vitejs/plugin-rsc/react/rsc");
+	return _rscModule ??= shareIsolatePromise(import("@vitejs/plugin-rsc/react/rsc"));
 }
 /** Collect a ReadableStream<Uint8Array> into a single Uint8Array. */
 async function collectStream(stream) {
@@ -365,9 +367,9 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 					...props,
 					params: restoreThenableParams(await props.params, outerParams)
 				});
-				if (pagePropsIndex !== void 0) callArgs = withErroringPageSearchParams(callArgs, pagePropsIndex);
 			}
-			if (fallbackParams) return (await executeWithContext(fn, callArgs, cacheVariant, rsc)).result;
+			const callFn = segmentPropsIndex !== -1 && pagePropsIndex !== void 0 ? withErroringPageSearchParams(fn, pagePropsIndex) : fn;
+			if (fallbackParams) return (await executeWithContext(callFn, callArgs, cacheVariant, rsc)).result;
 			if (cacheVariant === "private") {
 				const privateCache = _getPrivateState()._privateCache;
 				const privateHit = privateCache.get(cacheKey);
@@ -375,11 +377,11 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 					if (privateHit.serialized) return rsc.createFromReadableStream(uint8ToStream(base64ToUint8(privateHit.serialized.body)), {}, { preserveServerReferences: true });
 					return privateHit.result;
 				}
-				const execution = await executeWithContext(fn, callArgs, cacheVariant, rsc);
+				const execution = await executeWithContext(callFn, callArgs, cacheVariant, rsc);
 				if (execution.cacheable) privateCache.set(cacheKey, execution);
 				return execution.result;
 			}
-			if (isDev || isDraftModeEnabled()) return (await executeWithContext(fn, callArgs, cacheVariant, rsc)).result;
+			if (isDev || isDraftModeEnabled()) return (await executeWithContext(callFn, callArgs, cacheVariant, rsc)).result;
 			const handler = getDataCacheHandler();
 			const rootParams = getCurrentRootParams();
 			const knownRootParamNames = knownRootParamsByFunctionId.get(id);
@@ -409,7 +411,7 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 				}
 			}
 			const generate = async (propagate) => {
-				const { result, ctx, effectiveLife, collectedResult } = await runCachedFunctionWithContext(fn, callArgs, cacheVariant, (value) => serializeCacheResult(value, rsc));
+				const { result, ctx, effectiveLife, collectedResult } = await runCachedFunctionWithContext(callFn, callArgs, cacheVariant, (value) => serializeCacheResult(value, rsc));
 				const rootParamNames = ctx.readRootParamNames && ctx.readRootParamNames.size > 0 ? addKnownRootParamNames(id, ctx.readRootParamNames) : knownRootParamsByFunctionId.get(id);
 				if (propagate) {
 					recordRequestScopedCacheLife(effectiveLife);
@@ -631,18 +633,44 @@ function toReplayablePageArgs(args, index) {
 	return replaceArgument(args, index, pageProps);
 }
 /**
-* Give page props at `index` without `searchParams` (a Response Store replay of
-* args encoded by `toReplayablePageArgs`) a value that throws on
-* access inside the cache scope, like Next.js's
-* `makeErroringSearchParamsForUseCache`, instead of `undefined`.
+* Run `fn` with an erroring `searchParams` in the page props at `index` when
+* they have none (they are omitted from a public page cache's arguments, and
+* from a Response Store replay of them), instead of `undefined`.
 */
-function withErroringPageSearchParams(args, index) {
-	const props = args[index];
-	if (!isPagePropsObject(props) || "searchParams" in props) return args;
-	return replaceArgument(args, index, {
-		...props,
-		searchParams: makeThenableParams({}, { observeParamAccess: () => throwIfInsideCacheScope("searchParams") })
-	});
+function withErroringPageSearchParams(fn, index) {
+	return (...args) => {
+		const props = args[index];
+		if (!isPagePropsObject(props) || "searchParams" in props) return fn(...args);
+		return fn(...replaceArgument(args, index, {
+			...props,
+			searchParams: makeErroringPageSearchParams()
+		}));
+	};
+}
+function isNextWellKnownProperty(prop) {
+	return prop !== "value" && prop !== "error" && isWellKnownProperty(prop);
+}
+/**
+* Ported from Next.js's `makeErroringSearchParamsForUseCache`
+* (server/request/search-params.ts): reading `then` or a param throws, and
+* everything else reads the underlying promise, with methods bound to it.
+*/
+function makeErroringPageSearchParams() {
+	const cacheContext = cacheContextStorage.getStore() ?? null;
+	const requestContext = isInsideUnifiedScope() ? getRequestContext() : null;
+	const promise = Promise.resolve({});
+	return new Proxy(promise, { get(target, prop, receiver) {
+		if (!Object.hasOwn(target, prop) && typeof prop === "string" && (prop === "then" || !isNextWellKnownProperty(prop))) {
+			const error = createUseCacheAccessError("searchParams");
+			if (cacheContext) cacheContext.invalidDynamicUsageError ??= error;
+			const activeCacheContext = cacheContextStorage.getStore();
+			if (activeCacheContext && activeCacheContext !== cacheContext) activeCacheContext.invalidDynamicUsageError ??= error;
+			if (requestContext) recordInvalidDynamicUsageError(requestContext, error);
+			throw error;
+		}
+		const value = Reflect.get(target, prop, receiver);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
 }
 //#endregion
 export { NestedDynamicUseCacheError, buildUseCacheKey, cacheContextStorage, clearPrivateCache, getCacheContext, isUseCacheFunction, memoizeInCacheScope, registerCachedFunction, replayCachedFunction, runWithPrivateCache };

package/dist/shims/cache.d.ts

@@ -1,6 +1,6 @@
 import { ExecutionContextLike, getRequestExecutionContext, runWithExecutionContext } from "./request-context.js";
 import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
-import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheLifeConfig, CacheLifeSink, CacheState, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
+import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheLifeConfig, CacheLifeSink, CacheState, PendingCdnTagInvalidation, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 import { CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, registerDataCacheHandler, registerLazyDataCacheHandler, setCacheHandler, setDataCacheHandler } from "./cache-handler.js";
 //#region src/shims/cache.d.ts
 /**
@@ -142,4 +142,4 @@ type UnstableCacheOptions = {
  */
 export declare function unstable_cache<T extends (...args: any[]) => Promise<any>>(fn: T, keyParts?: string[], options?: UnstableCacheOptions): T;
 //#endregion
-export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CacheLifeConfig, CacheLifeSink, CacheState, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, type ExecutionContextLike, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, markActionRevalidation, unstable_noStore as noStore, recordUnstableCacheObservation, registerDataCacheHandler, registerLazyDataCacheHandler, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CacheLifeConfig, CacheLifeSink, CacheState, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, type ExecutionContextLike, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, PendingCdnTagInvalidation, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, markActionRevalidation, unstable_noStore as noStore, recordUnstableCacheObservation, registerDataCacheHandler, registerLazyDataCacheHandler, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry };

package/dist/shims/cache.js

@@ -3,7 +3,6 @@ import { getRequestContext, isInsideUnifiedScope } from "./unified-request-conte
 import { getRequestExecutionContext, runWithExecutionContext } from "./request-context.js";
 import { isInsideWorkStoreScope } from "./internal/work-store-scope.js";
 import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
-import { getCdnCacheAdapter } from "./cdn-cache.js";
 import { isStagedCacheabilityProbeActive } from "./cacheability-classification.js";
 import { MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, registerDataCacheHandler, registerLazyDataCacheHandler, setCacheHandler, setDataCacheHandler } from "./cache-handler.js";
 import { encodeCacheTag, encodeCacheTags } from "../utils/encode-cache-tag.js";
@@ -13,7 +12,8 @@ import { makeHangingPromise } from "./internal/make-hanging-promise.js";
 import { getHeadersAccessPhase, markDynamicUsage } from "./internal/headers-state.js";
 import { isDraftModeEnabled } from "./headers.js";
 import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
-import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
+import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
+import { isPathKnownNotEdgeCached } from "./cdn-purge-routes.js";
 //#region src/shims/cache.ts
 /**
 * next/cache shim
@@ -69,7 +69,7 @@ function revalidateTag(tag, profile) {
 	if (!profile || !durations || durations.expire === 0) markActionRevalidation(1);
 	const encodedTag = encodeCacheTag(tag);
 	_markPendingRevalidatedTag(encodedTag);
-	return scheduleRevalidation(_invalidateEncodedTag(encodedTag, durations));
+	return scheduleTagInvalidation(encodedTag, durations);
 }
 /**
 * Invalidate one already-encoded tag across both cache layers.
@@ -79,10 +79,18 @@ function revalidateTag(tag, profile) {
 * default CDN adapter), THEN ask the CDN adapter to purge its edge (a no-op for
 * the default adapter). Purging the edge before the store is invalidated would
 * let the edge re-fetch and re-cache stale data.
+*
+* The data cache is invalidated right away, so reads later in the same action
+* see it. Inside a Server Action or Route Handler the purge waits for the
+* request boundary, which sends one batched adapter call per profile.
 */
-async function _invalidateEncodedTag(encoded, durations) {
+function scheduleTagInvalidation(encoded, durations) {
+	const dataInvalidation = invalidateDataCacheTag(encoded, durations);
+	if (_queuePendingCdnTagInvalidation(encoded, durations, dataInvalidation)) return scheduleRevalidation(dataInvalidation);
+	return scheduleRevalidation(dataInvalidation.then(() => _revalidateCdnTags(encoded, durations)));
+}
+async function invalidateDataCacheTag(encoded, durations) {
 	await getDataCacheHandler().revalidateTag(encoded, durations);
-	await getCdnCacheAdapter().revalidateTag(encoded, durations);
 }
 /**
 * Revalidate cached data associated with a specific path.
@@ -109,7 +117,8 @@ function revalidatePath(path, type) {
 	const tag = type ? `_N_T_${stem}/${type}` : `_N_T_${stem || "/"}`;
 	const encodedTag = encodeCacheTag(tag);
 	_markPendingRevalidatedTag(encodedTag);
-	return scheduleRevalidation(_invalidateEncodedTag(encodedTag));
+	if (isPathKnownNotEdgeCached(stem || "/")) return scheduleRevalidation(invalidateDataCacheTag(encodedTag));
+	return scheduleTagInvalidation(encodedTag);
 }
 /**
 * No-op shim for API compatibility.
@@ -140,7 +149,7 @@ function updateTag(tag) {
 	markActionRevalidation(1);
 	const encodedTag = encodeCacheTag(tag);
 	_markPendingRevalidatedTag(encodedTag);
-	return scheduleRevalidation(_invalidateEncodedTag(encodedTag));
+	return scheduleTagInvalidation(encodedTag);
 }
 /**
 * Opt out of static rendering and indicate a particular component should not be cached.
@@ -464,4 +473,4 @@ function unstable_cache(fn, keyParts, options) {
 	return cachedFn;
 }
 //#endregion
-export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, MemoryCacheHandler, NoOpCacheHandler, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, recordUnstableCacheObservation, refresh, registerDataCacheHandler, registerLazyDataCacheHandler, revalidatePath, revalidateTag, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, MemoryCacheHandler, NoOpCacheHandler, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, recordUnstableCacheObservation, refresh, registerDataCacheHandler, registerLazyDataCacheHandler, revalidatePath, revalidateTag, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };

package/dist/shims/cdn-purge-routes.d.ts

@@ -0,0 +1,24 @@
+//#region src/shims/cdn-purge-routes.d.ts
+type CdnPurgeRoute = {
+  patternParts: readonly string[];
+  routeSegments: readonly string[];
+};
+type CdnPurgeRoutes = {
+  metadataRoutes: readonly (Omit<CdnPurgeRoute, "patternParts"> & {
+    patternParts: readonly string[] | null;
+    servedUrl: string;
+  })[];
+  routes: readonly (CdnPurgeRoute & {
+    forceDynamic?: boolean;
+  })[];
+};
+/** Register the App Router's routes. Apps with a Pages Router never register. */
+export declare function registerCdnPurgeRoutes(routes: CdnPurgeRoutes): void;
+/**
+ * Whether no edge-cacheable response can carry the implicit tags of
+ * `revalidatePath(path)`, for any `type`. Paths that need encoding, the
+ * `/index` alias, and paths ending in a derived tag suffix (`/docs/page` is
+ * also the `/docs` page tag) always purge.
+ */
+export declare function isPathKnownNotEdgeCached(path: string): boolean;
+//#endregion

package/dist/shims/cdn-purge-routes.js

@@ -0,0 +1,77 @@
+import { matchRoutePatternPrefix, routePatternParts } from "../routing/route-pattern.js";
+//#region src/shims/cdn-purge-routes.ts
+/**
+* Build-time route facts that let `revalidatePath()` skip a CDN purge no
+* edge-cached response could match.
+*
+* Edge purges are rate limited (Workers Cache allows 5 a minute per account),
+* and a `dynamic = "force-dynamic"` App route never stores a response the
+* edge can serve. The check is conservative: it only skips a path when at
+* least one App route could serve it and every such route is force-dynamic.
+* The data cache is always invalidated.
+*/
+const CDN_PURGE_ROUTES_KEY = Symbol.for("vinext.cdnPurgeRoutes");
+const globals = globalThis;
+const DERIVED_TAG_SUFFIXES = /* @__PURE__ */ new Set([
+	"layout",
+	"page",
+	"route"
+]);
+/** Register the App Router's routes. Apps with a Pages Router never register. */
+function registerCdnPurgeRoutes(routes) {
+	globals[CDN_PURGE_ROUTES_KEY] = routes;
+}
+/** Whether some URL matched by `patternParts` starts with `pathParts`. */
+function canServeUnder(pathParts, patternParts) {
+	const last = patternParts.at(-1) ?? "";
+	const endsInCatchAll = last.startsWith(":") && (last.endsWith("+") || last.endsWith("*"));
+	if (patternParts.length < pathParts.length && !endsInCatchAll) return false;
+	return matchRoutePatternPrefix(pathParts, patternParts.slice(0, pathParts.length));
+}
+/**
+* Whether a response from `route` could carry a `revalidatePath(path)` tag.
+* Implicit tags use either the URL (`/blog/a`) or the route's segments
+* (`/(site)/blog/[slug]`), so check both as prefixes.
+*/
+function couldCarryPathTag(pathParts, route) {
+	return canServeUnder(pathParts, route.patternParts) || canServeUnder(pathParts, routePatternParts(route.routeSegments.join("/")));
+}
+/**
+* Whether a metadata route, or a child it generates (`/icon/small` from
+* `generateImageMetadata`, `/sitemap/0.xml` from `generateSitemaps`), could
+* carry a `revalidatePath(path)` tag.
+*/
+function metadataCouldCarryPathTag(pathParts, route) {
+	const patternParts = route.patternParts ?? routePatternParts(route.servedUrl);
+	const childParts = [
+		...patternParts.slice(0, -1),
+		(patternParts.at(-1) ?? "").replace(/\.[^.]*$/, ""),
+		":children*"
+	];
+	return couldCarryPathTag(pathParts, {
+		patternParts,
+		routeSegments: route.routeSegments
+	}) || canServeUnder(pathParts, childParts);
+}
+/**
+* Whether no edge-cacheable response can carry the implicit tags of
+* `revalidatePath(path)`, for any `type`. Paths that need encoding, the
+* `/index` alias, and paths ending in a derived tag suffix (`/docs/page` is
+* also the `/docs` page tag) always purge.
+*/
+function isPathKnownNotEdgeCached(path) {
+	const registered = globals[CDN_PURGE_ROUTES_KEY];
+	if (!registered || path === "/index" || /[^\x21-\x7e]|%/.test(path)) return false;
+	const pathParts = path.split("/").filter(Boolean);
+	if (DERIVED_TAG_SUFFIXES.has(pathParts.at(-1) ?? "")) return false;
+	if (registered.metadataRoutes.some((route) => metadataCouldCarryPathTag(pathParts, route))) return false;
+	let matched = false;
+	for (const route of registered.routes) {
+		if (!couldCarryPathTag(pathParts, route)) continue;
+		if (route.forceDynamic !== true) return false;
+		matched = true;
+	}
+	return matched;
+}
+//#endregion
+export { isPathKnownNotEdgeCached, registerCdnPurgeRoutes };

package/dist/shims/dynamic.js

@@ -52,13 +52,26 @@ function normalizeDynamicOptions(dynamicInput, options) {
 		...options
 	};
 }
-function createLazyComponent(loader) {
-	return React.lazy(async () => {
+function createLazyComponent(loader, share = (load) => load) {
+	return React.lazy(() => share((async () => {
 		const mod = await loader();
 		if (hasDefaultExport(mod)) return mod;
 		return { default: mod };
-	});
+	})()));
 }
+const SHARE_ISOLATE_PROMISE_KEY = Symbol.for("vinext.shareIsolatePromise");
+/**
+* The server React.lazy is created once per dynamic() call, so every request
+* in the isolate renders the same load. On Workers, the request that starts it
+* owns its I/O; if that request is canceled first, the load never settles and
+* every later render of the component hangs. The server installs
+* `shareIsolatePromise` on a global symbol, which keeps the starting request
+* alive until the load settles, without this shim importing request state.
+*/
+const shareServerLoad = (load) => {
+	const share = globalThis[SHARE_ISOLATE_PROMISE_KEY];
+	return share ? share(load) : load;
+};
 function useRetryableLazyComponent(loader, initialLazyComponent) {
 	const [LazyComponent, setLazyComponent] = React.useState(() => initialLazyComponent);
 	const [retryKey, setRetryKey] = React.useState(0);
@@ -218,7 +231,7 @@ function dynamic(dynamicInput, options) {
 			AsyncServerDynamic.displayName = "DynamicAsyncServer";
 			return AsyncServerDynamic;
 		}
-		const LazyServer = createLazyComponent(loader);
+		const LazyServer = createLazyComponent(loader, shareServerLoad);
 		const ServerDynamic = (props) => {
 			const isAppRouterTree = useIsAppRouterTree();
 			const fallback = LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps()) : null;

package/dist/shims/form.js

@@ -8,7 +8,7 @@ import { withBasePath } from "./url-utils.js";
 import { AppElementsWire } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
 import { createRscRequestHeaders, createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
-import { hasAppNavigationRuntime } from "../client/navigation-runtime.js";
+import { hasAppNavigationRuntime, loadNavigationRuntimeRouteManifest } 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";
@@ -145,14 +145,19 @@ const Form = forwardRef(function Form(props, ref) {
 			for (const entry of entries) if (entry.isIntersecting || entry.intersectionRatio > 0) {
 				(async () => {
 					if (isBotUserAgent(window.navigator?.userAgent ?? "")) return;
-					const interceptionContext = getPrefetchInterceptionContext(actionHref);
+					const currentPathname = window.location.pathname;
+					const resolvedAction = new URL(actionHref, window.location.href);
+					const prefetchHref = resolvedAction.pathname + resolvedAction.search;
 					const mountedSlotsHeader = getMountedSlotsHeader();
+					const routeManifestLoad = loadNavigationRuntimeRouteManifest();
+					if (routeManifestLoad !== null && !await routeManifestLoad) return;
+					const interceptionContext = getPrefetchInterceptionContext(prefetchHref, currentPathname);
 					const headers = createRscRequestHeaders({
 						interceptionContext,
 						renderMode: APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL
 					});
 					if (mountedSlotsHeader) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
-					const rscUrl = await createRscRequestUrl(actionHref, headers);
+					const rscUrl = await createRscRequestUrl(prefetchHref, headers);
 					const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 					const prefetched = getPrefetchedUrls();
 					if (prefetched.has(cacheKey)) return;

package/dist/shims/image-props.d.ts

@@ -0,0 +1,93 @@
+import React from "react";
+import { ImageProps, ImgProps, StaticImport } from "@vinext/types/next/upstream/dist/shared/lib/get-img-props";
+//#region src/shims/image-props.d.ts
+export declare const __isDev: boolean;
+/**
+ * Whether dangerouslyAllowSVG is enabled in next.config.js.
+ * When false (default), .svg sources auto-skip the optimization endpoint
+ * and are served directly, matching Next.js behavior.
+ * When true, .svg sources are routed through the optimizer (served as-is
+ * with security headers).
+ */
+export declare const __dangerouslyAllowSVG: boolean;
+export declare const __globallyUnoptimized: boolean;
+/**
+ * Validate that a remote URL is allowed by the configured remote patterns.
+ * Returns true if the URL is allowed, false otherwise.
+ *
+ * When no remotePatterns/domains are configured, all remote URLs are allowed
+ * (backwards-compatible — user hasn't opted into restriction).
+ *
+ * When patterns ARE configured, only matching URLs are allowed.
+ * In development, non-matching URLs produce a console warning.
+ * In production, non-matching URLs are blocked (src replaced with empty string).
+ *
+ * Private-IP hostnames are additionally rejected unless dangerouslyAllowLocalIP
+ * is set, mirroring Next.js's fetchExternalImage guard.
+ */
+export declare function validateRemoteUrl(src: string): {
+  allowed: boolean;
+  reason?: string;
+};
+/**
+ * Sanitize a blurDataURL to prevent CSS injection.
+ *
+ * A crafted data URL containing `)` can break out of the `url()` CSS function,
+ * allowing injection of arbitrary CSS properties or rules. Characters like `{`,
+ * `}`, and `\` can also assist in crafting injection payloads.
+ *
+ * This validates the URL starts with `data:image/` and rejects characters that
+ * could escape the `url()` context. Semicolons are allowed since they're part
+ * of valid data URLs (`data:image/png;base64,...`) and harmless inside `url()`.
+ *
+ * Returns undefined for invalid URLs, which causes the blur placeholder to be
+ * skipped gracefully.
+ */
+export declare function sanitizeBlurDataURL(url: string): string | undefined;
+/**
+ * Determine if a src is a remote URL (CDN-optimizable) or local.
+ */
+export declare function isRemoteUrl(src: string): boolean;
+export declare function isSvgUrl(src: string): boolean;
+export declare function getFillStyle(style?: React.CSSProperties, backgroundStyle?: React.CSSProperties): React.CSSProperties;
+/**
+ * Resolve src, width, height, blurDataURL from Image props (string or StaticImageData).
+ * Shared by the Image component and getImageProps to keep behavior in sync.
+ */
+export declare function resolveImageSource(v: {
+  src: string | StaticImport;
+  width?: number | `${number}`;
+  height?: number | `${number}`;
+  blurDataURL?: string;
+}): {
+  src: string;
+  width?: number;
+  height?: number;
+  blurDataURL?: string;
+};
+/**
+ * Responsive image widths matching Next.js's device sizes config.
+ * These are the breakpoints used for srcSet generation.
+ * Configurable via `images.deviceSizes` in next.config.js.
+ */
+export declare const RESPONSIVE_WIDTHS: number[];
+/**
+ * Build a `/_next/image` optimization URL.
+ *
+ * In production (Cloudflare Workers), the worker intercepts this path and uses
+ * the Images binding to resize/transcode on the fly. In dev, the Vite dev
+ * server handles it as a passthrough (serves the original file).
+ */
+export declare function imageOptimizationUrl(src: string, width: number, quality?: number): string;
+export declare function generateImageAttributes(src: string, width: number, quality?: number, sizes?: string): {
+  src: string;
+  srcSet: string;
+};
+/**
+ * getImageProps — for advanced use cases (picture elements, background images).
+ * Returns the props that would be passed to the underlying <img> element.
+ */
+export declare function getImageProps(props: ImageProps): {
+  props: ImgProps;
+};
+//#endregion