@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/runtime-DgeS2skB.d.ts

@@ -0,0 +1,206 @@
+import { FarmCacheInvalidationTarget } from './cache.js';
+import { M as MultipartSchema, T as TypedFormData } from './transport-BmbGTXA5.js';
+
+type AnySchema = {
+    _output?: any;
+    _input?: any;
+    parse?: (data: unknown) => any;
+};
+type MaybePromise<T> = T | Promise<T>;
+type Simplify<T> = {
+    [TKey in keyof T]: T[TKey];
+} & {};
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
+type InferOutput<T> = T extends {
+    _output: infer O;
+} ? O : T extends {
+    parse: (data: unknown) => infer R;
+} ? R : unknown;
+type InferBodyInput<T> = T extends MultipartSchema<AnySchema> ? TypedFormData<InferOutput<T>> : InferOutput<T>;
+type InferHeadersOutput<T> = [T] extends [never] ? Record<string, string> : T extends AnySchema ? InferOutput<T> : Record<string, string>;
+type EndpointErrorDefinition<TSchema extends AnySchema = AnySchema, TStatus extends number = number> = {
+    status: TStatus;
+    schema: TSchema;
+    /** Public message safe to expose to API callers. */
+    message?: string;
+};
+type EndpointErrorDefinitions = Record<string, EndpointErrorDefinition<AnySchema, number>>;
+type EndpointErrorContracts<TErrors extends EndpointErrorDefinitions> = {
+    [TCode in keyof TErrors]: {
+        data: InferOutput<TErrors[TCode]["schema"]>;
+        status: TErrors[TCode]["status"];
+    };
+};
+type EndpointFail<TErrors extends EndpointErrorDefinitions> = <TCode extends keyof TErrors & string>(code: TCode, data: InferOutput<TErrors[TCode]["schema"]>) => never;
+declare class EndpointFailure<TCode extends string = string, TData = unknown> extends Error {
+    readonly code: TCode;
+    readonly data: TData;
+    readonly status: number;
+    constructor(code: TCode, data: TData, options: {
+        status: number;
+        message: string;
+    });
+}
+declare function isEndpointFailure(value: unknown): value is EndpointFailure<string, unknown>;
+type EndpointParamValue = string | string[];
+type EndpointParams = Record<string, EndpointParamValue>;
+type EndpointMiddlewareContext<TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = {
+    body: TBody;
+    query: TQuery;
+    headers: THeaders;
+    request: Request;
+    /** Context accumulated from middleware that ran earlier in the chain. */
+    context: Readonly<TContext>;
+    params: EndpointParams;
+};
+type EndpointMiddlewareResult<TProvidedContext extends object = object> = TProvidedContext | true | false | Response;
+/** A plain async function. No wrapper or `next()` callback is required. */
+type EndpointMiddleware<TProvidedContext extends object = object, TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = (ctx: EndpointMiddlewareContext<TContext, TBody, TQuery, THeaders>) => MaybePromise<EndpointMiddlewareResult<TProvidedContext>>;
+type AnyEndpointMiddleware = (ctx: EndpointMiddlewareContext<any, any, any, any>) => unknown;
+type EndpointInvalidationTarget = FarmCacheInvalidationTarget;
+type EndpointInvalidationContext<TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = EndpointMiddlewareContext<TContext, TBody, TQuery, THeaders> & {
+    /** The raw value returned by the endpoint handler. */
+    result: unknown;
+};
+type EndpointInvalidations<TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = readonly EndpointInvalidationTarget[] | ((context: EndpointInvalidationContext<TContext, TBody, TQuery, THeaders>) => readonly EndpointInvalidationTarget[] | Promise<readonly EndpointInvalidationTarget[]>);
+type ValidateEndpointMiddlewares<TMiddlewares extends readonly AnyEndpointMiddleware[]> = {
+    readonly [TIndex in keyof TMiddlewares]: TMiddlewares[TIndex] extends AnyEndpointMiddleware ? [Awaited<ReturnType<TMiddlewares[TIndex]>>] extends [EndpointMiddlewareResult<object>] ? TMiddlewares[TIndex] : never : never;
+};
+type ContextFromMiddlewareResult<TResult> = Exclude<TResult, Response | boolean> extends infer TContext ? [TContext] extends [never] ? {} : TContext extends object ? TContext : {} : {};
+type ContextFromMiddleware<TMiddleware> = TMiddleware extends (...args: any[]) => infer TResult ? ContextFromMiddlewareResult<Awaited<TResult>> : {};
+type InferEndpointMiddlewareContext<TMiddlewares extends readonly ((...args: any[]) => any)[], TContext extends object = {}> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends (...args: any[]) => any ? TRest extends readonly ((...args: any[]) => any)[] ? InferEndpointMiddlewareContext<TRest, Simplify<TContext & ContextFromMiddleware<TMiddleware>>> : Simplify<TContext> : Simplify<TContext> : number extends TMiddlewares["length"] ? Simplify<TContext & UnionToIntersection<ContextFromMiddleware<TMiddlewares[number]>>> : Simplify<TContext>;
+type EndpointOptions<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TMiddlewares extends readonly AnyEndpointMiddleware[] = readonly [], TErrors extends EndpointErrorDefinitions = {}> = {
+    method?: "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
+    body?: TBody;
+    query?: TQuery;
+    headers?: THeaders;
+    middleware?: TMiddlewares;
+    /**
+     * Cache keys, tags, and route paths made stale after a successful handler result.
+     * The resolver receives validated input and middleware context.
+     */
+    invalidates?: EndpointInvalidations<InferEndpointMiddlewareContext<TMiddlewares>, InferOutput<TBody>, InferOutput<TQuery>, InferHeadersOutput<THeaders>>;
+    errors?: TErrors;
+    /** @deprecated Use plain functions in `middleware` for Farm endpoint middleware. */
+    use?: any[];
+};
+type EndpointHandler<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any, TContext extends object = {}, TErrors extends EndpointErrorDefinitions = {}> = (ctx: {
+    body: InferOutput<TBody>;
+    query: InferOutput<TQuery>;
+    headers: InferHeadersOutput<THeaders>;
+    request: Request;
+    context: Readonly<TContext>;
+    params: EndpointParams;
+    fail: EndpointFail<TErrors>;
+}) => Promise<TResponse> | TResponse;
+type TypedEndpoint<TBody = never, TQuery = never, TResponse = any, THeaders = Record<string, string>, TErrors = never, TBodyInput = TBody> = {
+    __types: {
+        body: TBody;
+        inputBody: TBodyInput;
+        query: TQuery;
+        headers: THeaders;
+        response: TResponse;
+        errors: TErrors;
+    };
+    __path?: string;
+    __method?: string;
+} & ((options?: {
+    body?: TBody;
+    query?: TQuery;
+}) => Promise<TResponse>);
+type CreatedEndpoint<TBody extends AnySchema, TQuery extends AnySchema, THeaders extends AnySchema, TResponse, TErrors extends EndpointErrorDefinitions = {}> = TypedEndpoint<InferOutput<TBody>, InferOutput<TQuery>, Awaited<TResponse>, InferHeadersOutput<THeaders>, EndpointErrorContracts<TErrors>, InferBodyInput<TBody>>;
+type AnyEndpointOptions = EndpointOptions<AnySchema, AnySchema, AnySchema, readonly AnyEndpointMiddleware[], EndpointErrorDefinitions>;
+type EndpointBodyFromOptions<TOptions> = TOptions extends {
+    body: infer TBody extends AnySchema;
+} ? TBody : never;
+type EndpointQueryFromOptions<TOptions> = TOptions extends {
+    query: infer TQuery extends AnySchema;
+} ? TQuery : never;
+type EndpointHeadersFromOptions<TOptions> = TOptions extends {
+    headers: infer THeaders extends AnySchema;
+} ? THeaders : never;
+type EndpointMiddlewaresFromOptions<TOptions> = TOptions extends {
+    middleware: infer TMiddlewares extends readonly AnyEndpointMiddleware[];
+} ? TMiddlewares : readonly [];
+type EndpointErrorsFromOptions<TOptions> = TOptions extends {
+    errors: infer TErrors extends EndpointErrorDefinitions;
+} ? TErrors : {};
+type MethodlessEndpointOptions = Omit<AnyEndpointOptions, "method">;
+type EndpointHandlerFromOptions<TOptions, TResponse> = EndpointHandler<EndpointBodyFromOptions<TOptions>, EndpointQueryFromOptions<TOptions>, EndpointHeadersFromOptions<TOptions>, TResponse, InferEndpointMiddlewareContext<EndpointMiddlewaresFromOptions<TOptions>>, EndpointErrorsFromOptions<TOptions>>;
+type ValidatedEndpointHandlerFromOptions<TOptions, TResponse> = EndpointHandlerFromOptions<TOptions, TResponse> & (EndpointMiddlewaresFromOptions<TOptions> extends ValidateEndpointMiddlewares<EndpointMiddlewaresFromOptions<TOptions>> ? unknown : never);
+type CreatedEndpointFromOptions<TOptions, TResponse> = CreatedEndpoint<EndpointBodyFromOptions<TOptions>, EndpointQueryFromOptions<TOptions>, EndpointHeadersFromOptions<TOptions>, TResponse, EndpointErrorsFromOptions<TOptions>>;
+/**
+ * Create a Farm.js API endpoint
+ *
+ * Supports two patterns:
+ * 1. File-based routing (path auto-inferred from file location):
+ *    `export const POST = createEndpoint({ method: 'POST', body: schema }, handler)`
+ *    `createEndpoint({ method: 'GET', query: z.object({...}) }, handler)`
+ *
+ * 2. Explicit path (for routes.ts at project root):
+ *    `createEndpoint('/api/hello', { method: 'GET', query: z.object({...}) }, handler)`
+ */
+declare function createEndpoint<const TOptions extends AnyEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function createEndpoint<const TOptions extends AnyEndpointOptions, TResponse = any>(path: string, options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function createEndpoint<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: EndpointOptions<TBody, TQuery, THeaders, readonly []>, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+declare function createEndpoint<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(path: string, options: EndpointOptions<TBody, TQuery, THeaders, readonly []>, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for GET requests
+ */
+declare function GET<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function GET<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function GET<TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<never, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<never, TQuery, THeaders, TResponse>): CreatedEndpoint<never, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for HEAD requests
+ */
+declare function HEAD<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function HEAD<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function HEAD<TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<never, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<never, TQuery, THeaders, TResponse>): CreatedEndpoint<never, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for POST requests
+ */
+declare function POST<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function POST<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function POST<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for PUT requests
+ */
+declare function PUT<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function PUT<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function PUT<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for DELETE requests
+ */
+declare function DELETE<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function DELETE<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function DELETE<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for PATCH requests
+ */
+declare function PATCH<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function PATCH<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function PATCH<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+/**
+ * Convenience method for OPTIONS requests
+ */
+declare function OPTIONS<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
+declare function OPTIONS<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
+declare function OPTIONS<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
+
+type APIRouteParamValue = string | string[];
+type APIRouteParams = Record<string, APIRouteParamValue>;
+interface APIRouteMatch<T extends {
+    path: string;
+}> {
+    route: T;
+    params: APIRouteParams;
+}
+declare function matchAPIRoute<T extends {
+    path: string;
+}>(routes: Map<string, T>, pathname: string): APIRouteMatch<T> | null;
+declare function invokeAPIRouteEndpoint(endpoint: any, request: Request, params?: APIRouteParams): Promise<Response>;
+declare function normalizeRouteResponse(result: unknown): Response;
+declare function isWebResponse(value: unknown): value is Response;
+declare function createEndpointFailureResponse(failure: EndpointFailure<string, unknown>): Response;
+
+export { type APIRouteMatch as A, DELETE as D, type EndpointErrorDefinition as E, GET as G, HEAD as H, type InferEndpointMiddlewareContext as I, OPTIONS as O, POST as P, type TypedEndpoint as T, isWebResponse as a, type APIRouteParams as b, type APIRouteParamValue as c, type EndpointErrorDefinitions as d, type EndpointErrorContracts as e, type EndpointFail as f, EndpointFailure as g, isEndpointFailure as h, invokeAPIRouteEndpoint as i, type EndpointParamValue as j, type EndpointParams as k, type EndpointMiddlewareContext as l, matchAPIRoute as m, normalizeRouteResponse as n, type EndpointMiddlewareResult as o, type EndpointMiddleware as p, type AnyEndpointMiddleware as q, type EndpointInvalidationTarget as r, type EndpointInvalidationContext as s, type EndpointInvalidations as t, type EndpointOptions as u, type EndpointHandler as v, createEndpoint as w, PUT as x, PATCH as y, createEndpointFailureResponse as z };

package/dist/runtime-bv63eUiO.d.ts

@@ -0,0 +1,27 @@
+import { F as FarmLocaleResolution } from './resolver-IH4RmPEl.js';
+import { R as ResolvedFarmI18nConfig, F as FarmI18nCatalogs, a as FarmI18nClientSnapshot } from './types-BMxWr97v.js';
+
+declare class FarmI18nRuntime {
+    readonly config: ResolvedFarmI18nConfig;
+    private catalogs;
+    private compiled;
+    private warnedMissing;
+    constructor(config: ResolvedFarmI18nConfig, catalogs?: FarmI18nCatalogs);
+    initialize(): Promise<void>;
+    reload(): Promise<void>;
+    replaceCatalogs(catalogs: FarmI18nCatalogs): void;
+    getCatalogs(): FarmI18nCatalogs;
+    resolveRequest(request: Request, options?: {
+        redirect?: boolean;
+    }): FarmLocaleResolution;
+    translate(locale: string, key: string, values?: Record<string, unknown>): string;
+    translateRich(locale: string, key: string, values?: Record<string, unknown>): unknown;
+    getRawMessage(locale: string, key: string): string;
+    hasMessage(locale: string, key: string): boolean;
+    getClientSnapshot(resolution: FarmLocaleResolution): FarmI18nClientSnapshot;
+    private formatMessage;
+    private resolveMessage;
+}
+declare function createFarmI18nRuntime(config: ResolvedFarmI18nConfig, catalogs?: FarmI18nCatalogs): FarmI18nRuntime;
+
+export { FarmI18nRuntime as F, createFarmI18nRuntime as c };

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

@@ -0,0 +1,43 @@
+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";
+};
+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.d.ts

@@ -0,0 +1,43 @@
+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";
+};
+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-fn-client.d.mts

@@ -0,0 +1,32 @@
+import { ServerFn } from './server-fn.mjs';
+import './cache.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;
+    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;
+};
+declare function useServerFn<TInput, TResult, TError extends Error = Error>(serverFn: ServerFn<TInput, TResult>, options?: UseServerFnOptions<TResult, TError, TInput>): UseServerFnReturn<TInput, TResult, TError>;
+
+export { type ServerFnActionStatus, type ServerFnOptimisticContext, type ServerFnSubmit, type UseServerFnOptions, type UseServerFnReturn, useServerFn };

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

@@ -0,0 +1,32 @@
+import { ServerFn } from './server-fn.js';
+import './cache.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;
+    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;
+};
+declare function useServerFn<TInput, TResult, TError extends Error = Error>(serverFn: ServerFn<TInput, TResult>, options?: UseServerFnOptions<TResult, TError, TInput>): UseServerFnReturn<TInput, TResult, TError>;
+
+export { type ServerFnActionStatus, type ServerFnOptimisticContext, type ServerFnSubmit, type UseServerFnOptions, type UseServerFnReturn, useServerFn };

package/dist/server-fn.d.mts

@@ -0,0 +1,93 @@
+import { FarmCacheInvalidationTarget } from './cache.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 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 ServerFnHandler<TInput, TResult, TContext extends object = {}> = (ctx: ServerFnContext<TInput, TContext>) => 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 []> = {
+    input?: TSchema;
+    output?: undefined;
+    middleware?: TMiddlewares;
+    invalidates?: ServerFnInvalidations<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, Awaited<TResult>, ServerFnMiddlewareContext<TMiddlewares>>;
+    handler: ServerFnHandler<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, TResult, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerFnOutputOptions<TInputSchema extends ServerFnSchema | undefined, TOutputSchema extends ServerFnSchema, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
+    input?: TInputSchema;
+    output: TOutputSchema;
+    middleware?: TMiddlewares;
+    invalidates?: ServerFnInvalidations<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>, ServerFnMiddlewareContext<TMiddlewares>>;
+    handler: ServerFnHandler<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerFn<TInput, TResult> = ([unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>) & {
+    readonly __farmServerFn: true;
+    readonly __farmServerFnInput?: unknown;
+    readonly __farmServerFnOutput?: unknown;
+};
+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 []>(options: ServerFnOutputOptions<TInputSchema, TOutputSchema, TMiddlewares>): ServerFn<InferServerFnSchemaInput<TInputSchema>, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerFn<TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerFnOutputOptions<undefined, TOutputSchema, TMiddlewares>): ServerFn<unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerFn<TSchema extends ServerFnSchema, TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerFnOptions<TSchema, TResult, TMiddlewares>): ServerFn<InferServerFnSchemaInput<TSchema>, Awaited<TResult>>;
+declare function createServerFn<TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerFnOptions<undefined, TResult, TMiddlewares>): ServerFn<unknown, Awaited<TResult>>;
+declare function _parseServerFnSchema(schema: ServerFnSchema | undefined, value: unknown, contract: "input" | "output", owner?: string): Promise<any>;
+
+export { type AnyServerFnMiddleware, FARM_SERVER_FN_SYMBOL, type InferServerFnSchemaInput, type InferServerFnSchemaOutput, type ServerFn, type ServerFnContext, type ServerFnFormInput, type ServerFnHandler, 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,93 @@
+import { FarmCacheInvalidationTarget } from './cache.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 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 ServerFnHandler<TInput, TResult, TContext extends object = {}> = (ctx: ServerFnContext<TInput, TContext>) => 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 []> = {
+    input?: TSchema;
+    output?: undefined;
+    middleware?: TMiddlewares;
+    invalidates?: ServerFnInvalidations<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, Awaited<TResult>, ServerFnMiddlewareContext<TMiddlewares>>;
+    handler: ServerFnHandler<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, TResult, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerFnOutputOptions<TInputSchema extends ServerFnSchema | undefined, TOutputSchema extends ServerFnSchema, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
+    input?: TInputSchema;
+    output: TOutputSchema;
+    middleware?: TMiddlewares;
+    invalidates?: ServerFnInvalidations<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>, ServerFnMiddlewareContext<TMiddlewares>>;
+    handler: ServerFnHandler<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerFn<TInput, TResult> = ([unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>) & {
+    readonly __farmServerFn: true;
+    readonly __farmServerFnInput?: unknown;
+    readonly __farmServerFnOutput?: unknown;
+};
+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 []>(options: ServerFnOutputOptions<TInputSchema, TOutputSchema, TMiddlewares>): ServerFn<InferServerFnSchemaInput<TInputSchema>, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerFn<TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerFnOutputOptions<undefined, TOutputSchema, TMiddlewares>): ServerFn<unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerFn<TSchema extends ServerFnSchema, TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerFnOptions<TSchema, TResult, TMiddlewares>): ServerFn<InferServerFnSchemaInput<TSchema>, Awaited<TResult>>;
+declare function createServerFn<TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerFnOptions<undefined, TResult, TMiddlewares>): ServerFn<unknown, Awaited<TResult>>;
+declare function _parseServerFnSchema(schema: ServerFnSchema | undefined, value: unknown, contract: "input" | "output", owner?: string): Promise<any>;
+
+export { type AnyServerFnMiddleware, FARM_SERVER_FN_SYMBOL, type InferServerFnSchemaInput, type InferServerFnSchemaOutput, type ServerFn, type ServerFnContext, type ServerFnFormInput, type ServerFnHandler, 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 };