@farm.js/core 0.1.0-beta.0

package/dist/client.mjs

@@ -0,0 +1,103 @@
+import {
+  Link,
+  createStore
+} from "./chunk-Y7A27276.mjs";
+import {
+  installChunkErrorRecovery,
+  isChunkLoadError
+} from "./chunk-SOU3Q3ZA.mjs";
+import {
+  fetchServerQuery,
+  prefetchServerQuery,
+  useServerQuery
+} from "./chunk-HXP3ZSPC.mjs";
+import {
+  IntegrationClientError,
+  createAPIClient,
+  createIntegrationApi,
+  createIntegrationClient,
+  createIntegrationClients,
+  createIntegrationServerClient,
+  createIntegrations,
+  createServerAPIClient,
+  getIntegrationAPIManifest,
+  integrationClients,
+  integrationsClient,
+  integrationsServer
+} from "./chunk-QFQRHRZS.mjs";
+import "./chunk-6XDUHOEM.mjs";
+import "./chunk-SCFX4UTD.mjs";
+import {
+  api,
+  defineIntegrationAPI,
+  defineIntegrationAPIOperation,
+  endpoint
+} from "./chunk-JK25YEN6.mjs";
+import {
+  SPARouter,
+  getRouter,
+  navigateTo,
+  prefetch,
+  pushState,
+  readPageState,
+  replaceState,
+  useBlocker,
+  useNavigation,
+  usePageState,
+  useRouter,
+  useScrollRestoration
+} from "./chunk-TU4YJICB.mjs";
+import "./chunk-ITN462YM.mjs";
+import "./chunk-B232I2GP.mjs";
+import "./chunk-GS6K5OCM.mjs";
+import "./chunk-44ZCFSKE.mjs";
+import "./chunk-ZBE6MLHL.mjs";
+import "./chunk-4PTK6KT4.mjs";
+import "./chunk-TXCFGOHW.mjs";
+import "./chunk-WZ5QFROO.mjs";
+import "./chunk-7ZY5AIJO.mjs";
+import {
+  FarmClientPluginManager,
+  createClientPluginManager
+} from "./chunk-NNLCAVB6.mjs";
+import "./chunk-CGILA3WO.mjs";
+export {
+  FarmClientPluginManager,
+  IntegrationClientError,
+  Link,
+  SPARouter,
+  api,
+  createAPIClient,
+  createClientPluginManager,
+  createIntegrationApi,
+  createIntegrationClient,
+  createIntegrationClients,
+  createIntegrationServerClient,
+  createIntegrations,
+  createServerAPIClient,
+  createStore,
+  defineIntegrationAPI,
+  defineIntegrationAPIOperation,
+  endpoint,
+  fetchServerQuery,
+  getIntegrationAPIManifest,
+  getRouter,
+  installChunkErrorRecovery,
+  integrationClients,
+  integrationsClient,
+  integrationsServer,
+  isChunkLoadError,
+  navigateTo,
+  prefetch,
+  prefetchServerQuery,
+  pushState,
+  readPageState,
+  replaceState,
+  useBlocker,
+  useNavigation,
+  usePageState,
+  useRouter,
+  useScrollRestoration,
+  useServerQuery
+};
+//# sourceMappingURL=client.mjs.map

package/dist/client.mjs.map

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

package/dist/config.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config-entry.ts
+var config_entry_exports = {};
+__export(config_entry_exports, {
+  defineConfig: () => defineConfig,
+  defineFarmConfig: () => defineFarmConfig
+});
+module.exports = __toCommonJS(config_entry_exports);
+function defineConfig(config) {
+  return config;
+}
+__name(defineConfig, "defineConfig");
+var defineFarmConfig = defineConfig;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig,
+  defineFarmConfig
+});
+//# sourceMappingURL=config.cjs.map

package/dist/config.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config-entry.ts"],"sourcesContent":["import type { FarmUserConfig } from \"./config\";\n\n/** Define a Farm application config while preserving literal types. */\nexport function defineConfig<const TConfig extends FarmUserConfig>(config: TConfig): TConfig {\n  return config;\n}\n\n/** @deprecated Use {@link defineConfig}. */\nexport const defineFarmConfig = defineConfig;\n\nexport type { FarmUserConfig };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,aAAmD,QAA0B;AAC3F,SAAO;AACT;AAFgB;AAKT,IAAM,mBAAmB;","names":[]}

package/dist/config.d.mts

@@ -0,0 +1,28 @@
+import { T as FarmUserConfig } from './client-plugins-g4bzuCmo.mjs';
+import './plugin-BJDf43dc.mjs';
+import 'react';
+import 'http';
+import './types-D1A6-XvH.mjs';
+import 'db0';
+import 'unstorage';
+import './integration-api-CHT2OKAf.mjs';
+import '@farming-labs/orm';
+import './types-C9N-nk5R.mjs';
+import '@farming-labs/docs';
+import './markdown.mjs';
+import './observability.mjs';
+import 'vite';
+import './workflows.mjs';
+import './cron.mjs';
+import './env.mjs';
+import './server-action-security.mjs';
+import './image-config-Duob7wER.mjs';
+import './types-BH1lhg5G.mjs';
+import './route-runtime-DoOHzCAD.mjs';
+
+/** Define a Farm application config while preserving literal types. */
+declare function defineConfig<const TConfig extends FarmUserConfig>(config: TConfig): TConfig;
+/** @deprecated Use {@link defineConfig}. */
+declare const defineFarmConfig: typeof defineConfig;
+
+export { FarmUserConfig, defineConfig, defineFarmConfig };

package/dist/config.d.ts

@@ -0,0 +1,28 @@
+import { T as FarmUserConfig } from './client-plugins-BZnpeTGA.js';
+import './plugin-BJDf43dc.js';
+import 'react';
+import 'http';
+import './types-D1A6-XvH.js';
+import 'db0';
+import 'unstorage';
+import './integration-api-CHT2OKAf.js';
+import '@farming-labs/orm';
+import './types-C9N-nk5R.js';
+import '@farming-labs/docs';
+import './markdown.js';
+import './observability.js';
+import 'vite';
+import './workflows.js';
+import './cron.js';
+import './env.js';
+import './server-action-security.js';
+import './image-config-Duob7wER.js';
+import './types-BH1lhg5G.js';
+import './route-runtime-DoOHzCAD.js';
+
+/** Define a Farm application config while preserving literal types. */
+declare function defineConfig<const TConfig extends FarmUserConfig>(config: TConfig): TConfig;
+/** @deprecated Use {@link defineConfig}. */
+declare const defineFarmConfig: typeof defineConfig;
+
+export { FarmUserConfig, defineConfig, defineFarmConfig };

package/dist/config.mjs

@@ -0,0 +1,10 @@
+import {
+  defineConfig,
+  defineFarmConfig
+} from "./chunk-UVCIEUJC.mjs";
+import "./chunk-CGILA3WO.mjs";
+export {
+  defineConfig,
+  defineFarmConfig
+};
+//# sourceMappingURL=config.mjs.map

package/dist/config.mjs.map

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

package/dist/cron.cjs

@@ -0,0 +1,406 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cron.ts
+var cron_exports = {};
+__export(cron_exports, {
+  DEFAULT_FARM_CRON_SECRET_ENV: () => DEFAULT_FARM_CRON_SECRET_ENV,
+  FARM_CRON_MANIFEST: () => FARM_CRON_MANIFEST,
+  applyFarmCronVercelCrons: () => applyFarmCronVercelCrons,
+  createFarmCronCloudflareConfig: () => createFarmCronCloudflareConfig,
+  createFarmCronCloudflareTriggers: () => createFarmCronCloudflareTriggers,
+  createFarmCronManifest: () => createFarmCronManifest,
+  createFarmCronVercelCrons: () => createFarmCronVercelCrons,
+  cronRoute: () => cronRoute,
+  isCronRequestAuthorized: () => isCronRequestAuthorized,
+  mergeScheduledTasks: () => mergeScheduledTasks,
+  prepareFarmCronForNitro: () => prepareFarmCronForNitro,
+  resolveCronConfig: () => resolveCronConfig
+});
+module.exports = __toCommonJS(cron_exports);
+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: []
+    };
+  }
+  const jobs = [];
+  for (const [name, job] of Object.entries(cron)) {
+    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 {
+    enabled: jobs.length > 0,
+    secretEnv: DEFAULT_FARM_CRON_SECRET_ENV,
+    jobs
+  };
+}
+__name(resolveCronConfig, "resolveCronConfig");
+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");
+  if (!cron.enabled) {
+    await Promise.all([
+      fs.rm(manifestPath, { force: true }),
+      fs.rm(generatedDir, { recursive: true, force: true })
+    ]);
+    return {
+      jobs: [],
+      tasks: {},
+      scheduledTasks: {}
+    };
+  }
+  await fs.rm(generatedDir, { recursive: true, force: true });
+  await fs.mkdir(generatedDir, { recursive: true });
+  const tasks = {};
+  for (const job of cron.jobs) {
+    const taskName = getFarmCronTaskName(job.name);
+    const wrapperPath = path.join(generatedDir, `${safeFileName(job.name)}.mjs`);
+    await fs.writeFile(wrapperPath, createNitroCronTaskWrapper(job, cron.secretEnv), "utf8");
+    tasks[taskName] = {
+      handler: wrapperPath,
+      description: job.description || `Farm cron ${job.name}`
+    };
+  }
+  const manifest = createFarmCronManifest(cron);
+  await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+  await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  return {
+    jobs: cron.jobs,
+    tasks,
+    scheduledTasks: createCronScheduledTasks(cron.jobs),
+    manifestPath
+  };
+}
+__name(prepareFarmCronForNitro, "prepareFarmCronForNitro");
+function createFarmCronManifest(cron) {
+  return {
+    schemaVersion: 1,
+    secretEnv: cron.secretEnv,
+    jobs: cron.jobs.map((job) => ({
+      name: job.name,
+      schedule: job.schedule,
+      path: job.path,
+      description: job.description || null
+    }))
+  };
+}
+__name(createFarmCronManifest, "createFarmCronManifest");
+function createFarmCronVercelCrons(jobs) {
+  return jobs.flatMap(
+    (job) => job.schedule.map((schedule) => ({
+      path: job.path,
+      schedule
+    }))
+  );
+}
+__name(createFarmCronVercelCrons, "createFarmCronVercelCrons");
+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;
+}
+__name(applyFarmCronVercelCrons, "applyFarmCronVercelCrons");
+function createFarmCronCloudflareTriggers(jobs) {
+  return [...new Set(jobs.flatMap((job) => job.schedule))];
+}
+__name(createFarmCronCloudflareTriggers, "createFarmCronCloudflareTriggers");
+function createFarmCronCloudflareConfig(jobs) {
+  const crons = createFarmCronCloudflareTriggers(jobs);
+  if (crons.length === 0) return void 0;
+  return {
+    deployConfig: true,
+    wrangler: {
+      triggers: { crons }
+    }
+  };
+}
+__name(createFarmCronCloudflareConfig, "createFarmCronCloudflareConfig");
+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
+    ])
+  );
+}
+__name(mergeScheduledTasks, "mergeScheduledTasks");
+function isCronRequestAuthorized(request, options = {}) {
+  const secretEnv = options.secretEnv || DEFAULT_FARM_CRON_SECRET_ENV;
+  const secret = options.secret || readEnvironmentValue(secretEnv);
+  if (!secret) {
+    return options.allowUnsecured === true || !getFarmRuntimeBindings() && readEnvironmentValue("NODE_ENV") !== "production";
+  }
+  const authorization = request.headers.get("authorization") || "";
+  const bearer = authorization.startsWith("Bearer ") ? authorization.slice(7) : "";
+  return bearer === secret || request.headers.get("x-farm-cron-secret") === secret;
+}
+__name(isCronRequestAuthorized, "isCronRequestAuthorized");
+function cronRoute(handler, options = {}) {
+  return (request, ...args) => {
+    if (!isCronRequestAuthorized(request, options)) {
+      return Promise.resolve(
+        Response.json({ error: "Unauthorized cron request." }, { status: 401 })
+      );
+    }
+    return handler(request, ...args);
+  };
+}
+__name(cronRoute, "cronRoute");
+function normalizeCronJob(name, job) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.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
+  };
+}
+__name(normalizeCronJob, "normalizeCronJob");
+function normalizeCronPath(name, value) {
+  if (typeof value !== "string" || !value.trim().startsWith("/")) {
+    throw new TypeError(`Farm cron ${JSON.stringify(name)} path must start with "/".`);
+  }
+  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.`
+    );
+  }
+  return path.length > 1 ? path.replace(/\/+$/, "") : path;
+}
+__name(normalizeCronPath, "normalizeCronPath");
+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;
+}
+__name(normalizeCronExpression, "normalizeCronExpression");
+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);
+    }
+  }
+}
+__name(validateCronField, "validateCronField");
+function isIntegerInRange(value, minimum, maximum = Number.MAX_SAFE_INTEGER) {
+  if (!/^\d+$/.test(value)) return false;
+  const parsed = Number(value);
+  return parsed >= minimum && parsed <= maximum;
+}
+__name(isIntegerInRange, "isIntegerInRange");
+function throwInvalidCronField(name, expression, label) {
+  throw new TypeError(
+    `Farm cron ${JSON.stringify(name)} schedule ${JSON.stringify(expression)} has an invalid ${label} field.`
+  );
+}
+__name(throwInvalidCronField, "throwInvalidCronField");
+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;
+}
+__name(isResolvedCronConfig, "isResolvedCronConfig");
+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;
+}
+__name(createCronScheduledTasks, "createCronScheduledTasks");
+function mergeTaskNames(current, taskName) {
+  if (!current) return taskName;
+  const names = Array.isArray(current) ? current : [current];
+  return names.includes(taskName) ? names : [...names, taskName];
+}
+__name(mergeTaskNames, "mergeTaskNames");
+function getFarmCronTaskName(name) {
+  return `farm:cron:${name}`;
+}
+__name(getFarmCronTaskName, "getFarmCronTaskName");
+function createNitroCronTaskWrapper(job, secretEnv) {
+  return `
+import { defineTask, useNitroApp } from "nitro/runtime";
+
+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();
+}
+__name(createNitroCronTaskWrapper, "createNitroCronTaskWrapper");
+function readEnvironmentValue(name) {
+  const runtimeValue = getFarmRuntimeBindings()?.[name];
+  if (typeof runtimeValue === "string") return runtimeValue;
+  return typeof process !== "undefined" ? process.env?.[name] : void 0;
+}
+__name(readEnvironmentValue, "readEnvironmentValue");
+function getFarmRuntimeBindings() {
+  const runtimeBindings = globalThis.__env__;
+  return runtimeBindings && typeof runtimeBindings === "object" ? runtimeBindings : void 0;
+}
+__name(getFarmRuntimeBindings, "getFarmRuntimeBindings");
+function safeFileName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-") || "cron";
+}
+__name(safeFileName, "safeFileName");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FARM_CRON_SECRET_ENV,
+  FARM_CRON_MANIFEST,
+  applyFarmCronVercelCrons,
+  createFarmCronCloudflareConfig,
+  createFarmCronCloudflareTriggers,
+  createFarmCronManifest,
+  createFarmCronVercelCrons,
+  cronRoute,
+  isCronRequestAuthorized,
+  mergeScheduledTasks,
+  prepareFarmCronForNitro,
+  resolveCronConfig
+});
+//# sourceMappingURL=cron.cjs.map