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

package/dist/routes.d.ts

@@ -0,0 +1,224 @@
+import { F as FarmRouteRuntimeConfig, a as FarmRouteRuntime, b as FarmRouteRegions, c as FarmRouteMaxDuration } from './route-runtime-DoOHzCAD.js';
+import { ComponentType } from 'react';
+import { RouteDataCacheKey } from './cache.js';
+import { k as LayoutProps, s as Metadata, h as FarmAppContext, i as PageProps, P as PluginContextProps, p as RouteModule, x as ParsedRoute } from './client-plugins-DU9oMspX.js';
+import './plugin-BJDf43dc.js';
+import 'http';
+import './types-D1A6-XvH.js';
+import 'db0';
+import 'unstorage';
+import './integration-api-CHT2OKAf.js';
+import '@farming-labs/orm';
+import './types-C9N-nk5R.js';
+import '@farming-labs/docs';
+import './markdown.js';
+import './observability.js';
+import 'vite';
+import './workflows.js';
+import './cron.js';
+import './env.js';
+import './server-action-security.js';
+import './image-config-Duob7wER.js';
+import './types-BMxWr97v.js';
+
+type ProgrammaticRouteRenderMode = "static" | "dynamic";
+type ProgrammaticRouteMethod = "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
+type ProgrammaticRoutePrimitive = string | number | boolean;
+type ProgrammaticStaticPathParams = Record<string, ProgrammaticRoutePrimitive | readonly ProgrammaticRoutePrimitive[]>;
+type ProgrammaticStaticPath = string | readonly ProgrammaticRoutePrimitive[] | ProgrammaticStaticPathParams;
+type ProgrammaticStaticPaths = () => readonly ProgrammaticStaticPath[] | Promise<readonly ProgrammaticStaticPath[]>;
+interface ProgrammaticRouteSchema<TOutput = unknown> {
+    parse(value: unknown): TOutput;
+}
+interface ProgrammaticRouteSearchOptions<TOutput = ProgrammaticRouteSearchFallback> {
+    schema?: ProgrammaticRouteSchema<TOutput>;
+    stripDefaults?: boolean | readonly string[];
+    preserve?: readonly string[];
+    temporary?: readonly string[];
+}
+type ProgrammaticRouteSearchConfig<TOutput = ProgrammaticRouteSearchFallback> = ProgrammaticRouteSchema<TOutput> | ProgrammaticRouteSearchOptions<TOutput>;
+type InferProgrammaticRouteSchema<TSchema, TFallback> = TSchema extends ProgrammaticRouteSchema<infer TOutput> ? TOutput : TFallback;
+type InferProgrammaticRouteSearch<TSearch, TFallback> = TSearch extends ProgrammaticRouteSearchOptions<infer TOutput> ? TOutput : TSearch extends ProgrammaticRouteSchema<infer TOutput> ? TOutput : TFallback;
+type ProgrammaticRouteParamsFallback = Record<string, string>;
+type ProgrammaticRouteSearchFallback = Record<string, string | string[] | undefined>;
+type ProgrammaticRouteMaybePromise<T> = T | Promise<T>;
+type ProgrammaticRouteDataStaleTime = number | false | `${number}ms` | `${number}s` | `${number}m` | `${number}h`;
+type ProgrammaticRouteContext = keyof FarmAppContext extends never ? unknown : FarmAppContext;
+type ProgrammaticRouteComponentProps<TParams = ProgrammaticRouteParamsFallback, TSearch = ProgrammaticRouteSearchFallback, TData = undefined> = Omit<PageProps, "params" | "searchParams"> & {
+    params: TParams;
+    search: TSearch;
+    searchParams: Promise<TSearch>;
+} & ([TData] extends [undefined] ? {
+    data?: undefined;
+} : {
+    data: TData;
+});
+type ProgrammaticRouteDataContext<TParams = ProgrammaticRouteParamsFallback, TSearch = ProgrammaticRouteSearchFallback, TContext = ProgrammaticRouteContext> = Omit<ProgrammaticRouteComponentProps<TParams, TSearch>, "context" | "data"> & {
+    context: TContext;
+    pluginContext?: PluginContextProps;
+};
+type ProgrammaticRouteDataCacheContext<TParams = ProgrammaticRouteParamsFallback, TSearch = ProgrammaticRouteSearchFallback, TBefore = unknown, TContext = ProgrammaticRouteContext> = ProgrammaticRouteDataContext<TParams, TSearch, TContext> & {
+    before: TBefore;
+};
+type ProgrammaticRouteGuardContext<TParams = ProgrammaticRouteParamsFallback, TSearch = ProgrammaticRouteSearchFallback, TContext = ProgrammaticRouteContext> = ProgrammaticRouteDataContext<TParams, TSearch, TContext>;
+type ProgrammaticRouteGuard<TParams = ProgrammaticRouteParamsFallback, TSearch = ProgrammaticRouteSearchFallback, TContext = ProgrammaticRouteContext> = (context: ProgrammaticRouteGuardContext<TParams, TSearch, TContext>) => ProgrammaticRouteMaybePromise<void>;
+type ProgrammaticRouteErrorComponentProps<TParams = ProgrammaticRouteParamsFallback, TSearch = ProgrammaticRouteSearchFallback> = Partial<ProgrammaticRouteComponentProps<TParams, TSearch>> & {
+    error: unknown;
+};
+type ProgrammaticRoutePendingComponentProps<TParams = ProgrammaticRouteParamsFallback, TSearch = ProgrammaticRouteSearchFallback> = Partial<ProgrammaticRouteComponentProps<TParams, TSearch>>;
+type ProgrammaticRouteDataCacheKeys<TParams = ProgrammaticRouteParamsFallback, TSearch = ProgrammaticRouteSearchFallback, TBefore = unknown, TContext = ProgrammaticRouteContext> = readonly string[] | ((context: ProgrammaticRouteDataCacheContext<TParams, TSearch, TBefore, TContext>) => ProgrammaticRouteMaybePromise<readonly string[]>);
+interface ProgrammaticRouteDataHooks<TParams = ProgrammaticRouteParamsFallback, TSearch = ProgrammaticRouteSearchFallback, TBefore = unknown, TData = unknown, TContext = ProgrammaticRouteContext> {
+    key?: (context: ProgrammaticRouteDataCacheContext<TParams, TSearch, NoInfer<TBefore>, TContext>) => ProgrammaticRouteMaybePromise<RouteDataCacheKey | null | undefined>;
+    staleTime?: ProgrammaticRouteDataStaleTime;
+    tags?: ProgrammaticRouteDataCacheKeys<TParams, TSearch, NoInfer<TBefore>, TContext>;
+    paths?: ProgrammaticRouteDataCacheKeys<TParams, TSearch, NoInfer<TBefore>, TContext>;
+    before?: (context: ProgrammaticRouteDataContext<TParams, TSearch, TContext>) => ProgrammaticRouteMaybePromise<TBefore>;
+    main: (context: ProgrammaticRouteDataContext<TParams, TSearch, TContext> & {
+        before: NoInfer<TBefore>;
+    }) => ProgrammaticRouteMaybePromise<TData>;
+    after?: (context: ProgrammaticRouteDataContext<TParams, TSearch, TContext> & {
+        before: NoInfer<TBefore>;
+        data: NoInfer<TData>;
+    }) => ProgrammaticRouteMaybePromise<void>;
+}
+type InferProgrammaticRouteData<TDataHooks> = TDataHooks extends {
+    main: (...args: any[]) => infer TResult;
+} ? Awaited<TResult> : undefined;
+interface ProgrammaticPageRoute<TParams = ProgrammaticRouteParamsFallback, TSearch = ProgrammaticRouteSearchFallback, TDataHooks extends ProgrammaticRouteDataHooks<TParams, TSearch, any, any, any> | undefined = ProgrammaticRouteDataHooks<TParams, TSearch, any, any, any> | undefined, TContext = ProgrammaticRouteContext> extends FarmRouteRuntimeConfig {
+    kind: "page";
+    path: string;
+    component: ComponentType<any>;
+    params?: ProgrammaticRouteSchema<TParams>;
+    search?: ProgrammaticRouteSearchConfig<TSearch>;
+    guard?: ProgrammaticRouteGuard<TParams, TSearch, TContext>;
+    data?: TDataHooks;
+    pending?: ComponentType<ProgrammaticRoutePendingComponentProps<TParams, TSearch>>;
+    error?: ComponentType<ProgrammaticRouteErrorComponentProps<TParams, TSearch>>;
+    notFound?: ComponentType<ProgrammaticRouteErrorComponentProps<TParams, TSearch>>;
+    render?: ProgrammaticRouteRenderMode;
+    staticPaths?: ProgrammaticStaticPaths;
+    revalidate?: number | false;
+    ppr?: boolean;
+    metadata?: Metadata & Record<string, any>;
+    generateMetadata?: RouteModule["generateMetadata"];
+}
+interface ProgrammaticLayoutRoute extends FarmRouteRuntimeConfig {
+    kind: "layout";
+    path: string;
+    component: ComponentType<LayoutProps>;
+    metadata?: Metadata & Record<string, any>;
+    generateMetadata?: (props: {
+        params: Record<string, string>;
+    }) => Promise<Metadata> | Metadata;
+}
+type ProgrammaticApiRouteOptions = Partial<Record<ProgrammaticRouteMethod, any>> & {
+    render?: ProgrammaticRouteRenderMode;
+} & FarmRouteRuntimeConfig;
+interface ProgrammaticApiRoute extends FarmRouteRuntimeConfig {
+    kind: "api";
+    path: string;
+    methods: Partial<Record<ProgrammaticRouteMethod, any>>;
+    render?: ProgrammaticRouteRenderMode;
+}
+interface ProgrammaticRedirectRoute {
+    kind: "redirect";
+    source: string;
+    destination: string;
+    permanent?: boolean;
+    statusCode?: number;
+}
+type ProgrammaticRouteDefinition = ProgrammaticPageRoute<any, any> | ProgrammaticLayoutRoute | ProgrammaticApiRoute | ProgrammaticRedirectRoute;
+interface ProgrammaticRouteManifest {
+    readonly __farmRoutes: true;
+    routes: ProgrammaticRouteDefinition[];
+}
+interface ProgrammaticRouteBuilder {
+    page(path: string, options: Omit<ProgrammaticPageRoute<any, any>, "kind" | "path">): ProgrammaticPageRoute;
+    layout(path: string, options: Omit<ProgrammaticLayoutRoute, "kind" | "path">): ProgrammaticLayoutRoute;
+    api(path: string, options: ProgrammaticApiRouteOptions): ProgrammaticApiRoute;
+    redirect(source: string, destination: string, options?: Omit<ProgrammaticRedirectRoute, "kind" | "source" | "destination">): ProgrammaticRedirectRoute;
+}
+type ProgrammaticRouteFactory = (builder: ProgrammaticRouteBuilder) => readonly ProgrammaticRouteDefinition[];
+type CreateRouteParams<TParamsSchema> = InferProgrammaticRouteSchema<TParamsSchema, ProgrammaticRouteParamsFallback>;
+type CreateRouteSearch<TSearchConfig> = InferProgrammaticRouteSearch<TSearchConfig, ProgrammaticRouteSearchFallback>;
+type CreateRouteSharedOptions<TParamsSchema extends ProgrammaticRouteSchema<any> | undefined, TSearchConfig extends ProgrammaticRouteSearchConfig<any> | undefined> = Omit<ProgrammaticPageRoute<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>>, "kind" | "path" | "component" | "params" | "search" | "data" | "guard"> & {
+    params?: TParamsSchema;
+    search?: TSearchConfig;
+    guard?: ProgrammaticRouteGuard<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>>;
+};
+type CreateRouteDataHooksWithBefore<TParams, TSearch, TBeforeResult, TMainResult, TContext = ProgrammaticRouteContext> = Omit<ProgrammaticRouteDataHooks<TParams, TSearch, NoInfer<Awaited<TBeforeResult>>, NoInfer<Awaited<TMainResult>>, TContext>, "before" | "main"> & {
+    before: (context: ProgrammaticRouteDataContext<TParams, TSearch, TContext>) => TBeforeResult;
+    main: (context: ProgrammaticRouteDataContext<TParams, TSearch, TContext> & {
+        before: NoInfer<Awaited<TBeforeResult>>;
+    }) => TMainResult;
+};
+type CreateRouteDataHooksWithoutBefore<TParams, TSearch, TMainResult, TContext = ProgrammaticRouteContext> = Omit<ProgrammaticRouteDataHooks<TParams, TSearch, undefined, NoInfer<Awaited<TMainResult>>, TContext>, "before" | "main"> & {
+    before?: undefined;
+    main: (context: ProgrammaticRouteDataContext<TParams, TSearch, TContext> & {
+        before: undefined;
+    }) => TMainResult;
+};
+type CreateRouteOptionsWithBefore<TParamsSchema extends ProgrammaticRouteSchema<any> | undefined, TSearchConfig extends ProgrammaticRouteSearchConfig<any> | undefined, TBefore, TData> = CreateRouteSharedOptions<TParamsSchema, TSearchConfig> & {
+    data: CreateRouteDataHooksWithBefore<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, TBefore, TData>;
+    component: ComponentType<ProgrammaticRouteComponentProps<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, NoInfer<Awaited<TData>>>>;
+};
+type CreateRouteOptionsWithoutBefore<TParamsSchema extends ProgrammaticRouteSchema<any> | undefined, TSearchConfig extends ProgrammaticRouteSearchConfig<any> | undefined, TData> = CreateRouteSharedOptions<TParamsSchema, TSearchConfig> & {
+    data: CreateRouteDataHooksWithoutBefore<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, TData>;
+    component: ComponentType<ProgrammaticRouteComponentProps<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, NoInfer<Awaited<TData>>>>;
+};
+type CreateRouteOptionsWithoutData<TParamsSchema extends ProgrammaticRouteSchema<any> | undefined, TSearchConfig extends ProgrammaticRouteSearchConfig<any> | undefined> = CreateRouteSharedOptions<TParamsSchema, TSearchConfig> & {
+    data?: undefined;
+    component: ComponentType<ProgrammaticRouteComponentProps<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, undefined>>;
+};
+type CreateRouteComponentOption<TComponent extends ComponentType<any>, TProps> = {
+    component: TComponent;
+} & (TComponent extends ComponentType<TProps> ? unknown : {
+    component: ComponentType<TProps>;
+});
+type CreateRouteOptions<TParamsSchema extends ProgrammaticRouteSchema<any> | undefined = undefined, TSearchConfig extends ProgrammaticRouteSearchConfig<any> | undefined = undefined, TBefore = unknown, TData = unknown> = CreateRouteOptionsWithBefore<TParamsSchema, TSearchConfig, TBefore, TData> | CreateRouteOptionsWithoutBefore<TParamsSchema, TSearchConfig, TData> | CreateRouteOptionsWithoutData<TParamsSchema, TSearchConfig>;
+declare const PROGRAMMATIC_ROUTE_FILE_NAMES: string[];
+declare function defineRoutes(input: readonly ProgrammaticRouteDefinition[] | ProgrammaticRouteFactory): ProgrammaticRouteManifest;
+declare const routesBuilder: ProgrammaticRouteBuilder;
+declare const page: (path: string, options: Omit<ProgrammaticPageRoute<any, any>, "kind" | "path">) => ProgrammaticPageRoute;
+declare const layout: (path: string, options: Omit<ProgrammaticLayoutRoute, "kind" | "path">) => ProgrammaticLayoutRoute;
+declare const api: (path: string, options: ProgrammaticApiRouteOptions) => ProgrammaticApiRoute;
+declare const redirect: (source: string, destination: string, options?: Omit<ProgrammaticRedirectRoute, "kind" | "source" | "destination">) => ProgrammaticRedirectRoute;
+interface ProgrammaticRouteSearchClientOptions {
+    stripDefaults?: boolean | readonly string[];
+    preserve?: readonly string[];
+    temporary?: readonly string[];
+}
+interface ProgrammaticRouteSearchResolution<TSearch = unknown> {
+    search: TSearch;
+    canonicalPath?: string;
+}
+declare function getProgrammaticRouteSearchSchema<TSearch = unknown>(search: ProgrammaticRouteSearchConfig<TSearch> | undefined): ProgrammaticRouteSchema<TSearch> | undefined;
+declare function getProgrammaticRouteSearchClientOptions(search: ProgrammaticRouteSearchConfig<any> | undefined): ProgrammaticRouteSearchClientOptions | undefined;
+declare function createRoute<TParamsSchema extends ProgrammaticRouteSchema<any> | undefined = undefined, TSearchConfig extends ProgrammaticRouteSearchConfig<any> | undefined = undefined, TBeforeResult = unknown, TMainResult = unknown, TComponent extends ComponentType<any> = ComponentType<any>>(path: string, options: Omit<CreateRouteOptionsWithBefore<TParamsSchema, TSearchConfig, TBeforeResult, TMainResult>, "component"> & CreateRouteComponentOption<TComponent, ProgrammaticRouteComponentProps<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, Awaited<TMainResult>>>): ProgrammaticPageRoute<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, CreateRouteDataHooksWithBefore<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, TBeforeResult, TMainResult>>;
+declare function createRoute<TParamsSchema extends ProgrammaticRouteSchema<any> | undefined = undefined, TSearchConfig extends ProgrammaticRouteSearchConfig<any> | undefined = undefined, TMainResult = unknown, TComponent extends ComponentType<any> = ComponentType<any>>(path: string, options: Omit<CreateRouteOptionsWithoutBefore<TParamsSchema, TSearchConfig, TMainResult>, "component"> & CreateRouteComponentOption<TComponent, ProgrammaticRouteComponentProps<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, Awaited<TMainResult>>>): ProgrammaticPageRoute<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, CreateRouteDataHooksWithoutBefore<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, TMainResult>>;
+declare function createRoute<TParamsSchema extends ProgrammaticRouteSchema<any> | undefined = undefined, TSearchConfig extends ProgrammaticRouteSearchConfig<any> | undefined = undefined>(path: string, options: CreateRouteOptionsWithoutData<TParamsSchema, TSearchConfig>): ProgrammaticPageRoute<CreateRouteParams<TParamsSchema>, CreateRouteSearch<TSearchConfig>, undefined>;
+declare function isProgrammaticRoutesFileName(fileName: string): boolean;
+declare function getProgrammaticRouteManifest(mod: Record<string, any> | null | undefined): ProgrammaticRouteManifest | null;
+declare function isProgrammaticRouteManifest(value: unknown): value is ProgrammaticRouteManifest;
+declare function isProgrammaticRouteDefinition(value: unknown): value is ProgrammaticRouteDefinition;
+declare function createProgrammaticRouteModuleId(filePath: string, kind: "page" | "layout" | "api", routePath: string): string;
+declare function parseProgrammaticRouteModuleId(moduleId: string): {
+    filePath: string;
+    kind: "page" | "layout" | "api";
+    routePath: string;
+} | null;
+declare function parseProgrammaticRoutePath(routePath: string, type?: ParsedRoute["type"]): ParsedRoute;
+declare function createRouteModuleFromProgrammaticPage(route: ProgrammaticPageRoute): RouteModule;
+declare function createLayoutModuleFromProgrammaticLayout(route: ProgrammaticLayoutRoute): {
+    metadata: (Metadata & Record<string, any>) | undefined;
+    generateMetadata: ((props: {
+        params: Record<string, string>;
+    }) => Promise<Metadata> | Metadata) | undefined;
+    runtime?: FarmRouteRuntime;
+    regions?: FarmRouteRegions;
+    maxDuration?: FarmRouteMaxDuration;
+    default: ComponentType<LayoutProps>;
+};
+declare function scanProgrammaticPagePaths(source: string): string[];
+
+export { type CreateRouteOptions, type InferProgrammaticRouteData, type InferProgrammaticRouteSchema, type InferProgrammaticRouteSearch, PROGRAMMATIC_ROUTE_FILE_NAMES, type ProgrammaticApiRoute, type ProgrammaticApiRouteOptions, type ProgrammaticLayoutRoute, type ProgrammaticPageRoute, type ProgrammaticRedirectRoute, type ProgrammaticRouteBuilder, type ProgrammaticRouteComponentProps, type ProgrammaticRouteContext, type ProgrammaticRouteDataCacheContext, type ProgrammaticRouteDataCacheKeys, type ProgrammaticRouteDataContext, type ProgrammaticRouteDataHooks, type ProgrammaticRouteDataStaleTime, type ProgrammaticRouteDefinition, type ProgrammaticRouteErrorComponentProps, type ProgrammaticRouteFactory, type ProgrammaticRouteGuard, type ProgrammaticRouteGuardContext, type ProgrammaticRouteManifest, type ProgrammaticRouteMaybePromise, type ProgrammaticRouteMethod, type ProgrammaticRouteParamsFallback, type ProgrammaticRoutePendingComponentProps, type ProgrammaticRoutePrimitive, type ProgrammaticRouteRenderMode, type ProgrammaticRouteSchema, type ProgrammaticRouteSearchClientOptions, type ProgrammaticRouteSearchConfig, type ProgrammaticRouteSearchFallback, type ProgrammaticRouteSearchOptions, type ProgrammaticRouteSearchResolution, type ProgrammaticStaticPath, type ProgrammaticStaticPathParams, type ProgrammaticStaticPaths, api, createLayoutModuleFromProgrammaticLayout, createProgrammaticRouteModuleId, createRoute, createRouteModuleFromProgrammaticPage, defineRoutes, getProgrammaticRouteManifest, getProgrammaticRouteSearchClientOptions, getProgrammaticRouteSearchSchema, isProgrammaticRouteDefinition, isProgrammaticRouteManifest, isProgrammaticRoutesFileName, layout, page, parseProgrammaticRouteModuleId, parseProgrammaticRoutePath, redirect, routesBuilder, scanProgrammaticPagePaths };

package/dist/runtime-9nQjVM7X.d.mts

@@ -0,0 +1,206 @@
+import { FarmCacheInvalidationTarget } from './cache.mjs';
+import { M as MultipartSchema, T as TypedFormData } from './transport-BmbGTXA5.mjs';
+
+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-Cxpq6xZN.d.mts

@@ -0,0 +1,27 @@
+import { F as FarmLocaleResolution } from './resolver-DJqjLMg_.mjs';
+import { R as ResolvedFarmI18nConfig, F as FarmI18nCatalogs, a as FarmI18nClientSnapshot } from './types-BMxWr97v.mjs';
+
+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 };