vinext 0.2.1 → 1.0.0-beta.1

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

@@ -1,5 +1,4 @@
-import { addBasePathToPathname } from "../utils/base-path.js";
-import { VINEXT_RSC_REDIRECT_HEADER } from "./headers.js";
+import { VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
 import { runWithConnectionProbe } from "../shims/headers.js";
 import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
@@ -7,28 +6,9 @@ import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { renderSsrErrorMetaTags } from "./app-ssr-error-meta.js";
 import { isPromiseLike } from "../utils/promise.js";
+import { formatNextRedirectDigest } from "./app-rsc-redirect-flight.js";
 //#region src/server/app-page-execution.ts
 /**
-* Builds the canonical `NEXT_REDIRECT;<type>;<url>;<status>;` digest that
-* Next.js encodes on `redirect()` / `permanentRedirect()` throws. Used when
-* we synthesize a flight payload for an RSC navigation: the digest must
-* round-trip through the client's `RedirectErrorBoundary` so the same
-* `getURLFromRedirectError` / `getRedirectTypeFromError` helpers decode it.
-*
-* The URL is included verbatim, not encoded — Next.js's `getRedirectError`
-* sets `digest = ${CODE};${type};${url};${status};` with the raw URL, and the
-* client decodes via `error.digest.split(';').slice(2, -2).join(';')`. We
-* default `type=replace` because `redirect()` is replace-style outside of
-* server actions, matching Next.js's `getRedirectError` default.
-*
-* Reference:
-*   `.nextjs-ref/packages/next/src/client/components/redirect.ts:20-23`
-*   `.nextjs-ref/packages/next/src/client/components/redirect-error.ts`
-*/
-function formatNextRedirectDigest(options) {
-	return `NEXT_REDIRECT;replace;${options.url};${options.statusCode};`;
-}
-/**
 * Marker we tag onto a thrown redirect/notFound error when it originates from
 * `generateMetadata()` (vs. a server component itself). Metadata resolution is
 * suspended/streamed in Next.js, so a redirect from metadata is not emitted as
@@ -73,12 +53,13 @@ function mergeAppPageSpecialErrorHeaders(response, middlewareContext) {
 function resolveAppPageSpecialError(error) {
 	if (!(error && typeof error === "object" && "digest" in error)) return null;
 	const digest = String(error.digest);
-	const fromMetadata = error[APP_PAGE_METADATA_ERROR_MARKER] === true;
+	const fromMetadata = Reflect.get(error, APP_PAGE_METADATA_ERROR_MARKER) === true;
 	const redirect = parseNextRedirectDigest(digest);
 	if (redirect) return {
 		kind: "redirect",
 		location: redirect.url,
 		statusCode: redirect.status,
+		type: redirect.type === "push" ? "push" : "replace",
 		...fromMetadata ? { fromMetadata: true } : {}
 	};
 	const httpError = parseNextHttpErrorDigest(digest);
@@ -97,17 +78,15 @@ function resolveAppPageSpecialError(error) {
 * in `app-render.tsx`: a `redirect("/about")` call from a page mounted at
 * `/blog` (basePath) produces `Location: /blog/about`.
 *
-* Skips prefixing when:
-*  - basePath is unset / empty
-*  - the target is a full URL pointing at a different origin (external redirect)
-*  - the target already starts with the basePath (caller did the work themselves)
+* Skips prefixing only when basePath is unset or the raw target does not start
+* with `/`, matching Next.js's literal `addPathPrefix()` contract.
 */
-function applyAppPageRedirectBasePath(location, requestUrl, basePath) {
-	const resolved = new URL(location, requestUrl);
-	const requestOrigin = new URL(requestUrl).origin;
-	if (!basePath || resolved.origin !== requestOrigin) return resolved.toString();
-	resolved.pathname = addBasePathToPathname(resolved.pathname, basePath);
-	return resolved.toString();
+function applyAppPageRedirectBasePath(location, basePath) {
+	if (!basePath || !location.startsWith("/")) return location;
+	const queryIndex = location.indexOf("?");
+	const hashIndex = location.indexOf("#");
+	const suffixIndex = queryIndex === -1 ? hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
+	return `${basePath}${suffixIndex === -1 ? location : location.slice(0, suffixIndex)}${suffixIndex === -1 ? "" : location.slice(suffixIndex)}`;
 }
 /**
 * Returns a path-relative form (`/foo?bar`) of an absolute URL when it shares
@@ -141,9 +120,10 @@ function buildMetadataRedirectHtmlResponse(options) {
 async function buildAppPageSpecialErrorResponse(options) {
 	if (options.specialError.kind === "redirect") {
 		options.clearRequestContext();
-		const prefixedLocation = applyAppPageRedirectBasePath(options.specialError.location, options.request.url, options.basePath);
+		const prefixedLocation = applyAppPageRedirectBasePath(options.specialError.location, options.basePath);
 		const digestUrl = sameOriginPathOrAbsolute(prefixedLocation, options.request.url);
 		const digest = formatNextRedirectDigest({
+			type: options.specialError.type ?? "replace",
 			url: digestUrl,
 			statusCode: options.specialError.statusCode
 		});
@@ -155,14 +135,13 @@ async function buildAppPageSpecialErrorResponse(options) {
 		});
 		if (Boolean(options.buildRscRedirectFlightStream) && options.isRscRequest && options.buildRscRedirectFlightStream) {
 			const stream = options.buildRscRedirectFlightStream({ digest });
-			const headers = new Headers({
-				"Content-Type": VINEXT_RSC_CONTENT_TYPE,
-				[VINEXT_RSC_REDIRECT_HEADER]: digestUrl
-			});
+			const headers = new Headers({ "Content-Type": VINEXT_RSC_CONTENT_TYPE });
 			applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
 			applyRscCompatibilityIdHeader(headers);
 			applyRscDeploymentIdHeader(headers);
 			mergeMiddlewareResponseHeaders(headers, options.middlewareContext?.headers ?? null);
+			headers.set(VINEXT_RSC_REDIRECT_HEADER, digestUrl);
+			headers.set(VINEXT_RSC_REDIRECT_TYPE_HEADER, options.specialError.type ?? "replace");
 			const pendingCookies = options.getAndClearPendingCookies?.() ?? [];
 			for (const cookie of pendingCookies) headers.append("Set-Cookie", cookie);
 			return new Response(stream, {
@@ -313,6 +292,19 @@ async function readAppPageBinaryStream(stream) {
 	}
 	return buffer.buffer;
 }
+async function bufferAppPageBinaryStream(stream) {
+	const reader = stream.getReader();
+	const chunks = [];
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+	}
+	return new ReadableStream({ start(controller) {
+		for (const chunk of chunks) controller.enqueue(chunk);
+		controller.close();
+	} });
+}
 function teeAppPageRscStreamForCapture(stream, shouldCapture) {
 	if (!shouldCapture) return { ssrStream: stream };
 	const [ssrStream, sideStream] = stream.tee();
@@ -326,4 +318,4 @@ function buildAppPageFontLinkHeader(preloads) {
 	return preloads.map((preload) => `<${preload.href}>; rel=preload; as=font; type=${preload.type}; crossorigin`).join(", ");
 }
 //#endregion
-export { buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageComponent, probeAppPageLayouts, probeAppPageThrownError, readAppPageBinaryStream, resolveAppPageSpecialError, tagAppPageMetadataError, teeAppPageRscStreamForCapture };
+export { bufferAppPageBinaryStream, buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageComponent, probeAppPageLayouts, probeAppPageThrownError, readAppPageBinaryStream, resolveAppPageSpecialError, tagAppPageMetadataError, teeAppPageRscStreamForCapture };

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

@@ -1,4 +1,3 @@
-import { CachedAppPageValue } from "../shims/cache-handler.js";
 import { ClientReuseManifestParseResult, ClientReuseManifestSkipDisposition } from "./client-reuse-manifest.js";
 import { AppOutgoingElements } from "./app-elements-wire.js";
 import { NavigationContext } from "../shims/navigation-context-state.js";
@@ -7,6 +6,7 @@ import { AppPageMiddlewareContext } from "./app-page-response.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
+import { CachedAppPageValue } from "../shims/cache-handler.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageRenderObservationState } from "./app-page-render-observation.js";
 import { ReactNode } from "react";

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

@@ -57,7 +57,7 @@ function getParallelParentParamNames(routeParamNames, branch, boundaryPosition)
 		return name ? [name] : [];
 	}));
 	const ownerParamNames = slotParamNames.filter((name) => !branchParamNameSet.has(name));
-	return [...new Set([...ownerParamNames, ...branchParamNames])];
+	return [.../* @__PURE__ */ new Set([...ownerParamNames, ...branchParamNames])];
 }
 function resolveAppPageGenerateStaticParamsSources(options) {
 	const sources = [];

package/dist/server/app-page-route-wiring.js

@@ -1,6 +1,6 @@
 import { createAppRenderDependency, registerAppElementRenderDependencies, renderAfterAppDependencies, renderWithAppDependencyBarrier } from "./app-render-dependency.js";
 import { APP_STATIC_SIBLINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
-import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
+import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "./app-rsc-render-mode.js";
 import { APP_PREFETCH_LOADING_SHELL_MARKER_KEY } from "./app-elements.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
 import { ErrorBoundary, ForbiddenBoundary, GlobalErrorBoundary, NotFoundBoundary, RedirectBoundary, UnauthorizedBoundary } from "../shims/error-boundary.js";
@@ -213,7 +213,7 @@ function buildAppPageElements(options) {
 		const slotName = slot.name;
 		slotNameCounts.set(slotName, (slotNameCounts.get(slotName) ?? 0) + 1);
 	}
-	const orderedTreePositions = Array.from(new Set([
+	const orderedTreePositions = Array.from(/* @__PURE__ */ new Set([
 		...layoutEntries.map((entry) => entry.treePosition),
 		...templateEntries.map((entry) => entry.treePosition),
 		...errorEntries.map((entry) => entry.treePosition)
@@ -353,7 +353,7 @@ function buildAppPageElements(options) {
 			children: slotElement
 		});
 		const slotLoadingComponent = getDefaultExport(slot.loading);
-		if (slotLoadingComponent && !shouldSuppressLoadingBoundaries(renderMode)) slotElement = /* @__PURE__ */ jsx(Suspense, {
+		if (slotLoadingComponent) slotElement = /* @__PURE__ */ jsx(Suspense, {
 			fallback: /* @__PURE__ */ jsx(slotLoadingComponent, {}),
 			children: slotElement
 		}, slotResetKey);
@@ -374,7 +374,7 @@ function buildAppPageElements(options) {
 	else routeChildren = /* @__PURE__ */ jsx(routeLoadingComponent, {});
 	else {
 		routeChildren = /* @__PURE__ */ jsx(RedirectBoundary, { children: routeChildren });
-		if (routeLoadingComponent && !shouldSuppressLoadingBoundaries(renderMode)) routeChildren = /* @__PURE__ */ jsx(Suspense, {
+		if (routeLoadingComponent) routeChildren = /* @__PURE__ */ jsx(Suspense, {
 			fallback: /* @__PURE__ */ jsx(routeLoadingComponent, {}),
 			children: routeChildren
 		}, routeResetKey);

package/dist/server/app-route-handler-execution.d.ts

@@ -1,7 +1,7 @@
 import { NextI18nConfig } from "../config/next-config.js";
-import { CachedRouteValue } from "../shims/cache-handler.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
 import { NextRequest } from "../shims/server.js";
+import { CachedRouteValue } from "../shims/cache-handler.js";
 import { HeadersAccessPhase } from "../shims/headers.js";
 import { RouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
 import { AppRouteHandlerModule } from "./app-route-handler-policy.js";

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

@@ -86,7 +86,7 @@ function modulesByTreePosition(modules, positions) {
 async function buildTree(route) {
 	const layoutsByPosition = layoutModuleByTreePosition(route);
 	const root = createNode("", layoutsByPosition.get(0));
-	const nodesByPosition = new Map([[0, root]]);
+	const nodesByPosition = /* @__PURE__ */ new Map([[0, root]]);
 	let current = root;
 	for (const [index, segment] of route.routeSegments.entries()) {
 		const position = index + 1;

package/dist/server/app-rsc-cache-busting.js

@@ -14,7 +14,6 @@ const VINEXT_RSC_COMPATIBILITY_ID_HEADER = "X-Vinext-RSC-Compatibility-Id";
 const VINEXT_RSC_CONTENT_TYPE = "text/x-component";
 const VINEXT_RSC_VARY_HEADER = [
 	"RSC",
-	"Accept",
 	NEXT_ROUTER_STATE_TREE_HEADER,
 	NEXT_ROUTER_PREFETCH_HEADER,
 	NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,
@@ -190,7 +189,7 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	const actualHash = url.searchParams.get(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM);
 	const expectedHash = await computeRscCacheBustingSearchParam(options.request.headers);
 	if (actualHash === null && expectedHash === "" && url.pathname.endsWith(".rsc")) return null;
-	const acceptedHashes = new Set([expectedHash]);
+	const acceptedHashes = /* @__PURE__ */ new Set([expectedHash]);
 	if (actualHash !== null && actualHash !== expectedHash) {
 		acceptedHashes.add(computeLegacyRscCacheBustingSearchParam(options.request.headers));
 		if (normalizeRenderModeHeaderValue(options.request.headers.get("X-Vinext-Rsc-Render-Mode")) === null) {

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

@@ -19,17 +19,17 @@ import "./app-page-response.js";
 import { parseNextHttpErrorDigest } from "./next-error-digest.js";
 import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
+import { flattenErrorCauses } from "../utils/error-cause.js";
 import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage } from "./server-action-not-found.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
 import { createRouteTreePrefetchResponse, isRouteTreePrefetchRequest } from "./app-route-tree-prefetch.js";
-import { flattenErrorCauses } from "../utils/error-cause.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
 import { runWithPrerenderWorkUnit } from "./prerender-work-unit-setup.js";
 //#region src/server/app-rsc-handler.ts
-const STATIC_METADATA_CONFIG_HEADER_OVERRIDES = new Set(["cache-control"]);
+const STATIC_METADATA_CONFIG_HEADER_OVERRIDES = /* @__PURE__ */ new Set(["cache-control"]);
 function applyMiddlewareContextToResponse(response, middlewareContext) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
 	const headers = new Headers(response.headers);

package/dist/server/app-rsc-redirect-flight.d.ts

@@ -0,0 +1,66 @@
+import { ReactNode } from "react";
+
+//#region src/server/app-rsc-redirect-flight.d.ts
+/**
+ * Encoding of a `redirect()` for RSC transport: the canonical
+ * `NEXT_REDIRECT;<type>;<url>;<status>;` digest and the flight payload that
+ * carries it. Kept in one module so the digest format and the stream that
+ * serializes it have a single owner; `buildAppPageSpecialErrorResponse` and the
+ * boundary/dispatch special-error paths all depend on this contract.
+ */
+/**
+ * Builds the canonical `NEXT_REDIRECT;<type>;<url>;<status>;` digest that
+ * Next.js encodes on `redirect()` / `permanentRedirect()` throws. Used when we
+ * synthesize a flight payload for an RSC navigation: the digest must round-trip
+ * through the client's `RedirectErrorBoundary` so the same
+ * `getURLFromRedirectError` / `getRedirectTypeFromError` helpers decode it.
+ *
+ * The URL is included verbatim, not encoded — Next.js's `getRedirectError`
+ * sets `digest = ${CODE};${type};${url};${status};` with the raw URL, and the
+ * client decodes via `error.digest.split(';').slice(2, -2).join(';')`. We
+ * default `type=replace` because `redirect()` is replace-style outside of
+ * server actions, matching Next.js's `getRedirectError` default.
+ *
+ * Reference:
+ *   `.nextjs-ref/packages/next/src/client/components/redirect.ts:20-23`
+ *   `.nextjs-ref/packages/next/src/client/components/redirect-error.ts`
+ */
+declare function formatNextRedirectDigest(options: {
+  type: "push" | "replace";
+  url: string;
+  statusCode: number;
+}): string;
+/**
+ * The subset of `renderToReadableStream` the redirect-flight encoding needs.
+ * Both the boundary and dispatch special-error paths hand in their own
+ * environment-specific renderer, which accepts a wider element type; a plain
+ * throwing React element satisfies all of them.
+ */
+type RedirectFlightStreamRenderer = (element: ReactNode, options: {
+  onError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
+}) => ReadableStream<Uint8Array>;
+/**
+ * Builds an RSC flight payload that encodes a `redirect()` as a React error
+ * carrying the canonical `NEXT_REDIRECT;<type>;<url>;<status>;` digest. We
+ * render a tiny element that throws immediately; `renderToReadableStream`'s
+ * `onError` returns the digest, react-server-dom-webpack serializes the error
+ * into the stream, and the client's `RedirectErrorBoundary` decodes it via
+ * `getURLFromRedirectError` / `getRedirectTypeFromError`. The HTTP response
+ * stays 200 because the redirect rides in the flight body, not the status line.
+ *
+ * Mirrors Next.js's `generateDynamicFlightRenderResult` in `app-render.tsx`,
+ * where a redirect thrown during RSC rendering propagates through
+ * `renderToFlightStream`'s `onError` into the flight payload.
+ *
+ * This is the single owner of the redirect-flight encoding: the matched
+ * dispatch paths (`renderLayoutSpecialError` / `renderPageSpecialError`) and the
+ * route-miss boundary path (`renderBoundarySpecialErrorResponse`) both call it
+ * through the `buildRscRedirectFlightStream` option of
+ * `buildAppPageSpecialErrorResponse`.
+ */
+declare function buildRscRedirectFlightStream(options: {
+  renderToReadableStream: RedirectFlightStreamRenderer;
+  digest: string;
+}): ReadableStream<Uint8Array>;
+//#endregion
+export { RedirectFlightStreamRenderer, buildRscRedirectFlightStream, formatNextRedirectDigest };

package/dist/server/app-rsc-redirect-flight.js

@@ -0,0 +1,71 @@
+import { createElement } from "react";
+//#region src/server/app-rsc-redirect-flight.ts
+/**
+* Encoding of a `redirect()` for RSC transport: the canonical
+* `NEXT_REDIRECT;<type>;<url>;<status>;` digest and the flight payload that
+* carries it. Kept in one module so the digest format and the stream that
+* serializes it have a single owner; `buildAppPageSpecialErrorResponse` and the
+* boundary/dispatch special-error paths all depend on this contract.
+*/
+/**
+* Builds the canonical `NEXT_REDIRECT;<type>;<url>;<status>;` digest that
+* Next.js encodes on `redirect()` / `permanentRedirect()` throws. Used when we
+* synthesize a flight payload for an RSC navigation: the digest must round-trip
+* through the client's `RedirectErrorBoundary` so the same
+* `getURLFromRedirectError` / `getRedirectTypeFromError` helpers decode it.
+*
+* The URL is included verbatim, not encoded — Next.js's `getRedirectError`
+* sets `digest = ${CODE};${type};${url};${status};` with the raw URL, and the
+* client decodes via `error.digest.split(';').slice(2, -2).join(';')`. We
+* default `type=replace` because `redirect()` is replace-style outside of
+* server actions, matching Next.js's `getRedirectError` default.
+*
+* Reference:
+*   `.nextjs-ref/packages/next/src/client/components/redirect.ts:20-23`
+*   `.nextjs-ref/packages/next/src/client/components/redirect-error.ts`
+*/
+function formatNextRedirectDigest(options) {
+	return `NEXT_REDIRECT;${options.type};${options.url};${options.statusCode};`;
+}
+/**
+* Error thrown by the redirect-flight renderer below. Its `digest` is the
+* canonical `NEXT_REDIRECT;...` string that react-server-dom's `onError`
+* reports so the client's `RedirectErrorBoundary` can decode it. A named
+* subclass keeps `digest` a real field rather than an `as`-cast on a plain
+* `Error`.
+*/
+var RscRedirectFlightError = class extends Error {
+	digest;
+	constructor(digest) {
+		super("NEXT_REDIRECT");
+		this.digest = digest;
+	}
+};
+/**
+* Builds an RSC flight payload that encodes a `redirect()` as a React error
+* carrying the canonical `NEXT_REDIRECT;<type>;<url>;<status>;` digest. We
+* render a tiny element that throws immediately; `renderToReadableStream`'s
+* `onError` returns the digest, react-server-dom-webpack serializes the error
+* into the stream, and the client's `RedirectErrorBoundary` decodes it via
+* `getURLFromRedirectError` / `getRedirectTypeFromError`. The HTTP response
+* stays 200 because the redirect rides in the flight body, not the status line.
+*
+* Mirrors Next.js's `generateDynamicFlightRenderResult` in `app-render.tsx`,
+* where a redirect thrown during RSC rendering propagates through
+* `renderToFlightStream`'s `onError` into the flight payload.
+*
+* This is the single owner of the redirect-flight encoding: the matched
+* dispatch paths (`renderLayoutSpecialError` / `renderPageSpecialError`) and the
+* route-miss boundary path (`renderBoundarySpecialErrorResponse`) both call it
+* through the `buildRscRedirectFlightStream` option of
+* `buildAppPageSpecialErrorResponse`.
+*/
+function buildRscRedirectFlightStream(options) {
+	const { digest } = options;
+	const throwingElement = createElement(function NextRedirectFlightThrower() {
+		throw new RscRedirectFlightError(digest);
+	});
+	return options.renderToReadableStream(throwingElement, { onError: () => digest });
+}
+//#endregion
+export { buildRscRedirectFlightStream, formatNextRedirectDigest };

package/dist/server/app-rsc-render-mode.d.ts

@@ -1,12 +1,9 @@
 //#region src/server/app-rsc-render-mode.d.ts
-type AppRscRenderMode = "navigation" | "prefetch-dynamic-shell" | "prefetch-loading-shell" | "refresh-preserve-ui" | "action-rerender-preserve-ui";
+type AppRscRenderMode = "navigation" | "prefetch-dynamic-shell" | "prefetch-loading-shell";
 declare const APP_RSC_RENDER_MODE_NAVIGATION = "navigation";
 declare const APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL = "prefetch-dynamic-shell";
 declare const APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL = "prefetch-loading-shell";
-declare const APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI = "refresh-preserve-ui";
-declare const APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI = "action-rerender-preserve-ui";
-declare function shouldSuppressLoadingBoundaries(mode: AppRscRenderMode): boolean;
 declare function getRscRenderModeCacheVariant(mode: AppRscRenderMode): string | null;
 declare function parseAppRscRenderMode(value: string | null): AppRscRenderMode;
 //#endregion
-export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };
+export { APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode };

package/dist/server/app-rsc-render-mode.js

@@ -2,27 +2,17 @@
 const APP_RSC_RENDER_MODE_NAVIGATION = "navigation";
 const APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL = "prefetch-dynamic-shell";
 const APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL = "prefetch-loading-shell";
-const APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI = "refresh-preserve-ui";
-const APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI = "action-rerender-preserve-ui";
-function shouldSuppressLoadingBoundaries(mode) {
-	return mode === "refresh-preserve-ui" || mode === "action-rerender-preserve-ui";
-}
-function shouldUsePreserveUiCacheVariant(mode) {
-	return shouldSuppressLoadingBoundaries(mode);
-}
 function getRscRenderModeCacheVariant(mode) {
 	if (mode === "prefetch-dynamic-shell") return "prefetch-dynamic-shell";
 	if (mode === "prefetch-loading-shell") return "prefetch-loading-shell";
-	return shouldUsePreserveUiCacheVariant(mode) ? "preserve-ui" : null;
+	return null;
 }
 function parseAppRscRenderMode(value) {
 	switch (value) {
 		case APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL: return APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL;
 		case APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL: return APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL;
-		case APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI: return APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI;
-		case APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI: return APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI;
 		default: return APP_RSC_RENDER_MODE_NAVIGATION;
 	}
 }
 //#endregion
-export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };
+export { APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, getRscRenderModeCacheVariant, parseAppRscRenderMode };

package/dist/server/app-segment-config.js

@@ -1,12 +1,12 @@
 import { isEdgeApiRuntime } from "./edge-api-runtime.js";
 //#region src/server/app-segment-config.ts
-const DYNAMIC_VALUES = new Set([
+const DYNAMIC_VALUES = /* @__PURE__ */ new Set([
 	"auto",
 	"error",
 	"force-dynamic",
 	"force-static"
 ]);
-const FETCH_CACHE_VALUES = new Set([
+const FETCH_CACHE_VALUES = /* @__PURE__ */ new Set([
 	"auto",
 	"default-cache",
 	"default-no-store",

package/dist/server/app-server-action-execution.js

@@ -4,7 +4,7 @@ import { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS
 import { isExternalUrl } from "../config/config-matchers.js";
 import { internalServerErrorResponse, payloadTooLargeResponse } from "./http-error-responses.js";
 import { validateCsrfOrigin, validateServerActionPayload } from "./request-pipeline.js";
-import { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI } from "./app-rsc-render-mode.js";
+import { APP_RSC_RENDER_MODE_NAVIGATION } from "./app-rsc-render-mode.js";
 import { headersContextFromRequest, isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
 import { getAndClearActionRevalidationKind } from "../shims/cache-request-state.js";
 import { setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
@@ -684,7 +684,7 @@ async function handleServerActionRscRequest(options) {
 					request: redirectRenderRequest,
 					route: targetMatch.route,
 					searchParams: redirectSearchParams,
-					renderMode: APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI,
+					renderMode: APP_RSC_RENDER_MODE_NAVIGATION,
 					observeMetadataSearchParamsAccess: redirectDynamicConfig !== "force-static",
 					observePageSearchParamsAccess: redirectDynamicConfig !== "force-static"
 				});
@@ -778,7 +778,7 @@ async function handleServerActionRscRequest(options) {
 				request: options.request,
 				route: actionRerenderTarget.route,
 				searchParams: actionRerenderSearchParams,
-				renderMode: APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI,
+				renderMode: APP_RSC_RENDER_MODE_NAVIGATION,
 				observeMetadataSearchParamsAccess: actionRerenderDynamicConfig !== "force-static",
 				observePageSearchParamsAccess: actionRerenderDynamicConfig !== "force-static"
 			});

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

@@ -16,7 +16,7 @@ import { setPagesClientAssets } from "./pages-client-assets.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
 import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
 import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
-import { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform } from "./app-ssr-stream.js";
+import { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, waitAtLeastOneReactRenderTask } from "./app-ssr-stream.js";
 import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
 import { runWithRootParamsScope } from "../shims/root-params.js";
 import { createInitialBfcacheMaps } from "./app-bfcache-identity.js";
@@ -238,6 +238,7 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 				};
 				let htmlStream;
 				let shellErrorRecovered = false;
+				let shouldDelayInitialHtmlPull = false;
 				if (pprFallbackShellSignal) {
 					const prerender = await loadStaticPrerender();
 					const htmlAbortController = new AbortController();
@@ -252,6 +253,7 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 					try {
 						streamingHtmlStream = await renderToReadableStream(ssrRoot, { ...renderOptions });
 						if (options?.waitForAllReady === true) await streamingHtmlStream.allReady;
+						else shouldDelayInitialHtmlPull = true;
 						htmlStream = streamingHtmlStream;
 					} catch (error) {
 						streamingHtmlStream?.cancel().catch(() => {});
@@ -281,6 +283,7 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 					return buildHeadInjectionHtml(ssrNavigationContext, bootstrapModuleUrl, options?.formState ?? null, insertedHTML + errorMetaHTML + getTraceMetaHTML() + initialDevServerErrorHTML, fontHTML, options?.dynamicStaleTimeSeconds, options?.scriptNonce);
 				};
 				const getBeforeInteractiveHeadHTML = () => renderBeforeInteractiveInlineScripts(beforeInteractiveInlineScripts);
+				if (shouldDelayInitialHtmlPull) await waitAtLeastOneReactRenderTask();
 				return {
 					htmlStream: deferUntilStreamConsumed(htmlStream.pipeThrough(createTickBufferedTransform(rscEmbed, getInsertedHTML, getBeforeInteractiveHeadHTML, inlineCssManifest, inlineCssFontStyles, inlineCssFontStyleFallbackHTML, options?.scriptNonce)), cleanup),
 					metadataReady: Promise.resolve(),

package/dist/server/app-ssr-stream.d.ts

@@ -10,6 +10,7 @@ type InitialNavigationCacheMetadata = {
   kind: "dynamic" | "static";
   dynamicStaleTimeSeconds?: number;
 };
+declare function waitAtLeastOneReactRenderTask(): Promise<void>;
 declare function navigationRuntimeRscBootstrapExpression(): string;
 declare function createNavigationRuntimeRscMetadataScript(params: Record<string, string | string[]>, nav: {
   pathname: string;
@@ -61,4 +62,4 @@ declare function fixPreloadAs(html: string): string;
  */
 declare function createTickBufferedTransform(rscEmbed: RscEmbedTransform, injectHTML?: HtmlInsertion, injectAfterHeadOpenHTML?: HtmlInsertion, inlineCssManifest?: InlineCssManifest, inlineCssPrependCss?: string, inlineCssPrependFallbackHTML?: string, inlineCssScriptNonce?: string): TransformStream<Uint8Array, Uint8Array>;
 //#endregion
-export { InitialNavigationCacheMetadata, createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, fixFlightHints, fixPreloadAs, navigationRuntimeRscBootstrapExpression };
+export { InitialNavigationCacheMetadata, createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, fixFlightHints, fixPreloadAs, navigationRuntimeRscBootstrapExpression, waitAtLeastOneReactRenderTask };

package/dist/server/app-ssr-stream.js

@@ -2,6 +2,9 @@ import { createInlineScriptTag, escapeHtmlAttr, htmlTokenListContains, safeJsonS
 import { bytesToBase64, concatUint8Arrays } from "./app-rsc-embedded-chunks.js";
 import { NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION } from "../client/navigation-runtime.js";
 //#region src/server/app-ssr-stream.ts
+function waitAtLeastOneReactRenderTask() {
+	return new Promise((resolve) => setTimeout(resolve, 0));
+}
 const NAVIGATION_RUNTIME_REFERENCE = `self[Symbol.for(${safeJsonStringify(NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION)})]`;
 function navigationRuntimeRscBootstrapExpression() {
 	return `((${NAVIGATION_RUNTIME_REFERENCE}??={bootstrap:{routeManifest:null},functions:{}}).bootstrap.rsc??={rsc:[]})`;
@@ -409,4 +412,4 @@ function createTickBufferedTransform(rscEmbed, injectHTML = "", injectAfterHeadO
 	});
 }
 //#endregion
-export { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, fixFlightHints, fixPreloadAs, navigationRuntimeRscBootstrapExpression };
+export { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, fixFlightHints, fixPreloadAs, navigationRuntimeRscBootstrapExpression, waitAtLeastOneReactRenderTask };

package/dist/server/cache-proof.js

@@ -19,7 +19,7 @@ const ALL_RENDER_REQUEST_API_KINDS = [
 	"params",
 	"searchParams"
 ];
-const PUBLIC_UNSAFE_DIMENSION_SOURCES = new Set([
+const PUBLIC_UNSAFE_DIMENSION_SOURCES = /* @__PURE__ */ new Set([
 	"auth",
 	"cookie",
 	"draft-mode",

package/dist/server/default-global-error-module.d.ts

@@ -1,3 +1,5 @@
+import DefaultGlobalError from "../shims/default-global-error.js";
+
 //#region src/server/default-global-error-module.d.ts
 /**
  * Module-shaped wrapper around vinext's built-in default global error
@@ -13,7 +15,7 @@
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack/loaders/next-app-loader/index.ts
  */
 declare const DEFAULT_GLOBAL_ERROR_MODULE: {
-  readonly default: any;
+  readonly default: typeof DefaultGlobalError;
 };
 //#endregion
 export { DEFAULT_GLOBAL_ERROR_MODULE };

package/dist/server/default-not-found-module.d.ts

@@ -1,3 +1,5 @@
+import DefaultNotFound from "../shims/default-not-found.js";
+
 //#region src/server/default-not-found-module.d.ts
 /**
  * Module-shaped wrapper around vinext's built-in default not-found component.
@@ -13,7 +15,7 @@
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack/loaders/next-app-loader/index.ts
  */
 declare const DEFAULT_NOT_FOUND_MODULE: {
-  readonly default: any;
+  readonly default: typeof DefaultNotFound;
 };
 //#endregion
 export { DEFAULT_NOT_FOUND_MODULE };

package/dist/server/dev-lockfile.js

@@ -1,6 +1,5 @@
-import { normalizePathSeparators } from "../utils/path.js";
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import fs from "node:fs";
-import path from "node:path";
 //#region src/server/dev-lockfile.ts
 /**
 * Dev server lock file.
@@ -99,7 +98,7 @@ function formatAlreadyRunningError(opts) {
 	if (!existing) return [
 		"Another vinext dev server appears to be running in this directory.",
 		"",
-		`Stale lock file: ${normalizePathSeparators(path.relative(cwd, lockfilePath))}`,
+		`Stale lock file: ${path.relative(cwd, lockfilePath)}`,
 		"Remove it manually if no server is running, then re-run `vinext dev`."
 	].join("\n");
 	const killCommand = process.platform === "win32" ? `taskkill /PID ${existing.pid} /F` : `kill ${existing.pid}`;

package/dist/server/dev-module-runner.js

@@ -8,7 +8,7 @@ import { ESModulesEvaluator, ModuleRunner, createNodeImportMeta } from "vite/mod
 *
 * ## Why this exists
 *
-* Vite 7's `server.ssrLoadModule()` and the lazy `RunnableDevEnvironment.runner`
+* Vite's `server.ssrLoadModule()` and the lazy `RunnableDevEnvironment.runner`
 * getter both use `SSRCompatModuleRunner`, which constructs a
 * `createServerModuleRunnerTransport` synchronously. That transport calls
 * `connect()` immediately, which reads `environment.hot.api.outsideEmitter` —

package/dist/server/dev-origin-check.d.ts

@@ -5,8 +5,8 @@
  * Prevents external websites from making cross-origin requests to the
  * local dev server and reading the responses (data exfiltration).
  *
- * Vite 7 provides built-in CORS and WebSocket origin protection, but
- * vinext overrides Vite's CORS config to allow OPTIONS passthrough.
+ * Vite provides built-in CORS and WebSocket origin protection, but vinext
+ * overrides Vite's CORS config to allow OPTIONS passthrough.
  * This module adds origin verification to vinext's own request handlers.
  */
 /**