vinext 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/shims/slot.js

@@ -1,9 +1,10 @@
 "use client";
-import { AppElementsWire, UNMATCHED_SLOT } from "../server/app-elements-wire.js";
+import { APP_BFCACHE_SEGMENT_IDENTITIES_KEY, AppElementsWire, UNMATCHED_SLOT } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
 import { getBfcacheIdMapContext, getBfcacheSegmentIdContext } from "./navigation-context-state.js";
 import { notFound } from "./navigation-errors.js";
 import "./navigation-server.js";
+import { isNestedBfcacheSlotSegmentId, isNestedBfcacheSlotSegmentIdFor } from "../server/bfcache-identity.js";
 import * as React$1 from "react";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 //#region src/shims/slot.tsx
@@ -23,7 +24,7 @@ const BfcacheSegmentIdContext = getBfcacheSegmentIdContext();
 const EMPTY_BFCACHE_STATE_KEYS = Object.freeze({});
 const MAX_BFCACHE_SLOT_ENTRIES_WITH_CACHE_COMPONENTS = 3;
 const MAX_BFCACHE_SLOT_ENTRIES_WITHOUT_CACHE_COMPONENTS = 1;
-const BfcacheStateKeyMapContext = React$1.createContext(EMPTY_BFCACHE_STATE_KEYS);
+const BfcacheIdentityMapContext = React$1.createContext(EMPTY_BFCACHE_STATE_KEYS);
 function isCacheComponentsEnabled() {
 	return String(process.env.__NEXT_CACHE_COMPONENTS) === "true";
 }
@@ -53,6 +54,17 @@ function haveSameBfcacheSlotEntryOrder(left, right) {
 	for (let index = 0; index < left.length; index++) if (left[index] !== right[index]) return false;
 	return true;
 }
+function stageBfcacheSlotEntryForRender(committedSnapshots, committedOrder, activeEntry, maxEntries = getBfcacheSlotEntryLimit()) {
+	const snapshots = new Map(committedSnapshots);
+	snapshots.set(activeEntry.stateKey, activeEntry);
+	const order = updateBfcacheSlotEntryOrder(committedOrder, activeEntry.stateKey, maxEntries);
+	pruneBfcacheSlotEntrySnapshots(snapshots, order);
+	return {
+		entries: order.map((stateKey) => snapshots.get(stateKey)).filter((entry) => entry !== void 0),
+		order,
+		snapshots
+	};
+}
 function isLayoutFlagsValue(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
 	const entries = Object.values(value);
@@ -72,6 +84,13 @@ function isSlotBindingListValue(value) {
 function isSkippedLayoutIdsMetadataValue(id, value) {
 	return id === "__skippedLayoutIds" && Array.isArray(value) && value.every((entry) => typeof entry === "string");
 }
+function isBfcacheSegmentIdentitiesMetadataValue(id, value) {
+	if (id !== "__bfcacheSegmentIdentities" || typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	return Object.entries(value).every(([elementId, identity]) => {
+		const parsed = AppElementsWire.parseElementKey(elementId);
+		return parsed !== null && parsed.kind !== "route" && typeof identity === "string";
+	});
+}
 function isInterceptionMetadataValue(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
 	return "sourceMatchedUrl" in value && typeof value.sourceMatchedUrl === "string" && "sourceRouteId" in value && typeof value.sourceRouteId === "string" && "slotId" in value && typeof value.slotId === "string" && "targetMatchedUrl" in value && typeof value.targetMatchedUrl === "string" && "targetRouteId" in value && typeof value.targetRouteId === "string";
@@ -81,7 +100,7 @@ function isCacheEntryReuseProofValue(value) {
 	return "kind" in value && value.kind === "runtime-cache-entry" && "decision" in value;
 }
 function isTransportMetadataValue(id, value) {
-	return isLayoutFlagsValue(value) || isArtifactCompatibilityEnvelopeValue(value) || isCacheEntryReuseProofValue(value) || isInterceptionMetadataValue(value) || isSkippedLayoutIdsMetadataValue(id, value) || isSlotBindingListValue(value);
+	return isLayoutFlagsValue(value) || isBfcacheSegmentIdentitiesMetadataValue(id, value) || isArtifactCompatibilityEnvelopeValue(value) || isCacheEntryReuseProofValue(value) || isInterceptionMetadataValue(value) || isSkippedLayoutIdsMetadataValue(id, value) || isSlotBindingListValue(value);
 }
 function warnTransportMetadataEntry(id) {
 	if (process.env.NODE_ENV === "production") return;
@@ -96,7 +115,7 @@ function warnTransportMetadataEntry(id) {
 * capture.
 */
 function BfcacheEntryProviders({ entry, fallbackElements, fallbackSegmentId, fallbackStateKeyMap, SegmentContext }) {
-	return /* @__PURE__ */ jsx(BfcacheStateKeyMapContext.Provider, {
+	return /* @__PURE__ */ jsx(BfcacheIdentityMapContext.Provider, {
 		value: entry.stateKeyMap ?? fallbackStateKeyMap,
 		children: /* @__PURE__ */ jsx(ElementsContext.Provider, {
 			value: entry.elements ?? fallbackElements,
@@ -110,23 +129,26 @@ function BfcacheEntryProviders({ entry, fallbackElements, fallbackSegmentId, fal
 function useBfcacheSlotEntries(activeEntry) {
 	const snapshotsByStateKey = React$1.useRef(/* @__PURE__ */ new Map());
 	const [entryOrder, setEntryOrder] = React$1.useState(() => [activeEntry.stateKey]);
-	snapshotsByStateKey.current.set(activeEntry.stateKey, activeEntry);
-	const nextOrder = updateBfcacheSlotEntryOrder(entryOrder, activeEntry.stateKey);
+	const committedSnapshots = snapshotsByStateKey.current;
+	const staged = stageBfcacheSlotEntryForRender(committedSnapshots, entryOrder, activeEntry);
+	const nextOrder = staged.order;
 	const orderChanged = !haveSameBfcacheSlotEntryOrder(entryOrder, nextOrder);
-	const renderOrder = orderChanged ? nextOrder : entryOrder;
-	pruneBfcacheSlotEntrySnapshots(snapshotsByStateKey.current, renderOrder);
-	if (process.env.NODE_ENV !== "production" && !snapshotsByStateKey.current.has(activeEntry.stateKey)) throw new Error("BFCache Activity slot is missing the active entry snapshot");
+	React$1.useLayoutEffect(() => {
+		snapshotsByStateKey.current = staged.snapshots;
+	}, [staged.snapshots]);
+	if (process.env.NODE_ENV !== "production" && !staged.snapshots.has(activeEntry.stateKey)) throw new Error("BFCache Activity slot is missing the active entry snapshot");
 	if (orderChanged) setEntryOrder(nextOrder);
-	return renderOrder.map((stateKey) => snapshotsByStateKey.current.get(stateKey)).filter((entry) => entry !== void 0);
+	return staged.entries;
 }
 function BfcacheActivitySlotBoundary({ activeStateKey, content, elements, id, SegmentContext, stateKeyMap }) {
-	return /* @__PURE__ */ jsx(Fragment$1, { children: useBfcacheSlotEntries({
+	const renderEntries = useBfcacheSlotEntries({
 		content,
 		elements,
 		segmentId: id,
 		stateKey: activeStateKey,
 		stateKeyMap
-	}).map((entry) => /* @__PURE__ */ jsx(React$1.Activity, {
+	});
+	return /* @__PURE__ */ jsx(Fragment$1, { children: renderEntries.map((entry) => /* @__PURE__ */ jsx(React$1.Activity, {
 		mode: entry.stateKey === activeStateKey ? "visible" : "hidden",
 		children: /* @__PURE__ */ jsx(BfcacheEntryProviders, {
 			entry,
@@ -137,11 +159,42 @@ function BfcacheActivitySlotBoundary({ activeStateKey, content, elements, id, Se
 		})
 	}, entry.stateKey)) });
 }
+/**
+* Adds a nested segment-owned Activity cache inside a flattened AppElements
+* entry. Named parallel routes are transported as one slot value, but Next.js
+* retains each descendant segment independently. This boundary recreates that
+* ownership without requiring a separate wire entry for every nested segment.
+*/
+function BfcacheSegmentBoundary({ children, id, stateKey }) {
+	const elements = React$1.useContext(ElementsContext);
+	const identityMap = React$1.useContext(BfcacheIdentityMapContext);
+	const activeStateKey = resolveBfcacheSegmentStateKey(id, identityMap, React$1.useContext(BfcacheIdMapContext));
+	if (!BfcacheSegmentIdContext || activeStateKey === void 0) return /* @__PURE__ */ jsx(React$1.Fragment, { children }, stateKey);
+	if (!isCacheComponentsEnabled()) return /* @__PURE__ */ jsx(BfcacheSegmentIdContext.Provider, {
+		value: id,
+		children
+	}, activeStateKey);
+	return /* @__PURE__ */ jsx(BfcacheActivitySlotBoundary, {
+		activeStateKey,
+		content: children,
+		elements,
+		id,
+		SegmentContext: BfcacheSegmentIdContext,
+		stateKeyMap: identityMap
+	});
+}
+function getNonCacheComponentsSegmentKey(id, activeStateKey) {
+	const parsed = AppElementsWire.parseElementKey(id);
+	return parsed !== null && parsed.kind !== "route" ? activeStateKey : void 0;
+}
+function resolveBfcacheSegmentStateKey(id, identityMap, bfcacheIdMap) {
+	return identityMap[id] ?? bfcacheIdMap?.[id];
+}
 function BfcacheSlotBoundary({ content, id }) {
 	const SegmentContext = BfcacheSegmentIdContext;
 	const elements = React$1.useContext(ElementsContext);
-	const stateKeyMap = React$1.useContext(BfcacheStateKeyMapContext);
-	const activeStateKey = stateKeyMap[id];
+	const identityMap = React$1.useContext(BfcacheIdentityMapContext);
+	const activeStateKey = resolveBfcacheSegmentStateKey(id, identityMap, React$1.useContext(BfcacheIdMapContext));
 	if (!SegmentContext) return /* @__PURE__ */ jsx(Fragment$1, { children: content });
 	if (activeStateKey === void 0) return /* @__PURE__ */ jsx(SegmentContext.Provider, {
 		value: id,
@@ -150,14 +203,14 @@ function BfcacheSlotBoundary({ content, id }) {
 	if (!isCacheComponentsEnabled()) return /* @__PURE__ */ jsx(SegmentContext.Provider, {
 		value: id,
 		children: content
-	});
+	}, getNonCacheComponentsSegmentKey(id, activeStateKey));
 	return /* @__PURE__ */ jsx(BfcacheActivitySlotBoundary, {
 		activeStateKey,
 		content,
 		elements,
 		id,
 		SegmentContext,
-		stateKeyMap
+		stateKeyMap: identityMap
 	});
 }
 function mergeElements(prev, next, options = {}) {
@@ -166,24 +219,57 @@ function mergeElements(prev, next, options = {}) {
 	const preserveElementIds = typeof options === "boolean" ? [] : options.preserveElementIds ?? [];
 	const preservePreviousSlotIds = typeof options === "boolean" ? [] : options.preservePreviousSlotIds ?? [];
 	const merged = { ...next };
+	const preservedIdentityIds = /* @__PURE__ */ new Set();
 	for (const id of preserveElementIds) if (Object.hasOwn(prev, id)) {
 		const value = prev[id];
-		if (value !== void 0) merged[id] = value;
+		if (value !== void 0) {
+			merged[id] = value;
+			preservedIdentityIds.add(id);
+		}
 	}
-	const slotKeys = new Set([...Object.keys(prev), ...Object.keys(next)].filter((key) => AppElementsWire.isSlotId(key)));
+	const slotKeys = new Set([...Object.keys(prev), ...Object.keys(next)].filter((key) => AppElementsWire.isSlotId(key) && !isNestedBfcacheSlotSegmentId(key)));
 	if (clearAbsentSlots) {
 		for (const key of slotKeys) if (!Object.hasOwn(next, key)) delete merged[key];
 	} else if (preserveAbsentSlots) {
 		for (const key of slotKeys) if (!Object.hasOwn(merged, key) && Object.hasOwn(prev, key)) {
 			const value = prev[key];
-			if (value !== void 0) merged[key] = value;
+			if (value !== void 0) {
+				merged[key] = value;
+				preservedIdentityIds.add(key);
+			}
 		}
 	}
 	for (const id of preservePreviousSlotIds) {
 		if (!AppElementsWire.isSlotId(id)) continue;
 		if (!Object.hasOwn(prev, id)) continue;
 		const value = prev[id];
-		if (value !== void 0 && value !== UNMATCHED_SLOT) merged[id] = value;
+		if (value !== void 0 && value !== UNMATCHED_SLOT) {
+			merged[id] = value;
+			preservedIdentityIds.add(id);
+			for (const nestedId of Object.keys(prev)) {
+				if (!isNestedBfcacheSlotSegmentIdFor(nestedId, id)) continue;
+				const nestedValue = prev[nestedId];
+				if (nestedValue !== void 0) merged[nestedId] = nestedValue;
+				preservedIdentityIds.add(nestedId);
+			}
+		}
+	}
+	if (preservedIdentityIds.size > 0) {
+		const previousIdentityValue = prev[APP_BFCACHE_SEGMENT_IDENTITIES_KEY];
+		const nextIdentityValue = next[APP_BFCACHE_SEGMENT_IDENTITIES_KEY];
+		const hasPreviousIdentities = isBfcacheSegmentIdentitiesMetadataValue(APP_BFCACHE_SEGMENT_IDENTITIES_KEY, previousIdentityValue);
+		const hasNextIdentities = isBfcacheSegmentIdentitiesMetadataValue(APP_BFCACHE_SEGMENT_IDENTITIES_KEY, nextIdentityValue);
+		const previousIdentities = hasPreviousIdentities ? { ...previousIdentityValue } : {};
+		const mergedIdentities = hasNextIdentities ? { ...nextIdentityValue } : {};
+		const identityIds = /* @__PURE__ */ new Set([...Object.keys(previousIdentities), ...Object.keys(mergedIdentities)]);
+		const preservedParentIds = new Set(preservedIdentityIds);
+		for (const parentId of preservedParentIds) for (const identityId of identityIds) if (isNestedBfcacheSlotSegmentIdFor(identityId, parentId)) preservedIdentityIds.add(identityId);
+		for (const id of preservedIdentityIds) {
+			const previousIdentity = previousIdentities[id];
+			if (previousIdentity === void 0) delete mergedIdentities[id];
+			else mergedIdentities[id] = previousIdentity;
+		}
+		if (hasPreviousIdentities || hasNextIdentities) merged[APP_BFCACHE_SEGMENT_IDENTITIES_KEY] = mergedIdentities;
 	}
 	return merged;
 }
@@ -224,4 +310,4 @@ function ParallelSlot({ name }) {
 	return React$1.useContext(ParallelSlotsContext)?.[name] ?? null;
 }
 //#endregion
-export { BfcacheStateKeyMapContext, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, mergeElements, updateBfcacheSlotEntryOrder };
+export { BfcacheIdentityMapContext, BfcacheSegmentBoundary, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, getNonCacheComponentsSegmentKey, mergeElements, resolveBfcacheSegmentStateKey, stageBfcacheSlotEntryForRender, updateBfcacheSlotEntryOrder };

package/dist/shims/streamed-icons.d.ts

@@ -0,0 +1,6 @@
+//#region src/shims/streamed-icons.d.ts
+export declare function reconcileStreamedIcons(metadataKey: string): void;
+export declare function StreamedIconsInsertion({ metadataKey }: {
+  metadataKey: string;
+}): null;
+//#endregion

package/dist/shims/streamed-icons.js

@@ -0,0 +1,33 @@
+"use client";
+import { useLayoutEffect } from "react";
+//#region src/shims/streamed-icons.tsx
+const STREAMED_ICON_ATTRIBUTE = "data-vinext-streamed-icon";
+function getStreamedIconOrder(icon, metadataKey) {
+	const marker = icon.getAttribute(STREAMED_ICON_ATTRIBUTE);
+	const prefix = `${metadataKey}:`;
+	if (!marker?.startsWith(prefix)) return null;
+	const order = Number(marker.slice(prefix.length));
+	return Number.isInteger(order) && order >= 0 ? order : null;
+}
+function reconcileStreamedIcons(metadataKey) {
+	document.querySelectorAll(`body link[${STREAMED_ICON_ATTRIBUTE}]`).forEach((icon) => document.head.appendChild(icon));
+	const ownedIcons = [...document.querySelectorAll(`head link[${STREAMED_ICON_ATTRIBUTE}]`)];
+	const retainedIcons = /* @__PURE__ */ new Map();
+	for (const icon of ownedIcons) {
+		const order = getStreamedIconOrder(icon, metadataKey);
+		if (order === null) {
+			icon.remove();
+			continue;
+		}
+		const previousIcon = retainedIcons.get(order);
+		if (previousIcon) previousIcon.remove();
+		retainedIcons.set(order, icon);
+	}
+	for (const [, icon] of [...retainedIcons].sort(([leftOrder], [rightOrder]) => leftOrder - rightOrder)) document.head.appendChild(icon);
+}
+function StreamedIconsInsertion({ metadataKey }) {
+	useLayoutEffect(() => reconcileStreamedIcons(metadataKey), [metadataKey]);
+	return null;
+}
+//#endregion
+export { StreamedIconsInsertion, reconcileStreamedIcons };

package/dist/shims/thenable-params.d.ts

@@ -1,11 +1,10 @@
 //#region src/shims/thenable-params.d.ts
 declare const WELL_KNOWN_PROPERTIES: readonly ["hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toString", "valueOf", "toLocaleString", "then", "catch", "finally", "status", "value", "error", "displayName", "_debugInfo", "toJSON", "$$typeof", "__esModule", "@@iterator"];
 type WellKnownProperty = (typeof WELL_KNOWN_PROPERTIES)[number];
-type ThenableParams<T extends Record<string, unknown>> = Promise<T> & Omit<T, WellKnownProperty>;
-type ThenableParamsObserver = Readonly<{
+export type ThenableParams<T extends Record<string, unknown>> = Promise<T> & Omit<T, WellKnownProperty>;
+export type ThenableParamsObserver = Readonly<{
   observeParamAccess: (keys: readonly string[]) => void;
   observeReactPromiseStatus?: boolean;
 }>;
-declare function makeThenableParams<T extends Record<string, unknown>>(obj: T, observer?: ThenableParamsObserver): ThenableParams<T>;
-//#endregion
-export { ThenableParams, ThenableParamsObserver, makeThenableParams };
+export declare function makeThenableParams<T extends Record<string, unknown>>(obj: T, observer?: ThenableParamsObserver): ThenableParams<T>;
+//#endregion

package/dist/shims/thenable-params.js

@@ -3,7 +3,7 @@ import { createPprFallbackShellSuspensePromiseForState, getPprFallbackShellState
 function hasParamProperty(obj, prop) {
 	return Object.prototype.hasOwnProperty.call(obj, prop);
 }
-const wellKnownProperties = new Set([
+const wellKnownProperties = /* @__PURE__ */ new Set([
 	"hasOwnProperty",
 	"isPrototypeOf",
 	"propertyIsEnumerable",

package/dist/shims/unified-request-context.d.ts

@@ -1,6 +1,6 @@
-import { RootParamsState } from "./root-params.js";
-import { CacheState } from "./cache-request-state.js";
 import { ExecutionContextLike } from "./request-context.js";
+import { CacheState } from "./cache-request-state.js";
+import { RootParamsState } from "./root-params.js";
 import { FetchCacheState } from "./fetch-cache.js";
 import { VinextHeadersShimState } from "./headers.js";
 import { RouterState } from "./router-state.js";
@@ -8,6 +8,7 @@ import { PrivateCacheState } from "./cache-runtime.js";
 import { HeadState } from "./head-state.js";
 import { I18nState } from "./i18n-state.js";
 import { NavigationState } from "./navigation-state.js";
+import "./request-state-types.js";
 //#region src/shims/unified-request-context.d.ts
 /**
  * Flat union of all per-request state previously spread across
@@ -16,22 +17,80 @@ import { NavigationState } from "./navigation-state.js";
  *
  * Each field group is documented with its source shim module.
  */
-type UnifiedRequestContext = {
-  /** Cloudflare Workers ExecutionContext, or null on Node.js dev. */executionContext: ExecutionContextLike | null; /** Per-request cache for cacheForRequest(). Keyed by factory function reference. */
+export type UnifiedRequestContext = {
+  /** Cloudflare Workers ExecutionContext, or null on Node.js dev. */
+  executionContext: ExecutionContextLike | null;
+  /** Per-request cache for cacheForRequest(). Keyed by factory function reference. */
   requestCache: WeakMap<(...args: any[]) => any, unknown>;
+  /** Shared lifecycle state for work deferred until the response closes. */
+  afterContext: AfterRequestContext;
 } & VinextHeadersShimState & I18nState & NavigationState & CacheState & PrivateCacheState & FetchCacheState & RouterState & HeadState & RootParamsState;
+export type AfterRequestContext = {
+  callbacks: Array<() => unknown>;
+  responseClosed: boolean;
+  pendingCallbacks: number;
+  pendingPromises: number;
+  completion: Promise<void> | null;
+  resolveCompletion: (() => void) | null;
+};
 /**
  * Create a fresh `UnifiedRequestContext` with defaults for all fields.
  * Pass partial overrides for the fields you need to pre-populate.
  */
-declare function createRequestContext(opts?: Partial<UnifiedRequestContext>): UnifiedRequestContext;
+export declare function createRequestContext(opts?: Partial<UnifiedRequestContext>): UnifiedRequestContext;
+/** Queue a callback until response close, or start it immediately once closed. */
+export declare function queueAfterCallback(ctx: UnifiedRequestContext, callback: () => unknown): void;
+/** Track promise-form after() work that can register a callback before settling. */
+export declare function trackAfterPromise<T>(ctx: UnifiedRequestContext, promise: Promise<T>): Promise<T>;
+/** Bind a callback to every AsyncLocalStorage context active at registration. */
+export declare function bindRequestContextSnapshot<T>(ctx: UnifiedRequestContext, callback: () => T): () => T;
+/**
+ * Release function-form `after()` work once the response body has closed.
+ * All queued callbacks start together, matching Next.js' unbounded PromiseQueue.
+ */
+export declare function closeAfterResponse(ctx: UnifiedRequestContext): Promise<void>;
+/**
+ * Whether this request has function-form `after()` work that still needs to
+ * observe the response body closing.
+ *
+ * Promise-form `after(promise)` is included because its continuation can
+ * register a function-form `after()` before the promise settles. Function-form
+ * work needs the body's close observed because its contract is "run once the
+ * response has been sent". `resolveCompletion` stays non-null for as long as
+ * any callback is queued or in flight, so checking it alongside the explicit
+ * counters keeps this correct on re-entry after callbacks have started.
+ */
+export declare function requiresResponseCloseTracking(ctx: UnifiedRequestContext): boolean;
+/**
+ * Mark a response whose body vinext constructed from a fully in-memory string
+ * or byte array, as opposed to a body handed back by user code, which could
+ * still be producing. With no producer left, no `after()` call can originate
+ * from this body — the one signal that makes it safe for
+ * `closeAfterResponseWithBody()` to skip close tracking.
+ *
+ * Not set for a metadata route's `result instanceof Response` passthrough (a
+ * user `icon.tsx`/`opengraph-image.tsx` can return a streaming
+ * `ImageResponse`) or any handler-returned `new Response(stream)` — those
+ * bodies can still be producing and must keep close tracking.
+ */
+export declare function markFullyBufferedBody(response: Response): Response;
+/** Preserve the internal buffered-body signal when response metadata is rebuilt. */
+export declare function preserveFullyBufferedBodyMetadata(source: Response, target: Response): Response;
+/**
+ * Wrap a response so deferred `after()` callbacks start on stream completion
+ * or cancellation. Skipped only when the body is marked fully buffered (see
+ * `markFullyBufferedBody`) and nothing is currently registered — that lets
+ * the runtime send it with an accurate `Content-Length` instead of chunked
+ * transfer encoding.
+ */
+export declare function closeAfterResponseWithBody(response: Response, ctx: UnifiedRequestContext): Response;
 /**
  * Run `fn` within a unified request context scope.
  * All shim modules will read/write their state from `ctx` for the
  * duration of the call, including async continuations.
  */
-declare function runWithRequestContext<T>(ctx: UnifiedRequestContext, fn: () => Promise<T>): Promise<T>;
-declare function runWithRequestContext<T>(ctx: UnifiedRequestContext, fn: () => T | Promise<T>): T | Promise<T>;
+export declare function runWithRequestContext<T>(ctx: UnifiedRequestContext, fn: () => Promise<T>): Promise<T>;
+export declare function runWithRequestContext<T>(ctx: UnifiedRequestContext, fn: () => T | Promise<T>): T | Promise<T>;
 /**
  * Run `fn` in a nested unified scope derived from the current request context.
  * Used by legacy runWith* wrappers to reset or override one sub-state while
@@ -41,8 +100,8 @@ declare function runWithRequestContext<T>(ctx: UnifiedRequestContext, fn: () =>
  *
  * @internal
  */
-declare function runWithUnifiedStateMutation<T>(mutate: (ctx: UnifiedRequestContext) => void, fn: () => Promise<T>): Promise<T>;
-declare function runWithUnifiedStateMutation<T>(mutate: (ctx: UnifiedRequestContext) => void, fn: () => T | Promise<T>): T | Promise<T>;
+export declare function runWithUnifiedStateMutation<T>(mutate: (ctx: UnifiedRequestContext) => void, fn: () => Promise<T>): Promise<T>;
+export declare function runWithUnifiedStateMutation<T>(mutate: (ctx: UnifiedRequestContext) => void, fn: () => T | Promise<T>): T | Promise<T>;
 /**
  * Get the current unified request context.
  * Returns the ALS store when inside a `runWithRequestContext()` scope,
@@ -57,12 +116,11 @@ declare function runWithUnifiedStateMutation<T>(mutate: (ctx: UnifiedRequestCont
  * If called inside a standalone `runWithExecutionContext()` scope, the
  * detached context still reflects that inherited `executionContext`.
  */
-declare function getRequestContext(): UnifiedRequestContext;
+export declare function getRequestContext(): UnifiedRequestContext;
 /**
  * Check whether the current execution is inside a `runWithRequestContext()` scope.
  * Shim modules use this to decide whether to read from the unified store
  * or fall back to their own standalone ALS.
  */
-declare function isInsideUnifiedScope(): boolean;
-//#endregion
-export { UnifiedRequestContext, createRequestContext, getRequestContext, isInsideUnifiedScope, runWithRequestContext, runWithUnifiedStateMutation };
+export declare function isInsideUnifiedScope(): boolean;
+//#endregion

package/dist/shims/unified-request-context.js

@@ -16,6 +16,8 @@ function createRequestContext(opts) {
 	return {
 		headersContext: null,
 		actionRevalidationKind: 0,
+		pendingRevalidatedTags: /* @__PURE__ */ new Set(),
+		pendingRevalidations: /* @__PURE__ */ new Set(),
 		dynamicUsageDetected: false,
 		renderRequestApiUsage: /* @__PURE__ */ new Set(),
 		connectionProbe: null,
@@ -34,6 +36,7 @@ function createRequestContext(opts) {
 		currentRequestTags: [],
 		currentFetchSoftTags: [],
 		currentFetchCacheMode: null,
+		currentFetchRevalidate: null,
 		currentForceDynamicFetchDefault: false,
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
 		refreshStaleFetchesInForeground: false,
@@ -41,6 +44,14 @@ function createRequestContext(opts) {
 		currentFetchDedupeEntries: /* @__PURE__ */ new Map(),
 		executionContext: _getInheritedExecutionContext(),
 		requestCache: /* @__PURE__ */ new WeakMap(),
+		afterContext: {
+			callbacks: [],
+			responseClosed: false,
+			pendingCallbacks: 0,
+			pendingPromises: 0,
+			completion: null,
+			resolveCompletion: null
+		},
 		ssrContext: null,
 		ssrHeadChildren: [],
 		documentInitialHead: [],
@@ -48,6 +59,133 @@ function createRequestContext(opts) {
 		...opts
 	};
 }
+function ensureAfterCompletion(ctx) {
+	const state = ctx.afterContext;
+	if (state.resolveCompletion && state.completion) return;
+	let resolveCompletion;
+	const completion = new Promise((resolve) => {
+		resolveCompletion = resolve;
+	});
+	state.completion = completion;
+	state.resolveCompletion = resolveCompletion;
+	ctx.executionContext?.waitUntil(completion);
+}
+function finishAfterCallbacksIfIdle(ctx) {
+	const state = ctx.afterContext;
+	if (!state.responseClosed || state.pendingCallbacks !== 0 || state.callbacks.length !== 0 || !state.resolveCompletion) return;
+	const resolveCompletion = state.resolveCompletion;
+	state.resolveCompletion = null;
+	resolveCompletion();
+}
+function startAfterCallback(ctx, callback) {
+	const state = ctx.afterContext;
+	ensureAfterCompletion(ctx);
+	state.pendingCallbacks += 1;
+	Promise.resolve().then(callback).catch((error) => {
+		console.error("[vinext] after() task failed:", error);
+	}).finally(() => {
+		state.pendingCallbacks -= 1;
+		finishAfterCallbacksIfIdle(ctx);
+	});
+}
+/** Queue a callback until response close, or start it immediately once closed. */
+function queueAfterCallback(ctx, callback) {
+	ensureAfterCompletion(ctx);
+	if (ctx.afterContext.responseClosed) startAfterCallback(ctx, callback);
+	else ctx.afterContext.callbacks.push(callback);
+}
+/** Track promise-form after() work that can register a callback before settling. */
+function trackAfterPromise(ctx, promise) {
+	ctx.afterContext.pendingPromises += 1;
+	return promise.finally(() => {
+		ctx.afterContext.pendingPromises -= 1;
+	});
+}
+/** Bind a callback to every AsyncLocalStorage context active at registration. */
+function bindRequestContextSnapshot(ctx, callback) {
+	const constructor = _als.constructor;
+	try {
+		const runInSnapshot = constructor.snapshot?.();
+		if (runInSnapshot) return () => runInSnapshot(callback);
+	} catch {}
+	return () => _als.run(ctx, callback);
+}
+/**
+* Release function-form `after()` work once the response body has closed.
+* All queued callbacks start together, matching Next.js' unbounded PromiseQueue.
+*/
+async function closeAfterResponse(ctx) {
+	const state = ctx.afterContext;
+	if (!state.responseClosed) {
+		state.responseClosed = true;
+		const callbacks = state.callbacks.splice(0);
+		for (const callback of callbacks) startAfterCallback(ctx, callback);
+		finishAfterCallbacksIfIdle(ctx);
+	}
+	return state.completion ?? Promise.resolve();
+}
+/**
+* Whether this request has function-form `after()` work that still needs to
+* observe the response body closing.
+*
+* Promise-form `after(promise)` is included because its continuation can
+* register a function-form `after()` before the promise settles. Function-form
+* work needs the body's close observed because its contract is "run once the
+* response has been sent". `resolveCompletion` stays non-null for as long as
+* any callback is queued or in flight, so checking it alongside the explicit
+* counters keeps this correct on re-entry after callbacks have started.
+*/
+function requiresResponseCloseTracking(ctx) {
+	const state = ctx.afterContext;
+	return state.callbacks.length > 0 || state.pendingCallbacks > 0 || state.pendingPromises > 0 || state.resolveCompletion !== null;
+}
+/**
+* Mark a response whose body vinext constructed from a fully in-memory string
+* or byte array, as opposed to a body handed back by user code, which could
+* still be producing. With no producer left, no `after()` call can originate
+* from this body — the one signal that makes it safe for
+* `closeAfterResponseWithBody()` to skip close tracking.
+*
+* Not set for a metadata route's `result instanceof Response` passthrough (a
+* user `icon.tsx`/`opengraph-image.tsx` can return a streaming
+* `ImageResponse`) or any handler-returned `new Response(stream)` — those
+* bodies can still be producing and must keep close tracking.
+*/
+function markFullyBufferedBody(response) {
+	response.__vinextFullyBufferedBody = true;
+	return response;
+}
+function isFullyBufferedBody(response) {
+	return response.__vinextFullyBufferedBody === true;
+}
+/** Preserve the internal buffered-body signal when response metadata is rebuilt. */
+function preserveFullyBufferedBodyMetadata(source, target) {
+	return isFullyBufferedBody(source) ? markFullyBufferedBody(target) : target;
+}
+/**
+* Wrap a response so deferred `after()` callbacks start on stream completion
+* or cancellation. Skipped only when the body is marked fully buffered (see
+* `markFullyBufferedBody`) and nothing is currently registered — that lets
+* the runtime send it with an accurate `Content-Length` instead of chunked
+* transfer encoding.
+*/
+function closeAfterResponseWithBody(response, ctx) {
+	if (!response.body) {
+		queueMicrotask(() => void closeAfterResponse(ctx));
+		return response;
+	}
+	if (isFullyBufferedBody(response) && !requiresResponseCloseTracking(ctx)) return response;
+	const passthrough = new TransformStream();
+	response.body.pipeTo(passthrough.writable).then(() => void closeAfterResponse(ctx), () => void closeAfterResponse(ctx));
+	const wrapped = new Response(passthrough.readable, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+	wrapped.__vinextStreamedHtmlResponse = response.__vinextStreamedHtmlResponse;
+	wrapped.__vinextStreamedApiResponse = response.__vinextStreamedApiResponse;
+	return wrapped;
+}
 function runWithRequestContext(ctx, fn) {
 	return _als.run(ctx, fn);
 }
@@ -84,4 +222,4 @@ function isInsideUnifiedScope() {
 	return _als.getStore() != null;
 }
 //#endregion
-export { createRequestContext, getRequestContext, isInsideUnifiedScope, runWithRequestContext, runWithUnifiedStateMutation };
+export { bindRequestContextSnapshot, closeAfterResponse, closeAfterResponseWithBody, createRequestContext, getRequestContext, isInsideUnifiedScope, markFullyBufferedBody, preserveFullyBufferedBodyMetadata, queueAfterCallback, requiresResponseCloseTracking, runWithRequestContext, runWithUnifiedStateMutation, trackAfterPromise };

package/dist/shims/unrecognized-action-error.d.ts

@@ -20,7 +20,7 @@
  * server-action dispatcher when the server reports the requested action id as
  * unknown (the `x-nextjs-action-not-found` response header).
  */
-declare class UnrecognizedActionError extends Error {
+export declare class UnrecognizedActionError extends Error {
   constructor(...args: ConstructorParameters<typeof Error>);
 }
 /**
@@ -29,6 +29,5 @@ declare class UnrecognizedActionError extends Error {
  * `await myAction(...)` calls; reloading the page generally fixes the
  * underlying client/server deployment mismatch.
  */
-declare function unstable_isUnrecognizedActionError(error: unknown): error is UnrecognizedActionError;
-//#endregion
-export { UnrecognizedActionError, unstable_isUnrecognizedActionError };
+export declare function unstable_isUnrecognizedActionError(error: unknown): error is UnrecognizedActionError;
+//#endregion

package/dist/shims/url-safety.d.ts

@@ -5,8 +5,8 @@
  * Centralizes dangerous URI scheme detection so all components and
  * navigation functions use the same validation logic.
  */
-declare const DANGEROUS_URL_BLOCK_MESSAGE = "Next.js has blocked a javascript: URL as a security precaution.";
-declare function isDangerousScheme(url: string): boolean;
+export declare const DANGEROUS_URL_BLOCK_MESSAGE = "Next.js has blocked a javascript: URL as a security precaution.";
+export declare function isDangerousScheme(url: string): boolean;
 /**
  * Emit a `console.error` matching Next.js's blocked-navigation message.
  *
@@ -28,7 +28,6 @@ declare function isDangerousScheme(url: string): boolean;
  *   packages/next/src/client/components/app-router-instance.ts:345,402,442,460
  *   packages/next/src/shared/lib/router/router.ts:1025,1057
  */
-declare function reportBlockedDangerousNavigation(): void;
-declare function assertSafeNavigationUrl(url: string): void;
-//#endregion
-export { DANGEROUS_URL_BLOCK_MESSAGE, assertSafeNavigationUrl, isDangerousScheme, reportBlockedDangerousNavigation };
+export declare function reportBlockedDangerousNavigation(): void;
+export declare function assertSafeNavigationUrl(url: string, ErrorConstructor?: new (message: string) => Error): void;
+//#endregion

package/dist/shims/url-safety.js

@@ -60,10 +60,10 @@ function isDangerousScheme(url) {
 function reportBlockedDangerousNavigation() {
 	console.error(DANGEROUS_URL_BLOCK_MESSAGE);
 }
-function assertSafeNavigationUrl(url) {
+function assertSafeNavigationUrl(url, ErrorConstructor = Error) {
 	if (isDangerousScheme(url)) {
 		reportBlockedDangerousNavigation();
-		throw new Error(DANGEROUS_URL_BLOCK_MESSAGE);
+		throw new ErrorConstructor(DANGEROUS_URL_BLOCK_MESSAGE);
 	}
 }
 //#endregion