@farm.js/core 0.1.61 → 0.1.63

package/dist/config.d.mts

@@ -0,0 +1,40 @@
+import { p as FarmUserConfig } from './client-plugins.d-BTF0gZm4.mjs';
+import './lifecycle.d-C2aLBOwu.mjs';
+import './route.d-BaVH3V0w.mjs';
+import './endpoint.d-BkMSCRf6.mjs';
+import './cache.mjs';
+import './renderer.mjs';
+import './deployment.mjs';
+import 'http';
+import './server-fn.mjs';
+import './server-fn-error.d-DrcH9cc1.mjs';
+import './server-query.mjs';
+import './types.d-BnIqOn9w.mjs';
+import 'db0';
+import 'unstorage';
+import './schema.mjs';
+import 'react';
+import '@farming-labs/orm';
+import '@farming-labs/docs';
+import './observability.d-B2363jB6.mjs';
+import '@opentelemetry/api';
+import 'vite';
+import './workflows.d-CRMzQZ3k.mjs';
+import './cron.mjs';
+import './env.mjs';
+import './server-action-security.mjs';
+import './layers.d-CcS42OGR.mjs';
+import 'rolldown/utils';
+import 'rolldown';
+import './image-config.d-CeDgNyX4.mjs';
+import './types.d-C41ePjvP.mjs';
+import './config.d-qt-mE8O5.mjs';
+import './types.d-DQnyD3VD.mjs';
+import './font.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,40 @@
+import { p as FarmUserConfig } from './client-plugins.d-BgPUYPc9.js';
+import './lifecycle.d-C2aLBOwu.js';
+import './route.d-DBTEqifW.js';
+import './endpoint.d-BgHn0lhl.js';
+import './cache.js';
+import './renderer.js';
+import './deployment.js';
+import 'http';
+import './server-fn.js';
+import './server-fn-error.d-DrcH9cc1.js';
+import './server-query.js';
+import './types.d-BnIqOn9w.js';
+import 'db0';
+import 'unstorage';
+import './schema.js';
+import 'react';
+import '@farming-labs/orm';
+import '@farming-labs/docs';
+import './observability.d-B2363jB6.js';
+import '@opentelemetry/api';
+import 'vite';
+import './workflows.d-CRMzQZ3k.js';
+import './cron.js';
+import './env.js';
+import './server-action-security.js';
+import './layers.d-CcS42OGR.js';
+import 'rolldown/utils';
+import 'rolldown';
+import './image-config.d-CeDgNyX4.js';
+import './types.d-C41ePjvP.js';
+import './config.d-qt-mE8O5.js';
+import './types.d-DQnyD3VD.js';
+import './font.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

@@ -1,8 +1,8 @@
 import {
   defineConfig,
   defineFarmConfig
-} from "./chunk-XZNTNMHT.mjs";
-import "./chunk-LPEX4YW6.mjs";
+} from "./chunk-VISQDC6W.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 export {
   defineConfig,
   defineFarmConfig

package/dist/cron.cjs

@@ -11,19 +11,19 @@
 
 
 
-var _chunk6EXBPJ24cjs = require('./chunk-6EXBPJ24.cjs');
-require('./chunk-JDNHKPTD.cjs');
-require('./chunk-CMGMGHUZ.cjs');
-require('./chunk-5QIKR7RR.cjs');
-require('./chunk-QNPEUFHQ.cjs');
-require('./chunk-US2QVW3E.cjs');
-require('./chunk-NO3WWW3N.cjs');
-require('./chunk-S3JO3N4H.cjs');
 
 
 
 
 
+var _chunkBT4SEFLCcjs = require('./chunk-BT4SEFLC.cjs');
+require('./chunk-2KMIJDY6.cjs');
+require('./chunk-SHIWRBFI.cjs');
+require('./chunk-QMNWKQL4.cjs');
+require('./chunk-SUCDVKUB.cjs');
+require('./chunk-6CTFVBAT.cjs');
+require('./chunk-YTVSWXEZ.cjs');
+require('./chunk-BTZ5O6VM.cjs');
 
 
 
@@ -32,4 +32,14 @@ require('./chunk-S3JO3N4H.cjs');
 
 
 
-exports.DEFAULT_FARM_CRON_SECRET_ENV = _chunk6EXBPJ24cjs.DEFAULT_FARM_CRON_SECRET_ENV; exports.FARM_CRON_MANIFEST = _chunk6EXBPJ24cjs.FARM_CRON_MANIFEST; exports.applyFarmCronVercelCrons = _chunk6EXBPJ24cjs.applyFarmCronVercelCrons; exports.createFarmCronCloudflareConfig = _chunk6EXBPJ24cjs.createFarmCronCloudflareConfig; exports.createFarmCronCloudflareTriggers = _chunk6EXBPJ24cjs.createFarmCronCloudflareTriggers; exports.createFarmCronManifest = _chunk6EXBPJ24cjs.createFarmCronManifest; exports.createFarmCronVercelCrons = _chunk6EXBPJ24cjs.createFarmCronVercelCrons; exports.cronRoute = _chunk6EXBPJ24cjs.cronRoute; exports.isCronRequestAuthorized = _chunk6EXBPJ24cjs.isCronRequestAuthorized; exports.mergeScheduledTasks = _chunk6EXBPJ24cjs.mergeScheduledTasks; exports.prepareFarmCronForNitro = _chunk6EXBPJ24cjs.prepareFarmCronForNitro; exports.resolveCronConfig = _chunk6EXBPJ24cjs.resolveCronConfig;
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_FARM_CRON_SECRET_ENV = _chunkBT4SEFLCcjs.DEFAULT_FARM_CRON_SECRET_ENV; exports.FARM_CRON_MANIFEST = _chunkBT4SEFLCcjs.FARM_CRON_MANIFEST; exports.FARM_CRON_NAME_SEGMENT_PATTERN = _chunkBT4SEFLCcjs.FARM_CRON_NAME_SEGMENT_PATTERN; exports.FARM_CRON_SIGNATURE_HEADER = _chunkBT4SEFLCcjs.FARM_CRON_SIGNATURE_HEADER; exports.applyFarmCronVercelCrons = _chunkBT4SEFLCcjs.applyFarmCronVercelCrons; exports.authorizeCronRequest = _chunkBT4SEFLCcjs.authorizeCronRequest; exports.createFarmCronCloudflareConfig = _chunkBT4SEFLCcjs.createFarmCronCloudflareConfig; exports.createFarmCronCloudflareTriggers = _chunkBT4SEFLCcjs.createFarmCronCloudflareTriggers; exports.createFarmCronManifest = _chunkBT4SEFLCcjs.createFarmCronManifest; exports.createFarmCronVercelCrons = _chunkBT4SEFLCcjs.createFarmCronVercelCrons; exports.cronRoute = _chunkBT4SEFLCcjs.cronRoute; exports.farmCronSignature = _chunkBT4SEFLCcjs.farmCronSignature; exports.isCronRequestAuthorized = _chunkBT4SEFLCcjs.isCronRequestAuthorized; exports.mergeScheduledTasks = _chunkBT4SEFLCcjs.mergeScheduledTasks; exports.normalizeCronExpression = _chunkBT4SEFLCcjs.normalizeCronExpression; exports.prepareFarmCronForNitro = _chunkBT4SEFLCcjs.prepareFarmCronForNitro; exports.resolveCronConfig = _chunkBT4SEFLCcjs.resolveCronConfig;

package/dist/cron.d.mts

@@ -0,0 +1,186 @@
+import { T as TypedEndpoint } from './endpoint.d-BkMSCRf6.mjs';
+import './cache.mjs';
+
+type FarmCronSchedule = string | string[];
+/**
+ * Who fires the schedules. `host` is the platform chosen by `deploy.target` or the Nitro preset
+ * (Vercel Cron, Cloudflare Cron Triggers, or Nitro scheduled tasks); `farmjs` is Farm.js Infra.
+ */
+type FarmCronProvider = "host" | "farmjs";
+/** A JSON value, as route-level cron `input` must survive the build manifest unchanged. */
+type FarmCronInputValue = string | number | boolean | null | FarmCronInputValue[] | {
+    [key: string]: FarmCronInputValue;
+};
+/**
+ * What a cron-guarded endpoint handler reads as `context.cron`. Only the endpoint form receives
+ * it; a plain `(request) => ...` handler reads the `x-farm-cron-name` and
+ * `x-farm-cron-scheduled-at` headers itself.
+ */
+interface FarmCronContext {
+    /** Job name from the `x-farm-cron-name` header; a direct platform call sends none. */
+    name?: string;
+    /** When the scheduler meant to fire, from `x-farm-cron-scheduled-at` (a millisecond epoch). */
+    scheduledAt?: Date;
+    /** The literal `input` from the route options; `undefined` when the options set none. */
+    input: FarmCronInputValue | undefined;
+    /** Aborts when the handler outlives the route's `timeoutMs`. */
+    signal: AbortSignal;
+}
+interface FarmCronJobConfig {
+    /** Portable five-field cron expression, or a list of expressions. */
+    schedule: FarmCronSchedule;
+    /** Farm API route invoked with GET when the schedule fires. */
+    path: string;
+    /** Human-readable purpose shown by local tooling and deployment manifests. */
+    description?: string;
+    /** Disable this schedule without removing its configuration. */
+    enabled?: boolean;
+}
+interface FarmCronConfig {
+    /**
+     * Who runs the schedules. `host` uses the scheduler of the platform you deploy to with
+     * `deploy.target` or the Nitro preset. `farmjs` leaves the host output empty and writes a manifest
+     * for `farm cron sync` after deployment. Credentials never select Infra.
+     * @default "host"
+     * @example { provider: "farmjs" }
+     */
+    provider: FarmCronProvider;
+    /** Named jobs, merged with route-local `cronRoute()` schedules. */
+    jobs?: Record<string, FarmCronJobConfig>;
+}
+type FarmCronUserConfig = Record<string, FarmCronJobConfig> | FarmCronConfig;
+interface FarmCronJob {
+    name: string;
+    schedule: string[];
+    path: string;
+    description?: string;
+    /** Literal `input` from route-level options; config entries never carry one. */
+    input?: FarmCronInputValue;
+    /** Route-level `timeoutMs`, carried to the manifest so external schedulers can honor it. */
+    timeoutMs?: number;
+}
+interface FarmCronResolvedConfig {
+    provider?: FarmCronProvider;
+    enabled: boolean;
+    secretEnv: typeof DEFAULT_FARM_CRON_SECRET_ENV;
+    jobs: FarmCronJob[];
+}
+interface PreparedFarmCron {
+    jobs: FarmCronJob[];
+    tasks: Record<string, {
+        handler: string;
+        description: string;
+    }>;
+    scheduledTasks: Record<string, string | string[]>;
+    manifestPath?: string;
+    /** Who fires the jobs: the deploy platform, or Farm.js Infra (then the host outputs stay empty). */
+    provider: FarmCronProvider;
+}
+interface FarmCronRouteOptions {
+    /** Environment variable containing the bearer token. */
+    secretEnv?: string;
+    /** Inline token, primarily useful in tests. Environment variables are preferred. */
+    secret?: string;
+    /** Allow a production route without a secret. Defaults to false. */
+    allowUnsecured?: boolean;
+    /**
+     * Schedule this route beside its code: one portable five-field UTC cron expression, or a list.
+     * A route with a `schedule` is a cron job, equivalent to a `cron` config entry. The build reads
+     * `schedule`, `name`, `description`, `input`, `timeoutMs`, and `enabled` statically from the
+     * route file, so they must be written as literals in the `cronRoute()` call.
+     */
+    schedule?: FarmCronSchedule;
+    /** Job name. Defaults to the route path without the leading `/api/`. */
+    name?: string;
+    /** Human-readable purpose shown by CLI output and the build manifest. */
+    description?: string;
+    /** JSON literal handed to the handler as `context.cron.input` (endpoint form only). */
+    input?: FarmCronInputValue;
+    /**
+     * Milliseconds the handler may run. When it has not finished, `context.cron.signal` aborts and
+     * the route answers 504; a handler that finishes first keeps its own result.
+     */
+    timeoutMs?: number;
+    /**
+     * `"skip"` answers 409 `{ skipped: true }` while a run of the same job is still going, without
+     * running the handler. Per-process only in v1: replicas and serverless instances do not share
+     * the in-flight set, so it is not a distributed lock.
+     */
+    overlap?: "skip";
+    /**
+     * `false` keeps the route callable with the same auth but removes it from scheduling outputs,
+     * like a disabled `cron` config entry.
+     */
+    enabled?: boolean;
+}
+interface FarmCronCloudflareConfig {
+    deployConfig: true;
+    wrangler: {
+        triggers: {
+            crons: string[];
+        };
+    };
+}
+declare const DEFAULT_FARM_CRON_SECRET_ENV = "CRON_SECRET";
+declare const FARM_CRON_MANIFEST = "cron-manifest.json";
+declare function resolveCronConfig(cron: FarmCronResolvedConfig | FarmCronUserConfig | false | undefined): FarmCronResolvedConfig;
+declare function prepareFarmCronForNitro(config: {
+    root?: string;
+    distDir?: string;
+    cron?: FarmCronResolvedConfig | FarmCronUserConfig | false;
+}): Promise<PreparedFarmCron>;
+declare function createFarmCronManifest(cron: FarmCronResolvedConfig, provider?: FarmCronProvider): {
+    schemaVersion: number;
+    provider: FarmCronProvider;
+    secretEnv: "CRON_SECRET";
+    jobs: {
+        input?: FarmCronInputValue | undefined;
+        timeoutMs?: number | undefined;
+        name: string;
+        schedule: string[];
+        path: string;
+        description: string | null;
+    }[];
+};
+declare function createFarmCronVercelCrons(jobs: FarmCronJob[]): Array<{
+    path: string;
+    schedule: string;
+}>;
+declare function applyFarmCronVercelCrons(vercelConfig: Record<string, any>, jobs: FarmCronJob[]): Record<string, any>;
+declare function createFarmCronCloudflareTriggers(jobs: FarmCronJob[]): string[];
+declare function createFarmCronCloudflareConfig(jobs: FarmCronJob[]): FarmCronCloudflareConfig | undefined;
+declare function mergeScheduledTasks(...maps: Array<Record<string, string | string[]> | undefined>): Record<string, string | string[]>;
+declare function isCronRequestAuthorized(request: Request, options?: FarmCronRouteOptions): boolean;
+/** A `createEndpoint()` result: Farm's route runtime calls `__handler` with the parsed context. */
+type FarmCronEndpoint = TypedEndpoint<any, any, any, any, any, any, any, any>;
+/**
+ * Guards an API route so only the scheduler can call it: a `createEndpoint()` result, which keeps its
+ * validation, types and metadata, or a plain handler that receives the `Request`.
+ *
+ * Options may also carry the job's `schedule` and its scheduling fields beside the code; the
+ * build reads them statically, so they must be literals in the call. `timeoutMs` and
+ * `overlap: "skip"` guard both forms at runtime; `context.cron` is endpoint-form only, a plain
+ * handler reads the cron headers from its `Request` itself.
+ */
+/** Header carrying Farm.js Infra's signature on a scheduled call. */
+declare const FARM_CRON_SIGNATURE_HEADER = "farmjs-signature";
+/**
+ * @internal Exported for tests. `v1` of a scheduled call's `farmjs-signature`: HMAC-SHA256 keyed
+ * with the hex SHA-256 of `FARMJS_API_KEY` (as text), over `farmjs-cron-v1\n<t>\nGET <pathname>`.
+ * Web Crypto only, so the same code runs on Workers.
+ */
+declare function farmCronSignature(apiKey: string, t: number, pathname: string): Promise<string>;
+/**
+ * Whether a scheduler may run this cron request: the configured secret
+ * (`isCronRequestAuthorized`), or Farm.js Infra's `farmjs-signature`, verified with the
+ * `FARMJS_API_KEY` the runtime already has. No key in the runtime means signatures never verify.
+ */
+declare function authorizeCronRequest(request: Request, options?: FarmCronRouteOptions, now?: number): Promise<boolean>;
+declare function cronRoute<TEndpoint extends FarmCronEndpoint>(endpoint: TEndpoint, options?: FarmCronRouteOptions): TEndpoint;
+declare function cronRoute<TArgs extends unknown[], TResult>(handler: (request: Request, ...args: TArgs) => TResult, options?: FarmCronRouteOptions): (request: Request, ...args: TArgs) => TResult | Promise<Response>;
+/** @internal One segment of a cron job name; route-level names join segments with `/`. */
+declare const FARM_CRON_NAME_SEGMENT_PATTERN: RegExp;
+/** @internal Validate and normalize one cron expression; the build scan reuses config's rules. */
+declare function normalizeCronExpression(name: string, value: unknown): string;
+
+export { DEFAULT_FARM_CRON_SECRET_ENV, FARM_CRON_MANIFEST, FARM_CRON_NAME_SEGMENT_PATTERN, FARM_CRON_SIGNATURE_HEADER, type FarmCronCloudflareConfig, type FarmCronConfig, type FarmCronContext, type FarmCronInputValue, type FarmCronJob, type FarmCronJobConfig, type FarmCronProvider, type FarmCronResolvedConfig, type FarmCronRouteOptions, type FarmCronSchedule, type FarmCronUserConfig, type PreparedFarmCron, applyFarmCronVercelCrons, authorizeCronRequest, createFarmCronCloudflareConfig, createFarmCronCloudflareTriggers, createFarmCronManifest, createFarmCronVercelCrons, cronRoute, farmCronSignature, isCronRequestAuthorized, mergeScheduledTasks, normalizeCronExpression, prepareFarmCronForNitro, resolveCronConfig };

package/dist/cron.d.ts

@@ -0,0 +1,186 @@
+import { T as TypedEndpoint } from './endpoint.d-BgHn0lhl.js';
+import './cache.js';
+
+type FarmCronSchedule = string | string[];
+/**
+ * Who fires the schedules. `host` is the platform chosen by `deploy.target` or the Nitro preset
+ * (Vercel Cron, Cloudflare Cron Triggers, or Nitro scheduled tasks); `farmjs` is Farm.js Infra.
+ */
+type FarmCronProvider = "host" | "farmjs";
+/** A JSON value, as route-level cron `input` must survive the build manifest unchanged. */
+type FarmCronInputValue = string | number | boolean | null | FarmCronInputValue[] | {
+    [key: string]: FarmCronInputValue;
+};
+/**
+ * What a cron-guarded endpoint handler reads as `context.cron`. Only the endpoint form receives
+ * it; a plain `(request) => ...` handler reads the `x-farm-cron-name` and
+ * `x-farm-cron-scheduled-at` headers itself.
+ */
+interface FarmCronContext {
+    /** Job name from the `x-farm-cron-name` header; a direct platform call sends none. */
+    name?: string;
+    /** When the scheduler meant to fire, from `x-farm-cron-scheduled-at` (a millisecond epoch). */
+    scheduledAt?: Date;
+    /** The literal `input` from the route options; `undefined` when the options set none. */
+    input: FarmCronInputValue | undefined;
+    /** Aborts when the handler outlives the route's `timeoutMs`. */
+    signal: AbortSignal;
+}
+interface FarmCronJobConfig {
+    /** Portable five-field cron expression, or a list of expressions. */
+    schedule: FarmCronSchedule;
+    /** Farm API route invoked with GET when the schedule fires. */
+    path: string;
+    /** Human-readable purpose shown by local tooling and deployment manifests. */
+    description?: string;
+    /** Disable this schedule without removing its configuration. */
+    enabled?: boolean;
+}
+interface FarmCronConfig {
+    /**
+     * Who runs the schedules. `host` uses the scheduler of the platform you deploy to with
+     * `deploy.target` or the Nitro preset. `farmjs` leaves the host output empty and writes a manifest
+     * for `farm cron sync` after deployment. Credentials never select Infra.
+     * @default "host"
+     * @example { provider: "farmjs" }
+     */
+    provider: FarmCronProvider;
+    /** Named jobs, merged with route-local `cronRoute()` schedules. */
+    jobs?: Record<string, FarmCronJobConfig>;
+}
+type FarmCronUserConfig = Record<string, FarmCronJobConfig> | FarmCronConfig;
+interface FarmCronJob {
+    name: string;
+    schedule: string[];
+    path: string;
+    description?: string;
+    /** Literal `input` from route-level options; config entries never carry one. */
+    input?: FarmCronInputValue;
+    /** Route-level `timeoutMs`, carried to the manifest so external schedulers can honor it. */
+    timeoutMs?: number;
+}
+interface FarmCronResolvedConfig {
+    provider?: FarmCronProvider;
+    enabled: boolean;
+    secretEnv: typeof DEFAULT_FARM_CRON_SECRET_ENV;
+    jobs: FarmCronJob[];
+}
+interface PreparedFarmCron {
+    jobs: FarmCronJob[];
+    tasks: Record<string, {
+        handler: string;
+        description: string;
+    }>;
+    scheduledTasks: Record<string, string | string[]>;
+    manifestPath?: string;
+    /** Who fires the jobs: the deploy platform, or Farm.js Infra (then the host outputs stay empty). */
+    provider: FarmCronProvider;
+}
+interface FarmCronRouteOptions {
+    /** Environment variable containing the bearer token. */
+    secretEnv?: string;
+    /** Inline token, primarily useful in tests. Environment variables are preferred. */
+    secret?: string;
+    /** Allow a production route without a secret. Defaults to false. */
+    allowUnsecured?: boolean;
+    /**
+     * Schedule this route beside its code: one portable five-field UTC cron expression, or a list.
+     * A route with a `schedule` is a cron job, equivalent to a `cron` config entry. The build reads
+     * `schedule`, `name`, `description`, `input`, `timeoutMs`, and `enabled` statically from the
+     * route file, so they must be written as literals in the `cronRoute()` call.
+     */
+    schedule?: FarmCronSchedule;
+    /** Job name. Defaults to the route path without the leading `/api/`. */
+    name?: string;
+    /** Human-readable purpose shown by CLI output and the build manifest. */
+    description?: string;
+    /** JSON literal handed to the handler as `context.cron.input` (endpoint form only). */
+    input?: FarmCronInputValue;
+    /**
+     * Milliseconds the handler may run. When it has not finished, `context.cron.signal` aborts and
+     * the route answers 504; a handler that finishes first keeps its own result.
+     */
+    timeoutMs?: number;
+    /**
+     * `"skip"` answers 409 `{ skipped: true }` while a run of the same job is still going, without
+     * running the handler. Per-process only in v1: replicas and serverless instances do not share
+     * the in-flight set, so it is not a distributed lock.
+     */
+    overlap?: "skip";
+    /**
+     * `false` keeps the route callable with the same auth but removes it from scheduling outputs,
+     * like a disabled `cron` config entry.
+     */
+    enabled?: boolean;
+}
+interface FarmCronCloudflareConfig {
+    deployConfig: true;
+    wrangler: {
+        triggers: {
+            crons: string[];
+        };
+    };
+}
+declare const DEFAULT_FARM_CRON_SECRET_ENV = "CRON_SECRET";
+declare const FARM_CRON_MANIFEST = "cron-manifest.json";
+declare function resolveCronConfig(cron: FarmCronResolvedConfig | FarmCronUserConfig | false | undefined): FarmCronResolvedConfig;
+declare function prepareFarmCronForNitro(config: {
+    root?: string;
+    distDir?: string;
+    cron?: FarmCronResolvedConfig | FarmCronUserConfig | false;
+}): Promise<PreparedFarmCron>;
+declare function createFarmCronManifest(cron: FarmCronResolvedConfig, provider?: FarmCronProvider): {
+    schemaVersion: number;
+    provider: FarmCronProvider;
+    secretEnv: "CRON_SECRET";
+    jobs: {
+        input?: FarmCronInputValue | undefined;
+        timeoutMs?: number | undefined;
+        name: string;
+        schedule: string[];
+        path: string;
+        description: string | null;
+    }[];
+};
+declare function createFarmCronVercelCrons(jobs: FarmCronJob[]): Array<{
+    path: string;
+    schedule: string;
+}>;
+declare function applyFarmCronVercelCrons(vercelConfig: Record<string, any>, jobs: FarmCronJob[]): Record<string, any>;
+declare function createFarmCronCloudflareTriggers(jobs: FarmCronJob[]): string[];
+declare function createFarmCronCloudflareConfig(jobs: FarmCronJob[]): FarmCronCloudflareConfig | undefined;
+declare function mergeScheduledTasks(...maps: Array<Record<string, string | string[]> | undefined>): Record<string, string | string[]>;
+declare function isCronRequestAuthorized(request: Request, options?: FarmCronRouteOptions): boolean;
+/** A `createEndpoint()` result: Farm's route runtime calls `__handler` with the parsed context. */
+type FarmCronEndpoint = TypedEndpoint<any, any, any, any, any, any, any, any>;
+/**
+ * Guards an API route so only the scheduler can call it: a `createEndpoint()` result, which keeps its
+ * validation, types and metadata, or a plain handler that receives the `Request`.
+ *
+ * Options may also carry the job's `schedule` and its scheduling fields beside the code; the
+ * build reads them statically, so they must be literals in the call. `timeoutMs` and
+ * `overlap: "skip"` guard both forms at runtime; `context.cron` is endpoint-form only, a plain
+ * handler reads the cron headers from its `Request` itself.
+ */
+/** Header carrying Farm.js Infra's signature on a scheduled call. */
+declare const FARM_CRON_SIGNATURE_HEADER = "farmjs-signature";
+/**
+ * @internal Exported for tests. `v1` of a scheduled call's `farmjs-signature`: HMAC-SHA256 keyed
+ * with the hex SHA-256 of `FARMJS_API_KEY` (as text), over `farmjs-cron-v1\n<t>\nGET <pathname>`.
+ * Web Crypto only, so the same code runs on Workers.
+ */
+declare function farmCronSignature(apiKey: string, t: number, pathname: string): Promise<string>;
+/**
+ * Whether a scheduler may run this cron request: the configured secret
+ * (`isCronRequestAuthorized`), or Farm.js Infra's `farmjs-signature`, verified with the
+ * `FARMJS_API_KEY` the runtime already has. No key in the runtime means signatures never verify.
+ */
+declare function authorizeCronRequest(request: Request, options?: FarmCronRouteOptions, now?: number): Promise<boolean>;
+declare function cronRoute<TEndpoint extends FarmCronEndpoint>(endpoint: TEndpoint, options?: FarmCronRouteOptions): TEndpoint;
+declare function cronRoute<TArgs extends unknown[], TResult>(handler: (request: Request, ...args: TArgs) => TResult, options?: FarmCronRouteOptions): (request: Request, ...args: TArgs) => TResult | Promise<Response>;
+/** @internal One segment of a cron job name; route-level names join segments with `/`. */
+declare const FARM_CRON_NAME_SEGMENT_PATTERN: RegExp;
+/** @internal Validate and normalize one cron expression; the build scan reuses config's rules. */
+declare function normalizeCronExpression(name: string, value: unknown): string;
+
+export { DEFAULT_FARM_CRON_SECRET_ENV, FARM_CRON_MANIFEST, FARM_CRON_NAME_SEGMENT_PATTERN, FARM_CRON_SIGNATURE_HEADER, type FarmCronCloudflareConfig, type FarmCronConfig, type FarmCronContext, type FarmCronInputValue, type FarmCronJob, type FarmCronJobConfig, type FarmCronProvider, type FarmCronResolvedConfig, type FarmCronRouteOptions, type FarmCronSchedule, type FarmCronUserConfig, type PreparedFarmCron, applyFarmCronVercelCrons, authorizeCronRequest, createFarmCronCloudflareConfig, createFarmCronCloudflareTriggers, createFarmCronManifest, createFarmCronVercelCrons, cronRoute, farmCronSignature, isCronRequestAuthorized, mergeScheduledTasks, normalizeCronExpression, prepareFarmCronForNitro, resolveCronConfig };

package/dist/cron.mjs

@@ -1,35 +1,45 @@
 import {
   DEFAULT_FARM_CRON_SECRET_ENV,
   FARM_CRON_MANIFEST,
+  FARM_CRON_NAME_SEGMENT_PATTERN,
+  FARM_CRON_SIGNATURE_HEADER,
   applyFarmCronVercelCrons,
+  authorizeCronRequest,
   createFarmCronCloudflareConfig,
   createFarmCronCloudflareTriggers,
   createFarmCronManifest,
   createFarmCronVercelCrons,
   cronRoute,
+  farmCronSignature,
   isCronRequestAuthorized,
   mergeScheduledTasks,
+  normalizeCronExpression,
   prepareFarmCronForNitro,
   resolveCronConfig
-} from "./chunk-YHOCRI4H.mjs";
-import "./chunk-2UC36WAC.mjs";
-import "./chunk-ONUEYC6N.mjs";
-import "./chunk-KI3MESHB.mjs";
-import "./chunk-QVKYGNVM.mjs";
-import "./chunk-CQ6OSQ3K.mjs";
-import "./chunk-55YI3RRB.mjs";
-import "./chunk-LPEX4YW6.mjs";
+} from "./chunk-DQF3QLOH.mjs";
+import "./chunk-WXFY5JIY.mjs";
+import "./chunk-YP7YO3S3.mjs";
+import "./chunk-JSDV2NUN.mjs";
+import "./chunk-H3ASZDT7.mjs";
+import "./chunk-OHWM2VI4.mjs";
+import "./chunk-AYP2YFVN.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 export {
   DEFAULT_FARM_CRON_SECRET_ENV,
   FARM_CRON_MANIFEST,
+  FARM_CRON_NAME_SEGMENT_PATTERN,
+  FARM_CRON_SIGNATURE_HEADER,
   applyFarmCronVercelCrons,
+  authorizeCronRequest,
   createFarmCronCloudflareConfig,
   createFarmCronCloudflareTriggers,
   createFarmCronManifest,
   createFarmCronVercelCrons,
   cronRoute,
+  farmCronSignature,
   isCronRequestAuthorized,
   mergeScheduledTasks,
+  normalizeCronExpression,
   prepareFarmCronForNitro,
   resolveCronConfig
 };

package/dist/deferred.cjs

@@ -10,8 +10,8 @@
 
 
 
-var _chunkQBK2AA4Ucjs = require('./chunk-QBK2AA4U.cjs');
-require('./chunk-S3JO3N4H.cjs');
+var _chunkXQSYOVCWcjs = require('./chunk-XQSYOVCW.cjs');
+require('./chunk-BTZ5O6VM.cjs');
 
 
 
@@ -24,4 +24,4 @@ require('./chunk-S3JO3N4H.cjs');
 
 
 
-exports.DeferredDataError = _chunkQBK2AA4Ucjs.DeferredDataError; exports.FARM_DEFERRED_BRAND = _chunkQBK2AA4Ucjs.FARM_DEFERRED_BRAND; exports.FARM_DEFERRED_CONTENT_TYPE = _chunkQBK2AA4Ucjs.FARM_DEFERRED_CONTENT_TYPE; exports.FARM_DEFERRED_ERROR_CODE = _chunkQBK2AA4Ucjs.FARM_DEFERRED_ERROR_CODE; exports.createDeferredDataResponse = _chunkQBK2AA4Ucjs.createDeferredDataResponse; exports.defer = _chunkQBK2AA4Ucjs.defer; exports.isDeferred = _chunkQBK2AA4Ucjs.isDeferred; exports.prepareDeferredData = _chunkQBK2AA4Ucjs.prepareDeferredData; exports.readDeferredDataResponse = _chunkQBK2AA4Ucjs.readDeferredDataResponse; exports.reviveDeferredData = _chunkQBK2AA4Ucjs.reviveDeferredData; exports.snapshotDeferredData = _chunkQBK2AA4Ucjs.snapshotDeferredData;
+exports.DeferredDataError = _chunkXQSYOVCWcjs.DeferredDataError; exports.FARM_DEFERRED_BRAND = _chunkXQSYOVCWcjs.FARM_DEFERRED_BRAND; exports.FARM_DEFERRED_CONTENT_TYPE = _chunkXQSYOVCWcjs.FARM_DEFERRED_CONTENT_TYPE; exports.FARM_DEFERRED_ERROR_CODE = _chunkXQSYOVCWcjs.FARM_DEFERRED_ERROR_CODE; exports.createDeferredDataResponse = _chunkXQSYOVCWcjs.createDeferredDataResponse; exports.defer = _chunkXQSYOVCWcjs.defer; exports.isDeferred = _chunkXQSYOVCWcjs.isDeferred; exports.prepareDeferredData = _chunkXQSYOVCWcjs.prepareDeferredData; exports.readDeferredDataResponse = _chunkXQSYOVCWcjs.readDeferredDataResponse; exports.reviveDeferredData = _chunkXQSYOVCWcjs.reviveDeferredData; exports.snapshotDeferredData = _chunkXQSYOVCWcjs.snapshotDeferredData;

package/dist/deferred.d.mts

@@ -0,0 +1,44 @@
+declare const FARM_DEFERRED_CONTENT_TYPE = "application/x-farm-deferred+json";
+declare const FARM_DEFERRED_ERROR_CODE = "FARM_DEFERRED_DATA_ERROR";
+declare const FARM_DEFERRED_BRAND: unique symbol;
+interface Deferred<T> extends Promise<T> {
+    readonly [FARM_DEFERRED_BRAND]: true;
+}
+interface PreparedDeferredData {
+    data: unknown;
+    records: readonly DeferredRecord[];
+}
+interface DeferredRecord {
+    id: string;
+    promise: Deferred<unknown>;
+}
+type DeferredSettlement = {
+    status: "fulfilled";
+    value: unknown;
+} | {
+    status: "rejected";
+    error: {
+        code: typeof FARM_DEFERRED_ERROR_CODE;
+        message: string;
+    };
+};
+type DeferredSettlements = Record<string, DeferredSettlement>;
+interface DeferredDataResponseOptions {
+    onError?: (error: unknown, id: string) => void;
+    /** Called only after a deferred response reaches the end of its stream. */
+    onComplete?: () => void;
+}
+declare class DeferredDataError extends Error {
+    readonly name = "DeferredDataError";
+    readonly code = "FARM_DEFERRED_DATA_ERROR";
+    constructor(message?: string);
+}
+declare function defer<T>(value: PromiseLike<T>): Deferred<Awaited<T>>;
+declare function isDeferred<T = unknown>(value: unknown): value is Deferred<T>;
+declare function prepareDeferredData(value: unknown): PreparedDeferredData;
+declare function snapshotDeferredData(records: readonly DeferredRecord[]): DeferredSettlements;
+declare function reviveDeferredData<T>(value: T, settlements: DeferredSettlements): T;
+declare function createDeferredDataResponse(value: unknown, init?: ResponseInit, options?: DeferredDataResponseOptions): Response;
+declare function readDeferredDataResponse<T>(response: Response, options?: DeferredDataResponseOptions): Promise<T>;
+
+export { type Deferred, DeferredDataError, type DeferredDataResponseOptions, type DeferredRecord, type DeferredSettlement, type DeferredSettlements, FARM_DEFERRED_BRAND, FARM_DEFERRED_CONTENT_TYPE, FARM_DEFERRED_ERROR_CODE, type PreparedDeferredData, createDeferredDataResponse, defer, isDeferred, prepareDeferredData, readDeferredDataResponse, reviveDeferredData, snapshotDeferredData };