@farm.js/core 0.1.14 → 0.1.16

package/dist/request.d.ts

@@ -1,7 +1,8 @@
-export { g as getCurrentRequest } from './request-DsVSQVfD.js';
-import './client-plugins-CslwYp3E.js';
+export { g as getCurrentRequest } from './request-G8JhKr4F.js';
+import './client-plugins-CqVtZi5X.js';
 import './lifecycle-DK06VuKP.js';
-import './route-CHBaW55F.js';
+import './route-BxNJT447.js';
+import './endpoint-kSAxE52R.js';
 import './cache.js';
 import './renderer.js';
 import './deployment.js';
@@ -28,6 +29,8 @@ import './server-fn-error-DDh14a0V.js';
 import 'esbuild';
 import './image-config-Duob7wER.js';
 import './types-Z0aotQ8w.js';
+import './server-fn.js';
+import './server-query.js';
 import './types-DQnyD3VD.js';
 import './font.js';
 import './after.js';

package/dist/route-BxNJT447.d.ts

@@ -0,0 +1,128 @@
+import { E as EndpointMiddlewareResult, R as RouteSchema, a as RouteSchemaOutput, b as EndpointMCPOptions, A as AnyEndpointMiddleware, I as InferEndpointMiddlewareContext, T as TypedEndpoint, c as RouteSchemaInput } from './endpoint-kSAxE52R.js';
+
+type RouteMethod = "GET" | "HEAD" | "QUERY" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
+type RoutePathParams<Path extends string> = Path extends `${infer Head}/${infer Tail}` ? RoutePathParams<Head> & RoutePathParams<Tail> : Path extends `[[...${infer Name}]]` ? {
+    [K in Name]?: string[];
+} : Path extends `[...${infer Name}]` ? {
+    [K in Name]: string[];
+} : Path extends `[${infer Name}]` ? {
+    [K in Name]: string;
+} : {};
+interface RouteInputSchemas {
+    body?: RouteSchema;
+    query?: RouteSchema;
+    params?: RouteSchema;
+    headers?: RouteSchema;
+}
+type Input<I, K extends PropertyKey> = K extends keyof I ? RouteSchemaInput<I[K]> : never;
+type Output<I, K extends PropertyKey, Fallback = unknown> = K extends keyof I ? RouteSchemaOutput<I[K]> : Fallback;
+/** JSON responses have wire types, not server-side instances such as Date. */
+type RouteJSON<T> = T extends Response ? unknown : T extends {
+    toJSON(): infer J;
+} ? RouteJSON<J> : T extends bigint | symbol | ((...args: any[]) => any) ? never : T extends readonly (infer V)[] ? RouteJSON<V>[] : T extends object ? {
+    [K in keyof T]: RouteJSON<T[K]>;
+} : T;
+type RouteDefinition<P extends string = string, M extends RouteMethod = RouteMethod, E = any> = {
+    readonly path: P;
+    readonly method: M;
+    readonly endpoint: E;
+};
+type RouteEndpoint<P extends string, I extends RouteInputSchemas, R> = TypedEndpoint<Output<I, "body">, Input<I, "query">, RouteJSON<R>, Input<I, "headers">, never, Input<I, "body">> & {
+    __types: {
+        params: RoutePathParams<P>;
+        inputHeaders: Input<I, "headers">;
+    };
+};
+type TrimStart<P extends string> = P extends `/${infer Rest}` ? TrimStart<Rest> : P;
+type Join<P extends string, C extends string> = C extends "" ? P : `${P}/${TrimStart<C>}`;
+type ParamsCheck<P extends string, I extends RouteInputSchemas> = I extends {
+    params: infer S;
+} ? Exclude<keyof RoutePathParams<P>, keyof RouteSchemaOutput<S>> extends never ? Exclude<keyof RouteSchemaOutput<S>, keyof RoutePathParams<P>> extends never ? unknown : {
+    __error_unknown_route_params: never;
+} : {
+    __error_missing_route_params: never;
+} : unknown;
+type RouteMiddlewareResults = readonly (EndpointMiddlewareResult | Promise<EndpointMiddlewareResult>)[];
+type RouteMiddlewares<Results extends readonly unknown[]> = {
+    readonly [K in keyof Results]: (context: Parameters<AnyEndpointMiddleware>[0]) => Results[K];
+};
+type RouteOptions<P extends string, I extends RouteInputSchemas, O extends RouteSchema | undefined, R, MiddlewareResults extends RouteMiddlewareResults = RouteMiddlewareResults> = {
+    input?: I & ParamsCheck<P, I>;
+    /** Validate plain JSON handler results. Raw Response/stream results are never buffered. */
+    output?: O;
+    /** Opt this app-owned endpoint into an installed MCP transport. */
+    mcp?: EndpointMCPOptions;
+    middleware?: RouteMiddlewares<MiddlewareResults>;
+    handler(request: Request, context: {
+        input: {
+            body: Output<I, "body">;
+            query: Output<I, "query", Record<string, string | string[]>>;
+            headers: Output<I, "headers", Record<string, string>>;
+            params: Output<I, "params", RoutePathParams<P>>;
+        };
+        params: Output<I, "params", RoutePathParams<P>>;
+        context: Readonly<InferEndpointMiddlewareContext<RouteMiddlewares<MiddlewareResults>>>;
+    }): R | Promise<R>;
+};
+type RouteBuilder<P extends string, M extends RouteMethod> = <const C extends string, const MiddlewareResults extends RouteMiddlewareResults, const I extends RouteInputSchemas = {}, O extends RouteSchema | undefined = undefined, R = unknown>(path: C, options: RouteOptions<Join<P, C>, I, O, R, MiddlewareResults>) => RouteDefinition<Join<P, C>, M, RouteEndpoint<Join<P, C>, I, Extract<Awaited<R>, Response> extends never ? O extends RouteSchema ? RouteSchemaOutput<O> : Awaited<R> : unknown>>;
+type RouteFactory<P extends string = ""> = {
+    [M in Lowercase<RouteMethod>]: RouteBuilder<P, Uppercase<M> & RouteMethod>;
+} & {
+    /** Return a new builder; never mutate the parent scope. */
+    scope<const C extends string>(path: C): RouteFactory<Join<P, C>>;
+};
+type PluginRoutes = readonly RouteDefinition[];
+interface PluginLocalAPIEndpoint {
+    readonly path: string;
+    readonly method: RouteMethod;
+    readonly input: Readonly<RouteInputSchemas>;
+    readonly output?: RouteSchema;
+    readonly mcp?: EndpointMCPOptions;
+    invoke(request: Request, params?: Readonly<Record<string, string | string[]>>): Promise<Response>;
+}
+/**
+ * Read-only access to app-owned API endpoints while plugin routes are mounted.
+ * Plugin routes are intentionally excluded so a plugin cannot recurse through
+ * itself or depend on plugin registration order.
+ */
+interface PluginLocalAPI {
+    /** False during type-only route discovery, where app endpoint modules are unavailable. */
+    readonly available: boolean;
+    get(method: RouteMethod, path: string): PluginLocalAPIEndpoint | undefined;
+    /** Enumerate app-owned endpoints. Plugin routes are excluded. */
+    list(): readonly PluginLocalAPIEndpoint[];
+}
+type PluginRoutesFactory<R extends PluginRoutes = PluginRoutes> = (context: {
+    route: RouteFactory;
+    api: PluginLocalAPI;
+}) => R;
+declare function createRouteFactory(): RouteFactory;
+type UnionToIntersection<U> = (U extends unknown ? (v: U) => void : never) extends (v: infer I) => void ? I : never;
+type RouteTree<P extends string, M extends string, E> = P extends `${infer Head}/${infer Tail}` ? {
+    [K in Head]: RouteTree<Tail, M, E>;
+} : P extends "" ? {
+    [K in Lowercase<M>]: E;
+} : {
+    [K in P]: {
+        [Method in Lowercase<M>]: E;
+    };
+};
+type HasMethodSegment<P extends string> = P extends `${infer H}/${infer T}` ? H extends Lowercase<RouteMethod> ? true : HasMethodSegment<T> : P extends Lowercase<RouteMethod> ? true : false;
+type DefinitionTree<D> = D extends RouteDefinition<infer P, infer M, infer E> ? string extends P ? {} : (P extends `/api/integrations${string}` ? true : HasMethodSegment<P>) extends true ? {
+    [K in P extends `/api/${infer C}` ? `/${C}` : "/"]: {
+        [Method in Lowercase<M>]: E;
+    };
+} : RouteTree<P extends `/api/${infer C}` ? C : "", M, E> : {};
+type PluginAPIRouter<C> = C extends {
+    plugins: readonly (infer P)[];
+} ? UnionToIntersection<P extends {
+    routes?: PluginRoutesFactory<infer R>;
+} ? DefinitionTree<R[number]> : {}> : {};
+declare function resolvePluginRoutes(plugins?: readonly {
+    name: string;
+    routes?: PluginRoutesFactory;
+}[], context?: {
+    api?: PluginLocalAPI;
+}): PluginRoutes;
+
+export { type PluginRoutesFactory as P, type RouteMethod as R, type RoutePathParams as a, type RouteInputSchemas as b, type RouteJSON as c, type RouteDefinition as d, type RouteOptions as e, type RouteFactory as f, type PluginRoutes as g, type PluginLocalAPIEndpoint as h, type PluginLocalAPI as i, createRouteFactory as j, type PluginAPIRouter as k, resolvePluginRoutes as r };

package/dist/route-C_eLaFTZ.d.mts

@@ -0,0 +1,128 @@
+import { E as EndpointMiddlewareResult, R as RouteSchema, a as RouteSchemaOutput, b as EndpointMCPOptions, A as AnyEndpointMiddleware, I as InferEndpointMiddlewareContext, T as TypedEndpoint, c as RouteSchemaInput } from './endpoint-Bu3XgeMK.mjs';
+
+type RouteMethod = "GET" | "HEAD" | "QUERY" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
+type RoutePathParams<Path extends string> = Path extends `${infer Head}/${infer Tail}` ? RoutePathParams<Head> & RoutePathParams<Tail> : Path extends `[[...${infer Name}]]` ? {
+    [K in Name]?: string[];
+} : Path extends `[...${infer Name}]` ? {
+    [K in Name]: string[];
+} : Path extends `[${infer Name}]` ? {
+    [K in Name]: string;
+} : {};
+interface RouteInputSchemas {
+    body?: RouteSchema;
+    query?: RouteSchema;
+    params?: RouteSchema;
+    headers?: RouteSchema;
+}
+type Input<I, K extends PropertyKey> = K extends keyof I ? RouteSchemaInput<I[K]> : never;
+type Output<I, K extends PropertyKey, Fallback = unknown> = K extends keyof I ? RouteSchemaOutput<I[K]> : Fallback;
+/** JSON responses have wire types, not server-side instances such as Date. */
+type RouteJSON<T> = T extends Response ? unknown : T extends {
+    toJSON(): infer J;
+} ? RouteJSON<J> : T extends bigint | symbol | ((...args: any[]) => any) ? never : T extends readonly (infer V)[] ? RouteJSON<V>[] : T extends object ? {
+    [K in keyof T]: RouteJSON<T[K]>;
+} : T;
+type RouteDefinition<P extends string = string, M extends RouteMethod = RouteMethod, E = any> = {
+    readonly path: P;
+    readonly method: M;
+    readonly endpoint: E;
+};
+type RouteEndpoint<P extends string, I extends RouteInputSchemas, R> = TypedEndpoint<Output<I, "body">, Input<I, "query">, RouteJSON<R>, Input<I, "headers">, never, Input<I, "body">> & {
+    __types: {
+        params: RoutePathParams<P>;
+        inputHeaders: Input<I, "headers">;
+    };
+};
+type TrimStart<P extends string> = P extends `/${infer Rest}` ? TrimStart<Rest> : P;
+type Join<P extends string, C extends string> = C extends "" ? P : `${P}/${TrimStart<C>}`;
+type ParamsCheck<P extends string, I extends RouteInputSchemas> = I extends {
+    params: infer S;
+} ? Exclude<keyof RoutePathParams<P>, keyof RouteSchemaOutput<S>> extends never ? Exclude<keyof RouteSchemaOutput<S>, keyof RoutePathParams<P>> extends never ? unknown : {
+    __error_unknown_route_params: never;
+} : {
+    __error_missing_route_params: never;
+} : unknown;
+type RouteMiddlewareResults = readonly (EndpointMiddlewareResult | Promise<EndpointMiddlewareResult>)[];
+type RouteMiddlewares<Results extends readonly unknown[]> = {
+    readonly [K in keyof Results]: (context: Parameters<AnyEndpointMiddleware>[0]) => Results[K];
+};
+type RouteOptions<P extends string, I extends RouteInputSchemas, O extends RouteSchema | undefined, R, MiddlewareResults extends RouteMiddlewareResults = RouteMiddlewareResults> = {
+    input?: I & ParamsCheck<P, I>;
+    /** Validate plain JSON handler results. Raw Response/stream results are never buffered. */
+    output?: O;
+    /** Opt this app-owned endpoint into an installed MCP transport. */
+    mcp?: EndpointMCPOptions;
+    middleware?: RouteMiddlewares<MiddlewareResults>;
+    handler(request: Request, context: {
+        input: {
+            body: Output<I, "body">;
+            query: Output<I, "query", Record<string, string | string[]>>;
+            headers: Output<I, "headers", Record<string, string>>;
+            params: Output<I, "params", RoutePathParams<P>>;
+        };
+        params: Output<I, "params", RoutePathParams<P>>;
+        context: Readonly<InferEndpointMiddlewareContext<RouteMiddlewares<MiddlewareResults>>>;
+    }): R | Promise<R>;
+};
+type RouteBuilder<P extends string, M extends RouteMethod> = <const C extends string, const MiddlewareResults extends RouteMiddlewareResults, const I extends RouteInputSchemas = {}, O extends RouteSchema | undefined = undefined, R = unknown>(path: C, options: RouteOptions<Join<P, C>, I, O, R, MiddlewareResults>) => RouteDefinition<Join<P, C>, M, RouteEndpoint<Join<P, C>, I, Extract<Awaited<R>, Response> extends never ? O extends RouteSchema ? RouteSchemaOutput<O> : Awaited<R> : unknown>>;
+type RouteFactory<P extends string = ""> = {
+    [M in Lowercase<RouteMethod>]: RouteBuilder<P, Uppercase<M> & RouteMethod>;
+} & {
+    /** Return a new builder; never mutate the parent scope. */
+    scope<const C extends string>(path: C): RouteFactory<Join<P, C>>;
+};
+type PluginRoutes = readonly RouteDefinition[];
+interface PluginLocalAPIEndpoint {
+    readonly path: string;
+    readonly method: RouteMethod;
+    readonly input: Readonly<RouteInputSchemas>;
+    readonly output?: RouteSchema;
+    readonly mcp?: EndpointMCPOptions;
+    invoke(request: Request, params?: Readonly<Record<string, string | string[]>>): Promise<Response>;
+}
+/**
+ * Read-only access to app-owned API endpoints while plugin routes are mounted.
+ * Plugin routes are intentionally excluded so a plugin cannot recurse through
+ * itself or depend on plugin registration order.
+ */
+interface PluginLocalAPI {
+    /** False during type-only route discovery, where app endpoint modules are unavailable. */
+    readonly available: boolean;
+    get(method: RouteMethod, path: string): PluginLocalAPIEndpoint | undefined;
+    /** Enumerate app-owned endpoints. Plugin routes are excluded. */
+    list(): readonly PluginLocalAPIEndpoint[];
+}
+type PluginRoutesFactory<R extends PluginRoutes = PluginRoutes> = (context: {
+    route: RouteFactory;
+    api: PluginLocalAPI;
+}) => R;
+declare function createRouteFactory(): RouteFactory;
+type UnionToIntersection<U> = (U extends unknown ? (v: U) => void : never) extends (v: infer I) => void ? I : never;
+type RouteTree<P extends string, M extends string, E> = P extends `${infer Head}/${infer Tail}` ? {
+    [K in Head]: RouteTree<Tail, M, E>;
+} : P extends "" ? {
+    [K in Lowercase<M>]: E;
+} : {
+    [K in P]: {
+        [Method in Lowercase<M>]: E;
+    };
+};
+type HasMethodSegment<P extends string> = P extends `${infer H}/${infer T}` ? H extends Lowercase<RouteMethod> ? true : HasMethodSegment<T> : P extends Lowercase<RouteMethod> ? true : false;
+type DefinitionTree<D> = D extends RouteDefinition<infer P, infer M, infer E> ? string extends P ? {} : (P extends `/api/integrations${string}` ? true : HasMethodSegment<P>) extends true ? {
+    [K in P extends `/api/${infer C}` ? `/${C}` : "/"]: {
+        [Method in Lowercase<M>]: E;
+    };
+} : RouteTree<P extends `/api/${infer C}` ? C : "", M, E> : {};
+type PluginAPIRouter<C> = C extends {
+    plugins: readonly (infer P)[];
+} ? UnionToIntersection<P extends {
+    routes?: PluginRoutesFactory<infer R>;
+} ? DefinitionTree<R[number]> : {}> : {};
+declare function resolvePluginRoutes(plugins?: readonly {
+    name: string;
+    routes?: PluginRoutesFactory;
+}[], context?: {
+    api?: PluginLocalAPI;
+}): PluginRoutes;
+
+export { type PluginRoutesFactory as P, type RouteMethod as R, type RoutePathParams as a, type RouteInputSchemas as b, type RouteJSON as c, type RouteDefinition as d, type RouteOptions as e, type RouteFactory as f, type PluginRoutes as g, type PluginLocalAPIEndpoint as h, type PluginLocalAPI as i, createRouteFactory as j, type PluginAPIRouter as k, resolvePluginRoutes as r };

package/dist/{route-rendering-hUETRCbM.d.ts → route-rendering-BcLLPJgN.d.ts}

@@ -1,4 +1,4 @@
-import { k as RouteModule } from './client-plugins-CslwYp3E.js';
+import { k as RouteModule } from './client-plugins-CqVtZi5X.js';
 
 /**
  * The rendering-mode merge shared by every consumer of route directives.

package/dist/{route-rendering-LT4XSoQK.d.mts → route-rendering-CbAKr1TY.d.mts}

@@ -1,4 +1,4 @@
-import { k as RouteModule } from './client-plugins-C1EgdoJM.mjs';
+import { k as RouteModule } from './client-plugins-CIPRtSsW.mjs';
 
 /**
  * The rendering-mode merge shared by every consumer of route directives.

package/dist/routes.d.mts

@@ -1,10 +1,11 @@
-import { F as FarmRouteRuntimeConfig, L as LayoutProps, M as Metadata, e as FarmRouteRuntime, f as FarmRouteRegions, g as FarmRouteMaxDuration, h as FarmAppContext, i as PageProps, j as PluginContextProps, k as RouteModule, P as ParsedRoute } from './client-plugins-C1EgdoJM.mjs';
+import { F as FarmRouteRuntimeConfig, L as LayoutProps, M as Metadata, e as FarmRouteRuntime, f as FarmRouteRegions, g as FarmRouteMaxDuration, h as FarmAppContext, i as PageProps, j as PluginContextProps, k as RouteModule, P as ParsedRoute } from './client-plugins-CIPRtSsW.mjs';
 import { ComponentType } from 'react';
 import { RouteDataCacheKey } from './cache.mjs';
 import { ServerFn } from './server-fn.mjs';
 import { FarmServerRendererRuntime } from './renderer.mjs';
 import './lifecycle-DK06VuKP.mjs';
-import './route-C6UClI1z.mjs';
+import './route-C_eLaFTZ.mjs';
+import './endpoint-Bu3XgeMK.mjs';
 import 'http';
 import './markdown.mjs';
 import './types-Cc8l9IqS.mjs';
@@ -27,6 +28,7 @@ import './server-fn-error-DDh14a0V.mjs';
 import 'esbuild';
 import './image-config-Duob7wER.mjs';
 import './types-Z0aotQ8w.mjs';
+import './server-query.mjs';
 import './types-DQnyD3VD.mjs';
 import './font.mjs';
 import './after.mjs';

package/dist/routes.d.ts

@@ -1,10 +1,11 @@
-import { F as FarmRouteRuntimeConfig, L as LayoutProps, M as Metadata, e as FarmRouteRuntime, f as FarmRouteRegions, g as FarmRouteMaxDuration, h as FarmAppContext, i as PageProps, j as PluginContextProps, k as RouteModule, P as ParsedRoute } from './client-plugins-CslwYp3E.js';
+import { F as FarmRouteRuntimeConfig, L as LayoutProps, M as Metadata, e as FarmRouteRuntime, f as FarmRouteRegions, g as FarmRouteMaxDuration, h as FarmAppContext, i as PageProps, j as PluginContextProps, k as RouteModule, P as ParsedRoute } from './client-plugins-CqVtZi5X.js';
 import { ComponentType } from 'react';
 import { RouteDataCacheKey } from './cache.js';
 import { ServerFn } from './server-fn.js';
 import { FarmServerRendererRuntime } from './renderer.js';
 import './lifecycle-DK06VuKP.js';
-import './route-CHBaW55F.js';
+import './route-BxNJT447.js';
+import './endpoint-kSAxE52R.js';
 import 'http';
 import './markdown.js';
 import './types-Cc8l9IqS.js';
@@ -27,6 +28,7 @@ import './server-fn-error-DDh14a0V.js';
 import 'esbuild';
 import './image-config-Duob7wER.js';
 import './types-Z0aotQ8w.js';
+import './server-query.js';
 import './types-DQnyD3VD.js';
 import './font.js';
 import './after.js';

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

@@ -1,11 +1,12 @@
 import { FormHTMLAttributes, ComponentType } from 'react';
 import { ServerFn } from './server-fn.mjs';
-import { R as RetryOptions } from './api-client-C8d7BZNp.mjs';
+import { R as RetryOptions } from './api-client-B-n3pm_Q.mjs';
 import './cache.mjs';
 import './server-fn-error-DDh14a0V.mjs';
+import './endpoint-Bu3XgeMK.mjs';
 import './integration-api-BbaiokCC.mjs';
 import './client-cache-di_Nasxa.mjs';
-import './route-C6UClI1z.mjs';
+import './route-C_eLaFTZ.mjs';
 
 type ServerFnActionStatus = "idle" | "pending" | "success" | "error";
 type ServerFnSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;

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

@@ -1,11 +1,12 @@
 import { FormHTMLAttributes, ComponentType } from 'react';
 import { ServerFn } from './server-fn.js';
-import { R as RetryOptions } from './api-client-BWrEbxfO.js';
+import { R as RetryOptions } from './api-client-C0_NZEBl.js';
 import './cache.js';
 import './server-fn-error-DDh14a0V.js';
+import './endpoint-kSAxE52R.js';
 import './integration-api-BbaiokCC.js';
 import './client-cache-Deoqq-nM.js';
-import './route-CHBaW55F.js';
+import './route-BxNJT447.js';
 
 type ServerFnActionStatus = "idle" | "pending" | "success" | "error";
 type ServerFnSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;

package/dist/server-fn.cjs

@@ -25,9 +25,14 @@ __export(server_fn_exports, {
   FARM_SERVER_FN_SYMBOL: () => FARM_SERVER_FN_SYMBOL,
   ServerActionError: () => ServerActionError,
   ServerFnFailure: () => ServerFnFailure,
+  _attachServerFunctionDescriptor: () => _attachServerFunctionDescriptor,
+  _describeServerFunction: () => _describeServerFunction,
+  _invokeServerFunction: () => _invokeServerFunction,
   _parseServerFnSchema: () => _parseServerFnSchema,
+  _runServerFunctionForCaller: () => _runServerFunctionForCaller,
   createServerFn: () => createServerFn,
   createServerFnTransportError: () => createServerFnTransportError,
+  createServerFunctionDescriptor: () => createServerFunctionDescriptor,
   createServerMiddleware: () => createServerMiddleware,
   isServerFnFailure: () => isServerFnFailure
 });
@@ -137,6 +142,26 @@ __name(isSerializedServerFnFailure, "isSerializedServerFnFailure");
 // 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");
+async function runWithServerActionRequest(request, callback) {
+  throwIfAborted(request.signal);
+  const context2 = {
+    request,
+    signal: request.signal,
+    invalidations: /* @__PURE__ */ new Set(),
+    cacheTasks: /* @__PURE__ */ new Set()
+  };
+  return getServerActionStorage().run(context2, async () => {
+    try {
+      const result = await callback();
+      await Promise.all(context2.cacheTasks);
+      return result;
+    } catch (error) {
+      await Promise.allSettled(context2.cacheTasks);
+      throw error;
+    }
+  });
+}
+__name(runWithServerActionRequest, "runWithServerActionRequest");
 function getServerActionExecutionContext() {
   return getServerActionStorage().getStore();
 }
@@ -167,6 +192,12 @@ function getFallbackAbortController() {
   return globalState2[FALLBACK_ABORT_CONTROLLER_KEY];
 }
 __name(getFallbackAbortController, "getFallbackAbortController");
+function throwIfAborted(signal) {
+  if (!signal.aborted) return;
+  if (signal.reason !== void 0) throw signal.reason;
+  throw new DOMException("The operation was aborted", "AbortError");
+}
+__name(throwIfAborted, "throwIfAborted");
 
 // src/server/request-bridge.ts
 var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
@@ -1379,8 +1410,100 @@ function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
 }
 __name(stableSerialize, "stableSerialize");
 
+// src/navigation-errors.ts
+var REDIRECT_ERROR_CODE = "FARM_REDIRECT";
+var REDIRECT_ERROR_SYMBOL = /* @__PURE__ */ Symbol.for("farm.navigation.redirect");
+function getFarmRedirectError(error) {
+  if (!error || typeof error !== "object") return null;
+  const candidate = error;
+  if (candidate[REDIRECT_ERROR_SYMBOL]) {
+    return candidate[REDIRECT_ERROR_SYMBOL];
+  }
+  if (typeof candidate.digest === "string" && candidate.digest.startsWith(`${REDIRECT_ERROR_CODE};`)) {
+    const [, status, ...urlParts] = candidate.digest.split(";");
+    const parsedStatus = Number(status);
+    if (isFarmRedirectStatus(parsedStatus)) {
+      return {
+        status: parsedStatus,
+        url: urlParts.join(";")
+      };
+    }
+  }
+  return null;
+}
+__name(getFarmRedirectError, "getFarmRedirectError");
+function isFarmRedirectStatus(status) {
+  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+__name(isFarmRedirectStatus, "isFarmRedirectStatus");
+
 // src/server-fn.ts
 var FARM_SERVER_FN_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn");
+var FARM_SERVER_FUNCTION_DESCRIPTOR = /* @__PURE__ */ Symbol.for("farm.server-function.descriptor");
+var _ServerFnInputError = class _ServerFnInputError extends Error {
+  constructor(cause) {
+    super("Server function input is invalid");
+    this.cause = cause;
+  }
+};
+__name(_ServerFnInputError, "ServerFnInputError");
+var ServerFnInputError = _ServerFnInputError;
+function createServerFunctionDescriptor(kind, options, run) {
+  return Object.freeze({
+    kind,
+    input: options.input,
+    output: options.output,
+    mcp: options.mcp === void 0 ? void 0 : Object.freeze({ ...options.mcp }),
+    run
+  });
+}
+__name(createServerFunctionDescriptor, "createServerFunctionDescriptor");
+function _attachServerFunctionDescriptor(target, descriptor) {
+  Object.defineProperty(target, FARM_SERVER_FUNCTION_DESCRIPTOR, {
+    value: descriptor,
+    enumerable: false
+  });
+}
+__name(_attachServerFunctionDescriptor, "_attachServerFunctionDescriptor");
+function getServerFunctionRunner(value) {
+  if (typeof value !== "function") return void 0;
+  return value[FARM_SERVER_FUNCTION_DESCRIPTOR];
+}
+__name(getServerFunctionRunner, "getServerFunctionRunner");
+function _runServerFunctionForCaller(value, input) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) throw new TypeError("Expected a function created with createServerFn");
+  return runner.run(input);
+}
+__name(_runServerFunctionForCaller, "_runServerFunctionForCaller");
+function _describeServerFunction(value) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) return void 0;
+  const { kind, input, output, mcp } = runner;
+  return Object.freeze({ kind, input, output, mcp });
+}
+__name(_describeServerFunction, "_describeServerFunction");
+async function _invokeServerFunction(value, input, request) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) {
+    throw new TypeError("Expected a function created with createServerFn or createServerQuery");
+  }
+  try {
+    const data = await runWithServerActionRequest(request, () => runner.run(input));
+    return { ok: true, data };
+  } catch (error) {
+    if (error instanceof ServerFnInputError) {
+      return { ok: false, reason: "input", error: error.cause };
+    }
+    if (isServerFnFailure(error)) return { ok: false, reason: "failure", failure: error };
+    const redirect = getFarmRedirectError(error);
+    if (redirect) {
+      return { ok: false, reason: "redirect", url: redirect.url, status: redirect.status };
+    }
+    return { ok: false, reason: "error", error };
+  }
+}
+__name(_invokeServerFunction, "_invokeServerFunction");
 var UNSAFE_FORM_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function createServerMiddleware(options) {
   if (!options || typeof options.handler !== "function") {
@@ -1404,10 +1527,15 @@ function createServerFn(options) {
   const middleware = resolveServerFnMiddleware(options.middleware);
   const errors = normalizeServerFnErrors(options.errors);
   const error = createServerFnErrorHandler(errors);
-  const serverFn = /* @__PURE__ */ __name(async (value) => {
+  const run = /* @__PURE__ */ __name(async (value, labelInputErrors) => {
     const formData = isFormData(value) ? value : void 0;
     const rawInput = formData ? formDataToObject(formData) : value;
-    const input = await _parseServerFnSchema(options.input, rawInput, "input");
+    let input;
+    try {
+      input = await _parseServerFnSchema(options.input, rawInput, "input");
+    } catch (cause) {
+      throw labelInputErrors ? new ServerFnInputError(cause) : cause;
+    }
     const executionContext = getServerActionExecutionContext();
     const request = executionContext?.request ?? _resolveCurrentRequest();
     const signal = executionContext?.signal ?? request?.signal ?? getServerActionSignal();
@@ -1433,7 +1561,8 @@ function createServerFn(options) {
       await applyFarmCacheInvalidationTargets(declaration);
     }
     return parsedResult;
-  }, "serverFn");
+  }, "run");
+  const serverFn = /* @__PURE__ */ __name((value) => run(value, false), "serverFn");
   Object.defineProperties(serverFn, {
     [FARM_SERVER_FN_SYMBOL]: {
       value: true,
@@ -1464,6 +1593,10 @@ function createServerFn(options) {
       enumerable: false
     }
   });
+  _attachServerFunctionDescriptor(
+    serverFn,
+    createServerFunctionDescriptor("action", options, (value) => run(value, true))
+  );
   return serverFn;
 }
 __name(createServerFn, "createServerFn");
@@ -1665,9 +1798,14 @@ __name(isFormData, "isFormData");
   FARM_SERVER_FN_SYMBOL,
   ServerActionError,
   ServerFnFailure,
+  _attachServerFunctionDescriptor,
+  _describeServerFunction,
+  _invokeServerFunction,
   _parseServerFnSchema,
+  _runServerFunctionForCaller,
   createServerFn,
   createServerFnTransportError,
+  createServerFunctionDescriptor,
   createServerMiddleware,
   isServerFnFailure
 });