@farm.js/core 0.1.17 → 0.1.18

package/dist/chunk-6EODJYCX.cjs

@@ -0,0 +1,183 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkTIWHTW3Qcjs = require('./chunk-TIWHTW3Q.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/env-types.ts
+var _fs = require('fs'); var fs = _interopRequireWildcard(_fs);
+var _path = require('path'); var path = _interopRequireWildcard(_path);
+var DEFAULT_OUT_FILE = "farm-env.d.ts";
+var CONFIG_FILENAMES = [
+  "farm.config.ts",
+  "farm.config.tsx",
+  "farm.config.mts",
+  "farm.config.cts",
+  "farm.config.js",
+  "farm.config.jsx",
+  "farm.config.mjs",
+  "farm.config.cjs",
+  "config.ts",
+  "config.tsx",
+  "config.mts",
+  "config.cts",
+  "config.js",
+  "config.jsx",
+  "config.mjs",
+  "config.cjs"
+];
+async function generateEnvTypes(options) {
+  const root = path.resolve(options.root);
+  const srcDir = options.srcDir || "src";
+  const outFile = options.outFile || DEFAULT_OUT_FILE;
+  const outPath = path.isAbsolute(outFile) ? outFile : path.join(root, srcDir, outFile);
+  const content = createEnvTypeDeclarations(options, outPath);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  _chunkTIWHTW3Qcjs.writeFileIfChanged.call(void 0, outPath, content);
+  return outPath;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, generateEnvTypes, "generateEnvTypes");
+function createEnvTypeDeclarations(options, outPath) {
+  const root = path.resolve(options.root);
+  const configPath = findConfigPath(root, options.configPath);
+  const configPaths = [
+    ...(_nullishCoalesce(options.layerConfigPaths, () => ( []))).filter((value) => fs.existsSync(value)),
+    ...configPath ? [configPath] : []
+  ];
+  const content = configPaths.length > 1 ? createLayeredConfigBackedEnvTypes(outPath, configPaths) : configPaths.length === 1 ? createConfigBackedEnvTypes(outPath, configPaths[0]) : createEmptyEnvTypes();
+  return content;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createEnvTypeDeclarations, "createEnvTypeDeclarations");
+function createLayeredConfigBackedEnvTypes(outPath, configPaths) {
+  const imports = configPaths.map(
+    (configPath, index) => `import type FarmConfig${index} from ${JSON.stringify(toTypeImportPath(outPath, configPath))};`
+  ).join("\n");
+  const resolvedTypes = configPaths.map(
+    (_configPath, index) => `
+type FarmConfigEnv${index} = typeof FarmConfig${index} extends { env?: infer TEnv }
+  ? NonNullable<TEnv>
+  : never;
+type FarmResolvedEnv${index} = [FarmConfigEnv${index}] extends [never]
+  ? { server: {}; public: {} }
+  : InferEnv<FarmConfigEnv${index}>;`
+  ).join("\n");
+  const mergedTypes = configPaths.slice(1).map(
+    (_configPath, index) => `type FarmMergedEnv${index + 1} = MergeFarmEnv<${index === 0 ? "FarmResolvedEnv0" : `FarmMergedEnv${index}`}, FarmResolvedEnv${index + 1}>;`
+  ).join("\n");
+  const finalType = `FarmMergedEnv${configPaths.length - 1}`;
+  return `/**
+ * Auto-generated env types from Farm layers and farm.config.
+ * Regenerated on dev start, build, and farm generate.
+ */
+${imports}
+import type { InferEnv } from "@farm.js/core/env";
+
+type MergeFarmEnv<TBase, TOverride> = {
+  server: Omit<TBase extends { server: infer T } ? T : {}, keyof (TOverride extends { server: infer T } ? T : {})> &
+    (TOverride extends { server: infer T } ? T : {});
+  public: Omit<TBase extends { public: infer T } ? T : {}, keyof (TOverride extends { public: infer T } ? T : {})> &
+    (TOverride extends { public: infer T } ? T : {});
+};
+${resolvedTypes}
+${mergedTypes}
+
+type FarmResolvedEnv = ${finalType};
+
+declare module "@farm.js/core/env" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+declare module "@farm.js/core" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+export {};
+`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createLayeredConfigBackedEnvTypes, "createLayeredConfigBackedEnvTypes");
+function findConfigPath(root, configPath) {
+  if (configPath) {
+    const resolvedPath = path.isAbsolute(configPath) ? configPath : path.join(root, configPath);
+    return fs.existsSync(resolvedPath) ? resolvedPath : null;
+  }
+  for (const filename of CONFIG_FILENAMES) {
+    const resolvedPath = path.join(root, filename);
+    if (fs.existsSync(resolvedPath)) {
+      return resolvedPath;
+    }
+  }
+  return null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, findConfigPath, "findConfigPath");
+function createConfigBackedEnvTypes(outPath, configPath) {
+  const configImportPath = toTypeImportPath(outPath, configPath);
+  return `/**
+ * Auto-generated env types from farm.config.
+ * Regenerated on dev start, build, and farm generate.
+ */
+import type FarmConfig from ${JSON.stringify(configImportPath)};
+import type { InferEnv } from "@farm.js/core/env";
+
+type FarmConfigEnv = typeof FarmConfig extends { env?: infer TEnv } ? NonNullable<TEnv> : never;
+type FarmResolvedEnv = [FarmConfigEnv] extends [never]
+  ? { server: {}; public: {} }
+  : InferEnv<FarmConfigEnv>;
+
+declare module "@farm.js/core/env" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+declare module "@farm.js/core" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+export {};
+`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createConfigBackedEnvTypes, "createConfigBackedEnvTypes");
+function createEmptyEnvTypes() {
+  return `/**
+ * Auto-generated env types from farm.config.
+ * Regenerated on dev start, build, and farm generate.
+ */
+declare module "@farm.js/core/env" {
+  interface FarmEnvTypes {
+    server: {};
+    public: {};
+  }
+}
+
+declare module "@farm.js/core" {
+  interface FarmEnvTypes {
+    server: {};
+    public: {};
+  }
+}
+
+export {};
+`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createEmptyEnvTypes, "createEmptyEnvTypes");
+function toTypeImportPath(outPath, targetPath) {
+  const relativePath = path.relative(path.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toTypeImportPath, "toTypeImportPath");
+
+
+
+
+exports.generateEnvTypes = generateEnvTypes; exports.createEnvTypeDeclarations = createEnvTypeDeclarations;

package/dist/chunk-6EXBPJ24.cjs

@@ -0,0 +1,434 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkJDNHKPTDcjs = require('./chunk-JDNHKPTD.cjs');
+
+
+
+var _chunkCMGMGHUZcjs = require('./chunk-CMGMGHUZ.cjs');
+
+
+var _chunk5QIKR7RRcjs = require('./chunk-5QIKR7RR.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// 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: []
+    };
+  }
+  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
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 = {};
+  const wrapperNames = resolveCronWrapperFileNames(cron.jobs.map((job) => job.name));
+  for (const job of cron.jobs) {
+    const taskName = getFarmCronTaskName(job.name);
+    const wrapperPath = _chunk5QIKR7RRcjs.toPosixPath.call(void 0, 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}`
+    };
+  }
+  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
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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
+    }))
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmCronManifest, "createFarmCronManifest");
+function createFarmCronVercelCrons(jobs) {
+  return jobs.flatMap(
+    (job) => job.schedule.map((schedule) => ({
+      path: job.path,
+      schedule
+    }))
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyFarmCronVercelCrons, "applyFarmCronVercelCrons");
+function createFarmCronCloudflareTriggers(jobs) {
+  return [...new Set(jobs.flatMap((job) => job.schedule))];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmCronCloudflareTriggers, "createFarmCronCloudflareTriggers");
+function createFarmCronCloudflareConfig(jobs) {
+  const crons = createFarmCronCloudflareTriggers(jobs);
+  if (crons.length === 0) return void 0;
+  return {
+    deployConfig: true,
+    wrangler: {
+      triggers: { crons }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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
+    ])
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergeScheduledTasks, "mergeScheduledTasks");
+function isExplicitDevelopmentEnv() {
+  const nodeEnv = _chunkCMGMGHUZcjs.readFarmEnvironmentValue.call(void 0, "NODE_ENV");
+  return nodeEnv === "development" || nodeEnv === "test";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isExplicitDevelopmentEnv, "isExplicitDevelopmentEnv");
+function isCronRequestAuthorized(request, options = {}) {
+  const secretEnv = options.secretEnv || DEFAULT_FARM_CRON_SECRET_ENV;
+  const secret = options.secret || _chunkCMGMGHUZcjs.readFarmEnvironmentValue.call(void 0, secretEnv);
+  if (!secret) {
+    return options.allowUnsecured === true || !_chunkCMGMGHUZcjs.getFarmRuntimeBindings.call(void 0, ) && isExplicitDevelopmentEnv();
+  }
+  const authorization = request.headers.get("authorization") || "";
+  const bearer = _optionalChain([/^Bearer (.*)$/i, 'access', _ => _.exec, 'call', _2 => _2(authorization), 'optionalAccess', _3 => _3[1]]) || "";
+  const headerSecret = request.headers.get("x-farm-cron-secret") || "";
+  return _chunkJDNHKPTDcjs.farmSecretsMatch.call(void 0, bearer, secret) || _chunkJDNHKPTDcjs.farmSecretsMatch.call(void 0, headerSecret, secret);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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);
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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: _optionalChain([job, 'access', _4 => _4.description, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]) || void 0
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 hasUnstableCharacters = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  }), "hasUnstableCharacters");
+  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 (e) {
+    }
+    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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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);
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isIntegerInRange, "isIntegerInRange");
+function throwInvalidCronField(name, expression, label) {
+  throw new TypeError(
+    `Farm cron ${JSON.stringify(name)} schedule ${JSON.stringify(expression)} has an invalid ${label} field.`
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createCronScheduledTasks, "createCronScheduledTasks");
+function mergeTaskNames(current, taskName) {
+  if (!current) return taskName;
+  const names = Array.isArray(current) ? current : [current];
+  return names.includes(taskName) ? names : [...names, taskName];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergeTaskNames, "mergeTaskNames");
+function getFarmCronTaskName(name) {
+  return `farm:cron:${name}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmCronTaskName, "getFarmCronTaskName");
+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();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createNitroCronTaskWrapper, "createNitroCronTaskWrapper");
+function resolveCronWrapperFileNames(names) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const key = safeFileName(name).toLowerCase();
+    groups.set(key, (_nullishCoalesce(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 = (_nullishCoalesce(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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveCronWrapperFileNames, "resolveCronWrapperFileNames");
+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");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, cronNameFingerprint, "cronNameFingerprint");
+function safeFileName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-") || "cron";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, safeFileName, "safeFileName");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_FARM_CRON_SECRET_ENV = DEFAULT_FARM_CRON_SECRET_ENV; exports.FARM_CRON_MANIFEST = FARM_CRON_MANIFEST; exports.resolveCronConfig = resolveCronConfig; exports.prepareFarmCronForNitro = prepareFarmCronForNitro; exports.createFarmCronManifest = createFarmCronManifest; exports.createFarmCronVercelCrons = createFarmCronVercelCrons; exports.applyFarmCronVercelCrons = applyFarmCronVercelCrons; exports.createFarmCronCloudflareTriggers = createFarmCronCloudflareTriggers; exports.createFarmCronCloudflareConfig = createFarmCronCloudflareConfig; exports.mergeScheduledTasks = mergeScheduledTasks; exports.isCronRequestAuthorized = isCronRequestAuthorized; exports.cronRoute = cronRoute;

package/dist/chunk-6QQDAAAZ.cjs

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/route-context.ts
+var FARM_ROUTE_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("farm.routeContext");
+async function resolveFarmRouteContext(config, input) {
+  if (typeof config.context !== "function") {
+    return void 0;
+  }
+  return config.context(input);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRouteContext, "resolveFarmRouteContext");
+function withFarmRouteContext(props, context) {
+  if (context === void 0) {
+    return props;
+  }
+  Object.defineProperty(props, FARM_ROUTE_CONTEXT_SYMBOL, {
+    value: context,
+    enumerable: false,
+    configurable: true
+  });
+  return props;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, withFarmRouteContext, "withFarmRouteContext");
+function getFarmRouteContext(props) {
+  if (!props || typeof props !== "object") {
+    return void 0;
+  }
+  return props[FARM_ROUTE_CONTEXT_SYMBOL];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRouteContext, "getFarmRouteContext");
+
+
+
+
+
+exports.resolveFarmRouteContext = resolveFarmRouteContext; exports.withFarmRouteContext = withFarmRouteContext; exports.getFarmRouteContext = getFarmRouteContext;