vinext 0.1.8 → 0.2.0

package/dist/node_modules/.pnpm/am-i-vibing@0.5.0/node_modules/am-i-vibing/dist/detector-1yx2Hoe0.js

@@ -0,0 +1,294 @@
+import { getProcessAncestry } from "../../../../process-ancestry@0.1.0/node_modules/process-ancestry/dist/index.js";
+//#region ../../node_modules/.pnpm/am-i-vibing@0.5.0/node_modules/am-i-vibing/dist/detector-1yx2Hoe0.mjs
+/**
+* Provider configurations for major AI coding tools
+*/
+const providers = [
+	{
+		id: "opencode",
+		name: "OpenCode",
+		type: "agent",
+		envVars: [{ any: [
+			"OPENCODE",
+			"OPENCODE_BIN_PATH",
+			"OPENCODE_SERVER",
+			"OPENCODE_APP_INFO",
+			"OPENCODE_MODES"
+		] }]
+	},
+	{
+		id: "jules",
+		name: "Jules",
+		type: "agent",
+		envVars: [{ all: [["HOME", "/home/jules"], ["USER", "swebot"]] }]
+	},
+	{
+		id: "claude-code",
+		name: "Claude Code",
+		type: "agent",
+		envVars: ["CLAUDECODE"]
+	},
+	{
+		id: "cursor-agent",
+		name: "Cursor Agent",
+		type: "agent",
+		envVars: [{ all: ["CURSOR_TRACE_ID", ["PAGER", "head -n 10000 | cat"]] }]
+	},
+	{
+		id: "cursor",
+		name: "Cursor",
+		type: "interactive",
+		envVars: ["CURSOR_TRACE_ID"]
+	},
+	{
+		id: "antigravity",
+		name: "Antigravity",
+		type: "agent",
+		envVars: [{ any: ["ANTIGRAVITY_AGENT", "ANTIGRAVITY_PROJECT_ID"] }]
+	},
+	{
+		id: "gemini-agent",
+		name: "Gemini CLI",
+		type: "agent",
+		envVars: [["GEMINI_CLI", "1"]],
+		processChecks: ["gemini"]
+	},
+	{
+		id: "codex",
+		name: "OpenAI Codex",
+		type: "agent",
+		envVars: ["CODEX_THREAD_ID"],
+		processChecks: ["codex"]
+	},
+	{
+		id: "replit",
+		name: "Replit",
+		type: "agent",
+		envVars: ["REPL_ID"]
+	},
+	{
+		id: "aider",
+		name: "Aider",
+		type: "agent",
+		envVars: ["AIDER_API_KEY"],
+		processChecks: ["aider"]
+	},
+	{
+		id: "bolt-agent",
+		name: "Bolt.new Agent",
+		type: "agent",
+		envVars: [{ all: [["SHELL", "/bin/jsh"], "npm_config_yes"] }]
+	},
+	{
+		id: "bolt",
+		name: "Bolt.new",
+		type: "interactive",
+		envVars: [{
+			all: [["SHELL", "/bin/jsh"]],
+			none: ["npm_config_yes"]
+		}]
+	},
+	{
+		id: "zed-agent",
+		name: "Zed Agent",
+		type: "agent",
+		envVars: [{ all: [["TERM_PROGRAM", "zed"], ["PAGER", "cat"]] }]
+	},
+	{
+		id: "zed",
+		name: "Zed",
+		type: "interactive",
+		envVars: [{
+			all: [["TERM_PROGRAM", "zed"]],
+			none: [["PAGER", "cat"]]
+		}]
+	},
+	{
+		id: "replit-assistant",
+		name: "Replit Assistant",
+		type: "agent",
+		envVars: [{ all: ["REPL_ID", ["REPLIT_MODE", "assistant"]] }]
+	},
+	{
+		id: "replit",
+		name: "Replit",
+		type: "interactive",
+		envVars: [{
+			all: ["REPL_ID"],
+			none: [["REPLIT_MODE", "assistant"]]
+		}]
+	},
+	{
+		id: "windsurf",
+		name: "Windsurf",
+		type: "agent",
+		envVars: ["CODEIUM_EDITOR_APP_ROOT"]
+	},
+	{
+		id: "crush",
+		name: "Crush",
+		type: "agent",
+		envVars: [{ any: [
+			["CRUSH", "1"],
+			["AGENT", "crush"],
+			["AI_AGENT", "crush"]
+		] }],
+		processChecks: ["crush"]
+	},
+	{
+		id: "amp",
+		name: "Amp",
+		type: "agent",
+		envVars: [{ any: ["AMP_CURRENT_THREAD_ID", ["AGENT", "amp"]] }]
+	},
+	{
+		id: "auggie",
+		name: "Auggie",
+		type: "agent",
+		envVars: [["AUGMENT_AGENT", "1"]]
+	},
+	{
+		id: "qwen-code",
+		name: "Qwen Code",
+		type: "agent",
+		envVars: [["QWEN_CODE", "1"]]
+	},
+	{
+		id: "vscode-copilot-agent",
+		name: "GitHub Copilot in VS Code",
+		type: "agent",
+		envVars: [{ all: [["TERM_PROGRAM", "vscode"], ["GIT_PAGER", "cat"]] }]
+	},
+	{
+		id: "warp",
+		name: "Warp Terminal",
+		type: "hybrid",
+		envVars: [{ all: [["TERM_PROGRAM", "WarpTerminal"]] }]
+	},
+	{
+		id: "octofriend",
+		name: "Octofriend",
+		type: "agent",
+		processChecks: ["octofriend"]
+	},
+	{
+		id: "devin",
+		name: "Devin",
+		type: "agent",
+		processChecks: ["devin"]
+	},
+	{
+		id: "droid",
+		name: "Factory Droid",
+		type: "agent",
+		processChecks: ["droid"]
+	},
+	{
+		id: "pi",
+		name: "Pi",
+		type: "agent",
+		envVars: [["PI_CODING_AGENT", "true"]]
+	}
+];
+/**
+* Check if a specific environment variable exists (handles both strings and tuples)
+*/
+function checkEnvVar(envVarDef, env = process.env) {
+	const [envVar, expectedValue] = typeof envVarDef === "string" ? [envVarDef, void 0] : envVarDef;
+	const actualValue = env[envVar];
+	return Boolean(actualValue && (!expectedValue || actualValue === expectedValue));
+}
+/**
+* Check if a process is running in the process tree
+*/
+function checkProcess(processName, processAncestry) {
+	for (const ancestorProcess of processAncestry) if (ancestorProcess.command?.includes(processName)) return true;
+	return false;
+}
+/**
+* Check if an environment variable group matches based on its properties
+*/
+function checkEnvVars(definition, env = process.env) {
+	if (typeof definition === "string" || Array.isArray(definition)) return checkEnvVar(definition, env);
+	const { any, all, none } = definition;
+	const anyResult = !any?.length || any.some((envVar) => checkEnvVar(envVar, env));
+	const allResult = !all?.length || all.every((envVar) => checkEnvVar(envVar, env));
+	const noneResult = !none?.length || !none.some((envVar) => checkEnvVar(envVar, env));
+	return anyResult && allResult && noneResult;
+}
+/**
+* Run custom detectors for a provider
+*/
+function runCustomDetectors(provider) {
+	return provider.customDetectors?.some((detector) => {
+		try {
+			return detector();
+		} catch {
+			return false;
+		}
+	}) ?? false;
+}
+/**
+* Create a positive detection result
+*/
+function createDetectedResult(provider) {
+	return {
+		isAgentic: true,
+		id: provider.id,
+		name: provider.name,
+		type: provider.type
+	};
+}
+/**
+* Normalize the various supported argument shapes into a DetectOptions object.
+*
+* Supported shapes:
+*   - detectAgenticEnvironment()
+*   - detectAgenticEnvironment(options)
+*   - detectAgenticEnvironment(env)                       // legacy
+*   - detectAgenticEnvironment(env, processAncestry)      // legacy
+*/
+function normalizeOptions(envOrOptions, legacyAncestry) {
+	if (envOrOptions != null && typeof envOrOptions === "object" && ("env" in envOrOptions || "processAncestry" in envOrOptions || "checkProcesses" in envOrOptions)) {
+		const opts = envOrOptions;
+		return {
+			env: opts.env ?? process.env,
+			processAncestry: opts.processAncestry,
+			checkProcesses: opts.checkProcesses ?? opts.processAncestry !== void 0
+		};
+	}
+	return {
+		env: envOrOptions ?? process.env,
+		processAncestry: legacyAncestry,
+		checkProcesses: legacyAncestry !== void 0
+	};
+}
+function detectAgenticEnvironment(envOrOptions, legacyAncestry) {
+	const { env, processAncestry, checkProcesses } = normalizeOptions(envOrOptions, legacyAncestry);
+	for (const provider of providers) if (provider.envVars?.some((group) => checkEnvVars(group, env))) return createDetectedResult(provider);
+	for (const provider of providers) if (runCustomDetectors(provider)) return createDetectedResult(provider);
+	if (checkProcesses) {
+		let cachedAncestry = processAncestry;
+		const getAncestry = () => {
+			if (cachedAncestry === void 0) try {
+				cachedAncestry = getProcessAncestry();
+			} catch {
+				cachedAncestry = [];
+			}
+			return cachedAncestry;
+		};
+		for (const provider of providers) if (provider.processChecks?.some((processName) => checkProcess(processName, getAncestry()))) return createDetectedResult(provider);
+	}
+	return {
+		isAgentic: false,
+		id: null,
+		name: null,
+		type: null
+	};
+}
+function isAgent(envOrOptions, legacyAncestry) {
+	const result = detectAgenticEnvironment(envOrOptions, legacyAncestry);
+	return result.type === "agent" || result.type === "hybrid";
+}
+//#endregion
+export { isAgent };

package/dist/node_modules/.pnpm/process-ancestry@0.1.0/node_modules/process-ancestry/dist/index.js

@@ -0,0 +1,94 @@
+import os from "os";
+import { execSync } from "child_process";
+//#region ../../node_modules/.pnpm/process-ancestry@0.1.0/node_modules/process-ancestry/dist/index.js
+function getProcessInfo(pid) {
+	try {
+		const output = execSync(`ps -p ${pid} -o pid=,ppid=,command=`, {
+			encoding: "utf8",
+			timeout: 5e3
+		}).trim();
+		if (!output) return null;
+		const [pidStr, ppidStr, ...commandParts] = output.split(/\s+/);
+		const parsedPid = pidStr ? parseInt(pidStr, 10) : NaN;
+		const parsedPpid = ppidStr ? parseInt(ppidStr, 10) : NaN;
+		if (isNaN(parsedPid) || isNaN(parsedPpid)) return null;
+		return {
+			pid: parsedPid,
+			ppid: parsedPpid,
+			command: commandParts.join(" ") || void 0
+		};
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("timeout")) console.warn(`Process lookup timed out for PID ${pid}`);
+		return null;
+	}
+}
+function getAncestryUnix(startPid) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	let currentPid = startPid;
+	let maxDepth = 1e3;
+	while (currentPid && maxDepth > 0) {
+		if (visited.has(currentPid)) {
+			console.warn(`Detected cycle in process tree at PID ${currentPid}`);
+			break;
+		}
+		visited.add(currentPid);
+		const info = getProcessInfo(currentPid);
+		if (!info || info.ppid === 0 || info.ppid === 1) break;
+		result.push(info);
+		currentPid = info.ppid;
+		maxDepth--;
+	}
+	if (maxDepth === 0) console.warn(`Reached maximum depth limit while traversing process tree from PID ${startPid}`);
+	return result;
+}
+function getProcessInfo2(pid) {
+	try {
+		const output = execSync(`wmic process where (ProcessId=${pid}) get ProcessId,ParentProcessId,CommandLine /format:csv`, {
+			encoding: "utf8",
+			timeout: 1e4
+		});
+		if (!output) return null;
+		const fields = output.split("\n").filter((line) => line.trim() && !line.startsWith("Node")).pop()?.split(",");
+		if (!fields || fields.length < 4) return null;
+		const [_node, commandLine, parentPid, thisPid] = fields;
+		const parsedPid = thisPid ? parseInt(thisPid.trim(), 10) : NaN;
+		const parsedPpid = parentPid ? parseInt(parentPid.trim(), 10) : NaN;
+		if (isNaN(parsedPid) || isNaN(parsedPpid)) return null;
+		return {
+			pid: parsedPid,
+			ppid: parsedPpid,
+			command: commandLine?.trim() || void 0
+		};
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("timeout")) console.warn(`Process lookup timed out for PID ${pid}`);
+		return null;
+	}
+}
+function getAncestryWindows(startPid) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	let currentPid = startPid;
+	let maxDepth = 1e3;
+	while (currentPid && maxDepth > 0) {
+		if (visited.has(currentPid)) {
+			console.warn(`Detected cycle in process tree at PID ${currentPid}`);
+			break;
+		}
+		visited.add(currentPid);
+		const info = getProcessInfo2(currentPid);
+		if (!info || info.ppid === 0 || info.ppid === 4) break;
+		result.push(info);
+		currentPid = info.ppid;
+		maxDepth--;
+	}
+	if (maxDepth === 0) console.warn(`Reached maximum depth limit while traversing process tree from PID ${startPid}`);
+	return result;
+}
+function getProcessAncestry(pid = process.pid) {
+	if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) throw new Error("PID must be a positive integer");
+	if (os.platform() === "win32") return getAncestryWindows(pid);
+	else return getAncestryUnix(pid);
+}
+//#endregion
+export { getProcessAncestry };

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

@@ -1,4 +1,4 @@
-import { getRequestExecutionContext } from "../../../shims/request-context.js";
+import { getRequestExecutionContext } from "../../../../shims/request-context.js";
 //#region ../cloudflare/src/cache/cdn-adapter.runtime.ts
 function getWorkersCache() {
 	const cache = getRequestExecutionContext()?.cache;

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

@@ -1,5 +1,5 @@
-import { CacheHandler, CacheHandlerValue, IncrementalCacheValue } from "../../../shims/cache-handler.js";
-import { ExecutionContextLike } from "../../../shims/request-context.js";
+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 = {

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

@@ -1,4 +1,4 @@
-import { getRequestExecutionContext } from "../../../shims/request-context.js";
+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

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

@@ -0,0 +1,150 @@
+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

@@ -0,0 +1,55 @@
+//#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 };