vinext 0.0.54 → 0.1.0

package/dist/server/dev-stack-sourcemap.js

@@ -0,0 +1,443 @@
+import { VINEXT_ORIGINAL_STACK_TRACE_ENDPOINT } from "./dev-stack-sourcemap-endpoint.js";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/server/dev-stack-sourcemap.ts
+const MAX_ORIGINAL_STACK_TRACE_BODY_BYTES = 1024 * 1024;
+const V8_PAREN_STACK_LINE = /^(\s*at\s+.*?\()(.+):(\d+):(\d+)(\)\s*)$/;
+const V8_BARE_STACK_LINE = /^(\s*at\s+)(.+):(\d+):(\d+)(\s*)$/;
+const MOZ_STACK_LINE = /^([^@\n]*@)(.+):(\d+):(\d+)(\s*)$/;
+var RequestBodyTooLargeError = class extends Error {};
+const BASE64_VLQ_VALUES = Object.create(null);
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("").forEach((char, index) => {
+	BASE64_VLQ_VALUES[char] = index;
+});
+function installDevStackSourcemapMiddleware(server) {
+	server.middlewares.use((req, res, next) => {
+		if (!isOriginalStackTraceRequest(req)) {
+			next();
+			return;
+		}
+		handleOriginalStackTraceRequest(server, req, res).catch(() => {
+			if (!res.headersSent) writeJson(res, 500, { error: "Internal Server Error" });
+		});
+	});
+}
+function isOriginalStackTraceRequest(req) {
+	return new URL(req.url ?? "/", "http://vinext.local").pathname === VINEXT_ORIGINAL_STACK_TRACE_ENDPOINT;
+}
+async function handleOriginalStackTraceRequest(server, req, res) {
+	if (req.method !== "POST") {
+		writeJson(res, 405, { error: "Method Not Allowed" });
+		return;
+	}
+	try {
+		const payload = parseStackTraceRequestBody(await readRequestBody(req));
+		if (!payload) {
+			writeJson(res, 400, { error: "Bad Request" });
+			return;
+		}
+		writeJson(res, 200, await resolveDevServerStackTrace(server, payload.stack, getDevStackSourcemapRequestHost(req.headers)));
+	} catch (error) {
+		if (error instanceof RequestBodyTooLargeError) {
+			writeJson(res, 413, { error: "Payload Too Large" });
+			return;
+		}
+		writeJson(res, 500, { error: "Internal Server Error" });
+	}
+}
+function parseStackTraceRequestBody(body) {
+	try {
+		const payload = JSON.parse(body);
+		return typeof payload.stack === "string" ? { stack: payload.stack } : null;
+	} catch {
+		return null;
+	}
+}
+async function readRequestBody(req) {
+	return await new Promise((resolve, reject) => {
+		let body = "";
+		let bytes = 0;
+		let settled = false;
+		req.setEncoding("utf8");
+		req.on("data", (chunk) => {
+			bytes += Buffer.byteLength(chunk, "utf8");
+			if (bytes > MAX_ORIGINAL_STACK_TRACE_BODY_BYTES) {
+				settled = true;
+				reject(new RequestBodyTooLargeError());
+				req.destroy();
+				return;
+			}
+			body += chunk;
+		});
+		req.on("end", () => {
+			if (settled) return;
+			settled = true;
+			resolve(body);
+		});
+		req.on("error", (error) => {
+			if (settled) return;
+			settled = true;
+			reject(error);
+		});
+	});
+}
+function writeJson(res, statusCode, payload) {
+	res.writeHead(statusCode, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(payload));
+}
+function getDevStackSourcemapRequestHost(headers) {
+	return normalizeRequestHost(headers["x-forwarded-host"]) ?? normalizeRequestHost(headers.host);
+}
+function normalizeRequestHost(value) {
+	return (Array.isArray(value) ? value[0] : value)?.split(",")[0]?.trim().toLowerCase() || void 0;
+}
+async function resolveDevServerStackTrace(server, stack, requestHost) {
+	const sourceMapCache = /* @__PURE__ */ new Map();
+	const mapped = await Promise.all(stack.split("\n").map((line) => mapStackLineWithMetadata(server, line, requestHost, sourceMapCache)));
+	const codeFrame = mapped.find((line) => line.isFrame && !line.ignored && line.codeFrame)?.codeFrame;
+	const projectRoot = normalizeProjectRoot(server.config?.root);
+	return {
+		stack: mapped.map((line) => line.line).join("\n"),
+		ignoredFrames: createIgnoredFramesForOverlay(mapped),
+		...projectRoot ? { projectRoot } : {},
+		...codeFrame ? { codeFrame } : {}
+	};
+}
+async function mapStackLine(server, line, requestHost, sourceMapCache) {
+	return (await mapStackLineWithMetadata(server, line, requestHost, sourceMapCache)).line;
+}
+async function mapStackLineWithMetadata(server, line, requestHost, sourceMapCache) {
+	const v8Paren = line.match(V8_PAREN_STACK_LINE);
+	if (v8Paren) {
+		const methodName = extractV8ParenMethodName(v8Paren[1]);
+		const mapped = await mapGeneratedFrame(server, v8Paren[2], v8Paren[3], v8Paren[4], methodName, requestHost, sourceMapCache);
+		return {
+			line: mapped ? `${v8Paren[1]}${mapped.file}:${mapped.line}:${mapped.column}${v8Paren[5]}` : line,
+			isFrame: true,
+			ignored: mapped?.ignored ?? isIgnoreListedGeneratedFrame(v8Paren[2], requestHost),
+			...mapped?.codeFrame ? { codeFrame: mapped.codeFrame } : {}
+		};
+	}
+	const v8Bare = line.match(V8_BARE_STACK_LINE);
+	if (v8Bare) {
+		const mapped = await mapGeneratedFrame(server, v8Bare[2], v8Bare[3], v8Bare[4], void 0, requestHost, sourceMapCache);
+		return {
+			line: mapped ? `${v8Bare[1]}${mapped.file}:${mapped.line}:${mapped.column}${v8Bare[5]}` : line,
+			isFrame: true,
+			ignored: mapped?.ignored ?? isIgnoreListedGeneratedFrame(v8Bare[2], requestHost),
+			...mapped?.codeFrame ? { codeFrame: mapped.codeFrame } : {}
+		};
+	}
+	const moz = line.match(MOZ_STACK_LINE);
+	if (moz) {
+		const mapped = await mapGeneratedFrame(server, moz[2], moz[3], moz[4], moz[1].replace(/@$/, "") || void 0, requestHost, sourceMapCache);
+		return {
+			line: mapped ? `${moz[1]}${mapped.file}:${mapped.line}:${mapped.column}${moz[5]}` : line,
+			isFrame: true,
+			ignored: mapped?.ignored ?? isIgnoreListedGeneratedFrame(moz[2], requestHost),
+			...mapped?.codeFrame ? { codeFrame: mapped.codeFrame } : {}
+		};
+	}
+	return {
+		line,
+		isFrame: false,
+		ignored: false
+	};
+}
+function createIgnoredFramesForOverlay(mapped) {
+	const firstNonEmptyLineIndex = mapped.findIndex((line) => line.line.trim() !== "");
+	const firstLineIsMessage = mapped.reduce((count, line) => count + (line.line.trim() !== "" ? 1 : 0), 0) > 1 && firstNonEmptyLineIndex !== -1 && !mapped[firstNonEmptyLineIndex]?.isFrame;
+	return mapped.flatMap((line, index) => {
+		if (line.line.trim() === "") return [];
+		if (firstLineIsMessage && index === firstNonEmptyLineIndex) return [];
+		return [line.isFrame ? line.ignored : false];
+	});
+}
+async function mapGeneratedFrame(server, file, line, column, methodName, requestHost, sourceMapCache) {
+	const generatedFrame = getMappableGeneratedFrame(server, file, requestHost);
+	if (!generatedFrame) return null;
+	const generatedLine = Number(line);
+	const generatedColumn = Number(column);
+	if (!Number.isFinite(generatedLine) || !Number.isFinite(generatedColumn)) return null;
+	const sourceMap = await getSourceMapForGeneratedFrame(generatedFrame, sourceMapCache);
+	if (!sourceMap) return null;
+	const original = traceOriginalPositionFor(sourceMap, generatedLine, generatedColumn);
+	if (!original) return null;
+	const originalFile = resolveSourceFile(original.source, sourceMap, generatedFrame.sourceMapBaseUrl);
+	const codeFrame = await createStackCodeFrame({
+		file: originalFile,
+		line: original.line,
+		column: original.column,
+		methodName,
+		sourceContent: sourceMap.sourcesContent?.[original.sourceIndex] ?? null
+	});
+	return {
+		file: originalFile,
+		line: original.line,
+		column: original.column,
+		ignored: isSourceMapIgnored(sourceMap, original.sourceIndex) || isIgnoreListedOriginalFrame(original.source) || isIgnoreListedOriginalFrame(originalFile) || isIgnoreListedGeneratedFrame(file, requestHost),
+		...codeFrame ? { codeFrame } : {}
+	};
+}
+function extractV8ParenMethodName(prefix) {
+	return prefix.replace(/^\s*at\s+/, "").replace(/\($/, "").trim() || void 0;
+}
+function normalizeProjectRoot(root) {
+	if (!root) return void 0;
+	return root.replaceAll("\\", "/").replace(/\/+$/, "") || (root.startsWith("/") ? "/" : void 0);
+}
+function stripTrailingSlash(value) {
+	return value?.replace(/[\\/]+$/, "");
+}
+function stripQuery(value) {
+	return value.split(/[?#]/, 1)[0] ?? value;
+}
+function getMappableGeneratedFrame(server, file, requestHost) {
+	const normalizedFile = devirtualizeReactServerFrame(file);
+	const localPath = getLocalSourcePath(server, normalizedFile);
+	if (localPath) return {
+		cacheKey: `server:${localPath}`,
+		sourceMapBaseUrl: pathToFileURL(localPath),
+		transform: () => loadServerSourceMapForLocalPath(server, localPath)
+	};
+	if (isWindowsAbsolutePath(normalizedFile)) return null;
+	const generatedUrl = getMappableClientGeneratedUrl(normalizedFile, requestHost);
+	if (!generatedUrl) return null;
+	const viteUrl = generatedUrl.pathname + generatedUrl.search;
+	return {
+		cacheKey: `client:${viteUrl}`,
+		sourceMapBaseUrl: generatedUrl,
+		transform: () => loadClientSourceMapForGeneratedUrl(server, viteUrl)
+	};
+}
+function devirtualizeReactServerFrame(file) {
+	if (!file.startsWith("about://React/")) return file;
+	const envIdx = file.indexOf("/", 14);
+	const suffixIdx = file.lastIndexOf("?");
+	if (envIdx === -1 || suffixIdx === -1 || suffixIdx <= envIdx) return file;
+	return file.slice(envIdx + 1, suffixIdx);
+}
+function getLocalSourcePath(server, file) {
+	let localPath = file;
+	if (file.startsWith("file://")) try {
+		localPath = fileURLToPath(file);
+	} catch {
+		return null;
+	}
+	localPath = stripQuery(localPath);
+	if (!isAbsolutePath(localPath)) return null;
+	const localPathForCompare = normalizeLocalPathForCompare(localPath);
+	if (localPathForCompare.includes("/node_modules/")) return null;
+	const root = server.config?.root;
+	if (!root) return null;
+	const rootForCompare = normalizeLocalPathForCompare(root);
+	return localPathForCompare === rootForCompare || localPathForCompare.startsWith(`${rootForCompare}/`) ? localPath : null;
+}
+function isAbsolutePath(value) {
+	return value.startsWith("/") || isWindowsAbsolutePath(value);
+}
+function isWindowsAbsolutePath(value) {
+	return /^[A-Za-z]:[\\/]/.test(value);
+}
+function normalizeLocalPathForCompare(value) {
+	const normalized = (stripTrailingSlash(value.replaceAll("\\", "/")) ?? "").replace(/\/+/g, "/");
+	return /^[A-Za-z]:\//.test(normalized) ? normalized.toLowerCase() : normalized;
+}
+function normalizeIgnoreListPath(value) {
+	let path = devirtualizeReactServerFrame(value);
+	if (path.startsWith("file://")) try {
+		path = fileURLToPath(path);
+	} catch {}
+	else try {
+		const url = new URL(path);
+		if (url.protocol === "http:" || url.protocol === "https:") path = `${url.pathname}${url.search}`;
+	} catch {}
+	try {
+		path = decodeURIComponent(path);
+	} catch {}
+	return path.replaceAll("\\", "/").toLowerCase();
+}
+function isExternalHttpFrame(file, requestHost) {
+	if (!/^https?:\/\//i.test(file) || !requestHost) return false;
+	try {
+		return new URL(file).host.toLowerCase() !== requestHost;
+	} catch {
+		return false;
+	}
+}
+function isIgnoreListedGeneratedFrame(file, requestHost) {
+	const normalized = normalizeIgnoreListPath(file);
+	return isExternalHttpFrame(file, requestHost) || normalized.startsWith("node:") || normalized.includes("/node_modules/") || normalized.includes("/.vite/") || normalized.includes("/@vite/") || normalized.includes("/@react-refresh") || normalized.includes("/__vite") || normalized.includes("virtual:vinext") || normalized.includes("/packages/vinext/src/") || normalized.includes("/packages/vinext/dist/") || normalized.includes("/vinext/server/");
+}
+function isIgnoreListedOriginalFrame(file) {
+	const normalized = normalizeIgnoreListPath(file);
+	return normalized.startsWith("node:") || normalized.includes("/node_modules/") || normalized.includes("/packages/vinext/src/") || normalized.includes("/packages/vinext/dist/") || normalized.includes("/vinext/server/");
+}
+function isSourceMapIgnored(sourceMap, sourceIndex) {
+	return sourceMap.ignoreList?.includes(sourceIndex) ?? false;
+}
+async function createStackCodeFrame({ file, line, column, methodName, sourceContent }) {
+	const source = sourceContent ?? await readSourceFileForCodeFrame(file);
+	if (!source) return null;
+	const sourceLines = source.split(/\r\n|\r|\n/);
+	if (line < 1 || line > sourceLines.length) return null;
+	const start = Math.max(1, line - 2);
+	const end = Math.min(sourceLines.length, line + 3);
+	const lines = [];
+	for (let currentLine = start; currentLine <= end; currentLine++) lines.push({
+		line: currentLine,
+		text: sourceLines[currentLine - 1] ?? "",
+		isErrorLine: currentLine === line
+	});
+	return {
+		file,
+		line,
+		column,
+		...methodName ? { methodName } : {},
+		lines
+	};
+}
+async function readSourceFileForCodeFrame(file) {
+	if (!file.startsWith("file://")) return null;
+	try {
+		return await readFile(fileURLToPath(file), "utf8");
+	} catch {
+		return null;
+	}
+}
+function getMappableClientGeneratedUrl(file, requestHost) {
+	const isAbsoluteHttpUrl = /^https?:\/\//i.test(file);
+	let url;
+	try {
+		url = new URL(file, "http://vinext.local");
+	} catch {
+		return null;
+	}
+	if (isAbsoluteHttpUrl && requestHost && url.host !== requestHost) return null;
+	if (url.pathname.includes("/node_modules/")) return null;
+	return url;
+}
+async function getSourceMapForGeneratedFrame(generatedFrame, cache) {
+	let sourceMap = cache.get(generatedFrame.cacheKey);
+	if (!sourceMap) {
+		sourceMap = generatedFrame.transform();
+		cache.set(generatedFrame.cacheKey, sourceMap);
+	}
+	return sourceMap;
+}
+async function loadClientSourceMapForGeneratedUrl(server, viteUrl) {
+	try {
+		return normalizeSourceMapPayload((await server.environments.client.transformRequest(viteUrl))?.map);
+	} catch {
+		return null;
+	}
+}
+async function loadServerSourceMapForLocalPath(server, localPath) {
+	for (const environmentName of ["rsc", "ssr"]) {
+		const environment = server.environments[environmentName];
+		if (!environment) continue;
+		try {
+			const sourceMap = normalizeSourceMapPayload((await environment.transformRequest(localPath))?.map);
+			if (sourceMap) return sourceMap;
+		} catch {}
+	}
+	return null;
+}
+function normalizeSourceMapPayload(payload) {
+	if (!payload || typeof payload !== "object") return null;
+	const map = payload;
+	if (!Array.isArray(map.sources) || typeof map.mappings !== "string" || map.mappings === "") return null;
+	if (!map.sources.every((source) => typeof source === "string")) return null;
+	const ignoreList = normalizeIgnoreList(map.ignoreList) ?? normalizeIgnoreList(map.x_google_ignoreList);
+	return {
+		version: typeof map.version === "number" ? map.version : void 0,
+		sources: map.sources,
+		sourcesContent: normalizeSourcesContent(map.sourcesContent),
+		sourceRoot: typeof map.sourceRoot === "string" ? map.sourceRoot : void 0,
+		mappings: map.mappings,
+		ignoreList
+	};
+}
+function normalizeSourcesContent(value) {
+	if (!Array.isArray(value)) return void 0;
+	const sourcesContent = value.map((source) => typeof source === "string" ? source : null);
+	return sourcesContent.length > 0 ? sourcesContent : void 0;
+}
+function normalizeIgnoreList(value) {
+	if (!Array.isArray(value)) return void 0;
+	const ignoreList = value.filter((index) => Number.isInteger(index) && index >= 0);
+	return ignoreList.length > 0 ? ignoreList : void 0;
+}
+function originalPositionFor(sourceMap, generatedLine, generatedColumn) {
+	const original = traceOriginalPositionFor(sourceMap, generatedLine, generatedColumn);
+	if (!original) return null;
+	return {
+		source: original.source,
+		line: original.line,
+		column: original.column
+	};
+}
+function traceOriginalPositionFor(sourceMap, generatedLine, generatedColumn) {
+	const targetLineIndex = generatedLine - 1;
+	const targetColumn = Math.max(0, generatedColumn - 1);
+	if (targetLineIndex < 0) return null;
+	let sourceIndex = 0;
+	let originalLine = 0;
+	let originalColumn = 0;
+	const generatedLines = sourceMap.mappings.split(";");
+	for (let generatedLineIndex = 0; generatedLineIndex <= targetLineIndex; generatedLineIndex++) {
+		const generatedSegments = generatedLines[generatedLineIndex];
+		if (generatedSegments === void 0) return null;
+		let generatedSegmentColumn = 0;
+		let bestMatch = null;
+		for (const segment of generatedSegments.split(",")) {
+			if (!segment) continue;
+			const decoded = decodeVlqSegment(segment);
+			if (decoded.length === 0) continue;
+			generatedSegmentColumn += decoded[0] ?? 0;
+			if (decoded.length >= 4) {
+				sourceIndex += decoded[1] ?? 0;
+				originalLine += decoded[2] ?? 0;
+				originalColumn += decoded[3] ?? 0;
+			}
+			if (generatedLineIndex !== targetLineIndex) continue;
+			if (generatedSegmentColumn > targetColumn) break;
+			bestMatch = decoded.length >= 4 && sourceMap.sources[sourceIndex] ? {
+				source: sourceMap.sources[sourceIndex],
+				sourceIndex,
+				line: originalLine + 1,
+				column: originalColumn + 1
+			} : null;
+		}
+		if (generatedLineIndex === targetLineIndex) return bestMatch;
+	}
+	return null;
+}
+function decodeVlqSegment(segment) {
+	const values = [];
+	let value = 0;
+	let shift = 0;
+	for (const char of segment) {
+		const integer = BASE64_VLQ_VALUES[char];
+		if (integer === void 0) return [];
+		value += (integer & 31) << shift;
+		if (integer & 32) {
+			shift += 5;
+			continue;
+		}
+		values.push(value & 1 ? -(value >> 1) : value >> 1);
+		value = 0;
+		shift = 0;
+	}
+	return values;
+}
+function resolveSourceFile(source, sourceMap, generatedUrl) {
+	const rootedSource = sourceMap.sourceRoot ? `${sourceMap.sourceRoot.replace(/\/?$/, "/")}${source}` : source;
+	try {
+		return new URL(rootedSource, generatedUrl.href).href;
+	} catch {
+		return source;
+	}
+}
+//#endregion
+export { VINEXT_ORIGINAL_STACK_TRACE_ENDPOINT, decodeVlqSegment, installDevStackSourcemapMiddleware, mapStackLine, mapStackLineWithMetadata, originalPositionFor, resolveSourceFile };

package/dist/server/document-initial-head.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+
+//#region src/server/document-initial-head.d.ts
+declare function callDocumentGetInitialProps(DocumentComponent: React.ComponentType | null | undefined, setDocumentInitialHead: ((head: React.ReactNode[]) => void) | undefined): Promise<void>;
+//#endregion
+export { callDocumentGetInitialProps };

package/dist/server/document-initial-head.js

@@ -0,0 +1,33 @@
+import Document from "../shims/document.js";
+//#region src/server/document-initial-head.ts
+/**
+* Reference to the unmodified `Document.getInitialProps` static. Used to
+* detect when a user `_document.tsx` did NOT override the method (i.e. they
+* extend `Document` but only redefine `render`), so we can skip the call.
+*
+* Captured via an indexed access (`Document["getInitialProps"]`) rather than
+* a dotted access so oxlint's `unbound-method` rule doesn't flag this as a
+* possible `this` escape — `getInitialProps` is a static method with no
+* `this` dependency, so capturing the function reference is safe.
+*/
+const DEFAULT_GET_INITIAL_PROPS = Document["getInitialProps"];
+async function callDocumentGetInitialProps(DocumentComponent, setDocumentInitialHead) {
+	if (!DocumentComponent || !setDocumentInitialHead) return;
+	const getInitialProps = DocumentComponent.getInitialProps;
+	if (typeof getInitialProps !== "function" || getInitialProps === DEFAULT_GET_INITIAL_PROPS) return;
+	try {
+		const initialProps = await getInitialProps({
+			defaultGetInitialProps: async () => ({
+				html: "",
+				head: [],
+				styles: void 0
+			}),
+			renderPage: () => ({ html: "" })
+		});
+		setDocumentInitialHead(Array.isArray(initialProps?.head) ? initialProps.head : []);
+	} catch (err) {
+		console.error("[vinext] _document.getInitialProps() threw:", err);
+	}
+}
+//#endregion
+export { callDocumentGetInitialProps };

package/dist/server/edge-api-runtime.d.ts

@@ -1,5 +1,4 @@
 //#region src/server/edge-api-runtime.d.ts
 declare function isEdgeApiRuntime(runtime: string | undefined): boolean;
 //#endregion
-export { isEdgeApiRuntime };
-//# sourceMappingURL=edge-api-runtime.d.ts.map
+export { isEdgeApiRuntime };

package/dist/server/edge-api-runtime.js

@@ -4,5 +4,3 @@ function isEdgeApiRuntime(runtime) {
 }
 //#endregion
 export { isEdgeApiRuntime };
-
-//# sourceMappingURL=edge-api-runtime.js.map

package/dist/server/file-based-metadata.d.ts

@@ -26,5 +26,4 @@ type FileBasedMetadataOptions = {
 };
 declare function applyFileBasedMetadata(metadata: Metadata | null, routePath: string, params: AppPageParams, metadataRoutes: readonly MetadataFileRoute[] | null | undefined, options?: FileBasedMetadataOptions): Promise<Metadata | null>;
 //#endregion
-export { applyFileBasedMetadata };
-//# sourceMappingURL=file-based-metadata.d.ts.map
+export { applyFileBasedMetadata };

package/dist/server/file-based-metadata.js

@@ -399,5 +399,3 @@ async function applyFileBasedMetadata(metadata, routePath, params, metadataRoute
 }
 //#endregion
 export { applyFileBasedMetadata };
-
-//# sourceMappingURL=file-based-metadata.js.map

package/dist/server/headers.d.ts

@@ -31,6 +31,8 @@ declare const VINEXT_RSC_MARKER_HEADER = "x-vinext-rsc";
 declare const VINEXT_PARAMS_HEADER = "X-Vinext-Params";
 /** Deduplicated, sorted list of mounted layout slots for cache keying. */
 declare const VINEXT_MOUNTED_SLOTS_HEADER = "X-Vinext-Mounted-Slots";
+/** Per-page dynamic stale time in seconds for App Router RSC responses. */
+declare const VINEXT_DYNAMIC_STALE_TIME_HEADER = "X-Vinext-Dynamic-Stale-Time";
 /** Route interception context for parallel/intercepting routes. */
 declare const VINEXT_INTERCEPTION_CONTEXT_HEADER = "X-Vinext-Interception-Context";
 /** RSC render mode (e.g. "navigation", "prefetch"). */
@@ -98,5 +100,4 @@ declare const INTERNAL_HEADERS: string[];
 /** Vinext-only internal headers stripped alongside Next.js protocol internals. */
 declare const VINEXT_INTERNAL_HEADERS: string[];
 //#endregion
-export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXT_ACTION_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_STATIC_FILE_HEADER, VINEXT_TIMING_HEADER };
-//# sourceMappingURL=headers.d.ts.map
+export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXT_ACTION_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_STATIC_FILE_HEADER, VINEXT_TIMING_HEADER };

package/dist/server/headers.js

@@ -31,6 +31,8 @@ const VINEXT_RSC_MARKER_HEADER = "x-vinext-rsc";
 const VINEXT_PARAMS_HEADER = "X-Vinext-Params";
 /** Deduplicated, sorted list of mounted layout slots for cache keying. */
 const VINEXT_MOUNTED_SLOTS_HEADER = "X-Vinext-Mounted-Slots";
+/** Per-page dynamic stale time in seconds for App Router RSC responses. */
+const VINEXT_DYNAMIC_STALE_TIME_HEADER = "X-Vinext-Dynamic-Stale-Time";
 /** Route interception context for parallel/intercepting routes. */
 const VINEXT_INTERCEPTION_CONTEXT_HEADER = "X-Vinext-Interception-Context";
 /** RSC render mode (e.g. "navigation", "prefetch"). */
@@ -120,6 +122,4 @@ const INTERNAL_HEADERS = [
 /** Vinext-only internal headers stripped alongside Next.js protocol internals. */
 const VINEXT_INTERNAL_HEADERS = [VINEXT_PRERENDER_ROUTE_PARAMS_HEADER];
 //#endregion
-export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXT_ACTION_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_STATIC_FILE_HEADER, VINEXT_TIMING_HEADER };
-
-//# sourceMappingURL=headers.js.map
+export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXT_ACTION_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_STATIC_FILE_HEADER, VINEXT_TIMING_HEADER };

package/dist/server/html.d.ts

@@ -25,5 +25,4 @@ declare function htmlTokenListContains(value: string | null, token: string): boo
 declare function createNonceAttribute(nonce?: string): string;
 declare function createInlineScriptTag(content: string, nonce?: string): string;
 //#endregion
-export { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, htmlTokenListContains, safeJsonStringify };
-//# sourceMappingURL=html.d.ts.map
+export { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, htmlTokenListContains, safeJsonStringify };

package/dist/server/html.js

@@ -39,5 +39,3 @@ function createInlineScriptTag(content, nonce) {
 }
 //#endregion
 export { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, htmlTokenListContains, safeJsonStringify };
-
-//# sourceMappingURL=html.js.map

package/dist/server/http-error-responses.d.ts

@@ -88,5 +88,4 @@ declare function payloadTooLargeResponse(): Response;
  */
 declare function internalServerErrorResponse(message?: string, init?: ErrorResponseInit): Response;
 //#endregion
-export { badRequestResponse, forbiddenResponse, internalServerErrorResponse, methodNotAllowedResponse, notFoundResponse, notFoundStaticAssetResponse, payloadTooLargeResponse };
-//# sourceMappingURL=http-error-responses.d.ts.map
+export { badRequestResponse, forbiddenResponse, internalServerErrorResponse, methodNotAllowedResponse, notFoundResponse, notFoundStaticAssetResponse, payloadTooLargeResponse };

package/dist/server/http-error-responses.js

@@ -103,5 +103,3 @@ function internalServerErrorResponse(message, init) {
 }
 //#endregion
 export { badRequestResponse, forbiddenResponse, internalServerErrorResponse, methodNotAllowedResponse, notFoundResponse, notFoundStaticAssetResponse, payloadTooLargeResponse };
-
-//# sourceMappingURL=http-error-responses.js.map

package/dist/server/image-optimization.d.ts

@@ -113,5 +113,4 @@ type ImageHandlers = {
  */
 declare function handleImageOptimization(request: Request, handlers: ImageHandlers, allowedWidths?: number[], imageConfig?: ImageConfig): Promise<Response>;
 //#endregion
-export { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_CACHE_CONTROL, IMAGE_CONTENT_SECURITY_POLICY, IMAGE_OPTIMIZATION_PATH, ImageConfig, ImageHandlers, VINEXT_IMAGE_OPTIMIZATION_PATH, handleImageOptimization, isImageOptimizationPath, isSafeImageContentType, negotiateImageFormat, parseImageParams };
-//# sourceMappingURL=image-optimization.d.ts.map
+export { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_CACHE_CONTROL, IMAGE_CONTENT_SECURITY_POLICY, IMAGE_OPTIMIZATION_PATH, ImageConfig, ImageHandlers, VINEXT_IMAGE_OPTIMIZATION_PATH, handleImageOptimization, isImageOptimizationPath, isSafeImageContentType, negotiateImageFormat, parseImageParams };

package/dist/server/image-optimization.js

@@ -213,5 +213,3 @@ async function handleImageOptimization(request, handlers, allowedWidths, imageCo
 }
 //#endregion
 export { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_CACHE_CONTROL, IMAGE_CONTENT_SECURITY_POLICY, IMAGE_OPTIMIZATION_PATH, VINEXT_IMAGE_OPTIMIZATION_PATH, handleImageOptimization, isImageOptimizationPath, isSafeImageContentType, negotiateImageFormat, parseImageParams };
-
-//# sourceMappingURL=image-optimization.js.map

package/dist/server/implicit-tags.d.ts

@@ -2,5 +2,4 @@
 type AppCacheLeafKind = "page" | "route";
 declare function buildPageCacheTags(pathname: string, extraTags: string[], routeSegments: string[], leafKind: AppCacheLeafKind): string[];
 //#endregion
-export { buildPageCacheTags };
-//# sourceMappingURL=implicit-tags.d.ts.map
+export { buildPageCacheTags };

package/dist/server/implicit-tags.js

@@ -39,5 +39,3 @@ function buildPageCacheTags(pathname, extraTags, routeSegments, leafKind) {
 }
 //#endregion
 export { buildPageCacheTags };
-
-//# sourceMappingURL=implicit-tags.js.map

package/dist/server/instrumentation-runtime.d.ts

@@ -40,5 +40,4 @@
  */
 declare function ensureInstrumentationRegistered(instrumentationModule: Record<string, unknown>): Promise<void>;
 //#endregion
-export { ensureInstrumentationRegistered };
-//# sourceMappingURL=instrumentation-runtime.d.ts.map
+export { ensureInstrumentationRegistered };

package/dist/server/instrumentation-runtime.js

@@ -25,5 +25,3 @@ async function ensureInstrumentationRegistered(instrumentationModule) {
 }
 //#endregion
 export { ensureInstrumentationRegistered };
-
-//# sourceMappingURL=instrumentation-runtime.js.map

package/dist/server/instrumentation.d.ts

@@ -82,5 +82,4 @@ declare function reportRequestError(error: Error, request: {
   headers: Record<string, string>;
 }, context: OnRequestErrorContext): Promise<void>;
 //#endregion
-export { ModuleImporter, OnRequestErrorContext, OnRequestErrorHandler, findInstrumentationClientFile, findInstrumentationFile, getOnRequestErrorHandler, importModule, reportRequestError, runInstrumentation };
-//# sourceMappingURL=instrumentation.d.ts.map
+export { ModuleImporter, OnRequestErrorContext, OnRequestErrorHandler, findInstrumentationClientFile, findInstrumentationFile, getOnRequestErrorHandler, importModule, reportRequestError, runInstrumentation };

package/dist/server/instrumentation.js

@@ -128,5 +128,3 @@ function reportRequestError(error, request, context) {
 }
 //#endregion
 export { findInstrumentationClientFile, findInstrumentationFile, getOnRequestErrorHandler, importModule, reportRequestError, runInstrumentation };
-
-//# sourceMappingURL=instrumentation.js.map