@farm.js/core 0.1.0-beta.21 → 0.1.0-beta.22

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-plugins.d.mts

@@ -0,0 +1,57 @@
+import { bi as RedirectConfig, x as FarmRequest, y as FarmResponse, aG as FarmPluginContext, $ as FarmPlugin, bj as HeaderConfig, bk as RewriteConfig } from './client-plugins-QQntVkrv.mjs';
+export { aI as FarmPluginLifecycle, aJ as FarmRequestPluginContext, aK as FarmRequestStore } from './client-plugins-QQntVkrv.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-CusFV6mn.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 { bi as RedirectConfig, x as FarmRequest, y as FarmResponse, aG as FarmPluginContext, $ as FarmPlugin, bj as HeaderConfig, bk as RewriteConfig } from './client-plugins-CbRum1fj.js';
+export { aI as FarmPluginLifecycle, aJ as FarmRequestPluginContext, aK as FarmRequestStore } from './client-plugins-CbRum1fj.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-CusFV6mn.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.d.mts

@@ -0,0 +1,37 @@
+import { RouteDataCacheKey } from './cache.mjs';
+import { ServerFnContext, ServerFnSchema, AnyServerFnMiddleware, InferServerFnSchemaOutput, ServerFnMiddlewareContext, ServerFnHandler, InferServerFnSchemaInput } from './server-fn.mjs';
+import './server-fn-error-DDh14a0V.mjs';
+
+type MaybePromise<T> = T | Promise<T>;
+type ServerQueryStaleTime = number | false | `${number}${"ms" | "s" | "m" | "h"}`;
+type ServerQueryKey<TInput, TContext extends object = {}> = (context: ServerFnContext<TInput, TContext>) => MaybePromise<RouteDataCacheKey>;
+type ServerQueryOptions<TSchema extends ServerFnSchema | undefined, TResult, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
+    input?: TSchema;
+    output?: undefined;
+    middleware?: TMiddlewares;
+    key: ServerQueryKey<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+    /** Milliseconds, a duration string such as "30s", or false for no expiry. */
+    staleTime?: ServerQueryStaleTime;
+    handler: ServerFnHandler<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, TResult, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerQueryOutputOptions<TInputSchema extends ServerFnSchema | undefined, TOutputSchema extends ServerFnSchema, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
+    input?: TInputSchema;
+    output: TOutputSchema;
+    middleware?: TMiddlewares;
+    key: ServerQueryKey<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+    /** Milliseconds, a duration string such as "30s", or false for no expiry. */
+    staleTime?: ServerQueryStaleTime;
+    handler: ServerFnHandler<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerQuery<TInput, TResult> = ([unknown] extends [TInput] ? (input?: TInput) => Promise<TResult> : (input: TInput) => Promise<TResult>) & {
+    readonly __farmServerQuery: true;
+    readonly __farmServerQueryInput?: unknown;
+    readonly __farmServerQueryOutput?: unknown;
+};
+declare const FARM_SERVER_QUERY_SYMBOL: unique symbol;
+declare function createServerQuery<TInputSchema extends ServerFnSchema, TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOutputOptions<TInputSchema, TOutputSchema, TMiddlewares>): ServerQuery<InferServerFnSchemaInput<TInputSchema>, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerQuery<TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOutputOptions<undefined, TOutputSchema, TMiddlewares>): ServerQuery<unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerQuery<TSchema extends ServerFnSchema, TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOptions<TSchema, TResult, TMiddlewares>): ServerQuery<InferServerFnSchemaInput<TSchema>, Awaited<TResult>>;
+declare function createServerQuery<TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOptions<undefined, TResult, TMiddlewares>): ServerQuery<unknown, Awaited<TResult>>;
+
+export { FARM_SERVER_QUERY_SYMBOL, type ServerQuery, type ServerQueryKey, type ServerQueryOptions, type ServerQueryOutputOptions, type ServerQueryStaleTime, createServerQuery };

package/dist/server-query.d.ts

@@ -0,0 +1,37 @@
+import { RouteDataCacheKey } from './cache.js';
+import { ServerFnContext, ServerFnSchema, AnyServerFnMiddleware, InferServerFnSchemaOutput, ServerFnMiddlewareContext, ServerFnHandler, InferServerFnSchemaInput } from './server-fn.js';
+import './server-fn-error-DDh14a0V.js';
+
+type MaybePromise<T> = T | Promise<T>;
+type ServerQueryStaleTime = number | false | `${number}${"ms" | "s" | "m" | "h"}`;
+type ServerQueryKey<TInput, TContext extends object = {}> = (context: ServerFnContext<TInput, TContext>) => MaybePromise<RouteDataCacheKey>;
+type ServerQueryOptions<TSchema extends ServerFnSchema | undefined, TResult, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
+    input?: TSchema;
+    output?: undefined;
+    middleware?: TMiddlewares;
+    key: ServerQueryKey<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+    /** Milliseconds, a duration string such as "30s", or false for no expiry. */
+    staleTime?: ServerQueryStaleTime;
+    handler: ServerFnHandler<TSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TSchema> : unknown, TResult, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerQueryOutputOptions<TInputSchema extends ServerFnSchema | undefined, TOutputSchema extends ServerFnSchema, TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []> = {
+    input?: TInputSchema;
+    output: TOutputSchema;
+    middleware?: TMiddlewares;
+    key: ServerQueryKey<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+    /** Milliseconds, a duration string such as "30s", or false for no expiry. */
+    staleTime?: ServerQueryStaleTime;
+    handler: ServerFnHandler<TInputSchema extends ServerFnSchema ? InferServerFnSchemaOutput<TInputSchema> : unknown, unknown, ServerFnMiddlewareContext<TMiddlewares>>;
+};
+type ServerQuery<TInput, TResult> = ([unknown] extends [TInput] ? (input?: TInput) => Promise<TResult> : (input: TInput) => Promise<TResult>) & {
+    readonly __farmServerQuery: true;
+    readonly __farmServerQueryInput?: unknown;
+    readonly __farmServerQueryOutput?: unknown;
+};
+declare const FARM_SERVER_QUERY_SYMBOL: unique symbol;
+declare function createServerQuery<TInputSchema extends ServerFnSchema, TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOutputOptions<TInputSchema, TOutputSchema, TMiddlewares>): ServerQuery<InferServerFnSchemaInput<TInputSchema>, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerQuery<TOutputSchema extends ServerFnSchema, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOutputOptions<undefined, TOutputSchema, TMiddlewares>): ServerQuery<unknown, Awaited<InferServerFnSchemaOutput<TOutputSchema>>>;
+declare function createServerQuery<TSchema extends ServerFnSchema, TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOptions<TSchema, TResult, TMiddlewares>): ServerQuery<InferServerFnSchemaInput<TSchema>, Awaited<TResult>>;
+declare function createServerQuery<TResult, const TMiddlewares extends readonly AnyServerFnMiddleware[] = readonly []>(options: ServerQueryOptions<undefined, TResult, TMiddlewares>): ServerQuery<unknown, Awaited<TResult>>;
+
+export { FARM_SERVER_QUERY_SYMBOL, type ServerQuery, type ServerQueryKey, type ServerQueryOptions, type ServerQueryOutputOptions, type ServerQueryStaleTime, createServerQuery };

package/dist/server.cjs

@@ -23494,6 +23494,15 @@ __name(normalizeMiddlewareModule, "normalizeMiddlewareModule");
 
 // src/middleware/manager.ts
 init_response();
+
+// src/cli-colors.ts
+var import_picocolors = __toESM(require("picocolors"));
+function createCliColors(interactive = process.stdout.isTTY === true) {
+  return import_picocolors.default.createColors(interactive);
+}
+__name(createCliColors, "createCliColors");
+
+// src/middleware/manager.ts
 function isMiddlewareResponse(value) {
   return value instanceof Response;
 }
@@ -23650,23 +23659,16 @@ var _MiddlewareManager = class _MiddlewareManager {
     if (applicable.length === 0) {
       return false;
     }
-    try {
-      const pc = require("picocolors");
-      const middlewarePaths = applicable.map(({ mw }) => mw.path).join(", ");
-      const log = [
-        pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
-        pc.dim("[") + pc.bold(pc.magenta("MIDDLEWARE")) + pc.dim("]"),
-        pc.dim("[") + pc.bold(pc.white(method.padEnd(3))) + pc.dim("]"),
-        pc.gray("Executing middleware: "),
-        pc.gray(pathname),
-        pc.dim(` (${(Date.now() - startTime).toFixed(2)}ms)`)
-      ].join(" ");
-      console.log(log);
-    } catch {
-      console.log(
-        `[FARM] [MIDDLEWARE] [${method}] Executing ${pathname} (${applicable.length} middleware)`
-      );
-    }
+    const pc = createCliColors();
+    const log = [
+      pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
+      pc.dim("[") + pc.bold(pc.magenta("MIDDLEWARE")) + pc.dim("]"),
+      pc.dim("[") + pc.bold(pc.white(method.padEnd(3))) + pc.dim("]"),
+      pc.gray("Executing middleware: "),
+      pc.gray(pathname),
+      pc.dim(` (${(Date.now() - startTime).toFixed(2)}ms)`)
+    ].join(" ");
+    console.log(log);
     for (const entry of applicable) {
       const { mw, routeMatch } = entry;
       const configMatch = mw.config ? this.matchesConfig(routePathname, mw.config, ctx) : { matched: true };
@@ -24902,7 +24904,7 @@ function transformError(id, message) {
 __name(transformError, "transformError");
 
 // package.json
-var version = "0.1.0-beta.21";
+var version = "0.1.0-beta.22";
 
 // src/version.ts
 var FARM_VERSION = version;
@@ -25607,18 +25609,14 @@ function farmPlugin(options = {}, initialPluginManager) {
   let refreshRouteDiscovery = null;
   let workflowHandler = null;
   const logUpdate = /* @__PURE__ */ __name((tag, message) => {
-    try {
-      const pc = require("picocolors");
-      const log = [
-        pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
-        pc.dim("[") + pc.bold(pc.cyan(tag)) + pc.dim("]"),
-        pc.dim("[") + pc.bold(pc.yellow("UPDATE")) + pc.dim("]"),
-        pc.gray(message)
-      ].join(" ");
-      console.log(log);
-    } catch {
-      console.log(`[FARM] [${tag}] [UPDATE] ${message}`);
-    }
+    const pc = createCliColors();
+    const log = [
+      pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
+      pc.dim("[") + pc.bold(pc.cyan(tag)) + pc.dim("]"),
+      pc.dim("[") + pc.bold(pc.yellow("UPDATE")) + pc.dim("]"),
+      pc.gray(message)
+    ].join(" ");
+    console.log(log);
   }, "logUpdate");
   return {
     name: "farm",
@@ -26059,25 +26057,21 @@ window.__FARM_MANIFEST__ = ${inlineValue({
           return;
         }
         logResponse.__last = { key: dedupeKey, ts: now };
-        try {
-          const pc = require("picocolors");
-          let statusColor = pc.green;
-          if (status >= 500) statusColor = pc.red;
-          else if (status >= 400) statusColor = pc.yellow;
-          else if (status >= 300) statusColor = pc.cyan;
-          const log = [
-            pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
-            pc.dim("[") + pc.bold(pc.cyan(tag)) + pc.dim("]"),
-            pc.dim("[") + pc.bold(pc.white(method.padEnd(3))) + pc.dim("]"),
-            pc.gray(urlPath),
-            pc.dim("-"),
-            statusColor(status.toString()),
-            pc.dim(`(${duration}ms)`)
-          ].join(" ");
-          console.log(log);
-        } catch {
-          console.log(`[FARM] [${tag}] [${method}] ${urlPath} - ${status} (${duration}ms)`);
-        }
+        const pc = createCliColors();
+        let statusColor = pc.green;
+        if (status >= 500) statusColor = pc.red;
+        else if (status >= 400) statusColor = pc.yellow;
+        else if (status >= 300) statusColor = pc.cyan;
+        const log = [
+          pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
+          pc.dim("[") + pc.bold(pc.cyan(tag)) + pc.dim("]"),
+          pc.dim("[") + pc.bold(pc.white(method.padEnd(3))) + pc.dim("]"),
+          pc.gray(urlPath),
+          pc.dim("-"),
+          statusColor(status.toString()),
+          pc.dim(`(${duration}ms)`)
+        ].join(" ");
+        console.log(log);
       }, "logResponse");
       server.middlewares.use(
         _withAfterNodeMiddleware(async (req, res, next) => {
@@ -29143,7 +29137,7 @@ async function defineConfig2(config = {}) {
       return null;
     }
   };
-  const pc = await import("picocolors").then((m) => m.default);
+  const pc = createCliColors();
   let serverStarted = false;
   let startTime = Date.now();
   const farmLogger = {
@@ -30524,22 +30518,6 @@ var DEFAULT_FARM_DEV_SERVER_PORT = 3e3;
 function createBrandingPlugin() {
   let serverStarted = false;
   let startTime = Date.now();
-  const getColors = /* @__PURE__ */ __name(() => {
-    const id = /* @__PURE__ */ __name((s) => s, "id");
-    try {
-      const pc = typeof require === "function" ? require("picocolors") : null;
-      if (pc && typeof pc.createColors === "function") return pc.createColors(true);
-      if (pc) return pc;
-    } catch {
-    }
-    return {
-      dim: id,
-      bold: id,
-      green: id,
-      cyan: id,
-      gray: id
-    };
-  }, "getColors");
   return {
     name: "farm:branding",
     enforce: "pre",
@@ -30553,7 +30531,7 @@ function createBrandingPlugin() {
           const elapsed = Date.now() - startTime;
           const address = server.httpServer?.address();
           const resolvedPort = typeof address === "object" && address ? address.port : server.config.server.port || port || 3e3;
-          const pc = getColors();
+          const pc = createCliColors();
           console.log("");
           console.log(
             `  ${pc.bold(pc.green("Farm.js"))} ${pc.dim(`v${FARM_VERSION}`)} ${pc.dim(`ready in ${elapsed}ms`)}`