vinext 0.2.0 → 1.0.0-beta.0

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

@@ -1,435 +0,0 @@
-import { getRequestExecutionContext } from "../../../../shims/request-context.js";
-import { isUnknownRecord, readCacheControlNumberField } from "../utils/cache-control-metadata.js";
-import { Buffer } from "node:buffer";
-//#region ../cloudflare/src/cache/kv-data-adapter.runtime.ts
-/**
-* Cloudflare KV data cache — implementation + runtime factory.
-*
-* `KVCacheHandler` provides persistent ISR caching on Cloudflare Workers using
-* KV as the storage backend (time-based expiry / stale-while-revalidate and
-* tag-based invalidation). The default export is the adapter factory the
-* generated `virtual:vinext-cache-adapters` registration imports: it reads the
-* KV namespace from `env[binding]` at request time and constructs the handler.
-*
-* Configure it from vite.config via the {@link kvDataAdapter} builder in
-* `./kv-data-adapter.ts` (which `require.resolve`s this file). The legacy
-* imperative path (constructing `KVCacheHandler` and calling
-* `setDataCacheHandler` from a worker entry) is deprecated — prefer the
-* `cache.data` plugin option.
-*
-* Wrangler config (wrangler.jsonc):
-*
-*   { "kv_namespaces": [{ "binding": "VINEXT_KV_CACHE", "id": "<your-kv-namespace-id>" }] }
-*/
-/** Key prefix for tag invalidation timestamps. */
-const TAG_PREFIX = "__tag:";
-/** Key prefix for cache entries. */
-const ENTRY_PREFIX = "cache:";
-/** Prefix used by revalidatePath for path-based tags. */
-const PATH_TAG_PREFIX = "_N_T_";
-/** Max tag length to prevent KV key abuse. */
-const MAX_TAG_LENGTH = 256;
-/** Matches a valid base64 string (standard alphabet with optional padding). */
-const BASE64_RE = /^[A-Za-z0-9+/]*={0,2}$/;
-/**
-* Validate a cache tag. Returns null if invalid.
-* Note: `:` is rejected because TAG_PREFIX and ENTRY_PREFIX use `:` as a
-* separator — allowing `:` in user tags could cause ambiguous key lookups.
-*/
-function validateTag(tag) {
-	if (typeof tag !== "string" || tag.length === 0 || tag.length > MAX_TAG_LENGTH) return null;
-	if (/[\x00-\x1f\\:]/.test(tag)) return null;
-	return tag;
-}
-function readStringArrayField(ctx, field) {
-	const value = ctx?.[field];
-	if (!Array.isArray(value)) return [];
-	return value.filter((item) => typeof item === "string");
-}
-function validUniqueTags(tags) {
-	const result = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const tag of tags) {
-		const validTag = validateTag(tag);
-		if (!validTag || seen.has(validTag)) continue;
-		seen.add(validTag);
-		result.push(validTag);
-	}
-	return result;
-}
-/**
-* Segment-aware path prefix check. Returns true if `path` is equal to
-* `prefix` or is a child route (next char after prefix is `/`).
-* Prevents `/dashboard` from matching `/dashboard-admin`.
-*/
-function isPathChildOf(path, prefix) {
-	if (prefix === "/") return path.startsWith("/");
-	if (path === prefix) return true;
-	return path.startsWith(prefix + "/");
-}
-/**
-* 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.
-*/
-var KVCacheHandler = class {
-	kv;
-	prefix;
-	ctx;
-	ttlSeconds;
-	/** Local in-memory cache for tag invalidation timestamps. Avoids redundant KV reads. */
-	_tagCache = /* @__PURE__ */ new Map();
-	/** TTL (ms) for local tag cache entries. After this, re-fetch from KV. */
-	_tagCacheTtl;
-	constructor(kvNamespace, options) {
-		this.kv = kvNamespace;
-		this.prefix = options?.appPrefix ? `${options.appPrefix}:` : "";
-		this.ctx = options?.ctx;
-		this.ttlSeconds = options?.ttlSeconds ?? 720 * 3600;
-		this._tagCacheTtl = options?.tagCacheTtlMs ?? 5e3;
-	}
-	async get(key, _ctx) {
-		const kvKey = this.prefix + ENTRY_PREFIX + key;
-		const raw = await this.kv.get(kvKey);
-		if (!raw) return null;
-		let parsed;
-		try {
-			parsed = JSON.parse(raw);
-		} catch {
-			this._deleteInBackground(kvKey);
-			return null;
-		}
-		const entry = validateCacheEntry(parsed);
-		if (!entry) {
-			console.error("[vinext] Invalid cache entry shape for key:", key);
-			this._deleteInBackground(kvKey);
-			return null;
-		}
-		let restoredValue = null;
-		if (entry.value) {
-			restoredValue = restoreArrayBuffers(entry.value);
-			if (!restoredValue) {
-				this._deleteInBackground(kvKey);
-				return null;
-			}
-		}
-		if (await this._hasRevalidatedTag(validUniqueTags(entry.tags), entry.lastModified)) {
-			this._deleteInBackground(kvKey);
-			return null;
-		}
-		const softTags = validUniqueTags(readStringArrayField(_ctx, "softTags"));
-		if (await this._hasRevalidatedTag(softTags, entry.lastModified)) return null;
-		if (entry.expireAt !== void 0 && entry.expireAt !== null && Date.now() > entry.expireAt) {
-			this._deleteInBackground(kvKey);
-			return null;
-		}
-		if (entry.revalidateAt !== null && Date.now() > entry.revalidateAt) return {
-			lastModified: entry.lastModified,
-			value: restoredValue,
-			cacheState: "stale",
-			cacheControl: entry.cacheControl
-		};
-		return {
-			lastModified: entry.lastModified,
-			value: restoredValue,
-			cacheControl: entry.cacheControl
-		};
-	}
-	/**
-	* 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.
-	*/
-	async _hasRevalidatedTag(tags, lastModified) {
-		if (tags.length === 0) return false;
-		const now = Date.now();
-		const uncachedTags = [];
-		for (const tag of tags) {
-			const cached = this._tagCache.get(tag);
-			if (cached && now - cached.fetchedAt < this._tagCacheTtl) {
-				if (Number.isNaN(cached.timestamp) || cached.timestamp >= lastModified) return true;
-			} else {
-				if (cached) this._tagCache.delete(tag);
-				uncachedTags.push(tag);
-			}
-		}
-		if (uncachedTags.length > 0) {
-			const tagResults = await Promise.all(uncachedTags.map((tag) => this.kv.get(this.prefix + TAG_PREFIX + tag)));
-			for (let i = 0; i < uncachedTags.length; i++) {
-				const tagTime = tagResults[i];
-				const tagTimestamp = tagTime ? Number(tagTime) : 0;
-				this._tagCache.set(uncachedTags[i], {
-					timestamp: tagTimestamp,
-					fetchedAt: now
-				});
-			}
-			for (const tag of uncachedTags) {
-				const cached = this._tagCache.get(tag);
-				if (!cached || cached.timestamp === 0) continue;
-				if (Number.isNaN(cached.timestamp) || cached.timestamp >= lastModified) return true;
-			}
-		}
-		return false;
-	}
-	set(key, data, ctx) {
-		const tagSet = /* @__PURE__ */ new Set();
-		if (data && "tags" in data && Array.isArray(data.tags)) for (const t of data.tags) {
-			const validated = validateTag(t);
-			if (validated) tagSet.add(validated);
-		}
-		if (ctx && "tags" in ctx && Array.isArray(ctx.tags)) for (const t of ctx.tags) {
-			const validated = validateTag(t);
-			if (validated) tagSet.add(validated);
-		}
-		const tags = [...tagSet];
-		let effectiveRevalidate;
-		let effectiveExpire;
-		effectiveRevalidate = readCacheControlNumberField(ctx, "revalidate");
-		effectiveExpire = readCacheControlNumberField(ctx, "expire");
-		if (data && "revalidate" in data && typeof data.revalidate === "number") effectiveRevalidate = data.revalidate;
-		if (effectiveRevalidate === 0) return Promise.resolve();
-		const now = Date.now();
-		const revalidateAt = typeof effectiveRevalidate === "number" && effectiveRevalidate > 0 ? now + effectiveRevalidate * 1e3 : null;
-		const expireAt = typeof effectiveExpire === "number" && effectiveExpire > 0 ? now + effectiveExpire * 1e3 : null;
-		const cacheControl = typeof effectiveRevalidate === "number" ? effectiveExpire === void 0 ? { revalidate: effectiveRevalidate } : {
-			revalidate: effectiveRevalidate,
-			expire: effectiveExpire
-		} : void 0;
-		const entry = {
-			value: data ? serializeForJSON(data) : null,
-			tags,
-			lastModified: now,
-			revalidateAt,
-			expireAt,
-			cacheControl
-		};
-		const expirationTtl = revalidateAt !== null ? this.ttlSeconds : void 0;
-		const metadata = JSON.stringify({ tags }).length <= 1024 ? { tags } : void 0;
-		return this._put(this.prefix + ENTRY_PREFIX + key, JSON.stringify(entry), {
-			expirationTtl,
-			metadata
-		});
-	}
-	async revalidateTag(tags, _durations) {
-		const tagList = Array.isArray(tags) ? tags : [tags];
-		const now = Date.now();
-		const validTags = tagList.filter((t) => validateTag(t) !== null);
-		await Promise.all(validTags.map((tag) => this.kv.put(this.prefix + TAG_PREFIX + tag, String(now), { expirationTtl: 720 * 3600 })));
-		for (const tag of validTags) this._tagCache.set(tag, {
-			timestamp: now,
-			fetchedAt: now
-		});
-	}
-	/**
-	* 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.
-	*/
-	async revalidateByPathPrefix(pathPrefix) {
-		const tagsToInvalidate = /* @__PURE__ */ new Set();
-		let cursor;
-		const listPrefix = this.prefix + ENTRY_PREFIX;
-		do {
-			const page = await this.kv.list({
-				prefix: listPrefix,
-				cursor
-			});
-			for (const key of page.keys) {
-				const tags = key.metadata?.tags;
-				if (!Array.isArray(tags)) continue;
-				for (const tag of tags) {
-					if (typeof tag !== "string") continue;
-					const rawPath = tag.startsWith(PATH_TAG_PREFIX) ? tag.slice(5) : tag;
-					if (rawPath.startsWith("/") && isPathChildOf(rawPath, pathPrefix)) tagsToInvalidate.add(tag);
-				}
-			}
-			cursor = page.list_complete ? void 0 : page.cursor;
-		} while (cursor);
-		if (tagsToInvalidate.size > 0) await this.revalidateTag([...tagsToInvalidate]);
-	}
-	/**
-	* 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() {
-		this._tagCache.clear();
-	}
-	/**
-	* 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).
-	*/
-	_deleteInBackground(kvKey) {
-		const promise = this.kv.delete(kvKey);
-		const ctx = getRequestExecutionContext() ?? this.ctx;
-		if (ctx) ctx.waitUntil(promise);
-	}
-	/**
-	* 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.
-	*/
-	_put(kvKey, value, options) {
-		const promise = this.kv.put(kvKey, value, options);
-		const ctx = getRequestExecutionContext() ?? this.ctx;
-		if (ctx) ctx.waitUntil(promise);
-		return promise;
-	}
-};
-const VALID_KINDS = new Set([
-	"FETCH",
-	"APP_PAGE",
-	"PAGES",
-	"APP_ROUTE",
-	"REDIRECT",
-	"IMAGE"
-]);
-/**
-* Validate that a parsed JSON value has the expected KVCacheEntry shape.
-* Returns the validated entry or null if the shape is invalid.
-*/
-function validateCacheEntry(raw) {
-	if (!raw || typeof raw !== "object") return null;
-	const obj = raw;
-	if (typeof obj.lastModified !== "number") return null;
-	if (!Array.isArray(obj.tags)) return null;
-	if (obj.revalidateAt !== null && typeof obj.revalidateAt !== "number") return null;
-	if (obj.expireAt !== void 0 && obj.expireAt !== null && typeof obj.expireAt !== "number") return null;
-	if (obj.cacheControl !== void 0) {
-		if (!isUnknownRecord(obj.cacheControl)) return null;
-		if (typeof obj.cacheControl.revalidate !== "number") return null;
-		if (obj.cacheControl.expire !== void 0 && typeof obj.cacheControl.expire !== "number") return null;
-	}
-	if (obj.value !== null) {
-		if (!obj.value || typeof obj.value !== "object") return null;
-		const value = obj.value;
-		if (typeof value.kind !== "string" || !VALID_KINDS.has(value.kind)) return null;
-	}
-	return raw;
-}
-/**
-* Deep-clone a cache value, converting ArrayBuffer fields to base64 strings
-* so the entire structure can be JSON.stringify'd for KV storage.
-*/
-function serializeForJSON(value) {
-	if (value.kind === "APP_PAGE") return {
-		...value,
-		rscData: value.rscData ? arrayBufferToBase64(value.rscData) : void 0
-	};
-	if (value.kind === "APP_ROUTE") return {
-		...value,
-		body: arrayBufferToBase64(value.body)
-	};
-	if (value.kind === "IMAGE") return {
-		...value,
-		buffer: arrayBufferToBase64(value.buffer)
-	};
-	return value;
-}
-/**
-* Restore base64 strings back to ArrayBuffers after JSON.parse.
-* Returns the restored `IncrementalCacheValue`, or `null` if any base64
-* decode fails (corrupted entry).
-*/
-function restoreArrayBuffers(value) {
-	if (value.kind === "APP_PAGE") {
-		if (typeof value.rscData === "string") {
-			const decoded = safeBase64ToArrayBuffer(value.rscData);
-			if (!decoded) return null;
-			return {
-				...value,
-				rscData: decoded
-			};
-		}
-		return value;
-	}
-	if (value.kind === "APP_ROUTE") {
-		if (typeof value.body === "string") {
-			const decoded = safeBase64ToArrayBuffer(value.body);
-			if (!decoded) return null;
-			return {
-				...value,
-				body: decoded
-			};
-		}
-		return value;
-	}
-	if (value.kind === "IMAGE") {
-		if (typeof value.buffer === "string") {
-			const decoded = safeBase64ToArrayBuffer(value.buffer);
-			if (!decoded) return null;
-			return {
-				...value,
-				buffer: decoded
-			};
-		}
-		return value;
-	}
-	return value;
-}
-function arrayBufferToBase64(buffer) {
-	return Buffer.from(buffer).toString("base64");
-}
-/**
-* Decode a base64 string to an ArrayBuffer.
-* Validates the input against the base64 alphabet before decoding,
-* since Buffer.from(str, "base64") silently ignores invalid characters.
-*/
-function base64ToArrayBuffer(base64) {
-	if (!BASE64_RE.test(base64) || base64.length % 4 !== 0) throw new Error("Invalid base64 string");
-	const buf = Buffer.from(base64, "base64");
-	return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-}
-/**
-* Safely decode base64 to ArrayBuffer. Returns null on invalid input
-* instead of throwing.
-*/
-function safeBase64ToArrayBuffer(base64) {
-	try {
-		return base64ToArrayBuffer(base64);
-	} catch {
-		console.error("[vinext] Invalid base64 in cache entry");
-		return null;
-	}
-}
-//#endregion
-export { ENTRY_PREFIX, KVCacheHandler };

package/dist/packages/cloudflare/src/deploy-config.js

@@ -1,150 +0,0 @@
-import { findViteConfigPath } from "../../../utils/project.js";
-import fs from "node:fs";
-import path from "node:path";
-//#region ../cloudflare/src/deploy-config.ts
-function escapeRegExp(value) {
-	return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
-}
-/**
-* Check whether an existing vite.config file already imports and uses the
-* Cloudflare Vite plugin. This is a heuristic text scan — it doesn't execute
-* the config — so it may produce false negatives for unusual configurations.
-*
-* Returns true when the config both imports the package and invokes
-* `cloudflare(...)` in the plugin list.
-*/
-function viteConfigHasCloudflarePlugin(root) {
-	const configPath = findViteConfigPath(root);
-	if (!configPath) return false;
-	try {
-		const content = fs.readFileSync(configPath, "utf-8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
-		const requireBinding = content.match(/(?:const|let|var)\s*{([^}]*)}\s*=\s*require\s*\(\s*["']@cloudflare\/vite-plugin["']\s*\)/)?.[1];
-		if (requireBinding) {
-			const requireMatch = requireBinding.match(/(?:^|,)\s*cloudflare\s*(?::\s*([A-Za-z_$][\w$]*))?\s*(?:,|$)/);
-			if (requireMatch) {
-				const binding = requireMatch[1] ?? "cloudflare";
-				return new RegExp(`\\b${escapeRegExp(binding)}\\s*\\(`).test(content);
-			}
-		}
-		const namedImports = content.match(/import\s*{([^}]*)}\s*from\s*["']@cloudflare\/vite-plugin["']/)?.[1];
-		if (!namedImports) return false;
-		const importMatch = namedImports.match(/(?:^|,)\s*cloudflare\s*(?:as\s+([A-Za-z_$][\w$]*))?\s*(?:,|$)/);
-		if (!importMatch) return false;
-		const binding = importMatch[1] ?? "cloudflare";
-		return new RegExp(`\\b${escapeRegExp(binding)}\\s*\\(`).test(content);
-	} catch {
-		return false;
-	}
-}
-/**
-* Extract the object-literal text of the `cache:` key (the `{ ... }` passed as
-* `vinext({ cache })`) from a Vite config source, via brace matching. Returns
-* null if there is no `cache:` object literal.
-*/
-function extractCacheBlock(content) {
-	const m = /\bcache\s*:\s*\{/.exec(content);
-	if (!m) return null;
-	const open = m.index + m[0].length - 1;
-	let depth = 0;
-	for (let i = open; i < content.length; i++) {
-		const ch = content[i];
-		if (ch === "{") depth++;
-		else if (ch === "}" && --depth === 0) return content.slice(open, i + 1);
-	}
-	return null;
-}
-/**
-* Whether a `cdn` / `data` field inside the cache object is assigned a real
-* value (not absent, `undefined`, or `null`). Reads the value up to the next
-* comma / closing brace / newline, which is enough to tell an assignment like
-* `data: kvDataAdapter()` from `data: undefined`.
-*/
-function cacheFieldAssigned(cacheBlock, field) {
-	const m = new RegExp(`\\b${field}\\s*:\\s*([^,}\\n]+)`).exec(cacheBlock);
-	if (!m) return false;
-	const value = m[1].trim();
-	return value.length > 0 && value !== "undefined" && value !== "null";
-}
-/**
-* Detect whether the Vite config assigns a CDN or data cache adapter — i.e. the
-* `cdn` or `data` field of the `vinext({ cache })` option is given a value.
-* This is a source-level check on those exact object fields, not a fuzzy scan
-* for adapter names. Mirrors {@link viteConfigHasCloudflarePlugin}'s leniency:
-* an unreadable or absent config is treated as configured so a deploy is never
-* blocked on a false negative.
-*/
-function viteConfigHasCacheAdapter(root) {
-	const configPath = findViteConfigPath(root);
-	if (!configPath) return true;
-	let content;
-	try {
-		content = fs.readFileSync(configPath, "utf-8");
-	} catch {
-		return true;
-	}
-	const block = extractCacheBlock(content);
-	if (!block) return false;
-	return cacheFieldAssigned(block, "cdn") || cacheFieldAssigned(block, "data");
-}
-function viteConfigHasImageAdapter(root) {
-	const configPath = findViteConfigPath(root);
-	if (!configPath) return true;
-	try {
-		const content = fs.readFileSync(configPath, "utf-8");
-		const match = /\bimages\s*:\s*\{/.exec(content);
-		if (!match) return false;
-		const open = match.index + match[0].length - 1;
-		let depth = 0;
-		for (let index = open; index < content.length; index++) if (content[index] === "{") depth++;
-		else if (content[index] === "}" && --depth === 0) {
-			const optimizer = /\boptimizer\s*:\s*([^,}\n]+)/.exec(content.slice(open, index + 1))?.[1];
-			return Boolean(optimizer && !/^(?:undefined|null)$/.test(optimizer.trim()));
-		}
-		return false;
-	} catch {
-		return true;
-	}
-}
-/**
-* Detect whether an existing user-authored Worker entry wires up a cache
-* backend imperatively via one of the `setCacheHandler` / `setDataCacheHandler`
-* / `setCdnCacheAdapter` setters. These setters are deprecated in favour of the
-* declarative `vinext({ cache })` option, but older apps that scaffolded a KV
-* cache handler into their Worker entry must keep working — so a deploy should
-* not be blocked when the Worker entry already configures a backend.
-*
-* This is a heuristic text scan (it doesn't execute the entry), mirroring
-* {@link viteConfigHasCacheAdapter}'s leniency: an unreadable Worker entry is
-* treated as configured so a deploy is never blocked on a false negative. A
-* missing Worker entry returns false (nothing to inspect — defer to other
-* checks).
-*/
-function workerEntryHasCacheHandler(root) {
-	const candidates = [path.join(root, "worker", "index.ts"), path.join(root, "worker", "index.js")];
-	for (const candidate of candidates) {
-		if (!fs.existsSync(candidate)) continue;
-		let content;
-		try {
-			content = fs.readFileSync(candidate, "utf-8");
-		} catch {
-			return true;
-		}
-		return /\b(?:setCacheHandler|setDataCacheHandler|setCdnCacheAdapter)\s*\(/.test(content);
-	}
-	return false;
-}
-/**
-* Build the error thrown when an ISR/cached app is deployed without a cache
-* adapter configured in the Vite config. Production deployments need a
-* persistent cache backend; vinext no longer scaffolds one into the Worker
-* entry, so it must be declared via `vinext({ cache })`.
-*/
-function formatMissingCacheAdapterError(options) {
-	const configRef = options.configFile ? options.configFile : "your Vite config";
-	return `[vinext] This app uses ISR / caching but no cache adapter is configured in ${configRef}.\n\n  Production deployments need a persistent cache backend. Declare one on the\n  vinext() plugin in ${configRef}:\n\n    import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";\n\n    export default defineConfig({\n      plugins: [\n        vinext({\n          cache: {\n            data: kvDataAdapter(), // KV-backed data cache (binding: VINEXT_KV_CACHE)\n          },\n        }),\n        cloudflare(),\n      ],\n    });\n\n  The VINEXT_KV_CACHE namespace binding is added to wrangler.jsonc for you.\n  Create the namespace with:\n\n    npx wrangler kv namespace create VINEXT_KV_CACHE`;
-}
-function formatImageOptimizationHint() {
-	return "  [vinext] next/image is served unoptimized. To enable edge image\n  optimization via Cloudflare Images, run:\n\n    vinext init --platform=cloudflare --image-optimization=cloudflare-images\n\n  This adds the imagesOptimizer() option to your Vite config and the matching\n  IMAGES binding to your Wrangler config without replacing existing settings.";
-}
-//#endregion
-export { formatImageOptimizationHint, formatMissingCacheAdapterError, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };

package/dist/packages/cloudflare/src/deploy-help.js

@@ -1,55 +0,0 @@
-//#region ../cloudflare/src/deploy-help.ts
-function formatDeployHelp() {
-	return `
-  vinext-cloudflare deploy - Deploy to Cloudflare Workers
-
-  Usage: vinext-cloudflare deploy [options]
-
-  One-command deployment to Cloudflare Workers. Automatically:
-    - Detects App Router or Pages Router
-    - Validates setup from vinext init --platform=cloudflare
-    - Builds the project with Vite
-    - Deploys via wrangler
-
-  Options:
-    --preview                Deploy to preview environment (same as --env preview)
-    --env <name>             Deploy using wrangler env.<name>
-    --name <name>            Custom Worker name (default: from package.json)
-    --skip-build             Skip the build step (use existing dist/)
-    --dry-run                Validate setup without building or deploying
-    --prerender-all          Pre-render discovered routes after building (future
-                             releases will auto-populate the remote cache)
-    --prerender-concurrency <count>
-                             Maximum number of routes to pre-render in parallel
-    -h, --help               Show this help
-
-  Experimental:
-    --experimental-tpr               Enable Traffic-aware Pre-Rendering
-    --tpr-coverage <pct>             Traffic coverage target, 0-100 (default: 90)
-    --tpr-limit <count>              Hard cap on pages to pre-render (default: 1000)
-    --tpr-window <hours>             Analytics lookback window in hours (default: 24)
-
-  TPR (Traffic-aware Pre-Rendering) uses Cloudflare zone analytics to determine
-  which pages get the most traffic and pre-renders them into KV cache during
-  deploy. This feature is experimental and must be explicitly enabled. Requires
-  a custom domain (zone analytics are unavailable on *.workers.dev) and the
-  CLOUDFLARE_API_TOKEN environment variable with Zone.Analytics read permission.
-
-  Examples:
-    npx @vinext/cloudflare deploy                                      Build and deploy to production
-    vpx @vinext/cloudflare deploy                                      Build and deploy with Vite+
-    vp exec vinext-cloudflare deploy                                   Run the locally installed Vite+ bin
-    vinext-cloudflare deploy --preview                                 Deploy to a preview URL
-    vinext-cloudflare deploy --env staging                             Deploy using wrangler env.staging
-    vinext-cloudflare deploy --dry-run                                 Validate setup without building or deploying
-    vinext-cloudflare deploy --name my-app                             Deploy with a custom Worker name
-    vinext-cloudflare deploy --experimental-tpr                        Enable TPR during deploy
-    vinext-cloudflare deploy --experimental-tpr --tpr-coverage 95      Cover 95% of traffic
-    vinext-cloudflare deploy --experimental-tpr --tpr-limit 500        Cap at 500 pages
-`;
-}
-function printDeployHelp() {
-	console.log(formatDeployHelp());
-}
-//#endregion
-export { printDeployHelp };