@farm.js/core 0.1.0-beta.0

package/dist/vite.d.mts

@@ -0,0 +1,21 @@
+import 'vite';
+export { d as defineConfig, cZ as farmI18nClientBridgePlugin, f as farmPlugin, c_ as rewriteEarlySsrRelativeImports } from './client-plugins-g4bzuCmo.mjs';
+import './plugin-BJDf43dc.mjs';
+import 'react';
+import 'http';
+import './types-D1A6-XvH.mjs';
+import 'db0';
+import 'unstorage';
+import './integration-api-CHT2OKAf.mjs';
+import '@farming-labs/orm';
+import './types-C9N-nk5R.mjs';
+import '@farming-labs/docs';
+import './markdown.mjs';
+import './observability.mjs';
+import './workflows.mjs';
+import './cron.mjs';
+import './env.mjs';
+import './server-action-security.mjs';
+import './image-config-Duob7wER.mjs';
+import './types-BH1lhg5G.mjs';
+import './route-runtime-DoOHzCAD.mjs';

package/dist/vite.d.ts

@@ -0,0 +1,21 @@
+import 'vite';
+export { d as defineConfig, cZ as farmI18nClientBridgePlugin, f as farmPlugin, c_ as rewriteEarlySsrRelativeImports } from './client-plugins-BZnpeTGA.js';
+import './plugin-BJDf43dc.js';
+import 'react';
+import 'http';
+import './types-D1A6-XvH.js';
+import 'db0';
+import 'unstorage';
+import './integration-api-CHT2OKAf.js';
+import '@farming-labs/orm';
+import './types-C9N-nk5R.js';
+import '@farming-labs/docs';
+import './markdown.js';
+import './observability.js';
+import './workflows.js';
+import './cron.js';
+import './env.js';
+import './server-action-security.js';
+import './image-config-Duob7wER.js';
+import './types-BH1lhg5G.js';
+import './route-runtime-DoOHzCAD.js';

package/dist/vite.mjs

@@ -0,0 +1,59 @@
+import {
+  defineConfig,
+  farmI18nClientBridgePlugin,
+  farmPlugin,
+  rewriteEarlySsrRelativeImports
+} from "./chunk-CHFHNEMO.mjs";
+import "./chunk-LGHEOHBU.mjs";
+import "./chunk-ZJQNATYV.mjs";
+import "./chunk-V6WE6JSZ.mjs";
+import "./chunk-3XNTL3FQ.mjs";
+import "./chunk-BHG3LVHH.mjs";
+import "./chunk-USWZZUEH.mjs";
+import "./chunk-74YTBPTY.mjs";
+import "./chunk-7MABZJIM.mjs";
+import "./chunk-OYXO65LI.mjs";
+import "./chunk-GY2STC2S.mjs";
+import "./chunk-LLC7BNXW.mjs";
+import "./chunk-S2XHZS7W.mjs";
+import "./chunk-Y2OJJD7R.mjs";
+import "./chunk-UREJA4GZ.mjs";
+import "./chunk-AGS7UJ52.mjs";
+import "./chunk-K4667E2Q.mjs";
+import "./chunk-TRORP7E4.mjs";
+import "./chunk-7HO6AEOP.mjs";
+import "./chunk-O3HADRW6.mjs";
+import "./chunk-P7QDS5AT.mjs";
+import "./chunk-T4QJQK76.mjs";
+import "./chunk-E6EPN5BT.mjs";
+import "./chunk-QGOHVJ6J.mjs";
+import "./chunk-YHU7SS6L.mjs";
+import "./chunk-QF4PHCMA.mjs";
+import "./chunk-GN72QAIH.mjs";
+import "./chunk-FQYDHKKU.mjs";
+import "./chunk-J4FNJ5IU.mjs";
+import "./chunk-EVGBEZDF.mjs";
+import "./chunk-RHIFZZUI.mjs";
+import "./chunk-LM2YNO4U.mjs";
+import "./chunk-B6N4ZB2H.mjs";
+import "./chunk-QKVUNGAH.mjs";
+import "./chunk-QM6VV26B.mjs";
+import "./chunk-JK25YEN6.mjs";
+import "./chunk-TU4YJICB.mjs";
+import "./chunk-ITN462YM.mjs";
+import "./chunk-B232I2GP.mjs";
+import "./chunk-GS6K5OCM.mjs";
+import "./chunk-44ZCFSKE.mjs";
+import "./chunk-ZBE6MLHL.mjs";
+import "./chunk-4PTK6KT4.mjs";
+import "./chunk-TXCFGOHW.mjs";
+import "./chunk-WZ5QFROO.mjs";
+import "./chunk-7ZY5AIJO.mjs";
+import "./chunk-CGILA3WO.mjs";
+export {
+  defineConfig,
+  farmI18nClientBridgePlugin,
+  farmPlugin,
+  rewriteEarlySsrRelativeImports
+};
+//# sourceMappingURL=vite.mjs.map

package/dist/vite.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/workflows.cjs

@@ -0,0 +1,586 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/workflows.ts
+var workflows_exports = {};
+__export(workflows_exports, {
+  DEFAULT_FARM_WORKFLOW_DIRS: () => DEFAULT_FARM_WORKFLOW_DIRS,
+  DEFAULT_FARM_WORKFLOW_ROUTE: () => DEFAULT_FARM_WORKFLOW_ROUTE,
+  DEFAULT_FARM_WORKFLOW_SECRET_ENV: () => DEFAULT_FARM_WORKFLOW_SECRET_ENV,
+  applyFarmWorkflowVercelCrons: () => applyFarmWorkflowVercelCrons,
+  createFarmWorkflowRequestHandler: () => createFarmWorkflowRequestHandler,
+  createFarmWorkflowVercelCrons: () => createFarmWorkflowVercelCrons,
+  defineCron: () => defineCron,
+  defineTask: () => defineTask,
+  defineWorkflow: () => defineWorkflow,
+  discoverFarmWorkflows: () => discoverFarmWorkflows,
+  prepareFarmWorkflowsForNitro: () => prepareFarmWorkflowsForNitro,
+  resolveWorkflowsConfig: () => resolveWorkflowsConfig,
+  runFarmWorkflowModule: () => runFarmWorkflowModule
+});
+module.exports = __toCommonJS(workflows_exports);
+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";
+function defineWorkflow(definition) {
+  return {
+    ...definition,
+    kind: "farm-workflow"
+  };
+}
+__name(defineWorkflow, "defineWorkflow");
+function defineTask(definition) {
+  return defineWorkflow(definition);
+}
+__name(defineTask, "defineTask");
+function defineCron(definition) {
+  return {
+    ...definition,
+    kind: "farm-workflow"
+  };
+}
+__name(defineCron, "defineCron");
+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
+  };
+}
+__name(resolveWorkflowsConfig, "resolveWorkflowsConfig");
+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 module2 = options.loadModule ? await options.loadModule(filePath) : await loadWorkflowModule(filePath, root);
+    const definition = resolveWorkflowDefinition(module2);
+    if (!definition) continue;
+    const id = normalizeWorkflowId(definition.id || workflowIdFromFile(root, 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;
+}
+__name(discoverFarmWorkflows, "discoverFarmWorkflows");
+function createFarmWorkflowRequestHandler(options) {
+  const workflowsById = new Map(options.workflows.map((workflow) => [workflow.id, workflow]));
+  return /* @__PURE__ */ __name(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 = decodeURIComponent(url.pathname.slice(route.length + 1));
+    const workflow = workflowsById.get(id);
+    if (!workflow) {
+      return Response.json({ error: `Workflow "${id}" was not found.` }, { status: 404 });
+    }
+    const secretError = verifyWorkflowSecret(request, options.config);
+    if (secretError) return secretError;
+    const payload = await readWorkflowPayload(request);
+    const module2 = await options.loadModule(workflow);
+    const result = await runFarmWorkflowModule(module2, {
+      id: workflow.id,
+      name: workflow.id,
+      payload,
+      request,
+      scheduledTime: readScheduledTime(payload)
+    });
+    return Response.json({
+      id: workflow.id,
+      ok: true,
+      result: result ?? null
+    });
+  }, "handleFarmWorkflowRequest");
+}
+__name(createFarmWorkflowRequestHandler, "createFarmWorkflowRequestHandler");
+async function runFarmWorkflowModule(module2, context) {
+  const definition = resolveWorkflowDefinition(module2);
+  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
+  });
+}
+__name(runFarmWorkflowModule, "runFarmWorkflowModule");
+async function prepareFarmWorkflowsForNitro(config) {
+  const workflowConfig = isResolvedWorkflowConfig(config.workflows) ? config.workflows : resolveWorkflowsConfig(config.workflows);
+  const workflows = await discoverFarmWorkflows({
+    root: config.root,
+    workflows: workflowConfig
+  });
+  if (workflows.length === 0) {
+    return {
+      workflows,
+      tasks: {},
+      scheduledTasks: {}
+    };
+  }
+  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");
+  await fs.mkdir(generatedDir, { recursive: true });
+  const tasks = {};
+  const scheduledTasks = createScheduledTasks(workflows);
+  for (const workflow of workflows) {
+    const wrapperPath = path.join(generatedDir, `${safeFileName(workflow.id)}.mjs`);
+    await fs.writeFile(wrapperPath, createNitroTaskWrapper(workflow), "utf8");
+    tasks[workflow.id] = {
+      handler: wrapperPath,
+      description: workflow.description || `Farm workflow ${workflow.id}`
+    };
+  }
+  const handlerPath = path.join(generatedDir, "http-handler.mjs");
+  await fs.writeFile(handlerPath, createNitroWorkflowHTTPHandler(workflowConfig, workflows), "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
+  };
+}
+__name(prepareFarmWorkflowsForNitro, "prepareFarmWorkflowsForNitro");
+function createFarmWorkflowVercelCrons(workflows) {
+  return workflows.flatMap(
+    (workflow) => workflow.schedule.map((schedule) => ({
+      path: workflow.routePath,
+      schedule
+    }))
+  );
+}
+__name(createFarmWorkflowVercelCrons, "createFarmWorkflowVercelCrons");
+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
+  };
+}
+__name(applyFarmWorkflowVercelCrons, "applyFarmWorkflowVercelCrons");
+function isResolvedWorkflowConfig(value) {
+  return !!value && typeof value === "object" && "dirs" in value && Array.isArray(value.dirs) && typeof value.route === "string";
+}
+__name(isResolvedWorkflowConfig, "isResolvedWorkflowConfig");
+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((dir) => trimSlashes(dir)).filter(Boolean))];
+}
+__name(normalizeWorkflowDirs, "normalizeWorkflowDirs");
+function normalizeWorkflowRoute(route) {
+  const trimmed = route.trim();
+  if (!trimmed || trimmed === "/") return DEFAULT_FARM_WORKFLOW_ROUTE;
+  return `/${trimSlashes(trimmed)}`;
+}
+__name(normalizeWorkflowRoute, "normalizeWorkflowRoute");
+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";
+}
+__name(normalizeWorkflowId, "normalizeWorkflowId");
+function normalizeSchedule(schedule) {
+  if (!schedule) return [];
+  return (Array.isArray(schedule) ? schedule : [schedule]).map((value) => value.trim()).filter(Boolean);
+}
+__name(normalizeSchedule, "normalizeSchedule");
+function resolveWorkflowDefinition(module2) {
+  const candidates = [
+    module2.default,
+    module2.workflow,
+    module2.cron,
+    module2.task,
+    module2.job
+  ];
+  for (const candidate of candidates) {
+    if (candidate && typeof candidate === "object" && typeof candidate.run === "function") {
+      return candidate;
+    }
+  }
+  return null;
+}
+__name(resolveWorkflowDefinition, "resolveWorkflowDefinition");
+async function findWorkflowFiles(root, dirs) {
+  const fs = await import("fs/promises");
+  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();
+}
+__name(findWorkflowFiles, "findWorkflowFiles");
+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);
+    }
+  }
+}
+__name(walkWorkflowDir, "walkWorkflowDir");
+async function pathExists(filePath) {
+  const fs = await import("fs/promises");
+  return fs.access(filePath).then(() => true).catch(() => false);
+}
+__name(pathExists, "pathExists");
+function isWorkflowFile(fileName) {
+  return /\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(fileName) && !/\.d\.[cm]?ts$/.test(fileName);
+}
+__name(isWorkflowFile, "isWorkflowFile");
+async function loadWorkflowModule(filePath, root) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const { pathToFileURL } = await import("url");
+  const { build } = await import("esbuild");
+  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`
+  );
+  await build({
+    absWorkingDir: root,
+    entryPoints: [filePath],
+    outfile,
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: `node${process.versions.node.split(".")[0]}`,
+    packages: "external",
+    external: ["@farm.js/core", "@farm.js/core/*", "nitro", "nitro/*"],
+    jsx: "automatic",
+    logLevel: "silent",
+    sourcemap: "inline"
+  });
+  try {
+    return await import(
+      /* @vite-ignore */
+      `${pathToFileURL(outfile).href}?t=${Date.now()}`
+    );
+  } finally {
+    await fs.unlink(outfile).catch(() => void 0);
+  }
+}
+__name(loadWorkflowModule, "loadWorkflowModule");
+function workflowIdFromFile(root, filePath) {
+  const normalizedRoot = root.replace(/\\/g, "/");
+  const normalizedFile = filePath.replace(/\\/g, "/");
+  const relative = normalizedFile.startsWith(`${normalizedRoot}/`) ? normalizedFile.slice(normalizedRoot.length + 1) : normalizedFile;
+  return normalizeWorkflowId(
+    relative.replace(/^src\/(?:jobs|workflows|cron)\//, "").replace(/\.(tsx?|jsx?|mjs|cjs)$/, "")
+  );
+}
+__name(workflowIdFromFile, "workflowIdFromFile");
+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
+    ])
+  );
+}
+__name(createScheduledTasks, "createScheduledTasks");
+function createNitroTaskWrapper(workflow) {
+  const normalizedPath = workflow.filePath.replace(/\\/g, "/");
+  return `
+import { defineTask } from "nitro/runtime";
+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();
+}
+__name(createNitroTaskWrapper, "createNitroTaskWrapper");
+function createNitroWorkflowHTTPHandler(config, workflows) {
+  return `
+import { H3 } from "h3";
+import { runTask } from "nitro/runtime";
+
+const route = ${JSON.stringify(config.route)};
+const secretEnv = ${JSON.stringify(config.secretEnv)};
+const inlineSecret = ${JSON.stringify(config.secret || "")};
+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 getHeader(event, name) {
+  return event.req.headers.get(name);
+}
+
+function getSecret() {
+  return inlineSecret || process.env[secretEnv] || "";
+}
+
+function verifySecret(event) {
+  const secret = getSecret();
+  if (!secret) return null;
+  const authorization = getHeader(event, "authorization") || "";
+  const headerSecret = getHeader(event, "x-farm-workflow-secret") || "";
+  const querySecret = event.url.searchParams.get("secret") || "";
+  const bearer = authorization.startsWith("Bearer ") ? authorization.slice(7) : "";
+  if (headerSecret === secret || querySecret === secret || bearer === secret) return null;
+  return json({ error: "Unauthorized workflow request." }, 401);
+}
+
+async function readPayload(event) {
+  if (event.req.method === "GET" || event.req.method === "HEAD") {
+    const payload = Object.fromEntries(event.url.searchParams.entries());
+    delete payload.secret;
+    return payload;
+  }
+  return await event.req.json().catch(() => ({}));
+}
+
+export default new H3()
+  .get(route, (event) => {
+    const unauthorized = verifySecret(event);
+    if (unauthorized) return unauthorized;
+    return { workflows };
+  })
+  .all(route + "/:id", async (event) => {
+    const id = decodeURIComponent(event.context.params?.id || "");
+    if (!workflowIds.has(id)) {
+      return json({ error: "Workflow " + id + " was not found." }, 404);
+    }
+
+    const unauthorized = verifySecret(event);
+    if (unauthorized) return unauthorized;
+
+    const payload = await readPayload(event);
+    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();
+}
+__name(createNitroWorkflowHTTPHandler, "createNitroWorkflowHTTPHandler");
+function toWorkflowMetadata(workflow) {
+  return {
+    id: workflow.id,
+    description: workflow.description || null,
+    schedule: workflow.schedule,
+    timezone: workflow.timezone || null,
+    path: workflow.routePath
+  };
+}
+__name(toWorkflowMetadata, "toWorkflowMetadata");
+async function readWorkflowPayload(request) {
+  const url = new URL(request.url);
+  if (request.method === "GET" || request.method === "HEAD") {
+    const payload = Object.fromEntries(url.searchParams.entries());
+    delete payload.secret;
+    return payload;
+  }
+  const contentType = request.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await request.json().catch(() => ({}));
+  }
+  const text = await request.text().catch(() => "");
+  return text ? { text } : {};
+}
+__name(readWorkflowPayload, "readWorkflowPayload");
+function readScheduledTime(payload) {
+  return payload && typeof payload === "object" && "scheduledTime" in payload ? payload.scheduledTime : void 0;
+}
+__name(readScheduledTime, "readScheduledTime");
+function verifyWorkflowSecret(request, config) {
+  const secret = config.secret || process.env[config.secretEnv] || "";
+  if (!secret) return null;
+  const url = new URL(request.url);
+  const authorization = request.headers.get("authorization") || "";
+  const bearer = authorization.startsWith("Bearer ") ? authorization.slice(7) : "";
+  const headerSecret = request.headers.get("x-farm-workflow-secret") || "";
+  const querySecret = url.searchParams.get("secret") || "";
+  if (bearer === secret || headerSecret === secret || querySecret === secret) return null;
+  return Response.json({ error: "Unauthorized workflow request." }, { status: 401 });
+}
+__name(verifyWorkflowSecret, "verifyWorkflowSecret");
+function joinRoute(...parts) {
+  return `/${parts.map((part) => trimSlashes(part)).filter(Boolean).join("/")}`;
+}
+__name(joinRoute, "joinRoute");
+function trimSlashes(value) {
+  return value.replace(/^\/+|\/+$/g, "");
+}
+__name(trimSlashes, "trimSlashes");
+function safeFileName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-") || "workflow";
+}
+__name(safeFileName, "safeFileName");
+function relativePath(root, filePath) {
+  return filePath.replace(/\\/g, "/").replace(`${root.replace(/\\/g, "/")}/`, "");
+}
+__name(relativePath, "relativePath");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FARM_WORKFLOW_DIRS,
+  DEFAULT_FARM_WORKFLOW_ROUTE,
+  DEFAULT_FARM_WORKFLOW_SECRET_ENV,
+  applyFarmWorkflowVercelCrons,
+  createFarmWorkflowRequestHandler,
+  createFarmWorkflowVercelCrons,
+  defineCron,
+  defineTask,
+  defineWorkflow,
+  discoverFarmWorkflows,
+  prepareFarmWorkflowsForNitro,
+  resolveWorkflowsConfig,
+  runFarmWorkflowModule
+});
+//# sourceMappingURL=workflows.cjs.map