@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-K6FNHVDR.cjs

@@ -0,0 +1,696 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkJDNHKPTDcjs = require('./chunk-JDNHKPTD.cjs');
+
+
+
+var _chunkCMGMGHUZcjs = require('./chunk-CMGMGHUZ.cjs');
+
+
+
+
+var _chunkEM6SBQKMcjs = require('./chunk-EM6SBQKM.cjs');
+
+
+var _chunk5QIKR7RRcjs = require('./chunk-5QIKR7RR.cjs');
+
+
+var _chunkQNPEUFHQcjs = require('./chunk-QNPEUFHQ.cjs');
+
+
+var _chunkDVM4FKZLcjs = require('./chunk-DVM4FKZL.cjs');
+
+
+var _chunkUS2QVW3Ecjs = require('./chunk-US2QVW3E.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/workflows.ts
+
+
+
+
+
+
+var _path = require('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"
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineWorkflow, "defineWorkflow");
+function defineTask(definition) {
+  return defineWorkflow(definition);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineTask, "defineTask");
+function defineCron(definition) {
+  return {
+    ...definition,
+    kind: "farm-workflow"
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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: _nullishCoalesce(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
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, discoverFarmWorkflows, "discoverFarmWorkflows");
+function createFarmWorkflowRequestHandler(options) {
+  const workflowsById = new Map(options.workflows.map((workflow) => [workflow.id, workflow]));
+  return /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, 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 = _chunkUS2QVW3Ecjs.decodeRouteSegment.call(void 0, 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,
+        _chunkEM6SBQKMcjs.resolveFarmServerConfig.call(void 0, options.server).bodySizeLimit
+      );
+    } catch (error) {
+      const response = _chunkEM6SBQKMcjs.createFarmRequestBodyErrorResponse.call(void 0, 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: _nullishCoalesce(result, () => ( null))
+    });
+  }, "handleFarmWorkflowRequest");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmWorkflowRequestHandler, "createFarmWorkflowRequestHandler");
+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
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, runFarmWorkflowModule, "runFarmWorkflowModule");
+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 = _chunk5QIKR7RRcjs.toPosixPath.call(void 0, 
+      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 = _chunk5QIKR7RRcjs.toPosixPath.call(void 0, path.join(generatedDir, "http-handler.mjs"));
+  await fs.writeFile(
+    handlerPath,
+    createNitroWorkflowHTTPHandler(
+      workflowConfig,
+      workflows,
+      _chunkEM6SBQKMcjs.resolveFarmServerConfig.call(void 0, 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
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, prepareFarmWorkflowsForNitro, "prepareFarmWorkflowsForNitro");
+function createFarmWorkflowVercelCrons(workflows) {
+  return workflows.flatMap(
+    (workflow) => workflow.schedule.map((schedule) => ({
+      path: workflow.routePath,
+      schedule
+    }))
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyFarmWorkflowVercelCrons, "applyFarmWorkflowVercelCrons");
+function isResolvedWorkflowConfig(value) {
+  return !!value && typeof value === "object" && "dirs" in value && Array.isArray(value.dirs) && typeof value.route === "string";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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(normalizeWorkflowDir).filter(Boolean))];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeWorkflowDirs, "normalizeWorkflowDirs");
+function normalizeWorkflowDir(value) {
+  const dir = value.trim();
+  if (!dir) return "";
+  return _path.isAbsolute.call(void 0, dir) ? _path.normalize.call(void 0, dir) : trimSlashes(dir);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeWorkflowDir, "normalizeWorkflowDir");
+function normalizeWorkflowRoute(route) {
+  const trimmed = route.trim();
+  if (!trimmed || trimmed === "/") return DEFAULT_FARM_WORKFLOW_ROUTE;
+  const normalized = `/${trimSlashes(trimmed)}`;
+  _chunkDVM4FKZLcjs.validateConfigRouteSource.call(void 0, normalized, "workflows.route");
+  return normalized;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeWorkflowId, "normalizeWorkflowId");
+function normalizeSchedule(schedule) {
+  if (!schedule) return [];
+  return (Array.isArray(schedule) ? schedule : [schedule]).map((value) => value.trim()).filter(Boolean);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeSchedule, "normalizeSchedule");
+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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveWorkflowDefinition, "resolveWorkflowDefinition");
+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();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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);
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, walkWorkflowDir, "walkWorkflowDir");
+async function pathExists(filePath) {
+  const fs = await import("fs/promises");
+  return fs.access(filePath).then(() => true).catch(() => false);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, pathExists, "pathExists");
+function isWorkflowFile(fileName) {
+  return /\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(fileName) && !/\.d\.[cm]?ts$/.test(fileName);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loadWorkflowModule, "loadWorkflowModule");
+function workflowIdFromFile(root, dirs, filePath) {
+  for (const dir of dirs) {
+    const scanRoot = _path.isAbsolute.call(void 0, dir) ? dir : _path.resolve.call(void 0, root, dir);
+    const candidate = _path.relative.call(void 0, scanRoot, filePath);
+    if (candidate && candidate !== ".." && !candidate.startsWith(`..${_path.sep}`)) {
+      return normalizeWorkflowId(candidate);
+    }
+  }
+  return normalizeWorkflowId(_path.relative.call(void 0, root, filePath));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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
+    ])
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createScheduledTasks, "createScheduledTasks");
+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();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createNitroTaskWrapper, "createNitroTaskWrapper");
+function createNitroWorkflowHTTPHandler(config, workflows, server) {
+  return `
+import { H3 } from "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();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createNitroWorkflowHTTPHandler, "createNitroWorkflowHTTPHandler");
+function toWorkflowMetadata(workflow) {
+  return {
+    id: workflow.id,
+    description: workflow.description || null,
+    schedule: workflow.schedule,
+    timezone: workflow.timezone || null,
+    path: workflow.routePath
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toWorkflowMetadata, "toWorkflowMetadata");
+async function readWorkflowPayload(request, bodySizeLimit) {
+  const url = new URL(request.url);
+  if (request.method === "GET" || request.method === "HEAD") {
+    return _chunkQNPEUFHQcjs.searchParamsToObject.call(void 0, url.searchParams);
+  }
+  const bytes = await _chunkEM6SBQKMcjs.readFarmRequestBody.call(void 0, 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 };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readWorkflowPayload, "readWorkflowPayload");
+function readScheduledTime(payload) {
+  return payload && typeof payload === "object" && "scheduledTime" in payload ? payload.scheduledTime : void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readScheduledTime, "readScheduledTime");
+function verifyWorkflowSecret(request, config) {
+  const secret = config.secret || _chunkCMGMGHUZcjs.readFarmEnvironmentValue.call(void 0, config.secretEnv) || "";
+  if (!secret) {
+    if (config.allowUnsecured === true || !_chunkCMGMGHUZcjs.isFarmDeployedRuntime.call(void 0, )) return null;
+    return Response.json(
+      {
+        error: MISSING_FARM_WORKFLOW_SECRET_ERROR
+      },
+      { status: 401 }
+    );
+  }
+  const authorization = request.headers.get("authorization") || "";
+  const bearer = _optionalChain([authorization, 'access', _ => _.match, 'call', _2 => _2(/^Bearer\s+(.+)$/i), 'optionalAccess', _3 => _3[1]]) || "";
+  const headerSecret = request.headers.get("x-farm-workflow-secret") || "";
+  if (_chunkJDNHKPTDcjs.farmSecretsMatch.call(void 0, bearer, secret) || _chunkJDNHKPTDcjs.farmSecretsMatch.call(void 0, headerSecret, secret)) return null;
+  return Response.json({ error: "Unauthorized workflow request." }, { status: 401 });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, verifyWorkflowSecret, "verifyWorkflowSecret");
+function joinRoute(...parts) {
+  return `/${parts.map((part) => trimSlashes(part)).filter(Boolean).join("/")}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, joinRoute, "joinRoute");
+function trimSlashes(value) {
+  return value.replace(/^\/+|\/+$/g, "");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, trimSlashes, "trimSlashes");
+function resolveWorkflowWrapperFileNames(ids) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const key = safeFileName(id).toLowerCase();
+    groups.set(key, (_nullishCoalesce(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 = (_nullishCoalesce(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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveWorkflowWrapperFileNames, "resolveWorkflowWrapperFileNames");
+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");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, workflowIdFingerprint, "workflowIdFingerprint");
+function safeFileName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-") || "workflow";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, safeFileName, "safeFileName");
+function relativePath(root, filePath) {
+  return filePath.replace(/\\/g, "/").replace(`${root.replace(/\\/g, "/")}/`, "");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, relativePath, "relativePath");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_FARM_WORKFLOW_DIRS = DEFAULT_FARM_WORKFLOW_DIRS; exports.DEFAULT_FARM_WORKFLOW_ROUTE = DEFAULT_FARM_WORKFLOW_ROUTE; exports.DEFAULT_FARM_WORKFLOW_SECRET_ENV = DEFAULT_FARM_WORKFLOW_SECRET_ENV; exports.defineWorkflow = defineWorkflow; exports.defineTask = defineTask; exports.defineCron = defineCron; exports.resolveWorkflowsConfig = resolveWorkflowsConfig; exports.discoverFarmWorkflows = discoverFarmWorkflows; exports.createFarmWorkflowRequestHandler = createFarmWorkflowRequestHandler; exports.runFarmWorkflowModule = runFarmWorkflowModule; exports.prepareFarmWorkflowsForNitro = prepareFarmWorkflowsForNitro; exports.createFarmWorkflowVercelCrons = createFarmWorkflowVercelCrons; exports.applyFarmWorkflowVercelCrons = applyFarmWorkflowVercelCrons;