vinext 1.0.0-beta.9 → 1.0.0

package/dist/shims/head-state.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 //#region src/shims/head-state.d.ts
-type HeadState = {
+export type HeadState = {
   ssrHeadChildren: React.ReactNode[];
   documentInitialHead: React.ReactNode[];
 };
@@ -9,7 +9,6 @@ type HeadState = {
  * Ensures per-request isolation for Pages Router <Head> elements
  * on concurrent runtimes.
  */
-declare function runWithHeadState<T>(fn: () => Promise<T>): Promise<T>;
-declare function runWithHeadState<T>(fn: () => T | Promise<T>): T | Promise<T>;
-//#endregion
-export { HeadState, runWithHeadState };
+export declare function runWithHeadState<T>(fn: () => Promise<T>): Promise<T>;
+export declare function runWithHeadState<T>(fn: () => T | Promise<T>): T | Promise<T>;
+//#endregion

package/dist/shims/head.d.ts

@@ -4,19 +4,19 @@ type HeadProps = {
   children?: React.ReactNode;
 };
 /** @internal — exposed for unit tests of the client head projection. */
-declare const _clientHeadChildren: Map<symbol, React.ReactNode>;
+export declare const _clientHeadChildren: Map<symbol, React.ReactNode>;
 /**
  * Register ALS-backed state accessors. Called by head-state.ts on import.
  * @internal
  */
-declare function _registerHeadStateAccessors(accessors: {
+export declare function _registerHeadStateAccessors(accessors: {
   getSSRHeadChildren: () => React.ReactNode[];
   resetSSRHead: () => void;
   getDocumentInitialHead?: () => React.ReactNode[];
   setDocumentInitialHead?: (head: React.ReactNode[]) => void;
 }): void;
 /** Reset the SSR head collector. Call before render. */
-declare function resetSSRHead(): void;
+export declare function resetSSRHead(): void;
 /**
  * Register head tags returned by a user `_document.getInitialProps()` call.
  * Mirrors Next.js: `_document` may extend the head array passed to its render,
@@ -26,7 +26,7 @@ declare function resetSSRHead(): void;
  *
  * Pass an empty array (or simply don't call this) to skip the merge.
  */
-declare function setDocumentInitialHead(head: React.ReactNode[]): void;
+export declare function setDocumentInitialHead(head: React.ReactNode[]): void;
 /**
  * Default head tags emitted alongside every Pages Router render — charset
  * first, then viewport. Mirrors Next.js's `defaultHead()` in
@@ -37,13 +37,13 @@ declare function setDocumentInitialHead(head: React.ReactNode[]): void;
  * then user tags, all with `data-next-head=""`. See assertion in
  * `test/e2e/next-head/index.test.ts`.
  */
-declare function defaultHead(): React.ReactElement[];
+export declare function defaultHead(): React.ReactElement[];
 /** Get collected head HTML. Call after render. */
-declare function getSSRHeadHTML(): string;
+export declare function getSSRHeadHTML(): string;
 type HeadDOMElement = Pick<HTMLElement, "innerHTML" | "setAttribute" | "textContent">;
-declare function reduceHeadChildren(headChildren: React.ReactNode[]): React.ReactElement[];
-declare function isSafeAttrName(name: string): boolean;
-declare function escapeAttr(s: string): string;
+export declare function reduceHeadChildren(headChildren: React.ReactNode[]): React.ReactElement[];
+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
@@ -54,8 +54,8 @@ declare function escapeAttr(s: string): string;
  * and `<\/style` respectively. The `<\/` form is harmless in JS/CSS string
  * context but prevents the HTML parser from seeing a closing tag.
  */
-declare function escapeInlineContent(content: string, tag: string): string;
-declare function _applyHeadPropsToElement(domEl: HeadDOMElement, props: Record<string, unknown>): void;
+export declare function escapeInlineContent(content: string, tag: string): string;
+export declare function _applyHeadPropsToElement(domEl: HeadDOMElement, props: Record<string, unknown>): void;
 /**
  * Compare an existing head element with a newly-created projection.
  *
@@ -66,11 +66,11 @@ declare function _applyHeadPropsToElement(domEl: HeadDOMElement, props: Record<s
  *
  * Ported from Next.js: packages/next/src/client/head-manager.ts.
  */
-declare function isEqualHeadNode(oldTag: Element, newTag: Element): boolean;
+export declare function isEqualHeadNode(oldTag: Element, newTag: Element): boolean;
 /** @internal — register/update one mounted Head instance and batch reconciliation. */
-declare function _updateClientHeadInstance(instanceId: symbol, children: React.ReactNode): void;
+export declare function _updateClientHeadInstance(instanceId: symbol, children: React.ReactNode): void;
 /** @internal — unregister one mounted Head instance and batch reconciliation. */
-declare function _removeClientHeadInstance(instanceId: symbol): void;
+export declare function _removeClientHeadInstance(instanceId: symbol): void;
 /**
  * Reconcile the document <head> against the desired projection.
  *
@@ -90,7 +90,7 @@ declare function _removeClientHeadInstance(instanceId: symbol): void;
  *
  * @internal — exported for unit tests; called from the Head client effect.
  */
-declare function _syncClientHead(): void;
+export declare function _syncClientHead(): void;
 declare function Head({ children }: HeadProps): React.ReactElement;
 //#endregion
-export { _applyHeadPropsToElement, _clientHeadChildren, _registerHeadStateAccessors, _removeClientHeadInstance, _syncClientHead, _updateClientHeadInstance, Head as default, defaultHead, escapeAttr, escapeInlineContent, getSSRHeadHTML, isEqualHeadNode, isSafeAttrName, reduceHeadChildren, resetSSRHead, setDocumentInitialHead };
+export { Head as default };

package/dist/shims/head.js

@@ -75,7 +75,7 @@ function getSSRHeadHTML() {
 		...defaultHead(),
 		..._getSSRHeadChildren(),
 		..._getDocumentInitialHead()
-	]).map((child) => headChildToHTML(child.type, child.props)).filter(Boolean).join("\n  ");
+	]).map((child) => headChildToHTML(child.type, child.props)).filter(Boolean).join("");
 }
 /**
 * Tags allowed inside <head>. Anything else is silently dropped.
@@ -138,8 +138,10 @@ function createUniqueHeadFilter() {
 		let isUnique = true;
 		const normalizedKey = normalizeHeadKey(child.key);
 		const hasKey = normalizedKey !== null;
-		if (normalizedKey) if (keys.has(normalizedKey)) isUnique = false;
-		else keys.add(normalizedKey);
+		if (normalizedKey) {
+			if (keys.has(normalizedKey)) isUnique = false;
+			else keys.add(normalizedKey);
+		}
 		switch (child.type) {
 			case "title":
 			case "base":
@@ -167,7 +169,6 @@ function createUniqueHeadFilter() {
 				}
 				break;
 			}
-			default: break;
 		}
 		return isUnique;
 	};

package/dist/shims/headers.d.ts

@@ -2,7 +2,7 @@ import { RenderRequestApiKind } from "../server/cache-proof.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";
 //#region src/shims/headers.d.ts
-type HeadersContext = {
+export type HeadersContext = {
   headers: Headers;
   cookies: Map<string, string>;
   accessError?: Error;
@@ -16,10 +16,22 @@ type HeadersContext = {
 type HeadersContextFromRequestOptions = {
   draftModeSecret?: string;
 };
-type HeadersAccessPhase = "render" | "action" | "route-handler";
-type VinextHeadersShimState = {
+export type HeadersAccessPhase = "render" | "action" | "route-handler";
+/**
+ * Whether the current render has used a dynamic API. Unlike
+ * `dynamicUsageDetected`, nothing clears it, and one object is shared by every
+ * child scope of the request, so usage inside isolated scopes (such as the
+ * layout probe) stays visible to later readers.
+ */
+export type RenderDynamicLatch = {
+  dynamic: boolean;
+  listeners: Set<() => void>;
+};
+export declare function createRenderDynamicLatch(): RenderDynamicLatch;
+export type VinextHeadersShimState = {
   headersContext: HeadersContext | null;
   dynamicUsageDetected: boolean;
+  renderDynamicLatch: RenderDynamicLatch;
   renderRequestApiUsage: Set<RenderRequestApiKind>;
   connectionProbe: ConnectionProbeState | null;
   /** Error recorded by throwIfInsideCacheScope for dev diagnostics, persists even if caught by user code. */
@@ -50,25 +62,33 @@ type ConnectionProbeResult<T> = {
  * Mark the current render as requiring dynamic (uncached) rendering.
  * Called by connection(), cookies(), headers(), and noStore().
  */
-declare function markDynamicUsage(): void;
+export declare function markDynamicUsage(): void;
+/** Whether the current render has used a dynamic API at any point so far. */
+export declare function isRenderDynamicLatched(): boolean;
+/**
+ * Call `listener` once when the current render first uses a dynamic API.
+ * Returns an unsubscribe function. The listener never runs if the render is
+ * already latched; check `isRenderDynamicLatched()` first.
+ */
+export declare function onRenderDynamicLatched(listener: () => void): () => void;
 /**
  * Measure dynamic usage in a child async scope without clearing the parent.
  * Concurrent work that already belongs to the request (such as deferred
  * metadata) keeps writing to the parent state and therefore remains visible
  * to the final cache policy.
  */
-declare function runWithIsolatedDynamicUsage<T>(fn: () => T | Promise<T>): Promise<{
+export declare function runWithIsolatedDynamicUsage<T>(fn: () => T | Promise<T>): Promise<{
   result: T;
   dynamicDetected: boolean;
 }>;
-declare function markRenderRequestApiUsage(kind: RenderRequestApiKind): void;
-declare function throwIfStaticGenerationAccessError(): void;
-declare function runWithConnectionProbe<T>(fn: () => T | Promise<T>): Promise<ConnectionProbeResult<T>>;
-declare function suspendConnectionProbe(): Promise<never> | null;
-declare function peekRenderRequestApiUsage(): RenderRequestApiKind[];
-declare function consumeRenderRequestApiUsage(): RenderRequestApiKind[];
+export declare function markRenderRequestApiUsage(kind: RenderRequestApiKind): void;
+export declare function throwIfStaticGenerationAccessError(): void;
+export declare function runWithConnectionProbe<T>(fn: () => T | Promise<T>): Promise<ConnectionProbeResult<T>>;
+export declare function suspendConnectionProbe(): Promise<never> | null;
+export declare function peekRenderRequestApiUsage(): RenderRequestApiKind[];
+export declare function consumeRenderRequestApiUsage(): RenderRequestApiKind[];
 /** Whether work is executing inside a cache boundary that owns its reuse. */
-declare function isInsideAnyCacheScope(): boolean;
+export declare function isInsideAnyCacheScope(): boolean;
 /**
  * Throw if the current execution is inside a "use cache" or unstable_cache()
  * scope. Called by dynamic request APIs (headers, cookies, connection) to
@@ -76,7 +96,7 @@ declare function isInsideAnyCacheScope(): boolean;
  *
  * @param apiName - The name of the API being called (e.g. "connection()")
  */
-declare function throwIfInsideCacheScope(apiName: string): void;
+export declare function throwIfInsideCacheScope(apiName: string): void;
 /**
  * Check, consume, and return any invalid dynamic usage error recorded during
  * the render (e.g. cookies() called inside "use cache"). This error persists
@@ -86,12 +106,12 @@ declare function throwIfInsideCacheScope(apiName: string): void;
  * packages/next/src/server/app-render/app-render.tsx
  * https://github.com/vercel/next.js/commit/f5e54c06726b571a042fce67417e40a29f6b8689
  */
-declare function consumeInvalidDynamicUsageError(): unknown;
+export declare function consumeInvalidDynamicUsageError(): unknown;
 /**
  * Check and reset the dynamic usage flag.
  * Called by the server after rendering to decide on caching.
  */
-declare function consumeDynamicUsage(): boolean;
+export declare function consumeDynamicUsage(): boolean;
 /**
  * Read the dynamic usage flag without resetting it.
  * Used by the layout probe to fold a probe-scoped `markDynamicUsage()` into the
@@ -99,9 +119,9 @@ declare function consumeDynamicUsage(): boolean;
  * observation captures `markDynamicUsage()` paths (e.g. `"use cache: private"`)
  * that leave no other observable trace.
  */
-declare function peekDynamicUsage(): boolean;
-declare function setHeadersAccessPhase(phase: HeadersAccessPhase): HeadersAccessPhase;
-declare function getHeadersAccessPhase(): HeadersAccessPhase;
+export declare function peekDynamicUsage(): boolean;
+export declare function setHeadersAccessPhase(phase: HeadersAccessPhase): HeadersAccessPhase;
+export declare function getHeadersAccessPhase(): HeadersAccessPhase;
 /**
  * Set the headers/cookies context for the current RSC render.
  * Called by the framework's RSC entry before rendering each request.
@@ -116,8 +136,22 @@ declare function getHeadersAccessPhase(): HeadersAccessPhase;
  * Used after applyMiddlewareRequestHeaders() to build a post-middleware
  * request context for afterFiles/fallback rewrite has/missing evaluation.
  */
-declare function getHeadersContext(): HeadersContext | null;
-declare function setHeadersContext(ctx: HeadersContext | null): void;
+export declare function getHeadersContext(): HeadersContext | null;
+/** Serialize the effective request-cookie view, including middleware Set-Cookie overlays. */
+export declare function getEffectiveRequestCookieHeader(): string | null;
+export declare function hasEffectiveRequestCookieChanges(cookieHeader: string | null): boolean;
+/**
+ * Replace only the request-cookie view for the active request scope.
+ *
+ * Middleware Set-Cookie mutations are visible through `cookies()` during the
+ * same request in Next.js, but they do not rewrite the raw `Cookie` value
+ * returned by `headers()`. The staged App renderer uses this seam to restore
+ * that split view without changing the request Headers object.
+ */
+export declare function applyEffectiveRequestCookieHeader(cookieHeader: string): void;
+/** Restore a middleware draft-mode transition inside a staged render scope. */
+export declare function restoreDraftModeTransition(cookieHeader: string): void;
+export declare function setHeadersContext(ctx: HeadersContext | null): void;
 /**
  * Run a function with headers context, ensuring the context propagates
  * through all async operations (including RSC streaming).
@@ -128,8 +162,8 @@ declare function setHeadersContext(ctx: HeadersContext | null): void;
  * so RSC streaming works correctly — components that render when the
  * stream is consumed still see the correct request's context.
  */
-declare function runWithHeadersContext<T>(ctx: HeadersContext, fn: () => Promise<T>): Promise<T>;
-declare function runWithHeadersContext<T>(ctx: HeadersContext, fn: () => T | Promise<T>): T | Promise<T>;
+export declare function runWithHeadersContext<T>(ctx: HeadersContext, fn: () => Promise<T>): Promise<T>;
+export declare function runWithHeadersContext<T>(ctx: HeadersContext, fn: () => T | Promise<T>): T | Promise<T>;
 /**
  * Apply middleware-forwarded request headers to the current headers context.
  *
@@ -149,7 +183,7 @@ declare function runWithHeadersContext<T>(ctx: HeadersContext, fn: () => T | Pro
  * from a Server Component would return that stale snapshot instead of the
  * middleware-modified view.
  */
-declare function applyMiddlewareRequestHeaders(middlewareResponseHeaders: Headers): void;
+export declare function applyMiddlewareRequestHeaders(middlewareResponseHeaders: Headers): void;
 /**
  * Create a HeadersContext from a standard Request object.
  *
@@ -171,39 +205,39 @@ declare function applyMiddlewareRequestHeaders(middlewareResponseHeaders: Header
  * Cookie parsing is also deferred: the `cookie` header string is not split
  * until the first call to `cookies()` or `draftMode()`.
  */
-declare function headersContextFromRequest(request: Request, options?: HeadersContextFromRequestOptions): HeadersContext;
+export declare function headersContextFromRequest(request: Request, options?: HeadersContextFromRequestOptions): HeadersContext;
 /**
  * Read-only Headers instance from the incoming request.
  * Returns a Promise in Next.js 15+ style (but resolves synchronously since
  * the context is already available).
  */
-declare function headers(): Promise<Headers> & Headers;
+export declare function headers(): Promise<Headers> & Headers;
 type VinextReadonlyRequestCookies = Omit<ReadonlyRequestCookies, keyof RequestCookies> & RequestCookies;
-declare function cookies(): Promise<VinextReadonlyRequestCookies> & VinextReadonlyRequestCookies;
+export declare function cookies(): Promise<VinextReadonlyRequestCookies> & VinextReadonlyRequestCookies;
 /** Accumulated Set-Cookie headers from cookies().set() / .delete() calls */
 /**
  * Get and clear all pending Set-Cookie headers generated by cookies().set()/delete().
  * Called by the framework after rendering to attach headers to the response.
  */
-declare function getAndClearPendingCookies(): string[];
+export declare function getAndClearPendingCookies(): string[];
 /**
  * Get any Set-Cookie header generated by draftMode().enable()/disable().
  * Called by the framework after rendering to attach the header to the response.
  */
-declare function getDraftModeCookieHeader(): string | null;
-declare function isDraftModeRequest(request: Request, draftModeSecret: string): boolean;
+export declare function getDraftModeCookieHeader(): string | null;
+export declare function isDraftModeRequest(request: Request, draftModeSecret: string): boolean;
 /**
  * Read draft mode from the live request context without recording request API
  * usage. `null` means there is no active request context, which lets framework
  * callers fall back to an explicitly supplied request when needed.
  */
-declare function getActiveDraftModeState(): boolean | null;
+export declare function getActiveDraftModeState(): boolean | null;
 /**
  * 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;
+export declare function isDraftModeEnabled(): boolean;
 type DraftModeResult = {
   readonly isEnabled: boolean;
   enable(): void;
@@ -223,7 +257,7 @@ type DraftModeResult = {
  * Ported from Next.js: packages/next/src/server/request/draft-mode.ts
  * (`getDraftModeProviderForCacheScope` + `trackDynamicDraftMode`).
  */
-declare function draftMode(): Promise<DraftModeResult>;
+export declare function draftMode(): Promise<DraftModeResult>;
 declare const APPLY_RESPONSE_COOKIE: unique symbol;
 declare const SYNCHRONIZE_REQUEST_COOKIES: unique symbol;
 declare class RequestCookies {
@@ -254,4 +288,4 @@ declare class RequestCookies {
   [SYNCHRONIZE_REQUEST_COOKIES](): void;
 }
 //#endregion
-export { HeadersAccessPhase, HeadersContext, type RequestCookies, VinextHeadersShimState, applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, draftMode, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersAccessPhase, getHeadersContext, headers, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, isInsideAnyCacheScope, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithConnectionProbe, runWithHeadersContext, runWithIsolatedDynamicUsage, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };
+export type { RequestCookies };

package/dist/shims/headers.js

@@ -1,9 +1,9 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
-import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
-import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
+import { ensureRenderDynamicLatch, getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.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 { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
+import { FLIGHT_HEADERS, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER } from "../server/headers.js";
 import { serializeSetCookie, validateCookieName } from "./internal/cookie-serialize.js";
 import { createPprFallbackShellSuspensePromise } from "./ppr-fallback-shell.js";
 //#region src/shims/headers.ts
@@ -16,12 +16,19 @@ import { createPprFallbackShellSuspensePromise } from "./ppr-fallback-shell.js";
 * In Next.js 15+, cookies() and headers() return Promises (async).
 * We support both the sync (legacy) and async patterns.
 */
+function createRenderDynamicLatch() {
+	return {
+		dynamic: false,
+		listeners: /* @__PURE__ */ new Set()
+	};
+}
 const _FALLBACK_KEY = Symbol.for("vinext.nextHeadersShim.fallback");
 const _g = globalThis;
 const _als = getOrCreateAls("vinext.nextHeadersShim.als");
 const _fallbackState = _g[_FALLBACK_KEY] ??= {
 	headersContext: null,
 	dynamicUsageDetected: false,
+	renderDynamicLatch: createRenderDynamicLatch(),
 	renderRequestApiUsage: /* @__PURE__ */ new Set(),
 	connectionProbe: null,
 	invalidDynamicUsageError: null,
@@ -113,9 +120,40 @@ function markDynamicUsage() {
 	const state = _getState();
 	if (state.headersContext?.forceStatic) return;
 	state.dynamicUsageDetected = true;
+	const latches = [ensureRenderDynamicLatch(state)];
 	forEachConnectionProbeTarget(state, (target) => {
 		target.dynamicUsageDetected = true;
+		latches.push(ensureRenderDynamicLatch(target));
 	});
+	for (const latch of latches) latchRenderDynamic(latch);
+}
+function latchRenderDynamic(latch) {
+	if (latch.dynamic) return;
+	latch.dynamic = true;
+	const listeners = [...latch.listeners];
+	latch.listeners.clear();
+	for (const listener of listeners) try {
+		listener();
+	} catch (error) {
+		console.error(error);
+	}
+}
+/** Whether the current render has used a dynamic API at any point so far. */
+function isRenderDynamicLatched() {
+	return ensureRenderDynamicLatch(_getState()).dynamic;
+}
+/**
+* Call `listener` once when the current render first uses a dynamic API.
+* Returns an unsubscribe function. The listener never runs if the render is
+* already latched; check `isRenderDynamicLatched()` first.
+*/
+function onRenderDynamicLatched(listener) {
+	const latch = ensureRenderDynamicLatch(_getState());
+	if (latch.dynamic) return () => {};
+	latch.listeners.add(listener);
+	return () => {
+		latch.listeners.delete(listener);
+	};
 }
 function forEachConnectionProbeTarget(state, visit) {
 	let target = state.connectionProbe?.dynamicUsageTarget ?? null;
@@ -154,8 +192,10 @@ async function runWithIsolatedDynamicUsage(fn) {
 			return runInChildState(childState);
 		});
 	}
+	const parentState = _getState();
 	const childState = {
-		..._getState(),
+		...parentState,
+		renderDynamicLatch: ensureRenderDynamicLatch(parentState),
 		dynamicUsageDetected: false
 	};
 	return await _als.run(childState, () => runInChildState(childState));
@@ -211,6 +251,7 @@ async function runWithConnectionProbe(fn) {
 	}
 	const childState = {
 		...parentState,
+		renderDynamicLatch: ensureRenderDynamicLatch(parentState),
 		connectionProbe: probe
 	};
 	return await _als.run(childState, () => runInChildState(childState));
@@ -354,11 +395,54 @@ function getHeadersAccessPhase() {
 function getHeadersContext() {
 	return _getState().headersContext;
 }
+/** Serialize the effective request-cookie view, including middleware Set-Cookie overlays. */
+function getEffectiveRequestCookieHeader() {
+	const context = getHeadersContext();
+	if (!context || context.cookies.size === 0) return null;
+	return [...context.cookies].map(([name, value]) => `${name}=${encodeURIComponent(value)}`).join("; ");
+}
+function hasEffectiveRequestCookieChanges(cookieHeader) {
+	const effective = getHeadersContext()?.cookies;
+	if (!effective) return false;
+	const original = parseEdgeRequestCookieHeader(cookieHeader ?? "");
+	if (effective.size !== original.size) return true;
+	for (const [name, value] of effective) if (original.get(name) !== value) return true;
+	return false;
+}
+/**
+* Replace only the request-cookie view for the active request scope.
+*
+* Middleware Set-Cookie mutations are visible through `cookies()` during the
+* same request in Next.js, but they do not rewrite the raw `Cookie` value
+* returned by `headers()`. The staged App renderer uses this seam to restore
+* that split view without changing the request Headers object.
+*/
+function applyEffectiveRequestCookieHeader(cookieHeader) {
+	const context = _getState().headersContext;
+	if (!context) return;
+	rebuildCookiesFromHeader(context, cookieHeader);
+	context.readonlyCookies = void 0;
+	context.mutableCookies = void 0;
+}
+/** Restore a middleware draft-mode transition inside a staged render scope. */
+function restoreDraftModeTransition(cookieHeader) {
+	const state = _getState();
+	const context = state.headersContext;
+	if (!context) return;
+	const entry = setCookieNameValue(cookieHeader);
+	if (!entry || entry.name !== DRAFT_MODE_COOKIE) return;
+	context.cookies.set(entry.name, entry.value);
+	context.readonlyCookies = void 0;
+	context.mutableCookies = void 0;
+	context.draftModeEnabled = entry.value === validateDraftModeSecret(context.draftModeSecret ?? "");
+	state.draftModeCookieHeader = cookieHeader;
+}
 function setHeadersContext(ctx) {
 	const state = _getState();
 	if (ctx !== null) {
 		state.headersContext = ctx;
 		state.dynamicUsageDetected = false;
+		state.renderDynamicLatch = createRenderDynamicLatch();
 		state.renderRequestApiUsage = /* @__PURE__ */ new Set();
 		state.pendingSetCookies = [];
 		state.draftModeCookieHeader = null;
@@ -372,6 +456,7 @@ function runWithHeadersContext(ctx, fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
 		uCtx.headersContext = ctx;
 		uCtx.dynamicUsageDetected = false;
+		uCtx.renderDynamicLatch = createRenderDynamicLatch();
 		uCtx.renderRequestApiUsage = /* @__PURE__ */ new Set();
 		uCtx.connectionProbe = null;
 		uCtx.pendingSetCookies = [];
@@ -381,6 +466,7 @@ function runWithHeadersContext(ctx, fn) {
 	const state = {
 		headersContext: ctx,
 		dynamicUsageDetected: false,
+		renderDynamicLatch: createRenderDynamicLatch(),
 		renderRequestApiUsage: /* @__PURE__ */ new Set(),
 		connectionProbe: null,
 		invalidDynamicUsageError: null,
@@ -590,7 +676,8 @@ function headersContextFromRequest(request, options) {
 	let _cookies = null;
 	function getCookies() {
 		if (_cookies) return _cookies;
-		_cookies = parseEdgeRequestCookieHeader(headersProxy.get("cookie") || "");
+		const cookieHeader = headersProxy.get("cookie") || "";
+		_cookies = parseEdgeRequestCookieHeader(cookieHeader);
 		return _cookies;
 	}
 	return {
@@ -891,4 +978,4 @@ function serializeMutableCookie(cookie) {
 	});
 }
 //#endregion
-export { applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, draftMode, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersAccessPhase, getHeadersContext, headers, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, isInsideAnyCacheScope, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithConnectionProbe, runWithHeadersContext, runWithIsolatedDynamicUsage, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };
+export { applyEffectiveRequestCookieHeader, applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, createRenderDynamicLatch, draftMode, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, getEffectiveRequestCookieHeader, getHeadersAccessPhase, getHeadersContext, hasEffectiveRequestCookieChanges, headers, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, peekDynamicUsage, peekRenderRequestApiUsage, restoreDraftModeTransition, runWithConnectionProbe, runWithHeadersContext, runWithIsolatedDynamicUsage, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };

package/dist/shims/i18n-context.d.ts

@@ -1,6 +1,6 @@
 import { DomainLocale } from "../utils/domain-locale.js";
 //#region src/shims/i18n-context.d.ts
-type I18nContext = {
+export type I18nContext = {
   locale?: string;
   locales?: string[];
   defaultLocale?: string;
@@ -11,11 +11,10 @@ type I18nContext = {
  * Register ALS-backed accessors. Called by i18n-state.ts on import.
  * @internal
  */
-declare function _registerI18nStateAccessors(accessors: {
+export declare function _registerI18nStateAccessors(accessors: {
   getI18nContext: () => I18nContext | null;
   setI18nContext: (ctx: I18nContext | null) => void;
 }): void;
-declare function getI18nContext(): I18nContext | null;
-declare function setI18nContext(ctx: I18nContext | null): void;
-//#endregion
-export { I18nContext, _registerI18nStateAccessors, getI18nContext, setI18nContext };
+export declare function getI18nContext(): I18nContext | null;
+export declare function setI18nContext(ctx: I18nContext | null): void;
+//#endregion

package/dist/shims/i18n-state.d.ts

@@ -1,13 +1,12 @@
 import { I18nContext } from "./i18n-context.js";
 //#region src/shims/i18n-state.d.ts
-type I18nState = {
+export type I18nState = {
   i18nContext: I18nContext | null;
 };
 /**
  * Run a function within an i18n state ALS scope.
  * Ensures per-request isolation for i18n context on concurrent runtimes.
  */
-declare function runWithI18nState<T>(fn: () => Promise<T>): Promise<T>;
-declare function runWithI18nState<T>(fn: () => T | Promise<T>): T | Promise<T>;
-//#endregion
-export { I18nState, runWithI18nState };
+export declare function runWithI18nState<T>(fn: () => Promise<T>): Promise<T>;
+export declare function runWithI18nState<T>(fn: () => T | Promise<T>): T | Promise<T>;
+//#endregion

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

@@ -12,7 +12,7 @@
  * - `**` matches any number of segments
  * - protocol, port, and search are matched exactly when specified
  */
-type RemotePattern = {
+export type RemotePattern = {
   protocol?: string;
   hostname: string;
   port?: string;
@@ -23,11 +23,11 @@ type RemotePattern = {
  * Check whether a URL matches a single remote pattern.
  * Follows the same semantics as Next.js's matchRemotePattern().
  */
-declare function matchRemotePattern(pattern: RemotePattern, url: URL): boolean;
+export declare function matchRemotePattern(pattern: RemotePattern, url: URL): boolean;
 /**
  * Check whether a URL matches any configured remote pattern or legacy domain.
  */
-declare function hasRemoteMatch(domains: string[], remotePatterns: RemotePattern[], url: URL): boolean;
+export declare function hasRemoteMatch(domains: string[], remotePatterns: RemotePattern[], url: URL): boolean;
 /**
  * Determine whether a string is a private (non-routable) IP address.
  * Works for IPv4 and IPv6, including bracketed and IPv4-mapped forms.
@@ -40,6 +40,5 @@ declare function hasRemoteMatch(domains: string[], remotePatterns: RemotePattern
  *
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/is-private-ip.ts
  */
-declare function isPrivateIp(ip: string): boolean;
-//#endregion
-export { RemotePattern, hasRemoteMatch, isPrivateIp, matchRemotePattern };
+export declare function isPrivateIp(ip: string): boolean;
+//#endregion

package/dist/shims/image-config.js

@@ -59,6 +59,7 @@ function matchRemotePattern(pattern, url) {
 function hasRemoteMatch(domains, remotePatterns, url) {
 	return domains.some((domain) => url.hostname === domain) || remotePatterns.some((p) => matchRemotePattern(p, url));
 }
+const IPV4_LITERAL_CHARS_RE = /^[0-9a-fA-FxX.]+$/;
 /**
 * Determine whether a string is a private (non-routable) IP address.
 * Works for IPv4 and IPv6, including bracketed and IPv4-mapped forms.
@@ -73,6 +74,7 @@ function hasRemoteMatch(domains, remotePatterns, url) {
 */
 function isPrivateIp(ip) {
 	if (ip.startsWith("[") && ip.endsWith("]")) ip = ip.slice(1, -1);
+	if (!ip.includes(":") && !IPV4_LITERAL_CHARS_RE.test(ip)) return false;
 	try {
 		const parsed = ipaddr.parse(ip);
 		if (parsed instanceof ipaddr.IPv6 && parsed.isIPv4MappedAddress()) return parsed.toIPv4Address().range() !== "unicast";

package/dist/shims/image.d.ts

@@ -1,8 +1,8 @@
 import React from "react";
 import { ImageLoader, ImageProps as ImageProps$1, ImgProps, StaticImageData, StaticImport, StaticRequire } from "@vinext/types/next/upstream/dist/shared/lib/get-img-props";
 //#region src/shims/image.d.ts
-type ImageLoaderProps = Parameters<ImageLoader>[0];
-type ImageProps = ImageProps$1;
+export type ImageLoaderProps = Parameters<ImageLoader>[0];
+export type ImageProps = ImageProps$1;
 /**
  * Build a `/_next/image` optimization URL.
  *
@@ -10,7 +10,7 @@ type ImageProps = ImageProps$1;
  * the Images binding to resize/transcode on the fly. In dev, the Vite dev
  * server handles it as a passthrough (serves the original file).
  */
-declare function imageOptimizationUrl(src: string, width: number, quality?: number): string;
+export declare function imageOptimizationUrl(src: string, width: number, quality?: number): string;
 declare const Image: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "alt" | "height" | "loading" | "ref" | "src" | "srcSet" | "width"> & {
   src: string | StaticImport;
   alt: string;
@@ -37,8 +37,8 @@ declare const Image: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProp
  * getImageProps — for advanced use cases (picture elements, background images).
  * Returns the props that would be passed to the underlying <img> element.
  */
-declare function getImageProps(props: ImageProps): {
+export declare function getImageProps(props: ImageProps): {
   props: ImgProps;
 };
 //#endregion
-export { type ImageLoader, ImageLoaderProps, ImageProps, type StaticImageData, type StaticRequire, Image as default, getImageProps, imageOptimizationUrl };
+export { type ImageLoader, type StaticImageData, type StaticRequire, Image as default };