vinext 1.0.0-beta.9 → 1.0.0

package/dist/server/app-page-tracing.d.ts

@@ -0,0 +1,33 @@
+import { FrameworkSpan } from "./framework-tracer.js";
+//#region src/server/app-page-tracing.d.ts
+export declare function traceAppPageRender<T>(routePattern: string, operation: "prerender" | "render", callback: (span: FrameworkSpan) => T): T;
+export declare function createAppPageRenderSpanDescriptor(routePattern: string, operation: "prerender" | "render"): {
+  readonly attributes: {
+    readonly "next.route": string;
+  };
+  readonly name: `prerender route (app) ${string}` | `render route (app) ${string}`;
+  readonly type: "AppRender.getBodyResult";
+};
+export declare function createGetLayoutOrPageModuleSpanDescriptor(segment: string): {
+  readonly attributes: {
+    readonly "next.segment": string;
+  };
+  readonly name: "resolve segment modules";
+  readonly type: "NextNodeServer.getLayoutOrPageModule";
+};
+export declare function createComponentTreeSpanDescriptor(): {
+  readonly name: "build component tree";
+  readonly type: "NextNodeServer.createComponentTree";
+};
+export declare function traceCreateComponentTree<T>(callback: () => T): T;
+export declare function traceGetLayoutOrPageModule<T>(segment: string, callback: () => T): T;
+export declare function resolveAppPageModuleTraceSegment(routeSegments: readonly string[], treePosition: number): string;
+export declare function recordAppPageRenderError(span: FrameworkSpan, error: unknown): void;
+export declare function resolveAppPageTraceOperation(options: {
+  hasRequestSearchParams: boolean;
+  isDynamicError: boolean;
+  isForceStatic: boolean;
+  isKnownPrerenderedRoute: boolean;
+  isPrerender: boolean;
+}): "prerender" | "render";
+//#endregion

package/dist/server/app-page-tracing.js

@@ -0,0 +1,49 @@
+import { patternToNextFormat } from "../routing/route-validation.js";
+import { recordFrameworkSpanError } from "./framework-tracer.js";
+import { frameworkTracer } from "./tracer.js";
+import { getDigestForWellKnownError, isAppRenderAbortError } from "./app-rsc-errors.js";
+//#region src/server/app-page-tracing.ts
+function traceAppPageRender(routePattern, operation, callback) {
+	return frameworkTracer.trace(createAppPageRenderSpanDescriptor(routePattern, operation), callback);
+}
+function createAppPageRenderSpanDescriptor(routePattern, operation) {
+	const route = patternToNextFormat(routePattern);
+	return {
+		attributes: { "next.route": route },
+		name: `${operation} route (app) ${route}`,
+		type: "AppRender.getBodyResult"
+	};
+}
+function createGetLayoutOrPageModuleSpanDescriptor(segment) {
+	return {
+		attributes: { "next.segment": segment },
+		name: "resolve segment modules",
+		type: "NextNodeServer.getLayoutOrPageModule"
+	};
+}
+function createComponentTreeSpanDescriptor() {
+	return {
+		name: "build component tree",
+		type: "NextNodeServer.createComponentTree"
+	};
+}
+function traceCreateComponentTree(callback) {
+	return frameworkTracer.trace(createComponentTreeSpanDescriptor(), callback);
+}
+function traceGetLayoutOrPageModule(segment, callback) {
+	return frameworkTracer.trace(createGetLayoutOrPageModuleSpanDescriptor(segment), callback);
+}
+function resolveAppPageModuleTraceSegment(routeSegments, treePosition) {
+	return treePosition === 0 ? "" : routeSegments[treePosition - 1] ?? "";
+}
+function recordAppPageRenderError(span, error) {
+	if (isAppRenderAbortError(error) || getDigestForWellKnownError(error) !== void 0) return;
+	recordFrameworkSpanError(span, error);
+}
+function resolveAppPageTraceOperation(options) {
+	if (options.isPrerender || options.isForceStatic || options.isDynamicError) return "prerender";
+	if (options.hasRequestSearchParams) return "render";
+	return options.isKnownPrerenderedRoute ? "prerender" : "render";
+}
+//#endregion
+export { createAppPageRenderSpanDescriptor, createComponentTreeSpanDescriptor, createGetLayoutOrPageModuleSpanDescriptor, recordAppPageRenderError, resolveAppPageModuleTraceSegment, resolveAppPageTraceOperation, traceAppPageRender, traceCreateComponentTree, traceGetLayoutOrPageModule };

package/dist/server/app-pages-bridge.d.ts

@@ -1,13 +1,13 @@
 import { AppMiddlewareContext } from "./app-middleware.js";
 import { EdgeApiExecutionRuntime } from "./edge-api-runtime.js";
 //#region src/server/app-pages-bridge.d.ts
-type PagesEntry = {
-  handleApiRoute?: (request: Request, url: string, ctx: unknown, trustedRevalidateOrigin: string | undefined, edgeRuntime: EdgeApiExecutionRuntime) => Promise<Response> | Response;
+export type PagesEntry = {
+  handleApiRoute?: (request: Request, url: string, ctx: unknown, trustedRevalidateOrigin: string | undefined, edgeRuntime: EdgeApiExecutionRuntime, initialResponseHeaders?: Headers) => Promise<Response> | Response;
   matchApiRoute?: (url: string, request: Request) => PagesRouteMatch | null;
   matchPageRoute?: (url: string, request: Request) => PagesRouteMatch | null;
   renderPage?: (request: Request, url: string, query: Record<string, unknown>, parsedUrl: unknown, middlewareRequestHeaders?: Headers | null, options?: {
     isDataReq?: boolean;
-  }) => Promise<Response> | Response;
+  }, initialResponseHeaders?: Headers) => Promise<Response> | Response;
 };
 type PagesRouteMatch = {
   route: {
@@ -48,6 +48,7 @@ type RenderPagesFallbackOptions = {
   appRouteMatch?: AppRouteMatch | null;
   isDataRequest?: boolean;
   isRscRequest: boolean;
+  initialResponseHeaders?: Headers;
   matchKind?: "dynamic" | "static";
   middlewareContext: AppMiddlewareContext;
   pathname?: string;
@@ -58,6 +59,5 @@ type RenderPagesFallbackOptions = {
 /**
  * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
  */
-declare function renderPagesFallback(options: RenderPagesFallbackOptions, dependencies: RenderPagesFallbackDependencies): Promise<Response | null>;
-//#endregion
-export { PagesEntry, renderPagesFallback };
+export declare function renderPagesFallback(options: RenderPagesFallbackOptions, dependencies: RenderPagesFallbackDependencies): Promise<Response | null>;
+//#endregion

package/dist/server/app-pages-bridge.js

@@ -18,7 +18,7 @@ function applyPagesMiddlewareContext(response, middlewareContext) {
 * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
 */
 async function renderPagesFallback(options, dependencies) {
-	const { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, url } = options;
+	const { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, initialResponseHeaders, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, url } = options;
 	const { loadPagesEntry, buildRequestHeaders, decodePathParams, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
 	if (isRscRequest && !allowRscDocumentFallback) return null;
 	const pagesEntry = await loadPagesEntry();
@@ -40,7 +40,14 @@ async function renderPagesFallback(options, dependencies) {
 			if (apiMatch === null || !pagesRouteHasPriorityOverAppRoute(apiMatch.route, appRouteMatch.route)) return null;
 		}
 		const executionContext = getRequestExecutionContext();
-		const pagesApiResponse = await pagesEntry.handleApiRoute(pagesRequest, pagesUrl, void 0, executionContext?.trustedRevalidateOrigin ?? new URL(pagesRequest.url).origin, executionContext?.hostRuntime ?? "node");
+		const apiArgs = [
+			pagesRequest,
+			pagesUrl,
+			void 0,
+			executionContext?.trustedRevalidateOrigin ?? new URL(pagesRequest.url).origin,
+			executionContext?.hostRuntime ?? "node"
+		];
+		const pagesApiResponse = await (initialResponseHeaders ? pagesEntry.handleApiRoute(...apiArgs, initialResponseHeaders) : pagesEntry.handleApiRoute(...apiArgs));
 		const draftCookie = getDraftModeCookieHeader();
 		return applyDraftModeCookie(applyRouteHandlerMiddlewareContext(pagesApiResponse, middlewareContext), draftCookie);
 	}
@@ -52,8 +59,14 @@ async function renderPagesFallback(options, dependencies) {
 	if (pageMatch !== null && matchKind === "dynamic" && !pageMatch.route.isDynamic) return null;
 	if (appRouteMatch !== null && (pageMatch === null || !pagesRouteHasPriorityOverAppRoute(pageMatch.route, appRouteMatch.route))) return null;
 	if (pageMatch !== null) beginRouteCacheability("pages-page", pageMatch.route.pattern);
-	const renderRequest = pagesDataRequest ? cloneRequestWithUrl(pagesRequest, pagesDataRequest.url) : pagesRequest;
-	const pagesRes = isDataRequest ? await pagesEntry.renderPage(renderRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders, { isDataReq: true }) : await pagesEntry.renderPage(renderRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders);
+	const renderArgs = [
+		pagesDataRequest ? cloneRequestWithUrl(pagesRequest, pagesDataRequest.url) : pagesRequest,
+		pagesUrl,
+		{},
+		void 0,
+		middlewareContext.requestHeaders
+	];
+	const pagesRes = isDataRequest ? await (initialResponseHeaders ? pagesEntry.renderPage(...renderArgs, { isDataReq: true }, initialResponseHeaders) : pagesEntry.renderPage(...renderArgs, { isDataReq: true })) : await (initialResponseHeaders ? pagesEntry.renderPage(...renderArgs, void 0, initialResponseHeaders) : pagesEntry.renderPage(...renderArgs));
 	if (pagesRes.status === 404 && pageMatch === null) return null;
 	return applyDraftModeCookie(applyPagesMiddlewareContext(pagesRes, middlewareContext), getDraftModeCookieHeader());
 }

package/dist/server/app-post-middleware-context.d.ts

@@ -9,6 +9,5 @@ import { RequestContext } from "../config/request-context.js";
  * Falls back to `requestContextFromRequest(request)` when no HeadersContext
  * is set (no middleware ran, or middleware didn't set request headers).
  */
-declare function buildPostMwRequestContext(request: Request): RequestContext;
-//#endregion
-export { buildPostMwRequestContext };
+export declare function buildPostMwRequestContext(request: Request): RequestContext;
+//#endregion

package/dist/server/app-ppr-fallback-shell-render.d.ts

@@ -3,7 +3,7 @@ import { ReactNode } from "react";
 //#region src/server/app-ppr-fallback-shell-render.d.ts
 type AppPageBoundaryOnError = (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
 type AppPageRenderableElement = ReactNode | Record<string, ReactNode>;
-type WarmPprFallbackShellCachesOptions = {
+export type WarmPprFallbackShellCachesOptions = {
   element: AppPageRenderableElement;
   onError: AppPageBoundaryOnError;
   renderToReadableStream: (element: AppPageRenderableElement, options: {
@@ -12,6 +12,5 @@ type WarmPprFallbackShellCachesOptions = {
   }) => ReadableStream<Uint8Array>;
   state: PprFallbackShellState;
 };
-declare function warmPprFallbackShellCaches(options: WarmPprFallbackShellCachesOptions): Promise<void>;
-//#endregion
-export { WarmPprFallbackShellCachesOptions, warmPprFallbackShellCaches };
+export declare function warmPprFallbackShellCaches(options: WarmPprFallbackShellCachesOptions): Promise<void>;
+//#endregion

package/dist/server/app-ppr-fallback-shell-render.js

@@ -3,13 +3,14 @@ import { readAppPageBinaryStream } from "./app-page-execution.js";
 //#region src/server/app-ppr-fallback-shell-render.ts
 async function warmPprFallbackShellCaches(options) {
 	let warmupError = null;
-	const warmupDrain = readAppPageBinaryStream(options.renderToReadableStream(options.element, {
+	const warmupStream = options.renderToReadableStream(options.element, {
 		signal: options.state.abortController.signal,
 		onError(error, requestInfo, errorContext) {
 			if (options.state.abortController.signal.aborted || isPprFallbackShellAbortError(error)) return;
 			return options.onError(error, requestInfo, errorContext);
 		}
-	})).catch((error) => {
+	});
+	const warmupDrain = readAppPageBinaryStream(warmupStream).catch((error) => {
 		if (options.state.abortController.signal.aborted || isPprFallbackShellAbortError(error)) return;
 		warmupError = error;
 	});

package/dist/server/app-ppr-fallback-shell.d.ts

@@ -14,20 +14,19 @@ type AppPprFallbackShell = {
  * Produced at build time by the PPR prerender and served at request time
  * when the exact cache entry for a dynamic child param is missing.
  */
-type AppPagePprFallbackCacheShell = {
+export type AppPagePprFallbackCacheShell = {
   fallbackParamNames: readonly string[];
   params: Record<string, string | string[]>;
   pathname: string;
 };
-declare function markAppPprDynamicFallbackShellHtml(html: string): string;
-declare function isAppPprDynamicFallbackShellHtml(html: string): boolean;
-declare function createAppPprFallbackShells(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell[];
-declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
+export declare function markAppPprDynamicFallbackShellHtml(html: string): string;
+export declare function isAppPprDynamicFallbackShellHtml(html: string): boolean;
+export declare function createAppPprFallbackShells(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell[];
+export declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
   html: string;
   isForceStatic?: boolean;
   params: Record<string, string | string[]>;
   pathname: string;
   searchParams: URLSearchParams;
 }): string;
-//#endregion
-export { AppPagePprFallbackCacheShell, createAppPprFallbackShells, isAppPprDynamicFallbackShellHtml, markAppPprDynamicFallbackShellHtml, rewriteAppPprFallbackShellHtmlNavigation };
+//#endregion

package/dist/server/app-prerender-endpoints.d.ts

@@ -2,9 +2,10 @@ import { RootParams } from "../shims/root-params.js";
 //#region src/server/app-prerender-endpoints.d.ts
 type GenerateStaticParams = (args: {
   params: RootParams;
+  rejectEmptyResults?: boolean;
 }) => unknown;
-type AppPrerenderStaticParamsMap = Record<string, GenerateStaticParams | null | undefined>;
-type AppPrerenderRootParamNamesMap = Record<string, readonly string[] | undefined>;
+export type AppPrerenderStaticParamsMap = Record<string, GenerateStaticParams | null | undefined>;
+export type AppPrerenderRootParamNamesMap = Record<string, readonly string[] | undefined>;
 type HandleAppPrerenderEndpointOptions = {
   isPrerenderEnabled?: () => boolean;
   getMetadataRoutePaths?: () => Promise<unknown>;
@@ -13,6 +14,5 @@ type HandleAppPrerenderEndpointOptions = {
   rootParamNamesByPattern?: AppPrerenderRootParamNamesMap;
   staticParamsMap: AppPrerenderStaticParamsMap;
 };
-declare function handleAppPrerenderEndpoint(request: Request, options: HandleAppPrerenderEndpointOptions): Promise<Response | null>;
-//#endregion
-export { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap, handleAppPrerenderEndpoint };
+export declare function handleAppPrerenderEndpoint(request: Request, options: HandleAppPrerenderEndpointOptions): Promise<Response | null>;
+//#endregion

package/dist/server/app-prerender-endpoints.js

@@ -38,10 +38,12 @@ async function handleStaticParamsEndpoint(request, options) {
 	const generateStaticParams = options.staticParamsMap[pattern];
 	if (typeof generateStaticParams !== "function") return jsonNullResponse();
 	try {
+		const params = parseParentParams(url.searchParams.get("parentParams"));
 		const result = await callAppPrerenderStaticParams({
 			fn: generateStaticParams,
-			params: parseParentParams(url.searchParams.get("parentParams")),
+			params,
 			pattern,
+			rejectEmptyResults: url.searchParams.get("rejectEmptyResults") === "1",
 			rootParamNamesByPattern: options.rootParamNamesByPattern ?? {}
 		});
 		if (result === null) return jsonNullResponse();

package/dist/server/app-prerender-static-params.d.ts

@@ -1,8 +1,16 @@
 import { RootParams } from "../shims/root-params.js";
 //#region src/server/app-prerender-static-params.d.ts
-type GenerateStaticParamsFunction = (input: {
+/**
+ * A prerender resolver's input. `rejectEmptyResults` is set where Next.js
+ * fails the build on any generateStaticParams that returns no params
+ * (`output: "export"`, Cache Components), so the resolver hands the empty
+ * result back for the caller to reject instead of passing parents through.
+ */
+type AppPrerenderStaticParamsResolverInput = {
   params: RootParams;
-}) => unknown;
+  rejectEmptyResults?: boolean;
+};
+type AppPrerenderStaticParamsResolver = (input: AppPrerenderStaticParamsResolverInput) => unknown;
 /**
  * Build a prerender `generateStaticParams` resolver for one route pattern.
  *
@@ -17,13 +25,13 @@ type GenerateStaticParamsFunction = (input: {
  *
  * Returns `null` (no resolver) only when the pattern has zero sources at all.
  */
-declare function createAppPrerenderStaticParamsResolver(sources: readonly unknown[], rootParamNames?: readonly string[]): GenerateStaticParamsFunction | null;
+export declare function createAppPrerenderStaticParamsResolver(sources: readonly unknown[], rootParamNames?: readonly string[]): AppPrerenderStaticParamsResolver | null;
 type CallAppPrerenderStaticParamsOptions = {
-  fn: GenerateStaticParamsFunction;
+  fn: AppPrerenderStaticParamsResolver;
   params: RootParams;
   pattern: string;
+  rejectEmptyResults?: boolean;
   rootParamNamesByPattern: Record<string, readonly string[] | undefined>;
 };
-declare function callAppPrerenderStaticParams(options: CallAppPrerenderStaticParamsOptions): Promise<unknown>;
-//#endregion
-export { callAppPrerenderStaticParams, createAppPrerenderStaticParamsResolver };
+export declare function callAppPrerenderStaticParams(options: CallAppPrerenderStaticParamsOptions): Promise<unknown>;
+//#endregion

package/dist/server/app-prerender-static-params.js

@@ -1,10 +1,13 @@
 import { isUnknownRecord } from "../utils/record.js";
 import { pickRootParams, runWithRootParamsScope } from "../shims/root-params.js";
 //#region src/server/app-prerender-static-params.ts
-const PRERENDER_PATH_DISCOVERY_ENV = "__VINEXT_PRERENDER_PATH_DISCOVERY";
+/**
+* Next.js rejects malformed generateStaticParams output in every mode
+* (build/static-paths/app.ts callGenerateStaticParams), so it must never read
+* as an empty result that later providers continue from.
+*/
 function invalidGenerateStaticParamsResult(message) {
-	if (process.env[PRERENDER_PATH_DISCOVERY_ENV] === "1") throw new Error(message);
-	return [];
+	throw new Error(message);
 }
 function isGenerateStaticParamsFunction(value) {
 	return typeof value === "function";
@@ -55,19 +58,27 @@ function createAppPrerenderStaticParamsResolver(sources, rootParamNames) {
 		if (fns.length === 0) return null;
 		if (fns.length === 1) {
 			const single = fns[0];
-			return runWithRootParamsScope(filterRootParams(input.params), async () => {
-				const result = await single(input);
+			const picked = filterRootParams(input.params);
+			return runWithRootParamsScope(picked, async () => {
+				const result = await single({ params: input.params });
 				if (!Array.isArray(result)) return invalidGenerateStaticParamsResult("generateStaticParams must return an array");
 				for (const item of result) if (!isRootParams(item)) return invalidGenerateStaticParamsResult("generateStaticParams must return an array of objects");
 				return result;
 			});
 		}
-		let paramSets = [input.params];
+		let paramSets = Object.keys(input.params).length > 0 ? [input.params] : [];
 		for (const generateStaticParams of fns) {
 			const nextParamSets = [];
-			for (const parentParams of paramSets) {
-				const result = await runWithRootParamsScope(filterRootParams(parentParams), async () => generateStaticParams({ params: parentParams }));
+			const hasParentSets = paramSets.length > 0;
+			for (const parentParams of hasParentSets ? paramSets : [{}]) {
+				const rootScope = filterRootParams(parentParams);
+				const result = await runWithRootParamsScope(rootScope, async () => generateStaticParams({ params: parentParams }));
 				if (!Array.isArray(result)) return invalidGenerateStaticParamsResult("generateStaticParams must return an array");
+				if (result.length === 0) {
+					if (input.rejectEmptyResults) return [];
+					if (hasParentSets) nextParamSets.push(parentParams);
+					continue;
+				}
 				for (const item of result) {
 					if (!isRootParams(item)) return invalidGenerateStaticParamsResult("generateStaticParams must return an array of objects");
 					nextParamSets.push({
@@ -82,7 +93,11 @@ function createAppPrerenderStaticParamsResolver(sources, rootParamNames) {
 	};
 }
 async function callAppPrerenderStaticParams(options) {
-	return runWithRootParamsScope(pickRootParams(options.params, options.rootParamNamesByPattern[options.pattern]), () => options.fn({ params: options.params }));
+	const picked = pickRootParams(options.params, options.rootParamNamesByPattern[options.pattern]);
+	return runWithRootParamsScope(picked, () => options.fn(options.rejectEmptyResults ? {
+		params: options.params,
+		rejectEmptyResults: true
+	} : { params: options.params }));
 }
 //#endregion
 export { callAppPrerenderStaticParams, createAppPrerenderStaticParamsResolver };

package/dist/server/app-render-dependency.d.ts

@@ -1,21 +1,22 @@
 import { ComponentType, ReactNode } from "react";
 //#region src/server/app-render-dependency.d.ts
-type AppRenderDependency = {
+export type AppRenderDependency = {
   promise: Promise<void>;
   release: () => void;
 };
-type AppPageRenderDependency = AppRenderDependency & {
+export type AppPageRenderDependency = AppRenderDependency & {
   resultDependencies: readonly AppRenderDependency[];
   setResultDependencies: (dependencies: readonly AppRenderDependency[]) => void;
 };
-declare function isReactOwnedAppComponent(component: unknown): boolean;
-declare function invokeAppComponent(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>): ReactNode | Promise<ReactNode>;
-declare function registerAppElementRenderDependencies(elements: Readonly<Record<string, unknown>>, dependenciesByElementId: ReadonlyMap<string, AppRenderDependency>): void;
-declare function releaseAppElementRenderDependency(elements: Readonly<Record<string, unknown>>, elementId: string): void;
-declare function createAppRenderDependency(): AppRenderDependency;
-declare function createAppPageRenderDependency(): AppPageRenderDependency;
-declare function isAppRenderSuspension(error: unknown): boolean;
-declare function renderAfterAppDependencies(children: ReactNode, dependencies: readonly AppRenderDependency[]): ReactNode;
-declare function renderAppComponentWithDependencyBarrier(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, dependency: AppRenderDependency): ReactNode;
-//#endregion
-export { AppPageRenderDependency, AppRenderDependency, createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, isAppRenderSuspension, isReactOwnedAppComponent, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };
+/** Whether `component` is a "use client" export seen from the RSC environment. */
+export declare function isAppClientReference(component: unknown): boolean;
+export declare function isReactOwnedAppComponent(component: unknown): boolean;
+export declare function invokeAppComponent(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>): ReactNode | Promise<ReactNode>;
+export declare function registerAppElementRenderDependencies(elements: Readonly<Record<string, unknown>>, dependenciesByElementId: ReadonlyMap<string, AppRenderDependency>): void;
+export declare function releaseAppElementRenderDependency(elements: Readonly<Record<string, unknown>>, elementId: string): void;
+export declare function createAppRenderDependency(): AppRenderDependency;
+export declare function createAppPageRenderDependency(): AppPageRenderDependency;
+export declare function isAppRenderSuspension(error: unknown): boolean;
+export declare function renderAfterAppDependencies(children: ReactNode, dependencies: readonly AppRenderDependency[]): ReactNode;
+export declare function renderAppComponentWithDependencyBarrier(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, dependency: AppRenderDependency): ReactNode;
+//#endregion

package/dist/server/app-render-dependency.js

@@ -6,6 +6,10 @@ const REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
 const REACT_FORWARD_REF = Symbol.for("react.forward_ref");
 const REACT_LAZY = Symbol.for("react.lazy");
 const REACT_MEMO = Symbol.for("react.memo");
+/** Whether `component` is a "use client" export seen from the RSC environment. */
+function isAppClientReference(component) {
+	return component?.$$typeof === REACT_CLIENT_REFERENCE;
+}
 function isReactOwnedAppComponent(component) {
 	const candidate = component;
 	if (candidate?.$$typeof === REACT_MEMO || candidate?.$$typeof === REACT_LAZY || candidate?.$$typeof === REACT_FORWARD_REF) return false;
@@ -88,4 +92,4 @@ function renderAppComponentWithDependencyBarrier(component, props, dependency) {
 	return createElement(AppComponentDependencyBarrier);
 }
 //#endregion
-export { createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, isAppRenderSuspension, isReactOwnedAppComponent, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };
+export { createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };

package/dist/server/app-request-context.d.ts

@@ -8,7 +8,7 @@ import "../shims/navigation-server.js";
  *
  * Clearing nav context (ctx === null) also clears root params.
  */
-declare function setAppNavigationContext(ctx: NavigationContext | null): void;
+export declare function setAppNavigationContext(ctx: NavigationContext | null): void;
 /**
  * Clear all per-request ALS state owned by the App Router handler.
  * Must be called before returning a non-page response (redirect, public
@@ -16,6 +16,5 @@ declare function setAppNavigationContext(ctx: NavigationContext | null): void;
  *
  * Clears: headers, navigation context, root params.
  */
-declare function clearAppRequestContext(): void;
-//#endregion
-export { clearAppRequestContext, setAppNavigationContext };
+export declare function clearAppRequestContext(): void;
+//#endregion

package/dist/server/app-request-stage-context.d.ts

@@ -0,0 +1,5 @@
+//#region src/server/app-request-stage-context.d.ts
+/** The request stage does not render user code, so it owns no navigation context. */
+export declare function setAppRequestStageNavigationContext(): void;
+export declare function clearAppRequestStageContext(): void;
+//#endregion

package/dist/server/app-request-stage-context.js

@@ -0,0 +1,11 @@
+import { setHeadersContext } from "../shims/headers.js";
+import { setRootParams } from "../shims/root-params.js";
+//#region src/server/app-request-stage-context.ts
+/** The request stage does not render user code, so it owns no navigation context. */
+function setAppRequestStageNavigationContext() {}
+function clearAppRequestStageContext() {
+	setHeadersContext(null);
+	setRootParams(null);
+}
+//#endregion
+export { clearAppRequestStageContext, setAppRequestStageNavigationContext };

package/dist/server/app-request-stage-dispatch.d.ts

@@ -0,0 +1,25 @@
+import { VinextCacheabilityProbeMode } from "./multi-stage.js";
+import { TrustedPrerenderState } from "./prerender-route-params.js";
+import { DispatchAppWorkerResponseStage } from "./app-worker-stages.js";
+import { AppRscRequestHandler } from "./app-rsc-handler.js";
+//#region src/server/app-request-stage-dispatch.d.ts
+export type AppRequestStageDispatchOptions = {
+  basePath: string;
+  buildId: string | null;
+  draftModeSecret: string;
+  handleRequest: AppRscRequestHandler;
+  prerenderDiscovery: boolean;
+  probeMode: VinextCacheabilityProbeMode | null;
+  trustedPrerenderState?: TrustedPrerenderState | null;
+};
+/**
+ * Whether this request needs the complete App response graph before ordinary
+ * request-stage routing can safely classify it.
+ */
+export declare function appRequestUsesFullResponseGraph(request: Request, options: Pick<AppRequestStageDispatchOptions, "basePath" | "draftModeSecret" | "probeMode" | "trustedPrerenderState">): boolean;
+/**
+ * Select the request-only or complete App graph and perform the transport
+ * bookkeeping needed by a full-stage dispatch.
+ */
+export declare function dispatchAppRequestStage(request: Request, ctx: unknown, dispatchResponseStage: DispatchAppWorkerResponseStage | null | undefined, options: AppRequestStageDispatchOptions): Promise<Response>;
+//#endregion

package/dist/server/app-request-stage-dispatch.js

@@ -0,0 +1,54 @@
+import "../utils/protocol-headers.js";
+import "./headers.js";
+import { restoreStaticFileSignalFromTransport } from "./static-file-signal.js";
+import { isDraftModeRequest } from "../shims/headers.js";
+import { getScriptNonceFromHeaderSources } from "./csp.js";
+import { isRouteTreePrefetchRequest } from "./app-route-tree-prefetch.js";
+import "./app-worker-stages.js";
+//#region src/server/app-request-stage-dispatch.ts
+/**
+* Whether this request needs the complete App response graph before ordinary
+* request-stage routing can safely classify it.
+*/
+function appRequestUsesFullResponseGraph(request, options) {
+	if (request.method !== "GET" && request.method !== "HEAD") return true;
+	if (request.headers.get("upgrade")?.split(",").some((value) => value.trim().toLowerCase() === "websocket")) return true;
+	if (process.env.VINEXT_PRERENDER === "1") return true;
+	if (options.trustedPrerenderState) return true;
+	if (isDraftModeRequest(request, options.draftModeSecret)) return true;
+	if (request.headers.has("x-vinext-prerender-route-params")) return true;
+	if (getScriptNonceFromHeaderSources(request.headers) !== void 0 || isRouteTreePrefetchRequest(request)) return true;
+	const url = new URL(request.url);
+	return (options.basePath && url.pathname.startsWith(options.basePath + "/") ? url.pathname.slice(options.basePath.length) : url.pathname).startsWith("/__vinext/");
+}
+/**
+* Select the request-only or complete App graph and perform the transport
+* bookkeeping needed by a full-stage dispatch.
+*/
+async function dispatchAppRequestStage(request, ctx, dispatchResponseStage, options) {
+	if (!dispatchResponseStage) throw new Error("App request stage requires a response-stage dispatcher");
+	if (appRequestUsesFullResponseGraph(request, options)) {
+		const staticFileSignalToken = crypto.randomUUID();
+		const response = await dispatchResponseStage(request, {
+			kind: "app-full-request",
+			buildId: options.buildId,
+			cacheability: {
+				policyHeaders: null,
+				probeMode: options.probeMode,
+				resolvedRoutePathname: new URL(request.url).pathname
+			},
+			draftModeCookie: null,
+			middlewareCookieOverlay: null,
+			prerenderDiscovery: options.prerenderDiscovery,
+			protocolVersion: 10,
+			requestOrigin: new URL(request.url).origin,
+			scriptNonce: null,
+			staticFileSignalToken,
+			trustedPrerenderState: options.trustedPrerenderState ?? null
+		}, { cache: "bypass" });
+		return restoreStaticFileSignalFromTransport(response, staticFileSignalToken);
+	}
+	return options.handleRequest(request, ctx, false, dispatchResponseStage, options.probeMode);
+}
+//#endregion
+export { appRequestUsesFullResponseGraph, dispatchAppRequestStage };

package/dist/server/app-request-stage-independent-entry.d.ts

@@ -0,0 +1,8 @@
+import { VinextRequestStageContext } from "./multi-stage.js";
+import { ExecutionContextLike } from "../shims/request-context.js";
+import { DispatchAppWorkerResponseStage } from "./app-worker-stages.js";
+//#region src/server/app-request-stage-independent-entry.d.ts
+export type AppRequestStageEnv = Record<string, unknown>;
+type AppRequestStageContext = ExecutionContextLike & VinextRequestStageContext;
+export declare function handleRequestStage(request: Request, env: AppRequestStageEnv | undefined, ctx: AppRequestStageContext | undefined, dispatchResponseStage: DispatchAppWorkerResponseStage): Promise<Response>;
+//#endregion