@farm.js/core 0.1.16 → 0.1.18

package/dist/workflows.cjs

@@ -1,1062 +1,41 @@
-"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);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// 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);
 
-// src/routing/specificity.ts
-var _BrowserUnstableRouteError = class _BrowserUnstableRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserUnstableRouteError";
-  }
-};
-__name(_BrowserUnstableRouteError, "BrowserUnstableRouteError");
-var BrowserUnstableRouteError = _BrowserUnstableRouteError;
-function assertBrowserStableRoutePath(pattern) {
-  if (pattern.includes("\\") || hasControlCharacter(pattern)) {
-    throw new BrowserUnstableRouteError(
-      `Route path "${pattern}" cannot contain backslashes or control characters.`
-    );
-  }
-  for (const segment of pattern.split("/").filter(Boolean)) {
-    if (segment.startsWith("(") && segment.endsWith(")") || segment.startsWith("[") && segment.endsWith("]")) {
-      continue;
-    }
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
-      throw new BrowserUnstableRouteError(
-        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
-      );
-    }
-  }
-}
-__name(assertBrowserStableRoutePath, "assertBrowserStableRoutePath");
-function hasControlCharacter(value) {
-  return Array.from(value).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  });
-}
-__name(hasControlCharacter, "hasControlCharacter");
 
-// src/server-http.ts
-var DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = 1e7;
-var DEFAULT_FARM_SERVER_HEADERS_TIMEOUT = 6e4;
-var DEFAULT_FARM_SERVER_REQUEST_TIMEOUT = 3e5;
-var DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT = 5e3;
-var DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT = 3e4;
-var MAX_FARM_SERVER_TIMEOUT = 2147483647;
-var _FarmRequestBodyError = class _FarmRequestBodyError extends Error {
-  constructor(code, status, message) {
-    super(message);
-    this.name = "FarmRequestBodyError";
-    this.code = code;
-    this.status = status;
-  }
-};
-__name(_FarmRequestBodyError, "FarmRequestBodyError");
-var FarmRequestBodyError = _FarmRequestBodyError;
-function resolveFarmServerConfig(config) {
-  const headersTimeout = parseFarmServerDuration(
-    config?.headersTimeout ?? DEFAULT_FARM_SERVER_HEADERS_TIMEOUT,
-    "server.headersTimeout"
-  );
-  const requestTimeout = parseFarmServerDuration(
-    config?.requestTimeout ?? DEFAULT_FARM_SERVER_REQUEST_TIMEOUT,
-    "server.requestTimeout"
-  );
-  if (headersTimeout > requestTimeout) {
-    throw new TypeError("server.headersTimeout must not exceed server.requestTimeout");
-  }
-  return Object.freeze({
-    bodySizeLimit: parseBodySizeLimit(
-      config?.bodySizeLimit ?? DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT,
-      "server.bodySizeLimit"
-    ),
-    trustProxy: config?.trustProxy === true,
-    headersTimeout,
-    requestTimeout,
-    keepAliveTimeout: parseFarmServerDuration(
-      config?.keepAliveTimeout ?? DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT,
-      "server.keepAliveTimeout"
-    ),
-    gracefulShutdownTimeout: parseFarmServerDuration(
-      config?.gracefulShutdownTimeout ?? DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT,
-      "server.gracefulShutdownTimeout"
-    ),
-    health: resolveFarmServerHealthConfig(config?.health)
-  });
-}
-__name(resolveFarmServerConfig, "resolveFarmServerConfig");
-function parseFarmServerDuration(value, optionName = "duration") {
-  if (typeof value === "number") {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-      throw new TypeError(`${optionName} must be a positive safe integer`);
-    }
-    if (value > MAX_FARM_SERVER_TIMEOUT) {
-      throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
-    }
-    return value;
-  }
-  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)$/);
-  if (!match) {
-    throw new TypeError(`${optionName} must be milliseconds or a duration such as "30s" or "2m"`);
-  }
-  const amount = Number(match[1]);
-  const unit = match[2];
-  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
-  const milliseconds = Math.floor(amount * multiplier);
-  if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) {
-    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
-  }
-  if (milliseconds > MAX_FARM_SERVER_TIMEOUT) {
-    throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
-  }
-  return milliseconds;
-}
-__name(parseFarmServerDuration, "parseFarmServerDuration");
-function resolveFarmServerHealthConfig(config) {
-  if (config === false || config && "enabled" in config && config.enabled === false) {
-    return Object.freeze({
-      enabled: false,
-      livenessPath: "/_farm/health/live",
-      readinessPath: "/_farm/health/ready"
-    });
-  }
-  const livenessPath = normalizeHealthPath(
-    config?.livenessPath ?? "/_farm/health/live",
-    "server.health.livenessPath"
-  );
-  const readinessPath = normalizeHealthPath(
-    config?.readinessPath ?? "/_farm/health/ready",
-    "server.health.readinessPath"
-  );
-  if (livenessPath === readinessPath) {
-    throw new TypeError("server.health livenessPath and readinessPath must be different");
-  }
-  return Object.freeze({ enabled: true, livenessPath, readinessPath });
-}
-__name(resolveFarmServerHealthConfig, "resolveFarmServerHealthConfig");
-function normalizeHealthPath(value, optionName) {
-  const path = value.trim();
-  if (!path.startsWith("/") || path.includes("?") || path.includes("#") || path.includes("*")) {
-    throw new TypeError(`${optionName} must be an absolute pathname without a query or wildcard`);
-  }
-  const normalized = path.length > 1 ? path.replace(/\/+$/, "") || "/" : path;
-  assertBrowserStableRoutePath(normalized);
-  return normalized;
-}
-__name(normalizeHealthPath, "normalizeHealthPath");
-function parseBodySizeLimit(value, optionName = "bodySizeLimit") {
-  if (typeof value === "number") {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-      throw new TypeError(`${optionName} must be a positive safe integer`);
-    }
-    return value;
-  }
-  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|kib|mib|gib)?$/);
-  if (!match) {
-    throw new TypeError(`${optionName} must be bytes or a size string such as "500kb" or "10mb"`);
-  }
-  const amount = Number(match[1]);
-  const unit = match[2] ?? "b";
-  const multiplier = {
-    b: 1,
-    kb: 1e3,
-    mb: 1e6,
-    gb: 1e9,
-    kib: 1024,
-    mib: 1048576,
-    gib: 1073741824
-  };
-  const bytes = Math.floor(amount * multiplier[unit]);
-  if (!Number.isSafeInteger(bytes) || bytes <= 0) {
-    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
-  }
-  return bytes;
-}
-__name(parseBodySizeLimit, "parseBodySizeLimit");
-async function readFarmRequestBody(request, limit) {
-  try {
-    validateContentLength(request.headers.get("content-length"), limit);
-  } catch (error) {
-    void request.body?.cancel(error).catch(() => {
-    });
-    throw error;
-  }
-  throwIfAborted(request.signal);
-  if (!request.body) return new Uint8Array();
-  const reader = request.body.getReader();
-  const chunks = [];
-  let total = 0;
-  const cancelBodyRead = /* @__PURE__ */ __name(() => {
-    void reader.cancel(request.signal.reason).catch(() => {
-    });
-  }, "cancelBodyRead");
-  request.signal.addEventListener("abort", cancelBodyRead, { once: true });
-  try {
-    while (true) {
-      throwIfAborted(request.signal);
-      const { done, value } = await reader.read();
-      throwIfAborted(request.signal);
-      if (done) break;
-      if (!value) continue;
-      total += value.byteLength;
-      if (total > limit) {
-        const error = new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
-        void reader.cancel(error).catch(() => {
-        });
-        throw error;
-      }
-      chunks.push(value);
-    }
-  } catch (error) {
-    if (request.signal.aborted) throwIfAborted(request.signal);
-    throw error;
-  } finally {
-    request.signal.removeEventListener("abort", cancelBodyRead);
-    reader.releaseLock();
-  }
-  const body = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return body;
-}
-__name(readFarmRequestBody, "readFarmRequestBody");
-function createFarmRequestBodyErrorResponse(error) {
-  if (!(error instanceof FarmRequestBodyError)) return null;
-  return new Response(error.status === 413 ? "Payload Too Large" : "Bad Request", {
-    status: error.status,
-    headers: {
-      "cache-control": "no-store",
-      "content-type": "text/plain; charset=utf-8",
-      "x-content-type-options": "nosniff"
-    }
-  });
-}
-__name(createFarmRequestBodyErrorResponse, "createFarmRequestBodyErrorResponse");
-function validateContentLength(value, limit) {
-  const contentLength = value?.trim();
-  if (!contentLength) return;
-  if (!/^\d+$/.test(contentLength)) {
-    throw new FarmRequestBodyError("INVALID_CONTENT_LENGTH", 400, "Invalid content-length header");
-  }
-  if (Number(contentLength) > limit) {
-    throw new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
-  }
-}
-__name(validateContentLength, "validateContentLength");
-function throwIfAborted(signal) {
-  if (!signal.aborted) return;
-  if (signal.reason !== void 0) throw signal.reason;
-  throw new DOMException("The operation was aborted", "AbortError");
-}
-__name(throwIfAborted, "throwIfAborted");
 
-// src/search-params.ts
-function searchParamsToObject(searchParams) {
-  const output = {};
-  searchParams.forEach((value, key) => {
-    if (key === "__proto__" || key === "constructor" || key === "prototype") return;
-    const existing = Object.prototype.hasOwnProperty.call(output, key) ? output[key] : void 0;
-    if (existing !== void 0) {
-      if (Array.isArray(existing)) {
-        existing.push(value);
-      } else {
-        output[key] = [existing, value];
-      }
-    } else {
-      output[key] = value;
-    }
-  });
-  return output;
-}
-__name(searchParamsToObject, "searchParamsToObject");
 
-// src/secret-compare.ts
-function farmSecretsMatch(provided, expected) {
-  if (typeof provided !== "string" || typeof expected !== "string") return false;
-  if (expected.length === 0) return false;
-  let mismatch = provided.length ^ expected.length;
-  const length = Math.max(provided.length, expected.length);
-  for (let index = 0; index < length; index += 1) {
-    const providedCode = index < provided.length ? provided.charCodeAt(index) : 0;
-    const expectedCode = index < expected.length ? expected.charCodeAt(index) : 0;
-    mismatch |= providedCode ^ expectedCode;
-  }
-  return mismatch === 0;
-}
-__name(farmSecretsMatch, "farmSecretsMatch");
 
-// src/utils/runtime-env.ts
-function getFarmRuntimeBindings() {
-  const runtimeBindings = globalThis.__env__;
-  return runtimeBindings && typeof runtimeBindings === "object" ? runtimeBindings : void 0;
-}
-__name(getFarmRuntimeBindings, "getFarmRuntimeBindings");
-function readFarmEnvironmentValue(name) {
-  const runtimeValue = getFarmRuntimeBindings()?.[name];
-  if (typeof runtimeValue === "string") return runtimeValue;
-  return typeof process !== "undefined" ? process.env?.[name] : void 0;
-}
-__name(readFarmEnvironmentValue, "readFarmEnvironmentValue");
-function isFarmDeployedRuntime() {
-  if (getFarmRuntimeBindings()) return true;
-  return readFarmEnvironmentValue("NODE_ENV") === "production";
-}
-__name(isFarmDeployedRuntime, "isFarmDeployedRuntime");
 
-// src/utils/decode.ts
-function decodeRouteSegment(segment) {
-  try {
-    return decodeURIComponent(segment);
-  } catch {
-    return segment;
-  }
-}
-__name(decodeRouteSegment, "decodeRouteSegment");
 
-// src/utils.ts
-function toPosixPath(filePath) {
-  return filePath.replace(/\\/g, "/");
-}
-__name(toPosixPath, "toPosixPath");
 
-// src/plugins/route-pattern.ts
-function validateConfigRouteSource(source, field = "Config route source") {
-  if (typeof source !== "string" || source.length === 0) {
-    throw new TypeError(`${field} must be a non-empty pathname pattern.`);
-  }
-  if (source.trim() !== source) {
-    throw new Error(`${field} cannot contain leading or trailing whitespace.`);
-  }
-  if (!source.startsWith("/")) {
-    throw new Error(`${field} must start with "/".`);
-  }
-  if (source.includes("?") || source.includes("#")) {
-    throw new Error(`${field} must be a pathname without a query string or hash.`);
-  }
-  if (source.includes("\\") || Array.from(source).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  })) {
-    throw new Error(`${field} cannot contain backslashes or control characters.`);
-  }
-  assertBrowserStableRoutePath(source);
-  return source;
-}
-__name(validateConfigRouteSource, "validateConfigRouteSource");
 
-// src/workflows.ts
-var import_node_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"
-  };
-}
-__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 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, 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 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 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 (0, import_node_path.isAbsolute)(dir) ? (0, import_node_path.normalize)(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(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 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, dirs, filePath) {
-  for (const dir of dirs) {
-    const scanRoot = (0, import_node_path.isAbsolute)(dir) ? dir : (0, import_node_path.resolve)(root, dir);
-    const candidate = (0, import_node_path.relative)(scanRoot, filePath);
-    if (candidate && candidate !== ".." && !candidate.startsWith(`..${import_node_path.sep}`)) {
-      return normalizeWorkflowId(candidate);
-    }
-  }
-  return normalizeWorkflowId((0, import_node_path.relative)(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" }
-  });
-}
+var _chunkK6FNHVDRcjs = require('./chunk-K6FNHVDR.cjs');
+require('./chunk-JDNHKPTD.cjs');
+require('./chunk-CMGMGHUZ.cjs');
+require('./chunk-EM6SBQKM.cjs');
+require('./chunk-5QIKR7RR.cjs');
+require('./chunk-QNPEUFHQ.cjs');
+require('./chunk-DVM4FKZL.cjs');
+require('./chunk-US2QVW3E.cjs');
+require('./chunk-BIDYX3SL.cjs');
+require('./chunk-I57LW5VZ.cjs');
+require('./chunk-NO3WWW3N.cjs');
+require('./chunk-S3JO3N4H.cjs');
 
-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");
-// 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
-});
+
+
+
+
+
+exports.DEFAULT_FARM_WORKFLOW_DIRS = _chunkK6FNHVDRcjs.DEFAULT_FARM_WORKFLOW_DIRS; exports.DEFAULT_FARM_WORKFLOW_ROUTE = _chunkK6FNHVDRcjs.DEFAULT_FARM_WORKFLOW_ROUTE; exports.DEFAULT_FARM_WORKFLOW_SECRET_ENV = _chunkK6FNHVDRcjs.DEFAULT_FARM_WORKFLOW_SECRET_ENV; exports.applyFarmWorkflowVercelCrons = _chunkK6FNHVDRcjs.applyFarmWorkflowVercelCrons; exports.createFarmWorkflowRequestHandler = _chunkK6FNHVDRcjs.createFarmWorkflowRequestHandler; exports.createFarmWorkflowVercelCrons = _chunkK6FNHVDRcjs.createFarmWorkflowVercelCrons; exports.defineCron = _chunkK6FNHVDRcjs.defineCron; exports.defineTask = _chunkK6FNHVDRcjs.defineTask; exports.defineWorkflow = _chunkK6FNHVDRcjs.defineWorkflow; exports.discoverFarmWorkflows = _chunkK6FNHVDRcjs.discoverFarmWorkflows; exports.prepareFarmWorkflowsForNitro = _chunkK6FNHVDRcjs.prepareFarmWorkflowsForNitro; exports.resolveWorkflowsConfig = _chunkK6FNHVDRcjs.resolveWorkflowsConfig; exports.runFarmWorkflowModule = _chunkK6FNHVDRcjs.runFarmWorkflowModule;