vinext 1.2.1 → 1.3.1

package/dist/server/app-route-module-loader.d.ts

@@ -43,6 +43,14 @@ type LazyLoadableIntercept = {
   __loadInterceptLayouts?: LazyModuleLoaderArray | null;
   interceptLoadings?: readonly unknown[] | null;
   __loadInterceptLoadings?: LazyModuleLoaderArray | null;
+  interceptNotFounds?: readonly unknown[] | null;
+  __loadInterceptNotFounds?: LazyModuleLoaderArray | null;
+  interceptForbiddens?: readonly unknown[] | null;
+  __loadInterceptForbiddens?: LazyModuleLoaderArray | null;
+  interceptUnauthorizeds?: readonly unknown[] | null;
+  __loadInterceptUnauthorizeds?: LazyModuleLoaderArray | null;
+  interceptErrors?: readonly unknown[] | null;
+  __loadInterceptErrors?: LazyModuleLoaderArray | null;
   __loadState?: {
     page?: unknown;
     pageLoading?: Promise<unknown> | null;
@@ -60,6 +68,7 @@ type LazyLoadableSlot = {
   loadings?: readonly unknown[];
   error?: unknown;
   notFound?: unknown;
+  notFounds?: readonly unknown[];
   __loadPage?: LazyModuleThunk | null;
   __loadDefault?: LazyModuleThunk | null;
   __loadLayout?: LazyModuleThunk | null;
@@ -68,6 +77,7 @@ type LazyLoadableSlot = {
   __loadLoadings?: LazyModuleLoaderArray | null;
   __loadError?: LazyModuleThunk | null;
   __loadNotFound?: LazyModuleThunk | null;
+  __loadNotFounds?: LazyModuleLoaderArray | null;
   /** Hydrated only after an intercept matches, not with the slot's base modules. */
   intercepts?: LazyLoadableIntercept[];
 };
@@ -82,6 +92,9 @@ export type LazyLoadableRoute = {
   notFounds?: unknown[];
   forbiddens?: unknown[];
   unauthorizeds?: unknown[];
+  segmentNotFounds?: unknown[];
+  segmentForbiddens?: unknown[];
+  segmentUnauthorizeds?: unknown[];
   loading?: unknown;
   error?: unknown;
   notFound?: unknown;
@@ -101,6 +114,9 @@ export type LazyLoadableRoute = {
   __loadNotFounds?: LazyModuleLoaderArray | null;
   __loadForbiddens?: LazyModuleLoaderArray | null;
   __loadUnauthorizeds?: LazyModuleLoaderArray | null;
+  __loadSegmentNotFounds?: LazyModuleLoaderArray | null;
+  __loadSegmentForbiddens?: LazyModuleLoaderArray | null;
+  __loadSegmentUnauthorizeds?: LazyModuleLoaderArray | null;
   __loadLoading?: LazyModuleThunk | null;
   __loadError?: LazyModuleThunk | null;
   __loadNotFound?: LazyModuleThunk | null;
@@ -123,4 +139,5 @@ export declare function loadAppInterceptLayouts(intercept: LazyLoadableIntercept
  * `null`/`undefined` routes and on eager routes that have no lazy thunks.
  */
 export declare function ensureAppRouteModulesLoaded<TRoute extends LazyLoadableRoute>(route: TRoute | null | undefined): TRoute | Promise<TRoute>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-route-module-loader.js

@@ -1,4 +1,5 @@
 import { runOutsideRequestScopes } from "../shims/internal/als-registry.js";
+import { shareIsolatePromise } from "./isolate-shared-promise.js";
 //#region src/server/app-route-module-loader.ts
 /**
 * Lazy route-module hydration for the App Router RSC entry.
@@ -63,7 +64,7 @@ async function hydrateInterceptModule(intercept, loader, field, loadingField) {
 	const cached = loadState?.[field];
 	if (cached != null) intercept[field] = cached;
 	if (!loader || intercept[field] != null) return;
-	const loading = loadState?.[loadingField] ?? runOutsideRequestScopes(loader).then((module) => {
+	const loading = loadState?.[loadingField] ?? shareIsolatePromise(runOutsideRequestScopes(loader).then((module) => {
 		intercept[field] = module;
 		if (loadState) {
 			loadState[field] = module;
@@ -73,7 +74,7 @@ async function hydrateInterceptModule(intercept, loader, field, loadingField) {
 	}).catch((error) => {
 		if (loadState) loadState[loadingField] = null;
 		throw error;
-	});
+	}));
 	if (loadState) loadState[loadingField] = loading;
 	intercept[field] = await loading;
 }
@@ -91,14 +92,18 @@ function loadAppInterceptLayouts(intercept) {
 	const loads = [];
 	pushArrayLoads(loads, intercept.interceptLayouts, intercept.__loadInterceptLayouts);
 	pushArrayLoads(loads, intercept.interceptLoadings, intercept.__loadInterceptLoadings);
+	pushArrayLoads(loads, intercept.interceptNotFounds, intercept.__loadInterceptNotFounds);
+	pushArrayLoads(loads, intercept.interceptForbiddens, intercept.__loadInterceptForbiddens);
+	pushArrayLoads(loads, intercept.interceptUnauthorizeds, intercept.__loadInterceptUnauthorizeds);
+	pushArrayLoads(loads, intercept.interceptErrors, intercept.__loadInterceptErrors);
 	if (loads.length === 0) return Promise.resolve(intercept.interceptLayouts ?? []);
-	const loading = Promise.all(loads).then(() => {
+	const loading = shareIsolatePromise(Promise.all(loads).then(() => {
 		if (loadState) loadState.interceptLayoutsLoading = null;
 		return intercept.interceptLayouts ?? [];
 	}).catch((error) => {
 		if (loadState) loadState.interceptLayoutsLoading = null;
 		throw error;
-	});
+	}));
 	if (loadState) loadState.interceptLayoutsLoading = loading;
 	return loading;
 }
@@ -129,6 +134,9 @@ function ensureAppRouteModulesLoaded(route) {
 	pushArrayLoads(loads, route.notFounds, route.__loadNotFounds);
 	pushArrayLoads(loads, route.forbiddens, route.__loadForbiddens);
 	pushArrayLoads(loads, route.unauthorizeds, route.__loadUnauthorizeds);
+	pushArrayLoads(loads, route.segmentNotFounds, route.__loadSegmentNotFounds);
+	pushArrayLoads(loads, route.segmentForbiddens, route.__loadSegmentForbiddens);
+	pushArrayLoads(loads, route.segmentUnauthorizeds, route.__loadSegmentUnauthorizeds);
 	for (const slot of Object.values(route.slots ?? {})) {
 		pushFieldLoad(loads, slot, "page", slot.__loadPage);
 		pushFieldLoad(loads, slot, "default", slot.__loadDefault);
@@ -138,19 +146,20 @@ function ensureAppRouteModulesLoaded(route) {
 		pushArrayLoads(loads, slot.loadings, slot.__loadLoadings);
 		pushFieldLoad(loads, slot, "error", slot.__loadError);
 		pushFieldLoad(loads, slot, "notFound", slot.__loadNotFound);
+		pushArrayLoads(loads, slot.notFounds, slot.__loadNotFounds);
 	}
 	if (loads.length === 0) {
 		route.__loaded = true;
 		return route;
 	}
-	const loading = Promise.all(loads).then(() => {
+	const loading = shareIsolatePromise(Promise.all(loads).then(() => {
 		route.__loaded = true;
 		route.__loading = null;
 		return route;
 	}).catch((error) => {
 		route.__loading = null;
 		throw error;
-	});
+	}));
 	route.__loading = loading;
 	return loading;
 }

package/dist/server/app-route-tree-prefetch.d.ts

@@ -39,4 +39,5 @@ export type PrefetchInliningConfig = false | {
 };
 export declare function isRouteTreePrefetchRequest(request: Request): boolean;
 export declare function createRouteTreePrefetchResponse(route: AppRouteTreePrefetchRoute, options?: RouteTreePrefetchResponseOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-route-tree.d.ts

@@ -0,0 +1,20 @@
+import { AppElements } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { ReactNode } from "react";
+//#region src/server/app-route-tree.d.ts
+/**
+ * Builds the App Router route tree after a sibling that the browser uses to
+ * write navigation history. Insertion effects run in tree order, so that
+ * sibling's effect runs before React mutates the route tree's DOM, like
+ * Next.js' HistoryUpdater.
+ *
+ * The server and the browser must render this same shape: a second child
+ * changes the useId values of everything below it, so SSR passes null in the
+ * sibling's place to keep hydrated ids matching.
+ */
+export declare function createAppRouteTree(options: {
+  elements: AppElements;
+  historyCommit: ReactNode;
+  routeId: string;
+}): ReactNode;
+//#endregion

package/dist/server/app-route-tree.js

@@ -0,0 +1,18 @@
+import { ElementsContext, Slot } from "../shims/slot.js";
+import { Fragment, createElement } from "react";
+//#region src/server/app-route-tree.ts
+/**
+* Builds the App Router route tree after a sibling that the browser uses to
+* write navigation history. Insertion effects run in tree order, so that
+* sibling's effect runs before React mutates the route tree's DOM, like
+* Next.js' HistoryUpdater.
+*
+* The server and the browser must render this same shape: a second child
+* changes the useId values of everything below it, so SSR passes null in the
+* sibling's place to keep hydrated ids matching.
+*/
+function createAppRouteTree(options) {
+	return createElement(Fragment, null, options.historyCommit, createElement(ElementsContext.Provider, { value: options.elements }, createElement(Slot, { id: options.routeId })));
+}
+//#endregion
+export { createAppRouteTree };

package/dist/server/app-router-entry.js

@@ -31,7 +31,7 @@ var app_router_entry_default = {
 	__ensureInstrumentation,
 	async fetch(request, env, ctx) {
 		const handleFetch = async () => {
-			await __ensureInstrumentation();
+			await __ensureInstrumentation(ctx);
 			const url = new URL(request.url);
 			return traceFrameworkRequest({
 				callback: async () => applyCdnResponseIdentityHeaders(await handleRequest(request, env, ctx), request),
@@ -53,7 +53,7 @@ async function handleRequest(request, env, platformCtx) {
 	let ctx = createWorkerPrerenderDiscoveryContext(requestCtx, request, __prerenderSecret);
 	const readinessResponse = createWorkerPrerenderReadinessResponse(ctx, request);
 	if (readinessResponse) {
-		if (readinessResponse.status === 204) await __ensureHybridPagesApplication();
+		if (readinessResponse.status === 204) await __ensureHybridPagesApplication(ctx);
 		return await validateCdnRequest(request) ?? readinessResponse;
 	}
 	let finalizeCacheabilityResponse;

package/dist/server/app-rsc-combined-handler.js

@@ -1,8 +1,15 @@
+import { getRequestExecutionContext, runWithExecutionContext } from "../shims/request-context.js";
+import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createAppRscRequestHandler } from "./app-rsc-handler.js";
 //#region src/server/app-rsc-combined-handler.ts
 /** Combined request/response handler used by default single-stage App entries. */
 function createAppRscHandler(options) {
-	const appRscHandler = createAppRscRequestHandler(options);
+	const appRscRequestHandler = createAppRscRequestHandler(options);
+	const appRscHandler = (request, ctx, ...rest) => {
+		if (ctx != null || getRequestExecutionContext()) return appRscRequestHandler(request, ctx, ...rest);
+		const executionContext = createWorkerRevalidationContext(void 0, (internalRequest, internalCtx) => runWithExecutionContext(internalCtx, () => appRscRequestHandler(internalRequest, internalCtx)), "node");
+		return runWithExecutionContext(executionContext, () => appRscRequestHandler(request, ctx, ...rest));
+	};
 	return Object.assign(appRscHandler, { handleResponseStage(request, ctx, props, stageOptions) {
 		return import("./app-rsc-response-stage.js").then(({ renderAppWorkerResponseStage }) => renderAppWorkerResponseStage(options, request, ctx, props, stageOptions));
 	} });

package/dist/server/app-rsc-error-handler.d.ts

@@ -23,4 +23,5 @@ export type AppRenderErrorContextOverrides = {
  * Pure factory: takes all deps explicitly — no closure over module-level state.
  */
 export declare function createAppRscOnErrorHandler(reportRequestError: ReportRequestError, request: Request, pathname: string, routePath: string, overrides?: AppRenderErrorContextOverrides): (error: unknown) => string | undefined;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-rsc-errors.d.ts

@@ -37,6 +37,14 @@ export declare function getDigestForWellKnownError(error: unknown): string | und
  * djb2 hash matching Next.js's string-hash package for RSC error digests.
  */
 export declare function errorDigest(input: string): string;
+/**
+ * The message React 19.3's production Flight client gives a Server Components
+ * error in the browser (minified error #441). Sanitized errors that vinext
+ * serializes itself, such as the error passed to app/global-error, use the
+ * same text so they read the same as errors React reconstructs.
+ */
+export declare const PRODUCTION_SERVER_COMPONENTS_ERROR_MESSAGE = "Minified React error #441; visit https://react.dev/errors/441 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
 export declare function sanitizeErrorForClient(error: unknown, nodeEnv?: "development" | "production" | "test"): unknown;
 export declare function createRscOnErrorHandler(options: CreateRscOnErrorHandlerOptions): (error: unknown) => string | undefined;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-rsc-errors.js

@@ -41,10 +41,17 @@ function errorDigest(input) {
 	for (let i = input.length - 1; i >= 0; i--) hash = hash * 33 ^ input.charCodeAt(i);
 	return (hash >>> 0).toString();
 }
+/**
+* The message React 19.3's production Flight client gives a Server Components
+* error in the browser (minified error #441). Sanitized errors that vinext
+* serializes itself, such as the error passed to app/global-error, use the
+* same text so they read the same as errors React reconstructs.
+*/
+const PRODUCTION_SERVER_COMPONENTS_ERROR_MESSAGE = "Minified React error #441; visit https://react.dev/errors/441 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
 function sanitizeErrorForClient(error, nodeEnv = process.env.NODE_ENV) {
 	if (resolveAppPageSpecialError(error)) return error;
 	if (nodeEnv !== "production") return error;
-	const sanitized = /* @__PURE__ */ new Error("An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error.");
+	const sanitized = /* @__PURE__ */ new Error(PRODUCTION_SERVER_COMPONENTS_ERROR_MESSAGE);
 	sanitized.digest = hasDigest(error) ? String(error.digest) : getThrownValueDigest(error);
 	Object.defineProperty(sanitized, ORIGINAL_SERVER_ERROR, {
 		configurable: false,
@@ -85,4 +92,4 @@ function createRscOnErrorHandler(options) {
 	};
 }
 //#endregion
-export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };
+export { PRODUCTION_SERVER_COMPONENTS_ERROR_MESSAGE, createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };

package/dist/server/app-rsc-handler.d.ts

@@ -1,6 +1,7 @@
 import { VinextCacheabilityProbeMode } from "./multi-stage.js";
 import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
 import { ImageConfig } from "./image-optimization.js";
+import { ExecutionContextLike } from "../shims/request-context.js";
 import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware.js";
 import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
@@ -217,7 +218,7 @@ export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
    * dedup'd. Provided by the generated RSC entry; absent in older entries.
    */
   ensureRouteLoaded?: (route: TRoute) => unknown;
-  ensureInstrumentation?: () => Promise<void>;
+  ensureInstrumentation?: (ctx: ExecutionContextLike | null) => Promise<void>;
   /**
    * Register cache adapters configured via the vinext() `cache` option. Wired
    * from the generated RSC entry (which can import `virtual:vinext-cache-adapters`)
@@ -251,6 +252,8 @@ export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   renderPagesFallback?: (options: RenderPagesFallbackOptions) => Promise<Response | null>;
   rootParamNamesByPattern?: RootParamNamesMap;
   setNavigationContext: (context: NavigationContextValue) => void;
+  /** next.config `skipProxyUrlNormalize`. */
+  skipProxyUrlNormalize?: boolean;
   /** next.config `skipTrailingSlashRedirect`: serve both slash forms without a 308. */
   skipTrailingSlashRedirect?: boolean;
   staticParamsMap: StaticParamsMap;
@@ -260,4 +263,5 @@ export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
 export type AppRscRequestHandler = (request: Request, ctx: unknown, allowInternalRscDocumentFallback?: boolean, dispatchResponseStage?: DispatchAppWorkerResponseStage, responseStageProbeMode?: VinextCacheabilityProbeMode | null, trustedPrerenderState?: TrustedPrerenderState | null) => Promise<Response>;
 /** Build the request-only handler without retaining the response renderer graph. */
 export declare function createAppRscRequestHandler<TRoute extends AppRscHandlerRoute>(options: CreateAppRscHandlerOptions<TRoute>): AppRscRequestHandler;
-//#endregion
+//#endregion
+export {};