vinext 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/server/middleware-path-to-regexp.js

@@ -0,0 +1,228 @@
+//#region src/server/middleware-path-to-regexp.ts
+function lexer(value) {
+	const tokens = [];
+	let index = 0;
+	while (index < value.length) {
+		const character = value[index];
+		if (character === "*" || character === "+" || character === "?") {
+			tokens.push({
+				type: "MODIFIER",
+				index,
+				value: value[index++]
+			});
+			continue;
+		}
+		if (character === "\\") {
+			tokens.push({
+				type: "ESCAPED_CHAR",
+				index: index++,
+				value: value[index++]
+			});
+			continue;
+		}
+		if (character === "{") {
+			tokens.push({
+				type: "OPEN",
+				index,
+				value: value[index++]
+			});
+			continue;
+		}
+		if (character === "}") {
+			tokens.push({
+				type: "CLOSE",
+				index,
+				value: value[index++]
+			});
+			continue;
+		}
+		if (character === ":") {
+			let name = "";
+			let nameEnd = index + 1;
+			while (nameEnd < value.length) {
+				const code = value.charCodeAt(nameEnd);
+				if (code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95) {
+					name += value[nameEnd++];
+					continue;
+				}
+				break;
+			}
+			if (!name) throw new TypeError(`Missing parameter name at ${index}`);
+			tokens.push({
+				type: "NAME",
+				index,
+				value: name
+			});
+			index = nameEnd;
+			continue;
+		}
+		if (character === "(") {
+			let depth = 1;
+			let pattern = "";
+			let patternEnd = index + 1;
+			if (value[patternEnd] === "?") throw new TypeError(`Pattern cannot start with "?" at ${patternEnd}`);
+			while (patternEnd < value.length) {
+				if (value[patternEnd] === "\\") {
+					pattern += value[patternEnd++] + value[patternEnd++];
+					continue;
+				}
+				if (value[patternEnd] === ")") {
+					depth--;
+					if (depth === 0) {
+						patternEnd++;
+						break;
+					}
+				} else if (value[patternEnd] === "(") {
+					depth++;
+					if (value[patternEnd + 1] !== "?") throw new TypeError(`Capturing groups are not allowed at ${patternEnd}`);
+				}
+				pattern += value[patternEnd++];
+			}
+			if (depth) throw new TypeError(`Unbalanced pattern at ${index}`);
+			if (!pattern) throw new TypeError(`Missing pattern at ${index}`);
+			tokens.push({
+				type: "PATTERN",
+				index,
+				value: pattern
+			});
+			index = patternEnd;
+			continue;
+		}
+		tokens.push({
+			type: "CHAR",
+			index,
+			value: value[index++]
+		});
+	}
+	tokens.push({
+		type: "END",
+		index,
+		value: ""
+	});
+	return tokens;
+}
+function parseMiddlewarePath(value) {
+	const tokens = lexer(value);
+	const result = [];
+	const prefixes = "./";
+	const delimiter = "/#?";
+	let key = 0;
+	let index = 0;
+	let path = "";
+	const tryConsume = (type) => {
+		if (index < tokens.length && tokens[index].type === type) return tokens[index++].value;
+	};
+	const mustConsume = (type) => {
+		const consumed = tryConsume(type);
+		if (consumed !== void 0) return consumed;
+		const next = tokens[index];
+		throw new TypeError(`Unexpected ${next.type} at ${next.index}, expected ${type}`);
+	};
+	const consumeText = () => {
+		let text = "";
+		let consumed;
+		while ((consumed = tryConsume("CHAR") ?? tryConsume("ESCAPED_CHAR")) !== void 0) text += consumed;
+		return text;
+	};
+	const containsDelimiter = (text) => {
+		for (const character of delimiter) if (text.includes(character)) return true;
+		return false;
+	};
+	const defaultPattern = (prefix) => {
+		const previous = result[result.length - 1];
+		const previousText = prefix || (typeof previous === "string" ? previous : "");
+		if (previous && !previousText) {
+			const name = typeof previous === "string" ? previous : previous.name;
+			throw new TypeError(`Must have text between two parameters, missing text after "${name}"`);
+		}
+		if (!previousText || containsDelimiter(previousText)) return "[^\\/#\\?]+?";
+		return `(?:(?!${escapeRegex(previousText)})[^\\/#\\?])+?`;
+	};
+	while (index < tokens.length) {
+		const character = tryConsume("CHAR");
+		const name = tryConsume("NAME");
+		const pattern = tryConsume("PATTERN");
+		if (name !== void 0 || pattern !== void 0) {
+			let prefix = character ?? "";
+			if (!prefixes.includes(prefix)) {
+				path += prefix;
+				prefix = "";
+			}
+			if (path) {
+				result.push(path);
+				path = "";
+			}
+			result.push({
+				name: name ?? key++,
+				prefix,
+				suffix: "",
+				pattern: pattern ?? defaultPattern(prefix),
+				modifier: tryConsume("MODIFIER") ?? ""
+			});
+			continue;
+		}
+		const text = character ?? tryConsume("ESCAPED_CHAR");
+		if (text !== void 0) {
+			path += text;
+			continue;
+		}
+		if (path) {
+			result.push(path);
+			path = "";
+		}
+		if (tryConsume("OPEN") !== void 0) {
+			const prefix = consumeText();
+			const groupName = tryConsume("NAME") ?? "";
+			const groupPattern = tryConsume("PATTERN") ?? "";
+			const suffix = consumeText();
+			mustConsume("CLOSE");
+			result.push({
+				name: groupName || (groupPattern ? key++ : ""),
+				pattern: groupName && !groupPattern ? defaultPattern(prefix) : groupPattern,
+				prefix,
+				suffix,
+				modifier: tryConsume("MODIFIER") ?? ""
+			});
+			continue;
+		}
+		mustConsume("END");
+	}
+	return result;
+}
+function escapeRegex(value) {
+	return value.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+}
+function normalizeMiddlewarePathTokens(tokens) {
+	return tokens.map((token) => {
+		if (typeof token === "object" && (token.modifier === "*" || token.modifier === "+") && token.prefix === "" && token.suffix === "") return {
+			...token,
+			prefix: "/"
+		};
+		return token;
+	});
+}
+function middlewarePathTokensToRegExp(tokens) {
+	const delimiterRegex = `[${escapeRegex("/#?")}]`;
+	let route = "^";
+	for (const token of tokens) {
+		if (typeof token === "string") {
+			route += escapeRegex(token);
+			continue;
+		}
+		const prefix = escapeRegex(token.prefix);
+		const suffix = escapeRegex(token.suffix);
+		if (token.pattern) if (prefix || suffix) if (token.modifier === "+" || token.modifier === "*") {
+			const optional = token.modifier === "*" ? "?" : "";
+			route += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${optional}`;
+		} else route += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`;
+		else {
+			if (token.modifier === "+" || token.modifier === "*") throw new TypeError(`Can not repeat "${token.name}" without a prefix and suffix`);
+			route += `(${token.pattern})${token.modifier}`;
+		}
+		else route += `(?:${prefix}${suffix})${token.modifier}`;
+	}
+	route += `${delimiterRegex}?$`;
+	return new RegExp(route, "i");
+}
+//#endregion
+export { middlewarePathTokensToRegExp, normalizeMiddlewarePathTokens, parseMiddlewarePath };

package/dist/server/middleware-response-headers.js

@@ -1,5 +1,5 @@
 //#region src/server/middleware-response-headers.ts
-const ADDITIVE_RESPONSE_HEADER_NAMES = new Set(["set-cookie", "vary"]);
+const ADDITIVE_RESPONSE_HEADER_NAMES = /* @__PURE__ */ new Set(["set-cookie", "vary"]);
 function mergeVaryHeader(target, value) {
 	const existing = target.get("Vary");
 	const tokens = (existing ? `${existing}, ${value}` : value).split(",").map((token) => token.trim()).filter((token) => token.length > 0);

package/dist/server/middleware-runtime.js

@@ -1,3 +1,4 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
 import "./server-globals.js";
@@ -10,7 +11,6 @@ import { normalizePath } from "./normalize-path.js";
 import { matchesMiddleware } from "./middleware-matcher.js";
 import { badRequestResponse, internalServerErrorResponse } from "./http-error-responses.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
-import path from "node:path";
 //#region src/server/middleware-runtime.ts
 function isMiddlewareHandler(value) {
 	return typeof value === "function";
@@ -112,10 +112,11 @@ function resolveMiddlewarePathname(request) {
 		return badRequestResponse();
 	}
 }
-function createNextRequest(request, normalizedPathname, i18nConfig, basePath, trailingSlash, hadBasePath) {
+function createNextRequest(request, i18nConfig, basePath, trailingSlash, hadBasePath) {
 	const url = new URL(request.url);
 	let mwRequest = request.body && !request.bodyUsed ? request.clone() : request;
-	const mwPathname = basePath && hadBasePath ? addBasePathToPathname(normalizedPathname, basePath) : normalizedPathname;
+	const requestPathname = url.pathname;
+	const mwPathname = basePath && hadBasePath && !hasBasePath(requestPathname, basePath) ? addBasePathToPathname(requestPathname, basePath) : requestPathname;
 	if (mwPathname !== url.pathname) {
 		const mwUrl = new URL(url);
 		mwUrl.pathname = mwPathname;
@@ -141,7 +142,7 @@ async function executeMiddleware(options) {
 	const hadBasePath = options.hadBasePath ?? (!options.basePath || hasBasePath(new URL(options.request.url).pathname, options.basePath));
 	const matchPathname = options.basePath ? stripBasePath(normalizedPathname, options.basePath) : normalizedPathname;
 	if (!matchesMiddleware(matchPathname, middlewareMatcher(options.module), options.request, options.i18nConfig)) return { continue: true };
-	const nextRequest = createNextRequest(options.request, normalizedPathname, options.i18nConfig, options.basePath, options.trailingSlash, hadBasePath);
+	const nextRequest = createNextRequest(options.request, options.i18nConfig, options.basePath, options.trailingSlash, hadBasePath);
 	if (options.isDataRequest) Object.defineProperty(nextRequest, "__isData", {
 		enumerable: false,
 		value: true

package/dist/server/middleware.d.ts

@@ -1,5 +1,6 @@
 import { NextI18nConfig } from "../config/next-config.js";
 import { ValidFileMatcher } from "../routing/file-matcher.js";
+import { NextFetchEvent, NextRequest } from "../shims/server.js";
 import { MiddlewareModule, MiddlewareResult } from "./middleware-runtime.js";
 import { matchPattern, matchesMiddleware } from "./middleware-matcher.js";
 import { ModuleRunner } from "vite/module-runner";
@@ -57,6 +58,6 @@ declare function findMiddlewareFile(root: string, fileMatcher: ValidFileMatcher,
  * @param request - The incoming Request object
  * @returns Middleware result describing what action to take
  */
-declare function runMiddleware(runner: ModuleRunner, middlewarePath: string, request: Request, i18nConfig?: NextI18nConfig | null, basePath?: string, trailingSlash?: boolean, isDataRequest?: boolean): Promise<MiddlewareResult>;
+declare function runMiddleware(runner: ModuleRunner, middlewarePath: string, request: Request, i18nConfig?: NextI18nConfig | null, basePath?: string, trailingSlash?: boolean, isDataRequest?: boolean, normalizedPathname?: string): Promise<MiddlewareResult>;
 //#endregion
 export { findMiddlewareFile, isProxyFile, matchPattern, matchesMiddleware, resolveMiddlewareHandler, runMiddleware };

package/dist/server/middleware.js

@@ -1,7 +1,7 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { matchPattern, matchesMiddleware } from "./middleware-matcher.js";
 import { resolveMiddlewareModuleHandler, runGeneratedMiddleware } from "./middleware-runtime.js";
 import fs from "node:fs";
-import path from "node:path";
 //#region src/server/middleware.ts
 /**
 * Determine whether a middleware/proxy file path refers to a proxy file.
@@ -94,7 +94,7 @@ function isMiddlewareModule(value) {
 * @param request - The incoming Request object
 * @returns Middleware result describing what action to take
 */
-async function runMiddleware(runner, middlewarePath, request, i18nConfig, basePath, trailingSlash, isDataRequest) {
+async function runMiddleware(runner, middlewarePath, request, i18nConfig, basePath, trailingSlash, isDataRequest, normalizedPathname) {
 	const mod = await runner.import(middlewarePath);
 	if (!isMiddlewareModule(mod)) throw new Error(`Middleware module "${middlewarePath}" did not evaluate to an object.`);
 	return runGeneratedMiddleware({
@@ -106,6 +106,7 @@ async function runMiddleware(runner, middlewarePath, request, i18nConfig, basePa
 		isDataRequest,
 		isProxy: isProxyFile(middlewarePath),
 		module: mod,
+		normalizedPathname,
 		request,
 		trailingSlash
 	});

package/dist/server/navigation-planner.d.ts

@@ -121,6 +121,7 @@ type RscFetchResultFacts = {
   compatibilityIdHeader: string | null;
   responseUrl: string | null;
   streamedRedirectTarget: string | null;
+  streamedRedirectType?: "push" | "replace" | null;
 };
 type RscRedirectFollow = {
   href: string;
@@ -142,6 +143,7 @@ type RscFetchResultDecision = {
   kind: "hardNavigate";
   discardBody: boolean;
   url: string;
+  hardNavigationMode?: "assign" | "replace";
   reason: RscFetchResultHardNavReason;
   trace: NavigationTrace;
 };

package/dist/server/navigation-planner.js

@@ -8,6 +8,9 @@ import { resolveRscRedirectLifecycleHop, resolveStreamedRscRedirectLifecycleHop
 import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
 import { verifyOperationTokenForCacheReuse } from "./operation-token.js";
 //#region src/server/navigation-planner.ts
+function mergeRscRedirectHistoryMode(navigationMode, redirectType) {
+	return navigationMode === "push" || redirectType === "push" ? "push" : "replace";
+}
 const ROUTE_INTERCEPTION_CONTEXT_SEPARATOR = "\0";
 const CACHE_ENTRY_PROOF_MISSING_CODE = "CP_CACHE_ENTRY_PROOF_MISSING";
 function createRequestWorkDecision(options) {
@@ -41,6 +44,7 @@ function createRscFetchResultHardNavigationDecision(options) {
 	return {
 		discardBody: options.discardBody,
 		kind: "hardNavigate",
+		...options.hardNavigationMode !== void 0 ? { hardNavigationMode: options.hardNavigationMode } : {},
 		reason: options.reason,
 		trace: createNavigationTrace(options.reasonCode, createRscFetchResultTraceFields(options.facts, {
 			...options.redirectSignal !== void 0 ? { redirectSignal: options.redirectSignal } : {},
@@ -133,9 +137,10 @@ function classifyRscFetchResult(facts) {
 		});
 	}
 	if (facts.streamedRedirectTarget !== null) {
+		const streamedHistoryMode = mergeRscRedirectHistoryMode(facts.effectiveHistoryUpdateMode, facts.streamedRedirectType);
 		const redirectDecision = resolveStreamedRscRedirectLifecycleHop({
 			currentHref: facts.currentHref,
-			historyUpdateMode: facts.effectiveHistoryUpdateMode,
+			historyUpdateMode: streamedHistoryMode,
 			origin: facts.origin,
 			redirectDepth: facts.redirectDepth,
 			requestPreviousNextUrl: facts.requestPreviousNextUrl,
@@ -149,6 +154,7 @@ function classifyRscFetchResult(facts) {
 				reason: terminalReason.hardNavigationReason,
 				reasonCode: terminalReason.traceReasonCode,
 				redirectSignal: "streamed-header",
+				hardNavigationMode: streamedHistoryMode === "push" ? "assign" : "replace",
 				url: redirectDecision.href
 			});
 		}
@@ -157,7 +163,7 @@ function classifyRscFetchResult(facts) {
 			facts,
 			redirect: {
 				href: redirectDecision.href,
-				historyUpdateMode: facts.effectiveHistoryUpdateMode,
+				historyUpdateMode: streamedHistoryMode,
 				previousNextUrl: redirectDecision.previousNextUrl,
 				redirectDepth: redirectDecision.redirectDepth
 			},

package/dist/server/next-error-digest.d.ts

@@ -1,23 +1,7 @@
+import { RedirectDigest } from "../utils/redirect-digest.js";
+
 //#region src/server/next-error-digest.d.ts
-/**
- * Helpers for parsing Next.js error `digest` strings shared across the App
- * Router execution paths (server actions, page renders, route handlers).
- *
- * Next.js encodes special control flow as thrown errors carrying a `digest`
- * field with one of these formats:
- *  - `NEXT_REDIRECT;<type>;<encodedUrl>;<status>` — `redirect()` / `permanentRedirect()`
- *  - `NEXT_NOT_FOUND` — `notFound()`
- *  - `NEXT_HTTP_ERROR_FALLBACK;<status>` — `forbidden()` / `unauthorized()` / etc.
- *
- * Each call site needs slightly different post-processing (URL resolution
- * against the request, 303-vs-307 status overrides for actions, etc.), so
- * these helpers only handle the parsing — callers shape the result.
- */
-type NextRedirectDigest = {
-  status: number;
-  type: string | null;
-  url: string;
-};
+type NextRedirectDigest = RedirectDigest;
 type NextHttpErrorDigest = {
   status: number;
 };
@@ -27,11 +11,12 @@ type NextHttpErrorDigest = {
  */
 declare function getNextErrorDigest(error: unknown): string | null;
 /**
- * Parses a `NEXT_REDIRECT;<type>;<encodedUrl>;<status>` digest. Returns null
- * when the digest is not a redirect digest or the encoded URL segment is
- * missing. The `url` is decoded with `decodeURIComponent`; the `status`
- * defaults to 307 when omitted; an omitted `type` is left as null so the
- * caller can apply the correct context-sensitive default.
+ * Parses redirect digests from vinext's encoded three-part form and Next.js's
+ * raw, semicolon-terminated form. Returns null when the digest is not a
+ * redirect digest. Vinext's encoded URL is decoded with `decodeURIComponent`;
+ * Next.js's canonical raw URL is preserved verbatim. The `status` defaults to
+ * 307 when omitted; an omitted `type` is left as null so the caller can apply
+ * the correct context-sensitive default.
  */
 declare function parseNextRedirectDigest(digest: string): NextRedirectDigest | null;
 /**

package/dist/server/next-error-digest.js

@@ -1,5 +1,21 @@
+import { parseRedirectDigest } from "../utils/redirect-digest.js";
 //#region src/server/next-error-digest.ts
 /**
+* Helpers for parsing Next.js error `digest` strings shared across the App
+* Router execution paths (server actions, page renders, route handlers).
+*
+* Special control flow is encoded as thrown errors carrying a `digest` field.
+* Redirect digests may appear as vinext's encoded three-part form or Next.js's
+* raw, semicolon-terminated form:
+*  - `NEXT_REDIRECT;<type>;<url>[;<status>[;]]` — `redirect()` / `permanentRedirect()`
+*  - `NEXT_NOT_FOUND` — `notFound()`
+*  - `NEXT_HTTP_ERROR_FALLBACK;<status>` — `forbidden()` / `unauthorized()` / etc.
+*
+* Each call site needs slightly different post-processing (URL resolution
+* against the request, 303-vs-307 status overrides for actions, etc.), so
+* these helpers only handle the parsing — callers shape the result.
+*/
+/**
 * Pulls a stringified `digest` off an unknown thrown value, or returns null
 * when the value is not a digest-bearing error.
 */
@@ -8,23 +24,15 @@ function getNextErrorDigest(error) {
 	return String(error.digest);
 }
 /**
-* Parses a `NEXT_REDIRECT;<type>;<encodedUrl>;<status>` digest. Returns null
-* when the digest is not a redirect digest or the encoded URL segment is
-* missing. The `url` is decoded with `decodeURIComponent`; the `status`
-* defaults to 307 when omitted; an omitted `type` is left as null so the
-* caller can apply the correct context-sensitive default.
+* Parses redirect digests from vinext's encoded three-part form and Next.js's
+* raw, semicolon-terminated form. Returns null when the digest is not a
+* redirect digest. Vinext's encoded URL is decoded with `decodeURIComponent`;
+* Next.js's canonical raw URL is preserved verbatim. The `status` defaults to
+* 307 when omitted; an omitted `type` is left as null so the caller can apply
+* the correct context-sensitive default.
 */
 function parseNextRedirectDigest(digest) {
-	if (!digest.startsWith("NEXT_REDIRECT;")) return null;
-	const parts = digest.split(";");
-	const encodedUrl = parts[2];
-	if (!encodedUrl) return null;
-	const type = parts[1];
-	return {
-		status: parts[3] ? parseInt(parts[3], 10) : 307,
-		type: type || null,
-		url: decodeURIComponent(encodedUrl)
-	};
+	return parseRedirectDigest(digest);
 }
 /**
 * Parses a `NEXT_NOT_FOUND` or `NEXT_HTTP_ERROR_FALLBACK;<status>` digest.

package/dist/server/operation-token.js

@@ -41,7 +41,7 @@ function evaluateDimension(dimension, token, authority) {
 }
 function verifyOperationToken(token, authority, policy) {
 	const required = new Set(policy.require);
-	const evaluated = new Set([...policy.check, ...policy.require]);
+	const evaluated = /* @__PURE__ */ new Set([...policy.check, ...policy.require]);
 	for (const dimension of DIMENSION_ORDER) {
 		if (!evaluated.has(dimension)) continue;
 		const status = evaluateDimension(dimension, token, authority);

package/dist/server/pages-body-parser-config.js

@@ -49,7 +49,8 @@ function parseSizeLimit(value) {
 	if (!match) return void 0;
 	const amount = Number.parseFloat(match[1]);
 	if (!Number.isFinite(amount) || amount < 0) return void 0;
-	const multiplier = SIZE_UNITS[match[2] ?? "b"];
+	const unit = match[2] ?? "b";
+	const multiplier = SIZE_UNITS[unit];
 	if (multiplier === void 0) return void 0;
 	return Math.floor(amount * multiplier);
 }

package/dist/server/pages-data-route.d.ts

@@ -34,6 +34,16 @@ type NextDataMatch = {
  * even when the buildId is wrong (so we can still return a 404 JSON response).
  */
 declare function isNextDataPathname(pathname: string): boolean;
+/**
+ * WHATWG URL parsing removes TAB, LF, and CR characters. Reject paths where
+ * that normalization would manufacture the internal Pages data namespace.
+ */
+declare function urlParserCreatesPagesDataPath(pathname: string): boolean;
+/**
+ * Keep URL-parser-ignored characters encoded until route matching decodes the
+ * captured parameter. Passing them literally to `new URL()` would remove them.
+ */
+declare function encodeUrlParserIgnoredCharacters(pathname: string): string;
 /**
  * Parse `/_next/data/<buildId>/<...page>.json` and return the normalized page
  * pathname. Returns `null` if the pathname does not match the pattern or if
@@ -120,4 +130,4 @@ type NormalizePagesDataRequestResult = {
  */
 declare function normalizePagesDataRequest(request: Request, buildId: string | null, basePath?: string, trailingSlash?: boolean): NormalizePagesDataRequestResult;
 //#endregion
-export { buildMiddlewarePrefetchSkipResponse, buildNextDataJsonResponse, buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, isNextDataPathname, normalizeNextDataPagePathname, normalizePagesDataRequest, parseNextDataPathname };
+export { buildMiddlewarePrefetchSkipResponse, buildNextDataJsonResponse, buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, encodeUrlParserIgnoredCharacters, isNextDataPathname, normalizeNextDataPagePathname, normalizePagesDataRequest, parseNextDataPathname, urlParserCreatesPagesDataPath };

package/dist/server/pages-data-route.js

@@ -32,6 +32,21 @@ function isNextDataPathname(pathname) {
 	return pathname.startsWith(NEXT_DATA_PREFIX) && pathname.endsWith(NEXT_DATA_SUFFIX);
 }
 /**
+* WHATWG URL parsing removes TAB, LF, and CR characters. Reject paths where
+* that normalization would manufacture the internal Pages data namespace.
+*/
+function urlParserCreatesPagesDataPath(pathname) {
+	const parsedPathname = pathname.replaceAll("	", "").replaceAll("\n", "").replaceAll("\r", "");
+	return pathname !== parsedPathname && !isNextDataPathname(pathname) && isNextDataPathname(parsedPathname);
+}
+/**
+* Keep URL-parser-ignored characters encoded until route matching decodes the
+* captured parameter. Passing them literally to `new URL()` would remove them.
+*/
+function encodeUrlParserIgnoredCharacters(pathname) {
+	return pathname.replaceAll("	", "%09").replaceAll("\n", "%0A").replaceAll("\r", "%0D");
+}
+/**
 * Parse `/_next/data/<buildId>/<...page>.json` and return the normalized page
 * pathname. Returns `null` if the pathname does not match the pattern or if
 * the buildId segment does not match the server's buildId.
@@ -168,4 +183,4 @@ function normalizePagesDataRequest(request, buildId, basePath = "", trailingSlas
 	};
 }
 //#endregion
-export { buildMiddlewarePrefetchSkipResponse, buildNextDataJsonResponse, buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, isNextDataPathname, normalizeNextDataPagePathname, normalizePagesDataRequest, parseNextDataPathname };
+export { buildMiddlewarePrefetchSkipResponse, buildNextDataJsonResponse, buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, encodeUrlParserIgnoredCharacters, isNextDataPathname, normalizeNextDataPagePathname, normalizePagesDataRequest, parseNextDataPathname, urlParserCreatesPagesDataPath };

package/dist/server/pages-dev-hydration.d.ts

@@ -0,0 +1,14 @@
+//#region src/server/pages-dev-hydration.d.ts
+type PagesDevHydrationOptions = {
+  appModuleSource: string | null;
+  forceRouterReady?: boolean;
+  normalizePageProps?: boolean;
+  pageModuleSource: string;
+  reactStrictMode: boolean;
+  replaceFallbackRoute?: boolean;
+  scriptNonce?: string;
+  setPagePatternsFromNextData?: boolean;
+};
+declare function createPagesDevHydrationScript(options: PagesDevHydrationOptions): string;
+//#endregion
+export { PagesDevHydrationOptions, createPagesDevHydrationScript };

package/dist/server/pages-dev-hydration.js

@@ -0,0 +1,83 @@
+import { createNonceAttribute } from "./html.js";
+//#region src/server/pages-dev-hydration.ts
+function createPagesDevHydrationScript(options) {
+	const nonceAttr = createNonceAttribute(options.scriptNonce);
+	const initializeRouter = options.forceRouterReady ? "_initializePagesRouterReadyFromNextData(nextData, true);" : "_initializePagesRouterReadyFromNextData(nextData);";
+	const pagePatterns = options.setPagePatternsFromNextData ? "window.__VINEXT_PAGE_PATTERNS__ = [nextData.page];" : "";
+	const pageProps = options.normalizePageProps === false ? "const pageProps = rawPageProps ?? {};" : "const pageProps = rawPageProps && typeof rawPageProps === \"object\" ? rawPageProps : {};";
+	const fallbackReplacement = options.replaceFallbackRoute ? `
+  if (nextData.isFallback) {
+    await Router.replace(window.location.pathname + window.location.search + window.location.hash, undefined, { _h: 1, scroll: false });
+  }` : "";
+	const createElement = options.appModuleSource ? `
+  const appModule = await import(${JSON.stringify(options.appModuleSource)});
+  const AppComponent = appModule.default;
+  window.__VINEXT_APP__ = AppComponent;
+  const appRouter = ${options.forceRouterReady ? "{ ...Router, isReady: true }" : "Router"};
+  element = React.createElement(AppComponent, {
+    ...props,
+    Component: PageComponent,
+    pageProps: rawPageProps,
+    router: appRouter,
+  });
+  ` : `
+  element = React.createElement(PageComponent, pageProps);
+  `;
+	return `
+<script type="module"${nonceAttr}>
+import "vinext/instrumentation-client";
+import React from "react";
+import { hydrateRoot } from "react-dom/client";
+import Router, { wrapWithRouterContext, _initializePagesRouterReadyFromNextData } from "next/router";
+
+const nextDataElement = document.getElementById("__NEXT_DATA__");
+if (nextDataElement?.textContent) {
+  window.__NEXT_DATA__ = JSON.parse(nextDataElement.textContent);
+  window.__VINEXT_LOCALE__ = window.__NEXT_DATA__.locale;
+  window.__VINEXT_LOCALES__ = window.__NEXT_DATA__.locales;
+  window.__VINEXT_DEFAULT_LOCALE__ = window.__NEXT_DATA__.defaultLocale;
+}
+const nextData = window.__NEXT_DATA__;
+${initializeRouter}
+const props = nextData.props && typeof nextData.props === "object" ? nextData.props : {};
+const rawPageProps = props.pageProps;
+${pageProps}
+window.__VINEXT_PAGE_LOADERS__ = { [nextData.page]: () => import(${JSON.stringify(options.pageModuleSource)}) };
+${pagePatterns}
+window.__VINEXT_APP_LOADER__ = ${options.appModuleSource ? `() => import(${JSON.stringify(options.appModuleSource)})` : "undefined"};
+window.__VINEXT_REACT_STRICT_MODE__ = ${JSON.stringify(options.reactStrictMode)};
+
+async function hydrate() {
+  let hydrateRootOptions;
+  if (import.meta.env.DEV) {
+    const overlay = await import("vinext/dev-error-overlay");
+    overlay.installDevErrorOverlay();
+    overlay.installViteHmrErrorHandler(import.meta.hot);
+    overlay.reportInitialDevServerErrors();
+    hydrateRootOptions = {
+      onCaughtError: overlay.devOnCaughtError,
+      onUncaughtError: overlay.devOnUncaughtError,
+    };
+  }
+
+  const pageModule = await import(${JSON.stringify(options.pageModuleSource)});
+  const PageComponent = pageModule.default;
+  let element;
+  ${createElement}
+  let resolveHydrationCommit;
+  const hydrationCommitted = new Promise((resolve) => { resolveHydrationCommit = resolve; });
+  element = wrapWithRouterContext(element, resolveHydrationCommit);
+  const root = hydrateRoot(document.getElementById("__next"), element, hydrateRootOptions);
+  window.__VINEXT_ROOT__ = root;
+  await hydrationCommitted;
+  const hydratedAt = performance.now();
+  window.__VINEXT_HYDRATED_AT = hydratedAt;
+  window.__NEXT_HYDRATED = true;
+  window.__NEXT_HYDRATED_AT = hydratedAt;
+  window.__NEXT_HYDRATED_CB?.();${fallbackReplacement}
+}
+hydrate();
+<\/script>`;
+}
+//#endregion
+export { createPagesDevHydrationScript };

package/dist/server/pages-dev-module-url.js

@@ -1,4 +1,4 @@
-import path from "node:path";
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 //#region src/server/pages-dev-module-url.ts
 function normalizeBase(base) {
 	if (!base || base === "/") return "/";
@@ -11,7 +11,7 @@ function createPagesDevAssetUrl(assetPath) {
 	return "/" + encodePagesDevModulePath(assetPath.replace(/^\/+/, ""));
 }
 function createPagesDevModuleUrl(viteRoot, moduleFilePath, viteBase) {
-	const relativePath = (/^[A-Za-z]:[\\/]/.test(viteRoot) ? path.win32 : path).relative(viteRoot, moduleFilePath).replace(/\\/g, "/");
+	const relativePath = (/^[A-Za-z]:[\\/]/.test(viteRoot) ? path.win32 : path).relative(viteRoot, moduleFilePath);
 	return normalizeBase(viteBase) + encodePagesDevModulePath(relativePath);
 }
 //#endregion