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

package/dist/client-plugins-CCilIb_G.d.mts

@@ -0,0 +1,2092 @@
+import { n as FarmClientPlugin } from './plugin-BJDf43dc.mjs';
+import React__default, { ComponentType, ReactNode } from 'react';
+import { IncomingMessage, ServerResponse } from 'http';
+import { k as FarmStorageUserConfig } from './types-D1A6-XvH.mjs';
+import { F as FarmIntegrationAPI, f as FarmIntegrationAPIMethod, e as FarmIntegrationAPIBodyFormat, a as FarmIntegrationAPIOperation, g as FarmIntegrationAPIResponseFormat, h as FarmIntegrationRouteOperationCarrier, I as InferIntegrationAPIFromRoutes } from './integration-api-CHT2OKAf.mjs';
+import { OrmClient, SchemaDefinition, ModelDefinition, FieldBuilder, JsonValue, AnyModelDefinition, SchemaModels } from '@farming-labs/orm';
+import { a as FarmDocsUserConfig, F as FarmDocsResolvedConfig } from './types-DTzm4TCl.mjs';
+import { FarmMarkdownUserConfig, FarmMarkdownResolvedConfig } from './markdown.mjs';
+import { FarmObservabilityUserConfig } from './observability.mjs';
+import * as vite from 'vite';
+import { ViteDevServer, UserConfig, Plugin } from 'vite';
+import { g as FarmWorkflowsUserConfig, a as FarmServerConfig, F as FarmWorkflowsResolvedConfig, R as ResolvedFarmServerConfig } from './workflows-CusFV6mn.mjs';
+import { FarmCronUserConfig, FarmCronResolvedConfig } from './cron.mjs';
+import { FarmEnvConfig, ResolvedFarmEnv } from './env.mjs';
+import { FarmServerActionsConfig, ResolvedFarmServerActionsConfig } from './server-action-security.mjs';
+import { F as FarmImageConfig, R as ResolvedFarmImageConfig } from './image-config-Duob7wER.mjs';
+import { k as FarmI18nUserConfig, R as ResolvedFarmI18nConfig } from './types-BMxWr97v.mjs';
+import { FarmCacheUserConfig } from './cache.mjs';
+import { R as ResolvedFarmThemeConfig, d as FarmThemeConfig } from './types-CsR8fpgF.mjs';
+import { F as FarmRouteRuntimeConfig, a as FarmRouteRuntime, b as FarmRouteRegions, c as FarmRouteMaxDuration } from './route-runtime-DoOHzCAD.mjs';
+import { FarmLayoutFonts } from './font.mjs';
+
+type RuntimeClientFactory<TClient> = () => TClient | Promise<TClient>;
+type FarmIntegrationOrmSchema = SchemaDefinition<Record<string, AnyModelDefinition>>;
+type FarmIntegrationOrmClient<TSchema extends FarmIntegrationOrmSchema> = OrmClient<TSchema>;
+type FarmIntegrationOrmFieldKind<TField extends FarmIntegrationSchemaField> = TField["type"] extends "id" | "uuid" ? "id" : TField["type"] extends "text" ? "string" : TField["type"] extends "number" ? "decimal" : Extract<TField["type"], "string" | "boolean" | "integer" | "datetime" | "json" | "enum">;
+type FarmIntegrationOrmFieldNullable<TField extends FarmIntegrationSchemaField> = TField extends {
+    nullable: true;
+} ? true : TField extends {
+    required: false;
+} ? true : false;
+type FarmIntegrationOrmEnumValue<TField extends FarmIntegrationSchemaField> = TField extends {
+    values: readonly (infer TValue extends string)[];
+} ? TValue : string;
+type FarmIntegrationOrmFieldValue<TField extends FarmIntegrationSchemaField> = TField["type"] extends "id" | "uuid" | "string" | "text" ? string : TField["type"] extends "boolean" ? boolean : TField["type"] extends "integer" ? number : TField["type"] extends "number" ? string : TField["type"] extends "datetime" ? Date : TField["type"] extends "json" ? JsonValue : TField["type"] extends "enum" ? FarmIntegrationOrmEnumValue<TField> : never;
+type InferFarmIntegrationOrmField<TField extends FarmIntegrationSchemaField> = FieldBuilder<FarmIntegrationOrmFieldKind<TField>, FarmIntegrationOrmFieldNullable<TField>, FarmIntegrationOrmFieldValue<TField>>;
+type InferFarmIntegrationOrmFields<TModel extends FarmIntegrationSchemaModel> = {
+    [TFieldKey in keyof TModel["fields"] & string]: InferFarmIntegrationOrmField<Extract<TModel["fields"][TFieldKey], FarmIntegrationSchemaField>>;
+};
+type InferFarmIntegrationOrmSchema<TSchema extends FarmIntegrationSchema> = SchemaDefinition<{
+    [TModelKey in keyof TSchema["models"] & string]: ModelDefinition<InferFarmIntegrationOrmFields<Extract<TSchema["models"][TModelKey], FarmIntegrationSchemaModel>>, {}>;
+}>;
+type InferFarmIntegrationOrmClient<TSchema extends FarmIntegrationSchema | undefined> = TSchema extends FarmIntegrationSchema ? OrmClient<InferFarmIntegrationOrmSchema<TSchema>> : never;
+interface CreateIntegrationOrmOptions<TClient = unknown, TSchema extends FarmIntegrationSchema = FarmIntegrationSchema> {
+    schema: TSchema;
+    config?: Pick<FarmConfig, "storage">;
+    storage?: FarmStorageUserConfig;
+    client?: TClient | RuntimeClientFactory<TClient>;
+}
+declare function createIntegrationOrm<TClient = unknown, TSchema extends FarmIntegrationSchema = FarmIntegrationSchema>(options: CreateIntegrationOrmOptions<TClient, TSchema>): Promise<InferFarmIntegrationOrmClient<TSchema>>;
+declare function resolveIntegrationOrmRuntimeClient<TClient = unknown>(options: Omit<CreateIntegrationOrmOptions<TClient>, "schema">): Promise<TClient | unknown | undefined>;
+declare function farmIntegrationSchemaToOrmSchema(schema: FarmIntegrationSchema): Promise<FarmIntegrationOrmSchema>;
+type IntegrationOrmModelNames<TSchema extends FarmIntegrationOrmSchema> = keyof SchemaModels<TSchema> & string;
+
+/**
+ * Farm.js Middleware System
+ *
+ * Type definitions for the middleware system
+ */
+
+/**
+ * Next function type for middleware chain
+ */
+type MiddlewareResult = void | Response;
+type NextFunction = () => Promise<MiddlewareResult>;
+type MiddlewareStoreKey<TValues extends Record<string, any>> = Extract<keyof TValues, string>;
+/**
+ * A typed view over the request-scoped maps used by middleware.
+ */
+interface ReadonlyMiddlewareStore<TValues extends Record<string, any> = Record<string, any>> {
+    readonly size: number;
+    get<TKey extends MiddlewareStoreKey<TValues>>(key: TKey): TValues[TKey] | undefined;
+    has<TKey extends MiddlewareStoreKey<TValues>>(key: TKey): boolean;
+    entries(): IterableIterator<[MiddlewareStoreKey<TValues>, TValues[MiddlewareStoreKey<TValues>]]>;
+    keys(): IterableIterator<MiddlewareStoreKey<TValues>>;
+    values(): IterableIterator<TValues[MiddlewareStoreKey<TValues>]>;
+    forEach(callback: (value: TValues[MiddlewareStoreKey<TValues>], key: MiddlewareStoreKey<TValues>, store: ReadonlyMiddlewareStore<TValues>) => void, thisArg?: any): void;
+    [Symbol.iterator](): IterableIterator<[
+        MiddlewareStoreKey<TValues>,
+        TValues[MiddlewareStoreKey<TValues>]
+    ]>;
+}
+interface MiddlewareStore<TValues extends Record<string, any> = Record<string, any>> extends ReadonlyMiddlewareStore<TValues> {
+    clear(): void;
+    delete<TKey extends MiddlewareStoreKey<TValues>>(key: TKey): boolean;
+    set<TKey extends MiddlewareStoreKey<TValues>>(key: TKey, value: TValues[TKey]): this;
+}
+/**
+ * Middleware function signature
+ */
+type MiddlewareFunction = (ctx: MiddlewareContext, next: NextFunction) => MiddlewareResult | Promise<MiddlewareResult>;
+/**
+ * Context passed to a named, request-first middleware export.
+ * `locals` and the get/set helpers stay on the server. `data` can be exposed
+ * through page props and should contain only serializable, client-safe values.
+ */
+interface RequestMiddlewareContext<TLocals extends Record<string, any> = Record<string, any>, TData extends Record<string, any> = Record<string, any>> {
+    readonly url: URL;
+    readonly pathname: string;
+    readonly searchParams: URLSearchParams;
+    readonly method: string;
+    readonly params: Record<string, string>;
+    readonly route: string;
+    readonly locals: MiddlewareStore<TLocals>;
+    readonly data: MiddlewareStore<TData>;
+    readonly headers: Map<string, string>;
+    readonly cookies: CookieJar;
+    get<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): TLocals[TKey] | undefined;
+    has<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): boolean;
+    set<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey, value: TLocals[TKey]): void;
+    delete<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): boolean;
+    redirect(url: string, status?: number): void;
+    rewrite(url: string): void;
+    json(data: any, status?: number): void;
+    text(content: string, status?: number): void;
+    html(content: string, status?: number): void;
+}
+type RequestMiddleware<TLocals extends Record<string, any> = Record<string, any>, TData extends Record<string, any> = Record<string, any>> = (request: Request, context: RequestMiddlewareContext<TLocals, TData>) => MiddlewareResult | Promise<MiddlewareResult>;
+/**
+ * Cookie options
+ */
+interface CookieOptions {
+    maxAge?: number;
+    expires?: Date;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: "strict" | "lax" | "none";
+}
+/**
+ * Cookie management interface
+ */
+interface CookieJar {
+    get(name: string): string | undefined;
+    set(name: string, value: string, options?: CookieOptions): void;
+    delete(name: string): void;
+    getAll(): Record<string, string>;
+}
+interface RateLimitIncrementResult {
+    count: number;
+    /** Unix epoch timestamp in milliseconds when the fixed window resets. */
+    resetAt: number;
+}
+interface RateLimitStorage {
+    /** Atomically increment a key and create or retain its fixed expiry window. */
+    increment(key: string, windowMs: number): Promise<RateLimitIncrementResult> | RateLimitIncrementResult;
+    /** Optional inspection support used by getRateLimitStatus(). */
+    get?(key: string): Promise<RateLimitIncrementResult | null> | RateLimitIncrementResult | null;
+}
+interface MemoryRateLimitStorageOptions {
+    /** Maximum number of active keys retained by this process. */
+    maxEntries?: number;
+}
+interface RateLimitConfig {
+    requests: number;
+    window: string;
+    keyGenerator?: (ctx: MiddlewareContext) => string;
+    onLimit?: (ctx: MiddlewareContext) => void | Response | Promise<void | Response>;
+    storage?: RateLimitStorage;
+}
+interface RateLimitStatus {
+    requests: number;
+    limit: number;
+    remaining: number;
+    resetIn: number | null;
+    resetAt: Date | null;
+    isLimited: boolean;
+}
+/**
+ * Middleware configuration
+ */
+type MiddlewareMatcher = string | RegExp | ((ctx: MiddlewareContext) => boolean);
+interface MiddlewareConfig$1 {
+    matcher?: MiddlewareMatcher | MiddlewareMatcher[];
+    exclude?: (string | RegExp)[];
+    runtime?: "nodejs" | "edge";
+}
+interface MiddlewareConfigEntry extends MiddlewareConfig$1 {
+    handler?: MiddlewareFunction;
+    handlers?: MiddlewareFunction[];
+}
+type FarmMiddlewareConfig = MiddlewareConfig$1 | MiddlewareConfigEntry | MiddlewareConfigEntry[];
+/**
+ * Middleware context - the main object passed to middleware functions
+ */
+interface MiddlewareContext {
+    request: IncomingMessage;
+    response: ServerResponse;
+    url: URL;
+    pathname: string;
+    searchParams: URLSearchParams;
+    method: string;
+    params: Record<string, string>;
+    route: string;
+    parent?: {
+        data: Map<string, any>;
+        locals?: Map<string, any>;
+        headers: Record<string, string>;
+    };
+    vite: {
+        isDev: boolean;
+        hmr: boolean;
+        server?: ViteDevServer;
+    };
+    data: Map<string, any>;
+    locals: Map<string, any>;
+    headers: Map<string, string>;
+    cookies: CookieJar;
+    _handled: boolean;
+    _redirectUrl?: string;
+    _rewriteUrl?: string;
+    redirect(url: string, status?: number): void;
+    rewrite(url: string): void;
+    json(data: any, status?: number): void;
+    text(content: string, status?: number): void;
+    html(content: string, status?: number): void;
+}
+/**
+ * Middleware chain interface
+ */
+interface MiddlewareChain {
+    use(fn: MiddlewareFunction): MiddlewareChain;
+    /**
+     * Conditionally run middleware based on a condition.
+     * Supports boolean values or functions that evaluate to boolean.
+     *
+     * @example
+     * .when(true, (ctx, next) => { ... })  // Always run
+     * .when((ctx) => ctx.data.get('flag'), (ctx, next) => { ... })  // Conditional
+     */
+    when(condition: boolean | ((ctx: MiddlewareContext) => boolean), fn: MiddlewareFunction | ((chain: MiddlewareChain) => void)): MiddlewareChain;
+    rateLimit(config: RateLimitConfig): MiddlewareChain;
+    redirect(source: string, destination: string, permanent?: boolean): MiddlewareChain;
+    /**
+     * Rewrite the current route to a new destination.
+     * In route-specific middleware, this rewrites the middleware's route.
+     *
+     * @param destination - The destination path to rewrite to
+     * @param condition - Optional boolean or function that evaluates to boolean. If false, rewrite is skipped.
+     *
+     * @example
+     * // In /contact/middleware.ts
+     * .rewrite('/about')  // Always rewrites /contact to /about
+     * .rewrite('/about', true)  // Always rewrites
+     * .rewrite('/about', false)  // Never rewrites
+     * .rewrite('/about', (ctx) => ctx.data.get('shouldRewrite'))  // Conditional rewrite
+     */
+    rewrite(destination: string, condition?: boolean | ((ctx: MiddlewareContext) => boolean)): MiddlewareChain;
+    build(): {
+        handlers: MiddlewareFunction[];
+        config?: MiddlewareConfig$1;
+    };
+}
+/**
+ * Middleware module export
+ */
+interface MiddlewareModule {
+    default?: MiddlewareChain | MiddlewareFunction;
+    middleware?: RequestMiddleware;
+    config?: MiddlewareConfig$1;
+}
+
+type FarmMdxComponent = React__default.ComponentType<any> | keyof React__default.JSX.IntrinsicElements;
+type FarmMdxComponents = Record<string, FarmMdxComponent>;
+interface FarmMdxUserConfig {
+    /**
+     * Component map or module path that exports `components` or a default component map.
+     * Relative paths resolve from the project root.
+     */
+    components?: string | FarmMdxComponents;
+    /**
+     * Serve source-authored markdown pages at `/route.md`.
+     * Enabled by default for `page.md` and `page.mdx`.
+     */
+    markdownRoutes?: boolean;
+    /**
+     * Class name used for the wrapper around rendered markdown content.
+     */
+    className?: string;
+}
+interface FarmMdxResolvedConfig {
+    components?: string | FarmMdxComponents;
+    markdownRoutes: boolean;
+    className: string;
+}
+interface FarmMarkdownPageSource {
+    source: string;
+    filePath: string;
+}
+interface FarmMarkdownPageModuleInput extends FarmMarkdownPageSource {
+    components?: FarmMdxComponents;
+    config?: FarmMdxResolvedConfig;
+}
+declare function resolveMdxConfig(config: FarmMdxUserConfig | undefined): FarmMdxResolvedConfig;
+declare function isFarmMarkdownPageFile(filePath: string): boolean;
+declare function normalizeFarmMarkdownRoutePath(pathname: string): string;
+declare function parseMarkdownFrontmatter(source: string): {
+    frontmatter: Record<string, string>;
+    body: string;
+};
+declare function titleFromMarkdown(body: string, fallback?: string): string | undefined;
+declare function createMarkdownMetadata(source: string, filePath: string): (Metadata & Record<string, any>) | undefined;
+declare function createFarmMarkdownRouteModule(input: FarmMarkdownPageModuleInput): RouteModule & {
+    source: string;
+};
+declare function createFarmMarkdownRouteModuleFromFile(filePath: string, options?: {
+    components?: FarmMdxComponents;
+    config?: FarmMdxResolvedConfig;
+}): Promise<RouteModule<never> & {
+    source: string;
+}>;
+declare function loadFarmMdxComponents(config: FarmMdxResolvedConfig | undefined, options: {
+    root: string;
+    loadModule?: (modulePath: string) => Promise<unknown>;
+}): Promise<FarmMdxComponents>;
+declare function createFarmMarkdownSourceResponse(options: {
+    request: Request;
+    config?: FarmMdxResolvedConfig;
+    resolveSource: (pathname: string) => Promise<FarmMarkdownPageSource | null> | FarmMarkdownPageSource | null;
+}): Promise<Response | null>;
+
+type FarmRouteRuleRenderMode = "static" | "dynamic";
+type FarmRouteRuleRedirect = string | {
+    to: string;
+    statusCode?: number;
+    permanent?: boolean;
+};
+type FarmRouteRuleCors = boolean | {
+    origin?: string;
+    methods?: string | readonly string[];
+    headers?: string | readonly string[];
+};
+interface FarmRouteRule extends FarmRouteRuntimeConfig {
+    prerender?: boolean;
+    render?: FarmRouteRuleRenderMode;
+    ssr?: boolean;
+    swr?: boolean | number;
+    isr?: boolean | number;
+    cors?: FarmRouteRuleCors;
+    headers?: Record<string, string>;
+    redirect?: FarmRouteRuleRedirect;
+}
+type FarmRouteRules = Record<string, FarmRouteRule>;
+declare function normalizeRouteRules(routeRules: FarmRouteRules | undefined): FarmRouteRules;
+declare function routeRulesToRedirects(routeRules: FarmRouteRules): RedirectConfig[];
+declare function routeRulesToHeaders(routeRules: FarmRouteRules): HeaderConfig[];
+declare function routeRulesToNitroRouteRules(routeRules: FarmRouteRules): Record<string, any>;
+
+type FarmLayerEntry = string;
+interface ResolvedFarmLayer {
+    /** The value used in `extends`. */
+    source: string;
+    /** Stable name used by the `#layers/<name>` alias. */
+    name: string;
+    /** Absolute layer package or directory root. */
+    root: string;
+    /** Source directory relative to the layer root. */
+    srcDir: string;
+    /** Resolved layer config file when one exists. */
+    configFile?: string;
+}
+interface FarmSourceRoot {
+    name: string;
+    root: string;
+    srcDir: string;
+    layer: boolean;
+}
+interface ResolveFarmLayersOptions {
+    root: string;
+    mode: "development" | "production";
+}
+interface FarmLayerResolution<TConfig extends Record<string, any>> {
+    config: TConfig & {
+        extends?: readonly FarmLayerEntry[];
+        layers: ResolvedFarmLayer[];
+    };
+    layers: ResolvedFarmLayer[];
+}
+declare function resolveFarmLayers<TConfig extends Record<string, any>>(projectConfig: TConfig, options: ResolveFarmLayersOptions): Promise<FarmLayerResolution<TConfig>>;
+declare function getFarmSourceRoots(config: {
+    root?: string;
+    srcDir?: string;
+    layers?: readonly ResolvedFarmLayer[];
+}): FarmSourceRoot[];
+declare function getFarmAppDirectories(config: {
+    root?: string;
+    srcDir?: string;
+    layers?: readonly ResolvedFarmLayer[];
+}): string[];
+declare function getFarmLayerAliases(layers: readonly ResolvedFarmLayer[] | undefined): Record<string, string>;
+declare function loadFarmConfigFile<TConfig = Record<string, any>>(configPath: string, options: {
+    root: string;
+    cacheRoot?: string;
+}): Promise<TConfig>;
+
+declare const DEFAULT_FARM_DEVTOOLS_SHORTCUT = "mod+shift+.";
+declare const FARM_DEVTOOLS_PATH = "/__farm/devtools";
+declare const FARM_DEVTOOLS_LAUNCH_PARAM = "__farm_devtools";
+interface FarmDevtoolsConfig {
+    /** Enable the development-only DevTools UI and runtime endpoints. */
+    enabled?: boolean;
+    /** Keyboard shortcut used to toggle DevTools, or false to disable the shortcut. */
+    shortcut?: string | false;
+}
+type FarmDevtoolsUserConfig = boolean | FarmDevtoolsConfig;
+interface ResolvedFarmDevtoolsConfig {
+    enabled: boolean;
+    shortcut: string | false;
+}
+declare function resolveFarmDevtoolsConfig(config: FarmDevtoolsUserConfig | ResolvedFarmDevtoolsConfig | undefined, mode?: "development" | "production"): ResolvedFarmDevtoolsConfig;
+
+interface FarmAuthEmailAndPasswordConfig {
+    /** Require a verified email before creating a session. @default false */
+    requireEmailVerification?: boolean;
+    /** Smallest accepted password length. @default 8 */
+    minPasswordLength?: number;
+    /** Largest accepted password length. @default 128 */
+    maxPasswordLength?: number;
+}
+interface FarmAuthSessionConfig {
+    /** Session lifetime in seconds. @default 604800 */
+    expiresIn?: number;
+    /** Session refresh interval in seconds. @default 86400 */
+    updateAge?: number;
+}
+interface FarmAuthDatabaseConfig {
+    /**
+     * Postgres connection string. Defaults to DATABASE_URL.
+     * Local development falls back to SQLite when no URL is present.
+     */
+    url?: string;
+    /** Local SQLite path. @default ".farm/auth.sqlite" */
+    path?: string;
+    /** Automatically update the auth schema in development. @default true */
+    migrateInDevelopment?: boolean;
+}
+interface FarmAuthConfig {
+    /** Set false to disable auth without removing its configuration. @default true */
+    enabled?: boolean;
+    /** Display name used by authentication emails and metadata. */
+    appName?: string;
+    /** Route prefix for the auth endpoints. @default "/api/auth" */
+    basePath?: string;
+    /**
+     * Email/password authentication. It is enabled by default; set false to
+     * disable it when adding another sign-in method.
+     */
+    emailAndPassword?: boolean | FarmAuthEmailAndPasswordConfig;
+    session?: FarmAuthSessionConfig;
+    database?: FarmAuthDatabaseConfig;
+}
+type FarmAuthUserConfig = boolean | FarmAuthConfig;
+interface ResolvedFarmAuthConfig {
+    enabled: boolean;
+    appName?: string;
+    basePath: string;
+    emailAndPassword: {
+        enabled: boolean;
+        requireEmailVerification: boolean;
+        minPasswordLength: number;
+        maxPasswordLength: number;
+    };
+    session: {
+        expiresIn: number;
+        updateAge: number;
+    };
+    database: {
+        url?: string;
+        path: string;
+        migrateInDevelopment: boolean;
+    };
+}
+
+type FarmPreloadMode = "warn" | "enforce";
+interface FarmPreloadUserConfig {
+    /** Report excess hints or remove the lower-priority hints. @default "enforce" */
+    mode?: FarmPreloadMode;
+    /** Maximum image preload hints per document. @default 1 */
+    maxImages?: number;
+    /** Maximum font preload hints per document. @default 2 */
+    maxFonts?: number;
+}
+interface ResolvedFarmPreloadConfig {
+    mode: FarmPreloadMode;
+    maxImages: number;
+    maxFonts: number;
+}
+interface FarmPerformanceConfig {
+    preload?: FarmPreloadUserConfig;
+}
+interface ResolvedFarmPerformanceConfig {
+    preload: ResolvedFarmPreloadConfig;
+}
+type FarmPreloadKind = "image" | "font";
+interface FarmPreloadBudgetWarning {
+    kind: FarmPreloadKind;
+    count: number;
+    budget: number;
+    removed: number;
+}
+interface FarmManagedPreloads {
+    value: string;
+    warnings: FarmPreloadBudgetWarning[];
+}
+interface FarmManagedDocumentPreloads {
+    html: string;
+    linkHeader: string;
+    warnings: FarmPreloadBudgetWarning[];
+}
+/**
+ * Apply image and font budgets to HTML preload elements. High-priority image
+ * hints are retained before ordinary hints, making an explicitly preloaded LCP
+ * image the winner when a document contains too many React-generated hints.
+ */
+declare function manageFarmHtmlPreloads(html: string, config: ResolvedFarmPreloadConfig): FarmManagedPreloads;
+/** Apply the same budgets to HTTP Link preload hints, including Farm fonts. */
+declare function manageFarmLinkHeaderPreloads(value: string, config: ResolvedFarmPreloadConfig): FarmManagedPreloads;
+/** Apply a single document budget across HTML and HTTP Link header hints. */
+declare function manageFarmDocumentPreloads(html: string, linkHeader: string, config: ResolvedFarmPreloadConfig): FarmManagedDocumentPreloads;
+/** Rate-limit identical route-and-budget warnings within a server process. */
+declare function reportFarmPreloadWarnings(warnings: FarmPreloadBudgetWarning[], context?: string): void;
+
+type FarmCspDirectiveValue = string | readonly string[] | boolean | null | undefined;
+type FarmCspDirectives = Readonly<Record<string, FarmCspDirectiveValue>>;
+interface FarmCspOptions {
+    /** A pre-serialized CSP value. Cannot be combined with directives. */
+    policy?: string;
+    /** CSP directives using camelCase or kebab-case names. */
+    directives?: FarmCspDirectives;
+    /** Emit Content-Security-Policy-Report-Only instead of enforcing the policy. */
+    reportOnly?: boolean;
+}
+type FarmCspConfig = string | FarmCspOptions;
+interface FarmSecurityConfig {
+    /** App-wide Content Security Policy applied to pages, APIs, and static output. */
+    csp?: FarmCspConfig | false;
+    /** @deprecated Use csp. */
+    contentSecurityPolicy?: never;
+}
+interface ResolvedFarmCspConfig {
+    value: string;
+    reportOnly: boolean;
+}
+interface ResolvedFarmSecurityConfig {
+    csp: ResolvedFarmCspConfig | false;
+}
+
+declare const FARM_RESOLVED_CUSTOM_CONTEXT: unique symbol;
+
+interface RedirectConfig {
+    source: string;
+    destination: string;
+    permanent?: boolean;
+    statusCode?: number;
+}
+interface HeaderConfig {
+    source: string;
+    headers: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+interface RewriteConfig {
+    source: string;
+    destination: string;
+}
+/** @deprecated Use FarmImageConfig. */
+type ImageConfig = FarmImageConfig;
+/** @deprecated Use FarmI18nUserConfig. */
+type I18nConfig = FarmI18nUserConfig;
+interface OpenAPIConfig {
+    enabled?: boolean;
+    route?: string;
+    title?: string;
+    description?: string;
+    version?: string;
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    contact?: {
+        name?: string;
+        email?: string;
+        url?: string;
+    };
+    license?: {
+        name: string;
+        url?: string;
+    };
+}
+type MiddlewareConfig = FarmMiddlewareConfig;
+interface NotFoundConfig {
+    /** Path to a custom 404 page component (e.g., "./src/app/not-found.tsx") */
+    component?: string;
+}
+type FarmDeployTarget = "vercel" | "cloudflare" | "netlify" | "node" | string;
+interface FarmDeployConfig {
+    /**
+     * Deployment platform. When present, Farm picks the matching Nitro preset and
+     * output directory unless explicitly overridden.
+     */
+    target?: FarmDeployTarget;
+    /** Nitro preset override. Usually inferred from target. */
+    preset?: FarmConfig["preset"];
+    /** Deployable output directory, relative to project root unless absolute. */
+    outputDir?: string;
+    /** Alias for outputDir for terser config. */
+    output?: string;
+    /** Cloudflare Pages project name used by `farm deploy --cloudflare`. */
+    projectName?: string;
+    vercel?: {
+        outputDirectory?: string;
+        buildCommand?: string;
+        installCommand?: string;
+        framework?: string | null;
+    };
+    cloudflare?: {
+        outputDir?: string;
+        projectName?: string;
+    };
+    netlify?: {
+        outputDir?: string;
+        site?: string;
+    };
+}
+interface ResolvedFarmDeployConfig extends Omit<FarmDeployConfig, "output"> {
+    target?: FarmDeployTarget;
+    preset: FarmConfig["preset"];
+    outputDir: string;
+}
+interface FarmUserConfig extends Omit<FarmConfig, "vite" | "docs" | "env" | "layers"> {
+    /** Reusable Farm directories or installed packages, applied from left to right. */
+    extends?: readonly FarmLayerEntry[];
+    /** Global plugins. Integration-bound plugins must be contributed through an integration. */
+    plugins?: FarmPlugin<any, any, any, any, unknown, false>[];
+    integrations?: FarmIntegrationsUserConfig;
+    /**
+     * Farm-native authentication. `true` enables email/password auth with
+     * server helpers from `@farm.js/auth/server` and React APIs from
+     * `@farm.js/auth/client`.
+     */
+    auth?: FarmAuthUserConfig;
+    /** Shared application data, route, ISR, and PPR cache. */
+    cache?: FarmCacheUserConfig;
+    migrations?: FarmMigrationsUserConfig;
+    /** Map portable cron schedules to ordinary GET API routes. */
+    cron?: FarmCronUserConfig | FarmCronResolvedConfig | false;
+    workflows?: FarmWorkflowsUserConfig | boolean;
+    preset?: FarmConfig["preset"];
+    deploy?: FarmDeployConfig;
+    docs?: FarmDocsUserConfig;
+    md?: FarmMarkdownUserConfig | boolean;
+    mdx?: FarmMdxUserConfig;
+    observability?: FarmObservabilityUserConfig;
+    trailingSlash?: boolean;
+    redirects?: () => Promise<RedirectConfig[]> | RedirectConfig[];
+    rewrites?: () => Promise<RewriteConfig[]> | RewriteConfig[];
+    headers?: () => Promise<HeaderConfig[]> | HeaderConfig[];
+    images?: ImageConfig;
+    publicDir?: string;
+    i18n?: FarmI18nUserConfig | false;
+    openapi?: OpenAPIConfig;
+    middleware?: FarmMiddlewareConfig;
+    routeRules?: FarmRouteRules;
+    context?: FarmConfig["context"];
+    /** Server ingress and trusted-proxy policy. */
+    server?: FarmServerConfig;
+    serverActions?: FarmServerActionsConfig;
+    /** Build identifier used to detect and recover from deployment version skew. */
+    deploymentId?: string;
+    notFound?: NotFoundConfig;
+    output?: "standalone" | "static" | "export";
+    distDir?: string;
+    generateBuildId?: () => string | Promise<string>;
+    compress?: boolean;
+    devIndicators?: {
+        buildActivity?: boolean;
+        buildActivityPosition?: "bottom-right" | "bottom-left" | "top-right" | "top-left";
+    };
+    serverRuntimeConfig?: Record<string, any>;
+    publicRuntimeConfig?: Record<string, any>;
+    env?: FarmEnvConfig<any, any>;
+    typescript?: {
+        tsconfigPath?: string;
+        ignoreBuildErrors?: boolean;
+    };
+    vite?: UserConfig | ((config: UserConfig) => UserConfig);
+    [key: string]: any;
+}
+interface ResolvedFarmConfig extends Required<Omit<FarmUserConfig, "extends" | "plugins" | "vite" | "deploy" | "docs" | "md" | "mdx" | "migrations" | "cron" | "workflows" | "env" | "server" | "serverActions" | "devtools" | "images" | "i18n" | "auth" | "performance" | "security" | "theme">> {
+    /** @internal Tracks whether `context` came from user/layer config instead of the default noop. */
+    [FARM_RESOLVED_CUSTOM_CONTEXT]?: boolean;
+    extends: readonly FarmLayerEntry[];
+    layers: ResolvedFarmLayer[];
+    plugins: FarmPlugin[];
+    vite: UserConfig;
+    deploy: ResolvedFarmDeployConfig;
+    docs: FarmDocsResolvedConfig;
+    md: FarmMarkdownResolvedConfig;
+    mdx: FarmMdxResolvedConfig;
+    migrations: ResolvedFarmMigrationsConfig;
+    cron: FarmCronResolvedConfig;
+    workflows: FarmWorkflowsResolvedConfig;
+    env: ResolvedFarmEnv;
+    server: ResolvedFarmServerConfig;
+    serverActions: ResolvedFarmServerActionsConfig;
+    devtools: ResolvedFarmDevtoolsConfig;
+    images: ResolvedFarmImageConfig;
+    i18n: ResolvedFarmI18nConfig;
+    auth: ResolvedFarmAuthConfig;
+    performance: ResolvedFarmPerformanceConfig;
+    security: ResolvedFarmSecurityConfig;
+    theme: ResolvedFarmThemeConfig;
+    routeRules: FarmRouteRules;
+}
+type FarmLayerConfig = Omit<FarmUserConfig, "root" | "outDir" | "distDir" | "deploy" | "output" | "preset" | "publicDir" | "generateBuildId" | "deploymentId">;
+
+declare function normalizeDeployTarget(target?: FarmDeployTarget): FarmDeployTarget | undefined;
+declare function getPresetForDeployTarget(target?: FarmDeployTarget): FarmConfig["preset"] | undefined;
+declare function getDeployTargetForPreset(preset?: string): FarmDeployTarget | undefined;
+declare function resolveDeployOutputPath(root: string, outputDir: string): string;
+declare function resolveDeployConfig(config: Pick<FarmUserConfig, "deploy" | "preset" | "distDir">, overrides?: {
+    target?: FarmDeployTarget;
+    preset?: FarmConfig["preset"];
+    outputDir?: string;
+}): ResolvedFarmDeployConfig;
+declare function resolveMigrationsConfig(migrations: FarmMigrationsUserConfig | undefined): ResolvedFarmMigrationsConfig;
+declare function resolveConfig(userConfig: FarmUserConfig, mode: "development" | "production"): Promise<ResolvedFarmConfig>;
+declare function loadConfig(rootDir?: string, configPath?: string, mode?: string, loadEnvironment?: (typeof vite)["loadEnv"]): Promise<FarmUserConfig | undefined>;
+
+interface FarmVitePluginOptions extends FarmConfig {
+    openapi?: FarmUserConfig["openapi"];
+    images?: FarmUserConfig["images"];
+    publicDir?: FarmUserConfig["publicDir"];
+}
+declare function farmI18nClientBridgePlugin(): Plugin;
+interface FarmModuleAstNode {
+    type: string;
+    start: number;
+    end: number;
+    [key: string]: unknown;
+}
+declare function rewriteEarlySsrRelativeImports(options: {
+    code: string;
+    id: string;
+    root: string;
+    parse: (code: string) => FarmModuleAstNode;
+}): string | null;
+declare function farmPlugin(options?: FarmVitePluginOptions, initialPluginManager?: PluginManager): Plugin;
+declare function defineConfig(config?: FarmVitePluginOptions): Promise<UserConfig>;
+
+type MaybePromise$1<T> = T | Promise<T>;
+declare const FARM_PLUGIN_INTEGRATION_INSTANCE: unique symbol;
+declare const FARM_PLUGIN_INTEGRATION_BOUND: unique symbol;
+interface FarmPluginIntegrationContext<TInstance = unknown> {
+    /** Key used to register the integration in farm.config.ts. */
+    readonly key: string;
+    readonly category: string;
+    readonly type: string;
+    readonly instance: TInstance;
+    readonly serverRuntime: boolean;
+}
+declare class FarmRuntimeShutdownError extends Error {
+    readonly errors: readonly unknown[];
+    constructor(message: string, errors: readonly unknown[]);
+}
+interface PluginRequestContext {
+    set: (target: FarmRequest | Request, key: string, value: any, options?: {
+        exposeToPage?: boolean;
+    }) => void;
+    get: <T = any>(target: FarmRequest | Request, key: string) => T | undefined;
+    has: (target: FarmRequest | Request, key: string) => boolean;
+    delete: (target: FarmRequest | Request, key: string) => boolean;
+    clear: (target: FarmRequest | Request) => void;
+    getAll: (target: FarmRequest | Request, options?: {
+        exposedOnly?: boolean;
+    }) => Map<string, any>;
+}
+interface FarmRequestStore {
+    set(key: string, value: unknown, options?: {
+        exposeToPage?: boolean;
+    }): void;
+    get<T = unknown>(key: string): T | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    clear(): void;
+    snapshot(options?: {
+        exposedOnly?: boolean;
+    }): Map<string, unknown>;
+}
+interface FarmPluginContext<TIntegrationInstance = unknown> {
+    config: FarmConfig;
+    viteServer?: ViteDevServer;
+    isDev: boolean;
+    isProd: boolean;
+    /** The owning integration when this plugin is contributed through `integration.plugins`. */
+    readonly integration?: Readonly<FarmPluginIntegrationContext<TIntegrationInstance>>;
+    /** Register resource cleanup that must run when the application runtime closes. */
+    lifecycle: FarmPluginLifecycle;
+    /** @deprecated Use `ctx.req` inside request hooks. */
+    requestContext: PluginRequestContext;
+}
+type FarmPluginHookContext<TContext, TIntegrationInstance, TIntegrationBound extends boolean> = TIntegrationBound extends true ? Omit<TContext, "integration"> & {
+    /** The owning integration bound by `definePlugin.forIntegration<T>()`. */
+    readonly integration: Readonly<FarmPluginIntegrationContext<TIntegrationInstance>>;
+} : TContext;
+interface FarmPluginLifecycle {
+    /**
+     * Register a database, storage, queue, or other resource disposer.
+     * Disposers run once in reverse registration order after plugin shutdown hooks.
+     */
+    onShutdown(dispose: () => void | Promise<void>): () => void;
+}
+interface FarmRequestPluginContext<TIntegrationInstance = unknown> extends FarmPluginContext<TIntegrationInstance> {
+    /** Request-scoped values for the current hook invocation. */
+    readonly req: FarmRequestStore;
+}
+interface RouteDiscoveredPayload {
+    kind: "page" | "layout";
+    pattern: string;
+    modulePath: string;
+}
+interface RoutesGeneratedPayload {
+    routes: RouteDiscoveredPayload[];
+    pageCount: number;
+    layoutCount: number;
+}
+interface MiddlewareDiscoveredPayload {
+    path: string;
+    filePath: string;
+    handlerCount: number;
+}
+interface APIRouteDiscoveredPayload {
+    path: string;
+    filePath: string;
+    methods: string[];
+}
+interface RouteMatchPayload {
+    pathname: string;
+    method?: string;
+}
+interface RouteMatchResultPayload {
+    pathname: string;
+    matched: boolean;
+    routePattern: string | null;
+    params: Record<string, string>;
+    layoutPatterns: string[];
+}
+interface RenderLifecyclePayload {
+    pathname: string;
+    method: string;
+    routePattern: string | null;
+    params: Record<string, string>;
+}
+interface APIHandlerLifecyclePayload {
+    pathname: string;
+    method: string;
+    routePath?: string;
+}
+interface ErrorLifecyclePayload {
+    phase: string;
+    error: unknown;
+    meta?: Record<string, unknown>;
+}
+interface HMRUpdatePayload {
+    file: string;
+    modules: string[];
+}
+interface BundleLifecyclePayload {
+    root: string;
+    preset: string;
+    universal: boolean;
+    distDir: string;
+    outputDir?: string;
+}
+interface BundleResultPayload extends BundleLifecyclePayload {
+    success: boolean;
+}
+interface NitroBuildLifecyclePayload {
+    root: string;
+    preset: string;
+    distDir: string;
+    outputDir: string;
+}
+interface ShutdownPayload {
+    reason: string;
+}
+type FarmPluginRuntimeKind = "request" | "page" | "api" | "action" | "integration" | "docs" | "asset" | (string & {});
+interface FarmPluginRouteRuntimePayload {
+    pathname: string;
+    pattern?: string | null;
+    params?: Record<string, string>;
+}
+interface FarmPluginSetupContext<TIntegrationInstance = unknown> extends FarmPluginContext<TIntegrationInstance> {
+    env: ResolvedFarmEnv;
+}
+interface FarmPluginStateContext<TState = unknown, TIntegrationInstance = unknown> extends FarmPluginContext<TIntegrationInstance> {
+    state: TState;
+}
+interface FarmPluginRuntimeBaseEvent<TState = unknown, TIntegrationInstance = unknown> extends FarmPluginStateContext<TState, TIntegrationInstance> {
+    request: Request;
+    /** Request-scoped values shared by plugin hooks. */
+    req: FarmRequestStore;
+    kind: FarmPluginRuntimeKind;
+    route?: FarmPluginRouteRuntimePayload;
+    signal: AbortSignal;
+    waitUntil(promise: Promise<unknown>): void;
+}
+type FarmPluginRuntimeContextEvent<TState = unknown, TIntegrationInstance = unknown> = FarmPluginRuntimeBaseEvent<TState, TIntegrationInstance>;
+interface FarmPluginRuntimeBeforeEvent<TState = unknown, TRequestContext extends object = Record<string, unknown>, TIntegrationInstance = unknown> extends FarmPluginRuntimeBaseEvent<TState, TIntegrationInstance> {
+    ctx: Readonly<TRequestContext>;
+}
+interface FarmPluginRuntimeAfterEvent<TState = unknown, TRequestContext extends object = Record<string, unknown>, TIntegrationInstance = unknown> extends FarmPluginRuntimeBeforeEvent<TState, TRequestContext, TIntegrationInstance> {
+    response: Response;
+    durationMs: number;
+}
+interface FarmPluginRuntimeErrorEvent<TState = unknown, TRequestContext extends object = Record<string, unknown>, TIntegrationInstance = unknown> extends FarmPluginRuntimeBeforeEvent<TState, TRequestContext, TIntegrationInstance> {
+    error: unknown;
+    durationMs: number;
+}
+type FarmPluginRuntimeStartEvent<TState = unknown, TIntegrationInstance = unknown> = FarmPluginStateContext<TState, TIntegrationInstance>;
+interface FarmPluginRuntimeCloseEvent<TState = unknown, TIntegrationInstance = unknown> extends FarmPluginStateContext<TState, TIntegrationInstance>, ShutdownPayload {
+}
+type FarmPluginContextFor<TIntegrationInstance, TIntegrationBound extends boolean> = FarmPluginHookContext<FarmPluginContext<TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>;
+type FarmRequestPluginContextFor<TIntegrationInstance, TIntegrationBound extends boolean> = FarmPluginHookContext<FarmRequestPluginContext<TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>;
+type FarmPluginSetupContextFor<TIntegrationInstance, TIntegrationBound extends boolean> = FarmPluginHookContext<FarmPluginSetupContext<TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>;
+type FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound extends boolean> = FarmPluginHookContext<FarmPluginStateContext<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>;
+type FarmPluginRuntimeEventFor<TEvent, TIntegrationInstance, TIntegrationBound extends boolean> = FarmPluginHookContext<TEvent, TIntegrationInstance, TIntegrationBound>;
+interface FarmPluginRuntimeHooks<TState = unknown, TRequestContext extends object = Record<string, unknown>, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
+    start?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeStartEvent<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+    context?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeContextEvent<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<TRequestContext>;
+    before?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeBeforeEvent<TState, TRequestContext, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<Request | Response | void>;
+    after?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeAfterEvent<TState, TRequestContext, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<Response | void>;
+    error?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeErrorEvent<TState, TRequestContext, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+    close?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeCloseEvent<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+}
+interface FarmPluginRuntimeRequestOptions {
+    kind?: FarmPluginRuntimeKind;
+    route?: FarmPluginRouteRuntimePayload;
+    waitUntil?: (promise: Promise<unknown>) => void;
+}
+type FarmPluginRuntimeRequestHandler = (request: Request) => MaybePromise$1<Response>;
+interface FarmPluginRuntimeSession {
+    request: Request;
+    response?: Response;
+    ctx: Readonly<Record<string, unknown>>;
+    startedAt: number;
+    options: FarmPluginRuntimeRequestOptions;
+    waitUntil(promise: Promise<unknown>): void;
+}
+type FarmPluginDiscoveredRoute = RouteDiscoveredPayload | ({
+    kind: "middleware";
+} & MiddlewareDiscoveredPayload) | ({
+    kind: "api";
+} & APIRouteDiscoveredPayload);
+interface FarmPluginRouterHooks<TState = unknown, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
+    discovered?(route: FarmPluginDiscoveredRoute, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+    generated?(routes: RoutesGeneratedPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+    before?(route: RouteMatchPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+    after?(result: RouteMatchResultPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+}
+interface FarmPluginRenderHooks<TState = unknown, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
+    before?(render: RenderLifecyclePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+    html?(html: string, render: RenderLifecyclePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<string | void>;
+}
+interface FarmPluginBuildHooks<TState = unknown, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
+    before?(bundle: BundleLifecyclePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+    configure?(buildConfig: any, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<any>;
+    after?(result: BundleResultPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+}
+interface FarmPluginDevHooks<TState = unknown, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
+    server?(viteServer: ViteDevServer, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+    update?(update: HMRUpdatePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
+}
+interface FarmPluginClientConfig<TState = unknown, TPublic = undefined> extends FarmClientPlugin<TState, TPublic> {
+    /** Explicitly public, JSON-safe data embedded in the browser bundle. */
+    public?: TPublic;
+}
+interface FarmPlugin<TState = any, TRequestContext extends object = Record<string, unknown>, TClientState = any, TClientPublic = any, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
+    name: string;
+    version?: string;
+    enforce?: "pre" | "post";
+    /** Transform Farm config before it is resolved. */
+    configure?: (config: FarmConfig, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => MaybePromise$1<FarmConfig | void>;
+    /** Initialize private plugin state once for this plugin manager. */
+    setup?: (context: FarmPluginSetupContextFor<TIntegrationInstance, TIntegrationBound>) => MaybePromise$1<TState>;
+    runtime?: FarmPluginRuntimeHooks<TState, TRequestContext, TIntegrationInstance, TIntegrationBound>;
+    router?: FarmPluginRouterHooks<TState, TIntegrationInstance, TIntegrationBound>;
+    render?: FarmPluginRenderHooks<TState, TIntegrationInstance, TIntegrationBound>;
+    build?: FarmPluginBuildHooks<TState, TIntegrationInstance, TIntegrationBound>;
+    dev?: FarmPluginDevHooks<TState, TIntegrationInstance, TIntegrationBound>;
+    /** Optional browser lifecycle for this logical plugin. */
+    client?: FarmPluginClientConfig<TClientState, TClientPublic>;
+    /** @internal Carries the expected integration instance type without runtime data. */
+    readonly [FARM_PLUGIN_INTEGRATION_INSTANCE]?: (instance: TIntegrationInstance) => void;
+    /** @internal Prevents integration-bound plugins from being registered globally. */
+    readonly [FARM_PLUGIN_INTEGRATION_BOUND]?: TIntegrationBound;
+    /** @deprecated Use `setup` instead. */
+    init?: (context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `runtime.start` instead. */
+    ready?: (context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `dev.server` instead. */
+    devServerCreated?: (viteServer: ViteDevServer, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `configure` instead. */
+    config?: (config: FarmConfig, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => FarmConfig | Promise<FarmConfig>;
+    configResolved?: (config: FarmConfig, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `build.before` instead. */
+    buildStart?: (context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `build.after` instead. */
+    buildEnd?: (context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `router.discovered` instead. */
+    routeDiscovered?: (route: RouteDiscoveredPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `router.generated` instead. */
+    routesGenerated?: (routes: RoutesGeneratedPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `router.discovered` instead. */
+    middlewareDiscovered?: (middleware: MiddlewareDiscoveredPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `router.discovered` instead. */
+    apiRouteDiscovered?: (route: APIRouteDiscoveredPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `router.before` instead. */
+    beforeRouteMatch?: (route: RouteMatchPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `router.after` instead. */
+    afterRouteMatch?: (result: RouteMatchResultPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `render.before` instead. */
+    beforeRender?: (render: RenderLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `render.html` instead. */
+    afterRender?: (html: string, render: RenderLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => string | Promise<string> | void | Promise<void>;
+    /** @deprecated Use `runtime.before` instead. */
+    beforeApiHandler?: (request: Request, api: APIHandlerLifecyclePayload, context: FarmRequestPluginContextFor<TIntegrationInstance, TIntegrationBound>) => Request | Promise<Request> | void | Promise<void>;
+    /** @deprecated Use `runtime.after` instead. */
+    afterApiHandler?: (response: Response, api: APIHandlerLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => Response | Promise<Response> | void | Promise<void>;
+    onError?: (error: ErrorLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `dev.update` instead. */
+    hmrUpdate?: (update: HMRUpdatePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `build.before` instead. */
+    beforeBundle?: (bundle: BundleLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `build.after` instead. */
+    afterBundle?: (result: BundleResultPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `build.configure` instead. */
+    beforeNitroBuild?: (nitroConfig: any, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => any | Promise<any>;
+    afterNitroBuild?: (payload: NitroBuildLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `runtime.close` instead. */
+    shutdown?: (payload: ShutdownPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use the Web Request based `runtime.before` hook instead. */
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmRequestPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use the Web Response based `runtime.after` hook instead. */
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmRequestPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
+    /** @deprecated Use `render.html` instead. */
+    transformHTML?: (html: string, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => string | Promise<string>;
+    /** @deprecated Use `render.before` or `render.html` instead. */
+    transformPage?: (component: any, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => any | Promise<any>;
+}
+declare class PluginManager {
+    private plugins;
+    private hookPresence;
+    private runtimeHookPresence;
+    private context;
+    private pluginStates;
+    private setupComplete;
+    private initialized;
+    private runtimeReady;
+    private runtimeClosed;
+    private runtimeStartPromise?;
+    private runtimeClosePromise?;
+    private runtimeShutdownHooksRunning;
+    private runtimeDisposers;
+    private runtimeRequestContexts;
+    private failedRuntimeSessions;
+    constructor(context: Omit<FarmPluginContext, "requestContext" | "lifecycle">);
+    private createPluginHookContext;
+    private createRequestHookContext;
+    private copyRequestStore;
+    private copyRuntimeRequestContext;
+    private createRuntimeBaseEvent;
+    private createRuntimeRequestContext;
+    private runRuntimeErrorHooks;
+    private createStateHookContext;
+    private getPluginHooks;
+    private getHookContext;
+    addPlugin(plugin: FarmPlugin): void;
+    addPlugins(plugins: FarmPlugin[]): void;
+    getPlugins(): FarmPlugin[];
+    getSortedPlugins(): FarmPlugin[];
+    hasHook(hookName: keyof FarmPlugin): boolean;
+    hasRuntimeHook(hookName: "context" | "before" | "after" | "error"): boolean;
+    hasRuntimeRequestHooks(): boolean;
+    copyRequestContext(source: FarmRequest | Request, target: FarmRequest | Request): void;
+    setupPlugins(): Promise<void>;
+    startRuntime(): Promise<void>;
+    closeRuntime(reason?: string): Promise<void>;
+    beginRuntimeRequest(request: Request, options?: FarmPluginRuntimeRequestOptions): Promise<FarmPluginRuntimeSession>;
+    endRuntimeRequest(session: FarmPluginRuntimeSession, initialResponse: Response): Promise<Response>;
+    failRuntimeRequest(session: FarmPluginRuntimeSession, error: unknown): Promise<void>;
+    runRuntimeRequest(request: Request, handler: FarmPluginRuntimeRequestHandler, options?: FarmPluginRuntimeRequestOptions): Promise<Response>;
+    runHook<K extends keyof FarmPlugin>(hookName: K, ...args: any[]): Promise<any>;
+    runHookSerial<K extends keyof FarmPlugin>(hookName: K, initialValue: any, ...args: any[]): Promise<any>;
+    runHookParallel<K extends keyof FarmPlugin>(hookName: K, ...args: any[]): Promise<boolean>;
+    /** @internal Runs hooks for only the plugins selected by the runtime adapter. */
+    runHookParallelFiltered<K extends keyof FarmPlugin>(hookName: K, include: (plugin: FarmPlugin) => boolean, ...args: any[]): Promise<boolean>;
+    updateContext(updates: Partial<FarmPluginContext>): void;
+}
+declare function definePlugin<TState = undefined, TRequestContext extends object = Record<string, never>, TClientState = unknown, TClientPublic = undefined, TIntegrationInstance = unknown>(plugin: FarmPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, false>): FarmPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, false>;
+declare namespace definePlugin {
+    /** Bind an integration instance type while preserving inference for plugin state and context. */
+    function forIntegration<TIntegrationInstance>(): <TState = undefined, TRequestContext extends object = Record<string, never>, TClientState = unknown, TClientPublic = undefined>(plugin: FarmPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, true>) => FarmPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, true>;
+}
+
+type FarmIntegrationCategory = "auth" | "payment" | "monitoring" | "logging" | (string & {});
+/** @deprecated Use FarmIntegrationCategory instead. */
+type FarmIntegrationSlot = FarmIntegrationCategory;
+type FarmIntegrationRouteParamValue = string | string[];
+type FarmIntegrationRouteParams = Record<string, FarmIntegrationRouteParamValue>;
+type FarmIntegrationRouteMethod = FarmIntegrationAPIMethod | Lowercase<FarmIntegrationAPIMethod> | "ALL" | "all";
+type FarmIntegrationRouteInputSource = "body" | "query";
+type MaybePromise<T> = T | Promise<T>;
+type FarmIntegrationValidationPathSegment = PropertyKey | {
+    readonly key: PropertyKey;
+};
+interface FarmIntegrationRouteInput<TBody = unknown, TQuery = unknown> {
+    body?: TBody;
+    query?: TQuery;
+}
+interface FarmIntegrationValidationIssue {
+    source: FarmIntegrationRouteInputSource;
+    path?: readonly (string | number)[];
+    code?: string;
+    message: string;
+}
+interface FarmIntegrationValidationErrorLike {
+    issues?: readonly {
+        path?: readonly FarmIntegrationValidationPathSegment[];
+        code?: string;
+        message?: string;
+    }[];
+    message?: string;
+}
+type FarmIntegrationValidationResult<TValue> = {
+    success: true;
+    data: TValue;
+} | {
+    success: false;
+    error: FarmIntegrationValidationErrorLike;
+};
+type FarmIntegrationStandardValidationResult<TValue> = {
+    value: TValue;
+} | {
+    issues: readonly {
+        path?: readonly FarmIntegrationValidationPathSegment[];
+        code?: string;
+        message: string;
+    }[];
+};
+interface FarmIntegrationInputSchema<TValue = unknown> {
+    _output?: TValue;
+    parse?(value: unknown): MaybePromise<TValue>;
+    safeParse?(value: unknown): MaybePromise<FarmIntegrationValidationResult<TValue>>;
+    safeParseAsync?(value: unknown): Promise<FarmIntegrationValidationResult<TValue>>;
+    "~standard"?: {
+        validate(value: unknown): MaybePromise<FarmIntegrationStandardValidationResult<TValue>>;
+        types?: {
+            output: TValue;
+        };
+    };
+}
+interface FarmIntegrationRouteInputSchemas<TBody = unknown, TQuery = unknown> {
+    body?: FarmIntegrationInputSchema<TBody>;
+    query?: FarmIntegrationInputSchema<TQuery>;
+}
+/** @deprecated Use `FarmRequestStore` and access it through `ctx.req`. */
+type FarmIntegrationRequestContextStore = FarmRequestStore;
+declare const FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY = "farm.integration.internalDispatch";
+type FarmIntegrationRouteDb<TSchema extends FarmIntegrationSchema | undefined> = InferFarmIntegrationOrmClient<TSchema>;
+interface FarmIntegrationRouteStorageArgs<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    getClient(): Promise<unknown | undefined>;
+    getOrm(): Promise<FarmIntegrationRouteDb<TSchema>>;
+}
+interface FarmIntegrationRouteArgs<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    db: FarmIntegrationRouteDb<TSchema>;
+    getDb(): Promise<FarmIntegrationRouteDb<TSchema>>;
+    storage: FarmIntegrationRouteStorageArgs<TSchema>;
+}
+interface FarmIntegrationConfigContext<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    key: string;
+    integration: FarmIntegration<TSchema, any>;
+    appConfig: FarmPluginContext["config"];
+    /** Alias for appConfig. */
+    config: FarmPluginContext["config"];
+    args: FarmIntegrationRouteArgs<TSchema>;
+    env: Record<string, string | undefined>;
+    isDev: boolean;
+    isProd: boolean;
+}
+interface FarmIntegrationConfigDefinition<TConfig = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    schema?: FarmIntegrationInputSchema<TConfig>;
+    env?: Record<string, string | readonly string[]>;
+    defaults?: Partial<TConfig> | ((context: FarmIntegrationConfigContext<TSchema>) => MaybePromise<Partial<TConfig>>);
+    input?: Partial<TConfig> | ((context: FarmIntegrationConfigContext<TSchema>) => MaybePromise<Partial<TConfig>>);
+    resolve?(context: FarmIntegrationConfigContext<TSchema>): MaybePromise<TConfig | Partial<TConfig> | undefined>;
+}
+type FarmIntegrationConfigInput<TConfig = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = FarmIntegrationInputSchema<TConfig> | FarmIntegrationConfigDefinition<TConfig, TSchema>;
+type FarmIntegrationLifecycleLogLevel = "info" | "warn" | "error";
+interface FarmIntegrationLifecycleLogger {
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+}
+interface FarmIntegrationLifecycleContext<TConfig = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationConfigContext<TSchema> {
+    integration: FarmIntegration<TSchema, TConfig>;
+    integrationConfig: TConfig;
+    log: FarmIntegrationLifecycleLogger;
+    reason?: string;
+    cleanup(callback?: () => MaybePromise<void>): Promise<void>;
+}
+type FarmIntegrationLifecycleHook<TConfig = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = (context: FarmIntegrationLifecycleContext<TConfig, TSchema>) => MaybePromise<void>;
+/**
+ * Small per-call integration metadata. Values received over HTTP are
+ * client-controlled and should be validated before authorization decisions.
+ */
+type FarmIntegrationData = Record<string, unknown>;
+interface FarmIntegrationHandlerContext<TBody = unknown, TQuery = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    request: Request;
+    requestId: string;
+    url: URL;
+    pathname: string;
+    method: string;
+    params: FarmIntegrationRouteParams;
+    input: FarmIntegrationRouteInput<TBody, TQuery>;
+    args: FarmIntegrationRouteArgs<TSchema>;
+    data: FarmIntegrationData;
+    integration: {
+        category: FarmIntegrationCategory;
+        /** @deprecated Use category instead. */
+        slot: FarmIntegrationCategory;
+        type: string;
+        instance: unknown;
+    };
+    route: {
+        kind: "route" | "middleware";
+        path: string;
+        methods: readonly string[];
+    };
+    req: FarmRequestStore;
+    /** @deprecated Use `req` instead. */
+    requestContext: FarmRequestStore;
+    config: FarmPluginContext["config"];
+    isDev: boolean;
+    isProd: boolean;
+}
+interface FarmIntegrationRouteHookContext<TBody = unknown, TQuery = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationHandlerContext<TBody, TQuery, TSchema> {
+    response?: Response;
+}
+type FarmIntegrationRouteHook<TBody = unknown, TQuery = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = {
+    bivarianceHack(request: Request, context: FarmIntegrationRouteHookContext<TBody, TQuery, TSchema>): Promise<Response | void> | Response | void;
+}["bivarianceHack"];
+interface FarmIntegrationRoute<TBody = unknown, TQuery = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    path: string;
+    method?: FarmIntegrationRouteMethod;
+    methods?: readonly FarmIntegrationRouteMethod[];
+    middleware?: readonly FarmIntegrationRouteMiddleware<TSchema>[];
+    before?: readonly FarmIntegrationRouteHook<TBody, TQuery, TSchema>[];
+    after?: readonly FarmIntegrationRouteHook<TBody, TQuery, TSchema>[];
+    rawBody?: boolean;
+    bodyFormat?: FarmIntegrationAPIBodyFormat;
+    body?: FarmIntegrationInputSchema<TBody>;
+    query?: FarmIntegrationInputSchema<TQuery>;
+    input?: FarmIntegrationRouteInputSchemas<TBody, TQuery>;
+    handler(request: Request, context: FarmIntegrationHandlerContext<TBody, TQuery, TSchema>): Promise<Response> | Response;
+}
+interface FarmTypedIntegrationRoute<TPath extends string = string, TBody = never, TQuery = never, TResponse = unknown, TServer extends boolean = false, TMethod extends FarmIntegrationAPIMethod = FarmIntegrationAPIMethod, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationRoute<TBody, TQuery, TSchema> {
+    path: TPath;
+    method: TMethod;
+    __operation: FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, TMethod>;
+}
+interface FarmIntegrationRouteMiddleware<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, TSchema>): Promise<Response | void> | Response | void;
+}
+interface FarmIntegrationMiddleware<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    matcher?: string | string[];
+    handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, TSchema>): Promise<Response | void> | Response | void;
+}
+interface FarmIntegrationProviderProps {
+    children: ReactNode;
+}
+interface FarmIntegrationProvider {
+    name: string;
+    type: string;
+    props?: Record<string, unknown>;
+    component?: ComponentType<FarmIntegrationProviderProps>;
+}
+interface FarmIntegrationDocumentNavigation {
+    matcher: string | readonly string[];
+}
+type FarmIntegrationSchemaFieldType = "id" | "uuid" | "string" | "text" | "boolean" | "integer" | "number" | "datetime" | "json" | "enum";
+interface FarmIntegrationSchemaReference {
+    model: string;
+    field: string;
+    relation?: "belongsTo" | "hasOne" | "hasMany";
+    onDelete?: "cascade" | "restrict" | "setNull" | "noAction";
+    enforced?: "db" | "app" | "none";
+}
+interface FarmIntegrationSchemaField {
+    type: FarmIntegrationSchemaFieldType;
+    name?: string;
+    description?: string;
+    required?: boolean;
+    nullable?: boolean;
+    primaryKey?: boolean;
+    unique?: boolean;
+    index?: boolean;
+    list?: boolean;
+    default?: unknown;
+    values?: readonly string[];
+    reference?: FarmIntegrationSchemaReference;
+    meta?: Record<string, unknown>;
+}
+interface FarmIntegrationSchemaConstraint {
+    type: "unique" | "index";
+    fields: readonly string[];
+    name?: string;
+    meta?: Record<string, unknown>;
+}
+interface FarmIntegrationSchemaModel {
+    name?: string;
+    description?: string;
+    fields: Record<string, FarmIntegrationSchemaField>;
+    constraints?: readonly FarmIntegrationSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmIntegrationSchemaModelExtension {
+    name?: string;
+    description?: string;
+    fields?: Record<string, FarmIntegrationSchemaField>;
+    constraints?: readonly FarmIntegrationSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmIntegrationSchemaModelOverride {
+    name?: string;
+    description?: string;
+    fields?: Record<string, Partial<FarmIntegrationSchemaField>>;
+    constraints?: readonly FarmIntegrationSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmIntegrationSchema {
+    models: Record<string, FarmIntegrationSchemaModel>;
+    meta?: Record<string, unknown>;
+    extend?: Record<string, FarmIntegrationSchemaModelExtension>;
+    override?: Record<string, FarmIntegrationSchemaModelOverride>;
+}
+declare function defineIntegrationSchema<TSchema extends FarmIntegrationSchema>(schema: TSchema): TSchema;
+type FarmIntegrationLogPhase = "registered" | "validate" | "setup" | "ready" | "dispose" | "request:start" | "request:end" | "request:error";
+interface FarmIntegrationLogEvent {
+    category: FarmIntegrationCategory;
+    /** @deprecated Use category instead. */
+    slot: FarmIntegrationCategory;
+    type: string;
+    phase: FarmIntegrationLogPhase;
+    route?: {
+        kind: "route" | "middleware";
+        path: string;
+        methods: readonly string[];
+    };
+    requestId?: string;
+    request?: Request;
+    response?: Response;
+    error?: unknown;
+    durationMs?: number;
+    level?: FarmIntegrationLifecycleLogLevel;
+    message?: string;
+    meta?: Record<string, unknown>;
+    context: Map<string, unknown>;
+}
+type FarmIntegrationLogger = (event: FarmIntegrationLogEvent) => void | Promise<void>;
+interface FarmIntegrationPluginOwner {
+    key: string;
+    category: FarmIntegrationCategory;
+    type: string;
+    source: "lifecycle" | "contribution";
+    serverRuntime: boolean;
+}
+/** A normal plugin or an integration-bound plugin compatible with the shared instance. */
+type FarmIntegrationContributedPlugin<TInstance = unknown> = FarmPlugin<any, any, any, any, unknown, false> | FarmPlugin<any, any, any, any, TInstance, true>;
+interface FarmIntegration<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined, TConfig = unknown, TInstance = unknown> {
+    readonly kind: "farm-integration";
+    category: FarmIntegrationCategory;
+    /** @deprecated Use category instead. */
+    slot?: FarmIntegrationCategory;
+    type: string;
+    instance: TInstance;
+    /** Set to false when a platform adapter owns this integration's production routes. */
+    serverRuntime?: boolean;
+    api?: FarmIntegrationAPI;
+    schema?: TSchema;
+    config?: FarmIntegrationConfigInput<TConfig, TSchema>;
+    validate?: FarmIntegrationLifecycleHook<TConfig, TSchema>;
+    setup?: FarmIntegrationLifecycleHook<TConfig, TSchema>;
+    ready?: FarmIntegrationLifecycleHook<TConfig, TSchema>;
+    dispose?: FarmIntegrationLifecycleHook<TConfig, TSchema>;
+    log?: FarmIntegrationLogger;
+    routes?: readonly FarmIntegrationRoute<any, any, TSchema>[];
+    endpoints?: FarmIntegrationEndpoints<TSchema>;
+    middleware?: readonly FarmIntegrationMiddleware<TSchema>[];
+    providers?: readonly FarmIntegrationProvider[];
+    documentNavigations?: readonly FarmIntegrationDocumentNavigation[];
+    /** Additional Farm plugins owned and configured by this integration. */
+    plugins?: readonly FarmIntegrationContributedPlugin<NoInfer<TInstance>>[];
+}
+type FarmIntegrationsUserConfig = Record<string, FarmIntegration<any, any, any> | undefined>;
+/** @internal Identifies plugins owned by platform-managed integrations. */
+declare function getFarmIntegrationPluginServerRuntime(plugin: FarmPlugin): boolean | undefined;
+/** Returns the integration that contributed a normalized plugin, when applicable. */
+declare function getFarmIntegrationPluginOwner(plugin: FarmPlugin): Readonly<FarmIntegrationPluginOwner> | undefined;
+type IntegrationRouteBuilderOptions<TBody, TQuery, TServer extends boolean, TSchema extends FarmIntegrationSchema | undefined> = {
+    middleware?: readonly FarmIntegrationRouteMiddleware<TSchema>[];
+    before?: readonly FarmIntegrationRouteHook<TBody, TQuery, TSchema>[];
+    after?: readonly FarmIntegrationRouteHook<TBody, TQuery, TSchema>[];
+    rawBody?: boolean;
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+    bodyFormat?: FarmIntegrationAPIBodyFormat;
+    responseFormat?: FarmIntegrationAPIResponseFormat;
+    isServer?: TServer;
+    body?: FarmIntegrationInputSchema<TBody>;
+    query?: FarmIntegrationInputSchema<TQuery>;
+    input?: FarmIntegrationRouteInputSchemas<TBody, TQuery>;
+    handler(request: Request, context: FarmIntegrationHandlerContext<TBody, TQuery, TSchema>): Promise<Response> | Response;
+};
+interface FarmIntegrationRouteFactory<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    get<TPath extends string, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: Omit<IntegrationRouteBuilderOptions<never, TQuery, TServer, TSchema>, "bodyFormat">): FarmTypedIntegrationRoute<TPath, never, TQuery, TResponse, TServer, "GET", TSchema>;
+    post<TPath extends string, TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: IntegrationRouteBuilderOptions<TBody, TQuery, TServer, TSchema>): FarmTypedIntegrationRoute<TPath, TBody, TQuery, TResponse, TServer, "POST", TSchema>;
+    put<TPath extends string, TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: IntegrationRouteBuilderOptions<TBody, TQuery, TServer, TSchema>): FarmTypedIntegrationRoute<TPath, TBody, TQuery, TResponse, TServer, "PUT", TSchema>;
+    patch<TPath extends string, TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: IntegrationRouteBuilderOptions<TBody, TQuery, TServer, TSchema>): FarmTypedIntegrationRoute<TPath, TBody, TQuery, TResponse, TServer, "PATCH", TSchema>;
+    delete<TPath extends string, TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: IntegrationRouteBuilderOptions<TBody, TQuery, TServer, TSchema>): FarmTypedIntegrationRoute<TPath, TBody, TQuery, TResponse, TServer, "DELETE", TSchema>;
+    options<TPath extends string, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: Omit<IntegrationRouteBuilderOptions<never, TQuery, TServer, TSchema>, "bodyFormat">): FarmTypedIntegrationRoute<TPath, never, TQuery, TResponse, TServer, "OPTIONS", TSchema>;
+    head<TPath extends string, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: Omit<IntegrationRouteBuilderOptions<never, TQuery, TServer, TSchema>, "bodyFormat">): FarmTypedIntegrationRoute<TPath, never, TQuery, TResponse, TServer, "HEAD", TSchema>;
+}
+interface FarmIntegrationRoutesFactoryContext<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    route: FarmIntegrationRouteFactory<TSchema>;
+    integrationRoute: FarmIntegrationRouteFactory<TSchema>;
+}
+type FarmIntegrationRoutesFactory<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = (context: FarmIntegrationRoutesFactoryContext<TSchema>) => readonly FarmIntegrationRoute<any, any, TSchema>[];
+type FarmIntegrationEndpointValue<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = FarmIntegrationRoute<any, any, TSchema> | readonly FarmIntegrationEndpointValue<TSchema>[] | {
+    readonly [key: string]: FarmIntegrationEndpointValue<TSchema> | undefined;
+};
+type FarmIntegrationEndpoints<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = {
+    readonly [key: string]: FarmIntegrationEndpointValue<TSchema> | undefined;
+};
+interface FarmIntegrationEndpointsFactoryContext<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationRoutesFactoryContext<TSchema> {
+    endpoint: FarmIntegrationRouteFactory<TSchema>;
+}
+type FarmIntegrationEndpointsFactory<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = (context: FarmIntegrationEndpointsFactoryContext<TSchema>) => FarmIntegrationEndpoints<TSchema>;
+declare function createIntegrationRoute<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined>(_schema?: TSchema): FarmIntegrationRouteFactory<TSchema>;
+declare const integrationRoute: FarmIntegrationRouteFactory<undefined>;
+type RegisteredIntegrationRuntime = {
+    integration: FarmIntegration;
+    config: FarmPluginContext["config"];
+    isDev: boolean;
+    isProd: boolean;
+};
+type FarmIntegrationRoutesInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = readonly FarmIntegrationRoute<any, any, TSchema>[] | FarmIntegrationRoutesFactory<TSchema>;
+type FarmIntegrationEndpointsInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = FarmIntegrationEndpoints<TSchema> | FarmIntegrationEndpointsFactory<TSchema>;
+type FarmIntegrationInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined, TConfig = unknown, TInstance = unknown> = Omit<FarmIntegration<TSchema, TConfig, TInstance>, "kind" | "category" | "slot" | "instance" | "config" | "routes" | "endpoints" | "plugins"> & {
+    instance: TInstance;
+    config?: FarmIntegrationConfigInput<TConfig, TSchema>;
+    routes?: FarmIntegrationRoutesInput<TSchema>;
+    endpoints?: FarmIntegrationEndpointsInput<TSchema>;
+    plugins?: readonly FarmIntegrationContributedPlugin<NoInfer<TInstance>>[];
+} & ({
+    category: FarmIntegrationCategory;
+    slot?: FarmIntegrationCategory;
+} | {
+    category?: FarmIntegrationCategory;
+    slot: FarmIntegrationCategory;
+});
+type FarmIntegrationCategoryInput = {
+    category: FarmIntegrationCategory;
+    slot?: FarmIntegrationCategory;
+} | {
+    category?: FarmIntegrationCategory;
+    slot: FarmIntegrationCategory;
+};
+type FarmIntegrationShapeForInference = FarmIntegrationCategoryInput & {
+    api?: FarmIntegrationAPI;
+    schema?: FarmIntegrationSchema;
+    config?: unknown;
+    routes?: unknown;
+    endpoints?: unknown;
+};
+type ExtractIntegrationSchema<TIntegration> = TIntegration extends {
+    schema: infer TSchema extends FarmIntegrationSchema;
+} ? TSchema : undefined;
+type ResolveIntegrationRoutesInput<TRoutes, TSchema extends FarmIntegrationSchema | undefined> = TRoutes extends FarmIntegrationRoutesFactory<TSchema> ? ReturnType<TRoutes> : TRoutes;
+type ResolveIntegrationEndpointsInput<TEndpoints, TSchema extends FarmIntegrationSchema | undefined> = TEndpoints extends FarmIntegrationEndpointsFactory<TSchema> ? ReturnType<TEndpoints> : TEndpoints;
+type ExtractIntegrationRoutesFromRoutesInput<TRoutes, TSchema extends FarmIntegrationSchema | undefined> = ResolveIntegrationRoutesInput<TRoutes, TSchema> extends readonly (infer TRoute)[] ? TRoute : never;
+type ExtractIntegrationRoutesFromEndpointValue<TValue> = TValue extends FarmIntegrationRouteOperationCarrier<string, any> ? TValue : TValue extends readonly (infer TItem)[] ? ExtractIntegrationRoutesFromEndpointValue<TItem> : TValue extends object ? ExtractIntegrationRoutesFromEndpointValue<TValue[keyof TValue]> : never;
+type ExtractIntegrationRoutesFromEndpointsInput<TEndpoints, TSchema extends FarmIntegrationSchema | undefined> = ExtractIntegrationRoutesFromEndpointValue<ResolveIntegrationEndpointsInput<TEndpoints, TSchema>>;
+type ExtractIntegrationRouteUnion<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = (TIntegration extends {
+    routes: infer TRoutes;
+} ? ExtractIntegrationRoutesFromRoutesInput<TRoutes, TSchema> : never) | (TIntegration extends {
+    endpoints: infer TEndpoints;
+} ? ExtractIntegrationRoutesFromEndpointsInput<TEndpoints, TSchema> : never);
+type ExtractDefinedIntegrationRoutes<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = [ExtractIntegrationRouteUnion<TIntegration, TSchema>] extends [never] ? undefined : readonly ExtractIntegrationRouteUnion<TIntegration, TSchema>[];
+type ExtractDefinedIntegrationEndpoints<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = TIntegration extends {
+    endpoints: infer TEndpoints;
+} ? ResolveIntegrationEndpointsInput<TEndpoints, TSchema> : undefined;
+type ExtractIntegrationAPIRoutes<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = Extract<ExtractIntegrationRouteUnion<TIntegration, TSchema>, FarmIntegrationRouteOperationCarrier<string, any>>;
+type ExtractIntegrationCategory<TIntegration extends FarmIntegrationCategoryInput> = TIntegration extends {
+    category: infer TCategory extends FarmIntegrationCategory;
+} ? TCategory : TIntegration extends {
+    slot: infer TSlot extends FarmIntegrationCategory;
+} ? TSlot : FarmIntegrationCategory;
+type ExtractDerivedIntegrationAPI<TIntegration extends FarmIntegrationShapeForInference, TSchema extends FarmIntegrationSchema | undefined = ExtractIntegrationSchema<TIntegration>> = TIntegration extends {
+    api: infer TAPI extends FarmIntegrationAPI;
+} ? TAPI : [ExtractIntegrationAPIRoutes<TIntegration, TSchema>] extends [never] ? FarmIntegrationAPI | undefined : InferIntegrationAPIFromRoutes<readonly ExtractIntegrationAPIRoutes<TIntegration, TSchema>[]>;
+type DefinedIntegration<TIntegration extends FarmIntegrationShapeForInference, TSchema extends FarmIntegrationSchema | undefined = ExtractIntegrationSchema<TIntegration>> = Omit<TIntegration, "kind" | "category" | "slot" | "api" | "routes" | "endpoints"> & {
+    readonly kind: "farm-integration";
+    category: ExtractIntegrationCategory<TIntegration>;
+    slot: ExtractIntegrationCategory<TIntegration>;
+    routes: ExtractDefinedIntegrationRoutes<TIntegration, TSchema>;
+    endpoints: ExtractDefinedIntegrationEndpoints<TIntegration, TSchema>;
+    api: ExtractDerivedIntegrationAPI<TIntegration, TSchema>;
+};
+declare function defineIntegration<const TSchema extends FarmIntegrationSchema | undefined, const TConfig, TIntegration extends FarmIntegrationInput<TSchema, TConfig, any>>(integration: TIntegration & FarmIntegrationInput<TSchema, TConfig, NoInfer<TIntegration["instance"]>>): DefinedIntegration<TIntegration, TSchema>;
+declare function isFarmIntegration(value: unknown): value is FarmIntegration;
+declare function resolveIntegrationPlugins(integrations: FarmIntegrationsUserConfig | undefined): FarmPlugin[];
+declare function getIntegrationProviders(integrations: FarmIntegrationsUserConfig | undefined): Array<Pick<FarmIntegrationProvider, "name" | "type" | "props">>;
+declare function getIntegrationDocumentNavigationMatchers(integrations: FarmIntegrationsUserConfig | undefined): string[];
+declare function getIntegrationSchemas(integrations: FarmIntegrationsUserConfig | undefined): Record<string, FarmIntegrationSchema>;
+declare function getRegisteredIntegrationRuntime(key: string): RegisteredIntegrationRuntime | undefined;
+declare function getRegisteredIntegrations(): Record<string, FarmIntegration>;
+declare function getRegisteredIntegrationSchemas(): Record<string, FarmIntegrationSchema>;
+declare function matchIntegrationRoute(integrations: FarmIntegrationsUserConfig | undefined, input: {
+    pathname: string;
+    method?: string;
+}): {
+    key: string;
+    integration: FarmIntegration;
+    route: {
+        path: string;
+        methods: readonly string[];
+    };
+    params: FarmIntegrationRouteParams;
+} | null;
+declare function matchRegisteredIntegrationRoute(input: {
+    pathname: string;
+    method?: string;
+}): {
+    key: string;
+    integration: FarmIntegration;
+    route: {
+        path: string;
+        methods: readonly string[];
+    };
+    params: FarmIntegrationRouteParams;
+} | null;
+declare function getRegisteredIntegrationAPIManifest(): Record<string, FarmIntegrationAPI>;
+declare function dispatchIntegrationRequest(runtime: RegisteredIntegrationRuntime, request: Request, options?: {
+    currentRequest?: Request;
+    data?: FarmIntegrationData;
+    internal?: boolean;
+}): Promise<Response | null>;
+
+declare global {
+    namespace FarmJS {
+        /** @internal Application route patterns registered by generated types. */
+        interface RouteRegistry {
+        }
+    }
+}
+/** All generated route module patterns for the current application. */
+type AppRoutePattern = FarmJS.RouteRegistry extends {
+    pattern: infer TPattern extends string;
+} ? TPattern : string;
+type FarmRoutePropsDefault = never;
+type FarmRoutePropsTarget = AppRoutePattern;
+type StripPageRouteSuffix<TRoute extends string> = TRoute extends `${infer TPath}?${string}` ? StripPageRouteSuffix<TPath> : TRoute extends `${infer TPath}#${string}` ? StripPageRouteSuffix<TPath> : TRoute;
+type SimplifyPageRouteParams<TValue> = {
+    [TKey in keyof TValue]: TValue[TKey];
+} & {};
+type PageRouteSegmentParams<TSegment extends string> = TSegment extends `[[...${infer TParam}]]` ? {
+    [TKey in TParam]?: string;
+} : TSegment extends `[...${infer TParam}]` ? {
+    [TKey in TParam]: string;
+} : TSegment extends `[${infer TParam}]` ? {
+    [TKey in TParam]: string;
+} : {};
+type ExtractPageRouteParams<TRoute extends string> = TRoute extends `${infer TSegment}/${infer TRest}` ? PageRouteSegmentParams<TSegment> & ExtractPageRouteParams<TRest> : PageRouteSegmentParams<TRoute>;
+/** Infer the decoded params received by a page from a route pattern. */
+type PageRouteParams<TRoute extends string> = string extends TRoute ? Record<string, string> : TRoute extends string ? SimplifyPageRouteParams<ExtractPageRouteParams<StripPageRouteSuffix<TRoute>>> : never;
+type ResolvePageRouteParams<TRoute extends FarmRoutePropsTarget> = [TRoute] extends [never] ? Record<string, string> : TRoute extends string ? PageRouteParams<TRoute> : Record<string, string>;
+type NitroPreset = "node-server" | "vercel" | "cloudflare" | "cloudflare-pages" | "netlify" | "netlify-edge" | "bun" | "deno" | "azure" | "aws-lambda" | "firebase" | "custom" | "self-host" | "farm" | string;
+type FarmMigrationCommand = string | {
+    /** Shell command to run for this migration step. */
+    command: string;
+    /** Optional label printed by the CLI before running the command. */
+    name?: string;
+    /** Working directory for this command, relative to the project root unless absolute. */
+    cwd?: string;
+    /** Additional environment variables for this command. */
+    env?: Record<string, string | undefined>;
+    /** Skip this command without removing it from config. */
+    skip?: boolean;
+};
+interface FarmMigrationsConfig {
+    /** One-shot commands that create or update app/integration schemas. */
+    commands?: FarmMigrationCommand[];
+}
+type FarmMigrationsUserConfig = FarmMigrationsConfig | FarmMigrationCommand[];
+interface ResolvedFarmMigrationsConfig {
+    commands: FarmMigrationCommand[];
+}
+interface FarmContextFactoryInput {
+    request: Request;
+    rawRequest?: FarmRequest;
+    params: Record<string, string>;
+    search: Record<string, string | string[] | undefined>;
+    path: string;
+}
+type FarmContextFactory<TContext = unknown> = (input: FarmContextFactoryInput) => TContext | Promise<TContext>;
+interface FarmAppContext {
+}
+interface FarmConfig {
+    root?: string;
+    /** App source directory. @default "src" */
+    srcDir?: string;
+    extends?: readonly FarmLayerEntry[];
+    /** Resolved layer graph. Populated by config resolution. */
+    layers?: readonly ResolvedFarmLayer[];
+    outDir?: string;
+    basePath?: string;
+    preset?: NitroPreset;
+    deploy?: {
+        target?: "vercel" | "cloudflare" | "netlify" | "node" | string;
+        preset?: NitroPreset;
+        outputDir?: string;
+        output?: string;
+        projectName?: string;
+        vercel?: {
+            outputDirectory?: string;
+            buildCommand?: string;
+            installCommand?: string;
+            framework?: string | null;
+        };
+        cloudflare?: {
+            outputDir?: string;
+            projectName?: string;
+        };
+        netlify?: {
+            outputDir?: string;
+            site?: string;
+        };
+    };
+    storage?: FarmStorageUserConfig;
+    /** Shared application data, route, ISR, and PPR cache. */
+    cache?: FarmCacheUserConfig;
+    integrations?: FarmIntegrationsUserConfig;
+    /** Farm-native authentication. `true` enables email/password auth. */
+    auth?: FarmAuthUserConfig | ResolvedFarmAuthConfig;
+    plugins?: FarmPlugin[];
+    migrations?: FarmMigrationsUserConfig;
+    /** Map portable cron schedules to ordinary GET API routes. */
+    cron?: FarmCronUserConfig | FarmCronResolvedConfig | false;
+    workflows?: FarmWorkflowsUserConfig | boolean;
+    env?: FarmEnvConfig<any, any> | ResolvedFarmEnv;
+    middleware?: FarmMiddlewareConfig;
+    routeRules?: FarmRouteRules;
+    context?: FarmContextFactory<any>;
+    /** Server ingress and trusted-proxy policy. */
+    server?: FarmServerConfig;
+    serverActions?: FarmServerActionsConfig;
+    /** App-wide HTTP security policy. */
+    security?: FarmSecurityConfig | ResolvedFarmSecurityConfig;
+    images?: FarmImageConfig;
+    /** Browser resource scheduling and preload budgets. */
+    performance?: FarmPerformanceConfig;
+    /** Built-in light, dark, and system color-mode runtime. */
+    theme?: FarmThemeConfig | ResolvedFarmThemeConfig | false;
+    i18n?: FarmI18nUserConfig | ResolvedFarmI18nConfig | false;
+    /** Build identifier used to detect stale clients during rolling deployments. */
+    deploymentId?: string;
+    docs?: FarmDocsUserConfig | FarmDocsResolvedConfig;
+    md?: FarmMarkdownUserConfig | FarmMarkdownResolvedConfig | boolean;
+    mdx?: FarmMdxUserConfig | FarmMdxResolvedConfig;
+    observability?: FarmObservabilityUserConfig;
+    /** Development-only runtime inspector. Enabled by default during `farm dev`. */
+    devtools?: FarmDevtoolsUserConfig;
+    /**
+     * When true, Link href is not strictly typed (accepts any string).
+     * Use when you want to skip route-type errors on Link or don't use generated route types.
+     */
+    suppressLintOnLink?: boolean;
+    experimental?: {
+        serverComponents?: boolean;
+        serverActions?: boolean;
+        /**
+         * Automatically optimize eligible server-only host-element subtrees with
+         * the native Strata renderer. Unsupported trees keep normal React
+         * rendering; no application boundary component is required.
+         *
+         * @experimental
+         * @default false
+         */
+        optimizedBoundary?: boolean;
+    };
+    vite?: any;
+}
+/**
+ * Middleware data available in page components
+ */
+interface MiddlewareProps {
+    /**
+     * Map containing all data set by middleware via ctx.data.set()
+     *
+     * @example
+     * ```tsx
+     * // In middleware.ts
+     * ctx.data.set('user', { id: 1, name: 'John' });
+     *
+     * // In page.tsx
+     * const user = props.middleware?.data.get('user');
+     * ```
+     */
+    data: Map<string, any>;
+}
+/**
+ * Plugin context data available in server page components.
+ * Only values explicitly exposed by plugins are included.
+ */
+interface PluginContextProps {
+    data: Map<string, any>;
+}
+/**
+ * Page component props
+ *
+ * @param params - Dynamic route parameters (e.g., { id: '123' } for /users/[id])
+ * @param searchParams - URL search/query parameters
+ * @param path - Current pathname
+ * @param middleware - Data set by middleware.ts (optional, available if middleware exists)
+ * @param context - Data explicitly exposed by plugins for this request (optional)
+ */
+interface PageProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
+    params: ResolvePageRouteParams<TRoute>;
+    searchParams: Promise<Record<string, string | string[] | undefined>>;
+    path: string;
+    /**
+     * Data from middleware.ts in the same directory or parent directories
+     * Access data via props.middleware?.data.get('key')
+     *
+     * @example
+     * ```tsx
+     * export default function Page(props: PageProps) {
+     *   const user = props.middleware?.data.get('user');
+     *   const stats = props.middleware?.data.get('dashboardStats');
+     *
+     *   return <div>Welcome {user?.name}</div>;
+     * }
+     * ```
+     */
+    middleware?: MiddlewareProps;
+    /**
+     * Request-scoped plugin context values explicitly exposed by plugins.
+     * Access data via props.context?.data.get('key').
+     */
+    context?: PluginContextProps;
+}
+interface LoadingProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
+    params: ResolvePageRouteParams<TRoute>;
+    searchParams: Promise<Record<string, string | string[] | undefined>>;
+    search?: Record<string, string | string[] | undefined>;
+    path: string;
+    middleware?: MiddlewareProps;
+    context?: PluginContextProps;
+}
+interface ErrorProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> extends LoadingProps<TRoute> {
+    error: unknown;
+    reset: () => void;
+}
+/**
+ * Helper type to create typed page props with specific middleware data shape
+ *
+ * @example
+ * ```tsx
+ * interface MyMiddlewareData {
+ *   user: { id: number; name: string };
+ *   stats: { views: number };
+ * }
+ *
+ * type MyPageProps = PagePropsWithMiddleware<MyMiddlewareData>;
+ *
+ * export default function Page(props: MyPageProps) {
+ *   const user = props.middleware?.data.get('user');  // Fully typed!
+ *   const stats = props.middleware?.data.get('stats');  // Fully typed!
+ *
+ *   return <div>Welcome {user?.name}</div>;
+ * }
+ * ```
+ */
+type PagePropsWithMiddleware<T extends Record<string, any>, TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = PageProps<TRoute> & {
+    middleware: {
+        data: Map<keyof T, T[keyof T]>;
+    };
+};
+interface LayoutProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
+    children: ReactNode;
+    params: ResolvePageRouteParams<TRoute>;
+}
+/** Props passed to a route's `generateMetadata` function. */
+type MetadataProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = PageProps<TRoute>;
+/** Props passed to a layout's `generateMetadata` function. */
+interface LayoutMetadataProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
+    params: ResolvePageRouteParams<TRoute>;
+}
+type Page<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = ComponentType<PageProps<TRoute>>;
+type Layout<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = ComponentType<LayoutProps<TRoute>>;
+type Loading<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = ComponentType<LoadingProps<TRoute>>;
+type ErrorBoundary<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = ComponentType<ErrorProps<TRoute>>;
+/**
+ * Route module exports for pages
+ *
+ * SSR is the default - pages render on each request
+ * SSG is opt-in via `export const ssg = true`, Next-compatible route
+ * config exports, or a top-of-file rendering directive.
+ *
+ * @example SSR Page (default):
+ * ```tsx
+ * export default async function Page() {
+ *   const data = await fetchData();
+ *   return <div>{data.title}</div>;
+ * }
+ * ```
+ *
+ * @example SSG Page:
+ * ```tsx
+ * export const ssg = true;
+ *
+ * export default function AboutPage() {
+ *   return <h1>About Us</h1>;
+ * }
+ * ```
+ *
+ * @example SSG with Revalidation (ISR):
+ * ```tsx
+ * export const ssg = true;
+ * export const revalidate = 60; // Regenerate every 60 seconds
+ *
+ * export default async function ProductsPage() {
+ *   const products = await fetchProducts();
+ *   return <ProductList products={products} />;
+ * }
+ * ```
+ *
+ * @example Dynamic SSG Route:
+ * ```tsx
+ * export const ssg = true;
+ *
+ * export async function getStaticPaths() {
+ *   const posts = await fetchPosts();
+ *   return posts.map(post => ({ slug: post.slug }));
+ * }
+ *
+ * export default async function BlogPost({ params }) {
+ *   const post = await fetchPost(params.slug);
+ *   return <article>{post.title}</article>;
+ * }
+ * ```
+ *
+ * @example Next-compatible Route Config:
+ * ```tsx
+ * export const dynamic = "force-static";
+ * export const revalidate = 60;
+ *
+ * export default function DocsPage() {
+ *   return <h1>Docs</h1>;
+ * }
+ * ```
+ *
+ * @example Directive Route Config:
+ * ```tsx
+ * "use ssg; 60";
+ *
+ * export default function DocsPage() {
+ *   return <h1>Docs</h1>;
+ * }
+ * ```
+ */
+interface RouteModule<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
+    default?: Page<TRoute>;
+    /** Execution runtime for this route. Layout values are inherited unless overridden. */
+    runtime?: FarmRouteRuntime;
+    /** Provider-specific execution regions, or "auto" to clear an inherited value. */
+    regions?: FarmRouteRegions;
+    /** Maximum execution time in seconds, or "auto" to use the provider default. */
+    maxDuration?: FarmRouteMaxDuration;
+    /**
+     * Mark this page for Static Site Generation (SSG)
+     * When true, the page will be pre-rendered at build time
+     */
+    ssg?: boolean;
+    /**
+     * Revalidate interval in seconds for Incremental Static Regeneration (ISR)
+     * Only applicable when ssg = true
+     */
+    revalidate?: number | false;
+    /**
+     * Next.js-compatible rendering mode.
+     * - force-static/error: pre-render at build time
+     * - force-dynamic: render on each request
+     */
+    dynamic?: "auto" | "force-static" | "force-dynamic" | "error";
+    /**
+     * Opt into Partial Prerendering/static-shell caching for this route.
+     * Compatible with Farm's `ppr` export and Next.js `experimental_ppr`.
+     */
+    ppr?: boolean;
+    experimental_ppr?: boolean;
+    /**
+     * Return all paths to pre-render for dynamic SSG routes
+     * Required for dynamic routes (e.g., [slug]) when ssg = true
+     */
+    getStaticPaths?: GenerateStaticParams<TRoute>;
+    /**
+     * @deprecated Use getStaticPaths instead
+     */
+    generateStaticParams?: GenerateStaticParams<TRoute>;
+    metadata?: Metadata & Record<string, any>;
+    generateMetadata?: (props: MetadataProps<TRoute>) => Promise<Metadata> | Metadata;
+}
+/** A value accepted for one static route parameter. */
+type StaticPathPrimitive = string | number | boolean;
+/**
+ * Parameters returned by `getStaticPaths` or `generateStaticParams`.
+ * Arrays create individual URL segments for catch-all route parameters.
+ */
+type StaticPathParams = Record<string, StaticPathPrimitive | readonly StaticPathPrimitive[]>;
+type StaticRouteSegmentParams<TSegment extends string> = TSegment extends `[[...${infer TParam}]]` ? {
+    [TKey in TParam]?: readonly StaticPathPrimitive[];
+} : TSegment extends `[...${infer TParam}]` ? {
+    [TKey in TParam]: readonly StaticPathPrimitive[];
+} : TSegment extends `[${infer TParam}]` ? {
+    [TKey in TParam]: StaticPathPrimitive;
+} : {};
+type ExtractStaticRouteParams<TRoute extends string> = TRoute extends `${infer TSegment}/${infer TRest}` ? StaticRouteSegmentParams<TSegment> & ExtractStaticRouteParams<TRest> : StaticRouteSegmentParams<TRoute>;
+/** Infer the values accepted from `getStaticPaths` for a route pattern. */
+type StaticRouteParams<TRoute extends string> = string extends TRoute ? StaticPathParams : TRoute extends string ? SimplifyPageRouteParams<ExtractStaticRouteParams<StripPageRouteSuffix<TRoute>>> : never;
+type ResolveStaticRouteParams<TRoute extends FarmRoutePropsTarget> = [TRoute] extends [never] ? StaticPathParams : TRoute extends string ? StaticRouteParams<TRoute> : StaticPathParams;
+/** A route-aware `getStaticPaths` or `generateStaticParams` function. */
+type GenerateStaticParams<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = () => Array<ResolveStaticRouteParams<TRoute>> | Promise<Array<ResolveStaticRouteParams<TRoute>>>;
+interface LayoutModule<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
+    default: Layout<TRoute>;
+    /** Semantic fonts inherited by framework-owned surfaces for this route. */
+    fonts?: FarmLayoutFonts;
+    runtime?: FarmRouteRuntime;
+    regions?: FarmRouteRegions;
+    maxDuration?: FarmRouteMaxDuration;
+    metadata?: Metadata & Record<string, any>;
+    generateMetadata?: (props: LayoutMetadataProps<TRoute>) => Promise<Metadata> | Metadata;
+}
+interface Metadata {
+    metadataBase?: string | URL;
+    title?: string | {
+        default?: string;
+        template?: string;
+    };
+    description?: string;
+    keywords?: string | string[];
+    author?: string;
+    authors?: Array<{
+        name: string;
+        url?: string;
+    }>;
+    creator?: string;
+    publisher?: string;
+    robots?: string | {
+        index?: boolean;
+        follow?: boolean;
+    };
+    openGraph?: {
+        title?: string;
+        description?: string;
+        url?: string;
+        siteName?: string;
+        images?: string | {
+            url: string;
+            width?: number;
+            height?: number;
+            alt?: string;
+            type?: string;
+        } | Array<{
+            url: string;
+            width?: number;
+            height?: number;
+            alt?: string;
+            type?: string;
+        }>;
+        image?: string;
+        type?: string;
+        locale?: string;
+    };
+    twitter?: {
+        card?: "summary" | "summary_large_image" | "app" | "player";
+        site?: string;
+        creator?: string;
+        title?: string;
+        description?: string;
+        images?: string | {
+            url: string;
+            width?: number;
+            height?: number;
+            alt?: string;
+            type?: string;
+        } | Array<string | {
+            url: string;
+            width?: number;
+            height?: number;
+            alt?: string;
+            type?: string;
+        }>;
+    };
+    alternates?: {
+        canonical?: string;
+        languages?: Record<string, string>;
+    };
+    icons?: string | {
+        icon?: string | Array<string | {
+            url: string;
+            sizes?: string;
+            type?: string;
+        }>;
+        shortcut?: string | Array<string | {
+            url: string;
+            sizes?: string;
+            type?: string;
+        }>;
+        apple?: string | Array<string | {
+            url: string;
+            sizes?: string;
+            type?: string;
+        }>;
+    };
+    manifest?: string;
+}
+interface FarmRequest extends IncomingMessage {
+    params?: Record<string, string>;
+    query?: Record<string, string | string[]>;
+    body?: any;
+}
+interface FarmResponse extends ServerResponse {
+    json: (data: any) => void;
+    status: (code: number) => FarmResponse;
+    redirect: (url: string, status?: number) => void;
+}
+type ServerAction = (...args: any[]) => Promise<any>;
+interface RouteSegment {
+    segment: string;
+    isDynamic: boolean;
+    isOptional: boolean;
+    isCatchAll: boolean;
+}
+interface ParsedRoute {
+    segments: RouteSegment[];
+    filePath: string;
+    type: "page" | "layout" | "loading" | "error" | "not-found";
+}
+interface BuildOptions {
+    mode: "development" | "production";
+    ssr: boolean;
+    minify: boolean;
+    sourcemap: boolean;
+}
+/**
+ * Represents a page to be pre-rendered at build time (SSG)
+ */
+interface SSGPage {
+    /** The URL path for this page */
+    urlPath: string;
+    /** The file path to the page module */
+    filePath: string;
+    /** Route parameters for dynamic routes */
+    params: Record<string, string>;
+    /** Revalidation interval in seconds (ISR) */
+    revalidate?: number;
+}
+/**
+ * Result of SSG page collection
+ */
+interface SSGCollectionResult {
+    /** Pages to pre-render at build time */
+    ssg: SSGPage[];
+    /** Routes that will be server-rendered on each request */
+    ssr: string[];
+}
+
+export { type FarmPlugin as $, type AppRoutePattern as A, type RouteSegment as B, type ParsedRoute as C, type BuildOptions as D, type ErrorProps as E, type FarmConfig as F, type GenerateStaticParams as G, type SSGPage as H, type SSGCollectionResult as I, type FarmLayerEntry as J, type ResolvedFarmLayer as K, type LoadingProps as L, type MiddlewareProps as M, type NitroPreset as N, type FarmSourceRoot as O, type PageRouteParams as P, type ResolveFarmLayersOptions as Q, type ResolvedFarmMigrationsConfig as R, type StaticPathPrimitive as S, type FarmLayerResolution as T, resolveFarmLayers as U, getFarmSourceRoots as V, getFarmAppDirectories as W, getFarmLayerAliases as X, loadFarmConfigFile as Y, type FarmUserConfig as Z, type BundleResultPayload as _, type FarmMigrationCommand as a, type FarmPluginRouterHooks as a$, type FarmIntegration as a0, type ReadonlyMiddlewareStore as a1, type FarmMiddlewareConfig as a2, type MiddlewareModule as a3, type FarmMdxResolvedConfig as a4, type ResolvedFarmDevtoolsConfig as a5, type ResolvedFarmAuthConfig as a6, type ResolvedFarmPerformanceConfig as a7, type ResolvedFarmSecurityConfig as a8, manageFarmDocumentPreloads as a9, type FarmAuthConfig as aA, type FarmAuthDatabaseConfig as aB, type FarmAuthEmailAndPasswordConfig as aC, type FarmAuthSessionConfig as aD, type FarmAuthUserConfig as aE, type PluginRequestContext as aF, type FarmPluginContext as aG, type FarmPluginIntegrationContext as aH, type FarmPluginLifecycle as aI, type FarmRequestPluginContext as aJ, type FarmRequestStore as aK, type FarmPluginRuntimeKind as aL, type FarmPluginRouteRuntimePayload as aM, type FarmPluginSetupContext as aN, type FarmPluginStateContext as aO, type FarmPluginRuntimeBaseEvent as aP, type FarmPluginRuntimeContextEvent as aQ, type FarmPluginRuntimeBeforeEvent as aR, type FarmPluginRuntimeAfterEvent as aS, type FarmPluginRuntimeErrorEvent as aT, type FarmPluginRuntimeStartEvent as aU, type FarmPluginRuntimeCloseEvent as aV, type FarmPluginRuntimeHooks as aW, type FarmPluginRuntimeRequestOptions as aX, type FarmPluginRuntimeRequestHandler as aY, type FarmPluginRuntimeSession as aZ, type FarmPluginDiscoveredRoute as a_, manageFarmHtmlPreloads as aa, manageFarmLinkHeaderPreloads as ab, reportFarmPreloadWarnings as ac, type OpenAPIConfig as ad, definePlugin as ae, FarmRuntimeShutdownError as af, PluginManager as ag, resolveConfig as ah, loadConfig as ai, resolveDeployConfig as aj, resolveMigrationsConfig as ak, resolveDeployOutputPath as al, normalizeDeployTarget as am, getDeployTargetForPreset as an, getPresetForDeployTarget as ao, type FarmLayerConfig as ap, type FarmPerformanceConfig as aq, type FarmPreloadMode as ar, type FarmPreloadUserConfig as as, type ResolvedFarmPreloadConfig as at, type FarmCspConfig as au, type FarmCspDirectives as av, type FarmCspDirectiveValue as aw, type FarmCspOptions as ax, type FarmSecurityConfig as ay, type ResolvedFarmCspConfig as az, type FarmMigrationsConfig as b, type FarmIntegrationDocumentNavigation as b$, type FarmPluginRenderHooks as b0, type FarmPluginBuildHooks as b1, type FarmPluginDevHooks as b2, type FarmPluginClientConfig as b3, type RouteDiscoveredPayload as b4, type RoutesGeneratedPayload as b5, type MiddlewareDiscoveredPayload as b6, type APIRouteDiscoveredPayload as b7, type RouteMatchPayload as b8, type RouteMatchResultPayload as b9, type FarmIntegrationValidationErrorLike as bA, type FarmIntegrationValidationResult as bB, type FarmIntegrationStandardValidationResult as bC, type FarmIntegrationInputSchema as bD, type FarmIntegrationRouteInputSchemas as bE, type FarmIntegrationRequestContextStore as bF, FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY as bG, type FarmIntegrationRouteDb as bH, type FarmIntegrationRouteStorageArgs as bI, type FarmIntegrationRouteArgs as bJ, type FarmIntegrationConfigContext as bK, type FarmIntegrationConfigDefinition as bL, type FarmIntegrationConfigInput as bM, type FarmIntegrationLifecycleLogLevel as bN, type FarmIntegrationLifecycleLogger as bO, type FarmIntegrationLifecycleContext as bP, type FarmIntegrationLifecycleHook as bQ, type FarmIntegrationData as bR, type FarmIntegrationHandlerContext as bS, type FarmIntegrationRouteHookContext as bT, type FarmIntegrationRouteHook as bU, type FarmIntegrationRoute as bV, type FarmTypedIntegrationRoute as bW, type FarmIntegrationRouteMiddleware as bX, type FarmIntegrationMiddleware as bY, type FarmIntegrationProviderProps as bZ, type FarmIntegrationProvider as b_, type RenderLifecyclePayload as ba, type APIHandlerLifecyclePayload as bb, type ErrorLifecyclePayload as bc, type HMRUpdatePayload as bd, type BundleLifecyclePayload as be, type NitroBuildLifecyclePayload as bf, type ShutdownPayload as bg, type ResolvedFarmConfig as bh, type RedirectConfig as bi, type HeaderConfig as bj, type RewriteConfig as bk, type ImageConfig as bl, type I18nConfig as bm, type MiddlewareConfig as bn, type FarmDeployConfig as bo, type ResolvedFarmDeployConfig as bp, type FarmDeployTarget as bq, type FarmIntegrationCategory as br, type FarmIntegrationSlot as bs, type FarmIntegrationRouteParamValue as bt, type FarmIntegrationRouteParams as bu, type FarmIntegrationRouteMethod as bv, type FarmIntegrationRouteInputSource as bw, type FarmIntegrationValidationPathSegment as bx, type FarmIntegrationRouteInput as by, type FarmIntegrationValidationIssue as bz, type FarmMigrationsUserConfig as c, type MemoryRateLimitStorageOptions as c$, type FarmIntegrationSchemaFieldType as c0, type FarmIntegrationSchemaReference as c1, type FarmIntegrationSchemaField as c2, type FarmIntegrationSchemaConstraint as c3, type FarmIntegrationSchemaModel as c4, type FarmIntegrationSchemaModelExtension as c5, type FarmIntegrationSchemaModelOverride as c6, type FarmIntegrationSchema as c7, defineIntegrationSchema as c8, type FarmIntegrationLogPhase as c9, matchIntegrationRoute as cA, matchRegisteredIntegrationRoute as cB, getRegisteredIntegrationAPIManifest as cC, dispatchIntegrationRequest as cD, type FarmIntegrationOrmSchema as cE, type FarmIntegrationOrmClient as cF, type InferFarmIntegrationOrmField as cG, type InferFarmIntegrationOrmFields as cH, type InferFarmIntegrationOrmSchema as cI, type InferFarmIntegrationOrmClient as cJ, type CreateIntegrationOrmOptions as cK, createIntegrationOrm as cL, resolveIntegrationOrmRuntimeClient as cM, farmIntegrationSchemaToOrmSchema as cN, type IntegrationOrmModelNames as cO, type MiddlewareContext as cP, type MiddlewareFunction as cQ, type RequestMiddleware as cR, type RequestMiddlewareContext as cS, type MiddlewareStore as cT, type MiddlewareChain as cU, type CookieJar as cV, type CookieOptions as cW, type RateLimitConfig as cX, type RateLimitIncrementResult as cY, type RateLimitStorage as cZ, type RateLimitStatus as c_, type FarmIntegrationLogEvent as ca, type FarmIntegrationLogger as cb, type FarmIntegrationPluginOwner as cc, type FarmIntegrationContributedPlugin as cd, type FarmIntegrationsUserConfig as ce, getFarmIntegrationPluginServerRuntime as cf, getFarmIntegrationPluginOwner as cg, type FarmIntegrationRouteFactory as ch, type FarmIntegrationRoutesFactoryContext as ci, type FarmIntegrationRoutesFactory as cj, type FarmIntegrationEndpointValue as ck, type FarmIntegrationEndpoints as cl, type FarmIntegrationEndpointsFactoryContext as cm, type FarmIntegrationEndpointsFactory as cn, createIntegrationRoute as co, integrationRoute as cp, type DefinedIntegration as cq, defineIntegration as cr, isFarmIntegration as cs, resolveIntegrationPlugins as ct, getIntegrationProviders as cu, getIntegrationDocumentNavigationMatchers as cv, getIntegrationSchemas as cw, getRegisteredIntegrationRuntime as cx, getRegisteredIntegrations as cy, getRegisteredIntegrationSchemas as cz, defineConfig as d, type NextFunction as d0, type MiddlewareResult as d1, type FarmRouteRuleRenderMode as d2, type FarmRouteRuleRedirect as d3, type FarmRouteRuleCors as d4, type FarmRouteRule as d5, type FarmRouteRules as d6, normalizeRouteRules as d7, routeRulesToRedirects as d8, routeRulesToHeaders as d9, routeRulesToNitroRouteRules as da, type FarmMdxComponent as db, type FarmMdxComponents as dc, type FarmMdxUserConfig as dd, type FarmMarkdownPageSource as de, type FarmMarkdownPageModuleInput as df, resolveMdxConfig as dg, isFarmMarkdownPageFile as dh, normalizeFarmMarkdownRoutePath as di, parseMarkdownFrontmatter as dj, titleFromMarkdown as dk, createMarkdownMetadata as dl, createFarmMarkdownRouteModule as dm, createFarmMarkdownRouteModuleFromFile as dn, loadFarmMdxComponents as dp, createFarmMarkdownSourceResponse as dq, DEFAULT_FARM_DEVTOOLS_SHORTCUT as dr, FARM_DEVTOOLS_PATH as ds, FARM_DEVTOOLS_LAUNCH_PARAM as dt, type FarmDevtoolsConfig as du, type FarmDevtoolsUserConfig as dv, resolveFarmDevtoolsConfig as dw, type MiddlewareConfig$1 as dx, farmI18nClientBridgePlugin as dy, rewriteEarlySsrRelativeImports as dz, type FarmContextFactoryInput as e, farmPlugin as f, type FarmContextFactory as g, type FarmAppContext as h, type PluginContextProps as i, type PageProps as j, type PagePropsWithMiddleware as k, type LayoutProps as l, type MetadataProps as m, type LayoutMetadataProps as n, type Page as o, type Layout as p, type Loading as q, type ErrorBoundary as r, type RouteModule as s, type StaticPathParams as t, type StaticRouteParams as u, type LayoutModule as v, type Metadata as w, type FarmRequest as x, type FarmResponse as y, type ServerAction as z };