@farm.js/core 0.1.60 → 0.1.62

package/dist/{chunk-JBK7UJOI.cjs → chunk-AJB3DHN6.cjs}

@@ -7,7 +7,7 @@ var _chunkVVTJTMGQcjs = require('./chunk-VVTJTMGQ.cjs');
 var _chunkXVSBALOYcjs = require('./chunk-XVSBALOY.cjs');
 
 
-var _chunkNQJDO7K7cjs = require('./chunk-NQJDO7K7.cjs');
+var _chunk545WJ5UGcjs = require('./chunk-545WJ5UG.cjs');
 
 
 
@@ -114,7 +114,7 @@ async function createFarmRscViteConfig(userConfig, options) {
         server: { environmentName: "rsc" },
         config: {
           preset: options.preset,
-          outputDir: options.outputDir && _chunkNQJDO7K7cjs.resolveDeployOutputPath.call(void 0, root, options.outputDir)
+          outputDir: options.outputDir && _chunk545WJ5UGcjs.resolveDeployOutputPath.call(void 0, root, options.outputDir)
         }
       })
     ]

package/dist/{chunk-YB44NKC2.cjs → chunk-AXVRUDMB.cjs}

@@ -8,7 +8,7 @@ var _chunkKORZ6PREcjs = require('./chunk-KORZ6PRE.cjs');
 var _chunk4DCWVSL2cjs = require('./chunk-4DCWVSL2.cjs');
 
 
-var _chunkLIFUPCXWcjs = require('./chunk-LIFUPCXW.cjs');
+var _chunkCFG4QERRcjs = require('./chunk-CFG4QERR.cjs');
 
 // src/metadata-image.ts
 var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element");
@@ -129,7 +129,7 @@ async function finalizeMetadataImageResponse(body, headers, options) {
   responseHeaders.set("ETag", etag);
   responseHeaders.set("Content-Length", String(body.byteLength));
   responseHeaders.set("X-Content-Type-Options", "nosniff");
-  if (_chunkLIFUPCXWcjs.matchesFarmIfNoneMatch.call(void 0, options.ifNoneMatch, etag)) {
+  if (_chunkCFG4QERRcjs.matchesFarmIfNoneMatch.call(void 0, options.ifNoneMatch, etag)) {
     return new Response(null, { status: 304, headers: responseHeaders });
   }
   return new Response(_optionalChain([options, 'access', _5 => _5.method, 'optionalAccess', _6 => _6.toUpperCase, 'call', _7 => _7()]) === "HEAD" ? null : body, {

package/dist/{chunk-LJVNMGE3.mjs → chunk-BM2LH2JM.mjs}

@@ -1,7 +1,7 @@
 import {
   createRouteTypeDeclarations,
   generateRouteTypes
-} from "./chunk-D7LTCK3U.mjs";
+} from "./chunk-SA7MLSP4.mjs";
 import {
   readSchemaTables
 } from "./chunk-2DLGV2ZG.mjs";
@@ -17,6 +17,9 @@ import {
   mergeRouteRenderingDirectiveConfig,
   normalizeStaticPathParams
 } from "./chunk-23LVFSID.mjs";
+import {
+  FARM_NATIVE_SERVER_FN_PLUGIN
+} from "./chunk-L4RTTTVE.mjs";
 import {
   createEnvTypeDeclarations,
   generateEnvTypes
@@ -824,7 +827,9 @@ async function generateFarmTypeArtifacts(options) {
     const generator = new APITypeGenerator(appDirs);
     const apiRoutes = generator.scanAPIRoutes();
     const apiTypesPath = options.apiTypesOutFile ? resolve3(root, options.apiTypesOutFile) : join3(root, srcDir, "lib", "api.generated.ts");
-    const pluginRoutes = resolvePluginRoutes(options.plugins);
+    const pluginRoutes = resolvePluginRoutes(
+      options.plugins?.filter((plugin) => plugin.name !== FARM_NATIVE_SERVER_FN_PLUGIN)
+    );
     const configFiles = [
       ...(options.layers ?? []).map((layer) => layer.configFile).filter((file) => Boolean(file)),
       options.configPath ? resolve3(root, options.configPath) : [
@@ -928,7 +933,7 @@ async function generateFarmTypeArtifacts(options) {
     if (syncModelTypes) unifiedSections.push(syncModelTypes);
   }
   if (shouldRefreshUnifiedTypes && existsSync2(join3(root, srcDir, "native"))) {
-    const [{ scanFarmMobileAppModules }, { createFarmNativeModuleTypeDeclarations }] = await Promise.all([import("./modules-VHD7BELU.mjs"), import("./native-specs-BD7HOTMJ.mjs")]);
+    const [{ scanFarmMobileAppModules }, { createFarmNativeModuleTypeDeclarations }] = await Promise.all([import("./modules-KOKD4XS6.mjs"), import("./native-specs-LDV6IZ4N.mjs")]);
     const appModules = scanFarmMobileAppModules({ root, srcDir });
     const nativeTypes = appModules && createFarmNativeModuleTypeDeclarations(appModules.specs, { root });
     if (nativeTypes) unifiedSections.push(nativeTypes);

package/dist/{chunk-YI6FKTTN.cjs → chunk-BT4SEFLC.cjs}

@@ -28,8 +28,31 @@ function resolveCronConfig(cron) {
       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(cron)) {
+  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.`);
     }
@@ -37,6 +60,7 @@ function resolveCronConfig(cron) {
     jobs.push(normalizeCronJob(name, job));
   }
   return {
+    ...provider ? { provider } : {},
     enabled: jobs.length > 0,
     secretEnv: DEFAULT_FARM_CRON_SECRET_ENV,
     jobs
@@ -50,18 +74,21 @@ async function prepareFarmCronForNitro(config) {
   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 })
-    ]);
+  const provider = _nullishCoalesce(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: [],
+      jobs: cron.enabled ? cron.jobs : [],
       tasks: {},
-      scheduledTasks: {}
+      scheduledTasks: {},
+      manifestPath,
+      provider
     };
   }
-  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));
@@ -74,26 +101,26 @@ async function prepareFarmCronForNitro(config) {
       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
+    manifestPath,
+    provider: "host"
   };
 }
-function createFarmCronManifest(cron) {
+function createFarmCronManifest(cron, provider = _nullishCoalesce(cron.provider, () => ( "host"))) {
   return {
     schemaVersion: 1,
+    provider,
     secretEnv: cron.secretEnv,
-    jobs: cron.jobs.map((job) => ({
+    jobs: (cron.enabled ? cron.jobs : []).map((job) => ({
       name: job.name,
       schedule: job.schedule,
       path: job.path,
-      description: job.description || null
+      description: job.description || null,
+      ...job.timeoutMs !== void 0 ? { timeoutMs: job.timeoutMs } : {},
+      ...job.input !== void 0 ? { input: job.input } : {}
     }))
   };
 }
@@ -163,14 +190,161 @@ function isCronRequestAuthorized(request, options = {}) {
   const headerSecret = request.headers.get("x-farm-cron-secret") || "";
   return _chunkSHIWRBFIcjs.farmSecretsMatch.call(void 0, bearer, secret) || _chunkSHIWRBFIcjs.farmSecretsMatch.call(void 0, 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" ? _nullishCoalesce(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(() => {
+      _optionalChain([controller, 'optionalAccess', _4 => _4.abort, 'call', _5 => _5(
+        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 = _optionalChain([request, 'access', _6 => _6.headers, 'access', _7 => _7.get, 'call', _8 => _8("x-farm-cron-scheduled-at"), 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]) || "";
+  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 = _chunk2KMIJDY6cjs.readFarmEnvironmentValue.call(void 0, "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 (e) {
+    return false;
+  }
+  const expected = await farmCronSignature(apiKey, t, pathname);
+  return _chunkSHIWRBFIcjs.farmSecretsMatch.call(void 0, parsed[2], expected);
+}
 function cronRoute(handler, options = {}) {
-  if (isFarmEndpoint(handler)) return guardCronEndpoint(handler, options);
+  const controls = resolveCronRunControls(options);
+  if (isFarmEndpoint(handler)) return guardCronEndpoint(handler, options, controls);
   const route = handler;
-  return (request, ...args) => {
-    if (!isCronRequestAuthorized(request, options)) {
-      return Promise.resolve(unauthorizedCronResponse());
+  return async (request, ...args) => {
+    if (!await authorizeCronRequest(request, options)) {
+      return unauthorizedCronResponse();
     }
-    return route(request, ...args);
+    return runCronRouteControlled(
+      controls,
+      void 0,
+      () => route(request, ...args),
+      cronSkippedResponse,
+      () => cronTimeoutResponse(controls.timeoutMs)
+    );
   };
 }
 function unauthorizedCronResponse() {
@@ -180,32 +354,76 @@ 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) {
-  const allowed = (context) => {
-    const request = _optionalChain([context, 'optionalAccess', _4 => _4.request]);
-    return typeof _optionalChain([request, 'optionalAccess', _5 => _5.headers, 'optionalAccess', _6 => _6.get]) === "function" && isCronRequestAuthorized(request, options);
+function guardCronEndpoint(endpoint, options, controls) {
+  const allowed = async (context) => {
+    const request = _optionalChain([context, 'optionalAccess', _11 => _11.request]);
+    if (typeof _optionalChain([request, 'optionalAccess', _12 => _12.headers, 'optionalAccess', _13 => _13.get]) !== "function") return false;
+    return authorizeCronRequest(request, options);
   };
-  const guarded = function(context) {
-    return allowed(context) ? endpoint.call(this, context) : Promise.resolve(unauthorizedCronResponse());
+  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 = (context) => allowed(context) ? endpoint.__handler(context) : unauthorizedCronResponse();
+  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 = (context) => allowed(context) ? invoke(context) : {
-      result: unauthorizedCronResponse(),
-      context: context.context,
-      handlerExecuted: false,
-      invalidations: []
+    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 (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) {
+  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.`
     );
@@ -223,7 +441,7 @@ function normalizeCronJob(name, job) {
     name,
     schedule,
     path,
-    description: _optionalChain([job, 'access', _7 => _7.description, 'optionalAccess', _8 => _8.trim, 'call', _9 => _9()]) || void 0
+    description: _optionalChain([job, 'access', _14 => _14.description, 'optionalAccess', _15 => _15.trim, 'call', _16 => _16()]) || void 0
   };
 }
 function normalizeCronPath(name, value) {
@@ -249,7 +467,7 @@ function normalizeCronPath(name, value) {
     let decoded = segment;
     try {
       decoded = decodeURIComponent(segment);
-    } catch (e) {
+    } catch (e2) {
     }
     if (hasUnstableCharacters(decoded)) {
       throw new TypeError(
@@ -434,4 +652,9 @@ function safeFileName(value) {
 
 
 
-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;
+
+
+
+
+
+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.FARM_CRON_SIGNATURE_HEADER = FARM_CRON_SIGNATURE_HEADER; exports.farmCronSignature = farmCronSignature; exports.authorizeCronRequest = authorizeCronRequest; exports.cronRoute = cronRoute; exports.FARM_CRON_NAME_SEGMENT_PATTERN = FARM_CRON_NAME_SEGMENT_PATTERN; exports.normalizeCronExpression = normalizeCronExpression;

package/dist/{chunk-LIFUPCXW.cjs → chunk-CFG4QERR.cjs}

@@ -229,8 +229,18 @@ function withFarmRequestClientAddress(request, trustProxy, clientAddress) {
   }
   return requestWithShape;
 }
-function cloneFarmRequestWithContext(request) {
+var liveRequestClones = /* @__PURE__ */ new WeakMap();
+function cloneFarmRequest(request) {
   const cloned = request.clone();
+  if (request.body) {
+    const clones = liveRequestClones.get(request);
+    if (clones) clones.push(cloned);
+    else liveRequestClones.set(request, [cloned]);
+  }
+  return cloned;
+}
+function cloneFarmRequestWithContext(request) {
+  const cloned = cloneFarmRequest(request);
   _chunkJYT7AN37cjs.copyRequestContext.call(void 0, request, cloned);
   return cloned;
 }
@@ -420,4 +430,5 @@ function throwIfAborted(signal) {
 
 
 
-exports.createFarmNodeRequestAbortSignal = createFarmNodeRequestAbortSignal; exports.DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT; exports.createFarmWeakETag = createFarmWeakETag; exports.matchesFarmIfNoneMatch = matchesFarmIfNoneMatch; exports.resolveFarmServerConfig = resolveFarmServerConfig; exports.parseBodySizeLimit = parseBodySizeLimit; exports.withFarmRequestClientAddress = withFarmRequestClientAddress; exports.cloneFarmRequestWithContext = cloneFarmRequestWithContext; exports.bufferFarmRequestBody = bufferFarmRequestBody; exports.readFarmRequestBody = readFarmRequestBody; exports.readNodeRequestBody = readNodeRequestBody; exports.createFarmNodeRequestBodyStream = createFarmNodeRequestBodyStream; exports.createFarmRequestBodyErrorResponse = createFarmRequestBodyErrorResponse;
+
+exports.createFarmNodeRequestAbortSignal = createFarmNodeRequestAbortSignal; exports.DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT; exports.createFarmWeakETag = createFarmWeakETag; exports.matchesFarmIfNoneMatch = matchesFarmIfNoneMatch; exports.resolveFarmServerConfig = resolveFarmServerConfig; exports.parseBodySizeLimit = parseBodySizeLimit; exports.withFarmRequestClientAddress = withFarmRequestClientAddress; exports.cloneFarmRequest = cloneFarmRequest; exports.cloneFarmRequestWithContext = cloneFarmRequestWithContext; exports.bufferFarmRequestBody = bufferFarmRequestBody; exports.readFarmRequestBody = readFarmRequestBody; exports.readNodeRequestBody = readNodeRequestBody; exports.createFarmNodeRequestBodyStream = createFarmNodeRequestBodyStream; exports.createFarmRequestBodyErrorResponse = createFarmRequestBodyErrorResponse;

package/dist/{chunk-3OWVWZ6R.cjs → chunk-CLFEQGET.cjs}

@@ -6,7 +6,7 @@ var _chunkCKPTIEDXcjs = require('./chunk-CKPTIEDX.cjs');
 
 
 
-var _chunkFK25QSVCcjs = require('./chunk-FK25QSVC.cjs');
+var _chunk4P5634G6cjs = require('./chunk-4P5634G6.cjs');
 
 
 
@@ -35,20 +35,20 @@ function handleFarmFormActionRequest(request, config) {
 }
 async function runFarmFormAction(request, action) {
   if (!request.headers.has(FARM_FORM_ACTION_HEADER)) {
-    return _chunkFK25QSVCcjs.runWithServerActionRequest.call(void 0, request, action);
+    return _chunk4P5634G6cjs.runWithServerActionRequest.call(void 0, request, action);
   }
   try {
-    return await _chunkFK25QSVCcjs.runWithServerActionRequest.call(void 0, request, async () => {
+    return await _chunk4P5634G6cjs.runWithServerActionRequest.call(void 0, request, async () => {
       const value = await action();
       return {
-        [_chunkCKPTIEDXcjs.FARM_ACTION_RESULT_KEY]: { invalidations: [..._chunkFK25QSVCcjs.getServerActionInvalidations.call(void 0, )] },
+        [_chunkCKPTIEDXcjs.FARM_ACTION_RESULT_KEY]: { invalidations: [..._chunk4P5634G6cjs.getServerActionInvalidations.call(void 0, )] },
         value
       };
     });
   } catch (error) {
-    if (!_chunkFK25QSVCcjs.serializeServerFnFailure.call(void 0, error)) throw error;
+    if (!_chunk4P5634G6cjs.serializeServerFnFailure.call(void 0, error)) throw error;
     return {
-      [_chunkCKPTIEDXcjs.FARM_ACTION_RESULT_KEY]: { invalidations: [], error: _chunkFK25QSVCcjs.sanitizeServerActionError.call(void 0, error) }
+      [_chunkCKPTIEDXcjs.FARM_ACTION_RESULT_KEY]: { invalidations: [], error: _chunk4P5634G6cjs.sanitizeServerActionError.call(void 0, error) }
     };
   }
 }

package/dist/{chunk-OZK2DS44.mjs → chunk-CROAFCMW.mjs}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-D7Y63SOY.mjs";
 import {
   matchesFarmIfNoneMatch
-} from "./chunk-GFT5AHAT.mjs";
+} from "./chunk-QDWMCFTH.mjs";
 
 // src/metadata-image.ts
 var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element");

package/dist/{chunk-2KTYMMWT.mjs → chunk-DPE53XWL.mjs}

@@ -21,7 +21,7 @@ import {
 } from "./chunk-YSXTNSXS.mjs";
 import {
   matchesFarmIfNoneMatch
-} from "./chunk-GFT5AHAT.mjs";
+} from "./chunk-QDWMCFTH.mjs";
 
 // src/docs/handler.ts
 import {