vinext 0.1.8 → 0.2.1

package/dist/server/seed-cache.js

@@ -1,8 +1,8 @@
 import { isrCacheKey, isrSetPrerenderedAppPage } from "./isr-cache.js";
+import { getRenderedAppRoutes, isFallbackShellArtifactPath, readPrerenderManifest } from "./prerender-manifest.js";
 import { buildAppPageCacheTags } from "./app-page-cache.js";
 import { getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
 import { addPregeneratedConcretePath, clearPregeneratedConcretePaths, normalizePregeneratedPathname } from "./pregenerated-concrete-paths.js";
-import { getRenderedAppRoutes, isFallbackShellArtifactPath, readPrerenderManifest } from "./prerender-manifest.js";
 import fs from "node:fs";
 import path from "node:path";
 //#region src/server/seed-cache.ts
@@ -67,7 +67,7 @@ async function seedMemoryCacheFromPrerender(serverDir, options) {
 		const revalidateSeconds = typeof route.revalidate === "number" ? route.revalidate : void 0;
 		const expireSeconds = typeof route.expire === "number" ? route.expire : void 0;
 		const tags = buildAppPageCacheTags(cachePathname, []);
-		if (await seedHtml(writeAppPageEntry, prerenderDir, htmlKey, artifactPathname, trailingSlash, revalidateSeconds, expireSeconds, tags)) {
+		if (await seedHtml(writeAppPageEntry, prerenderDir, htmlKey, artifactPathname, trailingSlash, route.headers, revalidateSeconds, expireSeconds, tags)) {
 			await seedRsc(writeAppPageEntry, prerenderDir, rscKey, artifactPathname, revalidateSeconds, expireSeconds, tags);
 			seeded++;
 		}
@@ -81,7 +81,7 @@ function createDefaultAppPageEntryWriter() {
 * Seed the HTML cache entry for a single route.
 * Returns true if the file existed and was seeded.
 */
-async function seedHtml(writeAppPageEntry, prerenderDir, key, pathname, trailingSlash, revalidateSeconds, expireSeconds, tags) {
+async function seedHtml(writeAppPageEntry, prerenderDir, key, pathname, trailingSlash, headers, revalidateSeconds, expireSeconds, tags) {
 	const relPath = getOutputPath(pathname, trailingSlash);
 	const fullPath = path.join(prerenderDir, relPath);
 	if (!fs.existsSync(fullPath)) return false;
@@ -89,7 +89,7 @@ async function seedHtml(writeAppPageEntry, prerenderDir, key, pathname, trailing
 		kind: "APP_PAGE",
 		html: fs.readFileSync(fullPath, "utf-8"),
 		rscData: void 0,
-		headers: void 0,
+		headers,
 		postponed: void 0,
 		status: void 0
 	}, {

package/dist/shims/app-router-scroll-state.d.ts

@@ -2,6 +2,7 @@
 type AppRouterScrollIntent = Readonly<{
   commitId: number | null;
   hash: string | null;
+  headElements: ReadonlySet<Element> | null;
   id: number;
   targetHoistedInHead: boolean;
 }>;

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

@@ -14,6 +14,7 @@ function beginAppRouterScrollIntent(hash) {
 	const intent = {
 		commitId: null,
 		hash,
+		headElements: typeof document === "undefined" ? null : new Set(document.head?.children ?? []),
 		id: store.nextId,
 		targetHoistedInHead: false
 	};

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

@@ -99,7 +99,8 @@ var AppRouterScrollTargetInner = class extends React$1.Component {
 		else node = null;
 		if (node === null) {
 			node = findDOMNode(this);
-			if (node !== null && isInDocumentHead(node)) {
+			const headElement = node instanceof Element ? node : node?.parentElement;
+			if (node !== null && headElement != null && isInDocumentHead(node) && !intent.headElements?.has(headElement)) {
 				markAppRouterScrollIntentHeadHoisted(intent, this.props.commitId);
 				return;
 			}

package/dist/shims/cache-handler.js

@@ -42,6 +42,10 @@ function readStringArrayField(ctx, field) {
 	if (!Array.isArray(value)) return [];
 	return value.filter((item) => typeof item === "string");
 }
+function readPositiveNumberField(ctx, field) {
+	const value = ctx?.[field];
+	return typeof value === "number" && value > 0 ? value : void 0;
+}
 var MemoryCacheHandler = class {
 	store = /* @__PURE__ */ new Map();
 	tagRevalidatedAt = /* @__PURE__ */ new Map();
@@ -89,7 +93,10 @@ var MemoryCacheHandler = class {
 			return null;
 		}
 		this.touchEntry(key, entry);
-		if (entry.revalidateAt !== null && Date.now() > entry.revalidateAt) return {
+		const now = Date.now();
+		const requestedRevalidate = readPositiveNumberField(ctx, "revalidate");
+		const requestedRevalidateAt = requestedRevalidate === void 0 ? null : entry.lastModified + requestedRevalidate * 1e3;
+		if (entry.revalidateAt !== null && now > entry.revalidateAt || requestedRevalidateAt !== null && now > requestedRevalidateAt) return {
 			lastModified: entry.lastModified,
 			value: entry.value,
 			cacheState: "stale",

package/dist/shims/cache.js

@@ -5,9 +5,10 @@ import { MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getC
 import { getCdnCacheAdapter } from "./cdn-cache.js";
 import { fnv1a64 } from "../utils/hash.js";
 import { makeHangingPromise } from "./internal/make-hanging-promise.js";
-import { getHeadersAccessPhase, markDynamicUsage } from "./headers.js";
+import { getHeadersAccessPhase, isDraftModeEnabled, markDynamicUsage } from "./headers.js";
 import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _consumeRequestScopedCacheLife, _initRequestScopedCacheState, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 import { encodeCacheTag, encodeCacheTags } from "../utils/encode-cache-tag.js";
+import { addCollectedRequestTags } from "./fetch-cache.js";
 import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
 //#region src/shims/cache.ts
 /**
@@ -110,10 +111,10 @@ function refresh() {
 *
 * @see https://nextjs.org/docs/app/api-reference/functions/updateTag
 */
-async function updateTag(tag) {
+function updateTag(tag) {
 	if (getHeadersAccessPhase() !== "action") throw new Error("updateTag can only be called from within a Server Action. To invalidate cache tags in Route Handlers or other contexts, use revalidateTag instead. See more info here: https://nextjs.org/docs/app/api-reference/functions/updateTag");
 	markActionRevalidation(1);
-	await _invalidateEncodedTag(encodeCacheTag(tag));
+	return _invalidateEncodedTag(encodeCacheTag(tag));
 }
 /**
 * Opt out of static rendering and indicate a particular component should not be cached.
@@ -124,6 +125,7 @@ async function updateTag(tag) {
 * It's provided for API compatibility so apps importing it don't break.
 */
 function unstable_noStore() {
+	if (isInsideUnstableCacheScope()) return;
 	markDynamicUsage();
 }
 /**
@@ -373,6 +375,7 @@ function unstable_cache(fn, keyParts, options) {
 	const revalidateSeconds = options?.revalidate;
 	const cachedFn = async (...args) => {
 		const cacheKey = `unstable_cache:${baseKey}:${JSON.stringify(args)}`;
+		addCollectedRequestTags(tags);
 		recordUnstableCacheObservation({
 			kind: "unstable_cache",
 			keyHash: fnv1a64(cacheKey),
@@ -380,19 +383,23 @@ function unstable_cache(fn, keyParts, options) {
 			tagCount: tags.length,
 			tagHash: tags.length > 0 ? fnv1a64(JSON.stringify(tags)) : null
 		});
-		const existing = await getDataCacheHandler().get(cacheKey, {
-			kind: "FETCH",
-			tags
-		});
-		if (existing?.value && existing.value.kind === "FETCH") {
-			const cached = tryDeserializeUnstableCacheResult(existing.value.data.body);
-			if (cached.ok) if (existing.cacheState === "stale") {
-				if (shouldServeStaleUnstableCacheEntry()) {
-					scheduleUnstableCacheBackgroundRevalidation(cacheKey, () => refreshUnstableCacheResult(fn, args, cacheKey, tags, revalidateSeconds));
-					return cached.value;
-				}
-			} else return cached.value;
+		const isDraftMode = isDraftModeEnabled();
+		if (!isDraftMode) {
+			const existing = await getDataCacheHandler().get(cacheKey, {
+				kind: "FETCH",
+				tags
+			});
+			if (existing?.value && existing.value.kind === "FETCH") {
+				const cached = tryDeserializeUnstableCacheResult(existing.value.data.body);
+				if (cached.ok) if (existing.cacheState === "stale") {
+					if (shouldServeStaleUnstableCacheEntry()) {
+						scheduleUnstableCacheBackgroundRevalidation(cacheKey, () => refreshUnstableCacheResult(fn, args, cacheKey, tags, revalidateSeconds));
+						return cached.value;
+					}
+				} else return cached.value;
+			}
 		}
+		if (isDraftMode) return await _unstableCacheAls.run(true, () => fn(...args));
 		return await refreshUnstableCacheResult(fn, args, cacheKey, tags, revalidateSeconds);
 	};
 	return cachedFn;

package/dist/shims/cdn-cache.js

@@ -1,6 +1,6 @@
 import { getRequestExecutionContext } from "./request-context.js";
 import { getDataCacheHandler } from "./cache-handler.js";
-import { CloudflareCdnCacheAdapter } from "../cloudflare/src/cache/cdn-adapter.runtime.js";
+import { CloudflareCdnCacheAdapter } from "../packages/cloudflare/src/cache/cdn-adapter.runtime.js";
 //#region src/shims/cdn-cache.ts
 /**
 * CDN cache adapter — owns the *page-level ISR serving strategy*.

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

@@ -3,6 +3,7 @@ import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { useScriptNonce } from "./script-nonce-context.js";
 import React from "react";
 import * as ReactDOM from "react-dom";
+import { getPagesClientAssets } from "vinext/server/pages-client-assets";
 //#region src/shims/dynamic-preload-chunks.tsx
 /**
 * Preload links for rendered next/dynamic() boundaries.
@@ -34,7 +35,7 @@ function dynamicPreloadHref(file) {
 }
 function resolveDynamicPreloadFiles(moduleIds) {
 	if (!moduleIds || moduleIds.length === 0) return [];
-	const preloadMap = globalThis.__VINEXT_DYNAMIC_PRELOADS__;
+	const preloadMap = getPagesClientAssets().dynamicPreloads;
 	if (!preloadMap) return [];
 	const files = [];
 	const seen = /* @__PURE__ */ new Set();

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

@@ -42,6 +42,7 @@ type FetchCacheState = {
   currentFetchCacheMode: FetchCacheMode | null;
   currentForceDynamicFetchDefault: boolean;
   dynamicFetchUrls: Set<string>;
+  refreshStaleFetchesInForeground: boolean;
   isFetchDedupeActive: boolean;
   currentFetchDedupeEntries: Map<string, FetchDedupeEntry[]>;
 };
@@ -86,6 +87,7 @@ declare function setCurrentFetchSoftTags(tags: string[]): void;
 declare function getCurrentFetchSoftTags(): string[];
 declare function setCurrentFetchCacheMode(mode: FetchCacheMode | null): void;
 declare function setCurrentForceDynamicFetchDefault(enabled: boolean): void;
+declare function setRefreshStaleFetchesInForeground(enabled: boolean): void;
 /**
  * Install the patched fetch and reset per-request tag state.
  * Returns a cleanup function that clears tags.
@@ -133,4 +135,4 @@ declare function ensureFetchPatch(): void;
  */
 declare function getOriginalFetch(): typeof globalThis.fetch;
 //#endregion
-export { FetchCacheMode, FetchCacheState, _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, withFetchCache };
+export { FetchCacheMode, FetchCacheState, _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };

package/dist/shims/fetch-cache.js

@@ -3,6 +3,7 @@ import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation }
 import { getRequestExecutionContext } from "./request-context.js";
 import { getDataCacheHandler } from "./cache-handler.js";
 import { markDynamicUsage } from "./headers.js";
+import { _setRequestScopedCacheLife } from "./cache-request-state.js";
 import { encodeCacheTags } from "../utils/encode-cache-tag.js";
 //#region src/shims/fetch-cache.ts
 /**
@@ -296,6 +297,7 @@ const _fallbackState = _g[_FALLBACK_KEY] ??= {
 	currentFetchCacheMode: null,
 	currentForceDynamicFetchDefault: false,
 	dynamicFetchUrls: /* @__PURE__ */ new Set(),
+	refreshStaleFetchesInForeground: false,
 	isFetchDedupeActive: false,
 	currentFetchDedupeEntries: /* @__PURE__ */ new Map()
 };
@@ -314,6 +316,7 @@ function _resetFallbackState(isFetchDedupeActive) {
 	_fallbackState.currentFetchCacheMode = null;
 	_fallbackState.currentForceDynamicFetchDefault = false;
 	_fallbackState.dynamicFetchUrls = /* @__PURE__ */ new Set();
+	_fallbackState.refreshStaleFetchesInForeground = false;
 	_fallbackState.isFetchDedupeActive = isFetchDedupeActive;
 	_fallbackState.currentFetchDedupeEntries = /* @__PURE__ */ new Map();
 }
@@ -330,6 +333,56 @@ function markUncachedFetchForPageOutput(input) {
 function recordCacheableFetchObservation(input) {
 	_getState().cacheableFetchUrls.add(getFetchObservationUrl(input));
 }
+function recordFiniteFetchRevalidate(revalidateSeconds) {
+	if (Number.isFinite(revalidateSeconds) && revalidateSeconds > 0) _setRequestScopedCacheLife({ revalidate: revalidateSeconds });
+}
+function shouldRefreshStaleFetchInForeground() {
+	return _getState().refreshStaleFetchesInForeground;
+}
+async function buildFetchCacheValue(response, tags, revalidateSeconds, options) {
+	if (response.status !== 200) return null;
+	const responseForCache = options?.cloneForReturn === false ? response : response.clone();
+	const body = await responseForCache.text();
+	const headers = {};
+	responseForCache.headers.forEach((v, k) => {
+		if (k.toLowerCase() === "set-cookie") return;
+		headers[k] = v;
+	});
+	return {
+		kind: "FETCH",
+		data: {
+			headers,
+			body,
+			url: response.url,
+			status: responseForCache.status
+		},
+		tags,
+		revalidate: revalidateSeconds
+	};
+}
+async function writeFetchCacheResponse(handler, cacheKey, response, tags, revalidateSeconds, options) {
+	const cacheValue = await buildFetchCacheValue(response, tags, revalidateSeconds, options);
+	if (!cacheValue) return;
+	await handler.set(cacheKey, cacheValue, {
+		fetchCache: true,
+		tags,
+		revalidate: revalidateSeconds
+	});
+}
+async function lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cachedValue, tags, revalidateSeconds) {
+	if (!Number.isFinite(revalidateSeconds) || revalidateSeconds <= 0 || typeof cachedValue.revalidate !== "number" || cachedValue.revalidate <= revalidateSeconds) return;
+	const mergedTags = Array.from(new Set([...cachedValue.tags ?? [], ...tags]));
+	const updatedValue = {
+		...cachedValue,
+		tags: mergedTags,
+		revalidate: revalidateSeconds
+	};
+	await handler.set(cacheKey, updatedValue, {
+		fetchCache: true,
+		tags: mergedTags,
+		revalidate: revalidateSeconds
+	});
+}
 function peekCacheableFetchObservations() {
 	return [..._getState().cacheableFetchUrls].sort();
 }
@@ -393,6 +446,9 @@ function setCurrentFetchCacheMode(mode) {
 function setCurrentForceDynamicFetchDefault(enabled) {
 	_getState().currentForceDynamicFetchDefault = enabled;
 }
+function setRefreshStaleFetchesInForeground(enabled) {
+	_getState().refreshStaleFetchesInForeground = enabled;
+}
 function isNoStoreFetch(cacheDirective, nextOpts) {
 	return cacheDirective === "no-store" || cacheDirective === "no-cache" || nextOpts?.revalidate === 0;
 }
@@ -562,6 +618,7 @@ function createPatchedFetch() {
 			return dedupeFetch(input, cleanInit);
 		}
 		recordCacheableFetchObservation(input);
+		recordFiniteFetchRevalidate(revalidateSeconds);
 		const reqTags = _getState().currentRequestTags;
 		const tags = encodeCacheTags(nextOpts?.tags ?? []);
 		if (tags.length > 0) {
@@ -586,39 +643,24 @@ function createPatchedFetch() {
 			const cached = await handler.get(cacheKey, {
 				kind: "FETCH",
 				tags,
-				softTags
+				softTags,
+				revalidate: revalidateSeconds
 			});
 			if (cached?.value && cached.value.kind === "FETCH" && cached.cacheState !== "stale") {
+				await lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cached.value, tags, revalidateSeconds);
 				const cachedData = cached.value.data;
 				return buildCachedFetchResponse(cachedData, input);
 			}
 			if (cached?.value && cached.value.kind === "FETCH" && cached.cacheState === "stale") {
+				if (shouldRefreshStaleFetchInForeground()) {
+					const freshResponse = await dedupeFetch(input, fetchInit);
+					await writeFetchCacheResponse(handler, cacheKey, freshResponse, tags, revalidateSeconds);
+					return freshResponse;
+				}
 				const staleData = cached.value.data;
 				if (!pendingRefetches.has(cacheKey)) {
 					const refetchPromise = originalFetch(input, fetchInit).then(async (freshResp) => {
-						if (freshResp.status !== 200) return;
-						const freshBody = await freshResp.text();
-						const freshHeaders = {};
-						freshResp.headers.forEach((v, k) => {
-							if (k.toLowerCase() === "set-cookie") return;
-							freshHeaders[k] = v;
-						});
-						const freshValue = {
-							kind: "FETCH",
-							data: {
-								headers: freshHeaders,
-								body: freshBody,
-								url: freshResp.url,
-								status: freshResp.status
-							},
-							tags,
-							revalidate: revalidateSeconds
-						};
-						await handler.set(cacheKey, freshValue, {
-							fetchCache: true,
-							tags,
-							revalidate: revalidateSeconds
-						});
+						await writeFetchCacheResponse(handler, cacheKey, freshResp, tags, revalidateSeconds, { cloneForReturn: false });
 					}).catch((err) => {
 						const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
 						console.error(`[vinext] fetch cache background revalidation failed for ${url} (key=${cacheKey.slice(0, 12)}...):`, err);
@@ -638,33 +680,14 @@ function createPatchedFetch() {
 			console.error("[vinext] fetch cache read error:", cacheErr);
 		}
 		const response = await dedupeFetch(input, fetchInit);
-		if (response.status === 200) {
-			const cloned = response.clone();
-			const body = await cloned.text();
-			const headers = {};
-			cloned.headers.forEach((v, k) => {
-				if (k.toLowerCase() === "set-cookie") return;
-				headers[k] = v;
-			});
-			const cacheValue = {
-				kind: "FETCH",
-				data: {
-					headers,
-					body,
-					url: response.url,
-					status: cloned.status
-				},
-				tags,
-				revalidate: revalidateSeconds
-			};
-			handler.set(cacheKey, cacheValue, {
-				fetchCache: true,
-				tags,
-				revalidate: revalidateSeconds
-			}).catch((err) => {
-				console.error("[vinext] fetch cache write error:", err);
-			});
-		}
+		const cacheValue = await buildFetchCacheValue(response, tags, revalidateSeconds);
+		if (cacheValue) handler.set(cacheKey, cacheValue, {
+			fetchCache: true,
+			tags,
+			revalidate: revalidateSeconds
+		}).catch((err) => {
+			console.error("[vinext] fetch cache write error:", err);
+		});
 		return response;
 	};
 }
@@ -716,6 +739,7 @@ async function runWithFetchCache(fn) {
 		uCtx.currentRequestTags = [];
 		uCtx.currentFetchSoftTags = [];
 		uCtx.dynamicFetchUrls = /* @__PURE__ */ new Set();
+		uCtx.refreshStaleFetchesInForeground = false;
 		uCtx.isFetchDedupeActive = true;
 		uCtx.currentFetchDedupeEntries = /* @__PURE__ */ new Map();
 	}, fn);
@@ -726,6 +750,7 @@ async function runWithFetchCache(fn) {
 		currentFetchCacheMode: null,
 		currentForceDynamicFetchDefault: false,
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
+		refreshStaleFetchesInForeground: false,
 		isFetchDedupeActive: true,
 		currentFetchDedupeEntries: /* @__PURE__ */ new Map()
 	}, fn);
@@ -763,4 +788,4 @@ function getOriginalFetch() {
 	return originalFetch;
 }
 //#endregion
-export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, withFetchCache };
+export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };

package/dist/shims/form.d.ts

@@ -1,6 +1,8 @@
 import { FormHTMLAttributes, useActionState } from "react";
 
 //#region src/shims/form.d.ts
+type FormSubmitter = HTMLButtonElement | HTMLInputElement;
+declare function createFormSubmitDestinationUrl(action: string, form: HTMLFormElement, submitter: FormSubmitter | null): string;
 declare const Form: import("react").ForwardRefExoticComponent<{
   /** Target URL for GET forms, or server action for POST forms */action: string | ((formData: FormData) => void | Promise<void>); /** Replace instead of push in history (default: false) */
   replace?: boolean; /** Scroll to top after navigation (default: true) */
@@ -14,6 +16,6 @@ declare const Form: import("react").ForwardRefExoticComponent<{
    * In pages dir, prefetch is not supported and the prop has no effect.
    */
   prefetch?: false | null;
-} & Omit<FormHTMLAttributes<HTMLFormElement>, "method" | "encType" | "target"> & import("react").RefAttributes<HTMLFormElement>>;
+} & Omit<FormHTMLAttributes<HTMLFormElement>, "target" | "method" | "encType"> & import("react").RefAttributes<HTMLFormElement>>;
 //#endregion
-export { Form as default, useActionState };
+export { createFormSubmitDestinationUrl, Form as default, useActionState };

package/dist/shims/form.js

@@ -1,9 +1,11 @@
 "use client";
 import { VINEXT_MOUNTED_SLOTS_HEADER } from "../server/headers.js";
-import { isDangerousScheme } from "./url-safety.js";
+import { assertSafeNavigationUrl } from "./url-safety.js";
 import { AppElementsWire } from "../server/app-elements-wire.js";
+import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "../server/app-rsc-render-mode.js";
 import "../server/app-elements.js";
-import { toSameOriginPath, withBasePath } from "./url-utils.js";
+import { withBasePath } from "./url-utils.js";
+import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { createRscRequestHeaders, createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
 import { hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { getMountedSlotsHeader, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, navigateClientSide, prefetchRscResponse } from "./navigation.js";
@@ -37,18 +39,13 @@ const DISALLOWED_FORM_PROPS = [
 const SUPPORTED_FORM_ENCTYPE = "application/x-www-form-urlencoded";
 const SUPPORTED_FORM_METHOD = "GET";
 const SUPPORTED_FORM_TARGET = "_self";
-function isSafeAction(action) {
-	if (isDangerousScheme(action)) return false;
-	if (action.startsWith("//")) return false;
-	if (/^https?:\/\//i.test(action)) {
-		if (typeof window !== "undefined") try {
-			return new URL(action).origin === window.location.origin;
-		} catch {
-			return false;
-		}
+function isPrefetchableAction(action) {
+	try {
+		const actionUrl = new URL(action, window.location.href);
+		return (actionUrl.protocol === "http:" || actionUrl.protocol === "https:") && actionUrl.origin === window.location.origin;
+	} catch {
 		return false;
 	}
-	return true;
 }
 function getSubmitter(nativeEvent) {
 	const submitter = nativeEvent && typeof nativeEvent === "object" && "submitter" in nativeEvent && nativeEvent.submitter instanceof Element ? nativeEvent.submitter : null;
@@ -103,7 +100,7 @@ function createFormSubmitDestinationUrl(action, form, submitter) {
 		if (process.env.NODE_ENV !== "production") console.warn("<Form> only supports file inputs if `action` is a function. File inputs cannot be used if `action` is a string, because files cannot be encoded as search params.");
 		targetUrl.searchParams.append(name, value.name);
 	} else targetUrl.searchParams.append(name, value);
-	return toSameOriginPath(targetUrl.href) ?? targetUrl.href;
+	return targetUrl.href;
 }
 function buildFormData(form, submitter) {
 	if (!submitter) return new FormData(form);
@@ -137,7 +134,7 @@ const Form = forwardRef(function Form(props, ref) {
 	useEffect(() => {
 		if (typeof action !== "string") return;
 		if (prefetch === false || process.env.NODE_ENV !== "production") return;
-		if (!isSafeAction(action)) return;
+		if (!isPrefetchableAction(actionHref)) return;
 		if (!hasAppNavigationRuntime()) return;
 		const node = formRef.current;
 		if (!node) return;
@@ -145,9 +142,13 @@ const Form = forwardRef(function Form(props, ref) {
 		const observer = new IntersectionObserver((entries) => {
 			for (const entry of entries) if (entry.isIntersecting || entry.intersectionRatio > 0) {
 				(async () => {
+					if (isBotUserAgent(window.navigator?.userAgent ?? "")) return;
 					const interceptionContext = getPrefetchInterceptionContext(actionHref);
 					const mountedSlotsHeader = getMountedSlotsHeader();
-					const headers = createRscRequestHeaders({ interceptionContext });
+					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 cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
@@ -161,8 +162,8 @@ const Form = forwardRef(function Form(props, ref) {
 						priority: "low",
 						purpose: "prefetch"
 					}), interceptionContext, mountedSlotsHeader, void 0, {
-						cacheForNavigation: true,
-						optimisticRouteShell: false
+						cacheForNavigation: false,
+						optimisticRouteShell: true
 					});
 				})();
 				observer.unobserve(node);
@@ -183,15 +184,7 @@ const Form = forwardRef(function Form(props, ref) {
 		onSubmit,
 		...cleanRest
 	});
-	if (!isSafeAction(action)) {
-		if (process.env.NODE_ENV !== "production") console.warn(`<Form> blocked unsafe action: ${action}`);
-		return /* @__PURE__ */ jsx("form", {
-			ref: setRefs,
-			onSubmit,
-			...cleanRest
-		});
-	}
-	async function handleSubmit(e) {
+	function handleSubmit(e) {
 		if (onSubmit) {
 			onSubmit(e);
 			if (e.defaultPrevented) return;
@@ -204,23 +197,24 @@ const Form = forwardRef(function Form(props, ref) {
 		}
 		const effectiveAction = getEffectiveAction(submitter, actionHref);
 		if (process.env.NODE_ENV !== "production" && submitter?.getAttribute("formaction") !== null) checkFormActionUrl(effectiveAction, "formAction");
-		if (!isSafeAction(effectiveAction)) {
-			if (process.env.NODE_ENV !== "production") console.warn(`<Form> blocked unsafe action: ${effectiveAction}`);
-			e.preventDefault();
-			return;
-		}
-		e.preventDefault();
 		const url = createFormSubmitDestinationUrl(effectiveAction, e.currentTarget, submitter);
-		if (hasAppNavigationRuntime()) await navigateClientSide(url, replace ? "replace" : "push", scroll);
-		else try {
-			const Router = (await import("./router.js")).default;
-			if (replace) await Router.replace(url, void 0, { scroll });
-			else await Router.push(url, void 0, { scroll });
-		} catch {
-			if (replace) window.history.replaceState({}, "", url);
-			else window.history.pushState({}, "", url);
-			window.dispatchEvent(new PopStateEvent("popstate"));
-			if (scroll) window.scrollTo(0, 0);
+		e.preventDefault();
+		if (hasAppNavigationRuntime()) {
+			assertSafeNavigationUrl(url);
+			navigateClientSide(url, replace ? "replace" : "push", scroll);
+		} else {
+			assertSafeNavigationUrl(url);
+			(async () => {
+				let Router;
+				try {
+					Router = (await import("./router.js")).default;
+					if (replace) await Router.replace(url, void 0, { scroll });
+					else await Router.push(url, void 0, { scroll });
+				} catch {
+					if (replace) window.location.replace(url);
+					else window.location.assign(url);
+				}
+			})();
 		}
 	}
 	return /* @__PURE__ */ jsx("form", {
@@ -233,4 +227,4 @@ const Form = forwardRef(function Form(props, ref) {
 	});
 });
 //#endregion
-export { Form as default, useActionState };
+export { createFormSubmitDestinationUrl, Form as default, useActionState };

package/dist/shims/headers.d.ts

@@ -179,6 +179,12 @@ declare function getAndClearPendingCookies(): string[];
  */
 declare function getDraftModeCookieHeader(): string | null;
 declare function isDraftModeRequest(request: Request, draftModeSecret: string): boolean;
+/**
+ * Read the active request's draft-mode state without recording request API usage.
+ * Internal cache implementations use this to bypass persistent reads and writes,
+ * matching Next.js's request-level `workStore.isDraftMode` guard.
+ */
+declare function isDraftModeEnabled(): boolean;
 type DraftModeResult = {
   readonly isEnabled: boolean;
   enable(): void;
@@ -252,4 +258,4 @@ declare class RequestCookies {
   toString(): string;
 }
 //#endregion
-export { HeadersAccessPhase, HeadersContext, type RequestCookies, VinextHeadersShimState, applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, draftMode, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersAccessPhase, getHeadersContext, headers, headersContextFromRequest, isDraftModeRequest, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithConnectionProbe, runWithHeadersContext, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };
+export { HeadersAccessPhase, HeadersContext, type RequestCookies, VinextHeadersShimState, applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, draftMode, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersAccessPhase, getHeadersContext, headers, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithConnectionProbe, runWithHeadersContext, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };

package/dist/shims/headers.js

@@ -1,7 +1,8 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
-import { FLIGHT_HEADERS, MIDDLEWARE_SET_COOKIE_HEADER, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER } from "../server/headers.js";
-import { buildRequestHeadersFromMiddlewareResponse } from "../server/middleware-request-headers.js";
+import { MIDDLEWARE_SET_COOKIE_HEADER } from "../utils/protocol-headers.js";
+import { FLIGHT_HEADERS, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER } from "../server/headers.js";
+import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
 import { serializeSetCookie, validateCookieAttributeValue, validateCookieName } from "./internal/cookie-serialize.js";
 import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
 import { createPprFallbackShellSuspensePromise } from "./ppr-fallback-shell.js";
@@ -609,6 +610,19 @@ function isDraftModeRequest(request, draftModeSecret) {
 	if (!cookieHeader) return false;
 	return parseEdgeRequestCookieHeader(cookieHeader).get(DRAFT_MODE_COOKIE) === validateDraftModeSecret(draftModeSecret);
 }
+/**
+* Read the active request's draft-mode state without recording request API usage.
+* Internal cache implementations use this to bypass persistent reads and writes,
+* matching Next.js's request-level `workStore.isDraftMode` guard.
+*/
+function isDraftModeEnabled() {
+	const context = _getState().headersContext;
+	if (!context) return false;
+	if (context.draftModeEnabled !== void 0) return context.draftModeEnabled;
+	const secret = context.draftModeSecret;
+	if (secret === void 0) return false;
+	return context.cookies.get(DRAFT_MODE_COOKIE) === validateDraftModeSecret(secret);
+}
 function draftModeCookieAttributes() {
 	if (typeof process !== "undefined" && process.env?.NODE_ENV === "development") return "Path=/; HttpOnly; SameSite=Lax";
 	return "Path=/; HttpOnly; SameSite=None; Secure";
@@ -762,4 +776,4 @@ var RequestCookies = class {
 	}
 };
 //#endregion
-export { applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, draftMode, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersAccessPhase, getHeadersContext, headers, headersContextFromRequest, isDraftModeRequest, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithConnectionProbe, runWithHeadersContext, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };
+export { applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, draftMode, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersAccessPhase, getHeadersContext, headers, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithConnectionProbe, runWithHeadersContext, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };