@farm.js/cli 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,2469 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_add_integration = require("./add-integration-pp16Zr0U.js");
+const require_build = require("./build.js");
+let _farm_js_core_server = require("@farm.js/core/server");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+node_path = require_add_integration.__toESM(node_path);
+let child_process = require("child_process");
+let fs = require("fs");
+let path = require("path");
+path = require_add_integration.__toESM(path);
+let _farm_js_core = require("@farm.js/core");
+let node_child_process = require("node:child_process");
+let node_timers_promises = require("node:timers/promises");
+let picocolors = require("picocolors");
+picocolors = require_add_integration.__toESM(picocolors);
+let croner = require("croner");
+//#region src/deploy.ts
+/**
+* Deploy Farm.js application
+*/
+async function deployFarm(options = {}) {
+	const root = options.root || process.cwd();
+	const mode = "production";
+	const userConfig = await (0, _farm_js_core.loadConfig)(root, void 0, mode);
+	const config = userConfig ? await (0, _farm_js_core.resolveConfig)(userConfig, mode) : void 0;
+	const cliTarget = options.vercel ? "vercel" : options.cloudflare ? "cloudflare" : options.netlify ? "netlify" : void 0;
+	const platform = (0, _farm_js_core.normalizeDeployTarget)(cliTarget || config?.deploy.target);
+	if (platform !== "vercel" && platform !== "cloudflare" && platform !== "netlify") {
+		_farm_js_core.logger.error("Please specify a deployment target with --vercel, --cloudflare, --netlify, or farm.config deploy.target.");
+		process.exit(1);
+	}
+	const deployConfig = (0, _farm_js_core.resolveDeployConfig)(userConfig || {}, {
+		target: platform,
+		preset: cliTarget ? userConfig?.deploy?.preset || userConfig?.preset || (0, _farm_js_core.getPresetForDeployTarget)(platform) : void 0
+	});
+	const preset = deployConfig.preset || (0, _farm_js_core.getPresetForDeployTarget)(platform) || "node-server";
+	_farm_js_core.logger.info(`🚀 Building with ${preset} preset...`);
+	await require_build.buildFarm({
+		root,
+		preset
+	});
+	const nitroOutput = (0, _farm_js_core.resolveDeployOutputPath)(root, deployConfig.outputDir);
+	if (!(0, fs.existsSync)(nitroOutput)) {
+		_farm_js_core.logger.error(`Build output not found at ${nitroOutput}. Please run 'farm build' first.`);
+		process.exit(1);
+	}
+	await deployPlatform(platform, root, nitroOutput, deployConfig, options.prod);
+}
+/**
+* Deploy using platform's native CLI (user credentials)
+*/
+async function deployPlatform(platform, root, outputDir, deployConfig, prod) {
+	switch (platform) {
+		case "vercel":
+			await deployVercel(root, outputDir, prod);
+			break;
+		case "cloudflare":
+			await deployCloudflare(root, outputDir, deployConfig.cloudflare?.projectName || deployConfig.projectName);
+			break;
+		case "netlify":
+			await deployNetlify(root, outputDir, deployConfig.netlify?.site);
+			break;
+	}
+}
+/**
+* Deploy to Vercel using Vercel CLI
+*/
+async function deployVercel(root, outputDir, prod) {
+	_farm_js_core.logger.info("🚀 Deploying to Vercel...");
+	try {
+		(0, child_process.execSync)("vercel --version", { stdio: "ignore" });
+	} catch {
+		_farm_js_core.logger.error("❌ Vercel CLI is not installed.");
+		_farm_js_core.logger.info("💡 Install it with: npm i -g vercel");
+		process.exit(1);
+	}
+	try {
+		(0, child_process.execSync)("vercel whoami", { stdio: "ignore" });
+	} catch {
+		_farm_js_core.logger.warn("⚠️  Not logged in to Vercel.");
+		_farm_js_core.logger.info("💡 Please run: vercel login");
+		_farm_js_core.logger.info("   Then run: farm deploy --vercel");
+		process.exit(1);
+	}
+	try {
+		const { existsSync, statSync, readdirSync } = await import("fs");
+		const functionsDir = path.default.join(outputDir, "functions", "__nitro.func");
+		const staticDir = path.default.join(outputDir, "static");
+		const configFile = path.default.join(outputDir, "config.json");
+		const serverIndex = path.default.join(functionsDir, "index.mjs");
+		_farm_js_core.logger.info("🔍 Verifying deployment structure...");
+		if (!existsSync(functionsDir)) {
+			_farm_js_core.logger.error(`❌ Functions directory not found at ${functionsDir}`);
+			process.exit(1);
+		}
+		if (!existsSync(serverIndex)) {
+			_farm_js_core.logger.error(`❌ Server entry point not found at ${serverIndex}`);
+			process.exit(1);
+		}
+		_farm_js_core.logger.info(`✅ Functions directory: ${functionsDir}`);
+		if (!existsSync(staticDir)) _farm_js_core.logger.warn(`⚠️  Static directory not found at ${staticDir}`);
+		else {
+			const countFiles = (dir) => {
+				let count = 0;
+				try {
+					const entries = readdirSync(dir, { withFileTypes: true });
+					for (const entry of entries) {
+						const fullPath = path.default.join(dir, entry.name);
+						if (entry.isDirectory()) count += countFiles(fullPath);
+						else count++;
+					}
+				} catch {}
+				return count;
+			};
+			const fileCount = countFiles(staticDir);
+			_farm_js_core.logger.info(`✅ Static directory: ${staticDir} (${fileCount} files)`);
+			for (const file of [
+				"farm-client-manifest.json",
+				"farm-client.js",
+				"assets"
+			]) if (existsSync(path.default.join(staticDir, file))) _farm_js_core.logger.info(`   ✓ ${file}`);
+			else _farm_js_core.logger.warn(`   ✗ ${file} (missing)`);
+			if (fileCount === 0) _farm_js_core.logger.warn("⚠️  Static directory is empty - static assets may not be served");
+		}
+		if (!existsSync(configFile)) _farm_js_core.logger.warn(`⚠️  Config file not found at ${configFile}`);
+		else {
+			_farm_js_core.logger.info(`✅ Config file: ${configFile}`);
+			try {
+				const config = JSON.parse(require("fs").readFileSync(configFile, "utf-8"));
+				if (config.routes && config.routes.length > 0) _farm_js_core.logger.info(`   ✓ Routing rules: ${config.routes.length} rules configured`);
+			} catch {
+				_farm_js_core.logger.warn("   ⚠️  Could not parse config.json");
+			}
+		}
+		const calculateDirSize = (dirPath) => {
+			if (!existsSync(dirPath)) return 0;
+			let totalSize = 0;
+			try {
+				const entries = readdirSync(dirPath, { withFileTypes: true });
+				for (const entry of entries) {
+					const fullPath = path.default.join(dirPath, entry.name);
+					if (entry.isFile()) totalSize += statSync(fullPath).size;
+					else if (entry.isDirectory()) totalSize += calculateDirSize(fullPath);
+				}
+			} catch {}
+			return totalSize;
+		};
+		const functionsSize = calculateDirSize(functionsDir);
+		const staticSize = calculateDirSize(staticDir);
+		_farm_js_core.logger.info(`📦 Deployment size: Functions ${(functionsSize / 1024 / 1024).toFixed(2)}MB, Static ${(staticSize / 1024).toFixed(1)}KB`);
+		_farm_js_core.logger.info("🔍 Verifying critical files:");
+		const criticalFiles = [
+			{
+				path: serverIndex,
+				name: "Server entry point"
+			},
+			{
+				path: path.default.join(functionsDir, "package.json"),
+				name: "Function package.json"
+			},
+			{
+				path: path.default.join(functionsDir, ".vc-config.json"),
+				name: "Vercel config"
+			},
+			{
+				path: path.default.join(staticDir, "farm-client-manifest.json"),
+				name: "Client manifest"
+			}
+		];
+		for (const file of criticalFiles) if (existsSync(file.path)) _farm_js_core.logger.info(`   ✅ ${file.name}`);
+		else _farm_js_core.logger.warn(`   ⚠️  ${file.name} (missing)`);
+		if (existsSync(path.default.join(staticDir, "farm-client.js")) || existsSync(path.default.join(staticDir, "assets"))) _farm_js_core.logger.info("   ✅ Client assets (farm-client.js or assets/)");
+		else _farm_js_core.logger.warn("   ⚠️  Client assets directory (missing)");
+		_farm_js_core.logger.info("🚀 Deploying to Vercel...");
+		_farm_js_core.logger.info(`   Deploying from: ${root}`);
+		_farm_js_core.logger.info(`   Functions: ${functionsDir}`);
+		_farm_js_core.logger.info(`   Static: ${staticDir}`);
+		_farm_js_core.logger.info(`   Config: ${configFile}`);
+		_farm_js_core.logger.info("📤 Uploading to Vercel...");
+		(0, child_process.execSync)(`vercel deploy --prebuilt --yes${prod ? " --prod" : ""}`, {
+			stdio: "inherit",
+			cwd: root
+		});
+		_farm_js_core.logger.success("✅ Deployed to Vercel successfully!");
+	} catch (error) {
+		_farm_js_core.logger.error(`❌ Failed to deploy to Vercel: ${error.message}`);
+		process.exit(1);
+	}
+}
+/** Deploy to a composed Worker or fall back to Cloudflare Pages. */
+async function deployCloudflare(root, outputDir, projectName) {
+	const agentPlan = resolveCloudflareAgentDeployPlan(root);
+	if (agentPlan) {
+		_farm_js_core.logger.info("🚀 Deploying Farm and Cloudflare Agents as one Worker...");
+		assertWranglerInstalled(root);
+		try {
+			(0, child_process.execFileSync)("wrangler", [
+				"deploy",
+				"--config",
+				agentPlan.configPath,
+				...agentPlan.environment ? ["--env", agentPlan.environment] : []
+			], {
+				stdio: "inherit",
+				cwd: root
+			});
+			_farm_js_core.logger.success("✅ Deployed Farm and Cloudflare Agents successfully!");
+		} catch (error) {
+			_farm_js_core.logger.error(`❌ Failed to deploy to Cloudflare: ${error.message}`);
+			process.exit(1);
+		}
+		return;
+	}
+	_farm_js_core.logger.info("🚀 Deploying to Cloudflare Pages...");
+	assertWranglerInstalled(root);
+	try {
+		(0, child_process.execFileSync)("wrangler", [
+			"pages",
+			"deploy",
+			".",
+			`--project-name=${projectName || "farm-app"}`
+		], {
+			stdio: "inherit",
+			cwd: outputDir
+		});
+		_farm_js_core.logger.success("✅ Deployed to Cloudflare Pages successfully!");
+	} catch (error) {
+		_farm_js_core.logger.error(`❌ Failed to deploy to Cloudflare: ${error.message}`);
+		process.exit(1);
+	}
+}
+/** Read the trusted Workers deployment handoff emitted by @farm.js/cf-agent. */
+function resolveCloudflareAgentDeployPlan(root) {
+	const projectRoot = path.default.resolve(root);
+	const metadataPath = path.default.join(projectRoot, ".farm", "cf-agent", "deploy.json");
+	if (!(0, fs.existsSync)(metadataPath)) return void 0;
+	let metadata;
+	try {
+		metadata = JSON.parse((0, fs.readFileSync)(metadataPath, "utf8"));
+	} catch {
+		throw new Error(`Invalid Cloudflare Agents deployment metadata at ${metadataPath}.`);
+	}
+	if (!isRecord(metadata) || metadata.version !== 1 || metadata.provider !== "cloudflare-agents" || typeof metadata.config !== "string" || !metadata.config.trim()) throw new Error(`Invalid Cloudflare Agents deployment metadata at ${metadataPath}.`);
+	const configPath = path.default.resolve(projectRoot, metadata.config);
+	const relativeConfigPath = path.default.relative(projectRoot, configPath);
+	if (relativeConfigPath === ".." || relativeConfigPath.startsWith(`..${path.default.sep}`) || path.default.isAbsolute(relativeConfigPath)) throw new Error("Cloudflare Agents deployment config must stay inside the Farm project root.");
+	if (!(0, fs.existsSync)(configPath)) throw new Error(`Cloudflare Agents deployment config was not found at ${configPath}.`);
+	const environment = metadata.environment;
+	if (environment !== void 0 && (typeof environment !== "string" || !environment.trim())) throw new Error("Cloudflare Agents deployment environment must be a non-empty string.");
+	return {
+		configPath,
+		...typeof environment === "string" ? { environment: environment.trim() } : {}
+	};
+}
+function assertWranglerInstalled(root) {
+	try {
+		(0, child_process.execFileSync)("wrangler", ["--version"], {
+			stdio: "ignore",
+			cwd: root
+		});
+	} catch {
+		_farm_js_core.logger.error("❌ Wrangler CLI is not installed.");
+		_farm_js_core.logger.info("💡 Install it in this project with: npm i -D wrangler");
+		process.exit(1);
+	}
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* Deploy to Netlify using Netlify CLI
+*/
+async function deployNetlify(root, outputDir, site) {
+	_farm_js_core.logger.info("🚀 Deploying to Netlify...");
+	try {
+		(0, child_process.execSync)("netlify --version", { stdio: "ignore" });
+	} catch {
+		_farm_js_core.logger.error("❌ Netlify CLI is not installed.");
+		_farm_js_core.logger.info("💡 Install it with: npm i -g netlify-cli");
+		process.exit(1);
+	}
+	try {
+		process.chdir(outputDir);
+		(0, child_process.execSync)(`netlify deploy --prod --dir=.${site ? ` --site=${site}` : ""}`, { stdio: "inherit" });
+		_farm_js_core.logger.success("✅ Deployed to Netlify successfully!");
+	} catch (error) {
+		_farm_js_core.logger.error(`❌ Failed to deploy to Netlify: ${error.message}`);
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/preview-gateway.ts
+const DEFAULT_GATEWAY_URL = "https://preview.farming-labs.dev";
+const DEFAULT_PREVIEW_DOMAIN = "preview.farming-labs.dev";
+const DEFAULT_POLL_TIMEOUT_MS = 15e3;
+const DEFAULT_LOCAL_PROBE_INTERVAL_MS = 2e3;
+const DEFAULT_LOCAL_PROBE_TIMEOUT_MS = 1e3;
+const DEFAULT_MAX_CONCURRENT_REQUESTS = 25;
+const HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
+	"connection",
+	"content-length",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+]);
+function createPreviewGatewayPlan(target, options = {}) {
+	const requestedName = sanitizePreviewName$1(options.name || process.env.FARM_PREVIEW_NAME) || randomPreviewName$1();
+	const gatewayUrl = normalizeGatewayUrl(options.gatewayUrl || process.env.FARM_PREVIEW_GATEWAY_URL || DEFAULT_GATEWAY_URL);
+	const requestedHostname = `${requestedName}.${normalizePreviewDomain$1(process.env.FARM_PREVIEW_DOMAIN || DEFAULT_PREVIEW_DOMAIN)}`;
+	return {
+		provider: "farm-gateway",
+		gatewayUrl,
+		target,
+		requestedName,
+		requestedHostname,
+		requestedPublicUrl: `https://${requestedHostname}`
+	};
+}
+async function runPreviewGateway(plan, options = {}) {
+	const session = await createGatewaySession(plan, options.timeoutMs ?? 3e4);
+	const controller = new AbortController();
+	let handledRequests = 0;
+	const inFlightRequests = /* @__PURE__ */ new Set();
+	const maxConcurrentRequests = Math.max(1, options.maxConcurrentRequests ?? DEFAULT_MAX_CONCURRENT_REQUESTS);
+	const localTargetWatch = watchLocalPreviewTarget(plan.target, controller, {
+		intervalMs: options.localProbeIntervalMs ?? DEFAULT_LOCAL_PROBE_INTERVAL_MS,
+		timeoutMs: options.localProbeTimeoutMs ?? DEFAULT_LOCAL_PROBE_TIMEOUT_MS
+	});
+	const cleanup = () => controller.abort();
+	process.once("SIGINT", cleanup);
+	process.once("SIGTERM", cleanup);
+	_farm_js_core.logger.success("Preview URL ready.");
+	_farm_js_core.logger.info(`Public: ${session.publicUrl}`);
+	_farm_js_core.logger.info("Forwarding requests until Ctrl+C. Remote traffic will be logged below.");
+	const waitForAvailableRequestSlot = async () => {
+		while (!controller.signal.aborted && inFlightRequests.size >= maxConcurrentRequests) await Promise.race(inFlightRequests);
+	};
+	const handleRequest = async (request) => {
+		const startedAt = Date.now();
+		try {
+			const response = await forwardGatewayRequest(plan.target, request);
+			await sendGatewayResponse(plan, session, request.id, response, controller.signal);
+			handledRequests += 1;
+			_farm_js_core.logger.info(`${request.method.toUpperCase()} ${formatRequestPath(request.path)} -> ${response.status} ${Date.now() - startedAt}ms`);
+		} catch (error) {
+			if (controller.signal.aborted) return;
+			_farm_js_core.logger.warn(`Local preview target ${plan.target.localUrl} is no longer reachable. Closing preview session.`);
+			controller.abort(error);
+		}
+	};
+	try {
+		while (!controller.signal.aborted) {
+			await waitForAvailableRequestSlot();
+			if (controller.signal.aborted) break;
+			const requests = await pollGatewayRequests(plan, session, {
+				signal: controller.signal,
+				pollTimeoutMs: options.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS
+			});
+			for (const request of requests) {
+				await waitForAvailableRequestSlot();
+				if (controller.signal.aborted) break;
+				const promise = handleRequest(request);
+				inFlightRequests.add(promise);
+				promise.finally(() => inFlightRequests.delete(promise));
+			}
+			if (options.maxRequests && handledRequests >= options.maxRequests) break;
+		}
+	} finally {
+		process.removeListener("SIGINT", cleanup);
+		process.removeListener("SIGTERM", cleanup);
+		controller.abort();
+		await Promise.allSettled(inFlightRequests);
+		await localTargetWatch.catch(() => void 0);
+		await closeGatewaySession(plan, session).catch(() => void 0);
+	}
+	return session;
+}
+async function watchLocalPreviewTarget(target, controller, options) {
+	while (!controller.signal.aborted) {
+		try {
+			await (0, node_timers_promises.setTimeout)(options.intervalMs, void 0, { signal: controller.signal });
+		} catch {
+			return;
+		}
+		if (controller.signal.aborted) return;
+		if (!await isLocalPreviewTargetReachable(target.localUrl, options.timeoutMs) && !controller.signal.aborted) {
+			_farm_js_core.logger.warn(`Local preview target ${target.localUrl} is no longer reachable. Closing preview session.`);
+			controller.abort(/* @__PURE__ */ new Error("Local preview target is no longer reachable."));
+			return;
+		}
+	}
+}
+async function isLocalPreviewTargetReachable(url, timeoutMs) {
+	const signal = AbortSignal.timeout(timeoutMs);
+	try {
+		await fetch(url, {
+			method: "GET",
+			signal
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function createGatewaySession(plan, timeoutMs) {
+	const response = await fetch(`${plan.gatewayUrl}/api/sessions`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			name: plan.requestedName,
+			hostname: plan.requestedHostname,
+			localUrl: plan.target.localUrl
+		}),
+		signal: AbortSignal.timeout(timeoutMs)
+	});
+	if (!response.ok) throw new Error(`Preview gateway rejected the session (${response.status}): ${await response.text()}`);
+	const session = await response.json();
+	if (!session.id || !session.token || !session.publicUrl) throw new Error("Preview gateway returned an invalid session.");
+	return session;
+}
+async function forwardGatewayRequest(target, request) {
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(request.headers || {})) {
+		const normalized = key.toLowerCase();
+		if (HOP_BY_HOP_HEADERS.has(normalized) || normalized.startsWith("sec-websocket-")) continue;
+		headers.set(key, value);
+	}
+	headers.set("x-farm-preview", "1");
+	const method = request.method.toUpperCase();
+	const hasBody = method !== "GET" && method !== "HEAD" && Boolean(request.body);
+	const response = await fetch(`${target.localUrl}${request.path}`, {
+		method,
+		headers,
+		body: hasBody ? Buffer.from(request.body || "", request.encoding === "base64" ? "base64" : "utf8") : void 0
+	});
+	const responseHeaders = {};
+	response.headers.forEach((value, key) => {
+		const normalized = key.toLowerCase();
+		if (!HOP_BY_HOP_HEADERS.has(normalized)) responseHeaders[key] = value;
+	});
+	return {
+		status: response.status,
+		headers: responseHeaders,
+		body: Buffer.from(await response.arrayBuffer()).toString("base64"),
+		encoding: "base64"
+	};
+}
+async function pollGatewayRequests(plan, session, options) {
+	try {
+		const response = await fetch(`${plan.gatewayUrl}/api/sessions/${session.id}/requests?token=${encodeURIComponent(session.token)}&wait=${options.pollTimeoutMs}`, {
+			headers: { accept: "application/json" },
+			signal: options.signal
+		});
+		if (response.status === 204) return [];
+		if (!response.ok) throw new Error(`Preview gateway poll failed (${response.status}): ${await response.text()}`);
+		return (await response.json()).requests || [];
+	} catch (error) {
+		if (options.signal.aborted) return [];
+		throw error;
+	}
+}
+async function sendGatewayResponse(plan, session, requestId, responseBody, signal) {
+	const response = await fetch(`${plan.gatewayUrl}/api/sessions/${session.id}/responses/${requestId}?token=${encodeURIComponent(session.token)}`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify(responseBody),
+		signal
+	});
+	if (!response.ok) throw new Error(`Preview gateway response upload failed (${response.status}): ${await response.text()}`);
+}
+async function closeGatewaySession(plan, session) {
+	await fetch(`${plan.gatewayUrl}/api/sessions/${session.id}?token=${encodeURIComponent(session.token)}`, { method: "DELETE" });
+}
+function formatGatewayPlan(plan) {
+	return [
+		`Gateway: ${plan.gatewayUrl}`,
+		`Local:   ${plan.target.localUrl}`,
+		`Public:  ${plan.requestedPublicUrl}`
+	].join("\n");
+}
+function formatRequestPath(path) {
+	if (path.length <= 96) return path;
+	return `${path.slice(0, 93)}...`;
+}
+function normalizeGatewayUrl(value) {
+	return value.replace(/\/+$/, "");
+}
+function normalizePreviewDomain$1(value) {
+	return value.replace(/^https?:\/\//, "").replace(/^\.*/, "").replace(/\/*$/, "");
+}
+function sanitizePreviewName$1(value) {
+	if (!value) return void 0;
+	return value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+}
+function randomPreviewName$1() {
+	return `farm-${Math.random().toString(36).slice(2, 8)}`;
+}
+//#endregion
+//#region src/preview.ts
+const DEFAULT_PREVIEW_PORTS = [
+	3e3,
+	4319,
+	5173,
+	4173,
+	8080
+];
+const PREVIEW_URL_PATTERN = /https:\/\/[^\s"')\]}]+/g;
+async function previewFarm(options = {}) {
+	const target = await resolvePreviewTarget(options);
+	_farm_js_core.logger.info("Creating public preview for the running app...");
+	_farm_js_core.logger.info(`Local:  ${target.localUrl}`);
+	if (shouldUseManagedGateway(options)) {
+		const plan = createPreviewGatewayPlan(target, options);
+		if (options.dryRun) {
+			_farm_js_core.logger.info(formatGatewayPlan(plan));
+			_farm_js_core.logger.success("Preview gateway dry run completed.");
+			return {
+				target,
+				plan
+			};
+		}
+		_farm_js_core.logger.info(`Gateway: ${plan.gatewayUrl}`);
+		_farm_js_core.logger.info("Opening Farm preview gateway session...");
+		const session = await runPreviewGateway(plan, { timeoutMs: options.timeoutMs });
+		return {
+			target,
+			plan,
+			publicUrl: session.publicUrl,
+			session
+		};
+	}
+	const plan = createPreviewTunnelPlan(target, options);
+	if (options.dryRun) {
+		_farm_js_core.logger.info(`Command: ${formatCommand(plan)}`);
+		_farm_js_core.logger.success("Preview tunnel dry run completed.");
+		return {
+			target,
+			plan
+		};
+	}
+	_farm_js_core.logger.info("Opening public tunnel...");
+	return {
+		target,
+		plan,
+		publicUrl: await runPreviewTunnel(plan, options.timeoutMs ?? 3e4)
+	};
+}
+function shouldUseManagedGateway(options) {
+	if (options.provider === "farm" || process.env.FARM_PREVIEW_PROVIDER === "farm") return true;
+	if (options.provider === "local" || process.env.FARM_PREVIEW_PROVIDER === "local") return false;
+	return !process.env.FARM_PREVIEW_TUNNEL_COMMAND;
+}
+async function resolvePreviewTarget(options = {}) {
+	if (options.url) {
+		const parsed = new URL(options.url);
+		const port = Number(parsed.port || (parsed.protocol === "https:" ? 443 : 80));
+		if (!Number.isFinite(port)) throw new Error(`Could not resolve a port from ${options.url}.`);
+		return {
+			localUrl: normalizeLocalUrl(options.url),
+			host: parsed.hostname,
+			port,
+			source: "url"
+		};
+	}
+	const root = options.root || process.cwd();
+	const host = options.host || process.env.FARM_PREVIEW_HOST || "localhost";
+	const explicitPort = normalizePort(options.port || process.env.FARM_PREVIEW_PORT);
+	const configPort = explicitPort ? void 0 : await readConfigPort(root, options.configPath);
+	const candidates = uniqueNumbers([
+		explicitPort,
+		normalizePort(process.env.FARM_PORT),
+		normalizePort(process.env.PORT),
+		configPort,
+		...DEFAULT_PREVIEW_PORTS
+	]);
+	if (!candidates.length) throw new Error("No preview port candidates were available.");
+	if (options.noProbe && explicitPort) return {
+		localUrl: createLocalUrl(host, explicitPort),
+		host,
+		port: explicitPort,
+		source: "port"
+	};
+	const timeoutMs = options.timeoutMs ?? 1500;
+	for (const port of candidates) {
+		const localUrl = createLocalUrl(host, port);
+		if (await isReachable(localUrl, timeoutMs)) return {
+			localUrl,
+			host,
+			port,
+			source: explicitPort ? "port" : configPort === port ? "config" : "detected"
+		};
+	}
+	const hint = explicitPort ? createLocalUrl(host, explicitPort) : candidates.map((port) => port).join(", ");
+	throw new Error(`No running Farm app was found (${hint}). Start "farm dev" first, or pass --port/--url to the running app.`);
+}
+function createPreviewTunnelPlan(target, options = {}) {
+	const requestedName = sanitizePreviewName(options.name || process.env.FARM_PREVIEW_NAME) || randomPreviewName();
+	const requestedHostname = `${requestedName}.${normalizePreviewDomain(process.env.FARM_PREVIEW_DOMAIN || "preview.farming-labs.dev")}`;
+	const template = process.env.FARM_PREVIEW_TUNNEL_COMMAND;
+	if (template) return {
+		command: expandTunnelTemplate(template, target, requestedName, requestedHostname),
+		args: [],
+		shell: true,
+		target,
+		requestedName,
+		requestedHostname
+	};
+	if (commandExists("cloudflared")) return {
+		command: "cloudflared",
+		args: [
+			"tunnel",
+			"--url",
+			target.localUrl
+		],
+		target,
+		requestedName,
+		requestedHostname
+	};
+	if (commandExists("npx")) return {
+		command: "npx",
+		args: [
+			"--yes",
+			"localtunnel",
+			"--port",
+			String(target.port),
+			"--local-host",
+			target.host,
+			"--subdomain",
+			requestedName
+		],
+		target,
+		requestedName,
+		requestedHostname
+	};
+	throw new Error("No preview tunnel command is available. Install cloudflared, ensure npx is available, or set FARM_PREVIEW_TUNNEL_COMMAND.");
+}
+function parsePreviewPublicUrl(output, preferredHostname) {
+	const urls = (output.match(PREVIEW_URL_PATTERN) || []).filter((value) => {
+		try {
+			const url = new URL(value);
+			return Boolean(url.hostname);
+		} catch {
+			return false;
+		}
+	});
+	if (preferredHostname) {
+		const preferred = urls.find((value) => new URL(value).hostname === preferredHostname);
+		if (preferred) return preferred;
+	}
+	return urls.find((value) => {
+		const host = new URL(value).hostname;
+		return host.endsWith(".trycloudflare.com") || host.endsWith(".loca.lt") || host.endsWith(".localtunnel.me") || host.endsWith(".ngrok.app") || host.endsWith(".ngrok-free.app") || host.endsWith(".ngrok.dev") || host.endsWith(".ngrok.io") || host.endsWith(".preview.farming-labs.dev");
+	}) || urls[0];
+}
+async function runPreviewTunnel(plan, timeoutMs) {
+	const child = (0, node_child_process.spawn)(plan.command, plan.args, {
+		env: {
+			...process.env,
+			FARM_PREVIEW_LOCAL_URL: plan.target.localUrl,
+			FARM_PREVIEW_NAME: plan.requestedName,
+			FARM_PREVIEW_HOSTNAME: plan.requestedHostname
+		},
+		shell: plan.shell,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	let output = "";
+	let publicUrl;
+	let settled = false;
+	const cleanup = () => {
+		if (!child.killed) child.kill("SIGTERM");
+	};
+	process.once("SIGINT", cleanup);
+	process.once("SIGTERM", cleanup);
+	try {
+		publicUrl = await new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("Timed out waiting for the preview URL."));
+			}, timeoutMs);
+			const handleChunk = (chunk) => {
+				const text = chunk.toString();
+				output += text;
+				process.stdout.write(text);
+				const nextUrl = parsePreviewPublicUrl(output, plan.requestedHostname);
+				if (nextUrl && !settled) {
+					settled = true;
+					clearTimeout(timer);
+					_farm_js_core.logger.success("Preview URL ready.");
+					_farm_js_core.logger.info(`Public: ${nextUrl}`);
+					_farm_js_core.logger.info("Forwarding requests until Ctrl+C.");
+					resolve(nextUrl);
+				}
+			};
+			child.stdout?.on("data", handleChunk);
+			child.stderr?.on("data", handleChunk);
+			child.on("error", (error) => {
+				if (!settled) {
+					settled = true;
+					clearTimeout(timer);
+					reject(error);
+				}
+			});
+			child.on("exit", (code, signal) => {
+				if (!settled) {
+					settled = true;
+					clearTimeout(timer);
+					reject(/* @__PURE__ */ new Error(`Preview tunnel exited before returning a URL (${signal || `exit code ${code ?? 0}`}).`));
+				}
+			});
+		});
+		await waitForTunnelExit(child);
+		return publicUrl;
+	} finally {
+		process.removeListener("SIGINT", cleanup);
+		process.removeListener("SIGTERM", cleanup);
+	}
+}
+function waitForTunnelExit(child) {
+	return new Promise((resolve) => {
+		if (child.exitCode !== null || child.signalCode !== null) {
+			resolve();
+			return;
+		}
+		child.once("exit", () => resolve());
+	});
+}
+async function isReachable(url, timeoutMs) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		await fetch(url, {
+			method: "GET",
+			signal: controller.signal
+		});
+		return true;
+	} catch {
+		return false;
+	} finally {
+		clearTimeout(timer);
+		await (0, node_timers_promises.setTimeout)(0);
+	}
+}
+async function readConfigPort(root, configPath) {
+	try {
+		const vite = (await (0, _farm_js_core.loadConfig)(root, configPath, "development"))?.vite;
+		if (!vite || typeof vite === "function") return void 0;
+		return normalizePort(vite.server?.port);
+	} catch {
+		return;
+	}
+}
+function commandExists(command) {
+	const result = (0, node_child_process.spawnSync)(command, ["--version"], {
+		shell: process.platform === "win32",
+		stdio: "ignore"
+	});
+	return !result.error && result.status === 0;
+}
+function expandTunnelTemplate(template, target, requestedName, requestedHostname) {
+	return template.replaceAll("{url}", shellQuote(target.localUrl)).replaceAll("{port}", shellQuote(String(target.port))).replaceAll("{host}", shellQuote(target.host)).replaceAll("{name}", shellQuote(requestedName)).replaceAll("{hostname}", shellQuote(requestedHostname));
+}
+function shellQuote(value) {
+	return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+function formatCommand(plan) {
+	if (plan.shell) return plan.command;
+	return [plan.command, ...plan.args].join(" ");
+}
+function normalizeLocalUrl(value) {
+	return value.replace(/\/+$/, "");
+}
+function createLocalUrl(host, port) {
+	return `http://${host}:${port}`;
+}
+function normalizePort(value) {
+	if (value === void 0 || value === null || value === "") return void 0;
+	const port = Number(value);
+	return Number.isInteger(port) && port > 0 && port <= 65535 ? port : void 0;
+}
+function uniqueNumbers(values) {
+	return [...new Set(values.filter((value) => value !== void 0))];
+}
+function sanitizePreviewName(value) {
+	if (!value) return void 0;
+	return value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+}
+function randomPreviewName() {
+	return `farm-${Math.random().toString(36).slice(2, 8)}`;
+}
+function normalizePreviewDomain(value) {
+	return value.replace(/^https?:\/\//, "").replace(/^\.*/, "").replace(/\/*$/, "");
+}
+//#endregion
+//#region src/generate.ts
+const PRISMA_GENERATED_START = "// Farm.js integrations generated schema: start";
+const PRISMA_GENERATED_END = "// Farm.js integrations generated schema: end";
+async function generateFarmArtifacts(options = {}) {
+	const root = node_path.default.resolve(options.root || process.cwd());
+	const userConfig = await (0, _farm_js_core.loadConfig)(root, options.configPath, "development");
+	if (!userConfig && hasSchemaOptions(options)) throw new Error("No Farm config found. Please create farm.config.ts or config.ts.");
+	const resolvedConfig = await (0, _farm_js_core.resolveConfig)({
+		root,
+		...userConfig || {}
+	}, "development");
+	const extraRoutes = [...resolvedConfig.openapi?.enabled && resolvedConfig.openapi.route ? [resolvedConfig.openapi.route] : [], ...(0, _farm_js_core.getFarmDocsRouteTypeEntries)(resolvedConfig.docs)];
+	await (0, _farm_js_core.generateRouteTypes)({
+		root: resolvedConfig.root,
+		srcDir: resolvedConfig.srcDir,
+		extraRoutes,
+		suppressLintOnLink: resolvedConfig.suppressLintOnLink
+	});
+	await (0, _farm_js_core.generateEnvTypes)({
+		root: resolvedConfig.root,
+		srcDir: resolvedConfig.srcDir,
+		configPath: options.configPath
+	});
+	const apiGenerator = new _farm_js_core.APITypeGenerator(node_path.default.join(resolvedConfig.root, resolvedConfig.srcDir, "app"));
+	const apiRoutes = apiGenerator.scanAPIRoutes();
+	const apiTypesPath = node_path.default.join(resolvedConfig.root, resolvedConfig.srcDir, "lib", "api.generated.ts");
+	await (0, node_fs_promises.mkdir)(node_path.default.dirname(apiTypesPath), { recursive: true });
+	await (0, node_fs_promises.writeFile)(apiTypesPath, apiGenerator.generateAPIRouter(apiRoutes), "utf8");
+	if (resolvedConfig.i18n.enabled) await (0, _farm_js_core.generateFarmI18nTypes)({
+		root: resolvedConfig.root,
+		srcDir: resolvedConfig.srcDir,
+		config: resolvedConfig.i18n
+	});
+	_farm_js_core.logger.success(`Generated route, API, env${resolvedConfig.i18n.enabled ? ", and i18n" : ""} types (${apiRoutes.length} API route${apiRoutes.length === 1 ? "" : "s"}).`);
+	const schemas = (0, _farm_js_core.getIntegrationSchemas)(resolvedConfig.integrations);
+	const schemaEntries = Object.entries(schemas);
+	if (!schemaEntries.length) {
+		if (hasSchemaOptions(options)) _farm_js_core.logger.warn("No integration schemas were found in the current Farm config.");
+		return;
+	}
+	const packageManifest = await readPackageManifest(root);
+	const schemaOptionsExplicit = hasSchemaOptions(options);
+	let orm = null;
+	try {
+		orm = options.orm ?? await detectSchemaTarget(root, packageManifest);
+	} catch (error) {
+		if (schemaOptionsExplicit) throw error;
+		_farm_js_core.logger.warn(`Integration schemas were found, but Farm could not choose a schema target automatically: ${error.message}`);
+		return;
+	}
+	if (!orm) {
+		if (!schemaOptionsExplicit) {
+			_farm_js_core.logger.warn("Integration schemas were found, but no data layer was detected. Pass --orm prisma|drizzle|postgres|mysql|sqlite|mongodb to generate schema artifacts.");
+			return;
+		}
+		throw new Error("Could not auto-detect a schema target. Pass one explicitly with --orm prisma|drizzle|postgres|mysql|sqlite|mongodb.");
+	}
+	const collectedModels = collectSchemaModels(schemaEntries);
+	switch (orm) {
+		case "prisma": {
+			const schemaPath = options.output ? node_path.default.resolve(root, options.output) : node_path.default.join(root, "prisma", "schema.prisma");
+			if (!(0, node_fs.existsSync)(schemaPath)) throw new Error(`Prisma target was selected but no schema file was found at ${schemaPath}. Create prisma/schema.prisma or pass --output.`);
+			await writePrismaSchema(schemaPath, collectedModels);
+			_farm_js_core.logger.success(`Generated Prisma integration schema in ${node_path.default.relative(root, schemaPath)}.`);
+			return;
+		}
+		case "drizzle": {
+			const dialect = options.dialect ?? await detectDrizzleDialect(root, packageManifest) ?? void 0;
+			if (!dialect) throw new Error("Detected Drizzle but could not determine its dialect. Pass --dialect postgres|mysql|sqlite.");
+			const outputPath = options.output ? node_path.default.resolve(root, options.output) : node_path.default.join(root, "farm-integrations.generated.ts");
+			await writeGeneratedFile(outputPath, generateDrizzleSchema(collectedModels, dialect));
+			_farm_js_core.logger.success(`Generated Drizzle integration schema in ${node_path.default.relative(root, outputPath)}.`);
+			return;
+		}
+		case "postgres":
+		case "mysql":
+		case "sqlite": {
+			const outputPath = options.output ? node_path.default.resolve(root, options.output) : node_path.default.join(root, `farm-integrations.generated.${orm}.sql`);
+			await writeGeneratedFile(outputPath, generateSqlSchema(collectedModels, orm));
+			_farm_js_core.logger.success(`Generated ${orm} integration schema in ${node_path.default.relative(root, outputPath)}.`);
+			return;
+		}
+		case "mongodb": {
+			const outputPath = options.output ? node_path.default.resolve(root, options.output) : node_path.default.join(root, "farm-integrations.generated.mongodb.ts");
+			await writeGeneratedFile(outputPath, generateMongoBootstrap(collectedModels));
+			_farm_js_core.logger.success(`Generated MongoDB integration bootstrap in ${node_path.default.relative(root, outputPath)}.`);
+			return;
+		}
+	}
+}
+function hasSchemaOptions(options) {
+	return Boolean(options.orm || options.output || options.dialect);
+}
+async function readPackageManifest(root) {
+	const packagePath = node_path.default.join(root, "package.json");
+	if (!(0, node_fs.existsSync)(packagePath)) return null;
+	const source = await (0, node_fs_promises.readFile)(packagePath, "utf8");
+	return JSON.parse(source);
+}
+async function detectSchemaTarget(root, packageManifest) {
+	const hasPrismaSchema = (0, node_fs.existsSync)(node_path.default.join(root, "prisma", "schema.prisma"));
+	const drizzleConfigPath = findExistingPath(root, [
+		"drizzle.config.ts",
+		"drizzle.config.mts",
+		"drizzle.config.js",
+		"drizzle.config.mjs",
+		"drizzle.config.cjs"
+	]);
+	if (hasPrismaSchema && drizzleConfigPath) throw new Error("Detected both Prisma and Drizzle in this project. Pass --orm prisma or --orm drizzle to choose one.");
+	if (hasPrismaSchema) return "prisma";
+	if (drizzleConfigPath) return "drizzle";
+	const dependencies = getPackageDependencyNames(packageManifest);
+	const candidates = /* @__PURE__ */ new Set();
+	if (dependencies.has("@prisma/client") || dependencies.has("prisma")) candidates.add("prisma");
+	if (dependencies.has("drizzle-orm") || dependencies.has("drizzle-kit")) candidates.add("drizzle");
+	if (hasAnyDependency(dependencies, [
+		"pg",
+		"postgres",
+		"@neondatabase/serverless"
+	])) candidates.add("postgres");
+	if (hasAnyDependency(dependencies, ["mysql2", "@planetscale/database"])) candidates.add("mysql");
+	if (hasAnyDependency(dependencies, ["better-sqlite3", "sqlite3"])) candidates.add("sqlite");
+	if (hasAnyDependency(dependencies, ["mongodb", "mongoose"])) candidates.add("mongodb");
+	if (candidates.size === 1) return Array.from(candidates)[0];
+	if (candidates.size > 1) throw new Error(`Detected multiple possible schema targets (${Array.from(candidates).join(", ")}). Pass --orm to choose one.`);
+	return null;
+}
+async function detectDrizzleDialect(root, packageManifest) {
+	const configPath = findExistingPath(root, [
+		"drizzle.config.ts",
+		"drizzle.config.mts",
+		"drizzle.config.js",
+		"drizzle.config.mjs",
+		"drizzle.config.cjs"
+	]);
+	if (configPath) {
+		const dialectMatch = (await (0, node_fs_promises.readFile)(configPath, "utf8")).match(/dialect\s*:\s*["'](postgresql|postgres|mysql|sqlite|turso)["']/);
+		if (dialectMatch) {
+			const dialect = dialectMatch[1];
+			if (dialect === "postgresql" || dialect === "postgres") return "postgres";
+			if (dialect === "mysql") return "mysql";
+			if (dialect === "sqlite" || dialect === "turso") return "sqlite";
+		}
+	}
+	const dependencies = getPackageDependencyNames(packageManifest);
+	const candidates = /* @__PURE__ */ new Set();
+	if (hasAnyDependency(dependencies, [
+		"pg",
+		"postgres",
+		"@neondatabase/serverless"
+	])) candidates.add("postgres");
+	if (hasAnyDependency(dependencies, ["mysql2", "@planetscale/database"])) candidates.add("mysql");
+	if (hasAnyDependency(dependencies, ["better-sqlite3", "sqlite3"])) candidates.add("sqlite");
+	return candidates.size === 1 ? Array.from(candidates)[0] : null;
+}
+function findExistingPath(root, relativePaths) {
+	for (const relativePath of relativePaths) {
+		const absolutePath = node_path.default.join(root, relativePath);
+		if ((0, node_fs.existsSync)(absolutePath)) return absolutePath;
+	}
+	return null;
+}
+function getPackageDependencyNames(packageManifest) {
+	return /* @__PURE__ */ new Set([
+		...Object.keys(packageManifest?.dependencies || {}),
+		...Object.keys(packageManifest?.devDependencies || {}),
+		...Object.keys(packageManifest?.peerDependencies || {}),
+		...Object.keys(packageManifest?.optionalDependencies || {})
+	]);
+}
+function hasAnyDependency(dependencies, candidates) {
+	return candidates.some((candidate) => dependencies.has(candidate));
+}
+function collectSchemaModels(schemaEntries) {
+	const collectedModels = [];
+	const seenModelNames = /* @__PURE__ */ new Map();
+	for (const [integrationKey, schema] of schemaEntries) {
+		const resolvedModels = resolveSchemaModels(integrationKey, schema);
+		for (const [modelKey, model] of Object.entries(resolvedModels)) {
+			const collisionKey = model.name.toLowerCase();
+			const previousOwner = seenModelNames.get(collisionKey);
+			if (previousOwner && previousOwner !== `${integrationKey}.${modelKey}`) throw new Error(`Integration schema model "${integrationKey}.${modelKey}" resolves to "${model.name}", which conflicts with "${previousOwner}". Rename one of the models with schema.models.<model>.name.`);
+			seenModelNames.set(collisionKey, `${integrationKey}.${modelKey}`);
+			collectedModels.push({
+				integrationKey,
+				modelKey,
+				modelName: model.name,
+				exportName: toCamelCase(`${integrationKey}_${modelKey}`),
+				prismaModelName: toPascalCase(`${integrationKey}_${modelKey}`),
+				model
+			});
+		}
+	}
+	return collectedModels;
+}
+function resolveSchemaModels(integrationKey, schema) {
+	const models = Object.fromEntries(Object.entries(schema.models).map(([modelKey, model]) => [modelKey, cloneSchemaModel(model)]));
+	for (const [modelKey, extension] of Object.entries(schema.extend || {})) {
+		const existing = models[modelKey];
+		models[modelKey] = {
+			...existing || { fields: {} },
+			...extension.name ? { name: extension.name } : {},
+			...extension.description ? { description: extension.description } : {},
+			fields: {
+				...existing?.fields,
+				...extension.fields
+			},
+			constraints: [...existing?.constraints || [], ...extension.constraints || []],
+			meta: {
+				...existing?.meta,
+				...extension.meta
+			}
+		};
+	}
+	for (const [modelKey, override] of Object.entries(schema.override || {})) {
+		const existing = models[modelKey];
+		if (!existing) throw new Error(`Integration schema override for "${integrationKey}.${modelKey}" is invalid because that model does not exist.`);
+		const fields = { ...existing.fields };
+		for (const [fieldKey, fieldOverride] of Object.entries(override.fields || {})) {
+			const existingField = fields[fieldKey];
+			if (!existingField && !fieldOverride.type) throw new Error(`Integration schema override for "${integrationKey}.${modelKey}.${fieldKey}" is missing a field type.`);
+			fields[fieldKey] = {
+				...existingField,
+				...fieldOverride
+			};
+		}
+		models[modelKey] = {
+			...existing,
+			...override.name ? { name: override.name } : {},
+			...override.description ? { description: override.description } : {},
+			fields,
+			constraints: override.constraints || existing.constraints,
+			meta: {
+				...existing.meta,
+				...override.meta
+			}
+		};
+	}
+	const resolvedModels = {};
+	for (const [modelKey, model] of Object.entries(models)) {
+		const modelName = model.name || toSnakeCase(`${integrationKey}_${modelKey}`);
+		const fieldNames = /* @__PURE__ */ new Set();
+		const resolvedFields = {};
+		for (const [fieldKey, field] of Object.entries(model.fields)) {
+			const fieldName = field.name || toSnakeCase(fieldKey);
+			if (fieldNames.has(fieldName)) throw new Error(`Integration schema model "${integrationKey}.${modelKey}" contains duplicate field name "${fieldName}".`);
+			fieldNames.add(fieldName);
+			resolvedFields[fieldKey] = {
+				...field,
+				name: fieldName
+			};
+		}
+		resolvedModels[modelKey] = {
+			...model,
+			name: modelName,
+			fields: resolvedFields
+		};
+	}
+	return resolvedModels;
+}
+function cloneSchemaModel(model) {
+	return {
+		...model,
+		fields: Object.fromEntries(Object.entries(model.fields).map(([fieldKey, field]) => [fieldKey, { ...field }])),
+		constraints: model.constraints ? [...model.constraints] : void 0,
+		meta: model.meta ? { ...model.meta } : void 0
+	};
+}
+async function writePrismaSchema(schemaPath, models) {
+	const source = await (0, node_fs_promises.readFile)(schemaPath, "utf8");
+	const generated = createPrismaGeneratedBlock(generatePrismaSchema(models));
+	const pattern = new RegExp(`${escapeRegExp(PRISMA_GENERATED_START)}[\\s\\S]*?${escapeRegExp(PRISMA_GENERATED_END)}`, "m");
+	await (0, node_fs_promises.writeFile)(schemaPath, pattern.test(source) ? source.replace(pattern, generated) : `${source.trimEnd()}\n\n${generated}\n`, "utf8");
+}
+function generatePrismaSchema(models) {
+	return models.map((model) => renderPrismaModel(model)).join("\n\n");
+}
+function renderPrismaModel(model) {
+	const lines = [`/// Farm.js generated from integration "${model.integrationKey}" model "${model.modelKey}"`, `model ${model.prismaModelName} {`];
+	const modelLevelConstraints = [];
+	for (const [fieldKey, field] of Object.entries(model.model.fields)) {
+		if (field.reference) lines.push(`  /// References ${field.reference.model}.${field.reference.field}${field.reference.onDelete ? ` (onDelete: ${field.reference.onDelete})` : ""}`);
+		const parts = [fieldKey, `${getPrismaFieldType(field)}${field.list ? "[]" : isNullableField(field) ? "?" : ""}`];
+		const attributes = [];
+		if (field.primaryKey) {
+			attributes.push("@id");
+			if (field.type === "id" && field.default === void 0) attributes.push("@default(cuid())");
+			if (field.type === "uuid" && field.default === void 0) attributes.push("@default(uuid())");
+		} else if (field.unique) attributes.push("@unique");
+		const defaultAttribute = getPrismaDefaultAttribute(field);
+		if (defaultAttribute) attributes.push(defaultAttribute);
+		if (field.meta?.autoUpdate && field.type === "datetime") attributes.push("@updatedAt");
+		if (field.name !== fieldKey) attributes.push(`@map("${escapeString(field.name)}")`);
+		if (attributes.length) parts.push(attributes.join(" "));
+		lines.push(`  ${parts.join(" ")}`);
+		if (field.index) modelLevelConstraints.push(`@@index([${fieldKey}], map: "${escapeString(`${model.modelName}_${field.name}_idx`)}")`);
+	}
+	for (const constraint of model.model.constraints || []) {
+		const fields = constraint.fields.join(", ");
+		const attribute = constraint.type === "unique" ? "@@unique" : "@@index";
+		const suffix = constraint.name ? `, map: "${escapeString(constraint.name)}"` : "";
+		modelLevelConstraints.push(`${attribute}([${fields}]${suffix})`);
+	}
+	lines.push(`  @@map("${escapeString(model.modelName)}")`);
+	for (const constraint of modelLevelConstraints) lines.push(`  ${constraint}`);
+	lines.push("}");
+	return lines.join("\n");
+}
+function getPrismaFieldType(field) {
+	switch (field.type) {
+		case "boolean": return "Boolean";
+		case "integer": return "Int";
+		case "number": return "Float";
+		case "datetime": return "DateTime";
+		case "json": return "Json";
+		default: return "String";
+	}
+}
+function getPrismaDefaultAttribute(field) {
+	if (field.default === void 0) return null;
+	if (field.type === "datetime" && field.default === "now") return "@default(now())";
+	if (typeof field.default === "string") return `@default("${escapeString(field.default)}")`;
+	if (typeof field.default === "number" || typeof field.default === "boolean") return `@default(${String(field.default)})`;
+	return null;
+}
+function createPrismaGeneratedBlock(body) {
+	return [
+		PRISMA_GENERATED_START,
+		body,
+		PRISMA_GENERATED_END
+	].join("\n");
+}
+function generateDrizzleSchema(models, dialect) {
+	const tableFactoryName = dialect === "postgres" ? "pgTable" : dialect === "mysql" ? "mysqlTable" : "sqliteTable";
+	const importSource = dialect === "postgres" ? "drizzle-orm/pg-core" : dialect === "mysql" ? "drizzle-orm/mysql-core" : "drizzle-orm/sqlite-core";
+	const imports = /* @__PURE__ */ new Set([
+		tableFactoryName,
+		"index",
+		"uniqueIndex"
+	]);
+	for (const model of models) for (const field of Object.values(model.model.fields)) for (const helper of getDrizzleImportNames(dialect, field)) imports.add(helper);
+	const lines = [
+		"// Generated by Farm.js CLI. Review before committing.",
+		`import { ${Array.from(imports).sort().join(", ")} } from "${importSource}";`,
+		""
+	];
+	for (const model of models) {
+		lines.push(renderDrizzleModel(model, dialect, tableFactoryName));
+		lines.push("");
+	}
+	return lines.join("\n").trimEnd() + "\n";
+}
+function renderDrizzleModel(model, dialect, tableFactoryName) {
+	const lines = [`// Farm.js generated from integration "${model.integrationKey}" model "${model.modelKey}"`, `export const ${model.exportName} = ${tableFactoryName}("${model.modelName}", {`];
+	for (const [fieldKey, field] of Object.entries(model.model.fields)) {
+		if (field.reference) lines.push(`  // ${fieldKey} references ${field.reference.model}.${field.reference.field}${field.reference.onDelete ? ` (onDelete: ${field.reference.onDelete})` : ""}`);
+		lines.push(`  ${fieldKey}: ${renderDrizzleColumn(field, dialect)},`);
+	}
+	lines.push("}, (table) => ({");
+	for (const [fieldKey, field] of Object.entries(model.model.fields)) if (field.index) lines.push(`  ${fieldKey}Idx: index("${escapeString(`${model.modelName}_${field.name}_idx`)}").on(table.${fieldKey}),`);
+	for (const constraint of model.model.constraints || []) {
+		const builder = constraint.type === "unique" ? "uniqueIndex" : "index";
+		const accessor = constraint.fields.map((fieldKey) => `table.${fieldKey}`).join(", ");
+		const name = constraint.name || `${model.modelName}_${constraint.fields.map((fieldKey) => model.model.fields[fieldKey]?.name || fieldKey).join("_")}_${constraint.type}`;
+		lines.push(`  ${toCamelCase(name)}: ${builder}("${escapeString(name)}").on(${accessor}),`);
+	}
+	lines.push("}));");
+	return lines.join("\n");
+}
+function getDrizzleImportNames(dialect, field) {
+	switch (dialect) {
+		case "postgres": switch (field.type) {
+			case "boolean": return ["boolean"];
+			case "integer": return ["integer"];
+			case "number": return ["real"];
+			case "datetime": return ["timestamp"];
+			case "json": return ["jsonb"];
+			default: return ["text"];
+		}
+		case "mysql": switch (field.type) {
+			case "boolean": return ["boolean"];
+			case "integer": return ["int"];
+			case "number": return ["double"];
+			case "datetime": return ["datetime"];
+			case "json": return ["json"];
+			case "text": return ["text"];
+			default: return ["varchar"];
+		}
+		case "sqlite": switch (field.type) {
+			case "number": return ["real"];
+			case "integer":
+			case "boolean":
+			case "datetime": return ["integer"];
+			default: return ["text"];
+		}
+	}
+}
+function renderDrizzleColumn(field, dialect) {
+	let expression;
+	if (dialect === "postgres") expression = renderPostgresDrizzleColumn(field);
+	else if (dialect === "mysql") expression = renderMysqlDrizzleColumn(field);
+	else expression = renderSqliteDrizzleColumn(field);
+	if (field.primaryKey) expression += ".primaryKey()";
+	if (!field.primaryKey && !isNullableField(field)) expression += ".notNull()";
+	if (!field.primaryKey && field.unique) expression += ".unique()";
+	const defaultValue = getDrizzleDefaultExpression(field, dialect);
+	if (defaultValue) expression += defaultValue;
+	return expression;
+}
+function renderPostgresDrizzleColumn(field) {
+	switch (field.type) {
+		case "boolean": return `boolean("${field.name}")`;
+		case "integer": return `integer("${field.name}")`;
+		case "number": return `real("${field.name}")`;
+		case "datetime": return `timestamp("${field.name}", { mode: "date" })`;
+		case "json": return `jsonb("${field.name}")`;
+		default: return `text("${field.name}")`;
+	}
+}
+function renderMysqlDrizzleColumn(field) {
+	switch (field.type) {
+		case "boolean": return `boolean("${field.name}")`;
+		case "integer": return `int("${field.name}")`;
+		case "number": return `double("${field.name}")`;
+		case "datetime": return `datetime("${field.name}", { mode: "date" })`;
+		case "json": return `json("${field.name}")`;
+		case "text": return `text("${field.name}")`;
+		default: return `varchar("${field.name}", { length: 255 })`;
+	}
+}
+function renderSqliteDrizzleColumn(field) {
+	switch (field.type) {
+		case "boolean": return `integer("${field.name}", { mode: "boolean" })`;
+		case "integer": return `integer("${field.name}")`;
+		case "number": return `real("${field.name}")`;
+		case "datetime": return `integer("${field.name}", { mode: "timestamp_ms" })`;
+		default: return `text("${field.name}")`;
+	}
+}
+function getDrizzleDefaultExpression(field, dialect) {
+	if (field.default === void 0) return "";
+	if (field.type === "datetime" && field.default === "now") return dialect === "sqlite" ? "" : ".defaultNow()";
+	if (typeof field.default === "string") return `.default("${escapeString(field.default)}")`;
+	if (typeof field.default === "number" || typeof field.default === "boolean") return `.default(${String(field.default)})`;
+	return "";
+}
+function generateSqlSchema(models, dialect) {
+	const lines = ["-- Generated by Farm.js CLI. Review before applying.", ""];
+	const modelLookup = createModelLookup(models);
+	for (const model of models) {
+		lines.push(`-- Integration "${model.integrationKey}" model "${model.modelKey}"`, renderSqlTable(model, dialect, modelLookup), "");
+		for (const statement of renderSqlIndexes(model, dialect)) lines.push(statement, "");
+	}
+	return lines.join("\n").trimEnd() + "\n";
+}
+function renderSqlTable(model, dialect, modelLookup) {
+	const lines = [`CREATE TABLE IF NOT EXISTS ${quoteIdentifier(dialect, model.modelName)} (`];
+	const columns = [];
+	const internalReferences = createInternalReferenceLookup(model, dialect, modelLookup);
+	for (const [fieldKey, field] of Object.entries(model.model.fields)) {
+		const parts = [`  ${quoteIdentifier(dialect, field.name)}`, getSqlColumnType(field, dialect)];
+		if (field.primaryKey) parts.push("PRIMARY KEY");
+		else if (!isNullableField(field)) parts.push("NOT NULL");
+		if (!field.primaryKey && field.unique) parts.push("UNIQUE");
+		const defaultValue = getSqlDefaultExpression(field, dialect);
+		if (defaultValue) parts.push(`DEFAULT ${defaultValue}`);
+		const reference = internalReferences.get(fieldKey);
+		if (reference) parts.push(reference);
+		else if (field.reference) parts.push(`/* references ${field.reference.model}.${field.reference.field}${field.reference.onDelete ? ` on delete ${field.reference.onDelete}` : ""} */`);
+		columns.push(parts.join(" "));
+	}
+	lines.push(columns.join(",\n"));
+	lines.push(");");
+	return lines.join("\n");
+}
+function renderSqlIndexes(model, dialect) {
+	const statements = [];
+	const tableName = quoteIdentifier(dialect, model.modelName);
+	for (const [fieldKey, field] of Object.entries(model.model.fields)) {
+		if (!field.index) continue;
+		const indexName = `${model.modelName}_${field.name}_idx`;
+		statements.push(`CREATE INDEX IF NOT EXISTS ${quoteIdentifier(dialect, indexName)} ON ${tableName} (${quoteIdentifier(dialect, field.name)});`);
+	}
+	for (const constraint of model.model.constraints || []) {
+		const indexName = constraint.name || `${model.modelName}_${constraint.fields.map((fieldKey) => model.model.fields[fieldKey]?.name || fieldKey).join("_")}_${constraint.type}`;
+		const fields = constraint.fields.map((fieldKey) => quoteIdentifier(dialect, model.model.fields[fieldKey]?.name || fieldKey)).join(", ");
+		if (constraint.type === "unique") statements.push(`CREATE UNIQUE INDEX IF NOT EXISTS ${quoteIdentifier(dialect, indexName)} ON ${tableName} (${fields});`);
+		else statements.push(`CREATE INDEX IF NOT EXISTS ${quoteIdentifier(dialect, indexName)} ON ${tableName} (${fields});`);
+	}
+	return statements;
+}
+function createInternalReferenceLookup(model, dialect, modelLookup) {
+	const lookup = /* @__PURE__ */ new Map();
+	for (const [fieldKey, field] of Object.entries(model.model.fields)) {
+		if (!field.reference) continue;
+		const referencedModel = modelLookup.get(`${model.integrationKey}.${field.reference.model}`);
+		if (referencedModel) {
+			const referencedField = field.reference.field;
+			const pieces = [`REFERENCES ${quoteIdentifier(dialect, referencedModel.modelName)} (${quoteIdentifier(dialect, referencedModel.model.fields[referencedField]?.name || toSnakeCase(referencedField))})`];
+			if (field.reference.onDelete) pieces.push(`ON DELETE ${field.reference.onDelete.toUpperCase()}`);
+			lookup.set(fieldKey, pieces.join(" "));
+		}
+	}
+	return lookup;
+}
+function getSqlColumnType(field, dialect) {
+	if (dialect === "postgres") switch (field.type) {
+		case "boolean": return "BOOLEAN";
+		case "integer": return "INTEGER";
+		case "number": return "DOUBLE PRECISION";
+		case "datetime": return "TIMESTAMPTZ";
+		case "json": return "JSONB";
+		default: return "TEXT";
+	}
+	if (dialect === "mysql") switch (field.type) {
+		case "boolean": return "BOOLEAN";
+		case "integer": return "INT";
+		case "number": return "DOUBLE";
+		case "datetime": return "DATETIME";
+		case "json": return "JSON";
+		case "text": return "TEXT";
+		default: return "VARCHAR(255)";
+	}
+	switch (field.type) {
+		case "boolean":
+		case "integer": return "INTEGER";
+		case "number": return "REAL";
+		default: return "TEXT";
+	}
+}
+function getSqlDefaultExpression(field, dialect) {
+	if (field.default === void 0) return null;
+	if (field.type === "datetime" && field.default === "now") return "CURRENT_TIMESTAMP";
+	if (typeof field.default === "string") return `'${escapeString(field.default)}'`;
+	if (typeof field.default === "number") return String(field.default);
+	if (typeof field.default === "boolean") {
+		if (dialect === "sqlite") return field.default ? "1" : "0";
+		return field.default ? "TRUE" : "FALSE";
+	}
+	return null;
+}
+function generateMongoBootstrap(models) {
+	const lines = [
+		"// Generated by Farm.js CLI. Review before committing.",
+		"import type { Db } from \"mongodb\";",
+		"",
+		"export async function ensureFarmIntegrationCollections(db: Db) {"
+	];
+	for (const model of models) {
+		lines.push(`  // Integration "${model.integrationKey}" model "${model.modelKey}"`);
+		lines.push(`  const ${model.exportName} = db.collection("${escapeString(model.modelName)}");`);
+		for (const [fieldKey, field] of Object.entries(model.model.fields)) {
+			if (field.unique) {
+				const options = ["unique: true"];
+				if (isNullableField(field)) options.push("sparse: true");
+				options.push(`name: "${escapeString(`${model.modelName}_${field.name}_unique`)}"`);
+				lines.push(`  await ${model.exportName}.createIndex({ ${JSON.stringify(field.name)}: 1 }, { ${options.join(", ")} });`);
+			} else if (field.index) lines.push(`  await ${model.exportName}.createIndex({ ${JSON.stringify(field.name)}: 1 }, { name: "${escapeString(`${model.modelName}_${field.name}_idx`)}" });`);
+			if (field.reference) lines.push(`  // ${fieldKey} references ${field.reference.model}.${field.reference.field}${field.reference.onDelete ? ` (onDelete: ${field.reference.onDelete})` : ""}`);
+		}
+		for (const constraint of model.model.constraints || []) {
+			const indexSpec = constraint.fields.map((fieldKey) => `${JSON.stringify(model.model.fields[fieldKey]?.name || fieldKey)}: 1`).join(", ");
+			const indexName = constraint.name || `${model.modelName}_${constraint.fields.map((fieldKey) => model.model.fields[fieldKey]?.name || fieldKey).join("_")}_${constraint.type}`;
+			const options = constraint.type === "unique" ? `{ unique: true, name: "${escapeString(indexName)}" }` : `{ name: "${escapeString(indexName)}" }`;
+			lines.push(`  await ${model.exportName}.createIndex({ ${indexSpec} }, ${options});`);
+		}
+		lines.push("");
+	}
+	lines.push("}");
+	return lines.join("\n").trimEnd() + "\n";
+}
+async function writeGeneratedFile(filePath, contents) {
+	await (0, node_fs_promises.mkdir)(node_path.default.dirname(filePath), { recursive: true });
+	await (0, node_fs_promises.writeFile)(filePath, contents, "utf8");
+}
+function isNullableField(field) {
+	return field.nullable === true || field.required === false;
+}
+function quoteIdentifier(dialect, value) {
+	if (dialect === "mysql") return `\`${value.replace(/`/g, "``")}\``;
+	return `"${value.replace(/"/g, "\"\"")}"`;
+}
+function createModelLookup(models) {
+	return new Map(models.map((model) => [`${model.integrationKey}.${model.modelKey}`, model]));
+}
+function toSnakeCase(value) {
+	return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s.-]+/g, "_").replace(/__+/g, "_").toLowerCase();
+}
+function toPascalCase(value) {
+	return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[\s._-]+/g, " ").split(" ").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function toCamelCase(value) {
+	const pascal = toPascalCase(value);
+	return pascal ? pascal.charAt(0).toLowerCase() + pascal.slice(1) : pascal;
+}
+function escapeString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/'/g, "''");
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/doctor.ts
+const ROUTE_EXTENSIONS = [
+	"ts",
+	"tsx",
+	"js",
+	"jsx",
+	"md",
+	"mdx"
+];
+const CONFIG_FILES = [
+	"farm.config.ts",
+	"farm.config.mts",
+	"farm.config.js",
+	"farm.config.mjs",
+	"config.ts",
+	"config.mts",
+	"config.js",
+	"config.mjs"
+];
+async function runFarmDoctor(options = {}) {
+	const root = node_path.default.resolve(options.root || process.cwd());
+	const liveTarget = resolveLiveTarget(options);
+	let liveError;
+	if (!options.offline) try {
+		return createLiveReport(await fetchLiveSnapshot(liveTarget, options), liveTarget, options.now);
+	} catch (error) {
+		liveError = formatError$1(error);
+	}
+	const report = await createProjectReport(root, options);
+	if (!options.offline && hasExplicitLiveTarget(options) && liveError) {
+		report.checks.unshift({
+			status: "warn",
+			code: "LIVE_RUNTIME_UNREACHABLE",
+			title: "Running app was not reachable",
+			message: liveError,
+			action: `Start farm dev or verify ${liveTarget}.`
+		});
+		report.target = {
+			...report.target,
+			url: liveTarget
+		};
+		finalizeReport(report);
+	}
+	return report;
+}
+function formatFarmDoctorReport(report, options = {}) {
+	const color = options.color === void 0 ? picocolors.default : picocolors.default.createColors(options.color);
+	const statusStyle = {
+		pass: color.inverse,
+		warn: color.yellow,
+		fail: color.red,
+		info: color.cyan
+	};
+	const lines = [
+		`${color.bold("FARM")} ${color.dim("/")} ${color.bold("DOCTOR")}`,
+		`${color.white(report.project.name)} ${color.dim("/")} ${color.dim(report.source === "live" ? "LIVE RUNTIME" : "PROJECT")}`,
+		""
+	];
+	for (const check of report.checks) {
+		const label = check.status.toUpperCase().padEnd(4);
+		lines.push(`${statusStyle[check.status](label)}  ${color.bold(check.title)}`);
+		lines.push(`      ${color.dim(check.message)}`);
+		if (check.action) lines.push(`      ${color.dim(`Next: ${check.action}`)}`);
+	}
+	const summary = [
+		`${report.summary.pass} passed`,
+		`${report.summary.warn} warning${report.summary.warn === 1 ? "" : "s"}`,
+		`${report.summary.fail} failed`,
+		`${report.summary.info} info`
+	].join(" / ");
+	lines.push("", `${color.bold("SUMMARY")}  ${summary}`);
+	if (report.target?.devtoolsUrl) lines.push(`${color.bold("DEVTOOLS")} ${report.target.devtoolsUrl}`);
+	return lines.join("\n");
+}
+async function fetchLiveSnapshot(baseUrl, options) {
+	const controller = new AbortController();
+	const timeoutMs = options.timeoutMs ?? 1200;
+	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+	timeout.unref?.();
+	try {
+		const response = await (options.fetch || globalThis.fetch)(`${baseUrl}/__farm/devtools.json`, {
+			headers: { accept: "application/json" },
+			signal: controller.signal
+		});
+		if (!response.ok) throw new Error(`Devtools returned ${response.status} from ${baseUrl}.`);
+		const value = await response.json();
+		if (!isLiveSnapshot(value)) throw new Error(`Devtools at ${baseUrl} returned an unsupported snapshot.`);
+		return value;
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") throw new Error(`Timed out after ${timeoutMs}ms while probing ${baseUrl}.`);
+		if (error instanceof TypeError) throw new Error(`Could not connect to ${baseUrl}.`);
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+function createLiveReport(snapshot, baseUrl, now) {
+	const checks = [
+		{
+			status: "pass",
+			code: "LIVE_RUNTIME_READY",
+			title: "Connected to the Farm runtime",
+			message: `${formatCount$1(snapshot.counts.pages, "page")}, ${formatCount$1(snapshot.counts.apiRoutes, "API route")}, and ${formatCount$1(snapshot.counts.middleware, "middleware layer")} are registered.`
+		},
+		{
+			status: "pass",
+			code: "DEPLOYMENT_RESOLVED",
+			title: "Deployment target is resolved",
+			message: `${snapshot.deployment.target} uses the ${snapshot.deployment.preset} preset.`
+		},
+		{
+			status: "info",
+			code: "PRODUCT_SYSTEMS_DISCOVERED",
+			title: "Product systems are visible",
+			message: `${formatCount$1(snapshot.counts.integrations, "integration")}, ${formatCount$1(snapshot.counts.storageMounts, "storage mount")}, ${formatCount$1(snapshot.counts.cronJobs, "cron route")}, and ${formatCount$1(snapshot.counts.workflows, "workflow")}.`
+		},
+		...snapshot.diagnostics.map((diagnostic) => ({
+			status: diagnostic.severity === "error" ? "fail" : diagnostic.severity === "warning" ? "warn" : "info",
+			code: diagnostic.code,
+			title: diagnostic.title,
+			message: diagnostic.message,
+			...diagnostic.action ? { action: diagnostic.action } : {}
+		}))
+	];
+	const report = {
+		generatedAt: snapshot.generatedAt || (now?.() || /* @__PURE__ */ new Date()).toISOString(),
+		source: "live",
+		health: "ready",
+		project: snapshot.project,
+		target: {
+			url: baseUrl,
+			devtoolsUrl: `${baseUrl}/__farm/devtools`,
+			deployment: snapshot.deployment.target,
+			preset: snapshot.deployment.preset
+		},
+		runtime: { ...snapshot.counts },
+		summary: emptySummary(),
+		checks
+	};
+	finalizeReport(report);
+	return report;
+}
+async function createProjectReport(root, options) {
+	const checks = [];
+	const report = {
+		generatedAt: (options.now?.() || /* @__PURE__ */ new Date()).toISOString(),
+		source: "project",
+		health: "ready",
+		project: {
+			name: node_path.default.basename(root),
+			root
+		},
+		summary: emptySummary(),
+		checks
+	};
+	collectNodeCheck(checks);
+	collectPackageCheck(root, checks);
+	let config;
+	let userConfig;
+	try {
+		userConfig = await (0, _farm_js_core.loadConfig)(root, options.configPath, "development");
+		if (!userConfig) checks.push({
+			status: "fail",
+			code: "CONFIG_MISSING",
+			title: "Farm config was not found",
+			message: `No Farm config exists under ${root}.`,
+			action: "Add farm.config.ts and export defineConfig({...})."
+		});
+		else {
+			config = await (0, _farm_js_core.resolveConfig)({
+				root,
+				...userConfig
+			}, "development");
+			const configFile = findConfigFile(root, options.configPath);
+			checks.push({
+				status: "pass",
+				code: "CONFIG_VALID",
+				title: "Farm config loads successfully",
+				message: configFile ? node_path.default.relative(root, configFile) || node_path.default.basename(configFile) : "Resolved config"
+			});
+		}
+	} catch (error) {
+		checks.push({
+			status: "fail",
+			code: "CONFIG_INVALID",
+			title: "Farm config could not be resolved",
+			message: formatError$1(error),
+			action: "Fix the config or environment validation error, then run farm doctor again."
+		});
+	}
+	if (config && userConfig) {
+		collectRouterChecks(config, checks);
+		report.target = collectDeploymentChecks(config, userConfig, checks);
+		collectCronChecks(config, options.env || process.env, checks);
+	}
+	finalizeReport(report);
+	return report;
+}
+function collectNodeCheck(checks) {
+	const major = Number(process.versions.node.split(".")[0]);
+	checks.push(major >= 18 ? {
+		status: "pass",
+		code: "NODE_SUPPORTED",
+		title: "Node.js is supported",
+		message: `Node ${process.versions.node} satisfies Farm's Node 18+ baseline.`
+	} : {
+		status: "fail",
+		code: "NODE_UNSUPPORTED",
+		title: "Node.js is too old",
+		message: `Node ${process.versions.node} does not satisfy Farm's Node 18+ baseline.`,
+		action: "Upgrade Node.js to version 18 or newer."
+	});
+}
+function collectPackageCheck(root, checks) {
+	const packagePath = node_path.default.join(root, "package.json");
+	if (!(0, node_fs.existsSync)(packagePath)) {
+		checks.push({
+			status: "fail",
+			code: "PACKAGE_MISSING",
+			title: "package.json was not found",
+			message: `No package manifest exists under ${root}.`,
+			action: "Run the command from a Farm application root."
+		});
+		return;
+	}
+	try {
+		const manifest = JSON.parse((0, node_fs.readFileSync)(packagePath, "utf8"));
+		const version = {
+			...asRecord(manifest.dependencies),
+			...asRecord(manifest.devDependencies),
+			...asRecord(manifest.peerDependencies)
+		}["@farm.js/core"];
+		checks.push(typeof version === "string" ? {
+			status: "pass",
+			code: "CORE_INSTALLED",
+			title: "Farm core is installed",
+			message: `@farm.js/core ${version}`
+		} : {
+			status: "fail",
+			code: "CORE_MISSING",
+			title: "Farm core is not declared",
+			message: "@farm.js/core is missing from package.json.",
+			action: "Install @farm.js/core and add it to the application dependencies."
+		});
+	} catch (error) {
+		checks.push({
+			status: "fail",
+			code: "PACKAGE_INVALID",
+			title: "package.json is invalid",
+			message: formatError$1(error),
+			action: "Fix the package manifest JSON."
+		});
+	}
+}
+function collectRouterChecks(config, checks) {
+	const sources = (0, _farm_js_core.getFarmSourceRoots)(config);
+	const appDirectories = sources.map((source) => node_path.default.join(source.root, source.srcDir, "app"));
+	const hasPages = appDirectories.some((directory) => containsFile(directory, /^page\.(?:ts|tsx|js|jsx|md|mdx)$/));
+	const hasProgrammaticRoutes = sources.some((source) => ROUTE_EXTENSIONS.some((extension) => (0, node_fs.existsSync)(node_path.default.join(source.root, source.srcDir, `farm.routes.${extension}`))));
+	checks.push(hasPages || hasProgrammaticRoutes ? {
+		status: "pass",
+		code: "APP_ROUTER_READY",
+		title: "App router has route modules",
+		message: `${config.srcDir}/app and extended layers are discoverable.`
+	} : {
+		status: "fail",
+		code: "NO_PAGE_ROUTES",
+		title: "No page routes were found",
+		message: `Farm found no page modules under ${config.srcDir}/app.`,
+		action: `Add ${config.srcDir}/app/page.tsx or ${config.srcDir}/farm.routes.tsx.`
+	});
+	const hasRootLayout = appDirectories.some((directory) => ROUTE_EXTENSIONS.some((extension) => (0, node_fs.existsSync)(node_path.default.join(directory, `layout.${extension}`))));
+	checks.push(hasRootLayout ? {
+		status: "pass",
+		code: "ROOT_LAYOUT_READY",
+		title: "Root layout is present",
+		message: "Shared metadata and application chrome have a root boundary."
+	} : {
+		status: "warn",
+		code: "ROOT_LAYOUT_MISSING",
+		title: "Root layout is missing",
+		message: "The application has no shared root layout.",
+		action: `Add ${config.srcDir}/app/layout.tsx.`
+	});
+}
+function collectDeploymentChecks(config, userConfig, checks) {
+	const target = String(config.deploy.target || "node");
+	const preset = String(config.deploy.preset || config.preset || "node-server");
+	checks.push({
+		status: "pass",
+		code: "DEPLOYMENT_RESOLVED",
+		title: "Deployment target is resolved",
+		message: `${target} uses the ${preset} preset and writes to ${config.deploy.outputDir}.`
+	});
+	const integrations = Object.values(config.integrations || {}).filter(Boolean).length;
+	const storageMounts = getStorageMountCount(config.storage);
+	checks.push({
+		status: "info",
+		code: "PRODUCT_SYSTEMS_DISCOVERED",
+		title: "Product systems are configured",
+		message: `${formatCount$1(integrations, "integration")} and ${formatCount$1(storageMounts, "storage mount")}.`
+	});
+	if (userConfig.storage && describeRootStorageDriver(userConfig.storage) === "memory" && [
+		"vercel",
+		"cloudflare",
+		"netlify"
+	].includes(target)) checks.push({
+		status: "warn",
+		code: "EPHEMERAL_PRODUCTION_STORAGE",
+		title: "Production storage is in memory",
+		message: `${target} instances do not preserve in-memory data across executions.`,
+		action: "Configure a durable root storage driver for production state."
+	});
+	return {
+		deployment: target,
+		preset
+	};
+}
+function collectCronChecks(config, env, checks) {
+	const cron = config.cron;
+	if (!cron.jobs.length) return;
+	const missingRoutes = cron.jobs.filter((job) => !hasCronRoute(config, job));
+	for (const job of missingRoutes) checks.push({
+		status: "warn",
+		code: "CRON_ROUTE_MISSING",
+		title: `Cron route ${job.path} was not found`,
+		message: `${job.name} is scheduled, but its GET API route is not present in the app directory.`,
+		action: "Add the target API route or update the cron path in farm.config.ts."
+	});
+	if (!env[cron.secretEnv]) checks.push({
+		status: "info",
+		code: "CRON_SECRET_NOT_SET",
+		title: `${cron.secretEnv} is not set`,
+		message: "Local manual runs remain available, but production cron routes fail closed.",
+		action: `Set ${cron.secretEnv} in the deployment environment before production.`
+	});
+}
+function hasCronRoute(config, job) {
+	const relative = job.path.replace(/^\/+/, "").replace(/^api\//, "");
+	return (0, _farm_js_core.getFarmSourceRoots)(config).some((source) => {
+		const directory = node_path.default.join(source.root, source.srcDir, "app", "api", relative);
+		return ROUTE_EXTENSIONS.some((extension) => (0, node_fs.existsSync)(node_path.default.join(directory, `route.${extension}`)));
+	});
+}
+function containsFile(directory, pattern) {
+	if (!(0, node_fs.existsSync)(directory)) return false;
+	const pending = [directory];
+	while (pending.length) {
+		const current = pending.pop();
+		if (!current) continue;
+		for (const entry of (0, node_fs.readdirSync)(current, { withFileTypes: true })) {
+			if (entry.isFile() && pattern.test(entry.name)) return true;
+			if (entry.isDirectory() && !entry.name.startsWith(".")) pending.push(node_path.default.join(current, entry.name));
+		}
+	}
+	return false;
+}
+function getStorageMountCount(storage) {
+	if (!storage || typeof storage !== "object") return 1;
+	const mounts = asRecord(storage.mounts);
+	return 1 + Object.keys(mounts).length;
+}
+function describeRootStorageDriver(storage) {
+	if (!storage || typeof storage !== "object") return "memory";
+	const value = storage;
+	if (value.kind === "farm-storage-client") return "storage client";
+	if (value.client) return "storage client";
+	if (typeof value.driver === "string") return value.driver;
+	if (typeof value.driver === "function") return "custom";
+	return "memory";
+}
+function findConfigFile(root, configPath) {
+	return (configPath ? [configPath, ...CONFIG_FILES] : CONFIG_FILES).map((candidate) => node_path.default.isAbsolute(candidate) ? candidate : node_path.default.join(root, candidate)).find(node_fs.existsSync);
+}
+function resolveLiveTarget(options) {
+	return (options.url || `http://${options.host || "localhost"}:${options.port || 3e3}`).replace(/\/+$/, "");
+}
+function hasExplicitLiveTarget(options) {
+	return Boolean(options.url || options.host || options.port);
+}
+function isLiveSnapshot(value) {
+	if (!value || typeof value !== "object") return false;
+	const snapshot = value;
+	return Boolean(snapshot.project && typeof snapshot.project.name === "string" && snapshot.deployment && typeof snapshot.deployment.target === "string" && snapshot.counts && typeof snapshot.counts.pages === "number" && Array.isArray(snapshot.diagnostics));
+}
+function emptySummary() {
+	return {
+		pass: 0,
+		warn: 0,
+		fail: 0,
+		info: 0
+	};
+}
+function finalizeReport(report) {
+	const summary = emptySummary();
+	for (const check of report.checks) summary[check.status] += 1;
+	report.summary = summary;
+	report.health = summary.fail > 0 ? "error" : summary.warn > 0 ? "attention" : "ready";
+}
+function asRecord(value) {
+	return value && typeof value === "object" ? value : {};
+}
+function formatError$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function formatCount$1(value, noun) {
+	return `${value} ${noun}${value === 1 ? "" : "s"}`;
+}
+//#endregion
+//#region src/cron.ts
+async function loadFarmCronConfig(options = {}) {
+	const root = node_path.default.resolve(options.root || process.cwd());
+	const userConfig = await (0, _farm_js_core.loadConfig)(root, options.configPath, "development");
+	if (!userConfig) throw new Error("No Farm config found. Create farm.config.ts before configuring cron routes.");
+	return (await (0, _farm_js_core.resolveConfig)({
+		root,
+		...userConfig
+	}, "development")).cron;
+}
+async function listFarmCronJobs(options = {}) {
+	return (await loadFarmCronConfig(options)).jobs;
+}
+function formatFarmCronJobs(jobs) {
+	if (jobs.length === 0) return "No cron routes configured in farm.config.ts.";
+	const rows = jobs.map((job) => [
+		job.name,
+		job.schedule.join(", "),
+		job.path,
+		job.description || ""
+	]);
+	const headings = [
+		"NAME",
+		"SCHEDULE (UTC)",
+		"ROUTE",
+		"DESCRIPTION"
+	];
+	const widths = headings.map((heading, column) => Math.max(heading.length, ...rows.map((row) => row[column].length)));
+	return [headings, ...rows].map((row) => row.map((value, column) => value.padEnd(widths[column])).join("  ").trimEnd()).join("\n");
+}
+async function runFarmCronJob(name, options = {}) {
+	const cron = await loadFarmCronConfig(options);
+	const job = cron.jobs.find((entry) => entry.name === name);
+	if (!job) {
+		const available = cron.jobs.map((entry) => entry.name).join(", ");
+		throw new Error(available ? `Cron route ${JSON.stringify(name)} was not found. Available routes: ${available}.` : `Cron route ${JSON.stringify(name)} was not found. No cron routes are configured.`);
+	}
+	return invokeFarmCronJob(job, cron, options);
+}
+async function startFarmCronScheduler(options = {}) {
+	const cron = await loadFarmCronConfig(options);
+	const entries = [];
+	for (const job of cron.jobs) for (const schedule of job.schedule) {
+		const timer = new croner.Cron(schedule, {
+			name: `farm:cron:${job.name}:${schedule}`,
+			timezone: "UTC",
+			protect: () => {
+				_farm_js_core.logger.warn(`Cron ${job.name} skipped an overlapping run.`);
+			},
+			catch: (error) => {
+				_farm_js_core.logger.error(`Cron ${job.name} failed: ${formatError(error)}`);
+			}
+		}, async () => {
+			_farm_js_core.logger.info(`Cron ${job.name} -> ${job.path}`);
+			const result = await invokeFarmCronJob(job, cron, {
+				...options,
+				trigger: "development"
+			});
+			_farm_js_core.logger.success(`Cron ${job.name} completed in ${result.durationMs}ms.`);
+		});
+		entries.push({
+			job,
+			schedule,
+			timer
+		});
+	}
+	if (entries.length === 0) _farm_js_core.logger.info("No cron routes are configured; the development scheduler is idle.");
+	else {
+		_farm_js_core.logger.info(`Development cron scheduler started with ${entries.length} UTC schedule${entries.length === 1 ? "" : "s"}.`);
+		for (const entry of entries) {
+			const nextRun = entry.timer.nextRun();
+			_farm_js_core.logger.info(`Cron ${entry.job.name} (${entry.schedule}) next runs ${nextRun?.toISOString() || "never"}.`);
+		}
+	}
+	return {
+		entries,
+		stop() {
+			for (const entry of entries) entry.timer.stop();
+		}
+	};
+}
+async function invokeFarmCronJob(job, cron, options) {
+	const target = resolveCronTarget(job, options);
+	const headers = new Headers({
+		accept: "application/json",
+		"x-farm-cron-name": job.name,
+		"x-farm-cron-trigger": options.trigger || "manual"
+	});
+	const secret = options.secret ?? process.env[cron.secretEnv];
+	if (secret) headers.set("authorization", `Bearer ${secret}`);
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 1e4);
+	timeout.unref?.();
+	const startedAt = Date.now();
+	try {
+		const response = await (options.fetch || globalThis.fetch)(target, {
+			method: "GET",
+			headers,
+			signal: controller.signal
+		});
+		const body = await readResponseBody(response);
+		const durationMs = Date.now() - startedAt;
+		if (!response.ok) throw new Error(`Cron ${job.name} received ${response.status} from ${job.path}${formatResponseDetail(body)}.`);
+		return {
+			job,
+			url: target,
+			status: response.status,
+			body,
+			durationMs
+		};
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") throw new Error(`Cron ${job.name} timed out after ${options.timeoutMs ?? 1e4}ms.`);
+		if (error instanceof TypeError) throw new Error(`Could not reach ${target}. Start the Farm dev server or pass --url to a running app.`);
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+function resolveCronTarget(job, options) {
+	const baseURL = options.url || `http://${options.host || "localhost"}:${options.port || 3e3}`;
+	const normalizedBase = baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+	return new URL(job.path.replace(/^\/+/, ""), normalizedBase).toString();
+}
+async function readResponseBody(response) {
+	if (response.status === 204) return null;
+	const text = await response.text();
+	if (!text) return null;
+	if ((response.headers.get("content-type") || "").includes("application/json")) try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+	return text;
+}
+function formatResponseDetail(body) {
+	if (body === null || body === void 0 || body === "") return "";
+	const detail = typeof body === "string" ? body : JSON.stringify(body);
+	return detail ? `: ${detail}` : "";
+}
+function formatError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/migrate.ts
+async function migrateFarm(options = {}) {
+	const root = node_path.default.resolve(options.root || process.cwd());
+	if (options.source) {
+		if (options.source === "inspect") {
+			const detections = await inspectFrameworkMigrations(root);
+			printFrameworkInspection(root, detections);
+			return detections;
+		}
+		if (!isFrameworkMigrationSource(options.source)) throw new Error(`Unsupported migration source "${options.source}". Use "inspect", "next", or "tanstack".`);
+		const plan = await createFrameworkMigrationPlan(root, options.source, { force: options.force });
+		printFrameworkMigrationPlan(plan, Boolean(options.write && !options.dryRun));
+		if (!options.write || options.dryRun) {
+			_farm_js_core.logger.info(`Dry run only. Re-run with "farm migrate ${options.source} --write" to apply.`);
+			return plan;
+		}
+		await applyFrameworkMigrationPlan(plan);
+		_farm_js_core.logger.success(`Applied ${formatOperationCount(plan.operations.filter((operation) => !operation.skipped).length)}.`);
+		return plan;
+	}
+	const cliCommands = options.commands?.filter(Boolean) || [];
+	const configuredCommands = getConfiguredCommands((await (0, _farm_js_core.loadConfig)(root, options.configPath, "development"))?.migrations);
+	const commands = (cliCommands.length ? cliCommands : configuredCommands).map((entry, index) => resolveMigrationCommand(root, entry, index)).filter((entry) => !!entry);
+	if (!commands.length) throw new Error("No migrations configured. Add migrations.commands to farm.config.ts or pass --command.");
+	if (options.dryRun) {
+		_farm_js_core.logger.info(`Found ${formatCount(commands.length)} to run:`);
+		for (const command of commands) _farm_js_core.logger.info(`  ${command.name}: ${command.command}`);
+		return;
+	}
+	for (const command of commands) {
+		_farm_js_core.logger.info(`Running ${command.name}: ${command.command}`);
+		await runMigrationCommand(command);
+	}
+	_farm_js_core.logger.success(`Ran ${formatCount(commands.length)} successfully.`);
+}
+function getConfiguredCommands(migrations) {
+	if (!migrations) return [];
+	if (Array.isArray(migrations)) return migrations;
+	return migrations.commands || [];
+}
+function resolveMigrationCommand(root, entry, index) {
+	if (typeof entry === "string") {
+		const command = entry.trim();
+		if (!command) throw new Error(`Migration command ${index + 1} is empty.`);
+		return {
+			command,
+			name: `migration ${index + 1}`,
+			cwd: root
+		};
+	}
+	if (entry.skip) return null;
+	const command = entry.command.trim();
+	if (!command) throw new Error(`Migration command ${index + 1} is empty.`);
+	return {
+		command,
+		name: entry.name || `migration ${index + 1}`,
+		cwd: entry.cwd ? node_path.default.resolve(root, entry.cwd) : root,
+		env: entry.env
+	};
+}
+function runMigrationCommand(command) {
+	return new Promise((resolve, reject) => {
+		const child = (0, node_child_process.spawn)(command.command, {
+			cwd: command.cwd,
+			env: {
+				...process.env,
+				...command.env
+			},
+			shell: true,
+			stdio: "inherit"
+		});
+		child.on("error", reject);
+		child.on("close", (code, signal) => {
+			if (code === 0) {
+				resolve();
+				return;
+			}
+			const reason = signal ? `signal ${signal}` : `exit code ${code}`;
+			reject(/* @__PURE__ */ new Error(`${command.name} failed with ${reason}.`));
+		});
+	});
+}
+function formatCount(count) {
+	return `${count} migration command${count === 1 ? "" : "s"}`;
+}
+function formatOperationCount(count) {
+	return `${count} migration operation${count === 1 ? "" : "s"}`;
+}
+function isFrameworkMigrationSource(value) {
+	return value === "next" || value === "tanstack";
+}
+async function inspectFrameworkMigrations(root) {
+	const packageJson = await readPackageJson(root);
+	return [detectNext(root, packageJson), detectTanStack(root, packageJson)].filter((entry) => entry.confidence > 0).sort((a, b) => b.confidence - a.confidence);
+}
+async function createFrameworkMigrationPlan(root, source, options = {}) {
+	const detection = (await inspectFrameworkMigrations(root)).find((entry) => entry.source === source) || {
+		source,
+		confidence: 0,
+		evidence: [`No ${source} markers detected.`]
+	};
+	const packageJson = await readPackageJson(root);
+	const plan = {
+		source,
+		root,
+		confidence: detection.confidence,
+		evidence: detection.evidence,
+		operations: [],
+		warnings: [],
+		manual: []
+	};
+	if (source === "next") await planNextMigration(root, packageJson, plan, options);
+	else await planTanStackMigration(root, packageJson, plan, options);
+	addSharedFarmFiles(root, packageJson, plan, source, options);
+	return plan;
+}
+async function planNextMigration(root, packageJson, plan, options) {
+	const rootAppDir = node_path.default.join(root, "app");
+	const srcAppDir = node_path.default.join(root, "src", "app");
+	const sourceAppDir = (0, node_fs.existsSync)(rootAppDir) ? rootAppDir : (0, node_fs.existsSync)(srcAppDir) ? srcAppDir : null;
+	if (!sourceAppDir) {
+		plan.warnings.push("No Next App Router directory found at app/ or src/app/.");
+		if ((0, node_fs.existsSync)(node_path.default.join(root, "pages"))) plan.manual.push("Pages Router files in pages/ need manual conversion to src/app/**/page.tsx.");
+		return;
+	}
+	const allFiles = await collectFiles(sourceAppDir);
+	const files = allFiles.filter(isMigratableTextFile);
+	for (const file of allFiles) if (!isMigratableTextFile(file)) plan.manual.push(`Move or review non-code app asset ${toPosix(node_path.default.relative(root, file))}.`);
+	for (const file of files) {
+		const relative = node_path.default.relative(sourceAppDir, file);
+		const target = node_path.default.join(srcAppDir, relative);
+		const transformed = transformNextContent(await (0, node_fs_promises.readFile)(file, "utf8"));
+		collectNextManualNotes(relative, transformed, plan);
+		await addWriteFileOperation(plan, {
+			root,
+			source: file,
+			target,
+			content: transformed,
+			description: sourceAppDir === srcAppDir ? `Update Next-compatible app file ${toPosix(node_path.default.join("src/app", relative))}` : `Copy Next App Router file to ${toPosix(node_path.default.join("src/app", relative))}`,
+			force: options.force,
+			allowExisting: sourceAppDir === srcAppDir
+		});
+	}
+	const rootMiddleware = [
+		"middleware.ts",
+		"middleware.tsx",
+		"middleware.js",
+		"middleware.jsx"
+	].map((file) => node_path.default.join(root, file)).find((file) => (0, node_fs.existsSync)(file));
+	if (rootMiddleware) {
+		const extension = node_path.default.extname(rootMiddleware);
+		await addWriteFileOperation(plan, {
+			root,
+			source: rootMiddleware,
+			target: node_path.default.join(srcAppDir, `middleware${extension}`),
+			content: await (0, node_fs_promises.readFile)(rootMiddleware, "utf8"),
+			description: `Copy root middleware to ${toPosix(node_path.default.join("src/app", `middleware${extension}`))}`,
+			force: options.force
+		});
+		plan.manual.push("Review migrated middleware for next/server APIs; Farm middleware uses @farm.js/core/middleware.");
+	}
+	if ((0, node_fs.existsSync)(node_path.default.join(root, "next.config.js")) || (0, node_fs.existsSync)(node_path.default.join(root, "next.config.mjs"))) plan.manual.push("Review next.config.* and move equivalent settings into farm.config.ts or Vite config.");
+	if (packageJson) addPackageOperation(root, plan, createMigratedPackageJson(packageJson, "next"));
+}
+async function planTanStackMigration(root, packageJson, plan, options) {
+	const routesDir = [node_path.default.join(root, "src", "routes"), node_path.default.join(root, "routes")].find((dir) => (0, node_fs.existsSync)(dir));
+	if (!routesDir) {
+		plan.warnings.push("No TanStack Router file-route directory found at src/routes/ or routes/.");
+		return;
+	}
+	const appDir = node_path.default.join(root, "src", "app");
+	const files = (await collectFiles(routesDir)).filter((file) => {
+		const basename = node_path.default.basename(file);
+		return /\.(tsx|ts|jsx|js)$/.test(file) && basename !== "routeTree.gen.ts" && basename !== "routeTree.gen.tsx";
+	});
+	for (const file of files) {
+		const target = getTanStackTargetPath(routesDir, file, appDir);
+		if (!target) {
+			plan.manual.push(`Review ${toPosix(node_path.default.relative(root, file))}; root routes and route trees are not copied automatically.`);
+			continue;
+		}
+		await addWriteFileOperation(plan, {
+			root,
+			source: file,
+			target,
+			content: transformTanStackContent(await (0, node_fs_promises.readFile)(file, "utf8"), node_path.default.relative(root, file), plan),
+			description: `Convert TanStack route to ${toPosix(node_path.default.relative(root, target))}`,
+			force: options.force
+		});
+	}
+	plan.manual.push("Review loaders, beforeLoad hooks, search params, and Route.use* calls; Farm page modules should move that logic into props, API routes, or server helpers.");
+	if (packageJson) addPackageOperation(root, plan, createMigratedPackageJson(packageJson, "tanstack"));
+}
+function addSharedFarmFiles(root, packageJson, plan, source, options) {
+	if (![
+		"farm.config.ts",
+		"farm.config.mts",
+		"farm.config.js",
+		"farm.config.mjs"
+	].map((file) => node_path.default.join(root, file)).find((file) => (0, node_fs.existsSync)(file))) {
+		const output = source === "next" ? `import { defineConfig } from "@farm.js/core";
+
+export default defineConfig({
+  srcDir: "src",
+});
+` : `import { defineConfig } from "@farm.js/core";
+
+export default defineConfig({
+  srcDir: "src",
+});
+`;
+		plan.operations.push({
+			kind: "write-file",
+			path: node_path.default.join(root, "farm.config.ts"),
+			description: "Create farm.config.ts",
+			content: output,
+			skipped: false
+		});
+	}
+	const layoutPath = node_path.default.join(root, "src", "app", "layout.tsx");
+	if (!(0, node_fs.existsSync)(layoutPath)) plan.operations.push({
+		kind: "write-file",
+		path: layoutPath,
+		description: "Create a minimal root layout",
+		content: `import type { LayoutProps } from "@farm.js/core";
+
+export default function Layout({ children }: LayoutProps) {
+  return <>{children}</>;
+}
+`,
+		skipped: false
+	});
+	if (!packageJson) plan.warnings.push("No package.json found; add @farm.js/core and @farm.js/cli manually.");
+}
+async function addWriteFileOperation(plan, options) {
+	const exists = (0, node_fs.existsSync)(options.target);
+	const sameFile = options.source && node_path.default.resolve(options.source) === node_path.default.resolve(options.target);
+	const skipped = exists && !sameFile && !options.allowExisting && !options.force;
+	plan.operations.push({
+		kind: "write-file",
+		path: options.target,
+		description: options.description,
+		content: options.content,
+		skipped,
+		reason: skipped ? `${toPosix(node_path.default.relative(options.root, options.target))} already exists; pass --force to overwrite.` : void 0
+	});
+}
+function addPackageOperation(root, plan, migrated) {
+	if (!migrated.changes.length) return;
+	plan.operations.push({
+		kind: "update-package",
+		path: node_path.default.join(root, "package.json"),
+		description: "Update package.json scripts and Farm dependencies",
+		content: `${JSON.stringify(migrated.packageJson, null, 2)}\n`,
+		changes: migrated.changes
+	});
+}
+async function applyFrameworkMigrationPlan(plan) {
+	for (const operation of plan.operations) {
+		if (operation.skipped) {
+			_farm_js_core.logger.warn(`Skipped ${toPosix(node_path.default.relative(plan.root, operation.path))}: ${operation.reason}`);
+			continue;
+		}
+		if (operation.kind === "write-file" || operation.kind === "update-package") {
+			await (0, node_fs_promises.mkdir)(node_path.default.dirname(operation.path), { recursive: true });
+			await (0, node_fs_promises.writeFile)(operation.path, operation.content || "", "utf8");
+		}
+	}
+}
+function printFrameworkInspection(root, detections) {
+	_farm_js_core.logger.info(`Migration inspection for ${root}`);
+	if (!detections.length) {
+		_farm_js_core.logger.warn("No supported framework detected yet. Supported sources: next, tanstack.");
+		return;
+	}
+	for (const detection of detections) {
+		_farm_js_core.logger.info(`${detection.source}: ${detection.confidence}% confidence`);
+		for (const evidence of detection.evidence) _farm_js_core.logger.info(`  - ${evidence}`);
+	}
+}
+function printFrameworkMigrationPlan(plan, willWrite) {
+	_farm_js_core.logger.info(`${willWrite ? "Applying" : "Prepared"} ${plan.source} migration plan (${plan.confidence}% confidence):`);
+	for (const evidence of plan.evidence) _farm_js_core.logger.info(`  evidence: ${evidence}`);
+	if (!plan.operations.length) _farm_js_core.logger.warn("No file operations were planned.");
+	else {
+		_farm_js_core.logger.info("Operations:");
+		for (const operation of plan.operations) {
+			const marker = operation.skipped ? "skip" : willWrite ? "write" : "plan";
+			_farm_js_core.logger.info(`  [${marker}] ${operation.description}`);
+			if (operation.changes?.length) for (const change of operation.changes) _farm_js_core.logger.info(`        - ${change}`);
+			if (operation.reason) _farm_js_core.logger.info(`        ${operation.reason}`);
+		}
+	}
+	if (plan.warnings.length) {
+		_farm_js_core.logger.warn("Warnings:");
+		for (const warning of unique(plan.warnings)) _farm_js_core.logger.warn(`  - ${warning}`);
+	}
+	if (plan.manual.length) {
+		_farm_js_core.logger.info("Manual review:");
+		for (const note of unique(plan.manual)) _farm_js_core.logger.info(`  - ${note}`);
+	}
+}
+function detectNext(root, packageJson) {
+	const evidence = [];
+	let confidence = 0;
+	if (hasPackage(packageJson, "next")) {
+		confidence += 55;
+		evidence.push("package.json depends on next");
+	}
+	if ((0, node_fs.existsSync)(node_path.default.join(root, "app"))) {
+		confidence += 30;
+		evidence.push("app/ directory exists");
+	}
+	if ((0, node_fs.existsSync)(node_path.default.join(root, "src", "app"))) {
+		confidence += 25;
+		evidence.push("src/app/ directory exists");
+	}
+	if ((0, node_fs.existsSync)(node_path.default.join(root, "next.config.js")) || (0, node_fs.existsSync)(node_path.default.join(root, "next.config.mjs"))) {
+		confidence += 15;
+		evidence.push("next.config.* exists");
+	}
+	if ((0, node_fs.existsSync)(node_path.default.join(root, "pages"))) {
+		confidence += 10;
+		evidence.push("pages/ directory exists");
+	}
+	return {
+		source: "next",
+		confidence: Math.min(confidence, 100),
+		evidence
+	};
+}
+function detectTanStack(root, packageJson) {
+	const evidence = [];
+	let confidence = 0;
+	if (hasPackage(packageJson, "@tanstack/react-router")) {
+		confidence += 60;
+		evidence.push("package.json depends on @tanstack/react-router");
+	}
+	if ((0, node_fs.existsSync)(node_path.default.join(root, "src", "routes"))) {
+		confidence += 35;
+		evidence.push("src/routes/ directory exists");
+	}
+	if ((0, node_fs.existsSync)(node_path.default.join(root, "routes"))) {
+		confidence += 25;
+		evidence.push("routes/ directory exists");
+	}
+	if ((0, node_fs.existsSync)(node_path.default.join(root, "src", "routeTree.gen.ts"))) {
+		confidence += 15;
+		evidence.push("src/routeTree.gen.ts exists");
+	}
+	return {
+		source: "tanstack",
+		confidence: Math.min(confidence, 100),
+		evidence
+	};
+}
+async function collectFiles(dir) {
+	const entries = await (0, node_fs_promises.readdir)(dir);
+	const files = [];
+	for (const entry of entries) {
+		if (entry === "node_modules" || entry === ".next" || entry === ".output") continue;
+		const fullPath = node_path.default.join(dir, entry);
+		const info = await (0, node_fs_promises.stat)(fullPath);
+		if (info.isDirectory()) files.push(...await collectFiles(fullPath));
+		else if (info.isFile()) files.push(fullPath);
+	}
+	return files.sort();
+}
+function transformNextContent(content) {
+	return content.replace(/import\s+([A-Za-z_$][\w$]*)\s+from\s+["']next\/link["'];?/g, (_match, localName) => localName === "Link" ? `import { Link } from "@farm.js/core/client";` : `import { Link as ${localName} } from "@farm.js/core/client";`).replace(/from\s+["']next\/navigation["']/g, `from "@farm.js/core/navigation"`).replace(/from\s+["']next\/headers["']/g, `from "@farm.js/core/headers"`);
+}
+function collectNextManualNotes(relative, content, plan) {
+	const imports = Array.from(content.matchAll(/from\s+["'](next\/[^"']+)["']/g)).map((match) => match[1]);
+	for (const importId of imports) plan.manual.push(`Review ${toPosix(relative)}; it still imports ${importId}.`);
+	if (/getServerSideProps|getStaticProps|getInitialProps/.test(content)) plan.manual.push(`Review ${toPosix(relative)}; Pages Router data functions need manual App Router/Farm conversion.`);
+}
+function isMigratableTextFile(file) {
+	return /\.(ts|tsx|js|jsx|mjs|cjs|md|mdx|css|json|txt)$/.test(file);
+}
+function getTanStackTargetPath(routesDir, file, appDir) {
+	const withoutExt = toPosix(node_path.default.relative(routesDir, file)).replace(/\.(tsx|ts|jsx|js)$/, "");
+	if (withoutExt === "__root" || withoutExt === "routeTree.gen") return null;
+	const rawParts = withoutExt.split("/").flatMap((segment) => segment.split(".")).filter((segment) => segment && !segment.startsWith("_"));
+	if (!rawParts.length) return null;
+	const routeParts = (rawParts[rawParts.length - 1] === "index" ? rawParts.slice(0, -1) : rawParts).map(convertTanStackSegment);
+	return node_path.default.join(appDir, ...routeParts, "page.tsx");
+}
+function convertTanStackSegment(segment) {
+	if (segment === "$") return "[...splat]";
+	if (segment.startsWith("$")) return `[${segment.slice(1)}]`;
+	return segment;
+}
+function transformTanStackContent(content, relativeFile, plan) {
+	if (/Route\.use[A-Z]/.test(content) || /useLoaderData|beforeLoad|loader:/.test(content)) plan.manual.push(`Review ${toPosix(relativeFile)}; it uses TanStack route runtime APIs.`);
+	if (/export\s+default\s+/.test(content)) return content;
+	const componentName = content.match(/component\s*:\s*([A-Za-z_$][\w$]*)/)?.[1];
+	if (!componentName) {
+		plan.manual.push(`Add a default export to ${toPosix(relativeFile)}; no component: Identifier was found.`);
+		return content;
+	}
+	return `${content.trimEnd()}
+
+export default ${componentName};
+`;
+}
+function createMigratedPackageJson(packageJson, source) {
+	const nextPackageJson = cloneJson(packageJson);
+	const changes = [];
+	nextPackageJson.scripts = nextPackageJson.scripts || {};
+	const scriptReplacements = source === "next" ? [
+		[
+			"dev",
+			"farm dev",
+			/(^|\s)next\s+dev(\s|$)/
+		],
+		[
+			"build",
+			"farm build",
+			/(^|\s)next\s+build(\s|$)/
+		],
+		[
+			"start",
+			"node .output/server/index.mjs",
+			/(^|\s)next\s+start(\s|$)/
+		]
+	] : [[
+		"dev",
+		"farm dev",
+		/(^|\s)vite(\s|$)|(^|\s)vinxi\s+dev(\s|$)/
+	], [
+		"build",
+		"farm build",
+		/(^|\s)vite\s+build(\s|$)|(^|\s)vinxi\s+build(\s|$)/
+	]];
+	for (const [name, value, matcher] of scriptReplacements) {
+		const existing = nextPackageJson.scripts[name];
+		if (!existing || matcher.test(existing)) {
+			if (existing !== value) {
+				nextPackageJson.scripts[name] = value;
+				changes.push(`scripts.${name} -> ${value}`);
+			}
+		}
+	}
+	nextPackageJson.dependencies = nextPackageJson.dependencies || {};
+	if (!nextPackageJson.dependencies["@farm.js/core"]) {
+		nextPackageJson.dependencies["@farm.js/core"] = "latest";
+		changes.push("dependencies.@farm.js/core -> latest");
+	}
+	nextPackageJson.devDependencies = nextPackageJson.devDependencies || {};
+	if (!nextPackageJson.devDependencies["@farm.js/cli"]) {
+		nextPackageJson.devDependencies["@farm.js/cli"] = "latest";
+		changes.push("devDependencies.@farm.js/cli -> latest");
+	}
+	return {
+		packageJson: nextPackageJson,
+		changes
+	};
+}
+async function readPackageJson(root) {
+	const packagePath = node_path.default.join(root, "package.json");
+	if (!(0, node_fs.existsSync)(packagePath)) return null;
+	return JSON.parse(await (0, node_fs_promises.readFile)(packagePath, "utf8"));
+}
+function hasPackage(packageJson, packageName) {
+	return Boolean(packageJson?.dependencies?.[packageName] || packageJson?.devDependencies?.[packageName] || packageJson?.peerDependencies?.[packageName]);
+}
+function cloneJson(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+function unique(values) {
+	return [...new Set(values)];
+}
+function toPosix(value) {
+	return value.split(node_path.default.sep).join("/");
+}
+//#endregion
+exports.addFarmIntegration = require_add_integration.addFarmIntegration;
+exports.buildFarm = require_build.buildFarm;
+exports.createFrameworkMigrationPlan = createFrameworkMigrationPlan;
+exports.createGatewaySession = createGatewaySession;
+exports.createPreviewGatewayPlan = createPreviewGatewayPlan;
+exports.createPreviewTunnelPlan = createPreviewTunnelPlan;
+Object.defineProperty(exports, "createServer", {
+	enumerable: true,
+	get: function() {
+		return _farm_js_core_server.createServer;
+	}
+});
+exports.deployFarm = deployFarm;
+exports.formatFarmCronJobs = formatFarmCronJobs;
+exports.formatFarmDoctorReport = formatFarmDoctorReport;
+exports.forwardGatewayRequest = forwardGatewayRequest;
+exports.generateFarmArtifacts = generateFarmArtifacts;
+exports.inspectFrameworkMigrations = inspectFrameworkMigrations;
+exports.listFarmCronJobs = listFarmCronJobs;
+exports.listFarmIntegrationProviders = require_add_integration.listFarmIntegrationProviders;
+exports.loadFarmCronConfig = loadFarmCronConfig;
+exports.migrateFarm = migrateFarm;
+exports.parsePreviewPublicUrl = parsePreviewPublicUrl;
+exports.previewFarm = previewFarm;
+exports.resolveCloudflareAgentDeployPlan = resolveCloudflareAgentDeployPlan;
+exports.resolvePreviewTarget = resolvePreviewTarget;
+exports.runFarmCronJob = runFarmCronJob;
+exports.runFarmDoctor = runFarmDoctor;
+exports.runPreviewGateway = runPreviewGateway;
+Object.defineProperty(exports, "startDevServer", {
+	enumerable: true,
+	get: function() {
+		return _farm_js_core_server.startDevServer;
+	}
+});
+exports.startFarmCronScheduler = startFarmCronScheduler;
+
+//# sourceMappingURL=index.js.map