@farm.js/core 0.1.61 → 0.1.62

package/dist/server-action-security.d.ts

@@ -0,0 +1,45 @@
+import { S as SerializedServerFnFailure } from './server-fn-error.d-DrcH9cc1.js';
+
+declare const DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = 1000000;
+interface FarmServerActionsConfig {
+    /** Additional trusted origins or host patterns, such as https://app.example.com. */
+    allowedOrigins?: readonly string[];
+    /** Maximum encoded request body size in bytes or as a size string such as "1mb". */
+    bodySizeLimit?: number | string;
+}
+interface ResolvedFarmServerActionsConfig {
+    allowedOrigins: readonly string[];
+    bodySizeLimit: number;
+}
+type ServerActionRequestKind = "javascript" | "form";
+interface PreparedServerActionRequest {
+    body: string | FormData;
+    contentType: string;
+}
+type SanitizedServerActionError = {
+    name: "ServerActionError";
+    message: "Server function failed";
+} | SerializedServerFnFailure;
+type ServerActionRequestErrorCode = "BODY_TOO_LARGE" | "INVALID_ACTION_ID" | "INVALID_BODY" | "INVALID_CONTENT_LENGTH" | "INVALID_METHOD" | "INVALID_ORIGIN" | "MISSING_ORIGIN" | "UNSUPPORTED_CONTENT_TYPE";
+declare class ServerActionRequestError extends Error {
+    readonly code: ServerActionRequestErrorCode;
+    readonly status: number;
+    constructor(code: ServerActionRequestErrorCode, status: number, message: string);
+}
+type ServerActionExecutionContext = {
+    request: Request;
+    signal: AbortSignal;
+    invalidations: Set<string>;
+    cacheTasks: Set<Promise<void>>;
+};
+declare function resolveServerActionsConfig(config: FarmServerActionsConfig | undefined): ResolvedFarmServerActionsConfig;
+declare function validateServerActionRequest(request: Request, config: ResolvedFarmServerActionsConfig): void;
+declare function prepareServerActionRequest(request: Request, config: ResolvedFarmServerActionsConfig, kind: ServerActionRequestKind, actionId?: string | null): Promise<PreparedServerActionRequest>;
+declare function createServerActionRequestErrorResponse(error: unknown): Response | null;
+declare function sanitizeServerActionError(error: unknown): SanitizedServerActionError;
+declare function runWithServerActionRequest<T>(request: Request, callback: () => T | Promise<T>): Promise<T>;
+declare function getServerActionExecutionContext(): ServerActionExecutionContext | undefined;
+declare function getServerActionSignal(): AbortSignal;
+declare function getServerActionInvalidations(): readonly string[];
+
+export { DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT, type FarmServerActionsConfig, type PreparedServerActionRequest, type ResolvedFarmServerActionsConfig, type SanitizedServerActionError, ServerActionRequestError, type ServerActionRequestKind, createServerActionRequestErrorResponse, getServerActionExecutionContext, getServerActionInvalidations, getServerActionSignal, prepareServerActionRequest, resolveServerActionsConfig, runWithServerActionRequest, sanitizeServerActionError, validateServerActionRequest };

package/dist/server-action-security.mjs

@@ -10,12 +10,13 @@ import {
   runWithServerActionRequest,
   sanitizeServerActionError,
   validateServerActionRequest
-} from "./chunk-4WVJLURN.mjs";
-import "./chunk-FP2INE7H.mjs";
-import "./chunk-ZMMBIVQM.mjs";
-import "./chunk-4SIYUGRY.mjs";
-import "./chunk-55YI3RRB.mjs";
-import "./chunk-LPEX4YW6.mjs";
+} from "./chunk-E46NXBNJ.mjs";
+import "./chunk-QSTRBKHZ.mjs";
+import "./chunk-QDWMCFTH.mjs";
+import "./chunk-D2LCAV6L.mjs";
+import "./chunk-AZQXXXDX.mjs";
+import "./chunk-AYP2YFVN.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 export {
   DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT,
   ServerActionRequestError,

package/dist/server-client-bridge.d-DKWDl5NB.d.mts

@@ -0,0 +1,7 @@
+/** Browser-safe bridge: neither handlers nor Node.js imports cross this boundary. */
+interface APIRequestRuntime {
+    basePath: string;
+    dispatch(request: Request): Promise<Response>;
+}
+
+export type { APIRequestRuntime as A };

package/dist/server-client-bridge.d-DKWDl5NB.d.ts

@@ -0,0 +1,7 @@
+/** Browser-safe bridge: neither handlers nor Node.js imports cross this boundary. */
+interface APIRequestRuntime {
+    basePath: string;
+    dispatch(request: Request): Promise<Response>;
+}
+
+export type { APIRequestRuntime as A };

package/dist/server-fn-client.cjs

@@ -2,10 +2,10 @@
 
 
 
-var _chunkD7JTOLFKcjs = require('./chunk-D7JTOLFK.cjs');
-require('./chunk-LTNGXMQ6.cjs');
-require('./chunk-S3JO3N4H.cjs');
+var _chunkPZXYAWYGcjs = require('./chunk-PZXYAWYG.cjs');
+require('./chunk-EOXPRC2C.cjs');
+require('./chunk-BTZ5O6VM.cjs');
 
 
 
-exports.useAction = _chunkD7JTOLFKcjs.useAction; exports.useServerFn = _chunkD7JTOLFKcjs.useServerFn;
+exports.useAction = _chunkPZXYAWYGcjs.useAction; exports.useServerFn = _chunkPZXYAWYGcjs.useServerFn;

package/dist/server-fn-client.d.mts

@@ -0,0 +1,60 @@
+import { FormHTMLAttributes, ComponentType } from 'react';
+import { ServerFn } from './server-fn.mjs';
+import { k as RetryOptions } from './api-client.d-BNLXNCXJ.mjs';
+import './cache.mjs';
+import './server-fn-error.d-DrcH9cc1.mjs';
+import './endpoint.d-BkMSCRf6.mjs';
+import './route.d-BaVH3V0w.mjs';
+import './client-cache.d-di_Nasxa.mjs';
+
+type ServerFnActionStatus = "idle" | "pending" | "success" | "error";
+type ServerFnSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;
+type ServerFnOptimisticContext<TInput, TResult> = {
+    input: TInput | FormData | undefined;
+    formData?: FormData;
+    current: TResult | null;
+};
+type UseServerFnOptions<TResult, TError extends Error = Error, TInput = unknown> = {
+    initialResult?: TResult | null;
+    resetOnSubmit?: boolean;
+    throwOnFormError?: boolean;
+    optimistic?: (context: ServerFnOptimisticContext<TInput, TResult>) => TResult | null | undefined;
+    rollbackOnError?: boolean;
+    /** Retry failed submissions with the API client's retry shape. Defaults to no retries. */
+    retry?: RetryOptions;
+    onSuccess?: (result: TResult) => void;
+    onError?: (error: TError) => void;
+    onSettled?: (result: TResult | null, error: TError | null) => void;
+};
+type UseServerFnReturn<TInput, TResult, TError extends Error = Error> = {
+    pending: boolean;
+    status: ServerFnActionStatus;
+    result: TResult | null;
+    error: TError | null;
+    submit: ServerFnSubmit<TInput, TResult>;
+    formAction: (formData: FormData) => Promise<void>;
+    reset: () => void;
+};
+type UseActionFormProps = Omit<FormHTMLAttributes<HTMLFormElement>, "action">;
+type RouteActionTarget<TServerFn extends ServerFn<any, any, any>> = {
+    readonly action: TServerFn;
+};
+type UseActionReturn<TInput, TResult, TError extends Error = Error> = ServerFnSubmit<TInput, TResult> & {
+    pending: boolean;
+    status: ServerFnActionStatus;
+    data: TResult | null;
+    result: TResult | null;
+    error: TError | null;
+    formAction: (formData: FormData) => Promise<void>;
+    Form: ComponentType<UseActionFormProps>;
+    reset: () => void;
+};
+declare function useServerFn<TInput, TResult, TError extends Error = Error>(serverFn: ServerFn<TInput, TResult, TError>, options?: UseServerFnOptions<TResult, TError, TInput>): UseServerFnReturn<TInput, TResult, TError>;
+/**
+ * Wrap a server function, or a route's default server function, as a callable
+ * RPC with React mutation state.
+ */
+declare function useAction<TInput, TResult, TError extends Error = Error>(route: RouteActionTarget<ServerFn<TInput, TResult, TError>>, options?: UseServerFnOptions<TResult, TError, TInput>): UseActionReturn<TInput, TResult, TError>;
+declare function useAction<TInput, TResult, TError extends Error = Error>(serverFn: ServerFn<TInput, TResult, TError>, options?: UseServerFnOptions<TResult, TError, TInput>): UseActionReturn<TInput, TResult, TError>;
+
+export { type RouteActionTarget, type ServerFnActionStatus, type ServerFnOptimisticContext, type ServerFnSubmit, type UseActionFormProps, type UseActionReturn, type UseServerFnOptions, type UseServerFnReturn, useAction, useServerFn };

package/dist/server-fn-client.d.ts

@@ -0,0 +1,60 @@
+import { FormHTMLAttributes, ComponentType } from 'react';
+import { ServerFn } from './server-fn.js';
+import { k as RetryOptions } from './api-client.d-ddQBNGtu.js';
+import './cache.js';
+import './server-fn-error.d-DrcH9cc1.js';
+import './endpoint.d-BgHn0lhl.js';
+import './route.d-DBTEqifW.js';
+import './client-cache.d-Deoqq-nM.js';
+
+type ServerFnActionStatus = "idle" | "pending" | "success" | "error";
+type ServerFnSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;
+type ServerFnOptimisticContext<TInput, TResult> = {
+    input: TInput | FormData | undefined;
+    formData?: FormData;
+    current: TResult | null;
+};
+type UseServerFnOptions<TResult, TError extends Error = Error, TInput = unknown> = {
+    initialResult?: TResult | null;
+    resetOnSubmit?: boolean;
+    throwOnFormError?: boolean;
+    optimistic?: (context: ServerFnOptimisticContext<TInput, TResult>) => TResult | null | undefined;
+    rollbackOnError?: boolean;
+    /** Retry failed submissions with the API client's retry shape. Defaults to no retries. */
+    retry?: RetryOptions;
+    onSuccess?: (result: TResult) => void;
+    onError?: (error: TError) => void;
+    onSettled?: (result: TResult | null, error: TError | null) => void;
+};
+type UseServerFnReturn<TInput, TResult, TError extends Error = Error> = {
+    pending: boolean;
+    status: ServerFnActionStatus;
+    result: TResult | null;
+    error: TError | null;
+    submit: ServerFnSubmit<TInput, TResult>;
+    formAction: (formData: FormData) => Promise<void>;
+    reset: () => void;
+};
+type UseActionFormProps = Omit<FormHTMLAttributes<HTMLFormElement>, "action">;
+type RouteActionTarget<TServerFn extends ServerFn<any, any, any>> = {
+    readonly action: TServerFn;
+};
+type UseActionReturn<TInput, TResult, TError extends Error = Error> = ServerFnSubmit<TInput, TResult> & {
+    pending: boolean;
+    status: ServerFnActionStatus;
+    data: TResult | null;
+    result: TResult | null;
+    error: TError | null;
+    formAction: (formData: FormData) => Promise<void>;
+    Form: ComponentType<UseActionFormProps>;
+    reset: () => void;
+};
+declare function useServerFn<TInput, TResult, TError extends Error = Error>(serverFn: ServerFn<TInput, TResult, TError>, options?: UseServerFnOptions<TResult, TError, TInput>): UseServerFnReturn<TInput, TResult, TError>;
+/**
+ * Wrap a server function, or a route's default server function, as a callable
+ * RPC with React mutation state.
+ */
+declare function useAction<TInput, TResult, TError extends Error = Error>(route: RouteActionTarget<ServerFn<TInput, TResult, TError>>, options?: UseServerFnOptions<TResult, TError, TInput>): UseActionReturn<TInput, TResult, TError>;
+declare function useAction<TInput, TResult, TError extends Error = Error>(serverFn: ServerFn<TInput, TResult, TError>, options?: UseServerFnOptions<TResult, TError, TInput>): UseActionReturn<TInput, TResult, TError>;
+
+export { type RouteActionTarget, type ServerFnActionStatus, type ServerFnOptimisticContext, type ServerFnSubmit, type UseActionFormProps, type UseActionReturn, type UseServerFnOptions, type UseServerFnReturn, useAction, useServerFn };

package/dist/server-fn-client.mjs

@@ -2,9 +2,9 @@
 import {
   useAction,
   useServerFn
-} from "./chunk-SHB3GYXI.mjs";
-import "./chunk-72AK62H5.mjs";
-import "./chunk-LPEX4YW6.mjs";
+} from "./chunk-GL3ZDHKI.mjs";
+import "./chunk-IAPTECEB.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 export {
   useAction,
   useServerFn

package/dist/server-fn-error.d-DrcH9cc1.d.mts

@@ -0,0 +1,26 @@
+declare const FARM_SERVER_FN_FAILURE_SYMBOL: unique symbol;
+type SerializedServerFnFailure = {
+    name: "ServerFnFailure";
+    message: string;
+    code: string;
+    status: number;
+    data: unknown;
+};
+declare class ServerFnFailure<TCode extends string = string, TData = unknown, TStatus extends number = number> extends Error {
+    readonly name: "ServerFnFailure";
+    readonly code: TCode;
+    readonly data: TData;
+    readonly status: TStatus;
+    constructor(code: TCode, data: TData, options: {
+        status: TStatus;
+        message: string;
+    });
+}
+declare class ServerActionError extends Error {
+    readonly name: "ServerActionError";
+    constructor(message?: string);
+}
+declare function isServerFnFailure(value: unknown): value is ServerFnFailure;
+declare function createServerFnTransportError(value: unknown): ServerFnFailure | ServerActionError;
+
+export { FARM_SERVER_FN_FAILURE_SYMBOL as F, type SerializedServerFnFailure as S, ServerFnFailure as a, ServerActionError as b, createServerFnTransportError as c, isServerFnFailure as i };

package/dist/server-fn-error.d-DrcH9cc1.d.ts

@@ -0,0 +1,26 @@
+declare const FARM_SERVER_FN_FAILURE_SYMBOL: unique symbol;
+type SerializedServerFnFailure = {
+    name: "ServerFnFailure";
+    message: string;
+    code: string;
+    status: number;
+    data: unknown;
+};
+declare class ServerFnFailure<TCode extends string = string, TData = unknown, TStatus extends number = number> extends Error {
+    readonly name: "ServerFnFailure";
+    readonly code: TCode;
+    readonly data: TData;
+    readonly status: TStatus;
+    constructor(code: TCode, data: TData, options: {
+        status: TStatus;
+        message: string;
+    });
+}
+declare class ServerActionError extends Error {
+    readonly name: "ServerActionError";
+    constructor(message?: string);
+}
+declare function isServerFnFailure(value: unknown): value is ServerFnFailure;
+declare function createServerFnTransportError(value: unknown): ServerFnFailure | ServerActionError;
+
+export { FARM_SERVER_FN_FAILURE_SYMBOL as F, type SerializedServerFnFailure as S, ServerFnFailure as a, ServerActionError as b, createServerFnTransportError as c, isServerFnFailure as i };

package/dist/server-fn.cjs

@@ -8,25 +8,26 @@
 
 
 
-var _chunkBO36SELVcjs = require('./chunk-BO36SELV.cjs');
+var _chunkYN6BHOYYcjs = require('./chunk-YN6BHOYY.cjs');
 
 
 
 
 
 
-var _chunkT5OJPTVNcjs = require('./chunk-T5OJPTVN.cjs');
-require('./chunk-YWN746US.cjs');
-require('./chunk-SVRTJOUF.cjs');
-require('./chunk-KIIMAWOJ.cjs');
-require('./chunk-E3UK5IIB.cjs');
-require('./chunk-LIUGYUX3.cjs');
-require('./chunk-NYJMY3JA.cjs');
-require('./chunk-ZEG3OPIB.cjs');
-require('./chunk-OX6O6WVA.cjs');
-require('./chunk-U4KT7QP3.cjs');
-require('./chunk-NO3WWW3N.cjs');
-require('./chunk-S3JO3N4H.cjs');
+var _chunk4P5634G6cjs = require('./chunk-4P5634G6.cjs');
+require('./chunk-DMAP4RND.cjs');
+require('./chunk-FEFCISOX.cjs');
+require('./chunk-EVIWKPJV.cjs');
+require('./chunk-CFG4QERR.cjs');
+require('./chunk-JYT7AN37.cjs');
+require('./chunk-AOKXITZ6.cjs');
+require('./chunk-DXUXQP2T.cjs');
+require('./chunk-UZCMMJJT.cjs');
+require('./chunk-7JUIK547.cjs');
+require('./chunk-3BIASUGR.cjs');
+require('./chunk-YTVSWXEZ.cjs');
+require('./chunk-BTZ5O6VM.cjs');
 
 
 
@@ -42,4 +43,4 @@ require('./chunk-S3JO3N4H.cjs');
 
 
 
-exports.FARM_SERVER_FN_FAILURE_SYMBOL = _chunkT5OJPTVNcjs.FARM_SERVER_FN_FAILURE_SYMBOL; exports.FARM_SERVER_FN_SYMBOL = _chunkBO36SELVcjs.FARM_SERVER_FN_SYMBOL; exports.ServerActionError = _chunkT5OJPTVNcjs.ServerActionError; exports.ServerFnFailure = _chunkT5OJPTVNcjs.ServerFnFailure; exports._attachServerFunctionDescriptor = _chunkBO36SELVcjs._attachServerFunctionDescriptor; exports._describeServerFunction = _chunkBO36SELVcjs._describeServerFunction; exports._invokeServerFunction = _chunkBO36SELVcjs._invokeServerFunction; exports._parseServerFnSchema = _chunkBO36SELVcjs._parseServerFnSchema; exports._runServerFunctionForCaller = _chunkBO36SELVcjs._runServerFunctionForCaller; exports.createServerFn = _chunkBO36SELVcjs.createServerFn; exports.createServerFnTransportError = _chunkT5OJPTVNcjs.createServerFnTransportError; exports.createServerFunctionDescriptor = _chunkBO36SELVcjs.createServerFunctionDescriptor; exports.createServerMiddleware = _chunkBO36SELVcjs.createServerMiddleware; exports.isServerFnFailure = _chunkT5OJPTVNcjs.isServerFnFailure;
+exports.FARM_SERVER_FN_FAILURE_SYMBOL = _chunk4P5634G6cjs.FARM_SERVER_FN_FAILURE_SYMBOL; exports.FARM_SERVER_FN_SYMBOL = _chunkYN6BHOYYcjs.FARM_SERVER_FN_SYMBOL; exports.ServerActionError = _chunk4P5634G6cjs.ServerActionError; exports.ServerFnFailure = _chunk4P5634G6cjs.ServerFnFailure; exports._attachServerFunctionDescriptor = _chunkYN6BHOYYcjs._attachServerFunctionDescriptor; exports._describeServerFunction = _chunkYN6BHOYYcjs._describeServerFunction; exports._invokeServerFunction = _chunkYN6BHOYYcjs._invokeServerFunction; exports._parseServerFnSchema = _chunkYN6BHOYYcjs._parseServerFnSchema; exports._runServerFunctionForCaller = _chunkYN6BHOYYcjs._runServerFunctionForCaller; exports.createServerFn = _chunkYN6BHOYYcjs.createServerFn; exports.createServerFnTransportError = _chunk4P5634G6cjs.createServerFnTransportError; exports.createServerFunctionDescriptor = _chunkYN6BHOYYcjs.createServerFunctionDescriptor; exports.createServerMiddleware = _chunkYN6BHOYYcjs.createServerMiddleware; exports.isServerFnFailure = _chunk4P5634G6cjs.isServerFnFailure;

package/dist/server-fn.d.mts

@@ -0,0 +1,192 @@
+import { FarmCacheInvalidationTarget } from './cache.mjs';
+import { a as ServerFnFailure, b as ServerActionError } from './server-fn-error.d-DrcH9cc1.mjs';
+export { F as FARM_SERVER_FN_FAILURE_SYMBOL, S as SerializedServerFnFailure, c as createServerFnTransportError, i as isServerFnFailure } from './server-fn-error.d-DrcH9cc1.mjs';
+import { E as EndpointMCPMetadata } from './endpoint.d-BkMSCRf6.mjs';
+
+type MaybePromise<T> = T | Promise<T>;
+type ServerFnSchema = {
+    _input?: any;
+    _output?: any;
+    parse?: (data: unknown) => any;
+    parseAsync?: (data: unknown) => Promise<any>;
+    safeParse?: (data: unknown) => any;
+    safeParseAsync?: (data: unknown) => Promise<any>;
+};
+type InferServerFnSchemaInput<T> = T extends {
+    _input: infer I;
+} ? I : unknown;
+type InferServerFnSchemaOutput<T> = T extends {
+    _output: infer O;
+} ? O : T extends {
+    parse: (data: unknown) => infer R;
+} ? R : unknown;
+type ServerFnErrorSchema = ServerFnSchema & ({
+    parse: (data: unknown) => unknown;
+} | {
+    safeParse: (data: unknown) => unknown;
+});
+type ServerFnErrorDefinition<TSchema extends ServerFnErrorSchema = ServerFnErrorSchema, TStatus extends number = number> = {
+    status: TStatus;
+    /** Schema for the public error payload exposed to callers. */
+    data: TSchema;
+    /** Public message safe to expose to callers. */
+    message?: string;
+};
+type ServerFnErrorDefinitions = Record<string, ServerFnErrorDefinition<ServerFnErrorSchema, number>>;
+type ServerFnDeclaredError<TErrors extends ServerFnErrorDefinitions> = {
+    [TCode in keyof TErrors]: ServerFnFailure<TCode & string, InferServerFnSchemaOutput<TErrors[TCode]["data"]>, TErrors[TCode]["status"]>;
+}[keyof TErrors];
+type ServerFnError<TErrors extends ServerFnErrorDefinitions> = keyof TErrors extends never ? Error : ServerActionError | ServerFnDeclaredError<TErrors>;
+type ServerFnErrorHandler<TErrors extends ServerFnErrorDefinitions> = <TCode extends keyof TErrors & string>(code: TCode, data: InferServerFnSchemaInput<TErrors[TCode]["data"]>) => never;
+type ServerFnFormInput = FormData;
+/** MCP tool metadata for a server function or query. Server functions have no path to derive a name from. */
+type ServerFnMCPMetadata = EndpointMCPMetadata & {
+    name: string;
+};
+type Simplify<T> = {
+    [TKey in keyof T]: T[TKey];
+} & {};
+type AssignContext<TCurrent extends object, TNext extends object> = Simplify<Omit<TCurrent, keyof TNext> & TNext>;
+type MiddlewareContext<TMiddleware> = TMiddleware extends ServerFnMiddleware<infer TContext> ? TContext : {};
+type ServerFnMiddlewareContext<TMiddlewares extends readonly AnyServerFnMiddleware[], TContext extends object = {}> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends AnyServerFnMiddleware ? TRest extends readonly AnyServerFnMiddleware[] ? ServerFnMiddlewareContext<TRest, AssignContext<TContext, MiddlewareContext<TMiddleware>>> : TContext : TContext : number extends TMiddlewares["length"] ? Simplify<TContext & MiddlewareContext<TMiddlewares[number]>> : Simplify<TContext>;
+declare const SERVER_FN_MIDDLEWARE_CONTEXT: unique symbol;
+type ServerFnMiddlewareContinuation<TContext extends object = {}> = {
+    readonly [SERVER_FN_MIDDLEWARE_CONTEXT]: TContext;
+};
+type ServerFnMiddlewareNext = <TContext extends object = {}>(options?: {
+    context?: TContext;
+}) => Promise<ServerFnMiddlewareContinuation<TContext>>;
+type ServerFnContext<TInput, TContext extends object = {}> = {
+    input: TInput;
+    rawInput: unknown;
+    formData?: FormData;
+    /** The action request when invoked across the network. Undefined for direct server calls. */
+    request?: Request;
+    /** Aborts when the underlying action request is cancelled. */
+    signal: AbortSignal;
+    /** Context produced by this server function's middleware chain. */
+    context: Readonly<TContext>;
+};
+type ServerFnHandlerContext<TInput, TContext extends object = {}, TErrors extends ServerFnErrorDefinitions = {}> = ServerFnContext<TInput, TContext> & {
+    /** Return a declared, validated error from this server function. */
+    error: ServerFnErrorHandler<TErrors>;
+};
+type ServerFnHandler<TInput, TResult, TContext extends object = {}, TErrors extends ServerFnErrorDefinitions = {}> = (ctx: ServerFnHandlerContext<TInput, TContext, TErrors>) => MaybePromise<TResult>;
+type ServerFnInvalidationContext<TInput, TResult, TContext extends object = {}> = ServerFnContext<TInput, TContext> & {
+    /** Parsed value returned by the successful server function. */
+    result: TResult;
+};
+type ServerFnInvalidations<TInput, TResult, TContext extends object = {}> = readonly FarmCacheInvalidationTarget[] | ((context: ServerFnInvalidationContext<TInput, TResult, TContext>) => readonly FarmCacheInvalidationTarget[] | Promise<readonly FarmCacheInvalidationTarget[]>);
+type ServerFnMiddlewareHandlerContext<TContext extends object = {}> = ServerFnContext<unknown, TContext> & {
+    next: ServerFnMiddlewareNext;
+};
+type ServerFnMiddlewareHandler<TContext extends object = {}, TProvidedContext extends object = {}> = (ctx: ServerFnMiddlewareHandlerContext<TContext>) => MaybePromise<ServerFnMiddlewareContinuation<TProvidedContext>>;
+type ServerFnMiddleware<TContext extends object = {}> = {
+    readonly __farmServerFnMiddleware: true;
+    readonly __farmServerFnMiddlewareContext?: TContext;
+    readonly middleware: readonly AnyServerFnMiddleware[];
+    readonly handler: ServerFnMiddlewareHandler<any, any>;
+};
+type AnyServerFnMiddleware = ServerFnMiddleware<any>;
+type ServerFnMiddlewareOptions<TMiddlewares extends readonly AnyServerFnMiddleware[], TProvidedContext extends object> = {
+    middleware?: TMiddlewares;
+    handler: ServerFnMiddlewareHandler<ServerFnMiddlewareContext<TMiddlewares>, TProvidedContext>;
+};
+type ServerFnOptions<TSchema extends ServerFnSchema | undefined, TResult, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], TErrors extends ServerFnErrorDefinitions = {}> = {
+    input?: TSchema;
+    output?: undefined;
+    middleware?: TMiddlewares;
+    errors?: TErrors;
+    /** Expose this function as an MCP tool when it is listed in `mcp.tools`. `name` is required. */
+    mcp?: ServerFnMCPMetadata;
+    invalidates?: ServerFnInvalidations<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, Awaited<TResult>, ServerFnMiddlewareContext<TMiddlewares>>;
+    handler: ServerFnHandler<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, TResult, ServerFnMiddlewareContext<TMiddlewares>, TErrors>;
+};
+type ServerFnOutputOptions<TInputSchema extends ServerFnSchema | undefined, TOutputSchema extends ServerFnSchema, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], TErrors extends ServerFnErrorDefinitions = {}> = {
+    input?: TInputSchema;
+    output: TOutputSchema;
+    middleware?: TMiddlewares;
+    errors?: TErrors;
+    /** Expose this function as an MCP tool when it is listed in `mcp.tools`. `name` is required. */
+    mcp?: ServerFnMCPMetadata;
+    invalidates?: ServerFnInvalidations<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>, ServerFnMiddlewareContext<TMiddlewares>>;
+    handler: ServerFnHandler<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, unknown, ServerFnMiddlewareContext<TMiddlewares>, TErrors>;
+};
+type ServerFn<TInput, TResult, TError extends Error = Error> = ([unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>) & {
+    readonly __farmServerFn: true;
+    readonly __farmServerFnInput?: unknown;
+    readonly __farmServerFnOutput?: unknown;
+    readonly __farmServerFnError: TError;
+};
+type InferServerFnError<TServerFn> = TServerFn extends ServerFn<any, any, infer TError> ? TError : Error;
+declare const FARM_SERVER_FN_SYMBOL: unique symbol;
+/** @internal What a non-browser caller, such as an MCP tool, needs to know about a server function. */
+interface ServerFunctionDescriptor {
+    /** Queries only read data; actions may change it. */
+    readonly kind: "action" | "query";
+    readonly input: ServerFnSchema | undefined;
+    readonly output: ServerFnSchema | undefined;
+    readonly mcp: Readonly<ServerFnMCPMetadata> | undefined;
+}
+interface ServerFunctionRunner extends ServerFunctionDescriptor {
+    /** Runs the full pipeline and labels input validation failures with ServerFnInputError. */
+    readonly run: (input: unknown) => Promise<unknown>;
+}
+/** @internal Shared by createServerFn and createServerQuery. */
+declare function createServerFunctionDescriptor(kind: ServerFunctionDescriptor["kind"], options: {
+    input?: ServerFnSchema;
+    output?: ServerFnSchema;
+    mcp?: ServerFnMCPMetadata;
+}, run: ServerFunctionRunner["run"]): ServerFunctionRunner;
+/** @internal Attaches the descriptor that `_describeServerFunction` reads. */
+declare function _attachServerFunctionDescriptor(target: object, descriptor: ServerFunctionRunner): void;
+/** @internal Runs a server function's pipeline with input failures labelled, for createServerQuery. */
+declare function _runServerFunctionForCaller(value: unknown, input: unknown): Promise<unknown>;
+/**
+ * @internal Describes a createServerFn or createServerQuery function, or returns undefined for
+ * anything else. Exposes schemas and metadata, never the handler.
+ */
+declare function _describeServerFunction(value: unknown): ServerFunctionDescriptor | undefined;
+/** @internal How a server function call ended, for callers that are not the browser action transport. */
+type ServerFunctionInvocation = {
+    readonly ok: true;
+    readonly data: unknown;
+}
+/** The caller's input failed the input schema. The validator's error describes the caller's own data. */
+ | {
+    readonly ok: false;
+    readonly reason: "input";
+    readonly error: unknown;
+}
+/** A failure declared in `errors`, public by design. */
+ | {
+    readonly ok: false;
+    readonly reason: "failure";
+    readonly failure: ServerFnFailure;
+} | {
+    readonly ok: false;
+    readonly reason: "redirect";
+    readonly url: string;
+    readonly status: number;
+}
+/** Anything else. Can contain private data, so callers must not expose it. */
+ | {
+    readonly ok: false;
+    readonly reason: "error";
+    readonly error: unknown;
+};
+/**
+ * @internal Runs a server function or query on behalf of a non-browser caller, such as an MCP
+ * tool call. Runs the same pipeline as a browser action (input schema, middleware, handler,
+ * output schema, invalidations) with `request` as the action request, so middleware reads the
+ * caller's headers. A query resolves to its data rather than the client cache envelope.
+ */
+declare function _invokeServerFunction(value: unknown, input: unknown, request: Request): Promise<ServerFunctionInvocation>;
+declare function createServerMiddleware<const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], TProvidedContext extends object = {}>(options: ServerFnMiddlewareOptions<TMiddlewares, TProvidedContext>): ServerFnMiddleware<AssignContext<ServerFnMiddlewareContext<TMiddlewares>, TProvidedContext>>;
+declare function createServerFn<TInputSchema extends ServerFnSchema, TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], const TErrors extends ServerFnErrorDefinitions = {}>(options: ServerFnOutputOptions<TInputSchema, TOutputSchema, TMiddlewares, TErrors>): ServerFn<InferServerFnSchemaInput<TInputSchema>, Awaited<InferServerFnSchemaOutput<TOutputSchema>>, ServerFnError<TErrors>>;
+declare function createServerFn<TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], const TErrors extends ServerFnErrorDefinitions = {}>(options: ServerFnOutputOptions<undefined, TOutputSchema, TMiddlewares, TErrors>): ServerFn<unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>, ServerFnError<TErrors>>;
+declare function createServerFn<TSchema extends ServerFnSchema, TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], const TErrors extends ServerFnErrorDefinitions = {}>(options: ServerFnOptions<TSchema, TResult, TMiddlewares, TErrors>): ServerFn<InferServerFnSchemaInput<TSchema>, Awaited<TResult>, ServerFnError<TErrors>>;
+declare function createServerFn<TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly [], const TErrors extends ServerFnErrorDefinitions = {}>(options: ServerFnOptions<undefined, TResult, TMiddlewares, TErrors>): ServerFn<unknown, Awaited<TResult>, ServerFnError<TErrors>>;
+declare function _parseServerFnSchema(schema: ServerFnSchema | undefined, value: unknown, contract: "input" | "output", owner?: string): Promise<any>;
+
+export { type AnyServerFnMiddleware, FARM_SERVER_FN_SYMBOL, type InferServerFnError, type InferServerFnSchemaInput, type InferServerFnSchemaOutput, ServerActionError, type ServerFn, type ServerFnContext, type ServerFnDeclaredError, type ServerFnError, type ServerFnErrorDefinition, type ServerFnErrorDefinitions, type ServerFnErrorHandler, type ServerFnErrorSchema, ServerFnFailure, type ServerFnFormInput, type ServerFnHandler, type ServerFnHandlerContext, type ServerFnInvalidationContext, type ServerFnInvalidations, type ServerFnMCPMetadata, type ServerFnMiddleware, type ServerFnMiddlewareContext, type ServerFnMiddlewareContinuation, type ServerFnMiddlewareHandler, type ServerFnMiddlewareHandlerContext, type ServerFnMiddlewareNext, type ServerFnMiddlewareOptions, type ServerFnOptions, type ServerFnOutputOptions, type ServerFnSchema, type ServerFunctionDescriptor, type ServerFunctionInvocation, _attachServerFunctionDescriptor, _describeServerFunction, _invokeServerFunction, _parseServerFnSchema, _runServerFunctionForCaller, createServerFn, createServerFunctionDescriptor, createServerMiddleware };