@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-DQF3QLOH.mjs

@@ -0,0 +1,660 @@
+import {
+  getFarmRuntimeBindings,
+  readFarmEnvironmentValue
+} from "./chunk-WXFY5JIY.mjs";
+import {
+  farmSecretsMatch
+} from "./chunk-YP7YO3S3.mjs";
+import {
+  toPosixPath
+} from "./chunk-JSDV2NUN.mjs";
+
+// src/cron.ts
+var DEFAULT_FARM_CRON_SECRET_ENV = "CRON_SECRET";
+var FARM_CRON_MANIFEST = "cron-manifest.json";
+var CRON_FIELD_RANGES = [
+  [0, 59, "minute"],
+  [0, 23, "hour"],
+  [1, 31, "day of month"],
+  [1, 12, "month"],
+  [0, 6, "day of week"]
+];
+function resolveCronConfig(cron) {
+  if (isResolvedCronConfig(cron)) return cron;
+  if (!cron) {
+    return {
+      enabled: false,
+      secretEnv: DEFAULT_FARM_CRON_SECRET_ENV,
+      jobs: []
+    };
+  }
+  if (typeof cron !== "object" || Array.isArray(cron)) {
+    throw new TypeError("`cron` must be a job map, { provider, jobs }, or false.");
+  }
+  let provider;
+  let entries;
+  if ("provider" in cron && (typeof cron.provider !== "object" || cron.provider === null)) {
+    if (cron.provider !== "host" && cron.provider !== "farmjs") {
+      throw new TypeError(
+        `\`cron.provider\` must be "host" (the deploy platform's scheduler) or "farmjs" (Farm.js Infra), received ${JSON.stringify(cron.provider)}.`
+      );
+    }
+    provider = cron.provider;
+    if (Object.keys(cron).some((key) => key !== "provider" && key !== "jobs")) {
+      throw new TypeError("When `cron.provider` is set, place named jobs inside `cron.jobs`.");
+    }
+    const configured = cron.jobs === void 0 ? {} : cron.jobs;
+    if (!configured || typeof configured !== "object" || Array.isArray(configured)) {
+      throw new TypeError("`cron.jobs` must be a map of job names to configurations.");
+    }
+    entries = configured;
+  } else {
+    entries = cron;
+  }
+  const jobs = [];
+  for (const [name, job] of Object.entries(entries)) {
+    if (!job || typeof job !== "object" || Array.isArray(job)) {
+      throw new TypeError(`Farm cron ${JSON.stringify(name)} must be a configuration object.`);
+    }
+    if (job.enabled === false) continue;
+    jobs.push(normalizeCronJob(name, job));
+  }
+  return {
+    ...provider ? { provider } : {},
+    enabled: jobs.length > 0,
+    secretEnv: DEFAULT_FARM_CRON_SECRET_ENV,
+    jobs
+  };
+}
+async function prepareFarmCronForNitro(config) {
+  const cron = isResolvedCronConfig(config.cron) ? config.cron : resolveCronConfig(config.cron);
+  const root = config.root || process.cwd();
+  const distDir = config.distDir || ".farm";
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const manifestPath = path.join(root, distDir, FARM_CRON_MANIFEST);
+  const generatedDir = path.join(root, distDir, ".nitro", "farm-cron");
+  const provider = cron.provider ?? "host";
+  const manifest = createFarmCronManifest(cron, provider);
+  await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+  await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  await fs.rm(generatedDir, { recursive: true, force: true });
+  if (!cron.enabled || provider === "farmjs") {
+    return {
+      jobs: cron.enabled ? cron.jobs : [],
+      tasks: {},
+      scheduledTasks: {},
+      manifestPath,
+      provider
+    };
+  }
+  await fs.mkdir(generatedDir, { recursive: true });
+  const tasks = {};
+  const wrapperNames = resolveCronWrapperFileNames(cron.jobs.map((job) => job.name));
+  for (const job of cron.jobs) {
+    const taskName = getFarmCronTaskName(job.name);
+    const wrapperPath = toPosixPath(path.join(generatedDir, `${wrapperNames.get(job.name)}.mjs`));
+    await fs.writeFile(wrapperPath, createNitroCronTaskWrapper(job, cron.secretEnv), "utf8");
+    tasks[taskName] = {
+      handler: wrapperPath,
+      description: job.description || `Farm cron ${job.name}`
+    };
+  }
+  return {
+    jobs: cron.jobs,
+    tasks,
+    scheduledTasks: createCronScheduledTasks(cron.jobs),
+    manifestPath,
+    provider: "host"
+  };
+}
+function createFarmCronManifest(cron, provider = cron.provider ?? "host") {
+  return {
+    schemaVersion: 1,
+    provider,
+    secretEnv: cron.secretEnv,
+    jobs: (cron.enabled ? cron.jobs : []).map((job) => ({
+      name: job.name,
+      schedule: job.schedule,
+      path: job.path,
+      description: job.description || null,
+      ...job.timeoutMs !== void 0 ? { timeoutMs: job.timeoutMs } : {},
+      ...job.input !== void 0 ? { input: job.input } : {}
+    }))
+  };
+}
+function createFarmCronVercelCrons(jobs) {
+  return jobs.flatMap(
+    (job) => job.schedule.map((schedule) => ({
+      path: job.path,
+      schedule
+    }))
+  );
+}
+function applyFarmCronVercelCrons(vercelConfig, jobs) {
+  const existingCrons = Array.isArray(vercelConfig.crons) ? vercelConfig.crons : [];
+  const seen = new Set(existingCrons.map((cron) => `${cron.path}:${cron.schedule}`));
+  const crons = [...existingCrons];
+  for (const cron of createFarmCronVercelCrons(jobs)) {
+    const key = `${cron.path}:${cron.schedule}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    crons.push(cron);
+  }
+  return crons.length > 0 ? { ...vercelConfig, crons } : vercelConfig;
+}
+function createFarmCronCloudflareTriggers(jobs) {
+  return [...new Set(jobs.flatMap((job) => job.schedule))];
+}
+function createFarmCronCloudflareConfig(jobs) {
+  const crons = createFarmCronCloudflareTriggers(jobs);
+  if (crons.length === 0) return void 0;
+  return {
+    deployConfig: true,
+    wrangler: {
+      triggers: { crons }
+    }
+  };
+}
+function mergeScheduledTasks(...maps) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const map of maps) {
+    for (const [schedule, taskNames] of Object.entries(map || {})) {
+      const current = merged.get(schedule) || [];
+      for (const taskName of Array.isArray(taskNames) ? taskNames : [taskNames]) {
+        if (!current.includes(taskName)) current.push(taskName);
+      }
+      merged.set(schedule, current);
+    }
+  }
+  return Object.fromEntries(
+    [...merged].map(([schedule, taskNames]) => [
+      schedule,
+      taskNames.length === 1 ? taskNames[0] : taskNames
+    ])
+  );
+}
+function isExplicitDevelopmentEnv() {
+  const nodeEnv = readFarmEnvironmentValue("NODE_ENV");
+  return nodeEnv === "development" || nodeEnv === "test";
+}
+function isCronRequestAuthorized(request, options = {}) {
+  const secretEnv = options.secretEnv || DEFAULT_FARM_CRON_SECRET_ENV;
+  const secret = options.secret || readFarmEnvironmentValue(secretEnv);
+  if (!secret) {
+    return options.allowUnsecured === true || !getFarmRuntimeBindings() && isExplicitDevelopmentEnv();
+  }
+  const authorization = request.headers.get("authorization") || "";
+  const bearer = /^Bearer (.*)$/i.exec(authorization)?.[1] || "";
+  const headerSecret = request.headers.get("x-farm-cron-secret") || "";
+  return farmSecretsMatch(bearer, secret) || farmSecretsMatch(headerSecret, secret);
+}
+var inFlightCronRuns = /* @__PURE__ */ new Set();
+function resolveCronRunControls(options) {
+  if (options.timeoutMs !== void 0 && (typeof options.timeoutMs !== "number" || !Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)) {
+    throw new TypeError(
+      `Farm cron \`timeoutMs\` must be a positive number of milliseconds; received ${JSON.stringify(options.timeoutMs)}. Remove the option or set a positive number.`
+    );
+  }
+  if (options.overlap !== void 0 && options.overlap !== "skip") {
+    throw new TypeError(
+      `Farm cron \`overlap\` only supports "skip"; received ${JSON.stringify(options.overlap)}. Remove the option to allow overlapping runs.`
+    );
+  }
+  return {
+    timeoutMs: options.timeoutMs,
+    // A fresh object is this route's identity, so unnamed routes never skip each other.
+    overlapKey: options.overlap === "skip" ? options.name ?? {} : void 0
+  };
+}
+function cronSkippedResponse() {
+  return Response.json({ skipped: true }, { status: 409 });
+}
+function cronTimeoutResponse(timeoutMs) {
+  return Response.json(
+    {
+      error: `The cron handler did not finish within its \`timeoutMs\` of ${timeoutMs} milliseconds. Raise \`timeoutMs\` or make the handler finish sooner.`
+    },
+    { status: 504 }
+  );
+}
+function isThenable(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function runCronRouteControlled(controls, controller, run, onSkip, onTimeout) {
+  const { overlapKey, timeoutMs } = controls;
+  if (overlapKey !== void 0) {
+    if (inFlightCronRuns.has(overlapKey)) return onSkip();
+    inFlightCronRuns.add(overlapKey);
+  }
+  const release = () => {
+    if (overlapKey !== void 0) inFlightCronRuns.delete(overlapKey);
+  };
+  let outcome;
+  try {
+    outcome = run();
+  } catch (error) {
+    release();
+    throw error;
+  }
+  if (!isThenable(outcome)) {
+    release();
+    return outcome;
+  }
+  const pending = Promise.resolve(outcome);
+  if (timeoutMs === void 0) return pending.finally(release);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      controller?.abort(
+        new Error(
+          `The cron handler did not finish within its \`timeoutMs\` of ${timeoutMs} milliseconds.`
+        )
+      );
+      resolve(onTimeout());
+    }, timeoutMs);
+    pending.then(
+      (value) => {
+        clearTimeout(timer);
+        release();
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        release();
+        reject(error);
+      }
+    );
+  });
+}
+function createFarmCronRequestContext(request, options, signal) {
+  const name = request.headers.get("x-farm-cron-name") || void 0;
+  const scheduledAtHeader = request.headers.get("x-farm-cron-scheduled-at")?.trim() || "";
+  const scheduledAtMs = /^\d+$/.test(scheduledAtHeader) ? Number(scheduledAtHeader) : Number.NaN;
+  const scheduledAt = Number.isSafeInteger(scheduledAtMs) ? new Date(scheduledAtMs) : void 0;
+  return {
+    ...name !== void 0 ? { name } : {},
+    ...scheduledAt !== void 0 ? { scheduledAt } : {},
+    input: options.input,
+    signal
+  };
+}
+var FARM_CRON_SIGNATURE_HEADER = "farmjs-signature";
+var CRON_SIGNATURE_VERSION = "farmjs-cron-v1";
+var CRON_SIGNATURE_WINDOW_SECONDS = 300;
+var CRON_SIGNATURE_PATTERN = /^t=(\d{1,12}),v1=([0-9a-f]{64})$/;
+function toHex(buffer) {
+  let hex = "";
+  for (const byte of new Uint8Array(buffer)) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+async function farmCronSignature(apiKey, t, pathname) {
+  const encoder = new TextEncoder();
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", encoder.encode(apiKey));
+  const key = await globalThis.crypto.subtle.importKey(
+    "raw",
+    encoder.encode(toHex(digest)),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const mac = await globalThis.crypto.subtle.sign(
+    "HMAC",
+    key,
+    encoder.encode(`${CRON_SIGNATURE_VERSION}
+${t}
+GET ${pathname}`)
+  );
+  return toHex(mac);
+}
+async function authorizeCronRequest(request, options = {}, now = Date.now()) {
+  if (isCronRequestAuthorized(request, options)) return true;
+  const header = request.headers.get(FARM_CRON_SIGNATURE_HEADER);
+  if (!header) return false;
+  if (typeof request.method !== "string" || request.method.toUpperCase() !== "GET") return false;
+  if (typeof request.url !== "string") return false;
+  const parsed = CRON_SIGNATURE_PATTERN.exec(header.trim());
+  if (!parsed) return false;
+  const t = Number(parsed[1]);
+  if (Math.abs(now / 1e3 - t) > CRON_SIGNATURE_WINDOW_SECONDS) return false;
+  const apiKey = readFarmEnvironmentValue("FARMJS_API_KEY");
+  if (!apiKey) return false;
+  let pathname;
+  try {
+    const url = new URL(request.url);
+    if (url.search) return false;
+    pathname = url.pathname;
+  } catch {
+    return false;
+  }
+  const expected = await farmCronSignature(apiKey, t, pathname);
+  return farmSecretsMatch(parsed[2], expected);
+}
+function cronRoute(handler, options = {}) {
+  const controls = resolveCronRunControls(options);
+  if (isFarmEndpoint(handler)) return guardCronEndpoint(handler, options, controls);
+  const route = handler;
+  return async (request, ...args) => {
+    if (!await authorizeCronRequest(request, options)) {
+      return unauthorizedCronResponse();
+    }
+    return runCronRouteControlled(
+      controls,
+      void 0,
+      () => route(request, ...args),
+      cronSkippedResponse,
+      () => cronTimeoutResponse(controls.timeoutMs)
+    );
+  };
+}
+function unauthorizedCronResponse() {
+  return Response.json({ error: "Unauthorized cron request." }, { status: 401 });
+}
+function isFarmEndpoint(value) {
+  return typeof value === "function" && typeof value.__handler === "function";
+}
+var FUNCTION_OWN_KEYS = /* @__PURE__ */ new Set(["length", "name", "prototype", "arguments", "caller"]);
+function guardCronEndpoint(endpoint, options, controls) {
+  const allowed = async (context) => {
+    const request = context?.request;
+    if (typeof request?.headers?.get !== "function") return false;
+    return authorizeCronRequest(request, options);
+  };
+  const withCron = (context) => {
+    const controller = new AbortController();
+    const cron = createFarmCronRequestContext(
+      context.request,
+      options,
+      controller.signal
+    );
+    const invocation = {
+      ...context,
+      context: { ...context.context, cron }
+    };
+    return { controller, invocation };
+  };
+  const guarded = async function(context) {
+    if (!await allowed(context)) return unauthorizedCronResponse();
+    const { controller, invocation } = withCron(context);
+    return runCronRouteControlled(
+      controls,
+      controller,
+      () => endpoint.call(this, invocation),
+      cronSkippedResponse,
+      () => cronTimeoutResponse(controls.timeoutMs)
+    );
+  };
+  for (const key of Reflect.ownKeys(endpoint)) {
+    if (typeof key === "string" && FUNCTION_OWN_KEYS.has(key)) continue;
+    Object.defineProperty(guarded, key, Object.getOwnPropertyDescriptor(endpoint, key));
+  }
+  guarded.__handler = async (context) => {
+    if (!await allowed(context)) return unauthorizedCronResponse();
+    const { controller, invocation } = withCron(context);
+    return runCronRouteControlled(
+      controls,
+      controller,
+      () => endpoint.__handler(invocation),
+      cronSkippedResponse,
+      () => cronTimeoutResponse(controls.timeoutMs)
+    );
+  };
+  const invoke = endpoint.__farmInvoke;
+  if (invoke) {
+    guarded.__farmInvoke = async (context) => {
+      const denied = (result) => ({
+        result,
+        context: context.context,
+        handlerExecuted: false,
+        invalidations: []
+      });
+      if (!await allowed(context)) return denied(unauthorizedCronResponse());
+      const { controller, invocation } = withCron(context);
+      return runCronRouteControlled(
+        controls,
+        controller,
+        () => invoke(invocation),
+        () => denied(cronSkippedResponse()),
+        () => denied(cronTimeoutResponse(controls.timeoutMs))
+      );
+    };
+  }
+  return guarded;
+}
+var FARM_CRON_NAME_SEGMENT_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+function normalizeCronJob(name, job) {
+  if (!FARM_CRON_NAME_SEGMENT_PATTERN.test(name)) {
+    throw new TypeError(
+      `Farm cron name ${JSON.stringify(name)} must start with a letter or number and contain only letters, numbers, dots, underscores, or hyphens.`
+    );
+  }
+  if (!job || typeof job !== "object" || Array.isArray(job)) {
+    throw new TypeError(`Farm cron ${JSON.stringify(name)} must be a configuration object.`);
+  }
+  const path = normalizeCronPath(name, job.path);
+  const rawSchedule = Array.isArray(job.schedule) ? job.schedule : [job.schedule];
+  const schedule = [...new Set(rawSchedule.map((value) => normalizeCronExpression(name, value)))];
+  if (schedule.length === 0) {
+    throw new TypeError(`Farm cron ${JSON.stringify(name)} must define at least one schedule.`);
+  }
+  return {
+    name,
+    schedule,
+    path,
+    description: job.description?.trim() || void 0
+  };
+}
+function normalizeCronPath(name, value) {
+  if (typeof value !== "string" || !value.trim().startsWith("/")) {
+    throw new TypeError(`Farm cron ${JSON.stringify(name)} path must start with "/".`);
+  }
+  const hasUnstableCharacters = (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+  if (hasUnstableCharacters(value)) {
+    throw new TypeError(
+      `Farm cron ${JSON.stringify(name)} path cannot contain backslashes or control characters.`
+    );
+  }
+  const path = value.trim();
+  if (path.startsWith("//") || path.includes("?") || path.includes("#")) {
+    throw new TypeError(
+      `Farm cron ${JSON.stringify(name)} path must be an application pathname without a host, query, or hash.`
+    );
+  }
+  for (const segment of path.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+    }
+    if (hasUnstableCharacters(decoded)) {
+      throw new TypeError(
+        `Farm cron ${JSON.stringify(name)} path cannot contain backslashes or control characters.`
+      );
+    }
+    if (decoded.includes("/")) {
+      throw new TypeError(
+        `Farm cron ${JSON.stringify(name)} path cannot contain percent-encoded path separators.`
+      );
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new TypeError(
+        `Farm cron ${JSON.stringify(name)} path cannot contain "." or ".." path segments.`
+      );
+    }
+  }
+  return path.length > 1 ? path.replace(/\/+$/, "") : path;
+}
+function normalizeCronExpression(name, value) {
+  if (typeof value !== "string") {
+    throw new TypeError(`Farm cron ${JSON.stringify(name)} schedule must be a string.`);
+  }
+  const expression = value.trim().replace(/\s+/g, " ");
+  const fields = expression.split(" ");
+  if (fields.length !== CRON_FIELD_RANGES.length) {
+    throw new TypeError(
+      `Farm cron ${JSON.stringify(name)} schedule ${JSON.stringify(expression)} must use five fields: minute hour day-of-month month day-of-week.`
+    );
+  }
+  fields.forEach((field, index) => {
+    const [minimum, maximum, label] = CRON_FIELD_RANGES[index];
+    validateCronField(name, expression, field, minimum, maximum, label);
+  });
+  if (fields[2] !== "*" && fields[4] !== "*") {
+    throw new TypeError(
+      `Farm cron ${JSON.stringify(name)} schedule ${JSON.stringify(expression)} cannot constrain both day-of-month and day-of-week.`
+    );
+  }
+  return expression;
+}
+function validateCronField(name, expression, field, minimum, maximum, label) {
+  for (const segment of field.split(",")) {
+    const [range, stepText, ...extra] = segment.split("/");
+    if (!range || extra.length > 0 || stepText !== void 0 && !isIntegerInRange(stepText, 1)) {
+      throwInvalidCronField(name, expression, label);
+    }
+    if (range === "*") continue;
+    const bounds = range.split("-");
+    if (bounds.length > 2 || !bounds.every((value) => isIntegerInRange(value, minimum, maximum))) {
+      throwInvalidCronField(name, expression, label);
+    }
+    if (bounds.length === 2 && Number(bounds[0]) > Number(bounds[1])) {
+      throwInvalidCronField(name, expression, label);
+    }
+  }
+}
+function isIntegerInRange(value, minimum, maximum = Number.MAX_SAFE_INTEGER) {
+  if (!/^\d+$/.test(value)) return false;
+  const parsed = Number(value);
+  return parsed >= minimum && parsed <= maximum;
+}
+function throwInvalidCronField(name, expression, label) {
+  throw new TypeError(
+    `Farm cron ${JSON.stringify(name)} schedule ${JSON.stringify(expression)} has an invalid ${label} field.`
+  );
+}
+function isResolvedCronConfig(value) {
+  return !!value && typeof value === "object" && "enabled" in value && typeof value.enabled === "boolean" && "jobs" in value && Array.isArray(value.jobs) && "secretEnv" in value;
+}
+function createCronScheduledTasks(jobs) {
+  const scheduledTasks = {};
+  for (const job of jobs) {
+    const taskName = getFarmCronTaskName(job.name);
+    for (const schedule of job.schedule) {
+      scheduledTasks[schedule] = mergeTaskNames(scheduledTasks[schedule], taskName);
+    }
+  }
+  return scheduledTasks;
+}
+function mergeTaskNames(current, taskName) {
+  if (!current) return taskName;
+  const names = Array.isArray(current) ? current : [current];
+  return names.includes(taskName) ? names : [...names, taskName];
+}
+function getFarmCronTaskName(name) {
+  return `farm:cron:${name}`;
+}
+function createNitroCronTaskWrapper(job, secretEnv) {
+  return `
+import { useNitroApp } from "nitro/app";
+import { defineTask } from "nitro/task";
+
+const name = ${JSON.stringify(job.name)};
+const path = ${JSON.stringify(job.path)};
+const secretEnv = ${JSON.stringify(secretEnv)};
+
+function readSecret(event) {
+  const runtimeEnv = event?.context?.cloudflare?.env || event?.context?.env || {};
+  return runtimeEnv[secretEnv] || (typeof process !== "undefined" ? process.env?.[secretEnv] : "") || "";
+}
+
+export default defineTask({
+  meta: {
+    name: ${JSON.stringify(getFarmCronTaskName(job.name))},
+    description: ${JSON.stringify(job.description || `Farm cron ${job.name}`)}
+  },
+  async run(event) {
+    const headers = new Headers({
+      "x-farm-cron-name": name,
+      "x-farm-cron-scheduled-at": String(event?.payload?.scheduledTime || Date.now())
+    });
+    const secret = readSecret(event);
+    if (secret) headers.set("authorization", "Bearer " + secret);
+
+    const response = await useNitroApp().fetch(path, { method: "GET", headers });
+    const contentType = response.headers.get("content-type") || "";
+    const body = response.status === 204
+      ? null
+      : contentType.includes("application/json")
+        ? await response.json().catch(() => null)
+        : await response.text();
+
+    if (!response.ok) {
+      const detail = typeof body === "string" ? body : JSON.stringify(body);
+      throw new Error(
+        "Farm cron " + JSON.stringify(name) + " received " + response.status +
+        " from " + path + (detail ? ": " + detail : "")
+      );
+    }
+
+    return { result: body };
+  }
+});
+`.trim();
+}
+function resolveCronWrapperFileNames(names) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const key = safeFileName(name).toLowerCase();
+    groups.set(key, (groups.get(key) ?? 0) + 1);
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  const claimed = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const base = safeFileName(name);
+    const key = base.toLowerCase();
+    const fileName = (groups.get(key) ?? 0) > 1 ? `${key}-${cronNameFingerprint(name)}` : base;
+    const claimedBy = claimed.get(fileName.toLowerCase());
+    if (claimedBy !== void 0) {
+      throw new Error(
+        `Farm cron jobs ${JSON.stringify(claimedBy)} and ${JSON.stringify(name)} generate the same wrapper file ${JSON.stringify(`${fileName}.mjs`)}. Rename one of them.`
+      );
+    }
+    claimed.set(fileName.toLowerCase(), name);
+    resolved.set(name, fileName);
+  }
+  return resolved;
+}
+function cronNameFingerprint(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function safeFileName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-") || "cron";
+}
+
+export {
+  DEFAULT_FARM_CRON_SECRET_ENV,
+  FARM_CRON_MANIFEST,
+  resolveCronConfig,
+  prepareFarmCronForNitro,
+  createFarmCronManifest,
+  createFarmCronVercelCrons,
+  applyFarmCronVercelCrons,
+  createFarmCronCloudflareTriggers,
+  createFarmCronCloudflareConfig,
+  mergeScheduledTasks,
+  isCronRequestAuthorized,
+  FARM_CRON_SIGNATURE_HEADER,
+  farmCronSignature,
+  authorizeCronRequest,
+  cronRoute,
+  FARM_CRON_NAME_SEGMENT_PATTERN,
+  normalizeCronExpression
+};