vinext 1.0.1 → 1.2.0

package/dist/shims/fetch-cache.js

@@ -1,9 +1,10 @@
-import { getOrCreateAls } from "./internal/als-registry.js";
-import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+import { isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
 import { getRequestExecutionContext } from "./request-context.js";
 import { getDataCacheHandler } from "./cache-handler.js";
 import { encodeCacheTags } from "../utils/encode-cache-tag.js";
+import { sha256Hex } from "../utils/hash.js";
 import { traceAppFetch } from "../server/app-fetch-tracing.js";
+import { addCollectedRequestTags, fallbackFetchCacheState, fetchCacheAls, getCurrentFetchSoftTags, getFetchCacheState, resetFallbackFetchCacheState, runWithDetachedFetchObservations } from "./fetch-cache-state.js";
 import { isInsideAnyCacheScope, markDynamicUsage } from "./internal/headers-state.js";
 import { getHeadersContext } from "./headers.js";
 import { _hasPendingRevalidatedTag, _setRequestScopedCacheLife } from "./cache-request-state.js";
@@ -35,7 +36,7 @@ import { Buffer } from "node:buffer";
 * All other headers ARE included in the cache key, matching Next.js behavior.
 */
 const HEADER_BLOCKLIST = ["traceparent", "tracestate"];
-const CACHE_KEY_PREFIX = "v5";
+const CACHE_KEY_PREFIX = "v8";
 const MAX_CACHE_KEY_BODY_BYTES = 1048576;
 const ONE_YEAR_SECONDS = 31536e3;
 var BodyTooLargeForCacheKeyError = class extends Error {
@@ -76,6 +77,17 @@ function hasAuthHeaders(input, init) {
 	const headers = collectHeaders(input, init);
 	return AUTH_HEADERS.some((name) => name in headers);
 }
+/**
+* Workers' `cf.resolveOverride` sends the request to a different origin
+* without changing the URL or headers, so it must be part of the fetch cache
+* and dedupe keys. Other `cf` properties only tune Cloudflare's edge cache or
+* optimize the same resource, so they stay out of the keys. Next.js has no
+* equivalent because it never runs on Workers.
+*/
+function getResolveOverride(input, init) {
+	const initCf = init?.cf;
+	return (initCf !== void 0 ? initCf : input instanceof Request ? input.cf : void 0)?.resolveOverride ?? null;
+}
 const BYTE_HEX = Array.from({ length: 256 }, (_, value) => value.toString(16).padStart(2, "0"));
 function encodeBodyBytes(bytes) {
 	let encoded = "bytes:";
@@ -143,6 +155,40 @@ function normalizeFetchMethod(method) {
 	const upperMethod = method.toUpperCase();
 	return NORMALIZED_FETCH_METHODS.has(upperMethod) ? upperMethod : method;
 }
+function getIntrinsic(prototype, key) {
+	const getter = Object.getOwnPropertyDescriptor(prototype, key)?.get;
+	if (!getter) throw new Error(`Missing intrinsic getter: ${String(key)}`);
+	return (target) => Reflect.apply(getter, target, []);
+}
+const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+const getTypedArrayTag = getIntrinsic(typedArrayPrototype, Symbol.toStringTag);
+const getTypedArrayBuffer = getIntrinsic(typedArrayPrototype, "buffer");
+const getTypedArrayByteOffset = getIntrinsic(typedArrayPrototype, "byteOffset");
+const getTypedArrayByteLength = getIntrinsic(typedArrayPrototype, "byteLength");
+const getDataViewBuffer = getIntrinsic(DataView.prototype, "buffer");
+const getDataViewByteOffset = getIntrinsic(DataView.prototype, "byteOffset");
+const getDataViewByteLength = getIntrinsic(DataView.prototype, "byteLength");
+const getArrayBufferByteLength = getIntrinsic(ArrayBuffer.prototype, "byteLength");
+function isArrayBuffer(value) {
+	if (!(value instanceof ArrayBuffer)) return false;
+	try {
+		getArrayBufferByteLength(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* The bytes sent for a binary body chunk: the bytes an ArrayBuffer holds, or
+* those a typed array or DataView covers. Undefined for any other chunk.
+*/
+function getBinaryChunkBytes(value) {
+	if (ArrayBuffer.isView(value)) {
+		if (getTypedArrayTag(value) !== void 0) return new Uint8Array(getTypedArrayBuffer(value), getTypedArrayByteOffset(value), getTypedArrayByteLength(value));
+		return new Uint8Array(getDataViewBuffer(value), getDataViewByteOffset(value), getDataViewByteLength(value));
+	}
+	if (isArrayBuffer(value)) return new Uint8Array(value);
+}
 async function readRequestBodyChunksWithinLimit(request, effectiveHeaders) {
 	const contentLengthHeader = effectiveHeaders.get("content-length");
 	if (contentLengthHeader) {
@@ -162,9 +208,11 @@ async function readRequestBodyChunksWithinLimit(request, effectiveHeaders) {
 		while (true) {
 			const { done, value } = await reader.read();
 			if (done) break;
-			totalBodyBytes += value.byteLength;
+			const bytes = getBinaryChunkBytes(value);
+			if (!bytes) throw new SkipCacheKeyGenerationError();
+			totalBodyBytes += bytes.byteLength;
 			if (totalBodyBytes > MAX_CACHE_KEY_BODY_BYTES) throw new BodyTooLargeForCacheKeyError();
-			chunks.push(value);
+			chunks.push(bytes);
 		}
 	} catch (err) {
 		reader.cancel().catch(() => {});
@@ -175,6 +223,61 @@ async function readRequestBodyChunksWithinLimit(request, effectiveHeaders) {
 		contentType
 	};
 }
+const builtBodyRequests = /* @__PURE__ */ new WeakSet();
+/**
+* Whether serializeBody keys this init body type itself. Only genuine
+* instances count, so an array (which has keys()) or a Response (which has
+* arrayBuffer()) is sent however the runtime sends it.
+*/
+function isKeyableInitBody(body) {
+	return typeof body === "string" || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof URLSearchParams || body instanceof ReadableStream || body instanceof FormData || body instanceof Blob;
+}
+/**
+* Copy a cacheable fetch's request when fetch is called, as fetch itself does.
+* Its cache key is built, and it is sent, only after awaits. A URL, headers,
+* body or `cf` the caller changes in the meantime must reach neither: the
+* request would be sent with values its key doesn't hold, and its response
+* cached for the values the key does hold. A stream body is read after the
+* call, as fetch reads it, and sent as the bytes its key is built from.
+*/
+function snapshotFetchRequest(input, init) {
+	const snapshotInit = { ...init };
+	const headers = snapshotInit.headers !== void 0 ? snapshotInit.headers : input instanceof Request ? input.headers : void 0;
+	if (headers !== void 0) snapshotInit.headers = new Headers(headers);
+	const cf = snapshotInit.cf !== void 0 ? snapshotInit.cf : input instanceof Request ? input.cf : void 0;
+	if (cf !== null && typeof cf === "object") snapshotInit.cf = snapshotCf(cf);
+	if (snapshotInit.body !== void 0 && snapshotInit.body !== null) snapshotInit.body = snapshotBody(snapshotInit.body);
+	return {
+		input: input instanceof Request ? input : String(input),
+		init: snapshotInit
+	};
+}
+function snapshotCf(cf) {
+	try {
+		return JSON.parse(JSON.stringify(cf));
+	} catch {
+		return cf;
+	}
+}
+function snapshotBody(body) {
+	const bytes = getBinaryChunkBytes(body);
+	if (bytes) return bytes.slice();
+	if (body instanceof URLSearchParams) return new URLSearchParams(body);
+	if (body instanceof FormData) {
+		const formData = new FormData();
+		for (const [name, value] of body) formData.append(name, typeof value === "string" ? value : snapshotBlob(value));
+		return formData;
+	}
+	if (body instanceof Blob) return snapshotBlob(body);
+	return body;
+}
+function snapshotBlob(blob) {
+	if (blob instanceof File) return new File([blob], blob.name, {
+		type: blob.type,
+		lastModified: blob.lastModified
+	});
+	return new Blob([blob], { type: blob.type });
+}
 /**
 * Serialize request body into string chunks for cache key inclusion.
 * Handles all body types: string, Uint8Array, ReadableStream, FormData, Blob,
@@ -200,8 +303,9 @@ async function serializeBody(input, init) {
 		pushBodyChunk(encodeBodyBytes(bytes), bytes.byteLength);
 	};
 	const getTotalBodyBytes = () => totalBodyBytes;
-	if (init?.body instanceof ArrayBuffer || init?.body && ArrayBuffer.isView(init.body)) {
-		const bytes = init.body instanceof ArrayBuffer ? new Uint8Array(init.body) : new Uint8Array(init.body.buffer, init.body.byteOffset, init.body.byteLength);
+	const directBodyBytes = getBinaryChunkBytes(init?.body);
+	if (init?.body && directBodyBytes) {
+		const bytes = directBodyBytes;
 		if (bytes.byteLength > MAX_CACHE_KEY_BODY_BYTES) throw new BodyTooLargeForCacheKeyError();
 		pushBodyBytes(bytes);
 		init._ogBody = init.body;
@@ -214,12 +318,16 @@ async function serializeBody(input, init) {
 			while (true) {
 				const { done, value } = await reader.read();
 				if (done) break;
-				const bytes = typeof value === "string" ? encoder.encode(value) : value;
+				const bytes = typeof value === "string" ? encoder.encode(value) : getBinaryChunkBytes(value);
+				if (!bytes) throw new SkipCacheKeyGenerationError();
 				totalBodyBytes += bytes.byteLength;
 				if (totalBodyBytes > MAX_CACHE_KEY_BODY_BYTES) throw new BodyTooLargeForCacheKeyError();
 				chunks.push(bytes);
 			}
-			bodyChunks.push(encodeBodyBytes(concatBodyBytes(chunks)));
+			const bytes = concatBodyBytes(chunks);
+			bodyChunks.push(encodeBodyBytes(bytes));
+			init._ogBody = bytes;
+			bodyForFetch.cancel().catch(() => {});
 		} catch (err) {
 			reader.cancel().catch(() => {});
 			if (err instanceof BodyTooLargeForCacheKeyError) throw err;
@@ -258,7 +366,8 @@ async function serializeBody(input, init) {
 			if (err instanceof BodyTooLargeForCacheKeyError) throw err;
 			throw new SkipCacheKeyGenerationError();
 		}
-		const formContentType = getParsedFormContentType(contentType);
+		if (init) init._ogBody = concatBodyBytes(chunks);
+		const formContentType = builtBodyRequests.has(input) ? void 0 : getParsedFormContentType(contentType);
 		if (formContentType) try {
 			await serializeFormData(await new Request(input.url, {
 				method: input.method,
@@ -316,11 +425,10 @@ async function buildFetchCacheKey(input, init) {
 		init?.integrity ?? inputRequest?.integrity ?? "",
 		init?.cache ?? inputRequest?.cache ?? "default",
 		bodyChunks,
-		bodyMetadata
+		bodyMetadata,
+		getResolveOverride(input, init)
 	]);
-	const buffer = new TextEncoder().encode(cacheString);
-	const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
-	return Array.prototype.map.call(new Uint8Array(hashBuffer), (b) => b.toString(16).padStart(2, "0")).join("");
+	return sha256Hex(cacheString);
 }
 const _PENDING_KEY = Symbol.for("vinext.fetchCache.pendingRefetches");
 const _gPending = globalThis;
@@ -333,54 +441,17 @@ function _resetPendingRefetches() {
 const _ORIG_FETCH_KEY = Symbol.for("vinext.fetchCache.originalFetch");
 const _gFetch = globalThis;
 const originalFetch = _gFetch[_ORIG_FETCH_KEY] ??= globalThis.fetch;
-const _FALLBACK_KEY = Symbol.for("vinext.fetchCache.fallback");
-const _g = globalThis;
-const _als = getOrCreateAls("vinext.fetchCache.als");
 const _noop = () => {};
 let _responseBodyRegistry;
 if (globalThis.FinalizationRegistry) _responseBodyRegistry = new FinalizationRegistry((weakRef) => {
 	const stream = weakRef.deref();
 	if (stream && !stream.locked) stream.cancel("Response object has been garbage collected").then(_noop, _noop);
 });
-const _fallbackState = _g[_FALLBACK_KEY] ??= {
-	cacheableFetchUrls: /* @__PURE__ */ new Set(),
-	currentRequestTags: [],
-	currentFetchSoftTags: [],
-	currentFetchCacheMode: null,
-	currentFetchRevalidate: null,
-	currentForceDynamicFetchDefault: false,
-	dynamicFetchUrls: /* @__PURE__ */ new Set(),
-	refreshStaleFetchesInForeground: false,
-	isFetchDedupeActive: false,
-	currentFetchDedupeEntries: /* @__PURE__ */ new Map(),
-	nextFetchId: 1
-};
-function _getState() {
-	if (isInsideUnifiedScope()) return getRequestContext();
-	return _als.getStore() ?? _fallbackState;
-}
-/**
-* Reset the fallback state for a new request.  Used by `withFetchCache()`
-* in single-threaded contexts where ALS.run() isn't used.
-*/
-function _resetFallbackState(isFetchDedupeActive) {
-	_fallbackState.cacheableFetchUrls = /* @__PURE__ */ new Set();
-	_fallbackState.currentRequestTags = [];
-	_fallbackState.currentFetchSoftTags = [];
-	_fallbackState.currentFetchCacheMode = null;
-	_fallbackState.currentFetchRevalidate = null;
-	_fallbackState.currentForceDynamicFetchDefault = false;
-	_fallbackState.dynamicFetchUrls = /* @__PURE__ */ new Set();
-	_fallbackState.refreshStaleFetchesInForeground = false;
-	_fallbackState.isFetchDedupeActive = isFetchDedupeActive;
-	_fallbackState.currentFetchDedupeEntries = /* @__PURE__ */ new Map();
-	_fallbackState.nextFetchId = 1;
-}
 function getFetchObservationUrl(input) {
 	return typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
 }
 function addDynamicFetchObservation(input) {
-	_getState().dynamicFetchUrls.add(getFetchObservationUrl(input));
+	getFetchCacheState().dynamicFetchUrls.add(getFetchObservationUrl(input));
 }
 function recordDynamicFetchObservation(input) {
 	if (isInsideAnyCacheScope()) return;
@@ -389,21 +460,21 @@ function recordDynamicFetchObservation(input) {
 function markUncachedFetchForPageOutput(input) {
 	if (isInsideAnyCacheScope()) return;
 	addDynamicFetchObservation(input);
-	if (getHeadersContext()?.forceStatic !== true) _getState().currentFetchRevalidate = 0;
+	if (getHeadersContext()?.forceStatic !== true) getFetchCacheState().currentFetchRevalidate = 0;
 	markDynamicUsage();
 }
 function recordCacheableFetchObservation(input) {
-	_getState().cacheableFetchUrls.add(getFetchObservationUrl(input));
+	getFetchCacheState().cacheableFetchUrls.add(getFetchObservationUrl(input));
 }
 function recordFiniteFetchRevalidate(revalidateSeconds) {
 	if (Number.isFinite(revalidateSeconds) && revalidateSeconds > 0) _setRequestScopedCacheLife({ revalidate: revalidateSeconds });
 }
 function lowerCurrentFetchRevalidate(revalidateSeconds) {
-	const state = _getState();
+	const state = getFetchCacheState();
 	if (state.currentFetchRevalidate === null || revalidateSeconds < state.currentFetchRevalidate) state.currentFetchRevalidate = revalidateSeconds;
 }
 function shouldRefreshStaleFetchInForeground() {
-	return _getState().refreshStaleFetchesInForeground;
+	return getFetchCacheState().refreshStaleFetchesInForeground;
 }
 async function buildFetchCacheValue(response, tags, revalidateSeconds, options) {
 	if (response.status !== 200) return null;
@@ -450,13 +521,13 @@ async function lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cachedValue,
 	});
 }
 function peekCacheableFetchObservations() {
-	return [..._getState().cacheableFetchUrls].sort();
+	return [...getFetchCacheState().cacheableFetchUrls].sort();
 }
 function peekDynamicFetchObservations() {
-	return [..._getState().dynamicFetchUrls].sort();
+	return [...getFetchCacheState().dynamicFetchUrls].sort();
 }
 function consumeDynamicFetchObservations() {
-	const state = _getState();
+	const state = getFetchCacheState();
 	const observed = [...state.dynamicFetchUrls].sort();
 	state.dynamicFetchUrls = /* @__PURE__ */ new Set();
 	return observed;
@@ -467,24 +538,7 @@ function consumeDynamicFetchObservations() {
 * fetch tags used during rendering.
 */
 function getCollectedFetchTags() {
-	return [..._getState().currentRequestTags];
-}
-/**
-* Append cache tags to the current request's collected tags.
-*
-* Mirrors Next.js's `propagateCacheLifeAndTagsToRevalidateStore`: tags declared
-* inside a `"use cache"` function (via `cacheTag()`, persisted on the data cache
-* entry) must also bubble up to the surrounding page / route-handler ISR entry
-* so `revalidateTag()` / `revalidatePath()` can evict the rendered output, not
-* just the inner data cache entry. Without this, a cached `"use cache"` result
-* keeps being served from a stale page/route entry after its tag is revalidated
-* (issue #1453). Tags are already encoded by the caller; deduped to match the
-* tagged-fetch path. A no-op for empty input.
-*/
-function addCollectedRequestTags(tags) {
-	if (tags.length === 0) return;
-	const reqTags = _getState().currentRequestTags;
-	for (const tag of tags) if (!reqTags.includes(tag)) reqTags.push(tag);
+	return [...getFetchCacheState().currentRequestTags];
 }
 /**
 * Set path-derived implicit tags for fetch cache reads in the current render.
@@ -494,29 +548,19 @@ function addCollectedRequestTags(tags) {
 * affected route, without permanently coupling a shared fetch entry to one path.
 */
 function setCurrentFetchSoftTags(tags) {
-	_getState().currentFetchSoftTags = [...tags];
-}
-/**
-* Read the path-derived soft tags for the current render.
-*
-* Used by the "use cache" runtime to pass soft tags to the cache handler
-* so that `revalidatePath()` invalidates "use cache" entries during the
-* affected route's next request, even when the entry carries no hard tags.
-*/
-function getCurrentFetchSoftTags() {
-	return _getState().currentFetchSoftTags;
+	getFetchCacheState().currentFetchSoftTags = [...tags];
 }
 function setCurrentFetchCacheMode(mode) {
-	_getState().currentFetchCacheMode = mode;
+	getFetchCacheState().currentFetchCacheMode = mode;
 }
 function setCurrentFetchRevalidate(revalidate) {
-	_getState().currentFetchRevalidate = revalidate;
+	getFetchCacheState().currentFetchRevalidate = revalidate;
 }
 function setCurrentForceDynamicFetchDefault(enabled) {
-	_getState().currentForceDynamicFetchDefault = enabled;
+	getFetchCacheState().currentForceDynamicFetchDefault = enabled;
 }
 function setRefreshStaleFetchesInForeground(enabled) {
-	_getState().refreshStaleFetchesInForeground = enabled;
+	getFetchCacheState().refreshStaleFetchesInForeground = enabled;
 }
 function isNoStoreFetch(cacheDirective, nextOpts) {
 	return cacheDirective === "no-store" || cacheDirective === "no-cache" || nextOpts?.revalidate === 0;
@@ -552,7 +596,7 @@ function getFetchCacheDirective(input, init) {
 	if (!(input instanceof Request) || input.cache === "default") return;
 	return input.cache;
 }
-function buildFetchDedupeKey(request) {
+function buildFetchDedupeKey(request, resolveOverride) {
 	const filteredHeaders = Array.from(request.headers.entries()).filter(([key]) => !HEADER_BLOCKLIST.includes(key.toLowerCase()));
 	return JSON.stringify([
 		request.method,
@@ -562,7 +606,8 @@ function buildFetchDedupeKey(request) {
 		request.credentials,
 		request.referrer,
 		request.referrerPolicy,
-		request.integrity
+		request.integrity,
+		resolveOverride
 	]);
 }
 function createFetchDedupeCandidate(input, init) {
@@ -574,7 +619,7 @@ function createFetchDedupeCandidate(input, init) {
 	if (request.method !== "GET" && request.method !== "HEAD" || request.keepalive) return null;
 	return {
 		url: request.url,
-		key: buildFetchDedupeKey(request)
+		key: buildFetchDedupeKey(request, getResolveOverride(input, init))
 	};
 }
 function buildDedupeClone(body, source) {
@@ -612,7 +657,7 @@ function buildCachedFetchResponse(data, input) {
 	return response;
 }
 function dedupeFetch(input, init) {
-	const state = _getState();
+	const state = getFetchCacheState();
 	if (!state.isFetchDedupeActive) return originalFetch(input, init);
 	const candidate = createFetchDedupeCandidate(input, init);
 	if (!candidate) return originalFetch(input, init);
@@ -661,8 +706,8 @@ function dedupeFetch(input, init) {
 function createPatchedFetch() {
 	const patchedFetch = async function patchedFetch(input, init, span) {
 		const nextOpts = init?.next;
-		const state = _getState();
-		const fetchIdx = isInsideUnifiedScope() || _als.getStore() !== void 0 || _fallbackState.isFetchDedupeActive ? (state.nextFetchId ?? 1) + 1 : void 0;
+		const state = getFetchCacheState();
+		const fetchIdx = isInsideUnifiedScope() || fetchCacheAls.getStore() !== void 0 || fallbackFetchCacheState.isFetchDedupeActive ? (state.nextFetchId ?? 1) + 1 : void 0;
 		if (fetchIdx !== void 0) state.nextFetchId = fetchIdx;
 		const recordFetchOutcome = (response, cacheStatus, cacheReason) => {
 			if (fetchIdx !== void 0) span?.setAttributes({
@@ -695,7 +740,7 @@ function createPatchedFetch() {
 		else if (nextOpts?.revalidate === false) revalidateSeconds = ONE_YEAR_SECONDS;
 		else if (typeof nextOpts?.revalidate === "number" && nextOpts.revalidate > 0) revalidateSeconds = nextOpts.revalidate;
 		else if (tags.length > 0) {
-			const routeRevalidate = _getState().currentFetchRevalidate;
+			const routeRevalidate = getFetchCacheState().currentFetchRevalidate;
 			if (routeRevalidate === 0) {
 				const cleanInit = stripNextFromInit(init, cacheDirective);
 				markUncachedFetchForPageOutput(input);
@@ -713,12 +758,19 @@ function createPatchedFetch() {
 			lowerCurrentFetchRevalidate(nextOpts.revalidate);
 			recordFiniteFetchRevalidate(nextOpts.revalidate);
 		}
-		const reqTags = _getState().currentRequestTags;
+		const reqTags = getFetchCacheState().currentRequestTags;
 		if (tags.length > 0) {
 			for (const tag of tags) if (!reqTags.includes(tag)) reqTags.push(tag);
 		}
-		const softTags = _getState().currentFetchSoftTags;
-		let fetchInit = stripNextFromInit(init, cacheDirective);
+		const softTags = getFetchCacheState().currentFetchSoftTags;
+		let fetchInit;
+		({input, init: fetchInit} = snapshotFetchRequest(input, stripNextFromInit(init, cacheDirective)));
+		const initBody = fetchInit.body;
+		if (initBody !== void 0 && initBody !== null && !isKeyableInitBody(initBody)) {
+			input = new Request(input, fetchInit);
+			builtBodyRequests.add(input);
+			fetchInit = {};
+		}
 		let cacheKey;
 		try {
 			cacheKey = await buildFetchCacheKey(input, fetchInit);
@@ -810,6 +862,7 @@ function stripNextFromInit(init, cacheOverride) {
 	return Object.keys(rest).length > 0 ? rest : void 0;
 }
 const _PATCH_KEY = Symbol.for("vinext.fetchCache.patchInstalled");
+const _g = globalThis;
 function _ensurePatchInstalled() {
 	if (_g[_PATCH_KEY]) return;
 	_g[_PATCH_KEY] = true;
@@ -828,9 +881,9 @@ function _ensurePatchInstalled() {
 */
 function withFetchCache() {
 	_ensurePatchInstalled();
-	_resetFallbackState(true);
+	resetFallbackFetchCacheState(true);
 	return () => {
-		_resetFallbackState(false);
+		resetFallbackFetchCacheState(false);
 	};
 }
 /**
@@ -850,7 +903,7 @@ async function runWithFetchCache(fn) {
 		uCtx.currentFetchDedupeEntries = /* @__PURE__ */ new Map();
 		uCtx.nextFetchId = 1;
 	}, fn);
-	return _als.run({
+	return fetchCacheAls.run({
 		cacheableFetchUrls: /* @__PURE__ */ new Set(),
 		currentRequestTags: [],
 		currentFetchSoftTags: [],
@@ -866,13 +919,13 @@ async function runWithFetchCache(fn) {
 }
 function runWithFetchDedupe(fn) {
 	_ensurePatchInstalled();
-	const state = _getState();
+	const state = getFetchCacheState();
 	if (state.isFetchDedupeActive) return fn();
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
 		uCtx.isFetchDedupeActive = true;
 		uCtx.currentFetchDedupeEntries = /* @__PURE__ */ new Map();
 	}, fn);
-	return _als.run({
+	return fetchCacheAls.run({
 		...state,
 		isFetchDedupeActive: true,
 		currentFetchDedupeEntries: /* @__PURE__ */ new Map()
@@ -897,4 +950,4 @@ function getOriginalFetch() {
 	return originalFetch;
 }
 //#endregion
-export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };
+export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithDetachedFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };

package/dist/shims/form.js

@@ -4,9 +4,9 @@ import { VINEXT_MOUNTED_SLOTS_HEADER } from "../server/app-rsc-vary.js";
 import "../server/headers.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "../server/app-rsc-render-mode.js";
+import { withBasePath } from "./url-utils.js";
 import { AppElementsWire } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
-import { withBasePath } from "./url-utils.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";

package/dist/shims/head.d.ts

@@ -46,13 +46,17 @@ export declare function isSafeAttrName(name: string): boolean;
 export declare function escapeAttr(s: string): string;
 /**
  * Escape content that will be placed inside a raw <script> or <style> tag
- * during SSR. The HTML parser treats `</script>` (or `</style>`) as the end
- * of the block regardless of JavaScript string context, so any occurrence
- * of `</` followed by the tag name must be escaped.
+ * during SSR, so nothing in the content can move where the element ends.
  *
- * We replace `</script` and `</style` (case-insensitive) with `<\/script`
- * and `<\/style` respectively. The `<\/` form is harmless in JS/CSS string
- * context but prevents the HTML parser from seeing a closing tag.
+ * For scripts we mirror React Fizz's escaping of script children: `<script`
+ * and `</script` (case-insensitive) become `<\u0073cript` and `</\u0073cript`
+ * (`\u0053` for an uppercase `S`). The escape is equivalent in JS strings,
+ * regexes, template literals, comments and identifiers. Escaping only the
+ * closing tag is not enough: `<!--<script>` puts the tokenizer in the
+ * double-escaped script state, where the real `</script>` no longer closes it.
+ *
+ * For styles we replace `</style` with `<\/style`, which is harmless in CSS
+ * string context but prevents the HTML parser from seeing a closing tag.
  */
 export declare function escapeInlineContent(content: string, tag: string): string;
 export declare function _applyHeadPropsToElement(domEl: HeadDOMElement, props: Record<string, unknown>): void;

package/dist/shims/head.js

@@ -105,10 +105,8 @@ const SELF_CLOSING_HEAD_TAGS = /* @__PURE__ */ new Set([
 ]);
 /** Tags whose content is raw text — closing-tag sequences must be escaped during SSR. */
 const RAW_CONTENT_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
-const INLINE_CLOSE_TAG_RES = {
-	script: /<\/(script)/gi,
-	style: /<\/(style)/gi
-};
+const INLINE_SCRIPT_TAG_RE = /(<\/|<)(s)(cript)/gi;
+const INLINE_STYLE_CLOSE_TAG_RE = /<\/(style)/gi;
 function warnDisallowedHeadTag(tag) {
 	if (process.env.NODE_ENV !== "production") console.warn(`[vinext] <Head> ignoring disallowed tag <${tag}>. Only ${ALLOWED_HEAD_TAGS_LIST} are allowed.`);
 }
@@ -244,18 +242,22 @@ function escapeAttr(s) {
 }
 /**
 * Escape content that will be placed inside a raw <script> or <style> tag
-* during SSR. The HTML parser treats `<\/script>` (or `</style>`) as the end
-* of the block regardless of JavaScript string context, so any occurrence
-* of `</` followed by the tag name must be escaped.
+* during SSR, so nothing in the content can move where the element ends.
+*
+* For scripts we mirror React Fizz's escaping of script children: `<script`
+* and `<\/script` (case-insensitive) become `<\u0073cript` and `</\u0073cript`
+* (`\u0053` for an uppercase `S`). The escape is equivalent in JS strings,
+* regexes, template literals, comments and identifiers. Escaping only the
+* closing tag is not enough: `<!--<script>` puts the tokenizer in the
+* double-escaped script state, where the real `<\/script>` no longer closes it.
 *
-* We replace `<\/script` and `</style` (case-insensitive) with `<\/script`
-* and `<\/style` respectively. The `<\/` form is harmless in JS/CSS string
-* context but prevents the HTML parser from seeing a closing tag.
+* For styles we replace `</style` with `<\/style`, which is harmless in CSS
+* string context but prevents the HTML parser from seeing a closing tag.
 */
 function escapeInlineContent(content, tag) {
-	const pattern = INLINE_CLOSE_TAG_RES[tag];
-	if (!pattern) return content;
-	return content.replace(pattern, "<\\/$1");
+	if (tag === "script") return content.replace(INLINE_SCRIPT_TAG_RE, (_match, prefix, s, suffix) => `${prefix}${s === "s" ? "\\u0073" : "\\u0053"}${suffix}`);
+	if (tag === "style") return content.replace(INLINE_STYLE_CLOSE_TAG_RE, "<\\/$1");
+	return content;
 }
 function getDangerouslySetInnerHTML(value) {
 	if (typeof value !== "object" || value === null) return void 0;

package/dist/shims/headers.d.ts

@@ -1,4 +1,5 @@
 import { RenderRequestApiKind } from "../server/cache-proof.js";
+import { CacheLifeConfig } from "./cache-request-state.js";
 import { ConnectionProbeResult, HeadersAccessPhase, RenderDynamicLatch, VinextHeadersShimState, createRenderDynamicLatch, getHeadersAccessPhase, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, throwIfInsideCacheScope, throwIfStaticGenerationAccessError } from "./internal/headers-state.js";
 import { ReadonlyRequestCookies } from "@vinext/types/next/upstream/dist/server/web/spec-extension/adapters/request-cookies";
 import { ResponseCookie } from "@vinext/types/next/upstream/dist/compiled/@edge-runtime/cookies/index";
@@ -27,6 +28,18 @@ export declare function runWithIsolatedDynamicUsage<T>(fn: () => T | Promise<T>)
   result: T;
   dynamicDetected: boolean;
 }>;
+/**
+ * Run a pre-render probe without letting its dynamic API usage classify the
+ * request. Next.js has no probe: only the render decides whether a page is
+ * dynamic, and the render runs the probed layouts and page again. Returns the
+ * probe's own usage and cacheLife for a caller whose probe response replaces
+ * the render.
+ */
+export declare function runWithDetachedDynamicUsage<T>(fn: () => T | Promise<T>): Promise<{
+  result: T;
+  dynamicDetected: boolean;
+  cacheLife: CacheLifeConfig | null;
+}>;
 export declare function runWithConnectionProbe<T>(fn: () => T | Promise<T>): Promise<ConnectionProbeResult<T>>;
 export declare function suspendConnectionProbe(): Promise<never> | null;
 export declare function peekRenderRequestApiUsage(): RenderRequestApiKind[];