@qzsy/vinext 0.1.7

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

@@ -0,0 +1,398 @@
+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";
+//#region src/entries/pages-server-entry.ts
+/**
+* Pages Router server entry generator.
+*
+* Generates the virtual SSR server entry module (`virtual:vinext-server-entry`).
+* This is the entry point for `vite build --ssr`. It handles SSR, API routes,
+* middleware, ISR, and i18n for the Pages Router.
+*
+* Extracted from index.ts.
+*/
+const _requestContextShimPath = resolveEntryPath("../shims/request-context.js", import.meta.url);
+const _middlewareRuntimePath = resolveEntryPath("../server/middleware-runtime.js", import.meta.url);
+const _routeTriePath = resolveEntryPath("../routing/route-trie.js", import.meta.url);
+const _pagesI18nPath = resolveEntryPath("../server/pages-i18n.js", import.meta.url);
+const _pagesDataRoutePath = resolveEntryPath("../server/pages-data-route.js", import.meta.url);
+const _pagesDefault404Path = resolveEntryPath("../server/pages-default-404.js", import.meta.url);
+const _pagesApiRoutePath = resolveEntryPath("../server/pages-api-route.js", import.meta.url);
+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);
+/**
+* Generate the virtual SSR server entry module.
+* This is the entry point for `vite build --ssr`.
+*/
+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 pageRouteEntries = pageRoutes.map((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 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);
+	const errorFilePath = findFileWithExts(pagesDir, "_error", fileMatcher);
+	const appAssetPathJson = appFilePath !== null ? JSON.stringify(appFilePath) : "null";
+	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 i18nConfigJson = nextConfig?.i18n ? JSON.stringify({
+		locales: nextConfig.i18n.locales,
+		defaultLocale: nextConfig.i18n.defaultLocale,
+		localeDetection: nextConfig.i18n.localeDetection,
+		domains: nextConfig.i18n.domains
+	}) : "null";
+	const buildIdJson = JSON.stringify(nextConfig?.buildId ?? null);
+	const vinextConfigJson = JSON.stringify({
+		basePath: nextConfig?.basePath ?? "",
+		assetPrefix: nextConfig?.assetPrefix ?? "",
+		trailingSlash: nextConfig?.trailingSlash ?? false,
+		redirects: nextConfig?.redirects ?? [],
+		rewrites: nextConfig?.rewrites ?? {
+			beforeFiles: [],
+			afterFiles: [],
+			fallback: []
+		},
+		headers: nextConfig?.headers ?? [],
+		expireTime: nextConfig?.expireTime,
+		cacheMaxMemorySize: nextConfig?.cacheMaxMemorySize,
+		htmlLimitedBots: nextConfig?.htmlLimitedBots,
+		i18n: nextConfig?.i18n ?? null,
+		disableOptimizedLoading: nextConfig?.disableOptimizedLoading === true,
+		clientTraceMetadata: nextConfig?.clientTraceMetadata,
+		images: {
+			deviceSizes: nextConfig?.images?.deviceSizes,
+			imageSizes: nextConfig?.images?.imageSizes,
+			qualities: nextConfig?.images?.qualities,
+			dangerouslyAllowSVG: nextConfig?.images?.dangerouslyAllowSVG,
+			dangerouslyAllowLocalIP: nextConfig?.images?.dangerouslyAllowLocalIP,
+			contentDispositionType: nextConfig?.images?.contentDispositionType,
+			contentSecurityPolicy: nextConfig?.images?.contentSecurityPolicy
+		}
+	});
+	const instrumentationImportCode = instrumentationPath ? `import * as _instrumentation from ${JSON.stringify(normalizePathSeparators(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.
+if (typeof _instrumentation.register === "function") {
+  await _instrumentation.register();
+}
+// Store the onRequestError handler on globalThis so it is visible to all
+// code within the Worker (same global scope).
+if (typeof _instrumentation.onRequestError === "function") {
+  globalThis.__VINEXT_onRequestErrorHandler__ = _instrumentation.onRequestError;
+}` : "";
+	const middlewareImportCode = middlewarePath ? `import * as middlewareModule from ${JSON.stringify(normalizePathSeparators(middlewarePath))};` : "";
+	const middlewareExportCode = middlewarePath ? `
+export async function runMiddleware(request, ctx, options) {
+  return __runGeneratedMiddleware({
+    basePath: vinextConfig.basePath,
+    ctx,
+    filePath: ${JSON.stringify(normalizePathSeparators(middlewarePath))},
+    i18nConfig,
+    isDataRequest: options?.isDataRequest === true,
+    isProxy: ${JSON.stringify(isProxyFile(middlewarePath))},
+    module: middlewareModule,
+    request,
+    trailingSlash: vinextConfig.trailingSlash,
+  });
+}
+` : `
+export async function runMiddleware(request) {
+  return { continue: true };
+}
+`;
+	return `
+import ${JSON.stringify(_serverGlobalsPath)};
+import React from "react";
+import { renderToReadableStream } from "react-dom/server.edge";
+import { resetSSRHead, getSSRHeadHTML, setDocumentInitialHead } from "next/head";
+import { flushPreloads } from "next/dynamic";
+import Router, { setSSRContext, wrapWithRouterContext, getPagesNavigationIsReadyFromSerializedState } from "next/router";
+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 { runWithPrivateCache } from "vinext/cache-runtime";
+import { ensureFetchPatch, runWithFetchCache } from "vinext/fetch-cache";
+import "vinext/router-state";
+import { runWithServerInsertedHTMLState } from "vinext/navigation-state";
+import { runWithHeadState } from "vinext/head-state";
+import "vinext/i18n-state";
+import { setI18nContext } from "vinext/i18n-context";
+import { safeJsonStringify } from "vinext/html";
+import { mergeRouteParamsIntoQuery, parseQueryString as parseQuery } from ${JSON.stringify(_queryUtilsPath)};
+import { getSSRFontLinks as _getSSRFontLinks, getSSRFontStyles as _getSSRFontStylesGoogle, getSSRFontPreloads as _getSSRFontPreloadsGoogle } from "next/font/google";
+import { getSSRFontStyles as _getSSRFontStylesLocal, getSSRFontPreloads as _getSSRFontPreloadsLocal } from "next/font/local";
+import { sanitizeDestination as sanitizeDestinationLocal } from ${JSON.stringify(resolveEntryPath("../config/config-matchers.js", import.meta.url))};
+import { runWithExecutionContext as _runWithExecutionContext } from ${JSON.stringify(_requestContextShimPath)};
+import { runGeneratedMiddleware as __runGeneratedMiddleware } from ${JSON.stringify(_middlewareRuntimePath)};
+import { buildRouteTrie as _buildRouteTrie, trieMatch as _trieMatch } from ${JSON.stringify(_routeTriePath)};
+import { reportRequestError as _reportRequestError } from "vinext/instrumentation";
+import { resolvePagesI18nRequest } from ${JSON.stringify(_pagesI18nPath)};
+import { handlePagesApiRoute as __handlePagesApiRoute } from ${JSON.stringify(_pagesApiRoutePath)};
+import { normalizePagesDataRequest as __normalizePagesDataRequest, buildNextDataNotFoundResponse as __buildNextDataNotFoundResponse } from ${JSON.stringify(_pagesDataRoutePath)};
+import { buildDefaultPagesNotFoundResponse as __buildDefaultPagesNotFoundResponse } from ${JSON.stringify(_pagesDefault404Path)};
+import { createPagesPageHandler as __createPagesPageHandler } from ${JSON.stringify(_pagesPageHandlerPath)};
+${instrumentationImportCode}
+${middlewareImportCode}
+
+${instrumentationInitCode}
+
+// i18n config (embedded at build time)
+const i18nConfig = ${i18nConfigJson};
+
+// Build ID (embedded at build time). Exported so the production server can
+// match _next/data requests against the embedded buildId without needing
+// to load next.config.js at runtime.
+export const buildId = ${buildIdJson};
+export function normalizeDataRequest(request) {
+  return __normalizePagesDataRequest(request, buildId);
+}
+const __hasMiddleware = ${JSON.stringify(Boolean(middlewarePath))};
+
+// Full resolved config for production server (embedded at build time)
+export const vinextConfig = ${vinextConfigJson};
+
+// Default to the in-memory data cache; a configured cache.data/cache.cdn adapter
+// overrides it on the first request via registerConfiguredCacheAdapters (called
+// from renderPage/handleApiRoute below, and with env from the worker entry on
+// Cloudflare). The registration self-guards, so the first call wins.
+__configureMemoryCacheHandler({ cacheMaxMemorySize: vinextConfig.cacheMaxMemorySize });
+
+// Path to the user's pages/_app file (or null). Used to look up the
+// _app's CSS/JS chunks in the SSR manifest so any global styles imported
+// by _app are included in every page's <link rel="stylesheet"> set.
+const _appAssetPath = ${appAssetPathJson};
+
+async function _renderToStringAsync(element) {
+  const stream = await renderToReadableStream(element);
+  await stream.allReady;
+  return new Response(stream).text();
+}
+
+async function _renderIsrPassToStringAsync(element) {
+  // The cache-fill render is a second render pass for the same request.
+  // Reset render-scoped state so it cannot leak from the streamed response
+  // render or affect async work that is still draining from that stream.
+  // Keep request identity state (pathname/query/locale/executionContext)
+  // intact: this second pass still belongs to the same request.
+  return await runWithServerInsertedHTMLState(() =>
+    runWithHeadState(() =>
+      _runWithCacheState(() =>
+        runWithPrivateCache(() => runWithFetchCache(async () => _renderToStringAsync(element))),
+      ),
+    ),
+  );
+}
+
+${pageImports.join("\n")}
+${apiImports.join("\n")}
+
+${appImportCode}
+${docImportCode}
+${errorImportCode}
+
+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 apiRoutes = [
+${apiRouteEntries.join(",\n")}
+];
+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.
+  const urlParts = normalizedUrl.split("/").filter(Boolean);
+  const trie = routes === pageRoutes ? _pageRouteTrie : _apiRouteTrie;
+  return _trieMatch(trie, urlParts);
+}
+
+export function matchPageRoute(url, request) {
+  const routeUrl = i18nConfig && request
+    ? resolvePagesI18nRequest(
+        url,
+        i18nConfig,
+        request.headers,
+        new URL(request.url).hostname,
+        vinextConfig.basePath,
+        vinextConfig.trailingSlash,
+      ).url
+    : url;
+  return matchRoute(routeUrl, pageRoutes);
+}
+
+export function matchApiRoute(url, request) {
+  const routeUrl = i18nConfig && request
+    ? resolvePagesI18nRequest(
+        url,
+        i18nConfig,
+        request.headers,
+        new URL(request.url).hostname,
+        vinextConfig.basePath,
+        vinextConfig.trailingSlash,
+      ).url
+    : url;
+  return matchRoute(routeUrl, apiRoutes);
+}
+
+// ── Pages render orchestrator — delegates to server/pages-page-handler.ts ──
+//
+// 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/*).
+const _renderPage = __createPagesPageHandler({
+  pageRoutes,
+  errorPageRoute: _errorPageRoute,
+  matchRoute: (url) => matchRoute(url, pageRoutes),
+  i18nConfig,
+  vinextConfig: {
+    basePath: vinextConfig.basePath,
+    assetPrefix: vinextConfig.assetPrefix,
+    trailingSlash: vinextConfig.trailingSlash,
+    expireTime: vinextConfig.expireTime,
+    htmlLimitedBots: vinextConfig.htmlLimitedBots,
+    clientTraceMetadata: vinextConfig.clientTraceMetadata,
+    disableOptimizedLoading: vinextConfig.disableOptimizedLoading,
+  },
+  buildId,
+  hasMiddleware: __hasMiddleware,
+  appAssetPath: _appAssetPath,
+  hasRewrites:
+    vinextConfig.rewrites.beforeFiles.length > 0 ||
+    vinextConfig.rewrites.afterFiles.length > 0 ||
+    vinextConfig.rewrites.fallback.length > 0,
+
+  // next/*-derived closures
+  setSSRContext: typeof setSSRContext === "function" ? setSSRContext : null,
+  getPagesNavigationIsReadyFromSerializedState:
+    typeof getPagesNavigationIsReadyFromSerializedState === "function"
+      ? getPagesNavigationIsReadyFromSerializedState
+      : null,
+  setI18nContext: typeof setI18nContext === "function" ? setI18nContext : null,
+  wrapWithRouterContext: typeof wrapWithRouterContext === "function" ? wrapWithRouterContext : null,
+  resetSSRHead: typeof resetSSRHead === "function" ? resetSSRHead : undefined,
+  getSSRHeadHTML: typeof getSSRHeadHTML === "function" ? getSSRHeadHTML : undefined,
+  setDocumentInitialHead: typeof setDocumentInitialHead === "function" ? setDocumentInitialHead : undefined,
+  flushPreloads: typeof flushPreloads === "function" ? flushPreloads : undefined,
+  getFontLinks() {
+    try { return typeof _getSSRFontLinks === "function" ? _getSSRFontLinks() : []; } catch { return []; }
+  },
+  getFontStyles() {
+    try {
+      const styles = [];
+      if (typeof _getSSRFontStylesGoogle === "function") styles.push(..._getSSRFontStylesGoogle());
+      if (typeof _getSSRFontStylesLocal === "function") styles.push(..._getSSRFontStylesLocal());
+      return styles;
+    } catch { return []; }
+  },
+  getFontPreloads() {
+    try {
+      const preloads = [];
+      if (typeof _getSSRFontPreloadsGoogle === "function") preloads.push(..._getSSRFontPreloadsGoogle());
+      if (typeof _getSSRFontPreloadsLocal === "function") preloads.push(..._getSSRFontPreloadsLocal());
+      return preloads;
+    } catch { return []; }
+  },
+  renderToReadableStream,
+  renderIsrPassToStringAsync: _renderIsrPassToStringAsync,
+  safeJsonStringify,
+  sanitizeDestination: sanitizeDestinationLocal,
+  createPageElement(PageComponent, AppComponent, props) {
+    const rawPageProps = props?.pageProps;
+    const pageProps = rawPageProps && typeof rawPageProps === "object"
+      ? props.pageProps
+      : {};
+    return AppComponent
+      ? React.createElement(AppComponent, {
+          ...props,
+          Component: PageComponent,
+          pageProps: rawPageProps,
+          router: Router,
+        })
+      : React.createElement(PageComponent, pageProps);
+  },
+  enhancePageElement(PageComponent, AppComponent, props, opts) {
+    const rawPageProps = props?.pageProps;
+    const pageProps = rawPageProps && typeof rawPageProps === "object"
+      ? props.pageProps
+      : {};
+    let FinalApp = AppComponent;
+    let FinalComp = PageComponent;
+    if (opts && typeof opts.enhanceApp === "function" && FinalApp) FinalApp = opts.enhanceApp(FinalApp);
+    if (opts && typeof opts.enhanceComponent === "function") FinalComp = opts.enhanceComponent(FinalComp);
+    return FinalApp
+      ? React.createElement(FinalApp, {
+          ...props,
+          Component: FinalComp,
+          pageProps: rawPageProps,
+          router: Router,
+        })
+      : React.createElement(FinalComp, pageProps);
+  },
+  AppComponent,
+  DocumentComponent,
+});
+
+export async function renderPage(request, url, manifest, ctx, middlewareHeaders, options) {
+  __registerConfiguredCacheAdapters();
+  if (ctx) return _runWithExecutionContext(ctx, () => _renderPage(request, url, manifest, middlewareHeaders, options));
+  return _renderPage(request, url, manifest, middlewareHeaders, options);
+}
+
+
+
+export async function handleApiRoute(request, url, ctx) {
+  __registerConfiguredCacheAdapters();
+  const match = matchRoute(url, apiRoutes);
+  return __handlePagesApiRoute({
+    ctx,
+    match,
+    nextConfig: vinextConfig,
+    request,
+    url,
+    reportRequestError(error, routePattern) {
+      console.error("[vinext] API error:", error);
+      void _reportRequestError(
+        error,
+        { path: url, method: request.method, headers: Object.fromEntries(request.headers.entries()) },
+        { routerKind: "Pages Router", routePath: routePattern, routeType: "route" },
+      );
+    },
+  });
+}
+
+${middlewareExportCode}
+`;
+}
+//#endregion
+export { generateServerEntry };

package/dist/entries/runtime-entry-module.d.ts

@@ -0,0 +1,25 @@
+//#region src/entries/runtime-entry-module.d.ts
+/**
+ * Resolve a sibling module path relative to a caller's `import.meta.url`,
+ * returning a forward-slash path safe for embedding in generated code.
+ *
+ * This is the single place that owns the
+ * `fileURLToPath(new URL(rel, base))` + path-separator normalization idiom so
+ * callers don't duplicate it.
+ *
+ * @param rel  - Relative path to the target module (e.g. `"../server/foo.js"`)
+ * @param base - The caller's `import.meta.url`
+ */
+declare function resolveEntryPath(rel: string, base: string): string;
+/**
+ * Resolve a real runtime module for a virtual entry generator.
+ *
+ * During local development we want to point at source files (for example `.ts`),
+ * while packed builds only contain emitted `.js` files in `dist/`. Probe the
+ * common source/build extensions and fall back to the `.js` path that exists in
+ * published packages.
+ */
+declare function resolveRuntimeEntryModule(name: string): string;
+declare function resolveClientRuntimeModule(name: string): string;
+//#endregion
+export { resolveClientRuntimeModule, resolveEntryPath, resolveRuntimeEntryModule };

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

@@ -0,0 +1,46 @@
+import { normalizePathSeparators } from "../utils/path.js";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/entries/runtime-entry-module.ts
+/**
+* Resolve a sibling module path relative to a caller's `import.meta.url`,
+* returning a forward-slash path safe for embedding in generated code.
+*
+* This is the single place that owns the
+* `fileURLToPath(new URL(rel, base))` + path-separator normalization idiom so
+* callers don't duplicate it.
+*
+* @param rel  - Relative path to the target module (e.g. `"../server/foo.js"`)
+* @param base - The caller's `import.meta.url`
+*/
+function resolveEntryPath(rel, base) {
+	return normalizePathSeparators(fileURLToPath(new URL(rel, base)));
+}
+/**
+* Resolve a real runtime module for a virtual entry generator.
+*
+* During local development we want to point at source files (for example `.ts`),
+* while packed builds only contain emitted `.js` files in `dist/`. Probe the
+* common source/build extensions and fall back to the `.js` path that exists in
+* published packages.
+*/
+function resolveRuntimeEntryModule(name) {
+	return resolveRuntimeModulePath("server", name);
+}
+function resolveClientRuntimeModule(name) {
+	return resolveRuntimeModulePath("client", name);
+}
+function resolveRuntimeModulePath(directory, name) {
+	for (const ext of [
+		".ts",
+		".js",
+		".mts",
+		".mjs"
+	]) {
+		const filePath = resolveEntryPath(`../${directory}/${name}${ext}`, import.meta.url);
+		if (fs.existsSync(filePath)) return filePath;
+	}
+	return resolveEntryPath(`../${directory}/${name}.js`, import.meta.url);
+}
+//#endregion
+export { resolveClientRuntimeModule, resolveEntryPath, resolveRuntimeEntryModule };

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+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 { PluginOption } from "vite";
+import { Options } from "@vitejs/plugin-react";
+
+//#region src/index.d.ts
+type VinextOptions = {
+  /**
+   * Base directory containing the app/ and pages/ directories.
+   * Can be an absolute path or a path relative to the Vite root.
+   *
+   * By default, vinext auto-detects: checks for app/ and pages/ at the
+   * project root first, then falls back to src/app/ and src/pages/.
+   */
+  appDir?: string;
+  /**
+   * Force-disable App Router detection even when an app/ directory exists.
+   * Only the Pages Router pipeline will be active.
+   * Intended for testing and tools that need to build only the Pages Router
+   * bundle from a hybrid (app + pages) project.
+   * @default false
+   */
+  disableAppRouter?: boolean;
+  /**
+   * Override the output directory for the RSC server bundle.
+   * Absolute paths are used as-is; relative paths are resolved from the
+   * Vite root. Defaults to "dist/server".
+   * Intended for tests that need to build multiple fixtures in parallel
+   * without clobbering each other's output.
+   */
+  rscOutDir?: string;
+  /**
+   * Override the output directory for the SSR bundle.
+   * Defaults to "dist/server/ssr".
+   */
+  ssrOutDir?: string;
+  /**
+   * Override the output directory for the client bundle.
+   * Defaults to Vite's default (dist/client or dist).
+   */
+  clientOutDir?: string;
+  /**
+   * Inline Next.js config for projects that want to configure vinext from
+   * vite.config without a separate next.config file.
+   *
+   * When provided, vinext skips loading next.config.* from disk and uses this
+   * value instead. Supports both object-form and function-form config.
+   */
+  nextConfig?: NextConfigInput;
+  /**
+   * Auto-register @vitejs/plugin-rsc when an app/ directory is detected.
+   * Set to `false` to disable auto-registration (e.g. if you configure
+   * @vitejs/plugin-rsc manually with custom options).
+   * @default true
+   */
+  rsc?: boolean;
+  /**
+   * Options passed to @vitejs/plugin-react (React Fast Refresh + JSX transform).
+   * Enabled by default. Set to `false` to disable (e.g. if you configure
+   * @vitejs/plugin-react manually in your vite.config.ts), or pass an options
+   * object to customize the Babel transform.
+   * @default true
+   */
+  react?: Options | boolean;
+  /**
+   * Enable build-time precompression of static assets (.br, .gz, .zst).
+   *
+   * When enabled, hashed assets in the client build are precompressed at
+   * build time so the production server can serve them without on-the-fly
+   * compression overhead.
+   *
+   * Disabled by default. Not useful when deploying to edge platforms
+   * (Cloudflare Workers, Nitro) that handle compression at the CDN layer.
+   *
+   * Can also be enabled via the `--precompress` CLI flag or by setting the
+   * `VINEXT_PRECOMPRESS=1` environment variable (useful for CI pipelines
+   * that need to enable precompression without modifying vite.config.ts).
+   * @default false
+   */
+  precompress?: boolean;
+  /**
+   * Configure cache handlers declaratively, so you don't need a custom worker
+   * entry that calls `setDataCacheHandler()` / `setCdnCacheAdapter()`. Each slot
+   * is a `{ adapter, options }` descriptor pointing at an adapter module whose
+   * default export is a factory; the plugin registers them automatically on the
+   * first request, passing the host `env` (Worker bindings) so adapters that
+   * need a binding — e.g. a KV namespace — can read it.
+   *
+   * @example
+   * import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";
+   *
+   * vinext({
+   *   cache: {
+   *     data: kvDataAdapter({ binding: "MY_KV" }),
+   *   },
+   * })
+   */
+  cache?: VinextCacheConfig;
+  /**
+   * Experimental vinext-only feature flags.
+   */
+  experimental?: {
+    /**
+     * Dedup client references emitted from RSC proxy modules in dev.
+     * Disabled by default until the behavior is better proven across
+     * ecosystem apps.
+     * @default false
+     */
+    clientReferenceDedup?: boolean;
+  };
+};
+declare function vinext(options?: VinextOptions): PluginOption[];
+//#endregion
+export { type AppStaticExportOptions, type NextConfig, type StaticExportOptions, type StaticExportResult, VinextOptions, vinext as default, staticExportApp, staticExportPages };