vinext 0.2.1 → 1.0.0-beta.1

package/dist/utils/plugin-options.js

@@ -0,0 +1,8 @@
+//#region src/utils/plugin-options.ts
+async function flattenPluginOptions(value) {
+	if (value instanceof Promise) return flattenPluginOptions(await value);
+	if (Array.isArray(value)) return (await Promise.all(value.map((item) => flattenPluginOptions(item)))).flat();
+	return value ? [value] : [];
+}
+//#endregion
+export { flattenPluginOptions };

package/dist/utils/project.d.ts

@@ -110,17 +110,11 @@ _isResolvable?: (root: string, pkg: string) => boolean): MissingDep[];
  * Return the first candidate directory (resolved against `root`) that exists,
  * or null. Used to locate conventional `app`/`pages` directories that may live
  * at the root or under `src/`.
- *
- * `root` and `candidates` must be forward-slash, and the returned path is
- * forward-slash too: the candidate is joined with `path.posix.join`, which only
- * stays canonical when its inputs already are.
  */
 declare function findDir(root: string, ...candidates: string[]): string | null;
 /**
  * Check if the project uses App Router (has an app/ directory).
- *
- * `root` must be forward-slash — it is passed straight to `findDir`.
  */
 declare function hasAppDir(root: string): boolean;
 //#endregion
-export { ProjectInfo, detectPackageManager, detectPackageManagerName, detectProject, ensureESModule, ensureViteConfigCompatibility, findDir, findInNodeModules, findViteConfigPath, formatMissingCloudflarePluginError, getMissingDeps, hasAppDir, hasViteConfig, hasWranglerConfig, isPackageResolvable, renameCJSConfigs };
+export { PackageManagerName, ProjectInfo, detectPackageManager, detectPackageManagerName, detectProject, ensureESModule, ensureViteConfigCompatibility, findDir, findInNodeModules, findViteConfigPath, formatMissingCloudflarePluginError, getMissingDeps, hasAppDir, hasViteConfig, hasWranglerConfig, isPackageResolvable, renameCJSConfigs };

package/dist/utils/project.js

@@ -1,6 +1,6 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
-import path from "node:path";
 //#region src/utils/project.ts
 /**
 * Shared project utilities used by `vinext init`, the vinext plugin, and
@@ -412,14 +412,10 @@ function getMissingDeps(info, _isResolvable = isPackageResolvable) {
 * Return the first candidate directory (resolved against `root`) that exists,
 * or null. Used to locate conventional `app`/`pages` directories that may live
 * at the root or under `src/`.
-*
-* `root` and `candidates` must be forward-slash, and the returned path is
-* forward-slash too: the candidate is joined with `path.posix.join`, which only
-* stays canonical when its inputs already are.
 */
 function findDir(root, ...candidates) {
 	for (const candidate of candidates) {
-		const full = path.posix.join(root, candidate);
+		const full = path.join(root, candidate);
 		try {
 			if (fs.statSync(full).isDirectory()) return full;
 		} catch {}
@@ -428,8 +424,6 @@ function findDir(root, ...candidates) {
 }
 /**
 * Check if the project uses App Router (has an app/ directory).
-*
-* `root` must be forward-slash — it is passed straight to `findDir`.
 */
 function hasAppDir(root) {
 	return findDir(root, "app", "src/app") !== null;

package/dist/utils/public-routes.js

@@ -1,5 +1,5 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import fs from "node:fs";
-import path from "node:path";
 //#region src/utils/public-routes.ts
 function scanPublicFileRoutes(root) {
 	const publicDir = path.join(root, "public");
@@ -34,7 +34,7 @@ function scanPublicFileRoutes(root) {
 				}
 				if (!stat.isFile()) continue;
 			} else if (!entry.isFile()) continue;
-			const relativePath = path.relative(publicDir, fullPath).split(path.sep).join("/");
+			const relativePath = path.relative(publicDir, fullPath);
 			routes.push("/" + relativePath);
 		}
 	}

package/dist/utils/react-version.js

@@ -1,6 +1,6 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
-import path from "node:path";
 //#region src/utils/react-version.ts
 function getDependencyUpgradeDeps(root, recommendations) {
 	const req = createRequire(path.join(root, "package.json"));

package/dist/utils/redirect-digest.d.ts

@@ -0,0 +1,9 @@
+//#region src/utils/redirect-digest.d.ts
+type RedirectDigest = {
+  status: number;
+  type: string | null;
+  url: string;
+};
+declare function parseRedirectDigest(digest: string): RedirectDigest | null;
+//#endregion
+export { RedirectDigest, parseRedirectDigest };

package/dist/utils/redirect-digest.js

@@ -0,0 +1,25 @@
+//#region src/utils/redirect-digest.ts
+const NEXT_REDIRECT_PREFIX = "NEXT_REDIRECT;";
+function parseRedirectDigest(digest) {
+	if (!digest.startsWith(NEXT_REDIRECT_PREFIX)) return null;
+	const firstSemi = digest.indexOf(";", 14);
+	if (firstSemi === -1) return null;
+	const rest = digest.slice(firstSemi + 1);
+	const statusMatch = rest.match(/;(303|307|308);?$/);
+	const isCanonical = rest !== "" && digest.endsWith(";");
+	if (isCanonical && !statusMatch) return null;
+	const target = statusMatch ? rest.slice(0, -statusMatch[0].length) : rest;
+	let url = target;
+	if (!isCanonical) try {
+		url = decodeURIComponent(target);
+	} catch {
+		return null;
+	}
+	return {
+		status: statusMatch ? Number(statusMatch[1]) : 307,
+		type: digest.slice(14, firstSemi) || null,
+		url
+	};
+}
+//#endregion
+export { parseRedirectDigest };

package/dist/utils/vinext-root.js

@@ -1,4 +1,4 @@
-import path from "node:path";
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { fileURLToPath } from "node:url";
 //#region src/utils/vinext-root.ts
 /**

package/dist/utils/vite-version.d.ts

@@ -1,23 +1,16 @@
 //#region src/utils/vite-version.d.ts
 declare function serializeViteDefine(value: unknown): string;
-declare function getDepOptimizeNodeEnvOptions(viteMajorVersion: number, nodeEnvDefine: string): {
+declare function getDepOptimizeNodeEnvOptions(nodeEnvDefine: string): {
   rolldownOptions?: {
     transform: {
       define: Record<string, string>;
     };
     moduleTypes?: Record<string, "jsx">;
   };
-  esbuildOptions?: {
-    define: Record<string, string>;
-    loader?: Record<string, "jsx">;
-  };
 };
-/**
- * Detect Vite major version at runtime by resolving from cwd.
- * The plugin may be installed in a workspace root with Vite 7 but used
- * by a project that has Vite 8 — so we resolve from cwd, not from
- * the plugin's own location.
- */
-declare function getViteMajorVersion(): number;
+declare function supportsNativeTypeofWindowFolding(viteVersion: string, bundledRolldownVersion?: string): boolean;
+declare function assertSupportedViteVersion(): {
+  supportsNativeTypeofWindowFolding: boolean;
+};
 //#endregion
-export { getDepOptimizeNodeEnvOptions, getViteMajorVersion, serializeViteDefine };
+export { assertSupportedViteVersion, getDepOptimizeNodeEnvOptions, serializeViteDefine, supportsNativeTypeofWindowFolding };

package/dist/utils/vite-version.js

@@ -1,52 +1,86 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { createRequire } from "node:module";
-import path from "node:path";
 //#region src/utils/vite-version.ts
 /**
 * Vite major-version detection.
 *
-* Several vinext behaviors depend on whether the host project is running Vite 8
-* (Rolldown-based, with native `resolve.tsconfigPaths`, `oxc` transforms, and
-* `rolldownOptions`) or Vite 7 (Rollup/esbuild). This helper centralizes the
-* detection so the Vite-major gate is computed the same way everywhere.
+* vinext requires Vite 8 or newer so it can rely on Rolldown-based build
+* options, native `resolve.tsconfigPaths`, and OXC transforms.
 */
 function serializeViteDefine(value) {
 	if (typeof value === "string") return value;
 	return JSON.stringify(value) ?? "undefined";
 }
-function getDepOptimizeNodeEnvOptions(viteMajorVersion, nodeEnvDefine) {
-	const define = { "process.env.NODE_ENV": nodeEnvDefine };
-	const jsxModuleTypes = {
-		".js": "jsx",
-		".mjs": "jsx"
-	};
-	return viteMajorVersion >= 8 ? { rolldownOptions: {
-		transform: { define },
-		moduleTypes: jsxModuleTypes
-	} } : { esbuildOptions: {
-		define,
-		loader: jsxModuleTypes
+function getDepOptimizeNodeEnvOptions(nodeEnvDefine) {
+	return { rolldownOptions: {
+		transform: { define: { "process.env.NODE_ENV": nodeEnvDefine } },
+		moduleTypes: {
+			".js": "jsx",
+			".mjs": "jsx"
+		}
 	} };
 }
-/**
-* Detect Vite major version at runtime by resolving from cwd.
-* The plugin may be installed in a workspace root with Vite 7 but used
-* by a project that has Vite 8 — so we resolve from cwd, not from
-* the plugin's own location.
-*/
-function getViteMajorVersion() {
+function getViteToolchainVersion() {
+	try {
+		return getViteToolchainVersionFromRequire(createRequire(path.join(process.cwd(), "package.json")));
+	} catch (error) {
+		if (!isModuleNotFoundError(error)) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(`[vinext] Vite 8 or newer is required, but ${message}`);
+		}
+	}
 	try {
-		const vitePkg = createRequire(path.join(process.cwd(), "package.json"))("vite/package.json");
-		const viteMajor = parseInt(vitePkg?.version, 10);
-		if (vitePkg?.name === "vite" && Number.isFinite(viteMajor)) return viteMajor;
-		const bundledViteMajor = parseInt(vitePkg?.bundledVersions?.vite, 10);
-		if (Number.isFinite(bundledViteMajor)) return bundledViteMajor;
-		console.warn(`[vinext] Could not determine Vite major version from ${vitePkg?.name ?? "vite/package.json"}; assuming Vite 7`);
-		return 7;
+		return getViteToolchainVersionFromRequire(createRequire(import.meta.url));
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		console.warn(`[vinext] Failed to resolve vite/package.json (${message}); assuming Vite 7`);
-		return 7;
+		throw new Error(`[vinext] Vite 8 or newer is required, but vinext could not resolve vite/package.json (${message})`);
+	}
+}
+function getViteToolchainVersionFromRequire(require) {
+	const vitePkg = require("vite/package.json");
+	if (vitePkg?.name === "vite" && parseViteVersion(vitePkg.version)) return { vite: vitePkg.version };
+	const bundledViteVersion = vitePkg?.bundledVersions?.vite;
+	if (parseViteVersion(bundledViteVersion)) {
+		const bundledRolldownVersion = vitePkg?.bundledVersions?.rolldown;
+		return {
+			vite: bundledViteVersion,
+			rolldown: parseViteVersion(bundledRolldownVersion) ? bundledRolldownVersion : void 0
+		};
 	}
+	throw new Error(`could not determine Vite version from ${vitePkg?.name ?? "vite/package.json"}`);
+}
+function parseViteVersion(version) {
+	if (typeof version !== "string") return null;
+	const match = /^(\d+)\.(\d+)\.(\d+)(-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+	if (!match) return null;
+	return [
+		Number(match[1]),
+		Number(match[2]),
+		Number(match[3]),
+		!!match[4]
+	];
+}
+function isModuleNotFoundError(error) {
+	return !!error && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND";
+}
+function supportsNativeTypeofWindowFolding(viteVersion, bundledRolldownVersion) {
+	if (bundledRolldownVersion !== void 0) return isVersionAtLeast(bundledRolldownVersion, 1, 1, 4);
+	return isVersionAtLeast(viteVersion, 8, 1, 4);
+}
+function isVersionAtLeast(version, requiredMajor, requiredMinor, requiredPatch) {
+	const parsedVersion = parseViteVersion(version);
+	if (!parsedVersion) return false;
+	const [major, minor, patch, prerelease] = parsedVersion;
+	if (major !== requiredMajor) return major > requiredMajor;
+	if (minor !== requiredMinor) return minor > requiredMinor;
+	if (patch !== requiredPatch) return patch > requiredPatch;
+	return !prerelease;
+}
+function assertSupportedViteVersion() {
+	const toolchainVersion = getViteToolchainVersion();
+	const [major] = parseViteVersion(toolchainVersion.vite);
+	if (major < 8) throw new Error(`[vinext] Vite 8 or newer is required. Detected Vite ${major}.`);
+	return { supportsNativeTypeofWindowFolding: supportsNativeTypeofWindowFolding(toolchainVersion.vite, toolchainVersion.rolldown) };
 }
 //#endregion
-export { getDepOptimizeNodeEnvOptions, getViteMajorVersion, serializeViteDefine };
+export { assertSupportedViteVersion, getDepOptimizeNodeEnvOptions, serializeViteDefine, supportsNativeTypeofWindowFolding };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "0.2.1",
+  "version": "1.0.0-beta.1",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "license": "MIT",
   "repository": {
@@ -37,10 +37,6 @@
       "types": "./dist/server/pages-i18n.d.ts",
       "import": "./dist/server/pages-i18n.js"
     },
-    "./cloudflare": {
-      "types": "./dist/cloudflare/index.d.ts",
-      "import": "./dist/cloudflare/index.js"
-    },
     "./server/image-optimization": {
       "types": "./dist/server/image-optimization.d.ts",
       "import": "./dist/server/image-optimization.js"
@@ -81,10 +77,34 @@
       "types": "./dist/server/app-page-cache.d.ts",
       "import": "./dist/server/app-page-cache.js"
     },
+    "./internal/server/prerender-manifest": {
+      "types": "./dist/server/prerender-manifest.d.ts",
+      "import": "./dist/server/prerender-manifest.js"
+    },
+    "./internal/server/pregenerated-concrete-paths": {
+      "types": "./dist/server/pregenerated-concrete-paths.d.ts",
+      "import": "./dist/server/pregenerated-concrete-paths.js"
+    },
     "./internal/build/run-prerender": {
       "types": "./dist/build/run-prerender.d.ts",
       "import": "./dist/build/run-prerender.js"
     },
+    "./internal/build/prerender-paths": {
+      "types": "./dist/build/prerender-paths.d.ts",
+      "import": "./dist/build/prerender-paths.js"
+    },
+    "./internal/cache-adapters": {
+      "types": "./dist/cache/cache-adapters-virtual.d.ts",
+      "import": "./dist/cache/cache-adapters-virtual.js"
+    },
+    "./internal/init": {
+      "types": "./dist/init.d.ts",
+      "import": "./dist/init.js"
+    },
+    "./internal/init-platform": {
+      "types": "./dist/init-platform.d.ts",
+      "import": "./dist/init-platform.js"
+    },
     "./internal/config/dotenv": {
       "types": "./dist/config/dotenv.d.ts",
       "import": "./dist/config/dotenv.js"
@@ -128,6 +148,10 @@
     "./internal/utils/project": {
       "types": "./dist/utils/project.d.ts",
       "import": "./dist/utils/project.js"
+    },
+    "./internal/utils/prerender-output-paths": {
+      "types": "./dist/utils/prerender-output-paths.d.ts",
+      "import": "./dist/utils/prerender-output-paths.js"
     }
   },
   "dependencies": {
@@ -146,11 +170,10 @@
     "@vitejs/plugin-react": "^6.0.1",
     "@vitejs/plugin-rsc": "^0.5.27",
     "am-i-vibing": "^0.5.0",
+    "pathslash": "^0.1.0",
     "react-server-dom-webpack": "^19.2.7",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.1",
-    "vite-plus": "0.2.1",
-    "vite-tsconfig-paths": "^6.1.1",
-    "@vinext/cloudflare": "0.2.1"
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
+    "vite-plus": "0.2.2"
   },
   "peerDependencies": {
     "@mdx-js/rollup": "^3.0.0",
@@ -159,8 +182,7 @@
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
     "react-server-dom-webpack": "^19.2.6",
-    "vite": "^7.0.0 || ^8.0.0",
-    "vite-tsconfig-paths": "^6.1.1"
+    "vite": "^8.0.0"
   },
   "peerDependenciesMeta": {
     "@mdx-js/rollup": {
@@ -171,9 +193,6 @@
     },
     "react-server-dom-webpack": {
       "optional": true
-    },
-    "vite-tsconfig-paths": {
-      "optional": true
     }
   },
   "engines": {

package/dist/cloudflare/index.d.ts

@@ -1,3 +0,0 @@
-import { KVCacheHandler } from "../packages/cloudflare/src/cache/kv-data-adapter.runtime.js";
-import { TPROptions, TPRResult, runTPR } from "../packages/cloudflare/src/tpr.js";
-export { KVCacheHandler, type TPROptions, type TPRResult, runTPR };

package/dist/cloudflare/index.js

@@ -1,3 +0,0 @@
-import { KVCacheHandler } from "../packages/cloudflare/src/cache/kv-data-adapter.runtime.js";
-import { runTPR } from "../packages/cloudflare/src/tpr.js";
-export { KVCacheHandler, runTPR };

package/dist/packages/cloudflare/src/cache/cdn-adapter.runtime.js

@@ -1,102 +0,0 @@
-import { getRequestExecutionContext } from "../../../../shims/request-context.js";
-//#region ../cloudflare/src/cache/cdn-adapter.runtime.ts
-function getWorkersCache() {
-	const cache = getRequestExecutionContext()?.cache;
-	if (cache && typeof cache.purge === "function") return cache;
-	return null;
-}
-/** Non-cacheable responses: nobody (edge or browser) stores them. */
-const NO_STORE = "no-store";
-/**
-* Browser-facing policy for cacheable responses. `public` allows shared caches
-* to participate, but `max-age=0, must-revalidate` forces every reuse to
-* revalidate (against the edge) rather than serving a stored copy — so the user
-* always sees edge-fresh content while still permitting conditional 304s.
-*/
-const BROWSER_REVALIDATE = "public, max-age=0, must-revalidate";
-/**
-* A concrete stale window (1 year) substituted for a value-less
-* `stale-while-revalidate`. The framework emits a bare `stale-while-revalidate`
-* (no `=seconds`) to mean an unbounded stale window — a Vercel CDN extension.
-* Cloudflare follows RFC 5861, which requires `stale-while-revalidate=<seconds>`,
-* and treats the value-less form as a zero-width window (no stale serving →
-* hard expiry at `max-age`, so the next request is a MISS instead of UPDATING).
-* Stamping a large finite value preserves the "serve stale ~indefinitely while
-* revalidating" intent in a form the edge honors.
-*/
-const UNBOUNDED_SWR_SECONDS = 31536e3;
-/**
-* Convert the framework's shared-cache policy into a CDN-scoped one:
-* `s-maxage=…` → `max-age=…` (the edge honors `max-age` inside
-* `CDN-Cache-Control`), give a value-less `stale-while-revalidate` an explicit
-* seconds value (Cloudflare ignores the bare directive), and ensure a leading
-* `public`.
-*/
-function toEdgeCacheControl(cacheControl) {
-	const withMaxAge = cacheControl.replace(/\bs-maxage=/g, "max-age=").replace(/\bstale-while-revalidate\b(?!=)/g, `stale-while-revalidate=${UNBOUNDED_SWR_SECONDS}`);
-	return /\bpublic\b/.test(withMaxAge) ? withMaxAge : `public, ${withMaxAge}`;
-}
-/**
-* Cloudflare's `Cache-Tag` header budget is 16 KB total with each tag capped at
-* 1024 bytes. Keep a conservative ceiling so a page with a large tag set never
-* produces an oversized (silently-dropped) header.
-*/
-const MAX_CACHE_TAG_BYTES = 8 * 1024;
-const MAX_SINGLE_TAG_BYTES = 1024;
-/**
-* Build a `Cache-Tag` header value from canonicalised tags. Tags containing a
-* comma (the header separator) or exceeding the per-tag size are skipped, and
-* the whole value is bounded to stay within Cloudflare's limit.
-*/
-function formatCacheTag(tags) {
-	const parts = [];
-	let total = 0;
-	for (const tag of tags) {
-		if (!tag || tag.includes(",") || tag.length > MAX_SINGLE_TAG_BYTES) continue;
-		const next = total + tag.length + (parts.length > 0 ? 1 : 0);
-		if (next > MAX_CACHE_TAG_BYTES) break;
-		parts.push(tag);
-		total = next;
-	}
-	return parts.length > 0 ? parts.join(",") : null;
-}
-var CloudflareCdnCacheAdapter = class {
-	ownsBackgroundRevalidation = false;
-	/**
-	* The origin keeps no page store — return null so the request renders fresh.
-	* The edge serves cached HIT/STALE responses without reaching the origin.
-	*/
-	async get() {
-		return null;
-	}
-	/** No-op: the platform caches the response via its headers, not an origin store. */
-	async set(_key, _data, _ctx) {}
-	buildResponseHeaders(input) {
-		if (!input.cacheControl) return { "Cache-Control": NO_STORE };
-		if (/\b(?:no-store|no-cache|private)\b/.test(input.cacheControl)) return {
-			"Cache-Control": input.cacheControl,
-			"CDN-Cache-Control": null,
-			"Cloudflare-CDN-Cache-Control": null,
-			"Cache-Tag": null
-		};
-		const headers = {
-			"Cache-Control": BROWSER_REVALIDATE,
-			"CDN-Cache-Control": toEdgeCacheControl(input.cacheControl)
-		};
-		if (input.tags && input.tags.length > 0) {
-			const cacheTag = formatCacheTag(input.tags);
-			if (cacheTag) headers["Cache-Tag"] = cacheTag;
-		}
-		return headers;
-	}
-	/** Purge edge-cached responses by tag via the request context's `cache.purge`. */
-	async revalidateTag(tags, _durations) {
-		const cache = getWorkersCache();
-		if (!cache) return;
-		const tagList = (Array.isArray(tags) ? tags : [tags]).filter((t) => typeof t === "string" && t.length > 0);
-		if (tagList.length === 0) return;
-		await cache.purge({ tags: tagList });
-	}
-};
-//#endregion
-export { CloudflareCdnCacheAdapter };

package/dist/packages/cloudflare/src/cache/kv-data-adapter.runtime.d.ts

@@ -1,126 +0,0 @@
-import { CacheHandler, CacheHandlerValue, IncrementalCacheValue } from "../../../../shims/cache-handler.js";
-import { ExecutionContextLike } from "../../../../shims/request-context.js";
-
-//#region ../cloudflare/src/cache/kv-data-adapter.runtime.d.ts
-type KVNamespace = {
-  get(key: string, options?: {
-    type?: string;
-  }): Promise<string | null>;
-  get(key: string, options: {
-    type: "arrayBuffer";
-  }): Promise<ArrayBuffer | null>;
-  put(key: string, value: string | ArrayBuffer | ReadableStream, options?: {
-    expirationTtl?: number;
-    metadata?: Record<string, unknown>;
-  }): Promise<void>;
-  delete(key: string): Promise<void>;
-  list(options?: {
-    prefix?: string;
-    limit?: number;
-    cursor?: string;
-  }): Promise<{
-    keys: Array<{
-      name: string;
-      metadata?: Record<string, unknown>;
-    }>;
-    list_complete: boolean;
-    cursor?: string;
-  }>;
-};
-/** Key prefix for cache entries. */
-/**
- * Cloudflare KV data cache handler.
- *
- * @deprecated Consumers should not instantiate or register this handler by
- * hand. Configure it declaratively via the `cache.data` option on the
- * `vinext()` plugin, using the {@link kvDataAdapter} builder:
- *
- * ```ts
- * import { vinext } from "vinext";
- * import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";
- *
- * export default defineConfig({
- *   plugins: [vinext({ cache: { data: kvDataAdapter({ binding: "VINEXT_KV_CACHE" }) } })],
- * });
- * ```
- *
- * `kvDataAdapter()` is safe to call from `vite.config.ts` — it never touches
- * the Workers runtime — and the plugin defers instantiation of this handler to
- * the first request. This class stays exported for the runtime factory and for
- * backwards compatibility, but is not the recommended consumer API.
- */
-declare class KVCacheHandler implements CacheHandler {
-  private kv;
-  private prefix;
-  private ctx;
-  private ttlSeconds;
-  /** Local in-memory cache for tag invalidation timestamps. Avoids redundant KV reads. */
-  private _tagCache;
-  /** TTL (ms) for local tag cache entries. After this, re-fetch from KV. */
-  private _tagCacheTtl;
-  constructor(kvNamespace: KVNamespace, options?: {
-    appPrefix?: string;
-    ctx?: ExecutionContextLike;
-    ttlSeconds?: number; /** TTL in milliseconds for the local tag cache. Defaults to 5000ms. */
-    tagCacheTtlMs?: number;
-  });
-  get(key: string, _ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
-  /**
-   * Check tag invalidation markers for stored tags or read-time soft tags.
-   * Uses a local in-memory cache to avoid redundant KV reads for recently-seen tags.
-   */
-  private _hasRevalidatedTag;
-  set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
-  revalidateTag(tags: string | string[], _durations?: {
-    expire?: number;
-  }): Promise<void>;
-  /**
-   * Invalidate all cache entries whose path tags fall under `pathPrefix`.
-   *
-   * Uses KV list metadata to discover tags without fetching entry values —
-   * entries written by `set()` store their tags in KV metadata, so
-   * `kv.list()` returns them inline with each key. This makes prefix
-   * invalidation O(list_pages) instead of O(entries × get).
-   *
-   * Entries written before metadata was added (no metadata.tags) are
-   * gracefully skipped — they'll be picked up on next `set()` which
-   * writes metadata.
-   *
-   * When present, this method fully replaces the `revalidateTag` call
-   * path in `revalidatePath()` — implementors own all path-based tag
-   * handling.
-   */
-  revalidateByPathPrefix(pathPrefix: string): Promise<void>;
-  /**
-   * Clear the in-memory tag cache for this KVCacheHandler instance.
-   *
-   * Note: KVCacheHandler instances are typically reused across multiple
-   * requests in a Cloudflare Worker. The `_tagCache` is intentionally
-   * cross-request — it reduces redundant KV reads for recently-seen tags
-   * across all requests hitting the same isolate, bounded by `tagCacheTtlMs`
-   * (default 5s). vinext does NOT call this method per request.
-   *
-   * This is an opt-in escape hatch for callers that need stricter isolation
-   * (e.g., tests, or environments with custom lifecycle management).
-   * Callers that require per-request isolation should either construct a
-   * fresh KVCacheHandler per request or invoke this method explicitly.
-   */
-  resetRequestCache(): void;
-  /**
-   * Fire a KV delete in the background.
-   * Prefers the per-request ExecutionContext from ALS (set by
-   * runWithExecutionContext in the worker entry) so that background KV
-   * operations are registered with the correct request's waitUntil().
-   * Falls back to the constructor-provided ctx for callers that set it
-   * explicitly, and to fire-and-forget when neither is available (Node.js dev).
-   */
-  private _deleteInBackground;
-  /**
-   * Execute a KV put and return the promise so callers can await completion.
-   * Also registers with ctx.waitUntil() so the Workers runtime keeps the
-   * isolate alive even if the caller does not await the returned promise.
-   */
-  private _put;
-}
-//#endregion
-export { KVCacheHandler };