@farm.js/core 0.1.0-beta.14 → 0.1.0-beta.17

package/dist/server-fn.d.mts

@@ -0,0 +1,121 @@
+import { FarmCacheInvalidationTarget } from './cache.mjs';
+import { S as ServerFnFailure, a as ServerActionError } from './server-fn-error-DDh14a0V.mjs';
+export { F as FARM_SERVER_FN_FAILURE_SYMBOL, b as SerializedServerFnFailure, c as createServerFnTransportError, i as isServerFnFailure } from './server-fn-error-DDh14a0V.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;
+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;
+    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;
+    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;
+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 ServerFnMiddleware, type ServerFnMiddlewareContext, type ServerFnMiddlewareContinuation, type ServerFnMiddlewareHandler, type ServerFnMiddlewareHandlerContext, type ServerFnMiddlewareNext, type ServerFnMiddlewareOptions, type ServerFnOptions, type ServerFnOutputOptions, type ServerFnSchema, _parseServerFnSchema, createServerFn, createServerMiddleware };

package/dist/server-fn.d.ts

@@ -0,0 +1,121 @@
+import { FarmCacheInvalidationTarget } from './cache.js';
+import { S as ServerFnFailure, a as ServerActionError } from './server-fn-error-DDh14a0V.js';
+export { F as FARM_SERVER_FN_FAILURE_SYMBOL, b as SerializedServerFnFailure, c as createServerFnTransportError, i as isServerFnFailure } from './server-fn-error-DDh14a0V.js';
+
+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;
+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;
+    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;
+    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;
+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 ServerFnMiddleware, type ServerFnMiddlewareContext, type ServerFnMiddlewareContinuation, type ServerFnMiddlewareHandler, type ServerFnMiddlewareHandlerContext, type ServerFnMiddlewareNext, type ServerFnMiddlewareOptions, type ServerFnOptions, type ServerFnOutputOptions, type ServerFnSchema, _parseServerFnSchema, createServerFn, createServerMiddleware };

package/dist/server-fn.mjs

@@ -3,8 +3,14 @@ import {
   _parseServerFnSchema,
   createServerFn,
   createServerMiddleware
-} from "./chunk-VY2UYN5R.mjs";
-import "./chunk-UB5UOSHB.mjs";
+} from "./chunk-VPCFICID.mjs";
+import {
+  FARM_SERVER_FN_FAILURE_SYMBOL,
+  ServerActionError,
+  ServerFnFailure,
+  createServerFnTransportError,
+  isServerFnFailure
+} from "./chunk-ZVMV3THA.mjs";
 import "./chunk-LM2YNO4U.mjs";
 import "./chunk-V3XURYJO.mjs";
 import "./chunk-WZ5QFROO.mjs";
@@ -12,9 +18,14 @@ import "./chunk-RBRLLZL5.mjs";
 import "./chunk-7ZY5AIJO.mjs";
 import "./chunk-CGILA3WO.mjs";
 export {
+  FARM_SERVER_FN_FAILURE_SYMBOL,
   FARM_SERVER_FN_SYMBOL,
+  ServerActionError,
+  ServerFnFailure,
   _parseServerFnSchema,
   createServerFn,
-  createServerMiddleware
+  createServerFnTransportError,
+  createServerMiddleware,
+  isServerFnFailure
 };
 //# sourceMappingURL=server-fn.mjs.map

package/dist/server-plugins.d.mts

@@ -0,0 +1,57 @@
+import { bf as RedirectConfig, x as FarmRequest, y as FarmResponse, aF as FarmPluginContext, $ as FarmPlugin, bg as HeaderConfig, bh as RewriteConfig } from './client-plugins-278AvYHE.mjs';
+export { aG as FarmRequestPluginContext, aH as FarmRequestStore } from './client-plugins-278AvYHE.mjs';
+import './plugin-BJDf43dc.mjs';
+import 'react';
+import 'http';
+import './types-D1A6-XvH.mjs';
+import 'db0';
+import 'unstorage';
+import './integration-api-CHT2OKAf.mjs';
+import '@farming-labs/orm';
+import './types-DTzm4TCl.mjs';
+import '@farming-labs/docs';
+import './markdown.mjs';
+import './observability.mjs';
+import 'vite';
+import './workflows.mjs';
+import './cron.mjs';
+import './env.mjs';
+import './server-action-security.mjs';
+import './server-fn-error-DDh14a0V.mjs';
+import './image-config-Duob7wER.mjs';
+import './types-BMxWr97v.mjs';
+import './cache.mjs';
+import './route-runtime-DoOHzCAD.mjs';
+import './font.mjs';
+
+declare function createRedirectsPlugin(redirects: RedirectConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createHeadersPlugin(headers: HeaderConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createRewritesPlugin(rewrites: RewriteConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createEnvPlugin(env: Record<string, string>, { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createCompressionPlugin({ beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createLoggerPlugin({ beforeRequest, afterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+export { FarmPlugin, FarmPluginContext, HeaderConfig, RedirectConfig, RewriteConfig, createCompressionPlugin, createEnvPlugin, createHeadersPlugin, createLoggerPlugin, createRedirectsPlugin, createRewritesPlugin };

package/dist/server-plugins.d.ts

@@ -0,0 +1,57 @@
+import { bf as RedirectConfig, x as FarmRequest, y as FarmResponse, aF as FarmPluginContext, $ as FarmPlugin, bg as HeaderConfig, bh as RewriteConfig } from './client-plugins-CTQAkr7R.js';
+export { aG as FarmRequestPluginContext, aH as FarmRequestStore } from './client-plugins-CTQAkr7R.js';
+import './plugin-BJDf43dc.js';
+import 'react';
+import 'http';
+import './types-D1A6-XvH.js';
+import 'db0';
+import 'unstorage';
+import './integration-api-CHT2OKAf.js';
+import '@farming-labs/orm';
+import './types-DTzm4TCl.js';
+import '@farming-labs/docs';
+import './markdown.js';
+import './observability.js';
+import 'vite';
+import './workflows.js';
+import './cron.js';
+import './env.js';
+import './server-action-security.js';
+import './server-fn-error-DDh14a0V.js';
+import './image-config-Duob7wER.js';
+import './types-BMxWr97v.js';
+import './cache.js';
+import './route-runtime-DoOHzCAD.js';
+import './font.js';
+
+declare function createRedirectsPlugin(redirects: RedirectConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createHeadersPlugin(headers: HeaderConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createRewritesPlugin(rewrites: RewriteConfig[], { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createEnvPlugin(env: Record<string, string>, { beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createCompressionPlugin({ beforeRequest: overrideBeforeRequest, afterResponse: overrideAfterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+declare function createLoggerPlugin({ beforeRequest, afterResponse, }?: {
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmPluginContext) => void | Promise<void>;
+}): FarmPlugin;
+
+export { FarmPlugin, FarmPluginContext, HeaderConfig, RedirectConfig, RewriteConfig, createCompressionPlugin, createEnvPlugin, createHeadersPlugin, createLoggerPlugin, createRedirectsPlugin, createRewritesPlugin };

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

@@ -0,0 +1,51 @@
+import { a as FarmClientCacheStatus } from './client-cache-D-EZ7XVW.mjs';
+import { ServerQuery } from './server-query.mjs';
+import './cache.mjs';
+import './server-fn.mjs';
+import './server-fn-error-DDh14a0V.mjs';
+
+declare const FARM_SERVER_QUERY_RESULT_VERSION: 1;
+type FarmServerQueryResult<TData> = {
+    __farmServerQuery: {
+        version: typeof FARM_SERVER_QUERY_RESULT_VERSION;
+        key: string;
+        staleTime: number | false;
+        updatedAt: number;
+    };
+    data: TData;
+};
+
+type ServerQueryFetchOptions = {
+    /** Used only when a non-Farm transport returns plain data. Farm transports use the declaration. */
+    staleTime?: number | false;
+    /** Return stale data immediately while refreshing it in the background. Default true. */
+    swr?: boolean;
+    /** Always wait for a new result. */
+    force?: boolean;
+};
+type UseServerQueryOptions = ServerQueryFetchOptions & {
+    enabled?: boolean;
+    refetchOnWindowFocus?: boolean;
+    refetchOnReconnect?: boolean;
+};
+type UseServerQueryResult<TData> = {
+    data: TData | undefined;
+    error: Error | null;
+    status: FarmClientCacheStatus;
+    pending: boolean;
+    fetching: boolean;
+    stale: boolean;
+    refetch: () => Promise<TData>;
+};
+type FarmServerQueryActionInvocation = {
+    actionId: string;
+    args: readonly unknown[];
+    provisionalKey?: string;
+};
+declare function beginFarmServerQueryAction(actionId: string, args: readonly unknown[]): FarmServerQueryActionInvocation;
+declare function completeFarmServerQueryAction<TData>(invocation: FarmServerQueryActionInvocation, value: TData | FarmServerQueryResult<TData>): TData;
+declare function fetchServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: ServerQueryFetchOptions): Promise<TData>;
+declare function prefetchServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: Omit<ServerQueryFetchOptions, "force">): Promise<TData>;
+declare function useServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: UseServerQueryOptions): UseServerQueryResult<TData>;
+
+export { type FarmServerQueryActionInvocation, type ServerQueryFetchOptions, type UseServerQueryOptions, type UseServerQueryResult, beginFarmServerQueryAction, completeFarmServerQueryAction, fetchServerQuery, prefetchServerQuery, useServerQuery };

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

@@ -0,0 +1,51 @@
+import { a as FarmClientCacheStatus } from './client-cache-CIlyBlmx.js';
+import { ServerQuery } from './server-query.js';
+import './cache.js';
+import './server-fn.js';
+import './server-fn-error-DDh14a0V.js';
+
+declare const FARM_SERVER_QUERY_RESULT_VERSION: 1;
+type FarmServerQueryResult<TData> = {
+    __farmServerQuery: {
+        version: typeof FARM_SERVER_QUERY_RESULT_VERSION;
+        key: string;
+        staleTime: number | false;
+        updatedAt: number;
+    };
+    data: TData;
+};
+
+type ServerQueryFetchOptions = {
+    /** Used only when a non-Farm transport returns plain data. Farm transports use the declaration. */
+    staleTime?: number | false;
+    /** Return stale data immediately while refreshing it in the background. Default true. */
+    swr?: boolean;
+    /** Always wait for a new result. */
+    force?: boolean;
+};
+type UseServerQueryOptions = ServerQueryFetchOptions & {
+    enabled?: boolean;
+    refetchOnWindowFocus?: boolean;
+    refetchOnReconnect?: boolean;
+};
+type UseServerQueryResult<TData> = {
+    data: TData | undefined;
+    error: Error | null;
+    status: FarmClientCacheStatus;
+    pending: boolean;
+    fetching: boolean;
+    stale: boolean;
+    refetch: () => Promise<TData>;
+};
+type FarmServerQueryActionInvocation = {
+    actionId: string;
+    args: readonly unknown[];
+    provisionalKey?: string;
+};
+declare function beginFarmServerQueryAction(actionId: string, args: readonly unknown[]): FarmServerQueryActionInvocation;
+declare function completeFarmServerQueryAction<TData>(invocation: FarmServerQueryActionInvocation, value: TData | FarmServerQueryResult<TData>): TData;
+declare function fetchServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: ServerQueryFetchOptions): Promise<TData>;
+declare function prefetchServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: Omit<ServerQueryFetchOptions, "force">): Promise<TData>;
+declare function useServerQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: UseServerQueryOptions): UseServerQueryResult<TData>;
+
+export { type FarmServerQueryActionInvocation, type ServerQueryFetchOptions, type UseServerQueryOptions, type UseServerQueryResult, beginFarmServerQueryAction, completeFarmServerQueryAction, fetchServerQuery, prefetchServerQuery, useServerQuery };

package/dist/server-query.cjs

@@ -806,6 +806,26 @@ __name(stableSerialize, "stableSerialize");
 
 // src/server-action-security.ts
 var import_node_async_hooks = require("async_hooks");
+
+// src/server-fn-error.ts
+var FARM_SERVER_FN_FAILURE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn.failure");
+var _ServerFnFailure = class _ServerFnFailure extends Error {
+  constructor(code, data, options) {
+    super(options.message);
+    this.name = "ServerFnFailure";
+    this.code = code;
+    this.data = data;
+    this.status = options.status;
+    Object.defineProperty(this, FARM_SERVER_FN_FAILURE_SYMBOL, {
+      value: true,
+      enumerable: false
+    });
+  }
+};
+__name(_ServerFnFailure, "ServerFnFailure");
+var ServerFnFailure = _ServerFnFailure;
+
+// src/server-action-security.ts
 var SERVER_ACTION_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionStorage");
 var FALLBACK_ABORT_CONTROLLER_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionFallbackAbortController");
 function getServerActionExecutionContext() {
@@ -858,6 +878,8 @@ function createServerFn(options) {
     throw new TypeError("createServerFn requires a handler function");
   }
   const middleware = resolveServerFnMiddleware(options.middleware);
+  const errors = normalizeServerFnErrors(options.errors);
+  const error = createServerFnErrorHandler(errors);
   const serverFn = /* @__PURE__ */ __name(async (value) => {
     const formData = isFormData(value) ? value : void 0;
     const rawInput = formData ? formDataToObject(formData) : value;
@@ -875,7 +897,7 @@ function createServerFn(options) {
     let resolvedContext = Object.freeze(/* @__PURE__ */ Object.create(null));
     const result = await runServerFnMiddleware(middleware, handlerContext, async (context) => {
       resolvedContext = context.context;
-      return options.handler(context);
+      return options.handler({ ...context, error });
     });
     const parsedResult = await _parseServerFnSchema(options.output, result, "output");
     if (options.invalidates) {
@@ -905,6 +927,10 @@ function createServerFn(options) {
       value: options.output,
       enumerable: false
     },
+    __farmServerFnError: {
+      value: void 0,
+      enumerable: false
+    },
     __farmServerFnMiddleware: {
       value: middleware,
       enumerable: false
@@ -943,6 +969,78 @@ async function runServerFnMiddleware(middleware, handlerContext, handler) {
   return dispatch(0, Object.freeze(/* @__PURE__ */ Object.create(null)));
 }
 __name(runServerFnMiddleware, "runServerFnMiddleware");
+function normalizeServerFnErrors(definitions) {
+  if (definitions === void 0) return Object.freeze({});
+  if (!isPlainServerFnObject(definitions)) {
+    throw new TypeError("createServerFn errors must be an object");
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [code, definition] of Object.entries(definitions)) {
+    if (!code.trim()) {
+      throw new TypeError("Server function error codes cannot be empty");
+    }
+    if (!definition || typeof definition !== "object") {
+      throw new TypeError(`Server function error "${code}" must be an object`);
+    }
+    if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
+      throw new TypeError(
+        `Server function error "${code}" status must be an integer between 400 and 599`
+      );
+    }
+    if (!definition.data || typeof definition.data.parse !== "function" && typeof definition.data.safeParse !== "function") {
+      throw new TypeError(
+        `Server function error "${code}" data must provide synchronous parse() or safeParse()`
+      );
+    }
+    if (definition.message !== void 0 && typeof definition.message !== "string") {
+      throw new TypeError(`Server function error "${code}" message must be a string`);
+    }
+    normalized[code] = Object.freeze({ ...definition });
+  }
+  return Object.freeze(normalized);
+}
+__name(normalizeServerFnErrors, "normalizeServerFnErrors");
+function createServerFnErrorHandler(definitions) {
+  return ((code, data) => {
+    const definition = definitions[code];
+    if (!definition) {
+      throw new TypeError(`Server function error "${code}" is not declared`);
+    }
+    const parsed = parseServerFnFailureData(code, definition.data, data);
+    throw new ServerFnFailure(code, parsed, {
+      status: definition.status,
+      message: definition.message ?? "Server function failed"
+    });
+  });
+}
+__name(createServerFnErrorHandler, "createServerFnErrorHandler");
+function parseServerFnFailureData(code, schema, value) {
+  if (typeof schema.safeParse === "function") {
+    const result2 = schema.safeParse(value);
+    if (isPromiseLike(result2)) {
+      throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+    }
+    return unwrapSafeParseResult(result2);
+  }
+  const result = schema.parse(value);
+  if (isPromiseLike(result)) {
+    throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+  }
+  return result;
+}
+__name(parseServerFnFailureData, "parseServerFnFailureData");
+function isPlainServerFnObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainServerFnObject, "isPlainServerFnObject");
+function isPromiseLike(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function"
+  );
+}
+__name(isPromiseLike, "isPromiseLike");
 function resolveServerFnMiddleware(middleware) {
   const resolved = [];
   const seen = /* @__PURE__ */ new Set();