@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-VWW4Q3BJ.mjs

@@ -0,0 +1,1291 @@
+import {
+  resolveFarmAuthConfig,
+  resolveFarmAuthIntegration,
+  resolveFarmDevIndicatorsConfig,
+  resolveFarmServerComponentsMode,
+  setFarmProjectSourceDir
+} from "./chunk-PAKCHVUS.mjs";
+import {
+  normalizeRouteRules,
+  routeRulesToHeaders,
+  routeRulesToRedirects
+} from "./chunk-X3XUZWRB.mjs";
+import {
+  assertPluginDependencies
+} from "./chunk-XR2ZIBQK.mjs";
+import {
+  resolveFarmDevtoolsConfig
+} from "./chunk-CU5SYTJG.mjs";
+import {
+  isReactRenderer,
+  resolveFarmRenderer
+} from "./chunk-ES2LD2YD.mjs";
+import {
+  resolveFarmAgentCrawlers,
+  resolveFarmAgentSitemap,
+  resolveFarmNoindexPreviews,
+  resolveFarmPerformanceConfig
+} from "./chunk-T4TBK5NY.mjs";
+import {
+  farmCspBlocksFrameworkInlineScripts,
+  getFarmSecurityHeader,
+  resolveFarmSecurityConfig
+} from "./chunk-22W4FNTG.mjs";
+import {
+  resolveFarmAppManifestConfig
+} from "./chunk-2WZTGPK6.mjs";
+import {
+  resolveFarmLlmsTxtConfig
+} from "./chunk-KVW2M6PI.mjs";
+import {
+  loadFarmConfigFile,
+  resolveFarmLayers
+} from "./chunk-52Y3C3HG.mjs";
+import {
+  resolveFarmImageConfig
+} from "./chunk-2NGZFOKG.mjs";
+import {
+  resolveEnv,
+  setEnv
+} from "./chunk-N33DLJBC.mjs";
+import {
+  resolveMdxConfig
+} from "./chunk-UIJOLBUL.mjs";
+import {
+  resolveMarkdownConfig
+} from "./chunk-YSXTNSXS.mjs";
+import {
+  bundleNodeModule
+} from "./chunk-VFXE6NWR.mjs";
+import {
+  resolveWorkflowsConfig
+} from "./chunk-TZVUF5JJ.mjs";
+import {
+  FARM_CRON_NAME_SEGMENT_PATTERN,
+  normalizeCronExpression,
+  resolveCronConfig
+} from "./chunk-DQF3QLOH.mjs";
+import {
+  resolveServerActionsConfig
+} from "./chunk-E46NXBNJ.mjs";
+import {
+  resolveFarmThemeConfig
+} from "./chunk-YWPNIYUP.mjs";
+import {
+  resolveIntegrationPlugins
+} from "./chunk-TGULJSHD.mjs";
+import {
+  compileMiddlewareConfig
+} from "./chunk-EDPENAVO.mjs";
+import {
+  resolveFarmI18nConfig
+} from "./chunk-MU5V7XHL.mjs";
+import {
+  logger
+} from "./chunk-JSDV2NUN.mjs";
+import {
+  resolveFarmServerConfig
+} from "./chunk-QDWMCFTH.mjs";
+import {
+  resolveFarmAPIConfig
+} from "./chunk-W6QLRQ3V.mjs";
+import {
+  normalizeFarmDeploymentId
+} from "./chunk-UAQD67HM.mjs";
+import {
+  validateConfigRouteSource
+} from "./chunk-ONG4RDW3.mjs";
+import {
+  isFarmRedirectStatus
+} from "./chunk-JNYFXL7X.mjs";
+import {
+  normalizeFarmConfigBasePath
+} from "./chunk-SF3JB56B.mjs";
+
+// src/mcp-config.ts
+import { createRequire } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+function resolveFarmMCPConfig(input) {
+  if (input === false || input === void 0) return { enabled: false };
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new TypeError("mcp must be a configuration object or false.");
+  }
+  return { ...input, enabled: input.enabled !== false };
+}
+async function resolveFarmMCPPlugin(config, options) {
+  if (!config.enabled) return void 0;
+  const root = path.resolve(options.root);
+  let modulePath;
+  try {
+    const resolveFromApp = createRequire(path.join(root, "package.json"));
+    modulePath = resolveFromApp.resolve("@farm.js/mcp/internal");
+  } catch {
+    throw new Error(
+      "The `mcp` config requires @farm.js/mcp. Install it with `pnpm add @farm.js/mcp` and try again."
+    );
+  }
+  const runtime = await import(
+    /* @vite-ignore */
+    pathToFileURL(modulePath).href
+  );
+  if (typeof runtime.createFarmMCPPlugin !== "function") {
+    throw new Error(
+      "The installed @farm.js/mcp package is incompatible with this version of @farm.js/core."
+    );
+  }
+  return runtime.createFarmMCPPlugin(config);
+}
+
+// src/cron-scan.ts
+var LANGS = {
+  ts: "ts",
+  tsx: "tsx",
+  js: "jsx",
+  jsx: "jsx"
+};
+var parseAst;
+async function loadParseAst() {
+  if (!parseAst) {
+    const { createRequire: createRequire3 } = await import("module");
+    parseAst = createRequire3(typeof __filename === "string" ? __filename : import.meta.url)(
+      "rolldown/parseAst"
+    ).parseAst;
+  }
+  return parseAst;
+}
+function unwrap(node) {
+  while (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression" || node.type === "ParenthesizedExpression") {
+    node = node.expression;
+  }
+  return node;
+}
+function* walkNodes(value) {
+  if (!value || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    for (const item of value) yield* walkNodes(item);
+    return;
+  }
+  const node = value;
+  if (typeof node.type === "string") yield node;
+  for (const key of Object.keys(node)) {
+    if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") {
+      continue;
+    }
+    yield* walkNodes(node[key]);
+  }
+}
+function notLiteral(file, key) {
+  throw new TypeError(
+    `The \`${key}\` option of cronRoute() in ${file} is not a literal. The build reads scheduling options from the source without running the module, so write \`${key}\` out literally or move the job to the \`cron\` config in farm.config.ts.`
+  );
+}
+function literalValue(node, file, key) {
+  if (!node) notLiteral(file, key);
+  switch (node.type) {
+    case "Literal":
+      if (node.regex || typeof node.value === "bigint") notLiteral(file, key);
+      return node.value;
+    case "TemplateLiteral":
+      if (node.expressions.length > 0) notLiteral(file, key);
+      return node.quasis[0]?.value?.cooked ?? notLiteral(file, key);
+    case "UnaryExpression":
+      if (node.operator === "-" && node.argument.type === "Literal" && typeof node.argument.value === "number") {
+        return -node.argument.value;
+      }
+      notLiteral(file, key);
+      break;
+    case "ArrayExpression": {
+      const items = [];
+      for (const element of node.elements) {
+        if (!element || element.type === "SpreadElement") notLiteral(file, key);
+        items.push(literalValue(unwrap(element), file, key));
+      }
+      return items;
+    }
+    case "ObjectExpression": {
+      const object = {};
+      for (const property of node.properties) {
+        if (property.type !== "Property" || property.computed || property.kind !== "init") {
+          notLiteral(file, key);
+        }
+        const propertyKey = property.key.type === "Identifier" ? property.key.name : property.key.value;
+        if (typeof propertyKey !== "string" || propertyKey === "__proto__") notLiteral(file, key);
+        object[propertyKey] = literalValue(unwrap(property.value), file, key);
+      }
+      return object;
+    }
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+    case "ParenthesizedExpression":
+      return literalValue(node.expression, file, key);
+  }
+  notLiteral(file, key);
+}
+function optionProperty(object, name) {
+  return object.properties.find(
+    (entry) => entry.type === "Property" && !entry.computed && (entry.key.name === name || entry.key.value === name)
+  )?.value;
+}
+function cronRouteLocalNames(program) {
+  const locals = /* @__PURE__ */ new Set();
+  for (const statement of program.body) {
+    if (statement.type !== "ImportDeclaration") continue;
+    for (const specifier of statement.specifiers) {
+      if (specifier.type !== "ImportSpecifier") continue;
+      const imported = specifier.imported?.name ?? specifier.imported?.value;
+      if (imported === "cronRoute") locals.add(specifier.local.name);
+    }
+  }
+  return locals;
+}
+function scannedJobFromOptions(optionsNode, file, routePath) {
+  const scheduleNode = optionProperty(optionsNode, "schedule");
+  if (!scheduleNode) return null;
+  if (optionsNode.properties.some((entry) => entry.type === "SpreadElement")) {
+    throw new TypeError(
+      `The cronRoute() options in ${file} spread another object next to \`schedule\`, so the build cannot read the job statically. Write every scheduling option literally in the call.`
+    );
+  }
+  const read = (key) => {
+    const node = optionProperty(optionsNode, key);
+    return node === void 0 ? void 0 : literalValue(unwrap(node), file, key);
+  };
+  const name = readScannedName(read("name"), file, routePath);
+  const schedule = readScannedSchedule(read("schedule"), file, name);
+  const description = read("description");
+  if (description !== void 0 && typeof description !== "string") {
+    throw new TypeError(
+      `The \`description\` option of cronRoute() in ${file} must be a string literal.`
+    );
+  }
+  const timeoutMs = read("timeoutMs");
+  if (timeoutMs !== void 0 && (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
+    throw new TypeError(
+      `The \`timeoutMs\` option of cronRoute() in ${file} must be a positive number literal in milliseconds.`
+    );
+  }
+  const enabled = read("enabled");
+  if (enabled !== void 0 && typeof enabled !== "boolean") {
+    throw new TypeError(
+      `The \`enabled\` option of cronRoute() in ${file} must be \`true\` or \`false\`.`
+    );
+  }
+  const input = read("input");
+  return {
+    name,
+    schedule,
+    path: routePath,
+    ...typeof description === "string" && description.trim() ? { description: description.trim() } : {},
+    ...input !== void 0 ? { input } : {},
+    ...timeoutMs !== void 0 ? { timeoutMs } : {},
+    filePath: file,
+    enabled: enabled !== false
+  };
+}
+function readScannedName(value, file, routePath) {
+  if (value === void 0) {
+    const defaultName = routePath === "/api" ? "" : routePath.slice("/api/".length);
+    if (!defaultName) {
+      throw new TypeError(
+        `The scheduled cronRoute() in ${file} sits at the \`/api\` root, which has no default job name. Set the \`name\` option.`
+      );
+    }
+    return defaultName;
+  }
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(
+      `The \`name\` option of cronRoute() in ${file} must be a non-empty string literal.`
+    );
+  }
+  if (!value.split("/").every((segment) => FARM_CRON_NAME_SEGMENT_PATTERN.test(segment))) {
+    throw new TypeError(
+      `The \`name\` option ${JSON.stringify(value)} of cronRoute() in ${file} is invalid. Each "/"-separated segment must start with a letter or number and contain only letters, numbers, dots, underscores, or hyphens.`
+    );
+  }
+  return value;
+}
+function readScannedSchedule(value, file, name) {
+  const raw = Array.isArray(value) ? value : [value];
+  if (raw.length === 0) {
+    throw new TypeError(
+      `The \`schedule\` option of cronRoute() in ${file} must list at least one cron expression.`
+    );
+  }
+  try {
+    return [...new Set(raw.map((entry) => normalizeCronExpression(name, entry)))];
+  } catch (error) {
+    throw new TypeError(`${error.message} (from the cronRoute() options in ${file})`);
+  }
+}
+async function scanFarmCronRouteJobs(options) {
+  const [path4, fs] = await Promise.all([import("path"), import("fs/promises")]);
+  const apiDir = path4.join(options.root, options.srcDir || "src", "app", "api");
+  try {
+    if (!(await fs.stat(apiDir)).isDirectory()) return [];
+  } catch {
+    return [];
+  }
+  const { glob } = await import("tinyglobby");
+  const files = (await glob("**/route.{ts,tsx,js,jsx}", {
+    cwd: apiDir,
+    absolute: true,
+    expandDirectories: false
+  })).sort();
+  const jobs = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const code = await fs.readFile(file, "utf8");
+    if (!code.includes("cronRoute")) continue;
+    const parse = await loadParseAst();
+    const lang = LANGS[path4.extname(file).slice(1)] ?? "tsx";
+    let program;
+    try {
+      program = parse(code, { lang });
+    } catch (error) {
+      throw new TypeError(
+        `The route file ${file} could not be parsed while reading its cronRoute() schedule: ${error.message}`
+      );
+    }
+    const locals = cronRouteLocalNames(program);
+    if (locals.size === 0) continue;
+    const relativeDir = path4.relative(apiDir, path4.dirname(file)).split(path4.sep).join("/");
+    const routePath = relativeDir === "" || relativeDir === "." ? "/api" : `/api/${relativeDir}`;
+    for (const node of walkNodes(program)) {
+      if (node.type !== "CallExpression" || node.callee?.type !== "Identifier" || !locals.has(node.callee.name)) {
+        continue;
+      }
+      const optionsArgument = node.arguments?.[1];
+      if (!optionsArgument || optionsArgument.type === "SpreadElement") continue;
+      const optionsNode = unwrap(optionsArgument);
+      if (optionsNode.type !== "ObjectExpression") continue;
+      const job = scannedJobFromOptions(optionsNode, file, routePath);
+      if (!job) continue;
+      if (/[[\]]/.test(routePath)) {
+        throw new TypeError(
+          `The scheduled cronRoute() in ${file} sits under a dynamic segment, and a scheduler cannot fill route params. Move the schedule to a static route.`
+        );
+      }
+      const existing = byName.get(job.name);
+      if (existing !== void 0) {
+        throw new TypeError(
+          `Farm cron job ${JSON.stringify(job.name)} is defined twice: in ${existing} and in ${file}. Rename or remove one of them.`
+        );
+      }
+      byName.set(job.name, file);
+      jobs.push(job);
+    }
+  }
+  return jobs;
+}
+function mergeFarmCronJobs(config, scanned) {
+  const configNames = new Set(config.jobs.map((job) => job.name));
+  const jobs = [...config.jobs];
+  for (const scannedJob of scanned) {
+    if (configNames.has(scannedJob.name)) {
+      throw new TypeError(
+        `Farm cron job ${JSON.stringify(scannedJob.name)} is defined twice: in the \`cron\` config in farm.config.ts and in ${scannedJob.filePath}. Rename or remove one of them.`
+      );
+    }
+    if (!scannedJob.enabled) continue;
+    const { filePath: _filePath, enabled: _enabled, ...job } = scannedJob;
+    jobs.push(job);
+  }
+  if (jobs.length === config.jobs.length) return config;
+  return { ...config, enabled: jobs.length > 0, jobs };
+}
+async function resolveProjectCronJobs(options) {
+  const resolved = resolveCronConfig(options.cron);
+  if (resolved === options.cron || options.cron === false) return resolved;
+  const scanned = await scanFarmCronRouteJobs({
+    root: options.root || process.cwd(),
+    srcDir: options.srcDir
+  });
+  return mergeFarmCronJobs(resolved, scanned);
+}
+
+// src/config.ts
+import path3 from "path";
+
+// src/agent-config.ts
+var DEFAULT_JSON_LD = { type: "WebSite" };
+function resolveFarmAgentConfig(input, context = {}) {
+  const jsonLd = input?.jsonLd;
+  return {
+    jsonLd: jsonLd === void 0 ? { ...DEFAULT_JSON_LD } : !jsonLd ? false : jsonLd === true ? {} : jsonLd,
+    noindexPreviews: resolveFarmNoindexPreviews(input?.noindexPreviews),
+    // The docs engine answers /llms.txt with its own pages; a default here would replace it.
+    // llms-full.txt renders every listed page, so it stays opt-in.
+    llmsTxt: resolveFarmLlmsTxtConfig(input?.llmsTxt ?? (context.docs ? false : { full: false })),
+    // Same rule as llms.txt: the docs engine answers /sitemap.xml with its own pages.
+    sitemap: resolveFarmAgentSitemap(input?.sitemap ?? !context.docs),
+    crawlers: resolveFarmAgentCrawlers(input?.crawlers),
+    apiCatalog: resolveFarmAgentBoolean(input?.apiCatalog, "apiCatalog", false),
+    aiCatalog: resolveFarmAgentBoolean(input?.aiCatalog, "aiCatalog", true),
+    manifest: resolveFarmAppManifestConfig(input?.manifest),
+    // Same rule as llms.txt: the docs engine serves its own MCP server at /mcp.
+    mcp: resolveFarmAgentBoolean(input?.mcp, "mcp", !context.docs)
+  };
+}
+function resolveFarmAgentBoolean(input, key, fallback) {
+  if (input === void 0) return fallback;
+  if (typeof input !== "boolean") throw new TypeError(`agent.${key} must be a boolean.`);
+  return input;
+}
+
+// src/docs/framework-detect.ts
+import { readFile } from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import path2 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+var FRAMEWORK_PACKAGE = "@farming-labs/farmjs";
+var FRAMEWORK_CONFIG_ENTRY = "@farming-labs/farmjs/config";
+var SUPPORTED_ADAPTER_PROTOCOL = 1;
+async function frameworkDeclaredByApp(root) {
+  try {
+    const raw = await readFile(path2.join(root, "package.json"), "utf8");
+    const manifest = JSON.parse(raw);
+    for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+      const section = manifest[field];
+      if (section && typeof section === "object" && FRAMEWORK_PACKAGE in section) {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+var emittedNotices = /* @__PURE__ */ new Set();
+function noticeOnce(key, emit, message) {
+  if (emittedNotices.has(key)) return;
+  emittedNotices.add(key);
+  emit(message);
+}
+function docsWantsFrameworkDetection(docs) {
+  if (docs === true) return true;
+  if (!docs || typeof docs !== "object") return false;
+  if (docs.enabled === false) return false;
+  if (docs.adapter !== void 0) return false;
+  return true;
+}
+function isSupportedAdapterDescriptor(value) {
+  if (!value || typeof value !== "object") return false;
+  const descriptor = value;
+  return descriptor.protocol === SUPPORTED_ADAPTER_PROTOCOL && typeof descriptor.server === "string" && descriptor.server.length > 0 && typeof descriptor.react === "string" && descriptor.react.length > 0;
+}
+async function applyFarmDocsFrameworkAutoDetection(userConfig, options) {
+  if (!docsWantsFrameworkDetection(userConfig.docs)) return userConfig;
+  const log = options.log ?? ((message) => console.log(message));
+  const warn = options.warn ?? ((message) => console.warn(message));
+  const root = path2.resolve(options.root || process.cwd());
+  if (!await frameworkDeclaredByApp(root)) {
+    noticeOnce(
+      "embedded-fallback",
+      warn,
+      `[farm] docs is served by the embedded renderer, which is being replaced by the ${FRAMEWORK_PACKAGE} docs framework. Install ${FRAMEWORK_PACKAGE} (with @farming-labs/docs and @farming-labs/theme) to migrate now, or set docs.adapter = false to keep the embedded renderer and silence this notice.`
+    );
+    return userConfig;
+  }
+  let configEntryPath;
+  try {
+    const requireFromApp = createRequire2(path2.join(root, "package.json"));
+    configEntryPath = requireFromApp.resolve(FRAMEWORK_CONFIG_ENTRY);
+  } catch {
+    noticeOnce(
+      "declared-not-installed",
+      warn,
+      `[farm] ${FRAMEWORK_PACKAGE} is declared in package.json but could not be resolved; keeping the embedded docs renderer. Run your package manager's install to enable docs delegation.`
+    );
+    return userConfig;
+  }
+  try {
+    const frameworkConfig = await import(
+      /* @vite-ignore */
+      pathToFileURL2(configEntryPath).href
+    );
+    const withDocs = frameworkConfig?.withDocs;
+    if (typeof withDocs !== "function") {
+      noticeOnce(
+        "missing-withdocs",
+        warn,
+        `[farm] ${FRAMEWORK_CONFIG_ENTRY} does not export withDocs(); keeping the embedded docs renderer.`
+      );
+      return userConfig;
+    }
+    const applied = withDocs(userConfig);
+    const adapter = applied?.docs?.adapter;
+    if (!isSupportedAdapterDescriptor(adapter)) {
+      noticeOnce(
+        "unsupported-descriptor",
+        warn,
+        `[farm] The installed ${FRAMEWORK_PACKAGE} release publishes a docs adapter this Farm version cannot drive (need protocol ${SUPPORTED_ADAPTER_PROTOCOL}); keeping the embedded docs renderer. Upgrading @farm.js/core usually resolves this.`
+      );
+      return userConfig;
+    }
+    noticeOnce(
+      "delegated",
+      log,
+      `[farm] docs: delegated to ${FRAMEWORK_PACKAGE} (detected in this app). Set docs.adapter = false to keep the embedded renderer.`
+    );
+    return applied;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    noticeOnce(
+      "detect-failed",
+      warn,
+      `[farm] Failed to load ${FRAMEWORK_CONFIG_ENTRY} (${message}); keeping the embedded docs renderer.`
+    );
+    return userConfig;
+  }
+}
+
+// src/config.ts
+var FARM_RESOLVED_CUSTOM_CONTEXT = /* @__PURE__ */ Symbol.for("farm.resolvedCustomContext");
+function resolveSchemaConfig(config) {
+  if (config === void 0) return {};
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new TypeError("`schema` in farm.config must be an object.");
+  }
+  for (const key of ["allowExtend", "allowForeignKeys"]) {
+    const entries = config[key];
+    if (entries === void 0) continue;
+    if (!entries || typeof entries !== "object" || Array.isArray(entries)) {
+      throw new TypeError(
+        `\`schema.${key}\` must map a plugin's migrate name to a list of model or table names.`
+      );
+    }
+    for (const [owner, tables] of Object.entries(entries)) {
+      if (!Array.isArray(tables) || tables.some((table) => typeof table !== "string")) {
+        throw new TypeError(
+          `\`schema.${key}.${owner}\` must be a list of model or table names, such as ["user"].`
+        );
+      }
+    }
+  }
+  return config;
+}
+function hasCustomFarmRouteContext(config) {
+  return config[FARM_RESOLVED_CUSTOM_CONTEXT] === true;
+}
+function isResolvedFarmConfig(config) {
+  return Object.prototype.hasOwnProperty.call(config, FARM_RESOLVED_CUSTOM_CONTEXT);
+}
+function normalizeDeployTarget(target) {
+  if (!target) return void 0;
+  if (target === "cloudflare-pages" || target === "cloudflare_pages") return "cloudflare";
+  if (target === "node-server" || target === "nitro") return "node";
+  return target;
+}
+function getPresetForDeployTarget(target) {
+  switch (normalizeDeployTarget(target)) {
+    case "vercel":
+      return "vercel";
+    case "cloudflare":
+      return "cloudflare-pages";
+    case "netlify":
+      return "netlify";
+    case "node":
+      return "node-server";
+    default:
+      return void 0;
+  }
+}
+function getDeployTargetForPreset(preset) {
+  if (!preset) return void 0;
+  if (preset === "vercel" || preset === "vercel-edge") return "vercel";
+  if (preset === "cloudflare" || preset === "cloudflare-pages" || preset === "cloudflare-module") {
+    return "cloudflare";
+  }
+  if (preset === "netlify" || preset === "netlify-edge") return "netlify";
+  if (preset === "node-server") return "node";
+  return void 0;
+}
+var NETLIFY_INTERNAL_FUNCTIONS_DIR = ".netlify/functions-internal";
+function getDefaultDeployOutputDir(target, preset, distDir) {
+  const normalizedTarget = normalizeDeployTarget(target) || getDeployTargetForPreset(preset);
+  if (normalizedTarget === "vercel") return ".vercel/output";
+  if (normalizedTarget === "netlify" && (!preset || preset === "netlify")) {
+    return NETLIFY_INTERNAL_FUNCTIONS_DIR;
+  }
+  return `${distDir}/.output`;
+}
+function resolveDeployOutputPath(root, outputDir) {
+  return path3.isAbsolute(outputDir) ? outputDir : path3.join(root, outputDir);
+}
+var PLATFORM_BUILD_ENV_TARGETS = [
+  ["VERCEL", "vercel"],
+  ["NETLIFY", "netlify"],
+  ["CF_PAGES", "cloudflare"]
+];
+function detectPlatformDeployTarget(env = process.env) {
+  for (const [key, target] of PLATFORM_BUILD_ENV_TARGETS) {
+    const value = env[key]?.trim().toLowerCase();
+    if (value === "1" || value === "true") return target;
+  }
+  return void 0;
+}
+var warnedPlatformMismatches = /* @__PURE__ */ new Set();
+function resolveDeployConfig(config, overrides = {}) {
+  const deploy = config.deploy || {};
+  const distDir = config.distDir || ".farm";
+  const overrideTarget = normalizeDeployTarget(overrides.target);
+  let target = overrideTarget ? overrideTarget : overrides.preset ? getDeployTargetForPreset(overrides.preset) : normalizeDeployTarget(deploy.target);
+  const detectedTarget = detectPlatformDeployTarget(overrides.env);
+  if (detectedTarget) {
+    const hasExplicitSelection = Boolean(
+      target || overrides.preset || deploy.preset || config.preset
+    );
+    if (!hasExplicitSelection) {
+      target = detectedTarget;
+      if (!warnedPlatformMismatches.has(`select:${detectedTarget}`)) {
+        warnedPlatformMismatches.add(`select:${detectedTarget}`);
+        logger.info(
+          `Detected ${detectedTarget} build environment; using the ${detectedTarget} preset. Set deploy.target in farm.config.ts to override.`
+        );
+      }
+    }
+  }
+  const configuredPreset = deploy.preset || config.preset;
+  const overrideTargetPreset = overrideTarget && getDeployTargetForPreset(configuredPreset) !== overrideTarget ? getPresetForDeployTarget(overrideTarget) : void 0;
+  const preset = overrides.preset || overrideTargetPreset || configuredPreset || getPresetForDeployTarget(target) || "node-server";
+  const resolvedTarget = target || getDeployTargetForPreset(preset);
+  if (detectedTarget && resolvedTarget !== detectedTarget) {
+    const mismatchKey = `mismatch:${resolvedTarget}:${detectedTarget}`;
+    if (!warnedPlatformMismatches.has(mismatchKey)) {
+      warnedPlatformMismatches.add(mismatchKey);
+      logger.warn(
+        `The configured deploy target "${resolvedTarget ?? preset}" cannot be served by ${detectedTarget}, but this build is running in a ${detectedTarget} build environment. Set deploy.target: "${detectedTarget}" in farm.config.ts to deploy there.`
+      );
+    }
+  }
+  const platformOutput = resolvedTarget === "vercel" ? deploy.vercel?.outputDirectory : resolvedTarget === "cloudflare" ? deploy.cloudflare?.outputDir : resolvedTarget === "netlify" ? deploy.netlify?.outputDir : void 0;
+  const outputDir = overrides.outputDir || deploy.outputDir || deploy.output || platformOutput || getDefaultDeployOutputDir(resolvedTarget, preset, distDir);
+  return {
+    ...deploy,
+    target: resolvedTarget,
+    preset,
+    outputDir
+  };
+}
+function resolveMigrationsConfig(migrations) {
+  if (!migrations) return { commands: [] };
+  if (Array.isArray(migrations)) return { commands: migrations };
+  return { commands: migrations.commands || [] };
+}
+var DOCS_CONFIG_FILENAMES = [
+  "docs.config.ts",
+  "docs.config.tsx",
+  "docs.config.mts",
+  "docs.config.cts",
+  "docs.config.js",
+  "docs.config.jsx",
+  "docs.config.mjs",
+  "docs.config.cjs",
+  "docs.json"
+];
+function normalizeDocsRoute(value, fallback = "/docs") {
+  const raw = (value || fallback).trim();
+  if (!raw || raw === "/") return "/";
+  const normalized = raw.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\/?/, "/").replace(/\/+$/, "");
+  return normalized || "/";
+}
+function docsRouteToEntry(route) {
+  const entry = route.replace(/^\/+/, "").replace(/\/+$/, "");
+  return entry || "docs";
+}
+function normalizeDocsContentDir(value) {
+  if (!value) return void 0;
+  const normalized = value.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
+  return normalized || void 0;
+}
+async function inferDocsContentDir(root, srcDir, entry) {
+  const { existsSync } = await import("fs");
+  const contentDir = path3.resolve(root, srcDir, "app", entry);
+  if (!existsSync(contentDir)) return void 0;
+  const relativeContentDir = path3.relative(root, contentDir);
+  if (relativeContentDir.startsWith("..") || path3.isAbsolute(relativeContentDir)) return void 0;
+  return normalizeDocsContentDir(relativeContentDir);
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function cloneSerializable(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return null;
+  const valueType = typeof value;
+  if (valueType === "string" || valueType === "number" || valueType === "boolean") {
+    return value;
+  }
+  if (valueType === "undefined" || valueType === "function" || valueType === "symbol") {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneSerializable(item, seen)).filter((item) => item !== void 0);
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (isRecord(value)) {
+    if (seen.has(value)) return void 0;
+    seen.add(value);
+    const output = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+      const clonedValue = cloneSerializable(nestedValue, seen);
+      if (clonedValue !== void 0) {
+        output[key] = clonedValue;
+      }
+    }
+    return output;
+  }
+  return void 0;
+}
+function omitUndefined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+function sanitizeDocsConfig(config) {
+  return cloneSerializable(config) || {};
+}
+async function findDocsConfigPath(rootDir, configPath) {
+  const { existsSync } = await import("fs");
+  const root = path3.resolve(rootDir || process.cwd());
+  if (configPath) {
+    const resolvedPath = path3.isAbsolute(configPath) ? configPath : path3.join(root, configPath);
+    if (!existsSync(resolvedPath)) {
+      throw new Error(`Could not find docs config at ${configPath}.`);
+    }
+    return path3.resolve(resolvedPath);
+  }
+  for (const filename of DOCS_CONFIG_FILENAMES) {
+    const resolvedPath = path3.join(root, filename);
+    if (existsSync(resolvedPath)) {
+      return resolvedPath;
+    }
+  }
+  return void 0;
+}
+async function loadDocsConfig(rootDir, configPath) {
+  const fs = await import("fs/promises");
+  const { pathToFileURL: pathToFileURL3 } = await import("url");
+  const root = path3.resolve(rootDir || process.cwd());
+  const resolvedPath = await findDocsConfigPath(root, configPath);
+  if (!resolvedPath) return void 0;
+  try {
+    if (resolvedPath.endsWith(".json")) {
+      const content = await fs.readFile(resolvedPath, "utf8");
+      return { config: JSON.parse(content), configPath: resolvedPath };
+    }
+    const configCacheDir = path3.join(root, ".farm", ".config-loader");
+    await fs.mkdir(configCacheDir, { recursive: true });
+    const modulePath = path3.join(
+      configCacheDir,
+      `docs-config-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
+    );
+    await bundleNodeModule({
+      root,
+      entry: resolvedPath,
+      outfile: modulePath,
+      target: `node${process.versions.node.split(".")[0]}`,
+      externalPackages: true
+    });
+    const moduleUrl = pathToFileURL3(modulePath).href + `?t=${Date.now()}`;
+    let importedConfig;
+    try {
+      importedConfig = await import(
+        /* @vite-ignore */
+        moduleUrl
+      );
+    } finally {
+      await fs.unlink(modulePath).catch(() => void 0);
+    }
+    return {
+      config: importedConfig.default || importedConfig,
+      configPath: resolvedPath
+    };
+  } catch (error) {
+    const relativePath = path3.relative(root, resolvedPath) || resolvedPath;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load docs config from ${relativePath}: ${message}`);
+  }
+}
+async function resolveDocsConfig(userDocs, options = {}) {
+  const root = options.root || process.cwd();
+  if (userDocs === false) {
+    return {
+      enabled: false,
+      entry: "/docs",
+      config: { entry: "docs", docsPath: "/docs" }
+    };
+  }
+  const docsOptions = isRecord(userDocs) ? userDocs : {};
+  if (docsOptions.enabled === false) {
+    return {
+      enabled: false,
+      entry: "/docs",
+      config: { entry: "docs", docsPath: "/docs" }
+    };
+  }
+  const loadedConfig = await loadDocsConfig(root, docsOptions.configPath);
+  const hasExplicitDocsConfig = userDocs === true || isRecord(userDocs);
+  if (!hasExplicitDocsConfig && !loadedConfig) {
+    return {
+      enabled: false,
+      entry: "/docs",
+      config: { entry: "docs", docsPath: "/docs" }
+    };
+  }
+  const fileDocsConfig = omitDocsRoots(loadedConfig?.config);
+  const inlineRawDocsConfig = omitDocsRoots(docsOptions.config);
+  const inlineDocsConfig = sanitizeDocsConfig(inlineRawDocsConfig);
+  const directDocsConfig = sanitizeDocsConfig({
+    ...docsOptions,
+    adapter: void 0,
+    enabled: void 0,
+    prerender: void 0,
+    config: void 0,
+    configPath: void 0,
+    roots: void 0
+  });
+  const loadedDocsConfig = sanitizeDocsConfig(fileDocsConfig);
+  const mergedDocsConfig = {
+    ...loadedDocsConfig,
+    ...inlineDocsConfig,
+    ...directDocsConfig
+  };
+  const runtimeDocsConfig = {
+    ...fileDocsConfig,
+    ...inlineRawDocsConfig,
+    ...omitUndefined({
+      ...docsOptions,
+      adapter: void 0,
+      enabled: void 0,
+      prerender: void 0,
+      config: void 0,
+      configPath: void 0,
+      roots: void 0
+    })
+  };
+  const explicitRoute = typeof docsOptions.entry === "string" ? docsOptions.entry : void 0;
+  const configuredDocsPath = typeof mergedDocsConfig.docsPath === "string" ? mergedDocsConfig.docsPath : void 0;
+  const configuredEntry = typeof mergedDocsConfig.entry === "string" ? mergedDocsConfig.entry : void 0;
+  const entryRoute = normalizeDocsRoute(
+    configuredDocsPath || explicitRoute || (configuredEntry ? `/${configuredEntry}` : void 0)
+  );
+  const docsEntry = explicitRoute && explicitRoute.startsWith("/") ? docsRouteToEntry(explicitRoute) : docsRouteToEntry(configuredEntry || entryRoute);
+  const configuredContentDir = normalizeDocsContentDir(
+    docsOptions.contentDir || mergedDocsConfig.contentDir
+  );
+  const contentDir = configuredContentDir || await inferDocsContentDir(root, options.srcDir || "src", docsEntry);
+  const configOverrides = { ...inlineDocsConfig, ...directDocsConfig };
+  const configFileName = loadedConfig ? path3.relative(root, loadedConfig.configPath) || loadedConfig.configPath : "the docs config";
+  const roots = await resolveDocsRoots(
+    [
+      { field: `roots in ${configFileName}`, roots: docsRootsOf(loadedConfig?.config), file: true },
+      { field: "docs.config.roots", roots: docsRootsOf(docsOptions.config) },
+      { field: "docs.roots", roots: docsOptions.roots }
+    ],
+    {
+      root,
+      srcDir: options.srcDir || "src",
+      mainEntry: entryRoute,
+      mergedDocsConfig,
+      runtimeDocsConfig,
+      configOverrides
+    }
+  );
+  if (roots.length > 0 && !(docsOptions.adapter && docsOptions.adapter.server && docsOptions.adapter.react)) {
+    throw new Error(
+      `Docs roots require a docs adapter such as @farming-labs/farmjs; Farm's built-in docs renderer serves a single docs root. Install the adapter, or remove the roots from ${configFileName} and docs.roots.`
+    );
+  }
+  return {
+    enabled: true,
+    entry: entryRoute,
+    ...docsOptions.adapter ? { adapter: docsOptions.adapter } : {},
+    ...docsOptions.prerender === true ? { prerender: true } : {},
+    contentDir,
+    configPath: loadedConfig?.configPath,
+    config: {
+      ...mergedDocsConfig,
+      entry: docsEntry,
+      docsPath: entryRoute,
+      ...contentDir ? { contentDir } : {}
+    },
+    runtimeConfig: {
+      ...runtimeDocsConfig,
+      entry: docsEntry,
+      docsPath: entryRoute,
+      ...contentDir ? { contentDir } : {}
+    },
+    configOverrides,
+    ...roots.length > 0 ? { roots } : {}
+  };
+}
+function docsRootsOf(config) {
+  return isRecord(config) ? config.roots : void 0;
+}
+function omitDocsRoots(config) {
+  if (!isRecord(config)) return {};
+  const { roots: _roots, ...rest } = config;
+  return rest;
+}
+function omitKeys(value, keys) {
+  const output = { ...value };
+  for (const key of keys) delete output[key];
+  return output;
+}
+async function resolveDocsRoots(sources, options) {
+  const declared = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    if (source.roots === void 0) continue;
+    if (!Array.isArray(source.roots)) throw new Error(`${source.field} must be an array.`);
+    const seen = /* @__PURE__ */ new Set();
+    for (const [index, rootInput] of source.roots.entries()) {
+      const field = `${source.field}[${index}].entry`;
+      if (!isRecord(rootInput) || typeof rootInput.entry !== "string" || !rootInput.entry.trim()) {
+        throw new Error(`${field} must be a route such as "/guides/docs".`);
+      }
+      const entryRoute = normalizeDocsRoute(rootInput.entry);
+      if (entryRoute === "/") {
+        throw new Error(
+          `${field} cannot be "/"; a docs root at "/" leaves no route for the others.`
+        );
+      }
+      if (entryRoute === options.mainEntry || seen.has(entryRoute)) {
+        throw new Error(
+          `${field} ${JSON.stringify(entryRoute)} is already served by another docs root.`
+        );
+      }
+      seen.add(entryRoute);
+      const { entry: _entry, ...fields } = rootInput;
+      const layers = declared.get(entryRoute) ?? { file: {}, overrides: {} };
+      if (source.file) layers.file = fields;
+      else layers.overrides = { ...layers.overrides, ...fields };
+      declared.set(entryRoute, layers);
+    }
+  }
+  const roots = [];
+  for (const [entryRoute, { file, overrides }] of declared) {
+    const docsEntry = docsRouteToEntry(entryRoute);
+    const contentDir = normalizeDocsContentDir(
+      typeof overrides.contentDir === "string" && overrides.contentDir || typeof file.contentDir === "string" && file.contentDir || void 0
+    ) || await inferDocsContentDir(options.root, options.srcDir, docsEntry);
+    const routeConfig = {
+      entry: docsEntry,
+      docsPath: entryRoute,
+      contentDir
+    };
+    const rootOverrides = sanitizeDocsConfig(overrides);
+    roots.push({
+      entry: entryRoute,
+      contentDir,
+      config: omitUndefined({
+        ...options.mergedDocsConfig,
+        ...sanitizeDocsConfig(file),
+        ...rootOverrides,
+        ...routeConfig
+      }),
+      runtimeConfig: omitUndefined({
+        ...options.runtimeDocsConfig,
+        ...file,
+        ...overrides,
+        ...routeConfig
+      }),
+      // The adapter reads the config file's own root from the config module, so the main
+      // root's overrides leave out whatever that root sets itself.
+      configOverrides: {
+        ...omitKeys(options.configOverrides, Object.keys(file)),
+        ...rootOverrides
+      }
+    });
+  }
+  return roots;
+}
+function validateRedirectConfigs(redirects, field) {
+  for (const [index, redirect] of redirects.entries()) {
+    validateConfigRouteSource(redirect.source, `${field}[${index}].source`);
+    if (redirect.statusCode !== void 0 && !isFarmRedirectStatus(redirect.statusCode)) {
+      throw new RangeError(
+        `${field}[${index}].statusCode must be one of 301, 302, 303, 307, or 308.`
+      );
+    }
+  }
+  return redirects;
+}
+function validateMiddlewareConfig(middleware) {
+  for (const entry of Array.isArray(middleware) ? middleware : middleware ? [middleware] : []) {
+    compileMiddlewareConfig({ matcher: entry.matcher, exclude: entry.exclude });
+  }
+  return middleware;
+}
+function validateConfigRouteSources(routes, field) {
+  for (const [index, route] of routes.entries()) {
+    validateConfigRouteSource(route.source, `${field}[${index}].source`);
+  }
+  return routes;
+}
+async function resolveConfig(userConfig, mode) {
+  resolveFarmServerComponentsMode(userConfig.experimental?.serverComponents);
+  const projectRoot = userConfig.root || process.cwd();
+  const layerResolution = await resolveFarmLayers(userConfig, {
+    root: projectRoot,
+    mode
+  });
+  userConfig = layerResolution.config;
+  if (userConfig.typescript !== void 0) {
+    logger.warn(
+      'The top-level "typescript" option is not supported and has no effect. Configure TypeScript in `tsconfig.json` and run `tsc --noEmit` separately when builds must enforce project type errors.'
+    );
+  }
+  if (userConfig.output !== void 0) {
+    logger.warn(
+      'The top-level "output" option is not supported and has no effect. Configure `deploy.target`, `deploy.preset`, or `deploy.outputDir` for deployment output, and use route rendering configuration for static pages.'
+    );
+  }
+  if (isReactRenderer(resolveFarmRenderer(userConfig.renderer))) {
+    userConfig = await applyFarmDocsFrameworkAutoDetection(userConfig, {
+      root: userConfig.root || projectRoot
+    });
+  }
+  const redirects = validateRedirectConfigs(
+    typeof userConfig.redirects === "function" ? await userConfig.redirects() : userConfig.redirects || [],
+    "redirects"
+  );
+  const rewrites = typeof userConfig.rewrites === "function" ? await userConfig.rewrites() : userConfig.rewrites || [];
+  validateConfigRouteSources(rewrites, "rewrites");
+  const headers = typeof userConfig.headers === "function" ? await userConfig.headers() : userConfig.headers || [];
+  validateConfigRouteSources(headers, "headers");
+  const routeRules = normalizeRouteRules(userConfig.routeRules);
+  const routeRuleRedirects = routeRulesToRedirects(routeRules);
+  const routeRuleHeaders = routeRulesToHeaders(routeRules);
+  const security = resolveFarmSecurityConfig(userConfig.security);
+  const securityHeader = getFarmSecurityHeader(security);
+  if (farmCspBlocksFrameworkInlineScripts(security)) {
+    logger.warn(
+      "security.csp blocks the inline scripts Farm injects for theming and hydration. Set security.csp.nonce to true for managed dynamic nonces and prerendered hashes, or make the governing script directive allow 'unsafe-inline' without a nonce, hash, or 'strict-dynamic' source."
+    );
+  }
+  const root = userConfig.root || process.cwd();
+  const desktopSetup = await globalThis[/* @__PURE__ */ Symbol.for("@farm.js/core/desktop-setup")]?.(userConfig, root, mode);
+  if (desktopSetup) userConfig = desktopSetup.userConfig;
+  const deploy = resolveDeployConfig(userConfig, desktopSetup?.deploy);
+  const srcDir = userConfig.srcDir || "src";
+  setFarmProjectSourceDir(root, srcDir);
+  const docs = await resolveDocsConfig(userConfig.docs, { root, srcDir });
+  const md = resolveMarkdownConfig(userConfig.md);
+  const mdx = resolveMdxConfig(userConfig.mdx);
+  const env = resolveEnv(userConfig.env, process.env);
+  setEnv(env);
+  const api = await resolveFarmAPIConfig(userConfig.api, { root, mode, env });
+  const cron = await resolveProjectCronJobs({ root, srcDir, cron: userConfig.cron });
+  const auth = resolveFarmAuthConfig(userConfig.auth);
+  const mcp = resolveFarmMCPConfig(userConfig.mcp);
+  if (auth.enabled && userConfig.integrations?.auth) {
+    throw new Error(
+      "Choose either the top-level `auth` config or `integrations.auth`; they cannot both own the auth route."
+    );
+  }
+  const nativeAuthIntegration = await resolveFarmAuthIntegration(auth, {
+    root,
+    mode
+  });
+  const nativeMCPPlugin = await resolveFarmMCPPlugin(mcp, { root });
+  if (nativeMCPPlugin && userConfig.plugins?.some((plugin) => plugin?.name === "farm:api-mcp")) {
+    throw new Error(
+      "Choose either the top-level `mcp` config or `apiMcp()` in `plugins`; they configure the same MCP transport."
+    );
+  }
+  const integrations = nativeAuthIntegration ? { ...userConfig.integrations, auth: nativeAuthIntegration } : userConfig.integrations || {};
+  const generateBuildId = userConfig.generateBuildId || (() => `build-${Date.now()}`);
+  const deploymentId = normalizeFarmDeploymentId(
+    userConfig.deploymentId || process.env.FARM_DEPLOYMENT_ID || process.env.VERCEL_GIT_COMMIT_SHA || process.env.CF_PAGES_COMMIT_SHA || (mode === "production" ? await generateBuildId() : "development")
+  );
+  const basePath = normalizeFarmConfigBasePath(userConfig.basePath);
+  const mobileSessionPlugin = userConfig.mobile !== void 0 && userConfig.mobile !== null ? (await import("./session-QZXZOPR2.mjs")).createFarmMobileSessionPlugin({
+    basePath,
+    integrations: () => integrations
+  }) : null;
+  let nativeServerFnAppDirs = [];
+  const nativeServerFnPlugin = userConfig.mobile !== void 0 && userConfig.mobile !== null ? (await import("./native-server-fn-handler-GLRHAYWV.mjs")).createFarmNativeServerFnPlugin({
+    resolve: (await import("./internal/native-server-fns.mjs")).createFarmDevNativeServerFnResolver(
+      { root, srcDir, appDirs: () => nativeServerFnAppDirs }
+    )
+  }) : null;
+  const openapi = {
+    enabled: false,
+    route: "/docs/reference",
+    specRoute: "/openapi.json",
+    title: "API Documentation",
+    description: "Auto-generated API documentation",
+    version: "1.0.0",
+    ...userConfig.openapi
+  };
+  if (openapi.route !== void 0) validateConfigRouteSource(openapi.route, "openapi.route");
+  if (openapi.specRoute) validateConfigRouteSource(openapi.specRoute, "openapi.specRoute");
+  const resolved = {
+    [FARM_RESOLVED_CUSTOM_CONTEXT]: typeof userConfig.context === "function",
+    root,
+    srcDir,
+    extends: userConfig.extends || [],
+    layers: layerResolution.layers,
+    outDir: userConfig.outDir || "dist",
+    basePath,
+    renderer: resolveFarmRenderer(userConfig.renderer),
+    preset: deploy.preset || "node-server",
+    deploy,
+    docs,
+    md,
+    mdx,
+    migrations: resolveMigrationsConfig(userConfig.migrations),
+    cron,
+    workflows: resolveWorkflowsConfig(userConfig.workflows),
+    api,
+    observability: userConfig.observability ?? false,
+    telemetry: userConfig.telemetry !== false,
+    analytics: userConfig.analytics !== false,
+    devtools: resolveFarmDevtoolsConfig(userConfig.devtools, mode),
+    storage: userConfig.storage || {},
+    schema: resolveSchemaConfig(userConfig.schema),
+    cache: userConfig.cache || {},
+    auth,
+    mcp,
+    suppressLintOnLink: userConfig.suppressLintOnLink ?? false,
+    experimental: {
+      serverComponents: false,
+      serverActions: false,
+      // Islands mode hydrates client components as islands (RFC 0003); an app can still pick
+      // isolatedClientHydration itself.
+      isolatedClientHydration: resolveFarmServerComponentsMode(userConfig.experimental?.serverComponents) === "islands" ? "enabled" : "off",
+      ppr: false,
+      ...userConfig.experimental
+    },
+    agent: resolveFarmAgentConfig(userConfig.agent, { docs: docs.enabled }),
+    desktop: desktopSetup?.desktop ?? null,
+    ...userConfig.mobile !== void 0 ? { mobileClient: true } : {},
+    plugins: [
+      ...mobileSessionPlugin ? [mobileSessionPlugin] : [],
+      ...nativeServerFnPlugin ? [nativeServerFnPlugin] : [],
+      ...resolveIntegrationPlugins(integrations),
+      ...nativeMCPPlugin ? [nativeMCPPlugin] : [],
+      ...userConfig.plugins || []
+    ],
+    integrations,
+    trailingSlash: userConfig.trailingSlash ?? false,
+    redirects: () => [...redirects, ...routeRuleRedirects],
+    rewrites: () => rewrites,
+    headers: () => [
+      ...headers,
+      ...routeRuleHeaders,
+      ...securityHeader ? [{ source: "/*", headers: [securityHeader] }] : []
+    ],
+    routeRules,
+    images: resolveFarmImageConfig(userConfig.images),
+    performance: resolveFarmPerformanceConfig(userConfig.performance),
+    theme: resolveFarmThemeConfig(userConfig.theme, basePath),
+    publicDir: userConfig.publicDir || "public",
+    i18n: resolveFarmI18nConfig(userConfig.i18n, { root, mode, basePath }),
+    openapi,
+    middleware: validateMiddlewareConfig(userConfig.middleware) || {},
+    notFound: userConfig.notFound || {},
+    context: userConfig.context || (() => void 0),
+    server: resolveFarmServerConfig(userConfig.server),
+    serverActions: resolveServerActionsConfig(userConfig.serverActions),
+    security,
+    deploymentId,
+    distDir: userConfig.distDir || ".farm",
+    generateBuildId,
+    compress: userConfig.compress ?? true,
+    devIndicators: resolveFarmDevIndicatorsConfig(userConfig.devIndicators, mode),
+    serverRuntimeConfig: userConfig.serverRuntimeConfig || {},
+    publicRuntimeConfig: userConfig.publicRuntimeConfig || {},
+    env,
+    vite: typeof userConfig.vite === "function" ? userConfig.vite({}) : userConfig.vite || {}
+  };
+  assertPluginDependencies(resolved.plugins, resolved.integrations);
+  if (nativeServerFnPlugin) {
+    nativeServerFnAppDirs = (await import("./layers-T55SA47E.mjs")).getFarmAppDirectories(resolved);
+  }
+  return resolved;
+}
+function formatConfigLoadError(error) {
+  if (error && (typeof error === "object" || typeof error === "function")) {
+    for (const property of ["message", "stack", "name"]) {
+      try {
+        const value = Reflect.get(error, property);
+        if (typeof value === "string" && value) return value;
+      } catch {
+      }
+    }
+  }
+  try {
+    return String(error);
+  } catch {
+    return "Unknown config loader error";
+  }
+}
+async function loadConfig(rootDir, configPath, mode = process.env.NODE_ENV === "production" ? "production" : "development", loadEnvironment) {
+  const { existsSync } = await import("fs");
+  const loadEnv = loadEnvironment || (await import("vite")).loadEnv;
+  const root = rootDir || process.cwd();
+  const loadedEnv = loadEnv(mode, root, "");
+  for (const [key, value] of Object.entries(loadedEnv)) {
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+  if (configPath) {
+    const explicitPath = path3.resolve(
+      path3.isAbsolute(configPath) ? configPath : path3.join(root, configPath)
+    );
+    if (!existsSync(explicitPath)) {
+      throw new Error(`Config file not found at ${configPath} (resolved to ${explicitPath}).`);
+    }
+  }
+  const searchPaths = [
+    configPath,
+    "farm.config.ts",
+    "farm.config.mts",
+    "farm.config.js",
+    "farm.config.mjs",
+    "config.ts",
+    "config.mts",
+    "config.js",
+    "config.mjs"
+  ].filter(Boolean);
+  for (const relativePath of searchPaths) {
+    try {
+      const absolutePath = path3.isAbsolute(relativePath) ? relativePath : path3.join(root, relativePath);
+      const normalizedPath = path3.resolve(absolutePath);
+      if (!existsSync(normalizedPath)) {
+        continue;
+      }
+      const loadedConfig = await loadFarmConfigFile(normalizedPath, { root });
+      return loadedConfig.root === void 0 ? { ...loadedConfig, root } : loadedConfig;
+    } catch (error) {
+      const configError = new Error(
+        `Failed to load config from ${relativePath}: ${formatConfigLoadError(error)}`
+      );
+      configError.cause = error;
+      throw configError;
+    }
+  }
+  return void 0;
+}
+
+export {
+  resolveFarmMCPConfig,
+  resolveFarmMCPPlugin,
+  hasCustomFarmRouteContext,
+  isResolvedFarmConfig,
+  normalizeDeployTarget,
+  getPresetForDeployTarget,
+  getDeployTargetForPreset,
+  getDefaultDeployOutputDir,
+  resolveDeployOutputPath,
+  resolveDeployConfig,
+  resolveMigrationsConfig,
+  resolveDocsConfig,
+  resolveConfig,
+  loadConfig
+};