@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-Q2KB32T4.mjs

@@ -1,690 +0,0 @@
-import {
-  farmSecretsMatch
-} from "./chunk-2UC36WAC.mjs";
-import {
-  isFarmDeployedRuntime,
-  readFarmEnvironmentValue
-} from "./chunk-ONUEYC6N.mjs";
-import {
-  createFarmRequestBodyErrorResponse,
-  readFarmRequestBody,
-  resolveFarmServerConfig
-} from "./chunk-ZMMBIVQM.mjs";
-import {
-  toPosixPath
-} from "./chunk-KI3MESHB.mjs";
-import {
-  searchParamsToObject
-} from "./chunk-QVKYGNVM.mjs";
-import {
-  validateConfigRouteSource
-} from "./chunk-SAXPH6G5.mjs";
-import {
-  decodeRouteSegment
-} from "./chunk-CQ6OSQ3K.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.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"
-  };
-}
-__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,
-    allowUnsecured: options.allowUnsecured === true
-  };
-}
-__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 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;
-}
-__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 = 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
-    });
-  }, "handleFarmWorkflowRequest");
-}
-__name(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
-  });
-}
-__name(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 = 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
-  };
-}
-__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(normalizeWorkflowDir).filter(Boolean))];
-}
-__name(normalizeWorkflowDirs, "normalizeWorkflowDirs");
-function normalizeWorkflowDir(value) {
-  const dir = value.trim();
-  if (!dir) return "";
-  return isAbsolutePath(dir) ? normalizePath(dir) : trimSlashes(dir);
-}
-__name(normalizeWorkflowDir, "normalizeWorkflowDir");
-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;
-}
-__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(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;
-}
-__name(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();
-}
-__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 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-L5L7JCZ4.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);
-  }
-}
-__name(loadWorkflowModule, "loadWorkflowModule");
-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));
-}
-__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/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();
-}
-__name(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();
-}
-__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, 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 };
-}
-__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 || 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 });
-}
-__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 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;
-}
-__name(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");
-}
-__name(workflowIdFingerprint, "workflowIdFingerprint");
-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");
-
-export {
-  DEFAULT_FARM_WORKFLOW_DIRS,
-  DEFAULT_FARM_WORKFLOW_ROUTE,
-  DEFAULT_FARM_WORKFLOW_SECRET_ENV,
-  defineWorkflow,
-  defineTask,
-  defineCron,
-  resolveWorkflowsConfig,
-  discoverFarmWorkflows,
-  createFarmWorkflowRequestHandler,
-  runFarmWorkflowModule,
-  prepareFarmWorkflowsForNitro,
-  createFarmWorkflowVercelCrons,
-  applyFarmWorkflowVercelCrons
-};