vinext 1.3.1 → 1.4.0

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/lib/extend-node.js

@@ -0,0 +1,147 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/extend-node.js
+var require_extend_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Buffer = __require("buffer").Buffer;
+	module.exports = function(iconv) {
+		var original = void 0;
+		iconv.supportsNodeEncodingsExtension = !(Buffer.from || new Buffer(0) instanceof Uint8Array);
+		iconv.extendNodeEncodings = function extendNodeEncodings() {
+			if (original) return;
+			original = {};
+			if (!iconv.supportsNodeEncodingsExtension) {
+				console.error("ACTION NEEDED: require('iconv-lite').extendNodeEncodings() is not supported in your version of Node");
+				console.error("See more info at https://github.com/ashtuchkin/iconv-lite/wiki/Node-v4-compatibility");
+				return;
+			}
+			var nodeNativeEncodings = {
+				"hex": true,
+				"utf8": true,
+				"utf-8": true,
+				"ascii": true,
+				"binary": true,
+				"base64": true,
+				"ucs2": true,
+				"ucs-2": true,
+				"utf16le": true,
+				"utf-16le": true
+			};
+			Buffer.isNativeEncoding = function(enc) {
+				return enc && nodeNativeEncodings[enc.toLowerCase()];
+			};
+			var SlowBuffer = __require("buffer").SlowBuffer;
+			original.SlowBufferToString = SlowBuffer.prototype.toString;
+			SlowBuffer.prototype.toString = function(encoding, start, end) {
+				encoding = String(encoding || "utf8").toLowerCase();
+				if (Buffer.isNativeEncoding(encoding)) return original.SlowBufferToString.call(this, encoding, start, end);
+				if (typeof start == "undefined") start = 0;
+				if (typeof end == "undefined") end = this.length;
+				return iconv.decode(this.slice(start, end), encoding);
+			};
+			original.SlowBufferWrite = SlowBuffer.prototype.write;
+			SlowBuffer.prototype.write = function(string, offset, length, encoding) {
+				if (isFinite(offset)) {
+					if (!isFinite(length)) {
+						encoding = length;
+						length = void 0;
+					}
+				} else {
+					var swap = encoding;
+					encoding = offset;
+					offset = length;
+					length = swap;
+				}
+				offset = +offset || 0;
+				var remaining = this.length - offset;
+				if (!length) length = remaining;
+				else {
+					length = +length;
+					if (length > remaining) length = remaining;
+				}
+				encoding = String(encoding || "utf8").toLowerCase();
+				if (Buffer.isNativeEncoding(encoding)) return original.SlowBufferWrite.call(this, string, offset, length, encoding);
+				if (string.length > 0 && (length < 0 || offset < 0)) throw new RangeError("attempt to write beyond buffer bounds");
+				var buf = iconv.encode(string, encoding);
+				if (buf.length < length) length = buf.length;
+				buf.copy(this, offset, 0, length);
+				return length;
+			};
+			original.BufferIsEncoding = Buffer.isEncoding;
+			Buffer.isEncoding = function(encoding) {
+				return Buffer.isNativeEncoding(encoding) || iconv.encodingExists(encoding);
+			};
+			original.BufferByteLength = Buffer.byteLength;
+			Buffer.byteLength = SlowBuffer.byteLength = function(str, encoding) {
+				encoding = String(encoding || "utf8").toLowerCase();
+				if (Buffer.isNativeEncoding(encoding)) return original.BufferByteLength.call(this, str, encoding);
+				return iconv.encode(str, encoding).length;
+			};
+			original.BufferToString = Buffer.prototype.toString;
+			Buffer.prototype.toString = function(encoding, start, end) {
+				encoding = String(encoding || "utf8").toLowerCase();
+				if (Buffer.isNativeEncoding(encoding)) return original.BufferToString.call(this, encoding, start, end);
+				if (typeof start == "undefined") start = 0;
+				if (typeof end == "undefined") end = this.length;
+				return iconv.decode(this.slice(start, end), encoding);
+			};
+			original.BufferWrite = Buffer.prototype.write;
+			Buffer.prototype.write = function(string, offset, length, encoding) {
+				var _offset = offset, _length = length, _encoding = encoding;
+				if (isFinite(offset)) {
+					if (!isFinite(length)) {
+						encoding = length;
+						length = void 0;
+					}
+				} else {
+					var swap = encoding;
+					encoding = offset;
+					offset = length;
+					length = swap;
+				}
+				encoding = String(encoding || "utf8").toLowerCase();
+				if (Buffer.isNativeEncoding(encoding)) return original.BufferWrite.call(this, string, _offset, _length, _encoding);
+				offset = +offset || 0;
+				var remaining = this.length - offset;
+				if (!length) length = remaining;
+				else {
+					length = +length;
+					if (length > remaining) length = remaining;
+				}
+				if (string.length > 0 && (length < 0 || offset < 0)) throw new RangeError("attempt to write beyond buffer bounds");
+				var buf = iconv.encode(string, encoding);
+				if (buf.length < length) length = buf.length;
+				buf.copy(this, offset, 0, length);
+				return length;
+			};
+			if (iconv.supportsStreams) {
+				var Readable = __require("stream").Readable;
+				original.ReadableSetEncoding = Readable.prototype.setEncoding;
+				Readable.prototype.setEncoding = function setEncoding(enc, options) {
+					this._readableState.decoder = iconv.getDecoder(enc, options);
+					this._readableState.encoding = enc;
+				};
+				Readable.prototype.collect = iconv._collect;
+			}
+		};
+		iconv.undoExtendNodeEncodings = function undoExtendNodeEncodings() {
+			if (!iconv.supportsNodeEncodingsExtension) return;
+			if (!original) throw new Error("require('iconv-lite').undoExtendNodeEncodings(): Nothing to undo; extendNodeEncodings() is not called.");
+			delete Buffer.isNativeEncoding;
+			var SlowBuffer = __require("buffer").SlowBuffer;
+			SlowBuffer.prototype.toString = original.SlowBufferToString;
+			SlowBuffer.prototype.write = original.SlowBufferWrite;
+			Buffer.isEncoding = original.BufferIsEncoding;
+			Buffer.byteLength = original.BufferByteLength;
+			Buffer.prototype.toString = original.BufferToString;
+			Buffer.prototype.write = original.BufferWrite;
+			if (iconv.supportsStreams) {
+				var Readable = __require("stream").Readable;
+				Readable.prototype.setEncoding = original.ReadableSetEncoding;
+				delete Readable.prototype.collect;
+			}
+			original = void 0;
+		};
+	};
+}));
+//#endregion
+export default require_extend_node();
+export { require_extend_node };

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/lib/index.js

@@ -0,0 +1,94 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_safer } from "../../../../safer-buffer@2.1.2/deps/safer-buffer/safer.js";
+import { require_bom_handling } from "./bom-handling.js";
+import { require_encodings } from "../encodings/index.js";
+import { require_streams } from "./streams.js";
+import { require_extend_node } from "./extend-node.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Buffer = require_safer().Buffer;
+	var bomHandling = require_bom_handling();
+	var iconv = module.exports;
+	iconv.encodings = null;
+	iconv.defaultCharUnicode = "�";
+	iconv.defaultCharSingleByte = "?";
+	iconv.encode = function encode(str, encoding, options) {
+		str = "" + (str || "");
+		var encoder = iconv.getEncoder(encoding, options);
+		var res = encoder.write(str);
+		var trail = encoder.end();
+		return trail && trail.length > 0 ? Buffer.concat([res, trail]) : res;
+	};
+	iconv.decode = function decode(buf, encoding, options) {
+		if (typeof buf === "string") {
+			if (!iconv.skipDecodeWarning) {
+				console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding");
+				iconv.skipDecodeWarning = true;
+			}
+			buf = Buffer.from("" + (buf || ""), "binary");
+		}
+		var decoder = iconv.getDecoder(encoding, options);
+		var res = decoder.write(buf);
+		var trail = decoder.end();
+		return trail ? res + trail : res;
+	};
+	iconv.encodingExists = function encodingExists(enc) {
+		try {
+			iconv.getCodec(enc);
+			return true;
+		} catch (e) {
+			return false;
+		}
+	};
+	iconv.toEncoding = iconv.encode;
+	iconv.fromEncoding = iconv.decode;
+	iconv._codecDataCache = {};
+	iconv.getCodec = function getCodec(encoding) {
+		if (!iconv.encodings) iconv.encodings = require_encodings();
+		var enc = iconv._canonicalizeEncoding(encoding);
+		var codecOptions = {};
+		while (true) {
+			var codec = iconv._codecDataCache[enc];
+			if (codec) return codec;
+			var codecDef = iconv.encodings[enc];
+			switch (typeof codecDef) {
+				case "string":
+					enc = codecDef;
+					break;
+				case "object":
+					for (var key in codecDef) codecOptions[key] = codecDef[key];
+					if (!codecOptions.encodingName) codecOptions.encodingName = enc;
+					enc = codecDef.type;
+					break;
+				case "function":
+					if (!codecOptions.encodingName) codecOptions.encodingName = enc;
+					codec = new codecDef(codecOptions, iconv);
+					iconv._codecDataCache[codecOptions.encodingName] = codec;
+					return codec;
+				default: throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')");
+			}
+		}
+	};
+	iconv._canonicalizeEncoding = function(encoding) {
+		return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
+	};
+	iconv.getEncoder = function getEncoder(encoding, options) {
+		var codec = iconv.getCodec(encoding), encoder = new codec.encoder(options, codec);
+		if (codec.bomAware && options && options.addBOM) encoder = new bomHandling.PrependBOM(encoder, options);
+		return encoder;
+	};
+	iconv.getDecoder = function getDecoder(encoding, options) {
+		var codec = iconv.getCodec(encoding), decoder = new codec.decoder(options, codec);
+		if (codec.bomAware && !(options && options.stripBOM === false)) decoder = new bomHandling.StripBOM(decoder, options);
+		return decoder;
+	};
+	var nodeVer = typeof process !== "undefined" && process.versions && process.versions.node;
+	if (nodeVer) {
+		var nodeVerArr = nodeVer.split(".").map(Number);
+		if (nodeVerArr[0] > 0 || nodeVerArr[1] >= 10) require_streams()(iconv);
+		require_extend_node()(iconv);
+	}
+}));
+//#endregion
+export default require_lib();
+export {};

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/lib/streams.js

@@ -0,0 +1,95 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/streams.js
+var require_streams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Buffer = __require("buffer").Buffer;
+	var Transform = __require("stream").Transform;
+	module.exports = function(iconv) {
+		iconv.encodeStream = function encodeStream(encoding, options) {
+			return new IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options);
+		};
+		iconv.decodeStream = function decodeStream(encoding, options) {
+			return new IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options);
+		};
+		iconv.supportsStreams = true;
+		iconv.IconvLiteEncoderStream = IconvLiteEncoderStream;
+		iconv.IconvLiteDecoderStream = IconvLiteDecoderStream;
+		iconv._collect = IconvLiteDecoderStream.prototype.collect;
+	};
+	function IconvLiteEncoderStream(conv, options) {
+		this.conv = conv;
+		options = options || {};
+		options.decodeStrings = false;
+		Transform.call(this, options);
+	}
+	IconvLiteEncoderStream.prototype = Object.create(Transform.prototype, { constructor: { value: IconvLiteEncoderStream } });
+	IconvLiteEncoderStream.prototype._transform = function(chunk, encoding, done) {
+		if (typeof chunk != "string") return done(/* @__PURE__ */ new Error("Iconv encoding stream needs strings as its input."));
+		try {
+			var res = this.conv.write(chunk);
+			if (res && res.length) this.push(res);
+			done();
+		} catch (e) {
+			done(e);
+		}
+	};
+	IconvLiteEncoderStream.prototype._flush = function(done) {
+		try {
+			var res = this.conv.end();
+			if (res && res.length) this.push(res);
+			done();
+		} catch (e) {
+			done(e);
+		}
+	};
+	IconvLiteEncoderStream.prototype.collect = function(cb) {
+		var chunks = [];
+		this.on("error", cb);
+		this.on("data", function(chunk) {
+			chunks.push(chunk);
+		});
+		this.on("end", function() {
+			cb(null, Buffer.concat(chunks));
+		});
+		return this;
+	};
+	function IconvLiteDecoderStream(conv, options) {
+		this.conv = conv;
+		options = options || {};
+		options.encoding = this.encoding = "utf8";
+		Transform.call(this, options);
+	}
+	IconvLiteDecoderStream.prototype = Object.create(Transform.prototype, { constructor: { value: IconvLiteDecoderStream } });
+	IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) {
+		if (!Buffer.isBuffer(chunk)) return done(/* @__PURE__ */ new Error("Iconv decoding stream needs buffers as its input."));
+		try {
+			var res = this.conv.write(chunk);
+			if (res && res.length) this.push(res, this.encoding);
+			done();
+		} catch (e) {
+			done(e);
+		}
+	};
+	IconvLiteDecoderStream.prototype._flush = function(done) {
+		try {
+			var res = this.conv.end();
+			if (res && res.length) this.push(res, this.encoding);
+			done();
+		} catch (e) {
+			done(e);
+		}
+	};
+	IconvLiteDecoderStream.prototype.collect = function(cb) {
+		var res = "";
+		this.on("error", cb);
+		this.on("data", function(chunk) {
+			res += chunk;
+		});
+		this.on("end", function() {
+			cb(null, res);
+		});
+		return this;
+	};
+}));
+//#endregion
+export default require_streams();
+export { require_streams };

package/dist/deps/.pnpm/safer-buffer@2.1.2/deps/safer-buffer/safer.js

@@ -0,0 +1,45 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/safer-buffer@2.1.2/node_modules/safer-buffer/safer.js
+var require_safer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var buffer = __require("buffer");
+	var Buffer = buffer.Buffer;
+	var safer = {};
+	var key;
+	for (key in buffer) {
+		if (!buffer.hasOwnProperty(key)) continue;
+		if (key === "SlowBuffer" || key === "Buffer") continue;
+		safer[key] = buffer[key];
+	}
+	var Safer = safer.Buffer = {};
+	for (key in Buffer) {
+		if (!Buffer.hasOwnProperty(key)) continue;
+		if (key === "allocUnsafe" || key === "allocUnsafeSlow") continue;
+		Safer[key] = Buffer[key];
+	}
+	safer.Buffer.prototype = Buffer.prototype;
+	if (!Safer.from || Safer.from === Uint8Array.from) Safer.from = function(value, encodingOrOffset, length) {
+		if (typeof value === "number") throw new TypeError("The \"value\" argument must not be of type number. Received type " + typeof value);
+		if (value && typeof value.length === "undefined") throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+		return Buffer(value, encodingOrOffset, length);
+	};
+	if (!Safer.alloc) Safer.alloc = function(size, fill, encoding) {
+		if (typeof size !== "number") throw new TypeError("The \"size\" argument must be of type number. Received type " + typeof size);
+		if (size < 0 || size >= 2 * (1 << 30)) throw new RangeError("The value \"" + size + "\" is invalid for option \"size\"");
+		var buf = Buffer(size);
+		if (!fill || fill.length === 0) buf.fill(0);
+		else if (typeof encoding === "string") buf.fill(fill, encoding);
+		else buf.fill(fill);
+		return buf;
+	};
+	if (!safer.kStringMaxLength) try {
+		safer.kStringMaxLength = process.binding("buffer").kStringMaxLength;
+	} catch (e) {}
+	if (!safer.constants) {
+		safer.constants = { MAX_LENGTH: safer.kMaxLength };
+		if (safer.kStringMaxLength) safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
+	}
+	module.exports = safer;
+}));
+//#endregion
+export default require_safer();
+export { require_safer };

package/dist/entries/app-rsc-entry.js

@@ -389,9 +389,9 @@ const __requestHandler = createAppRscRequestHandler({
   publicFiles: new Set(${JSON.stringify(config?.publicFiles ?? [])}),
   registerCacheAdapters: __registerConfiguredCacheAdapters,
   renderNotFound: async () => null,
-  ${hasPagesDir ? `async renderPagesFallback({ allowRscDocumentFallback, appRouteMatch, dispatchPagesResponseStage, initialResponseHeaders, isDataRequest, isRscRequest, matchKind, middlewareContext, pathname, pagesDataRequest, request, url }) {
+  ${hasPagesDir ? `async renderPagesFallback({ allowRscDocumentFallback, appRouteMatch, dispatchPagesResponseStage, initialResponseHeaders, isDataRequest, isRscRequest, matchKind, middlewareContext, pathname, pagesDataRequest, request, sharedAcrossHosts, url }) {
     return __renderPagesFallback(
-      { allowRscDocumentFallback, appRouteMatch, initialResponseHeaders, isDataRequest, isRscRequest, matchKind, middlewareContext, pathname, pagesDataRequest, request, url },
+      { allowRscDocumentFallback, appRouteMatch, initialResponseHeaders, isDataRequest, isRscRequest, matchKind, middlewareContext, pathname, pagesDataRequest, request, sharedAcrossHosts, url },
       {
         async loadPagesEntry() {
           if (!dispatchPagesResponseStage) {
@@ -401,8 +401,8 @@ const __requestHandler = createAppRscRequestHandler({
             ...__pagesRequestEntry,
             handleApiRoute(stageRequest) { return dispatchPagesResponseStage(stageRequest, "api"); },
             renderPage(stageRequest, pagesUrl) {
-              const dataKind = __pagesRequestEntry.matchPageRoute?.(pagesUrl, stageRequest)?.route.dataKind;
-              return dispatchPagesResponseStage(stageRequest, "page", dataKind, __pagesRequestEntry.hasRequestAwareDocument);
+              const route = __pagesRequestEntry.matchPageRoute?.(pagesUrl, stageRequest)?.route;
+              return dispatchPagesResponseStage(stageRequest, "page", route?.dataKind, __pagesRequestEntry.hasRequestAwareDocument, route?.runsInitialProps === true);
             },
           };
         },
@@ -611,7 +611,7 @@ import {
   AppElementsWire as __AppElementsWire,
 } from ${JSON.stringify(appElementsPath)};
 import {
-  probeAppPageLayoutWithTracking as __probeAppPageLayoutWithTracking,
+  probeAppPageLayout as __probeAppPageLayout,
   resolveAppPageChildSegments as __resolveAppPageChildSegments,
 } from ${JSON.stringify(appPageRouteWiringPath)};
 import { buildPageElements as __buildPageElements } from ${JSON.stringify(appPageElementBuilderPath)};
@@ -697,16 +697,6 @@ const __isrDebug = process.env.NEXT_PRIVATE_DEBUG_CACHE
   ? console.debug.bind(console, "[vinext] ISR:")
   : undefined;
 
-// Classification debug — opt in with VINEXT_DEBUG_CLASSIFICATION=1. Gated on
-// the env var so the hot path pays no overhead unless an operator is actively
-// tracing why a layout was flagged static or dynamic. The reason payload is
-// carried by __VINEXT_CLASS_REASONS and consumed inside probeAppPageLayouts.
-const __classDebug = process.env.VINEXT_DEBUG_CLASSIFICATION
-  ? function(layoutId, reason) {
-      console.debug("[vinext] CLS:", layoutId, reason);
-    }
-  : undefined;
-
 function __resolveRouteFetchCacheMode(route) {
   return __resolveAppPageFetchCacheMode({
     layouts: route.layouts,
@@ -826,24 +816,6 @@ ${instrumentationPath ? `// Lazy instrumentation initialisation is handled by en
 // the user module in; all bookkeeping (initialized flag, shared promise, prerender
 // skip) lives in the typed helper so it can be unit-tested independently.` : ""}
 
-// Build-time layout classification dispatch. Replaced in renderChunk
-// with a switch statement that returns a pre-computed per-layout
-// Map<layoutIndex, "static" | "dynamic"> for each route. Until the
-// plugin patches this stub, every route falls back to the Layer 3
-// runtime probe, which is the current (slow) behaviour.
-function __VINEXT_CLASS(routeIdx) {
-  return null;
-}
-
-// Build-time layout classification reasons dispatch. Sibling of
-// __VINEXT_CLASS, returning a per-route Map<layoutIndex, ClassificationReason>
-// that feeds the debug channel when VINEXT_DEBUG_CLASSIFICATION is active.
-// Replaced in renderChunk with a real dispatch table; the stub returns
-// null so the hot path never allocates reason maps when debug is off.
-function __VINEXT_CLASS_REASONS(routeIdx) {
-  return null;
-}
-
 const routes = [
 ${routeEntries.join(",\n")}
 ];
@@ -962,7 +934,7 @@ function hasInterceptionId(interceptionId) {
   return __routeMatcher.hasInterceptionId(interceptionId);
 }
 
-async function buildPageElements(route, params, routePath, pageRequest, layoutParamAccess, displayPathname = routePath, scriptNonce) {
+async function buildPageElements(route, params, routePath, pageRequest, displayPathname = routePath, scriptNonce) {
   // Hydrate lazy page/route-handler modules before any synchronous read.
   await __ensureRouteLoaded(route);
   return __buildPageElements({
@@ -977,7 +949,6 @@ async function buildPageElements(route, params, routePath, pageRequest, layoutPa
     rootForbiddenModule: ${rootForbiddenVar ? rootForbiddenVar : "null"},
     rootUnauthorizedModule: ${rootUnauthorizedVar ? rootUnauthorizedVar : "null"},
     metadataRoutes,
-    layoutParamAccess,
     basePath: __basePath,
     trailingSlash: __trailingSlash,
     htmlLimitedBots: __htmlLimitedBots,
@@ -1087,7 +1058,6 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
   dispatchMatchedPage({
     bypassInterceptionContextCache,
     cachePathname,
-    clientReuseManifest,
     cleanPathname,
     displayPathname,
     formState,
@@ -1142,7 +1112,7 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
       ensureRouteLoaded: __ensureRouteLoaded,
       clientTraceMetadata: __clientTraceMetadata,
       reactMaxHeadersLength: __reactMaxHeadersLength,
-      buildPageElement(targetRoute, targetParams, targetOpts, targetSearchParams, layoutParamAccess, buildOptions) {
+      buildPageElement(targetRoute, targetParams, targetOpts, targetSearchParams, buildOptions) {
         return buildPageElements(targetRoute, targetParams, cleanPathname, {
           opts: targetOpts,
           searchParams: targetSearchParams,
@@ -1154,13 +1124,13 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
           observePageSearchParamsAccess: buildOptions?.observePageSearchParamsAccess === true,
           isForceStatic: buildOptions?.isForceStatic === true,
           isUncacheableRender: buildOptions?.isUncacheableRender === true,
+          mountedLayouts: buildOptions?.mountedLayouts ?? null,
           serveStreamingMetadata: buildOptions?.serveStreamingMetadata,
           placeStreamedMetadataInHead: buildOptions?.placeStreamedMetadataInHead === true,
           isProduction: process.env.NODE_ENV === "production",
           onHeadPrepared: buildOptions?.onHeadPrepared,
-        }, layoutParamAccess, displayPathname, scriptNonce);
+        }, displayPathname, scriptNonce);
       },
-      clientReuseManifest,
       cleanPathname,
       displayPathname,
       clearRequestContext() {
@@ -1169,7 +1139,6 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
       createRscOnErrorHandler(pathname, routePath, overrides) {
         return createRscOnErrorHandler(request, pathname, routePath, overrides);
       },
-      debugClassification: __classDebug,
       draftModeSecret: __draftModeSecret,
       dynamicConfig: __segmentConfig.dynamicConfig,
       dynamicStaleTimeSeconds: __segmentConfig.dynamicStaleTimeSeconds,
@@ -1236,10 +1205,9 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
       skipStaticParamsValidation,
       staticParamsValidationParams,
       rootParams,
-      probeLayoutAt(li, layoutParamAccess) {
-        return __probeAppPageLayoutWithTracking({
+      probeLayoutAt(li) {
+        return __probeAppPageLayout({
           layoutIndex: li,
-          layoutParamAccess,
           makeThenableParams,
           matchedParams: params,
           route,
@@ -1426,6 +1394,7 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
         );
       },
       hasPageRoute: __hasPageRoute,
+      currentRoute: routeMatch?.route ?? null,
       maxActionBodySize: __MAX_ACTION_BODY_SIZE,
       middlewareHeaders: middlewareContext.headers,
       readFormDataWithLimit: __readFormDataWithLimit,
@@ -1515,7 +1484,7 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
           observeMetadataSearchParamsAccess: observeMetadataSearchParamsAccess === true,
           observePageSearchParamsAccess: observePageSearchParamsAccess === true,
           isForceStatic: isForceStatic === true,
-        }, undefined, actionCleanPathname, targetScriptNonce ?? scriptNonce);
+        }, actionCleanPathname, targetScriptNonce ?? scriptNonce);
       },
       cleanPathname,
       clearRequestContext() {
@@ -1704,9 +1673,9 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
     const __isEdge = route ? __isEdgeRuntime(__resolveRouteRuntime(route)) : false;
     return __fallbackRenderer.renderNotFound(route, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, { isEdgeRuntime: __isEdge });
   },
-  ${hasPagesDir ? `async renderPagesFallback({ allowRscDocumentFallback, appRouteMatch, dispatchPagesResponseStage, initialResponseHeaders, isDataRequest, isRscRequest, matchKind, middlewareContext, pathname, pagesDataRequest, request, url }) {
+  ${hasPagesDir ? `async renderPagesFallback({ allowRscDocumentFallback, appRouteMatch, dispatchPagesResponseStage, initialResponseHeaders, isDataRequest, isRscRequest, matchKind, middlewareContext, pathname, pagesDataRequest, request, sharedAcrossHosts, url }) {
     return __renderPagesFallback(
-      { allowRscDocumentFallback, appRouteMatch, initialResponseHeaders, isDataRequest, isRscRequest, matchKind, middlewareContext, pathname, pagesDataRequest, request, url },
+      { allowRscDocumentFallback, appRouteMatch, initialResponseHeaders, isDataRequest, isRscRequest, matchKind, middlewareContext, pathname, pagesDataRequest, request, sharedAcrossHosts, url },
       {
         async loadPagesEntry() {
           const __pagesEntry = await __ensureHybridPagesApplication();
@@ -1725,8 +1694,8 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
             ...(typeof __pagesEntry.renderPage === "function"
               ? {
                   renderPage(stageRequest, pagesUrl) {
-                    const dataKind = __pagesEntry.matchPageRoute?.(pagesUrl, stageRequest)?.route.dataKind;
-                    return dispatchPagesResponseStage(stageRequest, "page", dataKind, __pagesEntry.hasRequestAwareDocument);
+                    const route = __pagesEntry.matchPageRoute?.(pagesUrl, stageRequest)?.route;
+                    return dispatchPagesResponseStage(stageRequest, "page", route?.dataKind, __pagesEntry.hasRequestAwareDocument, route?.runsInitialProps === true);
                   },
                 }
               : {}),

package/dist/entries/app-rsc-manifest.js

@@ -1,5 +1,5 @@
 import { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { computeAppRouteStaticSiblings, convertSegmentsToRouteParts } from "../routing/app-route-graph.js";
+import { computeAppRouteStaticSiblings, convertSegmentsToRouteParts, findSlotPageTreePosition } from "../routing/app-route-graph.js";
 import { appRouteHasMainTreeLoadingBoundary, appRouteLayoutStaticParamsGroups } from "../routing/app-router.js";
 import { createMetadataRouteEntriesSource } from "../server/metadata-route-build-data.js";
 //#region src/entries/app-rsc-manifest.ts
@@ -140,7 +140,7 @@ function lazyLoaderArray(filePaths, imports) {
 	return `[${filePaths.map((filePath) => filePath ? imports.getLazyLoaderVar(filePath) : "null").join(", ")}]`;
 }
 function buildRouteEntries(routes, imports) {
-	return routes.map((route, routeIdx) => {
+	return routes.map((route) => {
 		const staticSiblings = route.isDynamic ? computeAppRouteStaticSiblings(routes, route) : [];
 		const layoutLoaders = lazyLoaderArray(route.layouts, imports);
 		const templateLoaders = lazyLoaderArray(route.templates, imports);
@@ -232,6 +232,7 @@ function buildRouteEntries(routes, imports) {
         configLayouts: ${moduleArray(slot.configLayoutPaths?.length ?? 0)},
         __loadConfigLayouts: ${lazyLoaderArray(slot.configLayoutPaths ?? [], imports)},
         configLayoutTreePositions: ${JSON.stringify(slot.configLayoutTreePositions ?? [])},
+        pageTreePosition: ${findSlotPageTreePosition(slot) ?? "null"},
         loading: null,
         __loadLoading: ${slot.loadingPath ? imports.getLazyLoaderVar(slot.loadingPath) : "null"},
         loadings: ${moduleArray(slot.loadingPaths?.length ?? 0)},
@@ -264,8 +265,6 @@ ${interceptEntries.join(",\n")}
 		const loadPageField = route.pagePath ? imports.getLazyLoaderVar(route.pagePath) : "null";
 		const loadRouteHandlerField = route.routePath ? imports.getLazyLoaderVar(route.routePath) : "null";
 		return `  {
-    __buildTimeClassifications: __VINEXT_CLASS(${routeIdx}), // evaluated once at module load
-    __buildTimeReasons: __classDebug ? __VINEXT_CLASS_REASONS(${routeIdx}) : null,
     canUseCanonicalLoadingShell: ${appRouteHasMainTreeLoadingBoundary(route)},
     ids: ${JSON.stringify(route.ids ?? null)},
     pattern: ${JSON.stringify(route.pattern)},

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

@@ -26,6 +26,7 @@ export default withNitroPublicFiles(ssrEntry);
 ${hasPagesDir ? `
 export {
   __ensureInstrumentation,
+  getRuntimePageDataKind,
   handleApiRoute,
   matchApiRoute,
   matchPageRoute,