vinext 1.0.0-beta.8 → 1.0.0

package/dist/shims/font-local.d.ts

@@ -41,16 +41,16 @@ type NextFontWithVariable = Omit<NextFont, "variable"> & {
  * Note: We don't clear the arrays because fonts are loaded at module import
  * time and need to persist across all requests in the Workers environment.
  */
-declare function getSSRFontStyles(): string[];
+export declare function getSSRFontStyles(): string[];
 /**
  * Get collected SSR font preload data (used by the renderer).
  * Returns an array of { href, type } objects for emitting
  * <link rel="preload" as="font" ...> tags.
  */
-declare function getSSRFontPreloads(): Array<{
+export declare function getSSRFontPreloads(): Array<{
   href: string;
   type: string;
 }>;
 declare function localFont<T extends CssVariable | undefined = undefined>(options: LocalFontOptions<T>): T extends undefined ? NextFont : NextFontWithVariable;
 //#endregion
-export { localFont as default, getSSRFontPreloads, getSSRFontStyles };
+export { localFont as default };

package/dist/shims/font-local.js

@@ -1,5 +1,5 @@
-import { fnv1a64 } from "../utils/hash.js";
 import { escapeCSSString, formatFontClassRule, getFontMimeType, resolveSingleFaceStyle, sanitizeCSSVarName, sanitizeFallback, sanitizeFontDescriptorValue } from "./font-utils.js";
+import { fnv1a64 } from "../utils/hash.js";
 //#region src/shims/font-local.ts
 /**
 * next/font/local shim

package/dist/shims/font-utils.d.ts

@@ -1,10 +1,10 @@
 //#region src/shims/font-utils.d.ts
-type FontStyle = {
+export type FontStyle = {
   fontFamily: string;
   fontWeight?: number;
   fontStyle?: string;
 };
-type FontFaceStyleInput = {
+export type FontFaceStyleInput = {
   fontFamily: string;
   weight?: string | string[];
   style?: string | string[];
@@ -20,7 +20,7 @@ type FontFaceStyleInput = {
  *
  * Used by font-google-base.ts, font-local.ts, and fallback-metrics.ts.
  */
-declare function escapeCSSString(value: string): string;
+export declare function escapeCSSString(value: string): string;
 /**
  * Validate a CSS custom property name (e.g. `--font-inter`).
  *
@@ -30,7 +30,7 @@ declare function escapeCSSString(value: string): string;
  *
  * Returns the name if valid, undefined otherwise.
  */
-declare function sanitizeCSSVarName(name: string): string | undefined;
+export declare function sanitizeCSSVarName(name: string): string | undefined;
 /**
  * Sanitize a CSS font-family fallback name.
  *
@@ -38,19 +38,18 @@ declare function sanitizeCSSVarName(name: string): string | undefined;
  * Named families are wrapped in escaped quotes. This prevents injection via
  * crafted fallback values like `); } body { color: red; } .x {`.
  */
-declare function sanitizeFallback(name: string): string;
-declare function singleFontOptionValue(value: string | string[] | undefined): string | undefined;
-declare function sanitizeFontDescriptorValue(value: string): string | undefined;
-declare function resolveFontWeight(weight: string | string[] | undefined): number | undefined;
-declare function resolveFontStyle(style: string | string[] | undefined): string | undefined;
-declare function resolveGoogleFontStyle(style: string | string[] | undefined): string | undefined;
-declare function resolveSingleFaceStyle(input: FontFaceStyleInput): FontStyle;
-declare function formatFontClassRule(className: string, style: FontStyle): string;
+export declare function sanitizeFallback(name: string): string;
+export declare function singleFontOptionValue(value: string | string[] | undefined): string | undefined;
+export declare function sanitizeFontDescriptorValue(value: string): string | undefined;
+export declare function resolveFontWeight(weight: string | string[] | undefined): number | undefined;
+export declare function resolveFontStyle(style: string | string[] | undefined): string | undefined;
+export declare function resolveGoogleFontStyle(style: string | string[] | undefined): string | undefined;
+export declare function resolveSingleFaceStyle(input: FontFaceStyleInput): FontStyle;
+export declare function formatFontClassRule(className: string, style: FontStyle): string;
 /**
  * Determine the MIME type for a font file based on its extension.
  * Uses endsWith() only to avoid false positives from substring matches
  * (e.g. ".woff" matching ".woff2").
  */
-declare function getFontMimeType(pathOrUrl: string): string;
-//#endregion
-export { FontFaceStyleInput, FontStyle, escapeCSSString, formatFontClassRule, getFontMimeType, resolveFontStyle, resolveFontWeight, resolveGoogleFontStyle, resolveSingleFaceStyle, sanitizeCSSVarName, sanitizeFallback, sanitizeFontDescriptorValue, singleFontOptionValue };
+export declare function getFontMimeType(pathOrUrl: string): string;
+//#endregion

package/dist/shims/form.d.ts

@@ -1,7 +1,7 @@
 import { FormHTMLAttributes, useActionState } from "react";
 //#region src/shims/form.d.ts
 type FormSubmitter = HTMLButtonElement | HTMLInputElement;
-declare function createFormSubmitDestinationUrl(action: string, form: HTMLFormElement, submitter: FormSubmitter | null): string;
+export declare function createFormSubmitDestinationUrl(action: string, form: HTMLFormElement, submitter: FormSubmitter | null): string;
 declare const Form: import("react").ForwardRefExoticComponent<{
   /** Target URL for GET forms, or server action for POST forms */
   action: string | ((formData: FormData) => void | Promise<void>);
@@ -20,4 +20,4 @@ declare const Form: import("react").ForwardRefExoticComponent<{
   prefetch?: false | null;
 } & Omit<FormHTMLAttributes<HTMLFormElement>, "encType" | "method" | "target"> & import("react").RefAttributes<HTMLFormElement>>;
 //#endregion
-export { createFormSubmitDestinationUrl, Form as default, useActionState };
+export { Form as default, useActionState };

package/dist/shims/form.js

@@ -1,11 +1,12 @@
 "use client";
-import { VINEXT_MOUNTED_SLOTS_HEADER } from "../server/headers.js";
+import { isBotUserAgent } from "../utils/html-limited-bots.js";
+import { VINEXT_MOUNTED_SLOTS_HEADER } from "../server/app-rsc-vary.js";
+import "../server/headers.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
-import { AppElementsWire } from "../server/app-elements-wire.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "../server/app-rsc-render-mode.js";
+import { AppElementsWire } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
 import { withBasePath } from "./url-utils.js";
-import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { createRscRequestHeaders, createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
 import { hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { getMountedSlotsHeader, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, navigateClientSide, prefetchRscResponse } from "./navigation.js";
@@ -127,9 +128,10 @@ const Form = forwardRef(function Form(props, ref) {
 		delete cleanRest[key];
 	}
 	const formRef = useRef(null);
-	const setRefs = useMergedRef(useCallback((node) => {
+	const setFormRef = useCallback((node) => {
 		formRef.current = node;
-	}, []), ref ?? null);
+	}, []);
+	const setRefs = useMergedRef(setFormRef, ref ?? null);
 	const actionHref = typeof action === "string" ? withBasePath(action, __basePath) : "";
 	useEffect(() => {
 		if (typeof action !== "string") return;
@@ -156,12 +158,13 @@ const Form = forwardRef(function Form(props, ref) {
 					if (prefetched.has(cacheKey)) return;
 					if (hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader)) return;
 					prefetched.add(cacheKey);
-					prefetchRscResponse(rscUrl, fetch(rscUrl, {
+					const fetchPromise = fetch(rscUrl, {
 						headers,
 						credentials: "include",
 						priority: "low",
 						purpose: "prefetch"
-					}), interceptionContext, mountedSlotsHeader, void 0, {
+					});
+					prefetchRscResponse(rscUrl, fetchPromise, interceptionContext, mountedSlotsHeader, void 0, {
 						cacheForNavigation: false,
 						optimisticRouteShell: true
 					});

package/dist/shims/hash-scroll.d.ts

@@ -1,10 +1,9 @@
 //#region src/shims/hash-scroll.d.ts
-declare function decodeHashFragment(fragment: string): string;
-declare function scrollToHashTarget(hash: string): void;
-declare function scrollToHashTargetOnNextFrame(hash: string, shouldScroll?: () => boolean): void;
-declare function retryScrollTo(x: number, y: number, opts?: {
+export declare function decodeHashFragment(fragment: string): string;
+export declare function scrollToHashTarget(hash: string): void;
+export declare function scrollToHashTargetOnNextFrame(hash: string, shouldScroll?: () => boolean): void;
+export declare function retryScrollTo(x: number, y: number, opts?: {
   minFrames?: number;
   shouldContinue?: () => boolean;
 }): void;
-//#endregion
-export { decodeHashFragment, retryScrollTo, scrollToHashTarget, scrollToHashTargetOnNextFrame };
+//#endregion

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,23 +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. */
+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
@@ -74,7 +96,7 @@ declare function consumeRenderRequestApiUsage(): RenderRequestApiKind[];
  *
  * @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
@@ -84,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
@@ -97,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.
@@ -114,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).
@@ -126,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.
  *
@@ -147,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.
  *
@@ -169,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;
@@ -221,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 {
@@ -252,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, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithConnectionProbe, runWithHeadersContext, runWithIsolatedDynamicUsage, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };
+export type { RequestCookies };