vinext 1.3.0 → 1.4.0

package/dist/routing/app-route-graph.js

@@ -131,7 +131,7 @@ function createStaticSegmentGraph(routes) {
 				treePath
 			});
 		}
-		addRouteManifestSegmentErrorBoundaryFacts({
+		addRouteManifestSegmentBoundaryFacts({
 			boundaries,
 			route
 		});
@@ -303,19 +303,42 @@ function addRouteManifestBoundaryFacts(input) {
 	addRouteManifestBoundaryFact(input, "forbidden", input.route.forbiddenPaths[input.layoutIndex]);
 	addRouteManifestBoundaryFact(input, "unauthorized", input.route.unauthorizedPaths[input.layoutIndex]);
 }
-function addRouteManifestSegmentErrorBoundaryFacts(input) {
-	for (const [index, boundaryPath] of (input.route.errorPaths ?? []).entries()) {
-		const treePosition = input.route.errorTreePositions?.[index];
-		assertRouteManifestBoundaryTreePosition(input.route, boundaryPath, treePosition);
-		const ownerLayoutId = findRouteManifestOwnerLayoutId(input.route, treePosition);
+function addRouteManifestSegmentBoundaryFacts(input) {
+	const { route } = input;
+	const segmentBoundaries = [
+		[
+			"error",
+			route.errorPaths,
+			route.errorTreePositions
+		],
+		[
+			"notFound",
+			route.segmentNotFoundPaths,
+			route.segmentNotFoundTreePositions
+		],
+		[
+			"forbidden",
+			route.segmentForbiddenPaths,
+			route.segmentForbiddenTreePositions
+		],
+		[
+			"unauthorized",
+			route.segmentUnauthorizedPaths,
+			route.segmentUnauthorizedTreePositions
+		]
+	];
+	for (const [outcome, boundaryPaths, treePositions] of segmentBoundaries) for (const [index, boundaryPath] of (boundaryPaths ?? []).entries()) {
+		const treePosition = treePositions?.[index];
+		assertRouteManifestBoundaryTreePosition(route, boundaryPath, treePosition);
+		const ownerLayoutId = findRouteManifestOwnerLayoutId(route, treePosition);
 		if (ownerLayoutId !== null) continue;
-		const treePath = createAppRouteGraphTreePath(input.route.routeSegments, treePosition);
+		const treePath = createAppRouteGraphTreePath(route.routeSegments, treePosition);
 		addRouteManifestBoundaryFact({
 			boundaries: input.boundaries,
-			route: input.route,
+			route,
 			layoutId: ownerLayoutId,
 			treePath
-		}, "error", boundaryPath);
+		}, outcome, boundaryPath);
 	}
 }
 function addRouteManifestBoundaryFact(input, outcome, boundaryPath) {
@@ -458,14 +481,11 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const subPage = slotPages.get(slot.key);
 			if (subPage !== void 0) {
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage, matcher);
-				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage, matcher);
 				return withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
-					notFoundPath: notFoundBoundary.path,
-					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: rawSegments
 				}, subPage, matcher);
 			}
@@ -547,14 +567,11 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const subSlots = parentRoute.parallelSlots.map((slot) => {
 				const subPage = slotPages.get(slot.key);
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage ?? null, matcher);
-				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage ?? null, matcher);
 				return withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage || null,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
-					notFoundPath: notFoundBoundary.path,
-					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: subPage ? rawSegments : null
 				}, subPage ?? null, matcher);
 			});
@@ -593,6 +610,12 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 				unauthorizedPath: parentRoute.unauthorizedPath,
 				unauthorizedTreePosition: parentRoute.unauthorizedTreePosition,
 				unauthorizedPaths: parentRoute.unauthorizedPaths,
+				segmentNotFoundPaths: parentRoute.segmentNotFoundPaths,
+				segmentNotFoundTreePositions: parentRoute.segmentNotFoundTreePositions,
+				segmentForbiddenPaths: parentRoute.segmentForbiddenPaths,
+				segmentForbiddenTreePositions: parentRoute.segmentForbiddenTreePositions,
+				segmentUnauthorizedPaths: parentRoute.segmentUnauthorizedPaths,
+				segmentUnauthorizedTreePositions: parentRoute.segmentUnauthorizedTreePositions,
 				routeSegments: [...parentRoute.routeSegments, ...rawSegments],
 				childrenRouteSegments: childrenDefault ? parentRoute.routeSegments : void 0,
 				templateTreePositions: parentRoute.templateTreePositions,
@@ -679,53 +702,61 @@ function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
 		return relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0;
 	});
 }
+/**
+* The tree position of a slot's active page relative to the slot root, in the
+* coordinates of configLayoutTreePositions. Route groups count, unlike in
+* `routeSegments`, since each is its own loader-tree segment.
+*/
+function findSlotPageTreePosition(slot) {
+	return slot.pagePath ? findSlotConfigLayoutTreePositions(slot.ownerDir, [slot.pagePath])[0] : null;
+}
 function findSlotLoadingEntries(slotDir, pagePath, matcher) {
+	return findSlotSegmentFileEntries(slotDir, pagePath, "loading", matcher);
+}
+/** Find a convention file in each directory from the slot root to the page, outermost first. */
+function findSlotSegmentFileEntries(slotDir, pagePath, fileName, matcher) {
 	const pageDir = pagePath ? path.dirname(pagePath) : slotDir;
 	if (pageDir !== slotDir && !pageDir.startsWith(`${slotDir}${path.sep}`)) return [];
 	const relativeDir = path.relative(slotDir, pageDir);
 	const segments = relativeDir ? relativeDir.split(path.sep).filter(Boolean) : [];
-	const loadings = [];
+	const entries = [];
 	let currentDir = slotDir;
-	const rootLoading = findFile(currentDir, "loading", matcher);
-	if (rootLoading) loadings.push({
-		path: rootLoading,
+	const rootEntry = findFile(currentDir, fileName, matcher);
+	if (rootEntry) entries.push({
+		path: rootEntry,
 		treePosition: 0
 	});
 	for (let index = 0; index < segments.length; index++) {
 		currentDir = path.join(currentDir, segments[index]);
-		const loading = findFile(currentDir, "loading", matcher);
-		if (loading) loadings.push({
-			path: loading,
+		const entry = findFile(currentDir, fileName, matcher);
+		if (entry) entries.push({
+			path: entry,
 			treePosition: index + 1
 		});
 	}
-	return loadings;
+	return entries;
 }
 function withSlotLoadingEntries(slot, pagePath, matcher) {
 	const loadingEntries = findSlotLoadingEntries(slot.ownerDir, pagePath, matcher);
 	return {
 		...slot,
 		loadingPaths: loadingEntries.map((entry) => entry.path),
-		loadingTreePositions: loadingEntries.map((entry) => entry.treePosition)
+		loadingTreePositions: loadingEntries.map((entry) => entry.treePosition),
+		...findSlotNotFoundFields(slot.ownerDir, pagePath, matcher)
 	};
 }
-function findSlotNotFoundBoundary(slotDir, pagePath, matcher) {
-	let dir = pagePath ? path.dirname(pagePath) : slotDir;
-	while (dir === slotDir || dir.startsWith(`${slotDir}${path.sep}`)) {
-		const boundaryPath = findFile(dir, "not-found", matcher);
-		if (boundaryPath) {
-			const relativeDir = path.relative(slotDir, dir);
-			return {
-				path: boundaryPath,
-				treePosition: relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0
-			};
-		}
-		if (dir === slotDir) break;
-		dir = path.dirname(dir);
-	}
+/**
+* Every not-found convention on the slot's active branch, plus the nearest one,
+* which supplies the slot's not-found metadata.
+*/
+function findSlotNotFoundFields(slotDir, pagePath, matcher) {
+	const entries = findSlotSegmentFileEntries(slotDir, pagePath, "not-found", matcher);
+	const nearest = entries.at(-1);
 	return {
-		path: null,
-		treePosition: null
+		notFoundPath: nearest?.path ?? null,
+		notFoundTreePosition: nearest?.treePosition ?? null,
+		notFoundPaths: entries.map((entry) => entry.path),
+		notFoundTreePositions: entries.map((entry) => entry.treePosition)
 	};
 }
 /**
@@ -801,6 +832,10 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 	const notFoundPaths = discoverBoundaryFilePerLayout(layouts, "not-found", matcher);
 	const forbiddenPaths = discoverBoundaryFilePerLayout(layouts, "forbidden", matcher);
 	const unauthorizedPaths = discoverBoundaryFilePerLayout(layouts, "unauthorized", matcher);
+	const discoverPageSegmentBoundaryFiles = (fileName) => pagePath === null && routePath !== null ? [] : discoverSegmentBoundaryFiles(segments, appDir, fileName, matcher);
+	const segmentNotFounds = discoverPageSegmentBoundaryFiles("not-found");
+	const segmentForbiddens = discoverPageSegmentBoundaryFiles("forbidden");
+	const segmentUnauthorizeds = discoverPageSegmentBoundaryFiles("unauthorized");
 	const parallelSlots = discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, includeNestedOnlySlots);
 	return {
 		ids: createAppRouteSemanticIds({
@@ -833,6 +868,12 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 		forbiddenTreePosition: forbiddenEntry?.treePosition ?? null,
 		unauthorizedPath,
 		unauthorizedTreePosition: unauthorizedEntry?.treePosition ?? null,
+		segmentNotFoundPaths: segmentNotFounds.map((entry) => entry.path),
+		segmentNotFoundTreePositions: segmentNotFounds.map((entry) => entry.treePosition),
+		segmentForbiddenPaths: segmentForbiddens.map((entry) => entry.path),
+		segmentForbiddenTreePositions: segmentForbiddens.map((entry) => entry.treePosition),
+		segmentUnauthorizedPaths: segmentUnauthorizeds.map((entry) => entry.path),
+		segmentUnauthorizedTreePositions: segmentUnauthorizeds.map((entry) => entry.treePosition),
 		unauthorizedPaths,
 		routeSegments: segments,
 		templateTreePositions,
@@ -1034,6 +1075,24 @@ function discoverBoundaryFileEntry(segments, appDir, fileName, matcher) {
 	return null;
 }
 /**
+* Discover boundary files (not-found, forbidden, unauthorized) by segment tree
+* position. As with error.tsx, Next.js wraps each segment's children in its
+* boundary whether or not the segment has a layout.
+*/
+function discoverSegmentBoundaryFiles(segments, appDir, fileName, matcher) {
+	const boundaries = [];
+	let currentDir = appDir;
+	for (let index = 0; index <= segments.length; index++) {
+		if (index > 0) currentDir = path.join(currentDir, segments[index - 1]);
+		const boundary = findFile(currentDir, fileName, matcher);
+		if (boundary) boundaries.push({
+			path: boundary,
+			treePosition: index
+		});
+	}
+	return boundaries;
+}
+/**
 * Discover boundary files (not-found, forbidden, unauthorized) at each layout directory.
 * Returns an array aligned with the layouts array, where each entry is the boundary
 * file at that layout's directory, or null if none exists there.
@@ -1271,7 +1330,6 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
 		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
 		const loadingEntries = findSlotLoadingEntries(slotDir, pagePath, matcher);
-		const notFoundBoundary = findSlotNotFoundBoundary(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
 			key: `${slotName}@${path.relative(appDir, slotDir)}`,
@@ -1289,8 +1347,7 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 			loadingPaths: loadingEntries.map((loading) => loading.path),
 			loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
 			errorPath: findFile(slotDir, "error", matcher),
-			notFoundPath: notFoundBoundary.path,
-			notFoundTreePosition: notFoundBoundary.treePosition,
+			...findSlotNotFoundFields(slotDir, pagePath, matcher),
 			interceptingRoutes,
 			layoutIndex: -1,
 			routeSegments: pagePath ? [] : null
@@ -1440,7 +1497,7 @@ function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
 * Recursively scan a directory tree for page.tsx files that are inside
 * intercepting route directories.
 */
-function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher, parentLoadingEntries = []) {
+function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher, parentLoadingEntries = [], parentLayoutPaths = []) {
 	if (!fs.existsSync(currentDir)) return;
 	const entries = fs.readdirSync(currentDir, { withFileTypes: true });
 	for (const entry of entries) {
@@ -1450,13 +1507,14 @@ function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, res
 		const interceptDir = path.join(currentDir, entry.name);
 		if (interceptMatch) {
 			const restOfName = entry.name.slice(interceptMatch.prefix.length);
-			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, slotRootDir, results, matcher, [], parentLoadingEntries, path.relative(slotRootDir, currentDir).split(path.sep).filter(Boolean).length);
+			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, slotRootDir, results, matcher, parentLayoutPaths, parentLoadingEntries, path.relative(slotRootDir, currentDir).split(path.sep).filter(Boolean).length);
 		} else {
+			const layout = findFile(interceptDir, "layout", matcher);
 			const loading = findFile(interceptDir, "loading", matcher);
 			scanForInterceptingPages(interceptDir, slotRootDir, routeDir, appDir, results, matcher, loading ? [...parentLoadingEntries, {
 				path: loading,
 				treePosition: path.relative(slotRootDir, interceptDir).split(path.sep).filter(Boolean).length
-			}] : parentLoadingEntries);
+			}] : parentLoadingEntries, layout ? [...parentLayoutPaths, layout] : parentLayoutPaths);
 		}
 	}
 }
@@ -1486,7 +1544,15 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 		const targetPattern = computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir);
 		if (targetPattern) {
 			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
-			const notFoundBoundary = findSlotNotFoundBoundary(slotRootDir ?? interceptRoot, page, matcher);
+			const notFoundTreePositionOffset = slotRootDir ? 0 : 1;
+			const notFoundFields = findSlotNotFoundFields(slotRootDir ?? interceptRoot, page, matcher);
+			const findInterceptBoundaries = (fileName) => findSlotSegmentFileEntries(slotRootDir ?? interceptRoot, page, fileName, matcher).map((entry) => ({
+				path: entry.path,
+				treePosition: entry.treePosition + notFoundTreePositionOffset
+			}));
+			const forbiddenBoundaries = findInterceptBoundaries("forbidden");
+			const unauthorizedBoundaries = findInterceptBoundaries("unauthorized");
+			const errorBoundaries = findInterceptBoundaries("error");
 			const slotParentSegments = slotRootDir ? path.relative(slotRootDir, interceptParentDir).split(path.sep).filter(Boolean) : [];
 			const branchSegments = [
 				...slotParentSegments,
@@ -1498,7 +1564,9 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 				convention,
 				layoutPaths: [...layoutPaths],
 				layoutSegments: layoutPaths.map((layoutPath) => {
-					const relativeDir = path.relative(interceptRoot, path.dirname(layoutPath));
+					const layoutDir = path.dirname(layoutPath);
+					if (slotRootDir && layoutDir !== interceptRoot && !layoutDir.startsWith(`${interceptRoot}${path.sep}`)) return path.relative(slotRootDir, layoutDir).split(path.sep).filter(Boolean);
+					const relativeDir = path.relative(interceptRoot, layoutDir);
 					return [
 						...slotParentSegments,
 						interceptSegment,
@@ -1508,8 +1576,20 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 				loadingPaths: loadingEntries.map((loading) => loading.path),
 				loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
 				notFoundBranchSegments: branchSegments,
-				notFoundPath: notFoundBoundary.path,
-				notFoundTreePosition: notFoundBoundary.treePosition === null ? null : slotRootDir ? notFoundBoundary.treePosition : notFoundBoundary.treePosition + 1,
+				notFoundPath: notFoundFields.notFoundPath,
+				notFoundTreePosition: notFoundFields.notFoundTreePosition == null ? null : notFoundFields.notFoundTreePosition + notFoundTreePositionOffset,
+				notFoundPaths: notFoundFields.notFoundPaths,
+				notFoundTreePositions: notFoundFields.notFoundTreePositions?.map((treePosition) => treePosition + notFoundTreePositionOffset),
+				forbiddenPath: forbiddenBoundaries.at(-1)?.path ?? null,
+				forbiddenTreePosition: forbiddenBoundaries.at(-1)?.treePosition ?? null,
+				forbiddenPaths: forbiddenBoundaries.map((boundary) => boundary.path),
+				forbiddenTreePositions: forbiddenBoundaries.map((boundary) => boundary.treePosition),
+				unauthorizedPath: unauthorizedBoundaries.at(-1)?.path ?? null,
+				unauthorizedTreePosition: unauthorizedBoundaries.at(-1)?.treePosition ?? null,
+				unauthorizedPaths: unauthorizedBoundaries.map((boundary) => boundary.path),
+				unauthorizedTreePositions: unauthorizedBoundaries.map((boundary) => boundary.treePosition),
+				errorPaths: errorBoundaries.map((boundary) => boundary.path),
+				errorTreePositions: errorBoundaries.map((boundary) => boundary.treePosition),
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,
@@ -1751,4 +1831,4 @@ function computeAppRouteStaticSiblings(allRoutes, matchedRoute) {
 	return Array.from(siblings);
 }
 //#endregion
-export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment, patternsStructurallyEquivalent };
+export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, findSlotPageTreePosition, isInvisibleSegment, patternsStructurallyEquivalent };

package/dist/routing/browser-route-manifest.d.ts

@@ -40,4 +40,5 @@ export type BrowserRouteManifestWire = {
 };
 export declare function toBrowserRouteManifestWire(routeManifest: RouteManifest): BrowserRouteManifestWire;
 export declare function decodeBrowserRouteManifest(wire: BrowserRouteManifestWire): BrowserRouteManifest;
-//#endregion
+//#endregion
+export {};

package/dist/routing/optimistic-route-trie.d.ts

@@ -24,4 +24,5 @@ export type OptimisticRouteTrieMatch<Route extends OptimisticTrieRoute> = {
 };
 export declare function buildOptimisticRouteTrie<Route extends OptimisticTrieRoute>(routes: Iterable<Route>, onDynamicSegmentConflict?: (existingParamName: string, part: string) => void): OptimisticRouteTrieNode<Route>;
 export declare function matchOptimisticRouteTrie<Route extends OptimisticTrieRoute>(trie: OptimisticRouteTrieNode<Route>, urlParts: readonly string[]): OptimisticRouteTrieMatch<Route> | null;
-//#endregion
+//#endregion
+export {};

package/dist/routing/route-matching.d.ts

@@ -35,4 +35,5 @@ export declare function matchRouteWithTrieRawPathname<R extends {
   route: R;
   params: Record<string, string | string[]>;
 } | null;
-//#endregion
+//#endregion
+export {};

package/dist/routing/route-pattern.d.ts

@@ -68,4 +68,5 @@ export declare function normalizeStaticPathname(pathname: string): string;
  * locale handling should be added here, not duplicated at call sites.
  */
 export declare function normalizeStaticPathsEntry(entry: StaticPathsEntry, routePattern: string): NormalizedStaticPathsEntry;
-//#endregion
+//#endregion
+export {};

package/dist/server/accept-encoding.d.ts

@@ -23,4 +23,5 @@ export declare function selectContentEncoding<T extends ContentEncoding>(parsed:
 export declare const HAS_ZSTD: boolean;
 /** Select by client q-value first, then zstd > br > gzip > deflate > identity. */
 export declare function negotiateEncoding(req: IncomingMessage): NegotiatedEncoding;
-//#endregion
+//#endregion
+export {};

package/dist/server/api-handler.js

@@ -7,13 +7,14 @@ import { importModule, reportRequestError } from "./instrumentation.js";
 import { mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
 import { tracePagesApiHandler } from "./pages-execution-tracing.js";
 import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT, resolveBodyParserConfig } from "./pages-body-parser-config.js";
-import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
+import { PagesBodyParseError, createPagesBodyDecoder, isJsonMediaType } from "./pages-media-type.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { attachPagesPreviewApi, attachPagesRequestCookies } from "./pages-node-compat.js";
 import { finalizeEdgeApiResponse, isEdgeApiRuntime } from "./edge-api-runtime.js";
 import { signalFromNodeResponse } from "./node-response-signal.js";
 import { Buffer } from "node:buffer";
 import { decode } from "node:querystring";
+import { Stream } from "node:stream";
 //#region src/server/api-handler.ts
 /**
 * Default request body size (1 MB). Matches Next.js default bodyParser sizeLimit.
@@ -32,6 +33,8 @@ const MAX_BODY_SIZE = DEFAULT_PAGES_API_BODY_SIZE_LIMIT;
 * HMAC signature verification).
 */
 async function parseBody(req, sizeLimit = MAX_BODY_SIZE) {
+	const { mediaType, decoder } = await createPagesBodyDecoder(req.headers["content-type"]);
+	if (req.destroyed) throw req.errored ?? /* @__PURE__ */ new Error("Request aborted");
 	return new Promise((resolve, reject) => {
 		const chunks = [];
 		let totalSize = 0;
@@ -55,10 +58,10 @@ async function parseBody(req, sizeLimit = MAX_BODY_SIZE) {
 		req.on("end", () => {
 			if (settled) return;
 			settled = true;
-			const raw = Buffer.concat(chunks).toString("utf-8");
-			const mediaType = getMediaType(req.headers["content-type"]);
+			const body = Buffer.concat(chunks);
+			const raw = decoder.decode(body);
 			if (!raw) {
-				resolve(isJsonMediaType(mediaType) ? {} : mediaType === "application/x-www-form-urlencoded" ? decode(raw) : void 0);
+				resolve(isJsonMediaType(mediaType) ? {} : mediaType === "application/x-www-form-urlencoded" ? decode(raw) : body.length > 0 ? raw : void 0);
 				return;
 			}
 			if (isJsonMediaType(mediaType)) try {
@@ -188,6 +191,18 @@ function enhanceApiObjects(req, res, query, body, trustedRevalidateOrigin, allow
 			this.end(JSON.stringify(data));
 		},
 		send(data) {
+			if (this.statusCode === 204 || this.statusCode === 304) {
+				this.removeHeader("Content-Type");
+				this.removeHeader("Content-Length");
+				this.removeHeader("Transfer-Encoding");
+				this.end();
+				return;
+			}
+			if (data instanceof Stream) {
+				if (!this.getHeader("Content-Type")) this.setHeader("Content-Type", "application/octet-stream");
+				data.pipe(this);
+				return;
+			}
 			if (Buffer.isBuffer(data)) {
 				if (!this.getHeader("Content-Type")) this.setHeader("Content-Type", "application/octet-stream");
 				this.setHeader("Content-Length", String(data.length));

package/dist/server/app-action-forwarding.d.ts

@@ -22,4 +22,5 @@ export declare function createForwardedActionContext(executionContext: Execution
   actionForwarded: true;
 } & Partial<ExecutionContextLike>;
 export declare function forwardServerActionIfNeeded(options: ForwardServerActionOptions): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-bfcache-identity.d.ts

@@ -31,4 +31,5 @@ export declare function preserveBfcacheIdsForMergedElements(options: {
   preservedElementIds?: readonly string[];
   preservePreviousIds?: readonly string[];
 }): BfcacheIdMap;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-bfcache-identity.js

@@ -1,7 +1,7 @@
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { isNestedBfcacheSlotSegmentIdFor } from "./bfcache-identity.js";
 import { isBfcacheSegmentId } from "./app-bfcache-id.js";
+import { isNestedBfcacheSlotSegmentIdFor } from "./bfcache-identity.js";
 //#region src/server/app-bfcache-identity.ts
 let nextBfcacheId = 0;
 function rememberBfcacheId(value) {

package/dist/server/app-browser-action-result.d.ts

@@ -62,4 +62,5 @@ type DiscardedServerActionRefreshSchedulerOptions = {
   runRefresh: () => void;
 };
 export declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
-//#endregion
+//#endregion
+export {};