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

package/dist/config/prerender.js

@@ -1,4 +1,5 @@
 import { isUnknownRecord } from "../utils/record.js";
+import { flattenPluginOptions } from "../utils/plugin-options.js";
 import { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, findVinextCacheConfigInPlugins, loadVinextCacheConfigFromViteConfig } from "../cache/cache-adapters-virtual.js";
 //#region src/config/prerender.ts
 const VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY = "__vinextPrerenderConfig";
@@ -10,16 +11,8 @@ function normalizeVinextPrerenderConfig(config) {
 	if (config.routes === "*") return { routes: "*" };
 	throw new Error("[vinext] Unsupported `prerender.routes` config. Currently only `routes: \"*\"` is supported.");
 }
-function flattenPluginOptions(value, target) {
-	if (Array.isArray(value)) {
-		for (const item of value) flattenPluginOptions(item, target);
-		return;
-	}
-	if (value) target.push(value);
-}
-function findVinextPrerenderConfigInPlugins(plugins) {
-	const flattened = [];
-	flattenPluginOptions(plugins, flattened);
+async function findVinextPrerenderConfigInPlugins(plugins) {
+	const flattened = await flattenPluginOptions(plugins);
 	for (const plugin of flattened) {
 		if (!isUnknownRecord(plugin)) continue;
 		const prerenderConfig = plugin[VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY];
@@ -27,9 +20,8 @@ function findVinextPrerenderConfigInPlugins(plugins) {
 	}
 	return null;
 }
-function findVinextRouteRootConfigInPlugins(plugins) {
-	const flattened = [];
-	flattenPluginOptions(plugins, flattened);
+async function findVinextRouteRootConfigInPlugins(plugins) {
+	const flattened = await flattenPluginOptions(plugins);
 	for (const plugin of flattened) {
 		if (!isUnknownRecord(plugin)) continue;
 		const routeRootConfig = plugin[VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY];
@@ -38,13 +30,13 @@ function findVinextRouteRootConfigInPlugins(plugins) {
 	return null;
 }
 async function loadVinextPrerenderConfigFromViteConfig(vite, root) {
-	return findVinextPrerenderConfigInPlugins((await vite.loadConfigFromFile({
+	return await findVinextPrerenderConfigInPlugins((await vite.loadConfigFromFile({
 		command: "build",
 		mode: "production"
 	}, void 0, root))?.config.plugins);
 }
 async function loadVinextRouteRootConfigFromViteConfig(vite, root) {
-	return findVinextRouteRootConfigInPlugins((await vite.loadConfigFromFile({
+	return await findVinextRouteRootConfigInPlugins((await vite.loadConfigFromFile({
 		command: "build",
 		mode: "production"
 	}, void 0, root))?.config.plugins);

package/dist/config/request-context.d.ts

@@ -0,0 +1,14 @@
+//#region src/config/request-context.d.ts
+/** Request context needed for evaluating has/missing conditions. */
+type RequestContext = {
+  readonly headers: Headers;
+  readonly cookies: Record<string, string>;
+  readonly query: URLSearchParams;
+  readonly host: string;
+};
+declare function parseCookies(cookieHeader: string | null): Record<string, string>;
+declare function normalizeHost(hostHeader: string | null, fallbackHostname: string): string;
+/** Build a lazily parsed request context from a Web Request. */
+declare function requestContextFromRequest(request: Request): RequestContext;
+//#endregion
+export { RequestContext, normalizeHost, parseCookies, requestContextFromRequest };

package/dist/config/request-context.js

@@ -0,0 +1,26 @@
+import { parseCookieHeader } from "../utils/parse-cookie.js";
+//#region src/config/request-context.ts
+function parseCookies(cookieHeader) {
+	return parseCookieHeader(cookieHeader);
+}
+function normalizeHost(hostHeader, fallbackHostname) {
+	return (hostHeader ?? fallbackHostname).split(":", 1)[0].toLowerCase();
+}
+/** Build a lazily parsed request context from a Web Request. */
+function requestContextFromRequest(request) {
+	const url = new URL(request.url);
+	let cookies;
+	let query;
+	return {
+		headers: request.headers,
+		get cookies() {
+			return cookies ??= parseCookies(request.headers.get("cookie"));
+		},
+		get query() {
+			return query ??= url.searchParams;
+		},
+		host: normalizeHost(request.headers.get("host"), url.hostname)
+	};
+}
+//#endregion
+export { normalizeHost, parseCookies, requestContextFromRequest };

package/dist/config/server-external-packages.js

@@ -85,7 +85,7 @@ function mergeServerExternalPackages(userPackages = [], transpilePackages = [])
 	const conflicts = userPackages.filter((name) => transpiled.has(name));
 	if (conflicts.length > 0) throw new Error(`The packages specified in the 'transpilePackages' conflict with the 'serverExternalPackages': ${conflicts.join(", ")}`);
 	const defaults = DEFAULT_SERVER_EXTERNAL_PACKAGES.filter((name) => !transpiled.has(name));
-	return [...new Set([...defaults, ...userPackages])];
+	return [.../* @__PURE__ */ new Set([...defaults, ...userPackages])];
 }
 //#endregion
 export { mergeServerExternalPackages };

package/dist/config/tsconfig-paths.js

@@ -1,8 +1,8 @@
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { isUnknownRecord } from "../utils/record.js";
 import { parseStaticObjectLiteral } from "../plugins/fonts.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
-import path from "node:path";
 //#region src/config/tsconfig-paths.ts
 /**
 * tsconfig.json `compilerOptions.paths` loader.
@@ -61,7 +61,7 @@ function resolveTsconfigExtends(configPath, specifier) {
 		path.join(specifier, "tsconfig.json")
 	];
 	for (const item of candidates) try {
-		return requireFromConfig.resolve(item);
+		return toSlash(requireFromConfig.resolve(item));
 	} catch {}
 	return null;
 }

package/dist/{node_modules/.pnpm/am-i-vibing@0.5.0/node_modules → deps/.pnpm/am-i-vibing@0.5.0/deps}/am-i-vibing/dist/detector-1yx2Hoe0.js

@@ -1,4 +1,4 @@
-import { getProcessAncestry } from "../../../../process-ancestry@0.1.0/node_modules/process-ancestry/dist/index.js";
+import { getProcessAncestry } from "../../../../process-ancestry@0.1.0/deps/process-ancestry/dist/index.js";
 //#region ../../node_modules/.pnpm/am-i-vibing@0.5.0/node_modules/am-i-vibing/dist/detector-1yx2Hoe0.mjs
 /**
 * Provider configurations for major AI coding tools
@@ -291,4 +291,4 @@ function isAgent(envOrOptions, legacyAncestry) {
 	return result.type === "agent" || result.type === "hybrid";
 }
 //#endregion
-export { isAgent };
+export { providers as c, isAgent as n, detectAgenticEnvironment as t };

package/dist/deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js

@@ -0,0 +1,50 @@
+import nodePath from "node:path";
+//#region ../../node_modules/.pnpm/pathslash@0.1.0/node_modules/pathslash/dist/index.mjs
+const BACKSLASH_RE = /\\/g;
+const isWindows = process.platform === "win32";
+/**
+* Flip backslashes to forward slashes, used to slash-ify `node:path.win32`
+* output. `\\?\` (extended-length) paths are left untouched: there a forward
+* slash is a literal character, not a separator.
+*/
+const toForwardSlash = (path) => path.startsWith("\\\\?\\") ? path : path.replace(BACKSLASH_RE, "/");
+/**
+* Normalize separators to `/`, safely. On Windows it converts `\` to `/`. On
+* POSIX it does nothing, because there a backslash is a legal filename character
+* and rewriting it would corrupt the path.
+*/
+function toSlash(path) {
+	return isWindows ? toForwardSlash(path) : path;
+}
+const w = nodePath.win32;
+function slashed(fn) {
+	return (...args) => toForwardSlash(fn(...args));
+}
+const win32 = {
+	resolve: slashed(w.resolve),
+	normalize: slashed(w.normalize),
+	join: slashed(w.join),
+	relative: slashed(w.relative),
+	dirname: slashed(w.dirname),
+	format: slashed(w.format),
+	parse: (path) => {
+		const parsed = w.parse(path);
+		parsed.root = toForwardSlash(parsed.root);
+		parsed.dir = toForwardSlash(parsed.dir);
+		return parsed;
+	},
+	basename: w.basename,
+	extname: w.extname,
+	isAbsolute: w.isAbsolute,
+	matchesGlob: w.matchesGlob,
+	toNamespacedPath: w.toNamespacedPath,
+	delimiter: w.delimiter,
+	sep: "/"
+};
+const posix = { ...nodePath.posix };
+posix.posix = win32.posix = posix;
+posix.win32 = win32.win32 = win32;
+const path = isWindows ? win32 : posix;
+const { basename, delimiter, dirname, extname, format, isAbsolute, join, matchesGlob, normalize, parse, relative, resolve, sep, toNamespacedPath } = path;
+//#endregion
+export { path as default, posix, toSlash, win32 };

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

@@ -1,4 +1,4 @@
-import { normalizePathSeparators } from "../utils/path.js";
+import { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { resolveEntryPath } from "./runtime-entry-module.js";
 import { isProxyFile } from "../server/middleware.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES } from "../server/image-optimization.js";
@@ -127,9 +127,9 @@ import { getNavigationContext as _getNavigationContext } from "next/navigation";
 import { configureMemoryCacheHandler as __configureMemoryCacheHandler } from "vinext/shims/cache-handler";
 import { headersContextFromRequest, getDraftModeCookieHeader, getAndClearPendingCookies, consumeDynamicUsage, consumeInvalidDynamicUsageError, setHeadersAccessPhase } from "next/headers";
 import { mergeMetadata, resolveModuleMetadata, mergeViewport, resolveModuleViewport } from "vinext/metadata";
-${middlewarePath ? `import * as middlewareModule from ${JSON.stringify(normalizePathSeparators(middlewarePath))};
+${middlewarePath ? `import * as middlewareModule from ${JSON.stringify(toSlash(middlewarePath))};
 import { applyAppMiddleware as __applyAppMiddleware } from ${JSON.stringify(appMiddlewarePath)};` : ""}
-${instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(normalizePathSeparators(instrumentationPath))};
+${instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(toSlash(instrumentationPath))};
 import { ensureInstrumentationRegistered as __ensureInstrumentationRegistered } from ${JSON.stringify(instrumentationRuntimePath)};` : ""}
 import { createAppRscHandler } from "vinext/server/app-rsc-handler";
 import { registerConfiguredCacheAdapters as __registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
@@ -333,6 +333,11 @@ export const __basePath = ${JSON.stringify(bp)};
 // thread the configured trailingSlash flag through canonical URL rendering.
 const __trailingSlash = ${JSON.stringify(ts)};
 
+// Hoisted above __createAppFallbackRenderer (which runs at module init) so the
+// fallback renderer can decide streaming-vs-blocking metadata redirects per
+// request user-agent. The later per-request references still read this const.
+const __htmlLimitedBots = ${JSON.stringify(htmlLimitedBots)};
+
 const rootNotFoundModule = ${rootNotFoundVar ? rootNotFoundVar : "null"};
 const rootForbiddenModule = ${rootForbiddenVar ? rootForbiddenVar : "null"};
 const rootUnauthorizedModule = ${rootUnauthorizedVar ? rootUnauthorizedVar : "null"};
@@ -358,6 +363,7 @@ const __fallbackRenderer = __createAppFallbackRenderer({
   ${(metadataRoutes?.length ?? 0) > 0 ? "applyFileBasedMetadata: __applyFileBasedMetadata," : ""}
   basePath: __basePath,
   trailingSlash: __trailingSlash,
+  htmlLimitedBots: __htmlLimitedBots,
   rootBoundaries: {
     rootForbiddenModule,
     rootLayouts,
@@ -380,6 +386,7 @@ const __fallbackRenderer = __createAppFallbackRenderer({
   makeThenableParams,
   sanitizer: __sanitizeErrorForClient,
   rscRenderer: renderToReadableStream,
+  getAndClearPendingCookies,
   getNavigationContext: _getNavigationContext,
   resolveChildSegments: __resolveAppPageChildSegments,
   clearRequestContext() {
@@ -394,6 +401,10 @@ function matchRoute(url) {
   return __routeMatcher.matchRoute(url);
 }
 
+function matchRequestRoute(url) {
+  return __routeMatcher.matchRequestRoute(url);
+}
+
 /**
  * Check if a pathname matches any intercepting route.
  * Returns the match info or null.
@@ -432,7 +443,6 @@ const __runtimeImageConfig = ${JSON.stringify(config?.imageConfig)};
 const __publicFiles = new Set(${JSON.stringify(publicFiles)});
 const __allowedOrigins = ${JSON.stringify(allowedOrigins)};
 const __expireTime = ${JSON.stringify(expireTime)};
-const __htmlLimitedBots = ${JSON.stringify(htmlLimitedBots)};
 const __clientTraceMetadata = ${JSON.stringify(clientTraceMetadata)};
 const __reactMaxHeadersLength = ${JSON.stringify(reactMaxHeadersLength)};
 // Re-exported for the App Router prod-server to consume at startup —
@@ -517,6 +527,7 @@ export default createAppRscHandler({
     actionFailed,
     handlerStart,
     interceptionContext,
+    interceptionPathname,
     isProgressiveActionRender,
     isRscRequest,
     middlewareContext,
@@ -582,6 +593,8 @@ export default createAppRscHandler({
           renderMode,
           observeMetadataSearchParamsAccess: buildOptions?.observeMetadataSearchParamsAccess === true,
           observePageSearchParamsAccess: buildOptions?.observePageSearchParamsAccess === true,
+          serveStreamingMetadata: buildOptions?.serveStreamingMetadata,
+          isProduction: process.env.NODE_ENV === "production",
         }, layoutParamAccess, displayPathname);
       },
       clientReuseManifest,
@@ -601,7 +614,10 @@ export default createAppRscHandler({
       fetchCache: __segmentConfig.fetchCache ?? null,
       isEdgeRuntime: __isEdgeRuntime(__segmentConfig.runtime),
       findIntercept(pathname) {
-        return findIntercept(pathname, interceptionContext);
+        return findIntercept(
+          pathname === cleanPathname ? interceptionPathname : pathname,
+          interceptionContext,
+        );
       },
       generateStaticParams: __generateStaticParams,
       getFontLinks: _getSSRFontLinks,
@@ -653,7 +669,7 @@ export default createAppRscHandler({
         });
       },
       async probePage(probeSearchParams = searchParams) {
-        const __probeIntercept = findIntercept(cleanPathname, interceptionContext);
+        const __probeIntercept = findIntercept(interceptionPathname, interceptionContext);
         // The intercepting-route page module is lazy (page: null + __pageLoader).
         // Resolve it before probing so buildAppPageProbes inspects the real page
         // component for dynamic bailout — matching the render path, which also
@@ -675,7 +691,7 @@ export default createAppRscHandler({
         }));
       },
       renderErrorBoundaryPage(renderErr, errorOrigin) {
-        const __activeIntercept = findIntercept(cleanPathname, interceptionContext);
+        const __activeIntercept = findIntercept(interceptionPathname, interceptionContext);
         return __fallbackRenderer.renderErrorBoundary(route, renderErr, isRscRequest, request, params, scriptNonce, middlewareContext, {
           isEdgeRuntime: __isEdgeRuntime(__segmentConfig.runtime),
           sourcePageSegments: __activeIntercept?.slotKey === __SIBLING_PAGE_INTERCEPT_SLOT_KEY
@@ -684,9 +700,10 @@ export default createAppRscHandler({
         }, errorOrigin);
       },
       renderHttpAccessFallbackPage(statusCode, opts, currentMiddlewareContext) {
-        const __activeIntercept = findIntercept(cleanPathname, interceptionContext);
+        const __activeIntercept = findIntercept(interceptionPathname, interceptionContext);
         return __fallbackRenderer.renderHttpAccessFallback(route, statusCode, isRscRequest, request, opts, scriptNonce, currentMiddlewareContext, {
           isEdgeRuntime: __isEdgeRuntime(__segmentConfig.runtime),
+          routePathname: cleanPathname,
           sourcePageSegments: __activeIntercept?.slotKey === __SIBLING_PAGE_INTERCEPT_SLOT_KEY
             ? __activeIntercept.sourcePageSegments
             : null,
@@ -765,6 +782,7 @@ export default createAppRscHandler({
     contentType,
     middlewareContext,
     request,
+    routeMatch,
   }) {
     const {
       handleProgressiveServerActionRequest: __handleProgressiveServerActionRequest,
@@ -785,11 +803,10 @@ export default createAppRscHandler({
       contentType,
       actionId,
     );
-    const __progressiveActionMatch = __isProgressiveAction ? matchRoute(cleanPathname) : null;
     const __hasPageRoute = Boolean(
-      __progressiveActionMatch &&
-        __progressiveActionMatch.route.__loadPage &&
-        !__progressiveActionMatch.route.__loadRouteHandler,
+      __isProgressiveAction &&
+        routeMatch?.route.__loadPage &&
+        !routeMatch.route.__loadRouteHandler,
     );
     return __handleProgressiveServerActionRequest({
       actionId,
@@ -822,6 +839,8 @@ export default createAppRscHandler({
     middlewareContext,
     mountedSlotsHeader,
     request,
+    routeMatch,
+    routePathname,
     searchParams,
   }) {
     const {
@@ -829,7 +848,7 @@ export default createAppRscHandler({
       readActionBodyWithLimit: __readBodyWithLimit,
       readActionFormDataWithLimit: __readFormDataWithLimit,
     } = await __loadAppServerActionExecution();
-    const __actionMatch = matchRoute(cleanPathname);
+    const __actionMatch = routeMatch;
     if (__actionMatch) await __ensureRouteLoaded(__actionMatch.route);
     const __actionIsEdgeRuntime = __actionMatch
       ? __isEdgeRuntime(__resolveRouteRuntime(__actionMatch.route))
@@ -869,6 +888,8 @@ export default createAppRscHandler({
         __clearRequestContext();
       },
       contentType,
+      currentRouteMatch: __actionMatch,
+      currentRoutePathname: routePathname,
       createNotFoundElement(actionRouteId) {
         return {
           ...__AppElementsWire.createMetadataEntries({
@@ -933,6 +954,9 @@ export default createAppRscHandler({
           interceptLayouts: intercept.interceptLayouts,
           interceptLayoutSegments: intercept.interceptLayoutSegments,
           interceptBranchSegments: intercept.interceptBranchSegments,
+          interceptNotFoundBranchSegments: intercept.interceptNotFoundBranchSegments,
+          interceptNotFound: intercept.notFound,
+          interceptNotFoundTreePosition: intercept.notFoundTreePosition,
           interceptSlotId: intercept.slotId,
           interceptSlotKey: intercept.slotKey,
           interceptSourceMatchedUrl: interceptionContext,
@@ -956,13 +980,14 @@ export default createAppRscHandler({
     });
   },` : ""}
   matchRoute,
+  matchRequestRoute,
   ${middlewarePath ? `runMiddleware({ cleanPathname, context, hadBasePath, isDataRequest, request }) {
     return __applyAppMiddleware({
       basePath: __basePath,
       cleanPathname,
       context,
       hadBasePath,
-      filePath: ${JSON.stringify(middlewarePath ? normalizePathSeparators(middlewarePath) : "")},
+      filePath: ${JSON.stringify(middlewarePath ? toSlash(middlewarePath) : "")},
       i18nConfig: __i18nConfig,
       isDataRequest,
       isProxy: ${JSON.stringify(isProxyFile(middlewarePath))},

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

@@ -1,4 +1,4 @@
-import { normalizePathSeparators } from "../utils/path.js";
+import { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { computeAppRouteStaticSiblings, convertSegmentsToRouteParts } from "../routing/app-route-graph.js";
 import "../routing/app-router.js";
 import { createMetadataRouteEntriesSource } from "../server/metadata-route-build-data.js";
@@ -30,7 +30,7 @@ function createImportAllocator() {
 			const existing = importMap.get(filePath);
 			if (existing) return existing;
 			const varName = `mod_${importIdx++}`;
-			const absPath = normalizePathSeparators(filePath);
+			const absPath = toSlash(filePath);
 			imports.push(`import * as ${varName} from ${JSON.stringify(absPath)};`);
 			importMap.set(filePath, varName);
 			return varName;
@@ -39,7 +39,7 @@ function createImportAllocator() {
 			const existing = lazyMap.get(filePath);
 			if (existing) return existing;
 			const varName = `load_${lazyIdx++}`;
-			const absPath = normalizePathSeparators(filePath);
+			const absPath = toSlash(filePath);
 			imports.push(`const ${varName} = () => import(${JSON.stringify(absPath)});`);
 			lazyMap.set(filePath, varName);
 			return varName;
@@ -77,13 +77,16 @@ function registerRouteModules(routes, imports) {
 			for (const layoutPath of slot.configLayoutPaths ?? []) imports.getLazyLoaderVar(layoutPath);
 			if (slot.loadingPath) imports.getLazyLoaderVar(slot.loadingPath);
 			if (slot.errorPath) imports.getLazyLoaderVar(slot.errorPath);
+			if (slot.notFoundPath) imports.getLazyLoaderVar(slot.notFoundPath);
 			for (const ir of slot.interceptingRoutes) {
 				imports.getLazyLoaderVar(ir.pagePath);
+				if (ir.notFoundPath) imports.getLazyLoaderVar(ir.notFoundPath);
 				for (const layoutPath of ir.layoutPaths) imports.getLazyLoaderVar(layoutPath);
 			}
 		}
 		for (const ir of route.siblingIntercepts ?? []) {
 			imports.getLazyLoaderVar(ir.pagePath);
+			if (ir.notFoundPath) imports.getLazyLoaderVar(ir.notFoundPath);
 			for (const layoutPath of ir.layoutPaths) imports.getLazyLoaderVar(layoutPath);
 		}
 	}
@@ -115,8 +118,12 @@ function buildRouteEntries(routes, imports) {
       __loadInterceptLayouts: ${lazyLoaderArray(ir.layoutPaths, imports)},
       interceptLayoutSegments: ${JSON.stringify(ir.layoutSegments ?? [])},
       interceptBranchSegments: ${JSON.stringify(ir.branchSegments ?? [])},
+      interceptNotFoundBranchSegments: ${JSON.stringify(ir.notFoundBranchSegments ?? ir.branchSegments ?? [])},
       page: null,
       __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
+      notFound: null,
+      __loadNotFound: ${ir.notFoundPath ? imports.getLazyLoaderVar(ir.notFoundPath) : "null"},
+      notFoundTreePosition: ${ir.notFoundTreePosition ?? "null"},
       params: ${JSON.stringify(ir.params)},
     }`);
 		const slotEntries = route.parallelSlots.map((slot) => {
@@ -129,8 +136,12 @@ function buildRouteEntries(routes, imports) {
           __loadInterceptLayouts: ${lazyLoaderArray(ir.layoutPaths, imports)},
           interceptLayoutSegments: ${JSON.stringify(ir.layoutSegments ?? [])},
           interceptBranchSegments: ${JSON.stringify(ir.branchSegments ?? [])},
+          interceptNotFoundBranchSegments: ${JSON.stringify(ir.notFoundBranchSegments ?? ir.branchSegments ?? [])},
           page: null,
           __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
+          notFound: null,
+          __loadNotFound: ${ir.notFoundPath ? imports.getLazyLoaderVar(ir.notFoundPath) : "null"},
+          notFoundTreePosition: ${ir.notFoundTreePosition ?? "null"},
           params: ${JSON.stringify(ir.params)},
         }`);
 			return `      ${JSON.stringify(slot.key)}: {
@@ -149,6 +160,9 @@ function buildRouteEntries(routes, imports) {
         __loadLoading: ${slot.loadingPath ? imports.getLazyLoaderVar(slot.loadingPath) : "null"},
         error: null,
         __loadError: ${slot.errorPath ? imports.getLazyLoaderVar(slot.errorPath) : "null"},
+        notFound: null,
+        __loadNotFound: ${slot.notFoundPath ? imports.getLazyLoaderVar(slot.notFoundPath) : "null"},
+        notFoundTreePosition: ${slot.notFoundTreePosition ?? "null"},
         layoutIndex: ${slot.layoutIndex},
         routeSegments: ${JSON.stringify(slot.routeSegments)},
         slotPatternParts: ${slot.slotPatternParts ? JSON.stringify(slot.slotPatternParts) : "null"},
@@ -204,14 +218,17 @@ ${siblingInterceptEntries.join(",\n")}
     __loadError: ${route.errorPath ? imports.getLazyLoaderVar(route.errorPath) : "null"},
     notFound: null,
     __loadNotFound: ${route.notFoundPath ? imports.getLazyLoaderVar(route.notFoundPath) : "null"},
+    notFoundTreePosition: ${route.notFoundTreePosition ?? "null"},
     notFounds: ${moduleArray(notFoundPaths.length)},
     __loadNotFounds: ${notFoundLoaders},
     forbidden: null,
     __loadForbidden: ${route.forbiddenPath ? imports.getLazyLoaderVar(route.forbiddenPath) : "null"},
+    forbiddenTreePosition: ${route.forbiddenTreePosition ?? "null"},
     forbiddens: ${moduleArray(forbiddenPaths.length)},
     __loadForbiddens: ${forbiddenLoaders},
     unauthorized: null,
     __loadUnauthorized: ${route.unauthorizedPath ? imports.getLazyLoaderVar(route.unauthorizedPath) : "null"},
+    unauthorizedTreePosition: ${route.unauthorizedTreePosition ?? "null"},
     unauthorizeds: ${moduleArray(unauthorizedPaths.length)},
     __loadUnauthorizeds: ${unauthorizedLoaders},
   }`;
@@ -282,7 +299,7 @@ function buildAppRscManifestCode(options) {
 	const rootUnauthorizedVar = rootUnauthorizedPath ? imports.getImportVar(rootUnauthorizedPath) : null;
 	const rootLayoutVars = rootRouteLayoutPaths(rootRoute).map((layoutPath) => imports.getImportVar(layoutPath));
 	const globalErrorVar = options.globalErrorPath ? imports.getImportVar(options.globalErrorPath) : null;
-	const globalNotFoundImportSpecifier = options.globalNotFoundPath ? JSON.stringify(normalizePathSeparators(options.globalNotFoundPath)) : null;
+	const globalNotFoundImportSpecifier = options.globalNotFoundPath ? JSON.stringify(toSlash(options.globalNotFoundPath)) : null;
 	const dynamicMetadataRoutes = metadataRoutes.filter((r) => r.isDynamic);
 	for (const route of dynamicMetadataRoutes) imports.getImportVar(route.filePath);
 	const namesByPattern = buildRootParamNamesByPattern(options.routes);

package/dist/entries/pages-client-entry.js

@@ -1,8 +1,7 @@
-import { normalizePathSeparators } from "../utils/path.js";
+import { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { findFileWithExts } from "../routing/file-matcher.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { apiRouter, pagesRouter } from "../routing/pages-router.js";
-import "./pages-entry-helpers.js";
 import { hasExportedName } from "../build/report.js";
 import { readFile } from "node:fs/promises";
 //#region src/entries/pages-client-entry.ts
@@ -42,6 +41,7 @@ async function generateClientEntry(pagesDir, nextConfig, fileMatcher, options =
 	const pageRoutes = await pagesRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);
 	const apiRoutes = await apiRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);
 	const appFilePath = findFileWithExts(pagesDir, "_app", fileMatcher);
+	const errorFilePath = findFileWithExts(pagesDir, "_error", fileMatcher);
 	const hasApp = appFilePath !== null;
 	const appPrefetchRoutes = options.appPrefetchRoutes ?? [];
 	const pagesPrefetchRoutes = [...pageRoutes.map(toPagesLinkPrefetchRoute), ...apiRoutes.map((route) => ({
@@ -52,12 +52,13 @@ async function generateClientEntry(pagesDir, nextConfig, fileMatcher, options =
 	const pagesSspPatterns = (await Promise.all(pageRoutes.map(async (route) => await hasGetServerSidePropsExport(route.filePath) ? patternToNextFormat(route.pattern) : null))).filter((pattern) => pattern !== null);
 	const instrumentationClientPath = options.instrumentationClientPath ?? null;
 	const loaderEntries = pageRoutes.map((r) => {
-		const absPath = normalizePathSeparators(r.filePath);
+		const absPath = r.filePath;
 		const nextFormatPattern = patternToNextFormat(r.pattern);
 		return `  ${JSON.stringify(nextFormatPattern)}: () => import(${JSON.stringify(absPath)})`;
 	});
-	const appFileBase = appFilePath ? normalizePathSeparators(appFilePath) : void 0;
-	const userInstrumentationImport = instrumentationClientPath ? `import ${JSON.stringify(normalizePathSeparators(instrumentationClientPath))};\n` : "";
+	loaderEntries.push(errorFilePath !== null ? `  "/_error": () => import(${JSON.stringify(errorFilePath)})` : "  \"/_error\": () => import(\"next/error\")");
+	const appFileBase = appFilePath ?? void 0;
+	const userInstrumentationImport = instrumentationClientPath ? `import ${JSON.stringify(toSlash(instrumentationClientPath))};\n` : "";
 	const reactPreambleImport = options.reactPreamble === false ? "" : "import \"@vitejs/plugin-react/preamble\";\n";
 	const reactStrictModeEnabled = nextConfig.reactStrictMode === true;
 	return `${userInstrumentationImport}${reactPreambleImport}

package/dist/entries/pages-server-entry.js

@@ -1,9 +1,7 @@
-import { normalizePathSeparators } from "../utils/path.js";
 import { findFileWithExts } from "../routing/file-matcher.js";
 import { apiRouter, pagesRouter } from "../routing/pages-router.js";
 import { resolveEntryPath } from "./runtime-entry-module.js";
 import { isProxyFile } from "../server/middleware.js";
-import "./pages-entry-helpers.js";
 import { hasExportedName } from "../build/report.js";
 import { readFile } from "node:fs/promises";
 //#region src/entries/pages-server-entry.ts
@@ -39,18 +37,11 @@ async function getPagesDataKind(filePath) {
 async function generateServerEntry(pagesDir, nextConfig, fileMatcher, middlewarePath, instrumentationPath) {
 	const pageRoutes = await pagesRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);
 	const apiRoutes = await apiRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);
-	const pageImports = pageRoutes.map((r, i) => {
-		const absPath = normalizePathSeparators(r.filePath);
-		return `import * as page_${i} from ${JSON.stringify(absPath)};`;
-	});
-	const apiImports = apiRoutes.map((r, i) => {
-		const absPath = normalizePathSeparators(r.filePath);
-		return `import * as api_${i} from ${JSON.stringify(absPath)};`;
-	});
+	const pageImports = pageRoutes.map((r, i) => `import * as page_${i} from ${JSON.stringify(r.filePath)};`);
+	const apiImports = apiRoutes.map((r, i) => `import * as api_${i} from ${JSON.stringify(r.filePath)};`);
 	const pageRouteEntries = await Promise.all(pageRoutes.map(async (r, i) => {
-		const absPath = normalizePathSeparators(r.filePath);
 		const dataKind = await getPagesDataKind(r.filePath);
-		return `  { pattern: ${JSON.stringify(r.pattern)}, patternParts: ${JSON.stringify(r.patternParts)}, isDynamic: ${r.isDynamic}, params: ${JSON.stringify(r.params)}, module: page_${i}, filePath: ${JSON.stringify(absPath)}, dataKind: ${JSON.stringify(dataKind)} }`;
+		return `  { pattern: ${JSON.stringify(r.pattern)}, patternParts: ${JSON.stringify(r.patternParts)}, isDynamic: ${r.isDynamic}, params: ${JSON.stringify(r.params)}, module: page_${i}, filePath: ${JSON.stringify(r.filePath)}, dataKind: ${JSON.stringify(dataKind)} }`;
 	}));
 	const apiRouteEntries = apiRoutes.map((r, i) => `  { pattern: ${JSON.stringify(r.pattern)}, patternParts: ${JSON.stringify(r.patternParts)}, isDynamic: ${r.isDynamic}, params: ${JSON.stringify(r.params)}, module: api_${i} }`);
 	const appFilePath = findFileWithExts(pagesDir, "_app", fileMatcher);
@@ -60,7 +51,7 @@ async function generateServerEntry(pagesDir, nextConfig, fileMatcher, middleware
 	const appImportCode = appFilePath !== null ? `import { default as AppComponent } from ${JSON.stringify(appFilePath)};` : `const AppComponent = null;`;
 	const docImportCode = docFilePath !== null ? `import { default as DocumentComponent } from ${JSON.stringify(docFilePath)};` : `const DocumentComponent = null;`;
 	const errorAssetPathJson = errorFilePath !== null ? JSON.stringify(errorFilePath) : "null";
-	const errorImportCode = errorFilePath !== null ? `import * as ErrorPageModule from ${JSON.stringify(errorFilePath)};` : `const ErrorPageModule = null;`;
+	const errorImportCode = errorFilePath !== null ? `import * as ErrorPageModule from ${JSON.stringify(errorFilePath)};` : `import * as ErrorPageModule from "next/error";`;
 	const i18nConfigJson = nextConfig?.i18n ? JSON.stringify({
 		locales: nextConfig.i18n.locales,
 		defaultLocale: nextConfig.i18n.defaultLocale,
@@ -95,7 +86,7 @@ async function generateServerEntry(pagesDir, nextConfig, fileMatcher, middleware
 			contentSecurityPolicy: nextConfig?.images?.contentSecurityPolicy
 		}
 	});
-	const instrumentationImportCode = instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(normalizePathSeparators(instrumentationPath))};` : "";
+	const instrumentationImportCode = instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(instrumentationPath)};` : "";
 	const instrumentationInitCode = instrumentationPath ? `// Run instrumentation register() once at module evaluation time — before any
 // requests are handled. Matches Next.js semantics: register() is called once
 // on startup in the process that handles requests.
@@ -107,13 +98,13 @@ if (typeof _instrumentation.register === "function") {
 if (typeof _instrumentation.onRequestError === "function") {
   globalThis.__VINEXT_onRequestErrorHandler__ = _instrumentation.onRequestError;
 }` : "";
-	const middlewareImportCode = middlewarePath ? `import * as middlewareModule from ${JSON.stringify(normalizePathSeparators(middlewarePath))};` : "";
+	const middlewareImportCode = middlewarePath ? `import * as middlewareModule from ${JSON.stringify(middlewarePath)};` : "";
 	const middlewareExportCode = middlewarePath ? `
 export async function runMiddleware(request, ctx, options) {
   return __runGeneratedMiddleware({
     basePath: vinextConfig.basePath,
     ctx,
-    filePath: ${JSON.stringify(normalizePathSeparators(middlewarePath))},
+    filePath: ${JSON.stringify(middlewarePath)},
     i18nConfig,
     isDataRequest: options?.isDataRequest === true,
     isProxy: ${JSON.stringify(isProxyFile(middlewarePath))},
@@ -228,16 +219,14 @@ export const pageRoutes = [
 ${pageRouteEntries.join(",\n")}
 ];
 const _pageRouteTrie = _buildRouteTrie(pageRoutes);
-const _errorPageRoute = ErrorPageModule
-  ? {
-      pattern: "/_error",
-      patternParts: ["_error"],
-      isDynamic: false,
-      params: [],
-      module: ErrorPageModule,
-      filePath: ${errorAssetPathJson},
-    }
-  : null;
+const _errorPageRoute = {
+  pattern: "/_error",
+  patternParts: ["_error"],
+  isDynamic: false,
+  params: [],
+  module: ErrorPageModule,
+  filePath: ${errorAssetPathJson},
+};
 
 const apiRoutes = [
 ${apiRouteEntries.join(",\n")}
@@ -247,8 +236,8 @@ const _apiRouteTrie = _buildRouteTrie(apiRoutes);
 function matchRoute(url, routes) {
   const pathname = url.split("?")[0];
   let normalizedUrl = pathname === "/" ? "/" : pathname.replace(/\\/$/, "");
-  // NOTE: Do NOT decodeURIComponent here. The pathname is already decoded at
-  // the entry point. Decoding again would create a double-decode vector.
+  // Static route selection uses raw encoded identity (/%61bout must not
+  // select /about). _trieMatch decodes dynamic captures exactly once.
   const urlParts = normalizedUrl.split("/").filter(Boolean);
   const trie = routes === pageRoutes ? _pageRouteTrie : _apiRouteTrie;
   return _trieMatch(trie, urlParts);
@@ -318,6 +307,7 @@ const _renderPage = __createPagesPageHandler({
       : null,
   setI18nContext: typeof setI18nContext === "function" ? setI18nContext : null,
   wrapWithRouterContext: typeof wrapWithRouterContext === "function" ? wrapWithRouterContext : null,
+  router: Router,
   resetSSRHead: typeof resetSSRHead === "function" ? resetSSRHead : undefined,
   getSSRHeadHTML: typeof getSSRHeadHTML === "function" ? getSSRHeadHTML : undefined,
   setDocumentInitialHead: typeof setDocumentInitialHead === "function" ? setDocumentInitialHead : undefined,

package/dist/entries/runtime-entry-module.js

@@ -1,4 +1,4 @@
-import { normalizePathSeparators } from "../utils/path.js";
+import { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region src/entries/runtime-entry-module.ts
@@ -14,7 +14,7 @@ import { fileURLToPath } from "node:url";
 * @param base - The caller's `import.meta.url`
 */
 function resolveEntryPath(rel, base) {
-	return normalizePathSeparators(fileURLToPath(new URL(rel, base)));
+	return toSlash(fileURLToPath(new URL(rel, base)));
 }
 /**
 * Resolve a real runtime module for a virtual entry generator.