vinext 0.1.8 → 0.2.0

package/dist/config/config-matchers.js

@@ -1,5 +1,5 @@
-import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "../server/headers.js";
-import { buildRequestHeadersFromMiddlewareResponse } from "../server/middleware-request-headers.js";
+import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
+import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
 import { parseCookieHeader } from "../utils/parse-cookie.js";
 //#region src/config/config-matchers.ts
 /**
@@ -526,11 +526,13 @@ function extractConstraint(str, re) {
 *
 * The root path `"/"` is preserved as-is.
 */
-function stripTrailingSlashForConfigMatch(pathname) {
-	return pathname.length > 1 && pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+function stripTrailingSlashForConfigMatch(value) {
+	return value.length > 1 && value.endsWith("/") ? value.slice(0, -1) : value;
 }
 function matchConfigPattern(pathname, pattern) {
+	const pathnameHadTrailingSlash = pathname.length > 1 && pathname.endsWith("/");
 	pathname = stripTrailingSlashForConfigMatch(pathname);
+	if (pathnameHadTrailingSlash) pattern = stripTrailingSlashForConfigMatch(pattern);
 	const catchAllAnchor = /:[\w-]+[*+]/.test(pattern);
 	const namedParamCount = (pattern.match(/:[\w-]+/g) || []).length;
 	if (pattern.includes("(") || pattern.includes("\\") || /:[\w-]+[*+][^/]/.test(pattern) || /:[\w-]+\./.test(pattern) || /[^/]:[\w-]+/.test(pattern) || catchAllAnchor && namedParamCount > 1) try {
@@ -628,12 +630,12 @@ function matchConfigPattern(pathname, pattern) {
 */
 function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAULT) {
 	if (redirects.length === 0) return null;
-	pathname = stripTrailingSlashForConfigMatch(pathname);
+	const normalizedPathname = stripTrailingSlashForConfigMatch(pathname);
 	const index = _getRedirectIndex(redirects);
 	let localeMatch = null;
 	let localeMatchIndex = Infinity;
 	if (index.localeStatic.size > 0) {
-		const noLocaleBucket = index.localeStatic.get(pathname);
+		const noLocaleBucket = index.localeStatic.get(normalizedPathname);
 		if (noLocaleBucket) for (const entry of noLocaleBucket) {
 			if (!entry.optional) continue;
 			if (entry.originalIndex >= localeMatchIndex) continue;
@@ -651,10 +653,10 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 			localeMatchIndex = entry.originalIndex;
 			break;
 		}
-		const slashTwo = pathname.indexOf("/", 1);
+		const slashTwo = normalizedPathname.indexOf("/", 1);
 		if (slashTwo !== -1) {
-			const suffix = pathname.slice(slashTwo);
-			const localePart = pathname.slice(1, slashTwo);
+			const suffix = normalizedPathname.slice(slashTwo);
+			const localePart = normalizedPathname.slice(1, slashTwo);
 			const localeBucket = index.localeStatic.get(suffix);
 			if (localeBucket) for (const entry of localeBucket) {
 				if (entry.originalIndex >= localeMatchIndex) continue;
@@ -956,11 +958,13 @@ async function proxyExternalRequest(request, externalUrl) {
 * when evaluating headers, so this parameter is required.
 */
 function matchHeaders(pathname, headers, ctx, basePathState = _BASEPATH_DEFAULT) {
+	const pathnameHadTrailingSlash = pathname.length > 1 && pathname.endsWith("/");
 	pathname = stripTrailingSlashForConfigMatch(pathname);
 	const result = [];
 	for (const rule of headers) {
 		if (!shouldEvaluateRule(rule.basePath, basePathState)) continue;
-		const sourceRegex = getCachedRegex(_compiledHeaderSourceCache, rule.source, () => safeRegExp("^" + escapeHeaderSource(rule.source) + "$"));
+		const source = pathnameHadTrailingSlash ? stripTrailingSlashForConfigMatch(rule.source) : rule.source;
+		const sourceRegex = getCachedRegex(_compiledHeaderSourceCache, source, () => safeRegExp("^" + escapeHeaderSource(source) + "$"));
 		if (sourceRegex && sourceRegex.test(pathname)) {
 			if (rule.has || rule.missing) {
 				if (!checkHasConditions(rule.has, rule.missing, ctx)) continue;

package/dist/config/next-config.d.ts

@@ -107,7 +107,7 @@ type NextConfig = {
   }; /** Custom response headers */
   headers?: () => Promise<NextHeader[]> | NextHeader[]; /** Image optimization config */
   images?: {
-    remotePatterns?: Array<{
+    remotePatterns?: Array<URL | {
       protocol?: string;
       hostname: string;
       port?: string;
@@ -273,8 +273,10 @@ type ResolvedNextConfig = {
   allowedDevOrigins: string[]; /** Extra allowed origins for server action CSRF validation (from experimental.serverActions.allowedOrigins). */
   serverActionsAllowedOrigins: string[]; /** Packages whose barrel imports should be optimized (from experimental.optimizePackageImports). */
   optimizePackageImports: string[]; /** Packages explicitly requested for server/client transpilation. */
-  transpilePackages: string[]; /** Inline app CSS into production HTML (from experimental.inlineCss). */
-  inlineCss: boolean; /** Parsed body size limit for server actions in bytes (from experimental.serverActions.bodySizeLimit). Defaults to 1MB. */
+  transpilePackages: string[]; /** Packages treated as application code by Turbopack's foreign-code condition. */
+  turbopackTranspilePackages: string[]; /** Inline app CSS into production HTML (from experimental.inlineCss). */
+  inlineCss: boolean; /** Enable standalone route-miss 404 handling (from experimental.globalNotFound). */
+  globalNotFound: boolean; /** Parsed body size limit for server actions in bytes (from experimental.serverActions.bodySizeLimit). Defaults to 1MB. */
   serverActionsBodySizeLimit: number; /** Verbatim body size limit config value (e.g. "2mb") for the "Body exceeded {limit} limit" error. Defaults to "1 MB". */
   serverActionsBodySizeLimitLabel: string; /** Route-level expire fallback in seconds for ISR entries with numeric revalidate. */
   expireTime: number;

package/dist/config/next-config.js

@@ -72,6 +72,7 @@ const CONFIG_FILES = [
 	"next.config.cjs"
 ];
 const DEFAULT_EXPIRE_TIME = 31536e3;
+const DEFAULT_TRANSPILED_PACKAGES = ["geist"];
 /**
 * Default cap for the App Router preload `Link` header length, matching the
 * Next.js `defaultConfig.reactMaxHeadersLength`.
@@ -252,6 +253,31 @@ function findNextConfigPath(root) {
 	}
 	return null;
 }
+function hasConfigProperty(config, propertyPath) {
+	let current = config;
+	for (const property of propertyPath.split(".")) {
+		if (!isUnknownRecord(current) || current[property] === void 0) return false;
+		current = current[property];
+	}
+	return true;
+}
+const emittedConfigWarnings = /* @__PURE__ */ new Set();
+function warnConfigOnce(message) {
+	if (emittedConfigWarnings.has(message)) return;
+	emittedConfigWarnings.add(message);
+	console.warn(message);
+}
+function warnDeprecatedConfigOptions(config, root) {
+	const configFileName = path.basename(findNextConfigPath(root) ?? "next.config.js");
+	const warnings = [
+		["experimental.middlewarePrefetch", `\`experimental.middlewarePrefetch\` is deprecated. Please use \`experimental.proxyPrefetch\` instead in ${configFileName}.`],
+		["experimental.middlewareClientMaxBodySize", `\`experimental.middlewareClientMaxBodySize\` is deprecated. Please use \`experimental.proxyClientMaxBodySize\` instead in ${configFileName}.`],
+		["experimental.externalMiddlewareRewritesResolve", `\`experimental.externalMiddlewareRewritesResolve\` is deprecated. Please use \`experimental.externalProxyRewritesResolve\` instead in ${configFileName}.`],
+		["skipMiddlewareUrlNormalize", `\`skipMiddlewareUrlNormalize\` is deprecated. Please use \`skipProxyUrlNormalize\` instead in ${configFileName}.`],
+		["experimental.instrumentationHook", `\`experimental.instrumentationHook\` is no longer needed, because \`instrumentation.js\` is available by default. You can remove it from ${configFileName}.`]
+	];
+	for (const [propertyPath, warning] of warnings) if (hasConfigProperty(config, propertyPath)) warnConfigOnce(warning);
+}
 async function resolveNextConfigInput(config, phase = PHASE_DEVELOPMENT_SERVER) {
 	return await resolveConfigValue(config, phase);
 }
@@ -570,7 +596,9 @@ async function resolveNextConfig(config, root = process.cwd(), options = {}) {
 			serverActionsAllowedOrigins: [],
 			optimizePackageImports: [],
 			transpilePackages: [],
+			turbopackTranspilePackages: [...DEFAULT_TRANSPILED_PACKAGES],
 			inlineCss: false,
+			globalNotFound: false,
 			serverActionsBodySizeLimit: 1 * 1024 * 1024,
 			serverActionsBodySizeLimitLabel: "1 MB",
 			expireTime: DEFAULT_EXPIRE_TIME,
@@ -602,6 +630,7 @@ async function resolveNextConfig(config, root = process.cwd(), options = {}) {
 		detectNextIntlConfig(root, resolved);
 		return resolved;
 	}
+	warnDeprecatedConfigOptions(config, root);
 	let redirects = [];
 	if (config.redirects) {
 		const result = await config.redirects();
@@ -653,6 +682,7 @@ async function resolveNextConfig(config, root = process.cwd(), options = {}) {
 	const rawOptimize = experimental?.optimizePackageImports;
 	const optimizePackageImports = Array.isArray(rawOptimize) ? rawOptimize.filter((x) => typeof x === "string") : [];
 	const inlineCss = experimental?.inlineCss === true;
+	const globalNotFound = experimental?.globalNotFound === true;
 	const prefetchInlining = experimental?.prefetchInlining === true || isUnknownRecord(experimental?.prefetchInlining);
 	const appShells = experimental?.appShells === true;
 	if (appShells) {
@@ -668,6 +698,7 @@ async function resolveNextConfig(config, root = process.cwd(), options = {}) {
 	const legacyServerComponentsExternal = readStringArray(experimental?.serverComponentsExternalPackages);
 	const serverExternalPackages = topLevelServerExternalPackages ?? legacyServerComponentsExternal;
 	const transpilePackages = readStringArray(config.transpilePackages);
+	const turbopackTranspilePackages = [...transpilePackages, ...DEFAULT_TRANSPILED_PACKAGES];
 	if (experimental?.swcEnvOptions !== void 0) console.warn("[vinext] next.config option \"experimental.swcEnvOptions\" is not applicable and will be ignored (vinext uses Vite, not SWC). A Vite-compatible polyfill solution may be explored in the future.");
 	if (experimental?.rootParams !== void 0) console.warn("[vinext] `experimental.rootParams` is no longer needed, because `next/root-params` is available by default. You can remove it from next.config.(js|mjs|ts).");
 	const useLightningcss = experimental?.useLightningcss === true;
@@ -706,6 +737,16 @@ async function resolveNextConfig(config, root = process.cwd(), options = {}) {
 			fallback: applyLocaleToRoutes(rewrites.fallback, i18n, "rewrite", opts)
 		};
 	}
+	const images = config.images ? {
+		...config.images,
+		remotePatterns: config.images.remotePatterns?.map((pattern) => pattern instanceof URL ? {
+			protocol: pattern.protocol.slice(0, -1),
+			hostname: pattern.hostname,
+			port: pattern.port,
+			pathname: pattern.pathname,
+			search: pattern.search
+		} : { ...pattern })
+	} : void 0;
 	const resolved = {
 		env: config.env ?? {},
 		basePath: config.basePath ?? "",
@@ -723,7 +764,7 @@ async function resolveNextConfig(config, root = process.cwd(), options = {}) {
 		redirects,
 		rewrites,
 		headers,
-		images: config.images,
+		images,
 		i18n,
 		mdx,
 		aliases,
@@ -731,7 +772,9 @@ async function resolveNextConfig(config, root = process.cwd(), options = {}) {
 		serverActionsAllowedOrigins,
 		optimizePackageImports,
 		transpilePackages,
+		turbopackTranspilePackages,
 		inlineCss,
+		globalNotFound,
 		serverActionsBodySizeLimit,
 		serverActionsBodySizeLimitLabel,
 		expireTime: typeof config.expireTime === "number" ? config.expireTime : DEFAULT_EXPIRE_TIME,

package/dist/config/prerender.d.ts

@@ -0,0 +1,34 @@
+import { PluginOption } from "vite";
+
+//#region src/config/prerender.d.ts
+type VinextPrerenderConfig = true | {
+  /**
+   * Routes to pre-render after the production build.
+   *
+   * Currently only `"*"` is supported, which pre-renders every discovered
+   * App Router and Pages Router route that vinext can statically render.
+   */
+  routes: "*";
+};
+type ResolvedVinextPrerenderConfig = {
+  routes: "*";
+};
+type VinextPrerenderDecisionReason = "flag" | "next-export" | "vinext-config";
+type VinextPrerenderDecision = ResolvedVinextPrerenderConfig & {
+  reason: VinextPrerenderDecisionReason;
+};
+declare const VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY = "__vinextPrerenderConfig";
+type ViteConfigLoader = {
+  loadConfigFromFile: typeof import("vite").loadConfigFromFile;
+};
+declare function normalizeVinextPrerenderConfig(config: VinextPrerenderConfig | undefined): ResolvedVinextPrerenderConfig | null;
+declare function findVinextPrerenderConfigInPlugins(plugins: PluginOption[] | undefined): ResolvedVinextPrerenderConfig | null;
+declare function loadVinextPrerenderConfigFromViteConfig(vite: ViteConfigLoader, root: string): Promise<ResolvedVinextPrerenderConfig | null>;
+declare function resolveVinextPrerenderDecision(options: {
+  prerenderAllFlag?: boolean;
+  vinextPrerenderConfig?: ResolvedVinextPrerenderConfig | null;
+  nextOutput?: string;
+}): VinextPrerenderDecision | null;
+declare function formatVinextPrerenderLabel(decision: VinextPrerenderDecision): string;
+//#endregion
+export { ResolvedVinextPrerenderConfig, VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY, VinextPrerenderConfig, VinextPrerenderDecision, VinextPrerenderDecisionReason, findVinextPrerenderConfigInPlugins, formatVinextPrerenderLabel, loadVinextPrerenderConfigFromViteConfig, normalizeVinextPrerenderConfig, resolveVinextPrerenderDecision };

package/dist/config/prerender.js

@@ -0,0 +1,55 @@
+import { isUnknownRecord } from "../utils/record.js";
+//#region src/config/prerender.ts
+const VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY = "__vinextPrerenderConfig";
+function normalizeVinextPrerenderConfig(config) {
+	if (config === void 0) return null;
+	if (config === true) return { routes: "*" };
+	if (!isUnknownRecord(config)) throw new Error("[vinext] Invalid `prerender` config. Use `true` or `{ routes: \"*\" }`.");
+	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);
+	for (const plugin of flattened) {
+		if (!isUnknownRecord(plugin)) continue;
+		const prerenderConfig = plugin[VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY];
+		if (prerenderConfig) return prerenderConfig;
+	}
+	return null;
+}
+async function loadVinextPrerenderConfigFromViteConfig(vite, root) {
+	return findVinextPrerenderConfigInPlugins((await vite.loadConfigFromFile({
+		command: "build",
+		mode: "production"
+	}, void 0, root))?.config.plugins);
+}
+function resolveVinextPrerenderDecision(options) {
+	if (options.prerenderAllFlag) return {
+		routes: "*",
+		reason: "flag"
+	};
+	if (options.nextOutput === "export") return {
+		routes: "*",
+		reason: "next-export"
+	};
+	if (options.vinextPrerenderConfig?.routes === "*") return {
+		routes: "*",
+		reason: "vinext-config"
+	};
+	return null;
+}
+function formatVinextPrerenderLabel(decision) {
+	if (decision.reason === "next-export") return "Pre-rendering all routes (output: 'export')...";
+	if (decision.reason === "vinext-config") return "Pre-rendering all routes (vinext prerender config)...";
+	return "Pre-rendering all routes...";
+}
+//#endregion
+export { VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY, findVinextPrerenderConfigInPlugins, formatVinextPrerenderLabel, loadVinextPrerenderConfigFromViteConfig, normalizeVinextPrerenderConfig, resolveVinextPrerenderDecision };

package/dist/entries/app-rsc-entry.d.ts

@@ -43,7 +43,8 @@ type AppRouterConfig = {
    */
   reactMaxHeadersLength?: number; /** Maximum in-memory cache size in bytes. 0 disables the default memory cache. */
   cacheMaxMemorySize?: number; /** Inline app CSS into production HTML (from experimental.inlineCss). */
-  inlineCss?: boolean; /** Enables Next.js Cache Components semantics for App Router document HTML. */
+  inlineCss?: boolean; /** Enable standalone route-miss 404 handling (from experimental.globalNotFound). */
+  globalNotFound?: boolean; /** Enables Next.js Cache Components semantics for App Router document HTML. */
   cacheComponents?: boolean; /** Whether the RSC build discovered any server references. Defaults to true. */
   hasServerActions?: boolean; /** Internationalization routing config for middleware matcher locale handling. */
   i18n?: NextI18nConfig | null;

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

@@ -1,6 +1,7 @@
 import { normalizePathSeparators } from "../utils/path.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";
 import { buildAppRscManifestCode } from "./app-rsc-manifest.js";
 import { generateDevOriginCheckCode } from "../server/dev-origin-check.js";
 import { randomUUID } from "node:crypto";
@@ -16,7 +17,7 @@ import { randomUUID } from "node:crypto";
 */
 const DEFAULT_EXPIRE_TIME = 31536e3;
 const DEFAULT_REACT_MAX_HEADERS_LENGTH = 6e3;
-const middlewareRequestHeadersPath = resolveEntryPath("../server/middleware-request-headers.js", import.meta.url);
+const middlewareRequestHeadersPath = resolveEntryPath("../utils/middleware-request-headers.js", import.meta.url);
 const normalizePathModulePath = resolveEntryPath("../server/normalize-path.js", import.meta.url);
 const appRouteHandlerDispatchPath = resolveEntryPath("../server/app-route-handler-dispatch.js", import.meta.url);
 const appRouteHandlerResponsePath = resolveEntryPath("../server/app-route-handler-response.js", import.meta.url);
@@ -82,11 +83,19 @@ function generateRscEntry(appDir, routes, middlewarePath, metadataRoutes, global
 	const hasPagesDir = config?.hasPagesDir ?? false;
 	const publicFiles = config?.publicFiles ?? [];
 	const draftModeSecret = config?.draftModeSecret ?? randomUUID();
+	const imageAllowedWidths = [...config?.imageConfig?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...config?.imageConfig?.imageSizes ?? DEFAULT_IMAGE_SIZES];
+	const imageConfig = {
+		qualities: config?.imageConfig?.qualities,
+		dangerouslyAllowSVG: config?.imageConfig?.dangerouslyAllowSVG,
+		dangerouslyAllowLocalIP: config?.imageConfig?.dangerouslyAllowLocalIP,
+		contentDispositionType: config?.imageConfig?.contentDispositionType,
+		contentSecurityPolicy: config?.imageConfig?.contentSecurityPolicy
+	};
 	const { imports, routeEntries, metaRouteEntries, generateStaticParamsEntries, rootParamNameEntries, rootNotFoundVar, rootForbiddenVar, rootUnauthorizedVar, rootLayoutVars, globalErrorVar, globalNotFoundImportSpecifier } = buildAppRscManifestCode({
 		routes,
 		metadataRoutes,
 		globalErrorPath,
-		globalNotFoundPath: config?.globalNotFoundPath ?? null
+		globalNotFoundPath: config?.globalNotFound === true ? config.globalNotFoundPath ?? null : null
 	});
 	const loadPrerenderPagesRoutesCode = hasPagesDir ? `
 async function __loadPrerenderPagesRoutes() {
@@ -123,6 +132,8 @@ ${instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(norm
 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";
+import __pagesClientAssets from "virtual:vinext-pages-client-assets";
+import { setPagesClientAssets as __setPagesClientAssets } from "vinext/server/pages-client-assets";
 import { decodePathParams as __decodePathParams } from ${JSON.stringify(normalizePathModulePath)};
 import { buildRequestHeadersFromMiddlewareResponse as __buildRequestHeadersFromMiddlewareResponse } from ${JSON.stringify(middlewareRequestHeadersPath)};
 ${hasPagesDir ? `import {
@@ -354,6 +365,7 @@ const __fallbackRenderer = __createAppFallbackRenderer({
   },
   globalErrorModule: ${globalErrorVar ? globalErrorVar : "null"},
   loadGlobalNotFoundModule: __loadGlobalNotFoundModule,
+  globalNotFoundEnabled: ${config?.globalNotFound === true},
   metadataRoutes,
   ssrLoader() {
     return import.meta.viteRsc.loadModule("ssr", "index");
@@ -415,7 +427,7 @@ const __i18nConfig = ${JSON.stringify(i18nConfig)};
 const __configRedirects = ${JSON.stringify(redirects)};
 const __configRewrites = ${JSON.stringify(rewrites)};
 const __configHeaders = ${JSON.stringify(headers)};
-const __imageConfig = ${JSON.stringify(config?.imageConfig)};
+const __runtimeImageConfig = ${JSON.stringify(config?.imageConfig)};
 const __publicFiles = new Set(${JSON.stringify(publicFiles)});
 const __allowedOrigins = ${JSON.stringify(allowedOrigins)};
 const __expireTime = ${JSON.stringify(expireTime)};
@@ -426,6 +438,8 @@ const __reactMaxHeadersLength = ${JSON.stringify(reactMaxHeadersLength)};
 // mirrors the embedded \`__basePath\` pattern (and Pages Router's
 // \`vinextConfig\` export). Empty string when unset.
 export const __assetPrefix = ${JSON.stringify(assetPrefix)};
+export const __imageAllowedWidths = ${JSON.stringify(imageAllowedWidths)};
+export const __imageConfig = ${JSON.stringify(imageConfig)};
 export const __inlineCss = ${JSON.stringify(inlineCss)};
 export const __hasPagesDir = ${JSON.stringify(hasPagesDir)};
 export const getRenderedConcreteUrlPathsForRoute = __getRenderedConcreteUrlPathsForRoute;
@@ -474,6 +488,7 @@ const rootParamNamesMap = {
 ${rootParamNameEntries.join("\n")}
 };
 
+__setPagesClientAssets(__pagesClientAssets);
 export default createAppRscHandler({
   basePath: __basePath,
   buildId: process.env.__VINEXT_BUILD_ID ?? null,
@@ -488,7 +503,7 @@ export default createAppRscHandler({
   },` : ""}
   configRedirects: __configRedirects,
   configRewrites: __configRewrites,
-  imageConfig: __imageConfig,
+  imageConfig: __runtimeImageConfig,
   isDev: process.env.NODE_ENV !== "production",
   draftModeSecret: __draftModeSecret,
   dispatchMatchedPage({
@@ -520,18 +535,32 @@ export default createAppRscHandler({
     const PageComponent = route.page?.default;
     const __segmentConfig = __resolveAppPageSegmentConfig({
       layouts: route.layouts,
+      layoutTreePositions: route.layoutTreePositions,
       page: route.page,
+      parallelBranches: Object.values(route.slots ?? {}).map((slot) => ({
+        layout: slot.layout,
+        configLayouts: slot.configLayouts,
+        configLayoutTreePositions: slot.configLayoutTreePositions,
+        page: slot.page ?? slot.default,
+        routeSegments: slot.routeSegments,
+      })),
       parallelPages: Object.values(route.slots ?? {}).map((slot) => slot.page ?? slot.default),
-      parallelSegments: Object.values(route.slots ?? {}).flatMap((slot) => [
-        slot.layout,
-        ...(slot.configLayouts ?? []),
-        slot.page ?? slot.default,
-      ]),
+      routeSegments: route.routeSegments,
     });
     const __generateStaticParams = __resolveAppPageGenerateStaticParamsSources({
       layouts: route.layouts,
       layoutTreePositions: route.layoutTreePositions,
       page: route.page,
+      parallelBranches: Object.values(route.slots ?? {}).map((slot) => ({
+        layout: slot.layout,
+        configLayouts: slot.configLayouts,
+        configLayoutTreePositions: slot.configLayoutTreePositions,
+        page: slot.page ?? slot.default,
+        paramNames: slot.slotParamNames,
+        patternParts: slot.slotPatternParts,
+        routeSegments: slot.routeSegments,
+      })),
+      routePatternParts: route.patternParts,
       routeSegments: route.routeSegments,
     });
     const _asyncRouteParams = makeThenableParams(params);
@@ -923,11 +952,12 @@ export default createAppRscHandler({
     });
   },` : ""}
   matchRoute,
-  ${middlewarePath ? `runMiddleware({ cleanPathname, context, isDataRequest, request }) {
+  ${middlewarePath ? `runMiddleware({ cleanPathname, context, hadBasePath, isDataRequest, request }) {
     return __applyAppMiddleware({
       basePath: __basePath,
       cleanPathname,
       context,
+      hadBasePath,
       filePath: ${JSON.stringify(middlewarePath ? normalizePathSeparators(middlewarePath) : "")},
       i18nConfig: __i18nConfig,
       isDataRequest,

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

@@ -181,6 +181,7 @@ ${interceptEntries.join(",\n")}
     layouts: ${moduleArray(route.layouts.length)},
     __loadLayouts: ${layoutLoaders},
     routeSegments: ${JSON.stringify(route.routeSegments)},
+    childrenRouteSegments: ${JSON.stringify(route.childrenRouteSegments ?? null)},
     templateTreePositions: ${JSON.stringify(route.templateTreePositions)},
     layoutTreePositions: ${JSON.stringify(route.layoutTreePositions)},
     templates: ${moduleArray(route.templates.length)},
@@ -193,6 +194,7 @@ ${interceptEntries.join(",\n")}
     slots: {
 ${slotEntries.join(",\n")}
     },
+    childrenSlot: ${JSON.stringify(route.childrenSlot ?? null)},
     siblingIntercepts: [
 ${siblingInterceptEntries.join(",\n")}
     ],

package/dist/entries/pages-client-entry.d.ts

@@ -1,11 +1,14 @@
 import { ResolvedNextConfig } from "../config/next-config.js";
 import { createValidFileMatcher } from "../routing/file-matcher.js";
+import { StaticMiddlewareMatcher } from "../build/report.js";
 import { VinextLinkPrefetchRoute } from "../client/vinext-next-data.js";
 
 //#region src/entries/pages-client-entry.d.ts
 declare function generateClientEntry(pagesDir: string, nextConfig: ResolvedNextConfig, fileMatcher: ReturnType<typeof createValidFileMatcher>, options?: {
   appPrefetchRoutes?: readonly VinextLinkPrefetchRoute[];
   instrumentationClientPath?: string | null;
+  middlewareMatcher?: StaticMiddlewareMatcher | undefined;
+  reactPreamble?: boolean;
 }): Promise<string>;
 //#endregion
 export { generateClientEntry };

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

@@ -3,6 +3,8 @@ 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
 /**
 * Pages Router client hydration entry generator.
@@ -30,6 +32,12 @@ function toPagesLinkPrefetchRoute(route) {
 		patternParts: [...route.patternParts]
 	};
 }
+async function hasGetStaticPropsExport(filePath) {
+	return hasExportedName(await readFile(filePath, "utf8"), "getStaticProps");
+}
+async function hasGetServerSidePropsExport(filePath) {
+	return hasExportedName(await readFile(filePath, "utf8"), "getServerSideProps");
+}
 async function generateClientEntry(pagesDir, nextConfig, fileMatcher, options = {}) {
 	const pageRoutes = await pagesRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);
 	const apiRoutes = await apiRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);
@@ -40,6 +48,8 @@ async function generateClientEntry(pagesDir, nextConfig, fileMatcher, options =
 		...toPagesLinkPrefetchRoute(route),
 		documentOnly: true
 	}))];
+	const pagesSsgPatterns = (await Promise.all(pageRoutes.map(async (route) => await hasGetStaticPropsExport(route.filePath) ? patternToNextFormat(route.pattern) : null))).filter((pattern) => pattern !== null);
+	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);
@@ -47,7 +57,7 @@ async function generateClientEntry(pagesDir, nextConfig, fileMatcher, options =
 		return `  ${JSON.stringify(nextFormatPattern)}: () => import(${JSON.stringify(absPath)})`;
 	});
 	const appFileBase = appFilePath ? normalizePathSeparators(appFilePath) : void 0;
-	return `${instrumentationClientPath ? `import ${JSON.stringify(normalizePathSeparators(instrumentationClientPath))};\n` : ""}
+	return `${instrumentationClientPath ? `import ${JSON.stringify(normalizePathSeparators(instrumentationClientPath))};\n` : ""}${options.reactPreamble === false ? "" : "import \"@vitejs/plugin-react/preamble\";\n"}
 import "vinext/instrumentation-client";
 import React from "react";
 import { hydrateRoot } from "react-dom/client";
@@ -79,6 +89,9 @@ const appLoader = undefined;
 // can iterate in order and trust the first match.
 window.__VINEXT_PAGE_LOADERS__ = pageLoaders;
 window.__VINEXT_PAGE_PATTERNS__ = Object.keys(pageLoaders);
+window.__VINEXT_PAGES_SSG_PATTERNS__ = ${JSON.stringify(pagesSsgPatterns)};
+window.__VINEXT_PAGES_SSP_PATTERNS__ = ${JSON.stringify(pagesSspPatterns)};
+window.__VINEXT_MIDDLEWARE_MATCHER__ = ${JSON.stringify(options.middlewareMatcher)};
 window.__VINEXT_APP_LOADER__ = appLoader;
 // Expose the App Router prefetch manifest so Pages Router \`<Link>\`s and
 // \`Router.prefetch\` can detect when a prefetch target is actually an App
@@ -100,6 +113,7 @@ window.__VINEXT_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(appPrefetchRoutes)};
 // instead of issuing an RSC request). Set here AND in app-browser-entry.ts
 // so whichever entry runs first emits the Pages manifest.
 window.__VINEXT_PAGES_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(pagesPrefetchRoutes)};
+window.__VINEXT_CLIENT_REDIRECTS__ = ${JSON.stringify(nextConfig.redirects)};
 window.__VINEXT_CLIENT_REWRITES__ = ${JSON.stringify(nextConfig.rewrites)};
 
 const nextDataElement = document.getElementById("__NEXT_DATA__");

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

@@ -128,6 +128,8 @@ import Router, { setSSRContext, wrapWithRouterContext, getPagesNavigationIsReady
 import { _runWithCacheState } from "vinext/shims/cache-request-state";
 import { configureMemoryCacheHandler as __configureMemoryCacheHandler } from "vinext/shims/cache-handler";
 import { registerConfiguredCacheAdapters as __registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
+import __pagesClientAssets from "virtual:vinext-pages-client-assets";
+import { setPagesClientAssets as __setPagesClientAssets } from "vinext/server/pages-client-assets";
 import { runWithPrivateCache } from "vinext/cache-runtime";
 import { ensureFetchPatch, runWithFetchCache } from "vinext/fetch-cache";
 import "vinext/router-state";
@@ -164,7 +166,7 @@ export const buildId = ${buildIdJson};
 export function normalizeDataRequest(request) {
   return __normalizePagesDataRequest(request, buildId);
 }
-const __hasMiddleware = ${JSON.stringify(Boolean(middlewarePath))};
+export const hasMiddleware = ${JSON.stringify(Boolean(middlewarePath))};
 
 // Full resolved config for production server (embedded at build time)
 export const vinextConfig = ${vinextConfigJson};
@@ -271,6 +273,7 @@ export function matchApiRoute(url, request) {
 // All next/*-derived values are passed as closures so the handler module
 // stays importable in test environments (the root vite.config.ts only
 // aliases vinext/shims/*, not next/*).
+__setPagesClientAssets(__pagesClientAssets);
 const _renderPage = __createPagesPageHandler({
   pageRoutes,
   errorPageRoute: _errorPageRoute,
@@ -286,7 +289,7 @@ const _renderPage = __createPagesPageHandler({
     disableOptimizedLoading: vinextConfig.disableOptimizedLoading,
   },
   buildId,
-  hasMiddleware: __hasMiddleware,
+  hasMiddleware,
   appAssetPath: _appAssetPath,
   hasRewrites:
     vinextConfig.rewrites.beforeFiles.length > 0 ||

package/dist/image/image-adapters-virtual.d.ts

@@ -0,0 +1,59 @@
+//#region src/image/image-adapters-virtual.d.ts
+/**
+ * Code generation for the `virtual:vinext-image-adapters` module, resolved by
+ * the vinext vite plugin from the user's `images` config ({@link VinextImageConfig}).
+ *
+ * The generated module exports `registerConfiguredImageOptimizer(env)`, which the
+ * server entries call on each request. It self-guards (the optimizer instantiates
+ * once per isolate) and is a no-op when nothing is configured. Registration is
+ * resilient: a factory that throws (e.g. a Cloudflare Images adapter on the
+ * Node.js server, where the `IMAGES` binding can't exist) is logged and skipped
+ * rather than failing every request, so the same config can be registered from
+ * every runtime/router entry. When no optimizer is registered, image requests
+ * fall back to serving the original asset unoptimized.
+ *
+ * Descriptor `options` are inlined into the generated module and forwarded to the
+ * factory at runtime, so a config-time builder like `imagesOptimizer({ binding })`
+ * never touches the Workers runtime — instantiation is deferred to the first
+ * request.
+ *
+ * This mirrors the cache-adapter pattern in `cache/cache-adapters-virtual.ts`.
+ */
+/**
+ * A serializable pointer to an image optimizer adapter module — the shape of the
+ * `images.optimizer` slot in the vinext() plugin config. Produced by an adapter
+ * builder (e.g. `imagesOptimizer(...)` from `@vinext/cloudflare/images/images-optimizer`)
+ * or written by hand. `options` must be JSON-serializable: it is inlined into the
+ * generated registration module and forwarded to the adapter factory at runtime.
+ */
+type ImageAdapterDescriptor<O extends Record<string, unknown> = Record<string, unknown>> = {
+  /**
+   * Module specifier (or absolute path, e.g. from `require.resolve(...)`) whose
+   * default export is an image optimizer factory.
+   */
+  adapter: string; /** JSON-serializable options forwarded to the factory at runtime. */
+  options?: O;
+};
+/**
+ * The `images` option of the vinext() plugin: declaratively register the
+ * server-side image optimizer (transform backend) instead of wiring `env.IMAGES`
+ * into a custom worker entry.
+ *
+ * This is complementary to the `images` field in `next.config.js`, which
+ * configures the standard Next.js image options (`remotePatterns`, `deviceSizes`,
+ * `dangerouslyAllowSVG`, etc.). Those continue to be read from next.config; this
+ * option only selects the runtime transform backend, which can't be expressed as
+ * serializable next.config data.
+ */
+type VinextImageConfig = {
+  /** Server-side image optimizer adapter (the `/_next/image` transform backend). */optimizer?: ImageAdapterDescriptor;
+};
+/** Public virtual module id imported by the server entries. */
+declare const VIRTUAL_IMAGE_ADAPTERS = "virtual:vinext-image-adapters";
+/**
+ * Generate the source of the `virtual:vinext-image-adapters` module for the
+ * given config. Always exports `registerConfiguredImageOptimizer(env)`.
+ */
+declare function generateImageAdaptersModule(images?: VinextImageConfig): string;
+//#endregion
+export { VIRTUAL_IMAGE_ADAPTERS, VinextImageConfig, generateImageAdaptersModule };