vinext 0.1.8 → 0.2.1

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);
@@ -77,16 +78,25 @@ function generateRscEntry(appDir, routes, middlewarePath, metadataRoutes, global
 	const cacheMaxMemorySize = config?.cacheMaxMemorySize;
 	const inlineCss = config?.inlineCss === true;
 	const cacheComponents = config?.cacheComponents === true;
+	const prefetchInlining = config?.prefetchInlining ?? false;
 	const hasServerActions = config?.hasServerActions !== false;
 	const i18nConfig = config?.i18n ?? null;
 	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 +133,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 +366,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 +428,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 +439,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,10 +489,12 @@ const rootParamNamesMap = {
 ${rootParamNameEntries.join("\n")}
 };
 
+__setPagesClientAssets(__pagesClientAssets);
 export default createAppRscHandler({
   basePath: __basePath,
   buildId: process.env.__VINEXT_BUILD_ID ?? null,
   ensureRouteLoaded: __ensureRouteLoaded,
+  prefetchInlining: ${JSON.stringify(prefetchInlining)},
   clearRequestContext() {
     __clearRequestContext();
   },
@@ -488,7 +505,7 @@ export default createAppRscHandler({
   },` : ""}
   configRedirects: __configRedirects,
   configRewrites: __configRewrites,
-  imageConfig: __imageConfig,
+  imageConfig: __runtimeImageConfig,
   isDev: process.env.NODE_ENV !== "production",
   draftModeSecret: __draftModeSecret,
   dispatchMatchedPage({
@@ -512,6 +529,7 @@ export default createAppRscHandler({
     staticParamsValidationParams,
     rootParams,
     request,
+    renderedPathAndSearch,
     route,
     scriptNonce,
     searchParams,
@@ -520,18 +538,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);
@@ -664,6 +696,7 @@ export default createAppRscHandler({
       prerenderToReadableStream,
       request,
       revalidateSeconds: __segmentConfig.revalidateSeconds,
+      renderedPathAndSearch,
       resolveRouteFetchCacheMode(targetRoute) {
         return __resolveRouteFetchCacheMode(targetRoute);
       },
@@ -923,11 +956,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,10 @@ 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` : ""}
+	const userInstrumentationImport = instrumentationClientPath ? `import ${JSON.stringify(normalizePathSeparators(instrumentationClientPath))};\n` : "";
+	const reactPreambleImport = options.reactPreamble === false ? "" : "import \"@vitejs/plugin-react/preamble\";\n";
+	const reactStrictModeEnabled = nextConfig.reactStrictMode === true;
+	return `${userInstrumentationImport}${reactPreambleImport}
 import "vinext/instrumentation-client";
 import React from "react";
 import { hydrateRoot } from "react-dom/client";
@@ -79,6 +92,12 @@ const appLoader = undefined;
 // can iterate in order and trust the first match.
 window.__VINEXT_PAGE_LOADERS__ = pageLoaders;
 window.__VINEXT_PAGE_PATTERNS__ = Object.keys(pageLoaders);
+// reactStrictMode flag — read by wrapWithRouterContext (next/router) so the
+// <React.StrictMode> wrap is applied on initial hydration and every navigation.
+window.__VINEXT_REACT_STRICT_MODE__ = ${JSON.stringify(reactStrictModeEnabled)};
+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 +119,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__");
@@ -172,6 +192,9 @@ async function hydrate() {
   });
 
   // Wrap with RouterContext.Provider so next/router and next/compat/router work during hydration.
+  // When reactStrictMode is enabled, wrapWithRouterContext also wraps the tree
+  // in <React.StrictMode> (see next/router) — applied here and on every
+  // navigation render, matching Next.js.
   element = wrapWithRouterContext(element, resolveHydrationCommit);
 
   const container = document.getElementById("__next");
@@ -190,9 +213,11 @@ async function hydrate() {
   window.__NEXT_HYDRATED_CB?.();
 
   if (nextData.isFallback) {
+    const currentUrl = window.location.pathname + window.location.search + window.location.hash;
+    const routeUrl = nextData.__vinext?.routeUrl;
     await Router.replace(
-      window.location.pathname + window.location.search + window.location.hash,
-      undefined,
+      routeUrl || currentUrl,
+      routeUrl ? currentUrl : undefined,
       { _h: 1, scroll: false },
     );
   }

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

@@ -4,6 +4,8 @@ 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
 /**
 * Pages Router server entry generator.
@@ -24,6 +26,12 @@ const _pagesApiRoutePath = resolveEntryPath("../server/pages-api-route.js", impo
 const _serverGlobalsPath = resolveEntryPath("../server/server-globals.js", import.meta.url);
 const _queryUtilsPath = resolveEntryPath("../utils/query.js", import.meta.url);
 const _pagesPageHandlerPath = resolveEntryPath("../server/pages-page-handler.js", import.meta.url);
+async function getPagesDataKind(filePath) {
+	const source = await readFile(filePath, "utf8");
+	if (hasExportedName(source, "getStaticProps")) return "static";
+	if (hasExportedName(source, "getServerSideProps")) return "server";
+	return "none";
+}
 /**
 * Generate the virtual SSR server entry module.
 * This is the entry point for `vite build --ssr`.
@@ -39,10 +47,11 @@ async function generateServerEntry(pagesDir, nextConfig, fileMatcher, middleware
 		const absPath = normalizePathSeparators(r.filePath);
 		return `import * as api_${i} from ${JSON.stringify(absPath)};`;
 	});
-	const pageRouteEntries = pageRoutes.map((r, i) => {
+	const pageRouteEntries = await Promise.all(pageRoutes.map(async (r, i) => {
 		const absPath = normalizePathSeparators(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)} }`;
-	});
+		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)} }`;
+	}));
 	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);
 	const docFilePath = findFileWithExts(pagesDir, "_document", fileMatcher);
@@ -128,6 +137,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";
@@ -162,9 +173,14 @@ const i18nConfig = ${i18nConfigJson};
 // to load next.config.js at runtime.
 export const buildId = ${buildIdJson};
 export function normalizeDataRequest(request) {
-  return __normalizePagesDataRequest(request, buildId);
+  return __normalizePagesDataRequest(
+    request,
+    buildId,
+    vinextConfig.basePath,
+    hasMiddleware && vinextConfig.trailingSlash,
+  );
 }
-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 +287,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 +303,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 };

package/dist/image/image-adapters-virtual.js

@@ -0,0 +1,59 @@
+//#region src/image/image-adapters-virtual.ts
+/** Public virtual module id imported by the server entries. */
+const VIRTUAL_IMAGE_ADAPTERS = "virtual:vinext-image-adapters";
+/**
+* Serialize descriptor options into a JS expression for inlining. Plain JSON is
+* a valid JS literal; `undefined` when there are no options. Throws a clear
+* config-time error (not a runtime one) if options are not serializable.
+*/
+function inlineOptions(adapter, options) {
+	if (options === void 0) return "undefined";
+	try {
+		return JSON.stringify(options);
+	} catch (cause) {
+		throw new Error(`[vinext] image adapter "${adapter}" options must be JSON-serializable.`, { cause });
+	}
+}
+/**
+* Generate the source of the `virtual:vinext-image-adapters` module for the
+* given config. Always exports `registerConfiguredImageOptimizer(env)`.
+*/
+function generateImageAdaptersModule(images) {
+	const optimizer = images?.optimizer;
+	if (!optimizer?.adapter) return [
+		"// vinext: no images.optimizer adapter configured — registration is a no-op.",
+		"export function registerConfiguredImageOptimizer() {}",
+		""
+	].join("\n");
+	return [
+		"// vinext: generated from the `images` option in your vinext() plugin config.",
+		`import __vinextImageOptimizerFactory from ${JSON.stringify(optimizer.adapter)};`,
+		`import { setImageOptimizer } from "vinext/server/image-optimization";`,
+		"",
+		"// A factory that throws (e.g. a missing binding on an incompatible runtime)",
+		"// is logged and skipped so images fall back to unoptimized passthrough.",
+		"function __vinextFormatAdapterError(error) {",
+		"  if (error instanceof Error && error.message) return error.message;",
+		"  try {",
+		"    return String(error);",
+		"  } catch {",
+		"    return '<unknown error>';",
+		"  }",
+		"}",
+		"",
+		"let __vinextImageOptimizerRegistered = false;",
+		"",
+		"export function registerConfiguredImageOptimizer(env) {",
+		"  if (__vinextImageOptimizerRegistered) return;",
+		"  __vinextImageOptimizerRegistered = true;",
+		"  try {",
+		`    setImageOptimizer(__vinextImageOptimizerFactory({ env, options: ${inlineOptions(optimizer.adapter, optimizer.options)} }));`,
+		"  } catch (error) {",
+		"    console.warn(\"[vinext] failed to initialize the configured image optimizer; serving images unoptimized.\\n\" + __vinextFormatAdapterError(error));",
+		"  }",
+		"}",
+		""
+	].join("\n");
+}
+//#endregion
+export { VIRTUAL_IMAGE_ADAPTERS, generateImageAdaptersModule };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { NextConfig, NextConfigInput } from "./config/next-config.js";
 import { AppStaticExportOptions, StaticExportOptions, StaticExportResult, staticExportApp, staticExportPages } from "./build/static-export.js";
 import { VinextCacheConfig } from "./cache/cache-adapters-virtual.js";
+import { VinextPrerenderConfig } from "./config/prerender.js";
+import { VinextImageConfig } from "./image/image-adapters-virtual.js";
 import { PluginOption } from "vite";
 import { Options } from "@vitejs/plugin-react";
 
@@ -79,6 +81,26 @@ type VinextOptions = {
    * @default false
    */
   precompress?: boolean;
+  /**
+   * Pre-render routes after `vinext build` without passing
+   * `--prerender-all`.
+   *
+   * Use `true` as shorthand for `{ routes: "*" }`. The object form is
+   * available so future releases can support narrower route selections, but
+   * currently only `"*"` is supported.
+   *
+   * The `vinext build --prerender-all` and `vinext deploy --prerender-all`
+   * flags still work and take priority when present.
+   *
+   * @example
+   * vinext({ prerender: true })
+   *
+   * @example
+   * vinext({ prerender: { routes: "*" } })
+   *
+   * @default undefined
+   */
+  prerender?: VinextPrerenderConfig;
   /**
    * Configure cache handlers declaratively, so you don't need a custom worker
    * entry that calls `setDataCacheHandler()` / `setCdnCacheAdapter()`. Each slot
@@ -97,6 +119,17 @@ type VinextOptions = {
    * })
    */
   cache?: VinextCacheConfig;
+  /**
+   * Configure the server-side image optimizer declaratively. The adapter factory
+   * receives the host `env`, allowing bindings such as Cloudflare Images to be
+   * used by both built-in and custom worker entrypoints that forward `env`.
+   *
+   * @example
+   * import { imagesOptimizer } from "@vinext/cloudflare/images/images-optimizer";
+   *
+   * vinext({ images: { optimizer: imagesOptimizer() } })
+   */
+  images?: VinextImageConfig;
   /**
    * Experimental vinext-only feature flags.
    */