@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-TZVUF5JJ.mjs

@@ -0,0 +1,651 @@
+import {
+  isFarmDeployedRuntime,
+  readFarmEnvironmentValue
+} from "./chunk-WXFY5JIY.mjs";
+import {
+  farmSecretsMatch
+} from "./chunk-YP7YO3S3.mjs";
+import {
+  toPosixPath
+} from "./chunk-JSDV2NUN.mjs";
+import {
+  searchParamsToObject
+} from "./chunk-H3ASZDT7.mjs";
+import {
+  createFarmRequestBodyErrorResponse,
+  readFarmRequestBody,
+  resolveFarmServerConfig
+} from "./chunk-QDWMCFTH.mjs";
+import {
+  validateConfigRouteSource
+} from "./chunk-ONG4RDW3.mjs";
+import {
+  decodeRouteSegment
+} from "./chunk-OHWM2VI4.mjs";
+
+// src/workflows.ts
+import {
+  isAbsolute as isAbsolutePath,
+  normalize as normalizePath,
+  relative as relativeFilePath,
+  resolve as resolvePath,
+  sep as pathSeparator
+} from "path";
+var DEFAULT_FARM_WORKFLOW_DIRS = ["src/jobs", "src/workflows", "src/cron"];
+var DEFAULT_FARM_WORKFLOW_ROUTE = "/api/_farm/workflows";
+var DEFAULT_FARM_WORKFLOW_SECRET_ENV = "CRON_SECRET";
+var MISSING_FARM_WORKFLOW_SECRET_ERROR = "Workflow route requires a secret. Set the CRON_SECRET environment variable, configure workflows.secret, or set workflows.allowUnsecured to true.";
+function defineWorkflow(definition) {
+  return {
+    ...definition,
+    kind: "farm-workflow"
+  };
+}
+function defineTask(definition) {
+  return defineWorkflow(definition);
+}
+function defineCron(definition) {
+  return {
+    ...definition,
+    kind: "farm-workflow"
+  };
+}
+function resolveWorkflowsConfig(workflows) {
+  if (workflows === false) {
+    return {
+      enabled: false,
+      dirs: [...DEFAULT_FARM_WORKFLOW_DIRS],
+      route: DEFAULT_FARM_WORKFLOW_ROUTE,
+      secretEnv: DEFAULT_FARM_WORKFLOW_SECRET_ENV
+    };
+  }
+  const options = workflows && typeof workflows === "object" ? workflows : {};
+  const dirs = normalizeWorkflowDirs(options);
+  return {
+    enabled: options.enabled ?? true,
+    dirs,
+    route: normalizeWorkflowRoute(options.route || DEFAULT_FARM_WORKFLOW_ROUTE),
+    secretEnv: options.secretEnv || DEFAULT_FARM_WORKFLOW_SECRET_ENV,
+    secret: options.secret,
+    allowUnsecured: options.allowUnsecured === true
+  };
+}
+async function discoverFarmWorkflows(config, options = {}) {
+  const workflowConfig = isResolvedWorkflowConfig(config.workflows) ? config.workflows : resolveWorkflowsConfig(config.workflows);
+  if (!workflowConfig.enabled) return [];
+  const root = config.root || process.cwd();
+  const files = await findWorkflowFiles(root, workflowConfig.dirs);
+  const workflows = [];
+  const seenIds = /* @__PURE__ */ new Map();
+  for (const filePath of files) {
+    const module = options.loadModule ? await options.loadModule(filePath) : await loadWorkflowModule(filePath, root);
+    const definition = resolveWorkflowDefinition(module);
+    if (!definition) continue;
+    const id = normalizeWorkflowId(
+      definition.id || workflowIdFromFile(root, workflowConfig.dirs, filePath)
+    );
+    const previousPath = seenIds.get(id);
+    if (previousPath) {
+      throw new Error(
+        `Duplicate Farm workflow id "${id}" found in ${relativePath(root, previousPath)} and ${relativePath(root, filePath)}.`
+      );
+    }
+    seenIds.set(id, filePath);
+    workflows.push({
+      id,
+      filePath,
+      description: definition.description,
+      schedule: normalizeSchedule(definition.schedule),
+      timezone: definition.timezone,
+      routePath: joinRoute(workflowConfig.route, encodeURIComponent(id))
+    });
+  }
+  return workflows;
+}
+function createFarmWorkflowRequestHandler(options) {
+  const workflowsById = new Map(options.workflows.map((workflow) => [workflow.id, workflow]));
+  return async function handleFarmWorkflowRequest(request) {
+    const url = new URL(request.url);
+    const route = normalizeWorkflowRoute(options.config.route);
+    if (url.pathname !== route && !url.pathname.startsWith(`${route}/`)) {
+      return null;
+    }
+    if (url.pathname === route) {
+      const secretError2 = verifyWorkflowSecret(request, options.config);
+      if (secretError2) return secretError2;
+      return Response.json({
+        workflows: options.workflows.map(toWorkflowMetadata)
+      });
+    }
+    const id = decodeRouteSegment(url.pathname.slice(route.length + 1));
+    const secretError = verifyWorkflowSecret(request, options.config);
+    if (secretError) return secretError;
+    const workflow = workflowsById.get(id);
+    if (!workflow) {
+      return Response.json({ error: `Workflow "${id}" was not found.` }, { status: 404 });
+    }
+    let payload;
+    try {
+      payload = await readWorkflowPayload(
+        request,
+        resolveFarmServerConfig(options.server).bodySizeLimit
+      );
+    } catch (error) {
+      const response = createFarmRequestBodyErrorResponse(error);
+      if (response) return response;
+      if (error instanceof SyntaxError) {
+        return Response.json({ error: "Invalid workflow request body." }, { status: 400 });
+      }
+      throw error;
+    }
+    const module = await options.loadModule(workflow);
+    const result = await runFarmWorkflowModule(module, {
+      id: workflow.id,
+      name: workflow.id,
+      payload,
+      request,
+      scheduledTime: readScheduledTime(payload)
+    });
+    return Response.json({
+      id: workflow.id,
+      ok: true,
+      result: result ?? null
+    });
+  };
+}
+async function runFarmWorkflowModule(module, context) {
+  const definition = resolveWorkflowDefinition(module);
+  if (!definition) {
+    throw new Error(`Farm workflow "${context.id}" does not export a workflow definition.`);
+  }
+  return await definition.run({
+    id: context.id,
+    name: context.name || context.id,
+    payload: context.payload,
+    scheduledTime: context.scheduledTime,
+    request: context.request,
+    event: context.event,
+    env: context.env || process.env,
+    data: /* @__PURE__ */ new Map(),
+    log: console
+  });
+}
+async function prepareFarmWorkflowsForNitro(config) {
+  const workflowConfig = isResolvedWorkflowConfig(config.workflows) ? config.workflows : resolveWorkflowsConfig(config.workflows);
+  const root = config.root || process.cwd();
+  const distDir = config.distDir || ".farm";
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const generatedDir = path.join(root, distDir, ".nitro", "farm-workflows");
+  const workflows = await discoverFarmWorkflows({
+    root,
+    workflows: workflowConfig
+  });
+  if (workflows.length === 0) {
+    await fs.rm(generatedDir, { recursive: true, force: true });
+    return {
+      workflows,
+      tasks: {},
+      scheduledTasks: {}
+    };
+  }
+  await fs.rm(generatedDir, { recursive: true, force: true });
+  await fs.mkdir(generatedDir, { recursive: true });
+  const tasks = {};
+  const scheduledTasks = createScheduledTasks(workflows);
+  const wrapperNames = resolveWorkflowWrapperFileNames(workflows.map((workflow) => workflow.id));
+  for (const workflow of workflows) {
+    const wrapperPath = toPosixPath(
+      path.join(generatedDir, `${wrapperNames.get(workflow.id)}.mjs`)
+    );
+    await fs.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
+    tasks[workflow.id] = {
+      handler: wrapperPath,
+      description: workflow.description || `Farm workflow ${workflow.id}`
+    };
+  }
+  const handlerPath = toPosixPath(path.join(generatedDir, "http-handler.mjs"));
+  await fs.writeFile(
+    handlerPath,
+    createNitroWorkflowHTTPHandler(
+      workflowConfig,
+      workflows,
+      resolveFarmServerConfig(config.server)
+    ),
+    "utf8"
+  );
+  const manifestPath = path.join(generatedDir, "manifest.json");
+  await fs.writeFile(
+    manifestPath,
+    JSON.stringify(
+      {
+        route: workflowConfig.route,
+        secretEnv: workflowConfig.secretEnv,
+        trigger: {
+          method: "GET",
+          authorization: `Bearer $${workflowConfig.secretEnv}`
+        },
+        workflows: workflows.map(toWorkflowMetadata)
+      },
+      null,
+      2
+    ),
+    "utf8"
+  );
+  return {
+    workflows,
+    tasks,
+    scheduledTasks,
+    handlerPath,
+    manifestPath
+  };
+}
+function createFarmWorkflowVercelCrons(workflows) {
+  return workflows.flatMap(
+    (workflow) => workflow.schedule.map((schedule) => ({
+      path: workflow.routePath,
+      schedule
+    }))
+  );
+}
+function applyFarmWorkflowVercelCrons(vercelConfig, workflows) {
+  const crons = createFarmWorkflowVercelCrons(workflows);
+  if (crons.length === 0) return vercelConfig;
+  const existingCrons = Array.isArray(vercelConfig.crons) ? vercelConfig.crons : [];
+  const seen = new Set(existingCrons.map((cron) => `${cron.path}:${cron.schedule}`));
+  const nextCrons = [...existingCrons];
+  for (const cron of crons) {
+    const key = `${cron.path}:${cron.schedule}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    nextCrons.push(cron);
+  }
+  return {
+    ...vercelConfig,
+    crons: nextCrons
+  };
+}
+function isResolvedWorkflowConfig(value) {
+  return !!value && typeof value === "object" && "dirs" in value && Array.isArray(value.dirs) && typeof value.route === "string";
+}
+function normalizeWorkflowDirs(options) {
+  const rawDirs = options.dirs || (Array.isArray(options.dir) ? options.dir : options.dir ? [options.dir] : void 0);
+  const dirs = rawDirs && rawDirs.length > 0 ? rawDirs : DEFAULT_FARM_WORKFLOW_DIRS;
+  return [...new Set(dirs.map(normalizeWorkflowDir).filter(Boolean))];
+}
+function normalizeWorkflowDir(value) {
+  const dir = value.trim();
+  if (!dir) return "";
+  return isAbsolutePath(dir) ? normalizePath(dir) : trimSlashes(dir);
+}
+function normalizeWorkflowRoute(route) {
+  const trimmed = route.trim();
+  if (!trimmed || trimmed === "/") return DEFAULT_FARM_WORKFLOW_ROUTE;
+  const normalized = `/${trimSlashes(trimmed)}`;
+  validateConfigRouteSource(normalized, "workflows.route");
+  return normalized;
+}
+function normalizeWorkflowId(id) {
+  const normalized = id.replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs)$/, "").replace(/\/index$/, "").replace(/[^a-zA-Z0-9._/-]+/g, "-").replace(/^\/+|\/+$/g, "").replace(/\/+/g, "/");
+  return normalized || "workflow";
+}
+function normalizeSchedule(schedule) {
+  if (!schedule) return [];
+  return (Array.isArray(schedule) ? schedule : [schedule]).map((value) => value.trim()).filter(Boolean);
+}
+function resolveWorkflowDefinition(module) {
+  const candidates = [module.default, module.workflow, module.cron, module.task, module.job];
+  for (const candidate of candidates) {
+    if (candidate && typeof candidate === "object" && typeof candidate.run === "function") {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function findWorkflowFiles(root, dirs) {
+  const path = await import("path");
+  const files = [];
+  for (const dir of dirs) {
+    const absoluteDir = path.isAbsolute(dir) ? dir : path.join(root, dir);
+    if (!await pathExists(absoluteDir)) continue;
+    await walkWorkflowDir(absoluteDir, files);
+  }
+  return files.sort();
+}
+async function walkWorkflowDir(dir, files) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const filePath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+      await walkWorkflowDir(filePath, files);
+      continue;
+    }
+    if (isWorkflowFile(entry.name)) {
+      files.push(filePath);
+    }
+  }
+}
+async function pathExists(filePath) {
+  const fs = await import("fs/promises");
+  return fs.access(filePath).then(() => true).catch(() => false);
+}
+function isWorkflowFile(fileName) {
+  return /\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(fileName) && !/\.d\.[cm]?ts$/.test(fileName);
+}
+async function loadWorkflowModule(filePath, root) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const { pathToFileURL } = await import("url");
+  const outDir = path.join(root, ".farm", ".workflow-loader");
+  await fs.mkdir(outDir, { recursive: true });
+  const outfile = path.join(
+    outDir,
+    `workflow-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
+  );
+  const { bundleNodeModule } = await import("./node-module-bundle-7JHPPF6B.mjs");
+  await bundleNodeModule({
+    root,
+    entry: filePath,
+    outfile,
+    target: `node${process.versions.node.split(".")[0]}`,
+    externalPackages: true,
+    external: [/^@farm\.js\/core(?:\/|$)/, /^nitro(?:\/|$)/]
+  });
+  try {
+    return await import(
+      /* @vite-ignore */
+      `${pathToFileURL(outfile).href}?t=${Date.now()}`
+    );
+  } finally {
+    await fs.unlink(outfile).catch(() => void 0);
+  }
+}
+function workflowIdFromFile(root, dirs, filePath) {
+  for (const dir of dirs) {
+    const scanRoot = isAbsolutePath(dir) ? dir : resolvePath(root, dir);
+    const candidate = relativeFilePath(scanRoot, filePath);
+    if (candidate && candidate !== ".." && !candidate.startsWith(`..${pathSeparator}`)) {
+      return normalizeWorkflowId(candidate);
+    }
+  }
+  return normalizeWorkflowId(relativeFilePath(root, filePath));
+}
+function createScheduledTasks(workflows) {
+  const scheduleMap = /* @__PURE__ */ new Map();
+  for (const workflow of workflows) {
+    for (const schedule of workflow.schedule) {
+      const taskIds = scheduleMap.get(schedule) || [];
+      taskIds.push(workflow.id);
+      scheduleMap.set(schedule, taskIds);
+    }
+  }
+  return Object.fromEntries(
+    [...scheduleMap.entries()].map(([schedule, taskIds]) => [
+      schedule,
+      taskIds.length === 1 ? taskIds[0] : taskIds
+    ])
+  );
+}
+function createNitroTaskWrapper(workflow) {
+  const normalizedPath = workflow.filePath.replace(/\\/g, "/");
+  return `
+import { defineTask } from "nitro/task";
+import { runFarmWorkflowModule } from "@farm.js/core/workflows";
+import * as workflowModule from ${JSON.stringify(normalizedPath)};
+
+export default defineTask({
+  meta: {
+    description: ${JSON.stringify(workflow.description || `Farm workflow ${workflow.id}`)}
+  },
+  async run(event) {
+    const payload = event?.payload || {};
+    const env = event?.context?.cloudflare?.env || event?.context?.env || process.env;
+    return await runFarmWorkflowModule(workflowModule, {
+      id: ${JSON.stringify(workflow.id)},
+      name: event?.name || ${JSON.stringify(workflow.id)},
+      payload,
+      scheduledTime: payload.scheduledTime,
+      request: event?.context?.request,
+      event,
+      env
+    });
+  }
+});
+`.trim();
+}
+function createNitroWorkflowHTTPHandler(config, workflows, server) {
+  return `
+import { H3 } from "nitro/h3";
+import { runTask } from "nitro/task";
+import {
+  createFarmRequestBodyErrorResponse,
+  farmSecretsMatch,
+  readFarmRequestBody,
+  searchParamsToObject
+} from "@farm.js/core/internal/production-runtime";
+
+const route = ${JSON.stringify(config.route)};
+const secretEnv = ${JSON.stringify(config.secretEnv)};
+const inlineSecret = ${JSON.stringify(config.secret || "")};
+const allowUnsecured = ${JSON.stringify(config.allowUnsecured === true)};
+const bodySizeLimit = ${JSON.stringify(server.bodySizeLimit)};
+const workflows = ${JSON.stringify(workflows.map(toWorkflowMetadata))};
+const workflowIds = new Set(workflows.map((workflow) => workflow.id));
+
+function json(value, status = 200) {
+  return new Response(JSON.stringify(value), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+
+function decodeRouteSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+
+function getHeader(event, name) {
+  return event.req.headers.get(name);
+}
+
+function getSecret() {
+  // Match the dev-path verifyWorkflowSecret's resolution (readFarmEnvironmentValue):
+  // runtime bindings on globalThis.__env__ first, then process.env. Reading
+  // process.env alone misses a Cloudflare Workers secret, so a correctly
+  // configured deployment would see no secret and reject every request with 401.
+  const runtimeBindings = globalThis.__env__;
+  const runtimeSecret =
+    runtimeBindings && typeof runtimeBindings === "object" ? runtimeBindings[secretEnv] : undefined;
+  const resolved =
+    typeof runtimeSecret === "string"
+      ? runtimeSecret
+      : typeof process !== "undefined"
+        ? process.env?.[secretEnv]
+        : undefined;
+  return inlineSecret || resolved || "";
+}
+
+function verifySecret(event) {
+  const secret = getSecret();
+  if (!secret) {
+    if (allowUnsecured) return null;
+    return json({ error: ${JSON.stringify(MISSING_FARM_WORKFLOW_SECRET_ERROR)} }, 401);
+  }
+  const authorization = getHeader(event, "authorization") || "";
+  const headerSecret = getHeader(event, "x-farm-workflow-secret") || "";
+  const bearer = authorization.match(/^Bearer\\s+(.+)$/i)?.[1] || "";
+  if (farmSecretsMatch(headerSecret, secret) || farmSecretsMatch(bearer, secret)) return null;
+  return json({ error: "Unauthorized workflow request." }, 401);
+}
+
+async function readPayload(event) {
+  if (event.req.method === "GET" || event.req.method === "HEAD") {
+    return searchParamsToObject(event.url.searchParams);
+  }
+  const bytes = await readFarmRequestBody(event.req, bodySizeLimit);
+  const text = new TextDecoder().decode(bytes);
+  if (!text) return {};
+  const contentType = (getHeader(event, "content-type") || "").split(";", 1)[0].trim().toLowerCase();
+  if (
+    contentType === "application/json" ||
+    (contentType.startsWith("application/") && contentType.endsWith("+json"))
+  ) {
+    return JSON.parse(text);
+  }
+  return { text };
+}
+
+export default new H3()
+  .get(route, (event) => {
+    const unauthorized = verifySecret(event);
+    if (unauthorized) return unauthorized;
+    return { workflows };
+  })
+  .all(route + "/:id", async (event) => {
+    const id = decodeRouteSegment(event.context.params?.id || "");
+
+    // Verify the secret before consulting the workflow id map so the
+    // existing-vs-missing distinction is not disclosed to callers without
+    // the secret (a 401 for unknown ids would otherwise become a 404 oracle).
+    const unauthorized = verifySecret(event);
+    if (unauthorized) return unauthorized;
+
+    if (!workflowIds.has(id)) {
+      return json({ error: "Workflow " + id + " was not found." }, 404);
+    }
+
+    let payload;
+    try {
+      payload = await readPayload(event);
+    } catch (error) {
+      const response = createFarmRequestBodyErrorResponse(error);
+      if (response) return response;
+      if (error instanceof SyntaxError) return json({ error: "Invalid workflow request body." }, 400);
+      throw error;
+    }
+    const result = await runTask(id, {
+      payload,
+      context: {
+        source: "http",
+        request: event.req,
+        route,
+        url: event.url.href,
+        method: event.req.method
+      }
+    });
+    return {
+      id,
+      ok: true,
+      result: result ?? null
+    };
+  });
+`.trim();
+}
+function toWorkflowMetadata(workflow) {
+  return {
+    id: workflow.id,
+    description: workflow.description || null,
+    schedule: workflow.schedule,
+    timezone: workflow.timezone || null,
+    path: workflow.routePath
+  };
+}
+async function readWorkflowPayload(request, bodySizeLimit) {
+  const url = new URL(request.url);
+  if (request.method === "GET" || request.method === "HEAD") {
+    return searchParamsToObject(url.searchParams);
+  }
+  const bytes = await readFarmRequestBody(request, bodySizeLimit);
+  const text = new TextDecoder().decode(bytes);
+  if (!text) return {};
+  const contentType = (request.headers.get("content-type") || "").split(";", 1)[0].trim().toLowerCase();
+  if (contentType === "application/json" || contentType.startsWith("application/") && contentType.endsWith("+json")) {
+    return JSON.parse(text);
+  }
+  return { text };
+}
+function readScheduledTime(payload) {
+  return payload && typeof payload === "object" && "scheduledTime" in payload ? payload.scheduledTime : void 0;
+}
+function verifyWorkflowSecret(request, config) {
+  const secret = config.secret || readFarmEnvironmentValue(config.secretEnv) || "";
+  if (!secret) {
+    if (config.allowUnsecured === true || !isFarmDeployedRuntime()) return null;
+    return Response.json(
+      {
+        error: MISSING_FARM_WORKFLOW_SECRET_ERROR
+      },
+      { status: 401 }
+    );
+  }
+  const authorization = request.headers.get("authorization") || "";
+  const bearer = authorization.match(/^Bearer\s+(.+)$/i)?.[1] || "";
+  const headerSecret = request.headers.get("x-farm-workflow-secret") || "";
+  if (farmSecretsMatch(bearer, secret) || farmSecretsMatch(headerSecret, secret)) return null;
+  return Response.json({ error: "Unauthorized workflow request." }, { status: 401 });
+}
+function joinRoute(...parts) {
+  return `/${parts.map((part) => trimSlashes(part)).filter(Boolean).join("/")}`;
+}
+function trimSlashes(value) {
+  return value.replace(/^\/+|\/+$/g, "");
+}
+function resolveWorkflowWrapperFileNames(ids) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const key = safeFileName(id).toLowerCase();
+    groups.set(key, (groups.get(key) ?? 0) + 1);
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  const claimed = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const base = safeFileName(id);
+    const key = base.toLowerCase();
+    const fileName = (groups.get(key) ?? 0) > 1 ? `${key}-${workflowIdFingerprint(id)}` : base;
+    const claimedBy = claimed.get(fileName.toLowerCase());
+    if (claimedBy !== void 0) {
+      throw new Error(
+        `Farm workflows ${JSON.stringify(claimedBy)} and ${JSON.stringify(id)} generate the same wrapper file ${JSON.stringify(`${fileName}.mjs`)}. Rename one of them.`
+      );
+    }
+    claimed.set(fileName.toLowerCase(), id);
+    resolved.set(id, fileName);
+  }
+  return resolved;
+}
+function workflowIdFingerprint(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function safeFileName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-") || "workflow";
+}
+function relativePath(root, filePath) {
+  return filePath.replace(/\\/g, "/").replace(`${root.replace(/\\/g, "/")}/`, "");
+}
+
+export {
+  DEFAULT_FARM_WORKFLOW_DIRS,
+  DEFAULT_FARM_WORKFLOW_ROUTE,
+  DEFAULT_FARM_WORKFLOW_SECRET_ENV,
+  defineWorkflow,
+  defineTask,
+  defineCron,
+  resolveWorkflowsConfig,
+  discoverFarmWorkflows,
+  createFarmWorkflowRequestHandler,
+  runFarmWorkflowModule,
+  prepareFarmWorkflowsForNitro,
+  createFarmWorkflowVercelCrons,
+  applyFarmWorkflowVercelCrons
+};