@farm.js/core 0.1.47 → 0.1.49

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

@@ -0,0 +1,3922 @@
+import { n as FarmClientPlugin } from './lifecycle-DK06VuKP.mjs';
+import { b as PluginRoutes, c as PluginRoutesFactory, d as RouteMethod, F as FarmIntegrationAPI, f as FarmIntegrationAPIMethod, e as FarmIntegrationAPIBodyFormat, h as FarmIntegrationAPIResponseFormat, g as FarmIntegrationAPIOperation, i as FarmIntegrationRouteOperationCarrier, I as InferIntegrationAPIFromRoutes } from './route-2_yXC6gv.mjs';
+import { FarmRenderer } from './renderer.mjs';
+import { IncomingMessage, ServerResponse } from 'http';
+import { E as EndpointMCPMetadata, T as TypedEndpoint, R as RouteSchema, d as RouteSchemaOutput, e as RouteSchemaInput, Y as OpenAPISecurityMode } from './endpoint-BkMSCRf6.mjs';
+import { ServerFn } from './server-fn.mjs';
+import { ServerQuery } from './server-query.mjs';
+import { F as FarmStorageUserConfig } from './types-BnIqOn9w.mjs';
+import { FarmSchemaModel, FarmSchemaField, FarmSchema, FarmSchemaReference, FarmSchemaConfig, FarmSchemaConstraint, FarmSchemaFieldType, FarmSchemaModelExtension, FarmSchemaModelOverride, defineSchema } from './schema.mjs';
+import React__default, { ComponentType, ReactNode } from 'react';
+import { OrmClient, SchemaDefinition, ModelDefinition, FieldBuilder, JsonValue, AnyModelDefinition, SchemaModels } from '@farming-labs/orm';
+import { DocsConfig } from '@farming-labs/docs';
+import { p as FarmObservabilityUserConfig } from './observability-B2363jB6.mjs';
+import * as vite from 'vite';
+import { ViteDevServer, UserConfig } from 'vite';
+import { n as FarmWorkflowsUserConfig, f as FarmServerConfig, F as FarmWorkflowsResolvedConfig, R as ResolvedFarmServerConfig } from './workflows-Df1C_7OG.mjs';
+import { FarmCronUserConfig, FarmCronResolvedConfig } from './cron.mjs';
+import { ResolvedFarmEnv, FarmEnvConfig } from './env.mjs';
+import { FarmServerActionsConfig, ResolvedFarmServerActionsConfig } from './server-action-security.mjs';
+import { F as FarmLayerEntry, R as ResolvedFarmLayer } from './layers-D9fbe-rz.mjs';
+import { a as FarmImageConfig, R as ResolvedFarmImageConfig } from './image-config-CeDgNyX4.mjs';
+import { k as FarmI18nUserConfig, R as ResolvedFarmI18nConfig } from './types--Wh02r5_.mjs';
+import { FarmCacheUserConfig } from './cache.mjs';
+import { R as ResolvedFarmThemeConfig, d as FarmThemeConfig } from './types-DQnyD3VD.mjs';
+import { FarmLayoutFonts } from './font.mjs';
+
+/**
+ * Integration auth routes accept ordinary form posts, which browsers send
+ * cross-site without a CORS preflight. Without an origin check, a third-party
+ * page can submit credentials to an app's own sign-in route and plant an
+ * attacker-controlled session in the victim's browser (login CSRF), or drive a
+ * forced sign-out. This mirrors the server-action origin contract so both
+ * entry points reject the same requests.
+ */
+type IntegrationOriginRejection = "missing-origin" | "opaque-origin" | "invalid-origin" | "cross-site";
+type IntegrationOriginResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: IntegrationOriginRejection;
+};
+interface IntegrationOriginPolicy {
+    /** Extra trusted origins, using the `serverActions.allowedOrigins` pattern syntax. */
+    allowedOrigins?: readonly string[];
+    /**
+     * Whether a request carrying no origin metadata at all must be rejected.
+     *
+     * Form posts always carry an Origin header in supported browsers, so
+     * state-changing POSTs default to rejecting (`true`). Top-level GET
+     * navigations legitimately arrive with no Origin and no Referer — a typed
+     * URL or a bookmark — so GET callers pass `false` to avoid breaking them.
+     */
+    requireOriginMetadata?: boolean;
+}
+/**
+ * Resolve configured origin patterns once, at integration construction, so an
+ * invalid pattern fails loudly at startup instead of per request.
+ */
+declare function resolveIntegrationAllowedOrigins(values: readonly string[] | undefined, label: string): readonly string[];
+declare function validateIntegrationRequestOrigin(request: Request, policy?: IntegrationOriginPolicy): IntegrationOriginResult;
+declare function describeIntegrationOriginRejection(reason: IntegrationOriginRejection): string;
+
+/**
+ * `experimental.serverComponents`: which engine renders server components.
+ *
+ * - `"rsc"`: React's Flight pipeline (`@farm.js/plugin/rsc` on `@vitejs/plugin-rsc`).
+ * - `"islands"`: Farm's own engine (RFC 0003), on Farm's pipeline. Experimental.
+ *
+ * `true` means `{ mode: "rsc" }`. Both modes share one authoring contract.
+ */
+type FarmServerComponentsMode = "rsc" | "islands";
+interface FarmServerComponentsOptions {
+    mode: FarmServerComponentsMode;
+}
+type FarmServerComponentsConfig = boolean | FarmServerComponentsOptions;
+
+/**
+ * `agent.manifest`: which sections `/.well-known/farmjs.json` shows. Every section is shown by
+ * default; a section set to `false` is served as `null` (hidden by the app), unlike an empty
+ * list, which means there is nothing to show.
+ */
+/** Per-section options for `/.well-known/farmjs.json`. Every section is shown by default. */
+interface FarmAppManifestConfig {
+    /**
+     * The `app` section. `false` serves `app: null`; an object leaves out the Farm version
+     * (`version`), the `renderer` or the `build` ID. `basePath` is always kept.
+     *
+     * @default true
+     */
+    app?: boolean | {
+        version?: boolean;
+        renderer?: boolean;
+        build?: boolean;
+    };
+    /**
+     * Installed `@farm.js/*` and `@farming-labs/*` packages. `"names"` lists them with `null`
+     * versions; `false` serves `packages: null`.
+     *
+     * @default true
+     */
+    packages?: boolean | "names";
+    /**
+     * MCP servers and their tools. `schemas: false` drops tools' `inputSchema` and
+     * `outputSchema`; `hide` leaves out a server (`"store"`) or one of its tools
+     * (`"store/list_orders"`). `false` serves `mcp: null`.
+     *
+     * @default true
+     */
+    mcp?: boolean | {
+        schemas?: boolean;
+        hide?: string[];
+    };
+    /**
+     * WebMCP browser tools. `hide` leaves out tools by name; `false` serves `webmcp: null`.
+     *
+     * @default true
+     */
+    webmcp?: boolean | {
+        hide?: string[];
+    };
+    /** Integration keys, categories and providers. `false` serves `integrations: null`. */
+    integrations?: boolean;
+    /** The app's agent surfaces (API catalog, llms.txt, OpenAPI). `false` serves `agent: null`. */
+    agent?: boolean;
+    /** Plugin names. `false` serves `plugins: null`. */
+    plugins?: boolean;
+}
+interface ResolvedFarmAppManifestConfig {
+    app: false | {
+        version: boolean;
+        renderer: boolean;
+        build: boolean;
+    };
+    packages: boolean | "names";
+    mcp: false | {
+        schemas: boolean;
+        hide: string[];
+    };
+    webmcp: false | {
+        hide: string[];
+    };
+    integrations: boolean;
+    agent: boolean;
+    plugins: boolean;
+}
+
+declare const DEFAULT_FARM_DEVTOOLS_SHORTCUT = "mod+shift+.";
+declare const FARM_DEVTOOLS_PATH = "/__farm/devtools";
+declare const FARM_DEVTOOLS_LAUNCH_PARAM = "__farm_devtools";
+/**
+ * Configuration for the built-in DevTools dashboard. The dashboard is deprecated in favor
+ * of the `@farm.js/devtools` plugin, which reuses this configuration for enablement and
+ * the keyboard shortcut. Both options keep working while the built-in UI remains available.
+ */
+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;
+
+type ResolvedSchemaField = FarmSchemaField & {
+    name: string;
+};
+type ResolvedSchemaModel = Omit<FarmSchemaModel, "fields"> & {
+    name: string;
+    fields: Record<string, ResolvedSchemaField>;
+};
+/**
+ * Resolve a schema's extensions, overrides, and name mappings.
+ *
+ * Table and column names fall back to the schema's own keys, which is what the
+ * runtime ORM uses. Any other default would generate artifacts describing
+ * tables the app cannot actually read.
+ */
+declare function resolveSchemaModels(ownerKey: string, schema: FarmSchema): Record<string, ResolvedSchemaModel>;
+
+type FarmSqlDialect = "postgres" | "mysql" | "sqlite";
+type CollectedSchemaModel = {
+    /** Namespace that owns the model: an integration key or a plugin name. */
+    ownerKey: string;
+    modelKey: string;
+    modelName: string;
+    exportName: string;
+    prismaModelName: string;
+    model: ResolvedSchemaModel;
+    /**
+     * Real table and column for references to models this owner describes but
+     * does not create (external, or outside its `models`), keyed by field. Only
+     * shown in comments: Farm never creates a foreign key to them.
+     */
+    referenceTargets?: Record<string, {
+        table: string;
+        column: string;
+    }>;
+    /**
+     * References to tables other owners create that may carry a real foreign
+     * key, keyed by field. Set by migrate after checking the database; only a
+     * table created now gets one inline.
+     */
+    foreignKeys?: Record<string, {
+        table: string;
+        column: string;
+        onDelete: NonNullable<FarmSchemaReference["onDelete"]>;
+    }>;
+};
+/** `table.column` a field's reference points at, using real names when known. */
+declare function describeSchemaReference(model: CollectedSchemaModel, fieldKey: string): string;
+/**
+ * Flatten owners' schemas into one list, rejecting two models that would
+ * resolve to the same table.
+ *
+ * `only` narrows an owner to the models it actually controls; an owner handed a
+ * schema it shares with the rest of the app should not claim all of it.
+ */
+declare function collectSchemaModels(entries: ReadonlyArray<readonly [string, FarmSchema, (readonly string[])?]>): CollectedSchemaModel[];
+type FarmSqlStatement = {
+    kind: "table" | "index" | "column";
+    /** The object this statement creates, for drift reporting. */
+    target: string;
+    sql: string;
+};
+/**
+ * Emit create statements for a set of models.
+ *
+ * Everything here is derivable from the schema: nothing is inferred from a live
+ * database, so the output is stable and reviewable before it is applied.
+ */
+declare function generateSqlStatements(models: readonly CollectedSchemaModel[], dialect: FarmSqlDialect): FarmSqlStatement[];
+/** Render models as a standalone `.sql` file. */
+declare function renderSqlSchemaFile(models: readonly CollectedSchemaModel[], dialect: FarmSqlDialect): string;
+declare function getSqlColumnType(field: ResolvedSchemaField, dialect: FarmSqlDialect): "BOOLEAN" | "INTEGER" | "DOUBLE PRECISION" | "TIMESTAMPTZ" | "JSONB" | "TEXT" | "INT" | "DOUBLE" | "DATETIME" | "JSON" | "VARCHAR(255)" | "REAL";
+declare function getSqlDefaultExpression(field: ResolvedSchemaField, dialect: FarmSqlDialect): string | null;
+declare function isNullableField(field: ResolvedSchemaField): boolean;
+declare function quoteSqlIdentifier(dialect: FarmSqlDialect, value: string): string;
+declare function toSnakeCase(value: string): string;
+declare function toPascalCase(value: string): string;
+declare function toCamelCase(value: string): string;
+declare function escapeSqlString(value: string, dialect?: FarmSqlDialect): string;
+
+/**
+ * An ordered change a plugin release makes to its own tables that Farm will
+ * not infer: a rename looks exactly like a removal plus an addition. Each step
+ * runs once per database, in the order listed.
+ *
+ * Names are the plugin's own: `model` and `to` are keys in the current
+ * schema, so the app's renames apply; `from` is the old name in the database.
+ */
+type FarmSchemaMigrationStep = {
+    id: string;
+    description?: string;
+} & ({
+    renameColumn: {
+        model: string;
+        from: string;
+        to: string;
+    };
+} | {
+    renameTable: {
+        from: string;
+        to: string;
+    };
+}
+/**
+ * Deletes data, so it runs only with `--allow-destructive`, and only on a
+ * column or table Farm recorded this plugin creating.
+ */
+ | {
+    dropColumn: {
+        model: string;
+        column: string;
+    };
+} | {
+    dropTable: {
+        table: string;
+    };
+} | {
+    /** Per dialect; a dialect without SQL cannot run the step. */
+    sql: Partial<Record<FarmSqlDialect, string | readonly string[]>>;
+    /**
+     * Custom SQL runs after this release's new tables and columns exist, so
+     * a backfill can fill them. Set `before` to run it with the renames.
+     */
+    before?: boolean;
+});
+
+/**
+ * Typed, validated plugin options.
+ *
+ * A plugin factory takes one options object. Describing it with a Standard
+ * Schema (Zod, Valibot, ArkType, ...) gives the call site its input type for
+ * autocomplete, gives the plugin the parsed type with defaults applied, and
+ * rejects bad options while the config loads instead of deep inside a hook.
+ */
+type MaybePromise$2<T> = T | Promise<T>;
+type FarmPluginOptionsIssuePathSegment = PropertyKey | {
+    readonly key: PropertyKey;
+};
+interface FarmPluginOptionsIssue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<FarmPluginOptionsIssuePathSegment> | undefined;
+}
+type FarmPluginOptionsResult<TOutput> = {
+    readonly value: TOutput;
+    readonly issues?: undefined;
+} | {
+    readonly issues: ReadonlyArray<FarmPluginOptionsIssue>;
+};
+/** The part of the Standard Schema interface plugin options need. */
+interface FarmPluginOptionsSchema<TInput = unknown, TOutput = TInput> {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => MaybePromise$2<FarmPluginOptionsResult<TOutput>>;
+        readonly types?: {
+            readonly input: TInput;
+            readonly output: TOutput;
+        } | undefined;
+    };
+}
+/** What the app passes to the plugin factory. */
+type InferPluginOptionsInput<TSchema> = TSchema extends FarmPluginOptionsSchema<infer TInput, any> ? TInput : never;
+/** What the plugin receives, after parsing and defaults. */
+type InferPluginOptionsOutput<TSchema> = TSchema extends FarmPluginOptionsSchema<any, infer TOutput> ? TOutput : never;
+/**
+ * The factory a plugin exports. Options can be left out when every option is
+ * optional, so `plugin()` and `plugin({})` mean the same thing.
+ */
+type FarmPluginFactory<TInput, TPlugin> = {} extends TInput ? (options?: TInput) => TPlugin : (options: TInput) => TPlugin;
+/** Thrown when an app passes options its plugin's schema rejects. */
+declare class FarmPluginOptionsError extends TypeError {
+    readonly issues: ReadonlyArray<FarmPluginOptionsIssue>;
+    constructor(issues: ReadonlyArray<FarmPluginOptionsIssue>);
+}
+
+type MaybePromise$1<T> = T | Promise<T>;
+/** @internal Marks a Node response whose intercepted end is awaiting response hooks. */
+declare const FARM_NODE_RESPONSE_END_PENDING: unique symbol;
+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" | "endpoint" | "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 FarmPluginRuntimeEndpointEvent<TState = unknown, TIntegrationInstance = unknown> extends FarmPluginRuntimeBaseEvent<TState, TIntegrationInstance> {
+    /** Normalized application-relative path registered by the endpoint. */
+    path: string;
+}
+interface FarmPluginRuntimeEndpoint<TState = unknown, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
+    /** Exact application-relative pathname, before Farm's configured basePath. */
+    path: string;
+    handler(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeEndpointEvent<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<Response>;
+}
+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> {
+    /** Exact request endpoints owned by this plugin. */
+    endpoints?: readonly FarmPluginRuntimeEndpoint<TState, TIntegrationInstance, TIntegrationBound>[];
+    /**
+     * Whether a response `before` lets through may be stored by a shared cache (a CDN). `before`
+     * runs for every request and may be a guard, so by default (`"private"`) Farm sends those
+     * responses with `Cache-Control: private, no-store`. Set `"public"` when `before` never
+     * decides who may read a response, as for logging or analytics.
+     */
+    cache?: "private" | "public";
+    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, TRoutes extends PluginRoutes = PluginRoutes> {
+    name: string;
+    version?: string;
+    enforce?: "pre" | "post";
+    /** Declarative API routes, mounted through the normal dev and production API pipeline. */
+    routes?: PluginRoutesFactory<TRoutes>;
+    /** Transform Farm config before the development or production pipeline is created. */
+    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>;
+    /**
+     * Tables this plugin stores data in. Farm creates them with
+     * `farm <name> migrate` (the part of the plugin name after its last `:` or
+     * `/`), includes them in `farm generate` and `farm schema check`, and
+     * reaches them through the app's `storage.client`. Mark tables the plugin
+     * only reads, such as the app's `user`, with `external: true`.
+     */
+    schema?: FarmSchema;
+    /** Where the `schema` tables live, when not in the app's `storage.client`. */
+    database?: FarmPluginDatabase;
+    /**
+     * Plugins this one needs, by name (`farm:teams` or `teams`) or integration
+     * key. The config fails to load when one is missing or they form a cycle,
+     * and migrations run dependencies first.
+     */
+    dependsOn?: readonly string[];
+    /**
+     * Ordered steps for what a release changes in its tables that Farm will not
+     * infer, such as a renamed column. Each runs once per database, through
+     * `farm <name> migrate`. Additions need no step.
+     */
+    migrations?: readonly FarmSchemaMigrationStep[];
+    /** @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 runtimeEndpoints?;
+    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 getRuntimeEndpoints;
+    private runRuntimeEndpoint;
+    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>;
+    private runBeforeHooks;
+    /**
+     * Runs only `runtime.before` for a request Farm re-routed internally, such as
+     * a configured rewrite, so guards also see the destination URL. The session
+     * opened for `source` keeps its context; context and after hooks don't rerun.
+     */
+    runRuntimeBeforeForRewrite(source: Request, request: Request, options?: FarmPluginRuntimeRequestOptions): Promise<Request | Response>;
+    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;
+}
+type PluginOptionsSchemaInput = FarmPluginOptionsSchema<any, any>;
+/** Parsed options, available to `setup` and `configure` when a plugin declares `options`. */
+type WithPluginOptions<TContext, TSchema> = TSchema extends PluginOptionsSchemaInput ? TContext & {
+    readonly options: InferPluginOptionsOutput<TSchema>;
+} : TContext;
+/**
+ * A plugin's state. When it declares `options` and `setup` returns nothing (or
+ * there is no `setup`), the parsed options are its state.
+ */
+type ResolvedPluginState<TState, TSchema> = TSchema extends PluginOptionsSchemaInput ? [TState] extends [undefined | void] ? InferPluginOptionsOutput<TSchema> : TState : TState;
+/** What `definePlugin` accepts: a plugin, optionally with an `options` schema. */
+type FarmPluginDefinition<TState = undefined, TRequestContext extends object = Record<string, never>, TClientState = unknown, TClientPublic = undefined, TIntegrationInstance = unknown, TRoutes extends PluginRoutes = PluginRoutes, TSchema extends PluginOptionsSchemaInput | undefined = undefined> = Omit<FarmPlugin<ResolvedPluginState<TState, TSchema>, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, false, TRoutes>, "configure" | "setup"> & {
+    /**
+     * Describe the plugin's options with a Standard Schema (Zod, Valibot,
+     * ArkType, ...). `definePlugin` then returns a factory: the app passes typed
+     * options, invalid ones fail while the config loads, and the plugin receives
+     * the parsed result in `setup` and `configure`, and as its state.
+     */
+    options?: TSchema;
+    /** Transform Farm config before the development or production pipeline is created. */
+    configure?: (config: FarmConfig, context: WithPluginOptions<FarmPluginContextFor<TIntegrationInstance, false>, TSchema>) => MaybePromise$1<FarmConfig | void>;
+    /** Initialize private plugin state once for this plugin manager. */
+    setup?: (context: WithPluginOptions<FarmPluginSetupContextFor<TIntegrationInstance, false>, TSchema>) => MaybePromise$1<TState>;
+};
+type DefinedPlugin<TState, TRequestContext extends object, TClientState, TClientPublic, TIntegrationInstance, TRoutes extends PluginRoutes, TSchema> = FarmPlugin<ResolvedPluginState<TState, TSchema>, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, false, TRoutes>;
+/** The database a plugin's `schema` tables live in, when not `storage.client`. */
+interface FarmPluginDatabase {
+    /**
+     * A pg, mysql2, or sqlite connection the app chose for this plugin, or a
+     * function returning one. Left undefined, the app's `storage.client` is used,
+     * so a plugin can forward an optional app setting as is.
+     */
+    client?: unknown;
+    /** Only when the dialect cannot be detected from the connection. */
+    dialect?: FarmSqlDialect;
+}
+/**
+ * Define a plugin. Declaring `options` turns the result into a factory:
+ *
+ * ```ts
+ * export const security = definePlugin({
+ *   name: "acme:security",
+ *   options: z.object({ frameAncestors: z.string().default("'none'") }),
+ *   runtime: {
+ *     after({ state, response }) {
+ *       // state.frameAncestors: string
+ *       return response;
+ *     },
+ *   },
+ * });
+ *
+ * // farm.config.ts
+ * plugins: [security({ frameAncestors: "'self'" })]
+ * ```
+ */
+declare function definePlugin<TState = undefined, TRequestContext extends object = Record<string, never>, TClientState = unknown, TClientPublic = undefined, TIntegrationInstance = unknown, const TRoutes extends PluginRoutes = PluginRoutes, TSchema extends PluginOptionsSchemaInput | undefined = undefined>(plugin: FarmPluginDefinition<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, TRoutes, TSchema>): TSchema extends PluginOptionsSchemaInput ? FarmPluginFactory<InferPluginOptionsInput<TSchema>, DefinedPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, TRoutes, TSchema>> : DefinedPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, TRoutes, TSchema>;
+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>;
+}
+
+/** A server-only endpoint reference. Config references must declare an explicit /api path. */
+type FarmMCPEndpoint = TypedEndpoint<any, any, any, any, any, any, any, any>;
+interface FarmMCPExecuteContext {
+    /** The principal returned by authorize, or { subject: "anonymous" } for public servers. */
+    readonly authorization: Readonly<FarmMCPAuthorization>;
+    readonly request: Request;
+    /** Observe this signal in cancellable work. Cancellation cannot undo side effects. */
+    readonly signal: AbortSignal;
+}
+/** A server-only tool with no corresponding HTTP endpoint. */
+interface FarmMCPStandaloneTool<Schema extends RouteSchema = RouteSchema, Result = unknown, OutputSchema extends RouteSchema | undefined = undefined> extends EndpointMCPMetadata {
+    name: string;
+    /** Must describe an object and support input JSON Schema conversion. */
+    inputSchema: Schema;
+    /** Validate/transform returned data and advertise its output shape inside MCP's result envelope. */
+    outputSchema?: OutputSchema;
+    /** Return JSON-serializable data, not a Response or an MCP protocol envelope. */
+    execute(input: RouteSchemaOutput<Schema>, context: FarmMCPExecuteContext): OutputSchema extends RouteSchema ? NoInfer<RouteSchemaInput<OutputSchema>> | Promise<NoInfer<RouteSchemaInput<OutputSchema>>> : Result | Promise<Result>;
+    endpoint?: never;
+}
+/**
+ * A createServerFn or createServerQuery function with `mcp` metadata. It runs through its own
+ * input schema, middleware and output schema, with the MCP request as its request.
+ */
+type FarmMCPServerFunction = ServerFn<any, any, any> | ServerQuery<any, any>;
+/** Compose endpoint references, server functions and standalone tools. */
+type FarmMCPToolDefinition = FarmMCPEndpoint | FarmMCPServerFunction | (EndpointMCPMetadata & {
+    endpoint: FarmMCPEndpoint;
+    execute?: never;
+}) | FarmMCPStandaloneTool<any, unknown, any>;
+/** Resolved tool identity, without handlers, validators, or a way to bypass authorization. */
+type FarmMCPTool = Readonly<EndpointMCPMetadata> & {
+    readonly name: string;
+} & ({
+    readonly kind: "endpoint";
+    readonly method: RouteMethod;
+    readonly path: string;
+} | {
+    readonly kind: "standalone";
+    readonly method?: never;
+    readonly path?: never;
+} | {
+    readonly kind: "serverFunction";
+    readonly method?: never;
+    readonly path?: never;
+});
+/** What a resource's `read` receives: the URI asked for, its template variables, and the caller. */
+interface FarmMCPResourceContext extends FarmMCPExecuteContext {
+    readonly uri: URL;
+    /** Values matched by `uriTemplate`; empty for a fixed `uri`. */
+    readonly variables: Readonly<Record<string, string | string[]>>;
+}
+/**
+ * One piece of resource content: a string (sent as `mimeType`, or text/plain),
+ * text with its own type, JSON data, or binary data.
+ */
+type FarmMCPResourceContent = string | {
+    text: string;
+    mimeType?: string;
+} | {
+    json: unknown;
+} | {
+    blob: Uint8Array | ArrayBuffer;
+    mimeType?: string;
+};
+/** One concrete URI a templated resource lists. */
+interface FarmMCPResourceListing {
+    uri: string;
+    name?: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+}
+/**
+ * A server-only MCP resource: read-only context an agent can load, at a fixed
+ * `uri` or at every URI matching an RFC 6570 `uriTemplate`.
+ */
+interface FarmMCPResource {
+    /** Stable name, used in authorization and in `authorize`'s `resources` allowlist. */
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    /** A fixed absolute URI, such as `docs://handbook`. Set this or `uriTemplate`. */
+    uri?: string;
+    /** An RFC 6570 template, such as `notes://{id}`. Set this or `uri`. */
+    uriTemplate?: string;
+    /** For a template: the concrete resources to list. Omit to list none. */
+    list?(context: FarmMCPExecuteContext): readonly FarmMCPResourceListing[] | Promise<readonly FarmMCPResourceListing[]>;
+    /** Return the content, or null when the URI names nothing. */
+    read(context: FarmMCPResourceContext): FarmMCPResourceContent | readonly FarmMCPResourceContent[] | null | Promise<FarmMCPResourceContent | readonly FarmMCPResourceContent[] | null>;
+}
+interface FarmMCPPromptMessage {
+    role: "user" | "assistant";
+    text: string;
+}
+/**
+ * A server-only MCP prompt: a reusable message template a client offers its
+ * user. Arguments arrive as strings, as MCP sends them, and are validated by
+ * `arguments` before `render` runs.
+ */
+interface FarmMCPPrompt<Schema extends RouteSchema | undefined = RouteSchema | undefined> {
+    /** Stable name: 1-128 letters, numbers, dots, underscores, or hyphens. */
+    name: string;
+    title?: string;
+    description?: string;
+    /** An object schema of string arguments. */
+    arguments?: Schema;
+    /** Return the prompt text, sent as one user message, or a list of messages. */
+    render(args: Schema extends RouteSchema ? RouteSchemaOutput<Schema> : Record<string, never>, context: FarmMCPExecuteContext): string | readonly FarmMCPPromptMessage[] | Promise<string | readonly FarmMCPPromptMessage[]>;
+}
+interface FarmMCPServer {
+    readonly name: string;
+    readonly version: string;
+    readonly path: `/api/${string}`;
+    readonly title?: string;
+    readonly description?: string;
+}
+interface FarmMCPAuthorization extends Record<string, unknown> {
+    /** Stable application principal identifier. Never written to a response or log by Farm. */
+    subject: string;
+    scopes?: string[];
+    /** Allowed tool names for this request. Omit for all configured tools; [] denies all tools. */
+    tools?: readonly string[];
+    /** Allowed resource names. Omit for all configured resources; [] denies all resources. */
+    resources?: readonly string[];
+    /** Allowed prompt names. Omit for all configured prompts; [] denies all prompts. */
+    prompts?: readonly string[];
+}
+interface FarmMCPAuthorizeContext {
+    request: Request;
+    /** Untrusted requested name for a tools/call; authorization runs separately for every JSON-RPC batch item. */
+    tool?: string;
+    /** Untrusted requested URI for a resources/read. */
+    resource?: string;
+    /** Untrusted requested name for a prompts/get. */
+    prompt?: string;
+    /** Complete configured catalog, before applying this caller's permissions. */
+    tools: readonly FarmMCPTool[];
+    /** Resolved transport identity, for policies shared by multiple MCP endpoints. */
+    server: FarmMCPServer;
+}
+interface FarmMCPConfig {
+    /** Set false to disable MCP without removing its configuration. @default true */
+    enabled?: boolean;
+    /** Canonical Farm API path for the Streamable HTTP endpoint. @default "/api/mcp" */
+    path?: `/api/${string}`;
+    /** MCP server identity. @default "farm-api" */
+    name?: string;
+    /** MCP server version. @default "1.0.0" */
+    version?: string;
+    /** Display name, sent in `serverInfo` and the server card. */
+    title?: string;
+    /**
+     * What the server does, sent in `serverInfo` and the server card that
+     * `/.well-known/ai-catalog.json` lists. The card keeps the first 100 characters.
+     */
+    description?: string;
+    /** Explicit endpoint/standalone tool allowlist. Omit to discover route-owned MCP metadata. */
+    tools?: readonly FarmMCPToolDefinition[];
+    /** Read-only context for agents, from `defineResource()`. */
+    resources?: readonly FarmMCPResource[];
+    /** Reusable prompt templates, from `definePrompt()`. */
+    prompts?: readonly FarmMCPPrompt<any>[];
+    /** Authorize every MCP request. Returning false responds with 401 before protocol handling. */
+    authorize?: (context: FarmMCPAuthorizeContext) => FarmMCPAuthorization | false | Promise<FarmMCPAuthorization | false>;
+    /** Deliberate escape hatch for public servers. Authentication is required by default. */
+    allowUnauthenticated?: boolean;
+    /**
+     * Most JSON-RPC messages one batched POST may carry. `authorize` runs once per message, so a
+     * larger batch is refused before any of them is authorized. @default 25
+     */
+    maxBatchSize?: number;
+    /**
+     * Most array elements and object members, counted together across nested values, one tool
+     * call's arguments may contain. Larger arguments are refused before validation or the tool
+     * runs. `Infinity` removes the limit. @default 10000
+     */
+    maxToolInputElements?: number;
+    /**
+     * OAuth discovery for MCP clients. When set, a rejected request's 401 points at
+     * RFC 9728 Protected Resource Metadata naming these authorization servers, which
+     * Farm serves at `/.well-known/oauth-protected-resource/<endpoint path>`.
+     * Validating tokens stays in `authorize`.
+     */
+    oauth?: FarmMCPOAuthConfig;
+}
+interface FarmMCPOAuthConfig {
+    /** Issuer URLs of the OAuth authorization servers that issue tokens for this endpoint. */
+    authorizationServers: readonly string[];
+    /** Scopes clients may request, advertised as `scopes_supported` and in the 401 challenge. */
+    scopes?: readonly string[];
+    /** Human-readable name for consent screens. @default the MCP server name */
+    resourceName?: string;
+}
+type FarmMCPUserConfig = FarmMCPConfig | false;
+interface ResolvedFarmMCPConfig extends FarmMCPConfig {
+    enabled: boolean;
+}
+declare function resolveFarmMCPConfig(input: FarmMCPUserConfig | undefined): ResolvedFarmMCPConfig;
+declare function resolveFarmMCPPlugin(config: ResolvedFarmMCPConfig, options: {
+    root: string;
+}): Promise<FarmPlugin | undefined>;
+
+type JSONSchema = Readonly<Record<string, unknown>>;
+/** What a server can say beyond its tool list, for the app manifest. All optional. */
+interface FarmMCPCatalogDetails {
+    /**
+     * True when the endpoint answers anonymous clients: it has no `authorize`. The public
+     * `/.well-known/farmjs.json` lists tools, resources and prompts only for such a server.
+     */
+    public?: boolean;
+    /** MCP protocol versions the endpoint accepts, for its server card. */
+    protocolVersions?: readonly string[];
+    /** Each tool's input and output JSON Schemas, by tool name. */
+    schemas?: Readonly<Record<string, {
+        input: JSONSchema;
+        output?: JSONSchema;
+    }>>;
+    resources?: readonly {
+        name: string;
+        title?: string;
+        description?: string;
+        mimeType?: string;
+        uri?: string;
+        uriTemplate?: string;
+    }[];
+    prompts?: readonly {
+        name: string;
+        title?: string;
+        description?: string;
+        /** The arguments' JSON Schema. */
+        arguments?: JSONSchema;
+    }[];
+}
+/**
+ * @internal Publishes one MCP server's tools, replacing an earlier catalog for
+ * the same endpoint. Returns a function that removes it.
+ */
+declare function _publishFarmMCPCatalog(server: FarmMCPServer, tools: readonly FarmMCPTool[], details?: FarmMCPCatalogDetails): () => void;
+interface FarmMCPServerRegistrationBase {
+    /** Server name; a reverse-DNS name (`dev.farmjs/docs`) is kept as the card's name. */
+    name: string;
+    version: string;
+    /** Display name for the card and the catalog entry. */
+    title?: string;
+    /** What the server does. The card keeps the first 100 characters. */
+    description?: string;
+    /** MCP protocol versions the endpoint accepts, for its server card. */
+    protocolVersions?: readonly string[];
+}
+/**
+ * An MCP server that Farm lists in `/.well-known/ai-catalog.json`, `/.well-known/ard.json`,
+ * and the generated `/llms.txt`, but does not serve: a docs runtime's endpoint, an agent
+ * runtime, or a server on another host. It is not part of the `/.well-known/farmjs.json`
+ * manifest, which lists the tools Farm itself serves.
+ */
+type FarmMCPServerRegistration = FarmMCPServerRegistrationBase & ({
+    /**
+     * The Streamable HTTP endpoint's path in this app, below the app's `basePath`.
+     * Taken literally: it is not rewritten through `api.basePath`. Farm serves the
+     * server card at `<path>/server-card`.
+     */
+    path: `/${string}`;
+    url?: never;
+} | {
+    /**
+     * An absolute `http(s)` URL of an endpoint on another origin, which serves its
+     * own card at `<url>/server-card`.
+     */
+    url: string;
+    path?: never;
+});
+/**
+ * List an MCP server Farm does not serve itself in the app's AI catalog. Registering
+ * the same endpoint again replaces the earlier entry. Returns a function that removes it.
+ *
+ * ```ts
+ * const unregister = registerFarmMCPServer({
+ *   name: "dev.farmjs/agent",
+ *   version: "1.0.0",
+ *   path: "/agent/mcp",
+ * });
+ * ```
+ */
+declare function registerFarmMCPServer(server: FarmMCPServerRegistration): () => void;
+interface FarmMCPEndpointTool {
+    /** The MCP tool name. */
+    name: string;
+    /** The public path of the MCP endpoint that serves the tool. */
+    endpoint: string;
+}
+/**
+ * @internal Finds the MCP tool that runs the API endpoint a request to
+ * `method pathname` reaches, if a published catalog exposes one.
+ * `serverBasePath` is the app's public API path, which maps to `/api`.
+ */
+declare function _findFarmMCPEndpointTool(method: string, pathname: string, serverBasePath?: string): FarmMCPEndpointTool | undefined;
+
+/** Content type for Markdown responses, including agent-facing error bodies. */
+declare const FARM_MARKDOWN_CONTENT_TYPE = "text/markdown; charset=utf-8";
+/**
+ * @internal Header on the anonymous page render that decides whether a page's Markdown
+ * source is public. Its value is a per-process secret, so a client cannot set it: the
+ * render it selects is buffered to the end, where a late `redirect()` or `notFound()`
+ * still sets the status instead of a script in an already-sent 200 document.
+ */
+declare const FARM_MARKDOWN_PAGE_CHECK_HEADER = "x-farm-markdown-page-check";
+/** @internal The value of {@link FARM_MARKDOWN_PAGE_CHECK_HEADER} for this process. */
+declare function _getFarmMarkdownPageCheckToken(): string;
+/** @internal Whether a request is Farm's own anonymous page check. */
+declare function _isFarmMarkdownPageCheck(value: string | readonly string[] | null | undefined): boolean;
+declare function farmRequestWantsMarkdown(pathname: string, accept: string | null | undefined): boolean;
+declare function createFarmMarkdownErrorBody(status: number, pathname: string, homeHref?: string): string;
+type FarmMarkdownRouteInput = string | {
+    route: string;
+    title?: string;
+    cache?: number | false;
+};
+interface FarmMarkdownUserConfig {
+    /**
+     * Enable generated markdown representations for React pages.
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Routes that may expose generated markdown. Every page is exposed by default.
+     */
+    expose?: boolean | FarmMarkdownRouteInput[];
+    /** @deprecated Use `expose`. */
+    routes?: FarmMarkdownRouteInput[];
+    cache?: number | false;
+    includeMetadata?: boolean;
+}
+interface FarmMarkdownResolvedRoute {
+    route: string;
+    title?: string;
+    cache?: number | false;
+}
+interface FarmMarkdownResolvedConfig {
+    enabled: boolean;
+    expose: true | FarmMarkdownResolvedRoute[];
+    cache: number | false;
+    includeMetadata: boolean;
+}
+interface FarmMarkdownMirrorTarget {
+    pathname: string;
+    route: FarmMarkdownResolvedRoute | null;
+}
+interface ResolveMarkdownMirrorTargetOptions {
+    accept?: string | null;
+}
+interface CreateMarkdownMirrorResponseOptions {
+    request: Request;
+    /** @internal Reuse a parse only while its href still matches this request. */
+    requestUrl?: URL;
+    config?: FarmMarkdownResolvedConfig;
+    routeExists?: (pathname: string) => boolean;
+    renderPage: (request: Request) => Response | Promise<Response>;
+    /** The app's public API path, so a form posting to an API route can be matched to its MCP tool. */
+    apiServerBasePath?: string;
+}
+interface ApplyMarkdownNegotiationHeadersOptions {
+    config?: FarmMarkdownResolvedConfig;
+    pathname: string;
+}
+declare function resolveMarkdownConfig(config: FarmMarkdownUserConfig | boolean | undefined): FarmMarkdownResolvedConfig;
+declare function resolveMarkdownMirrorTarget(config: FarmMarkdownResolvedConfig | undefined, pathname: string, options?: ResolveMarkdownMirrorTargetOptions): FarmMarkdownMirrorTarget | null;
+declare function createMarkdownMirrorResponse(options: CreateMarkdownMirrorResponseOptions): Promise<Response | null>;
+declare function applyMarkdownNegotiationHeaders(response: Response, options: ApplyMarkdownNegotiationHeadersOptions): Response;
+declare function htmlToMarkdown(html: string, options?: {
+    title?: string;
+    sourcePath?: string;
+    includeMetadata?: boolean;
+    /** Where the page's forms are described, listed when the page has any. */
+    actionsPath?: string;
+}): string;
+/**
+ * Quality value an `Accept` header assigns a media type, or 0 when the client
+ * will not take it.
+ *
+ * `q=0` means "not acceptable" per RFC 9110, so it has to be distinguished from
+ * an absent entry rather than treated as a match. Wildcards are opt-in: a client
+ * sending `*&#47;*` will take anything, which says nothing about whether it would
+ * rather have Markdown than HTML, so callers negotiating between two concrete
+ * types should ask for exact entries only.
+ */
+declare function farmAcceptQuality(accept: string | null | undefined, mediaType: string, options?: {
+    wildcards?: boolean;
+}): number;
+declare function requestAcceptsMarkdown(accept: string | null | undefined): boolean;
+/** @internal The `.md` URL that serves a page's Markdown mirror. */
+declare function getFarmMarkdownMirrorPath(pathname: string): string;
+/**
+ * @internal The `.md` URL to advertise for the HTML page at `pathname`, or
+ * null when it has no Markdown mirror. Both the `Link` response header and the
+ * `<link rel="alternate">` in the document head come from this.
+ */
+declare function getFarmMarkdownAlternatePath(config: FarmMarkdownResolvedConfig | undefined, pathname: string): string | null;
+/** @internal Whether `pathname` has a Markdown mirror under `config`. */
+declare function isFarmMarkdownMirrorExposed(config: FarmMarkdownResolvedConfig | undefined, pathname: string): boolean;
+/** @internal Matches a page pathname against a route pattern such as `/docs/[...slug]`. */
+declare function matchesFarmMarkdownRoutePattern(pattern: string, pathname: string): boolean;
+interface FarmPageFormOption {
+    value: string;
+    label?: string;
+    selected?: true;
+}
+interface FarmPageFormField {
+    name: string;
+    /** The input type, or `select`, `textarea`, `radio`, or `checkbox` for a group. */
+    type: string;
+    label?: string;
+    required?: true;
+    multiple?: true;
+    /** A preset value: always present for hidden fields. */
+    value?: string;
+    checked?: true;
+    /** Choices of a select, or of radio buttons and checkboxes sharing a name. */
+    options?: FarmPageFormOption[];
+    placeholder?: string;
+    pattern?: string;
+    min?: string;
+    max?: string;
+    step?: string;
+    minLength?: number;
+    maxLength?: number;
+    accept?: string;
+}
+interface FarmPageFormSubmit {
+    label: string;
+    name?: string;
+    value?: string;
+    /** Set when the button submits somewhere other than its form (`formaction`). */
+    action?: string;
+    method?: string;
+}
+interface FarmPageFormAction {
+    type: "form";
+    name?: string;
+    method: "GET" | "POST";
+    /**
+     * Where the form submits: a root-relative URL on the page's origin, or an
+     * absolute URL elsewhere. Absent when the form only submits with JavaScript.
+     */
+    action?: string;
+    /** Present for POST forms. */
+    enctype?: string;
+    requiresJavaScript?: true;
+    fields: FarmPageFormField[];
+    submit: FarmPageFormSubmit[];
+    /** A React server action form: the id React put in its hidden `$ACTION_` fields. */
+    serverAction?: {
+        id: string;
+    };
+    /**
+     * The MCP tool that runs the same API endpoint, when `@farm.js/mcp` exposes
+     * it: the tool `name` and the MCP `endpoint` to call it at. The caller's
+     * `authorize` policy still decides whether that tool is available to it.
+     */
+    tool?: FarmMCPEndpointTool;
+}
+/**
+ * Describes the forms in the part of the page the mirror reads, so an agent can
+ * see what it can submit: where, how, and with which fields. Controls that are
+ * disabled are left out, since a browser would not submit them; hidden fields
+ * keep their values, so a submission without JavaScript can be replayed.
+ */
+declare function extractFarmPageActions(html: string, pageUrl: URL): FarmPageFormAction[];
+
+interface FarmLlmsTxtLink {
+    title: string;
+    url: string;
+    description?: string;
+}
+interface FarmLlmsTxtSection {
+    title: string;
+    links: FarmLlmsTxtLink[];
+}
+interface FarmLlmsTxt {
+    /** Site or project name, rendered as the `# H1`. Required by the format. */
+    title: string;
+    /** One-sentence summary, rendered as a `> blockquote`. */
+    summary?: string;
+    /** Free-form Markdown placed after the summary. */
+    details?: string;
+    /** `## H2` sections of links. A section titled "Optional" marks skippable links. */
+    sections?: FarmLlmsTxtSection[];
+}
+/** A static page of the app, ready to use as an llms.txt link. */
+interface FarmLlmsTxtPage extends FarmLlmsTxtLink {
+    /** The page's route path, such as `/docs/install`. */
+    path: string;
+}
+interface FarmLlmsTxtUserConfig {
+    /** Set to `false` to turn llms.txt off while keeping these options. */
+    enabled?: boolean;
+    /** Site name for the `# H1`. Defaults to the root layout's metadata title. */
+    title?: string;
+    /** Summary for the `> blockquote`. Defaults to the root layout's metadata description. */
+    summary?: string;
+    /** Markdown placed after the summary. */
+    details?: string;
+    /**
+     * Route patterns to list, using the same syntax as `md.expose`
+     * (`/docs/[...slug]`). Defaults to every static page.
+     */
+    include?: string[];
+    /** Route patterns to leave out, such as `/admin/[...path]`. */
+    exclude?: string[];
+    /**
+     * Also serve `/llms-full.txt`, the index with each page's Markdown mirror inlined.
+     *
+     * @default true
+     */
+    full?: boolean;
+    /**
+     * Seconds a CDN may cache the generated files, and the production server may
+     * reuse an llms-full.txt render, which renders every listed page. Defaults to
+     * no caching; concurrent llms-full.txt requests still share one render.
+     */
+    revalidate?: number;
+}
+interface ResolvedFarmLlmsTxtConfig {
+    enabled: boolean;
+    title?: string;
+    summary?: string;
+    details?: string;
+    include: string[];
+    exclude: string[];
+    full: boolean;
+    revalidate?: number;
+}
+interface FarmLlmsTxtPageSource {
+    pattern: string;
+    metadata?: unknown;
+}
+declare function resolveFarmLlmsTxtConfig(input: boolean | FarmLlmsTxtUserConfig | undefined): ResolvedFarmLlmsTxtConfig;
+declare function collectFarmLlmsTxtPages(sources: Iterable<FarmLlmsTxtPageSource>, options: {
+    origin: string;
+    basePath?: string;
+    markdown?: FarmMarkdownResolvedConfig;
+    include?: string[];
+    exclude?: string[];
+}): FarmLlmsTxtPage[];
+declare function createFarmDefaultLlmsTxt(options: {
+    origin: string;
+    pages: FarmLlmsTxtPage[];
+    config: ResolvedFarmLlmsTxtConfig;
+    rootMetadata?: unknown;
+    /** The app's MCP endpoints and AI catalog, listed in an "MCP" section. */
+    mcp?: FarmLlmsTxtLink[];
+}): FarmLlmsTxt;
+/**
+ * Reads a page's Markdown the way an agent would: a fresh `.md` request with no
+ * cookies or credentials, so a page behind auth answers 401 and is left out of
+ * a file that CDNs may cache, instead of leaking into it.
+ */
+declare function createFarmLlmsMarkdownReader(fetchMarkdown: (request: Request) => Promise<Response>): (url: string) => Promise<string | null>;
+/**
+ * Renders llms-full.txt: the llms.txt header, then one block per linked page with
+ * its Markdown inlined, in the layout the docs engine uses. A string passes
+ * through unchanged. Only same-origin links are fetched.
+ */
+declare function renderFarmLlmsFullTxt(value: unknown, options: {
+    origin: string;
+    readMarkdown: (url: string) => Promise<string | null>;
+    concurrency?: number;
+    /** Milliseconds to wait for one page's Markdown before leaving it out. */
+    pageTimeout?: number;
+    /** Called when a page is left out because it did not answer in time. */
+    onIncomplete?: () => void;
+}): Promise<string>;
+/**
+ * Shares llms-full.txt renders, which read every listed page. Requests for the
+ * same origin while a render runs, or within `revalidate` seconds after it, get
+ * that result; renders run one at a time, so a burst of requests, even with
+ * varied Host headers, cannot multiply page renders. The content is the same for
+ * every caller: pages are read with fresh requests that carry no credentials.
+ * A render that calls `incomplete()`, because a page timed out, is answered but
+ * not reused, so the next request tries that page again.
+ */
+declare function createFarmLlmsFullRenderer(options?: {
+    revalidate?: number;
+    now?: () => number;
+    maxEntries?: number;
+}): (origin: string, render: (shared: {
+    incomplete: () => void;
+}) => Promise<string>, onSettled?: (complete: boolean) => void) => Promise<string>;
+
+type ApplicationMetadataRouteKind = "sitemap" | "robots" | "manifest" | "llms" | "llms-full";
+declare namespace MetadataRoute {
+    type SitemapChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+    interface SitemapEntry {
+        url: string;
+        lastModified?: string | Date;
+        changeFrequency?: SitemapChangeFrequency;
+        priority?: number;
+        alternates?: {
+            languages?: Record<string, string>;
+        };
+    }
+    type Sitemap = SitemapEntry[];
+    interface RobotsRule {
+        userAgent: string | string[];
+        allow?: string | string[];
+        disallow?: string | string[];
+        crawlDelay?: number;
+    }
+    interface Robots {
+        rules: RobotsRule | RobotsRule[];
+        sitemap?: string | string[];
+        host?: string;
+    }
+    interface ManifestIcon {
+        src: string;
+        sizes?: string;
+        type?: string;
+        purpose?: string;
+    }
+    interface Manifest {
+        name?: string;
+        short_name?: string;
+        description?: string;
+        id?: string;
+        start_url?: string;
+        scope?: string;
+        display?: "fullscreen" | "standalone" | "minimal-ui" | "browser" | string;
+        orientation?: string;
+        background_color?: string;
+        theme_color?: string;
+        lang?: string;
+        dir?: "ltr" | "rtl" | "auto";
+        categories?: string[];
+        icons?: ManifestIcon[];
+        [key: string]: unknown;
+    }
+    /**
+     * The object an `llms.ts` metadata route returns, rendered as llms.txt. An
+     * `llms.ts` can also return the complete file as a string, or a `Response`.
+     */
+    type LlmsTxt = FarmLlmsTxt;
+    type LlmsTxtSection = FarmLlmsTxtSection;
+    type LlmsTxtLink = FarmLlmsTxtLink;
+    /** A static page of the app, usable directly as an llms.txt link. */
+    type LlmsTxtPage = FarmLlmsTxtPage;
+    /** What an `llms.ts` default-export function receives. */
+    interface LlmsTxtContext extends MetadataRouteContext {
+        /** The app's static pages, linking to their Markdown mirrors when exposed. */
+        pages: LlmsTxtPage[];
+        /** The llms.txt that `agent.llmsTxt` would serve, to extend instead of replace. */
+        defaults: LlmsTxt;
+    }
+    /**
+     * What an `llms-full.ts` default-export function receives. Returning an
+     * `LlmsTxt` object inlines each same-origin link's Markdown; returning a string
+     * serves it as the complete file.
+     */
+    interface LlmsFullTxtContext extends LlmsTxtContext {
+        /** A page's Markdown mirror, read without the request's cookies; `null` if unavailable. */
+        markdown(url: string): Promise<string | null>;
+    }
+}
+interface MetadataRouteContext {
+    request: Request;
+    params: Record<string, string>;
+    searchParams: URLSearchParams;
+    /** The concrete route-segment path that owns the metadata file. */
+    path: string;
+}
+interface FarmMetadataRouteModule {
+    revalidate?: number | false;
+}
+interface FarmMetadataRouteResponseOptions {
+    method?: string;
+    /** The request being answered, so llms.txt reads can be reported as agent traffic. */
+    request?: Request;
+}
+/** @internal */
+declare function createFarmMetadataRouteResponse(kind: ApplicationMetadataRouteKind, value: unknown, routeModule?: FarmMetadataRouteModule, options?: FarmMetadataRouteResponseOptions): Response;
+
+type FarmCrawlerPolicy = "allow" | "block";
+interface FarmAgentCrawlers {
+    /** Set to `false` to stop serving the generated robots.txt while keeping these options. */
+    enabled?: boolean;
+    /**
+     * AI search and user-triggered agents such as OAI-SearchBot, Claude-SearchBot,
+     * and PerplexityBot. Left unset, they follow the `User-agent: *` rules.
+     */
+    search?: FarmCrawlerPolicy;
+    /**
+     * AI training crawlers such as GPTBot, ClaudeBot, Google-Extended, and CCBot.
+     * Left unset, they follow the `User-agent: *` rules.
+     */
+    training?: FarmCrawlerPolicy;
+    /**
+     * More robots.txt groups, written after the generated ones. Crawlers combine
+     * groups that name the same agent. A rule for `*` replaces the default
+     * `User-agent: *` / `Allow: /` group.
+     */
+    rules?: MetadataRoute.RobotsRule[];
+    /**
+     * Absolute sitemap URLs. Defaults to the app's `sitemap.ts` route, resolved
+     * against the root layout's `metadataBase`; with neither, no `Sitemap:` line.
+     */
+    sitemap?: string | string[];
+}
+interface ResolvedFarmAgentCrawlers {
+    enabled: boolean;
+    search?: FarmCrawlerPolicy;
+    training?: FarmCrawlerPolicy;
+    rules: MetadataRoute.RobotsRule[];
+    sitemap?: string[];
+}
+interface FarmAgentRobotsOptions {
+    crawlers: ResolvedFarmAgentCrawlers;
+    /** The app's root sitemap route, such as `/sitemap.xml`, when it has one. */
+    sitemapPath?: string;
+    /** The root layout's `metadataBase`, which makes the sitemap URL absolute. */
+    metadataBase?: unknown;
+    basePath?: string;
+}
+/** The robots.txt `agent.crawlers` serves. */
+declare function createFarmAgentRobots(options: FarmAgentRobotsOptions): MetadataRoute.Robots;
+
+interface FarmAgentSitemapUserConfig {
+    /** Set to `false` to turn the sitemap off while keeping these options. */
+    enabled?: boolean;
+    /** Route patterns to list, such as `/blog/[...slug]`. Defaults to every static page. */
+    include?: string[];
+    /** Route patterns to leave out, such as `/admin/[...path]`. */
+    exclude?: string[];
+}
+interface ResolvedFarmAgentSitemap {
+    enabled: boolean;
+    include: string[];
+    exclude: string[];
+}
+interface FarmSitemapPageSource {
+    pattern: string;
+    /** The page module, for its `metadata` and whether a route `guard` gates it. */
+    module?: unknown;
+    /** When the page's file last changed, as an ISO date. */
+    lastModified?: string;
+}
+/**
+ * The generated sitemap's entries. Dynamic routes have no single URL and are left out,
+ * as are pages whose metadata says noindex and pages behind a route `guard`. URLs are
+ * absolute, on the root layout's `metadataBase` when it has one and the request's
+ * origin otherwise, the same origin the generated llms.txt links to.
+ */
+declare function createFarmDefaultSitemap(sources: Iterable<FarmSitemapPageSource>, options: {
+    origin: string;
+    config: ResolvedFarmAgentSitemap;
+    metadataBase?: unknown;
+    basePath?: string;
+}): MetadataRoute.Sitemap;
+
+/**
+ * Agent-readiness configuration: primitives that make a Farm site easier for AI agents and
+ * crawlers to discover, resolve, and use. The ones that only describe the site agents can
+ * already read (JSON-LD, llms.txt, the sitemap, and the AI catalog of MCP servers the app
+ * already serves, plus a read-only MCP server over the same public pages) are on by default; the
+ * ones that expose more (crawler rules, an API catalog) are opt-in. Each one turns off with `false`.
+ */
+
+/** schema.org JSON-LD emitted in the document head to identify the site. */
+interface FarmAgentJsonLd {
+    /**
+     * schema.org `@type`. Common values: `"Organization"` for a company or
+     * project, `"SoftwareApplication"` for a product, `"WebSite"`, `"Person"`.
+     *
+     * @default "Organization"
+     */
+    type?: string;
+    /** Entity name. Defaults to the site's Open Graph site name or page title. */
+    name?: string;
+    /** Canonical URL for the entity. Defaults to the configured `metadataBase`. */
+    url?: string;
+    /** Short description. Defaults to the page/site metadata description. */
+    description?: string;
+    /** Logo URL. */
+    logo?: string;
+    /** URLs that also represent this entity (social profiles, repos) — schema.org `sameAs`. */
+    sameAs?: string[];
+    /** Additional schema.org properties merged into the emitted object. */
+    properties?: Record<string, unknown>;
+}
+interface FarmAgentUserConfig {
+    /**
+     * Emit schema.org JSON-LD in the document head so agents and crawlers can
+     * resolve the site's identity. Left unset, it emits a `WebSite` built from the
+     * site's metadata; `true` emits an `Organization`; an object customizes the type
+     * and fields; `false` turns it off.
+     *
+     * @default { type: "WebSite" }
+     */
+    jsonLd?: boolean | FarmAgentJsonLd;
+    /**
+     * On a preview deployment, send `X-Robots-Tag: noindex, nofollow` with every
+     * response from Farm's server. Previews are detected from `FARM_PREVIEW`,
+     * `VERCEL_ENV=preview`, Netlify's deploy-preview and branch-deploy contexts,
+     * and Render pull request previews. Production is unaffected.
+     *
+     * @default false
+     */
+    noindexPreviews?: boolean;
+    /**
+     * Serve `/llms.txt` (https://llmstxt.org): a Markdown index of the app's static
+     * pages, linking to their Markdown mirrors. `true` builds it from page metadata
+     * and also serves `/llms-full.txt`; an object sets the title, summary, details,
+     * and which routes to list. A `src/app/llms.ts` metadata route or a
+     * `public/llms.txt` replaces the generated file. Left unset, `/llms.txt` is served
+     * (without `/llms-full.txt`) unless the docs engine is enabled, which serves its own.
+     *
+     * @default { full: false } without docs, false with docs
+     */
+    llmsTxt?: boolean | FarmLlmsTxtUserConfig;
+    /**
+     * Serve `/sitemap.xml` listing the app's static pages, the same pages the generated
+     * llms.txt lists, each with the time its page file last changed. Dynamic routes,
+     * pages whose metadata says noindex, pages behind a route `guard`, and pages a
+     * path-specific guard covers (non-root middleware.ts, a config or integration
+     * middleware matcher naming the path) are left out.
+     * URLs use the root layout's `metadataBase`, or the request's origin without one. An
+     * object sets which routes to list. A `src/app/sitemap.ts` or `public/sitemap.xml`
+     * replaces the generated file. Left unset, it is served unless the docs engine is
+     * enabled, which serves its own.
+     *
+     * @default true without docs, false with docs
+     */
+    sitemap?: boolean | FarmAgentSitemapUserConfig;
+    /**
+     * Serve a generated `/robots.txt` that allows or blocks AI search agents
+     * (`search`) and AI training crawlers (`training`), plus your own `rules`.
+     * `true` serves only `User-agent: *` / `Allow: /` and the sitemap. A
+     * `public/robots.txt` or `src/app/robots.ts` replaces the generated file.
+     *
+     * @default false
+     */
+    crawlers?: boolean | FarmAgentCrawlers;
+    /**
+     * Serve `/.well-known/api-catalog` (RFC 9727): a Linkset listing the app's
+     * OpenAPI description and reference (when `openapi` is enabled) and its MCP
+     * endpoint (when the top-level `mcp` is enabled), so agents can find them
+     * from the origin alone.
+     *
+     * @default false
+     */
+    apiCatalog?: boolean;
+    /**
+     * Advertise the app's MCP servers (the top-level `mcp` config, `apiMcp()`, and
+     * endpoints listed with `registerFarmMCPServer`, such as the docs engine's):
+     * `/.well-known/ai-catalog.json` (and `/.well-known/ard.json`) lists a server
+     * card for each, served at `<endpoint>/server-card`, and the generated
+     * `/llms.txt` names each endpoint. Nothing is served when the app has no MCP
+     * server. `false` turns all of it off.
+     *
+     * @default true
+     */
+    aiCatalog?: boolean;
+    /**
+     * Serve `/.well-known/farmjs.json`: Farm's version and packages, the app's MCP tools and
+     * their schemas, WebMCP browser tools, integration providers and plugin names. Everyone,
+     * Farm Infra included, gets the same public document; an MCP server that requires
+     * `authorize` or sits behind a guard is listed by identity only. An object hides sections
+     * (served as `null`), package versions, schemas or single servers and tools. `false` turns
+     * it off; Farm Infra then can't discover the app's tools either.
+     *
+     * @default true
+     */
+    manifest?: boolean | FarmAppManifestConfig;
+    /**
+     * Serve a read-only MCP server (Streamable HTTP) at `/mcp` with tools that list,
+     * search, and read the app's public pages as Markdown: the static pages llms.txt and
+     * the sitemap list, without pages whose metadata says noindex or pages a route `guard`
+     * or path-specific guard covers. Pages are read like an anonymous visitor, never with the caller's cookies.
+     * It steps aside when the app has an MCP server of its own: a route that answers
+     * `/mcp`, an API route at `/api/mcp`, the top-level `mcp` config or `apiMcp()`, or a
+     * server listed with `registerFarmMCPServer` (the docs engine's MCP). Left unset, it
+     * is served unless the docs engine is enabled, which serves its own.
+     *
+     * @default true without docs, false with docs
+     */
+    mcp?: boolean;
+}
+interface ResolvedFarmAgentConfig {
+    jsonLd: FarmAgentJsonLd | false;
+    noindexPreviews: boolean;
+    llmsTxt: ResolvedFarmLlmsTxtConfig;
+    sitemap: ResolvedFarmAgentSitemap;
+    crawlers: ResolvedFarmAgentCrawlers;
+    apiCatalog: boolean;
+    aiCatalog: boolean;
+    manifest: false | ResolvedFarmAppManifestConfig;
+    mcp: boolean;
+}
+
+interface FarmDocsAdapterDescriptor {
+    id: string;
+    protocol: number;
+    server: string;
+    react?: string;
+    vite?: string;
+    /**
+     * Build-time entry that compiles the adapter's docs runtime into Farm's
+     * serializable edge manifest. Older Farm releases safely ignore it.
+     */
+    edgeCompiler?: string;
+}
+interface FarmDocsSidebarItem {
+    label?: string;
+    title?: string;
+    slug?: string;
+    href?: string;
+    icon?: string;
+    children?: FarmDocsSidebarItem[];
+    items?: FarmDocsSidebarItem[];
+}
+interface FarmDocsNavigationConfig {
+    sidebar?: FarmDocsSidebarItem[];
+}
+interface FarmDocsSocialImageConfig {
+    /** Generate a page-specific 1200×630 social image. Defaults to true. */
+    enabled?: boolean;
+    /** Absolute public origin used in social metadata, e.g. https://example.com. */
+    baseUrl?: string;
+    /** Site name shown in Open Graph metadata. Defaults to the docs navigation title. */
+    siteName?: string;
+    /** Short brand label drawn in the image header. Defaults to siteName. */
+    brand?: string;
+    /** Optional WOFF2 URLs or data URLs embedded into the generated SVG. */
+    fonts?: FarmDocsSocialImageFonts;
+}
+interface FarmDocsSocialImageFonts {
+    /** Display face used for page titles. */
+    display?: string;
+    /** Sans-serif face used for descriptions. */
+    sans?: string;
+    /** Monospace face used for labels, routes, and diagrams. */
+    mono?: string;
+}
+type FarmDocsRuntimeConfig = Partial<DocsConfig> & {
+    /**
+     * Public favicon URL used by the standalone docs renderer.
+     * Set this explicitly when docs should share the host application's icon.
+     */
+    favicon?: string;
+    /**
+     * Optional serializable navigation tree used by Farm's docs runtime.
+     * Icon values reference keys from `icons`.
+     */
+    navigation?: FarmDocsNavigationConfig;
+    /**
+     * Automatic page-specific Open Graph and X images for Markdown docs.
+     * Enabled by default. Set false to opt out for the complete docs tree.
+     */
+    socialImage?: boolean | FarmDocsSocialImageConfig;
+};
+type FarmDocsConfigInput = FarmDocsRuntimeConfig & {
+    /**
+     * Versioned runtime descriptor supplied by an external docs adapter.
+     * Set false to pin the embedded renderer and disable framework
+     * auto-detection.
+     */
+    adapter?: FarmDocsAdapterDescriptor | false;
+    /**
+     * Farm public route for docs, e.g. "/docs". When passed through
+     * `config`, this is converted to the docs package's folder-style `entry`.
+     */
+    entry?: string;
+    /** Explicit public route prefix. Defaults to `entry`. */
+    docsPath?: string;
+    /** Source content directory, relative to the project root. */
+    contentDir?: string;
+    /** Set to false to opt out even when a docs config file exists. */
+    enabled?: boolean;
+    /** Inline @farming-labs/docs config object. */
+    config?: FarmDocsRuntimeConfig;
+    /** Path to docs.config.* or docs.json. */
+    configPath?: string;
+};
+type FarmDocsUserConfig = boolean | FarmDocsConfigInput;
+interface FarmDocsResolvedConfig {
+    enabled: boolean;
+    entry: string;
+    adapter?: FarmDocsAdapterDescriptor;
+    contentDir?: string;
+    configPath?: string;
+    config: FarmDocsRuntimeConfig & Pick<DocsConfig, "entry">;
+    /**
+     * `config` before it was made serializable: icons and other React elements, MDX
+     * components, and callbacks intact. Only the in-process adapter runtime reads it;
+     * whatever Farm serializes uses `config`.
+     */
+    runtimeConfig?: FarmDocsRuntimeConfig & Pick<DocsConfig, "entry">;
+    /** The serializable docs settings from `farm.config.ts`, applied over the config file. */
+    configOverrides?: Partial<DocsConfig>;
+}
+
+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;
+}
+declare function resolveMdxConfig(config: FarmMdxUserConfig | undefined): FarmMdxResolvedConfig;
+/**
+ * The MDX components module a Markdown page renders from, as an absolute path. Undefined when
+ * the components are an inline object, which cannot be analyzed for client components.
+ */
+declare function resolveFarmMdxComponentsModulePath(config: FarmMdxResolvedConfig | undefined, root: string): string | undefined;
+
+/**
+ * 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;
+    /** The pathname the router matches: decoded once, without basePath or locale. */
+    readonly routePathname: 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;
+    /**
+     * Remove a cookie. Pass the `path`/`domain` it was set with; a tombstone only
+     * matches a cookie with the same scope.
+     */
+    delete(name: string, options?: CookieOptions): 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";
+    /**
+     * Whether a response this middleware lets through may be stored by a shared cache (a CDN).
+     * Farm cannot tell a guard from harmless middleware, and a CDN serves its copy without
+     * running either, so by default (`"private"`) the response is sent with
+     * `Cache-Control: private, no-store`. Set `"public"` only on middleware that never decides
+     * who may read the response, such as logging or response headers.
+     */
+    cache?: "private" | "public";
+}
+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;
+    /** Request pathname as received: still percent-encoded and carrying basePath/locale. */
+    pathname: string;
+    /**
+     * The pathname the router matches: decoded once, without basePath or locale. String matchers
+     * compare this value; compare it in path checks too. Updated by `rewrite()`.
+     */
+    readonly routePathname: 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 FarmRedirectStatus = 301 | 302 | 303 | 307 | 308;
+interface FarmRedirectSignal {
+    url: string;
+    status: FarmRedirectStatus;
+}
+declare function redirect(url: string, status?: FarmRedirectStatus): never;
+declare function permanentRedirect(url: string): never;
+declare function notFound(): never;
+declare function isFarmRedirectError(error: unknown): boolean;
+declare function getFarmRedirectError(error: unknown): FarmRedirectSignal | null;
+declare function isFarmNotFoundError(error: unknown): boolean;
+
+type FarmBuildActivityPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left";
+interface FarmDevIndicatorsConfig {
+    /** Show build and HMR activity in the browser during development. */
+    buildActivity?: boolean;
+    /** Corner used by the build activity indicator. */
+    buildActivityPosition?: FarmBuildActivityPosition;
+}
+interface ResolvedFarmDevIndicatorsConfig {
+    buildActivity: boolean;
+    buildActivityPosition: FarmBuildActivityPosition;
+}
+declare function resolveFarmDevIndicatorsConfig(config: FarmDevIndicatorsConfig | undefined, mode?: "development" | "production"): ResolvedFarmDevIndicatorsConfig;
+declare function generateFarmDevIndicatorsClientRuntime(config: ResolvedFarmDevIndicatorsConfig): string;
+
+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;
+    /**
+     * Generate a fresh nonce for every dynamic HTML response and per-page
+     * script hashes for prerendered HTML. Farm adds the matching sources to the
+     * governing script directive. Only Farm's own scripts, the renderer's
+     * streaming scripts, and scripts the app gives `getCspNonce()` carry the
+     * nonce (or get a hash); every other script element loses its nonce.
+     */
+    nonce?: boolean;
+}
+type FarmCspConfig = string | FarmCspOptions;
+interface FarmSecurityConfig {
+    /** App-wide CSP for dynamic responses and prerendered output. */
+    csp?: FarmCspConfig | false;
+    /** @deprecated Use csp. */
+    contentSecurityPolicy?: never;
+}
+interface ResolvedFarmCspConfig {
+    value: string;
+    reportOnly: boolean;
+    nonce: boolean;
+}
+interface ResolvedFarmSecurityConfig {
+    csp: ResolvedFarmCspConfig | false;
+}
+declare function resolveFarmSecurityConfig(input: FarmSecurityConfig | ResolvedFarmSecurityConfig | undefined): ResolvedFarmSecurityConfig;
+declare function createFarmCspNonce(security: ResolvedFarmSecurityConfig): string | undefined;
+/**
+ * Stamp the nonce of the response being rendered on Farm-generated `html`.
+ * Returns `html` unchanged outside nonce mode.
+ */
+declare function stampFarmCspNonce(html: string, nonce?: string | undefined): string;
+/**
+ * Send `response` with the nonce policy. `nonce` is the one the response was
+ * rendered with: script elements that carry it keep it, and every other
+ * script element loses its nonce attribute, so markup injected into the page
+ * can never run under the policy.
+ */
+declare function applyFarmCspNonceToResponse(response: Response, security: ResolvedFarmSecurityConfig, nonce?: string | undefined): Response;
+
+interface FarmDesktopDevSession {
+    secret: string;
+    handshakeToken: string;
+    /** Set by the dev guard once the window used the token, so a Vite restart cannot reopen it. */
+    handshakeUsed?: boolean;
+}
+/** Called by the CLI before it starts the dev server for `farm dev --desktop`. */
+declare function setFarmDesktopDevSession(session: FarmDesktopDevSession | undefined): void;
+interface FarmDesktopWindowConfig {
+    /** Initial width in points. Defaults to 1024. */
+    width?: number;
+    /** Initial height in points. Defaults to 768. */
+    height?: number;
+    /** Window title. Defaults to `desktop.name`. */
+    title?: string;
+}
+interface FarmDesktopUserConfig {
+    /** Display name of the app. Defaults to the package.json `productName` or `name`. */
+    name?: string;
+    /**
+     * Reverse-DNS app identifier, such as `com.example.notes`. The OS keys the app's data
+     * directory on it, so changing it later moves the user's data. Defaults to `local.farm.<name>`.
+     */
+    id?: string;
+    /** App version. Defaults to the package.json `version`. */
+    version?: string;
+    /**
+     * App icon: a square PNG, relative to the app root. 1024×1024 is recommended; the OS scales it
+     * down. Defaults to the Farm icon.
+     */
+    icon?: string;
+    window?: FarmDesktopWindowConfig;
+    /**
+     * Desktop shell adapter. A name resolves to `@farm.js/desktop/<name>`; a package name or
+     * subpath (containing `/`) is imported as is. Defaults to `"electrobun"`.
+     */
+    shell?: "electrobun" | (string & {});
+}
+/** What a function-valued `desktop` block receives. Resolved once per dev start or build. */
+interface FarmDesktopContext {
+    /** The OS the app is built for. Builds target the host OS. */
+    os: "macos" | "windows" | "linux";
+    mode: "development" | "production";
+    command: "dev" | "build";
+    /** `--profile`, `"production"` by default. */
+    profile: string;
+    env: Readonly<Record<string, string | undefined>>;
+    /** App root. */
+    root: string;
+}
+/**
+ * `desktop` in farm.config: a static block, or a function of the platform context that returns
+ * one. The function runs in the CLI only; its code never reaches a server or browser bundle.
+ */
+type FarmDesktopConfigInput = FarmDesktopUserConfig | ((context: FarmDesktopContext) => FarmDesktopUserConfig | Promise<FarmDesktopUserConfig>);
+interface ResolvedFarmDesktopConfig {
+    name: string;
+    id: string;
+    version: string;
+    /** Absolute path of the app's icon PNG, or undefined for the shell's default icon. */
+    icon?: string;
+    window: {
+        width: number;
+        height: number;
+        title: string;
+    };
+    /** Adapter name, as configured. */
+    shell: string;
+    /** Module the CLI imports the adapter from, such as `@farm.js/desktop/electrobun`. */
+    shellPackage: string;
+}
+/**
+ * Check a `desktop` block. Web builds check a static block this way (a function-valued block is
+ * not called there); desktop builds check the value a function returned, naming the OS.
+ */
+declare function validateFarmDesktopConfig(input: unknown, context?: Pick<FarmDesktopContext, "os">): FarmDesktopUserConfig | undefined;
+/** Fill in `desktop` defaults for a desktop dev session or build. */
+/** Fill in defaults for an already resolved (static or returned) `desktop` block. */
+declare function resolveFarmDesktopConfig(input: FarmDesktopUserConfig | undefined, root: string, context?: Pick<FarmDesktopContext, "os">): ResolvedFarmDesktopConfig;
+/** Where `farm build --desktop` writes its outputs, relative to the app root. */
+declare function getFarmDesktopOutputDirs(distDir: string): {
+    root: string;
+    server: string;
+    shell: string;
+    dist: string;
+    devData: string;
+};
+interface FarmDesktopSetupOptions {
+    command: FarmDesktopContext["command"];
+    /** `--profile`; defaults to `"production"`. */
+    profile?: string;
+    /** Target OS; defaults to the host. `farm config inspect --os` sets another one. */
+    os?: FarmDesktopContext["os"];
+}
+/** The context a function-valued block receives. `env` is a frozen snapshot. */
+declare function createFarmDesktopContext(options: FarmDesktopSetupOptions & {
+    root: string;
+    mode: FarmDesktopContext["mode"];
+}): FarmDesktopContext;
+/** Results of function-valued blocks for one dev session or build. */
+type FarmDesktopBlockCache = Map<string, Promise<FarmDesktopUserConfig>>;
+/**
+ * The plain `desktop` block for a context: the static object, or what the function returned.
+ * Validated, with errors naming the OS and field.
+ *
+ * With a cache, the function runs once per session: `farm dev` loads farm.config more than once
+ * while it starts, and each load brings a new function with the same source. An edited block has
+ * new source, so it runs again.
+ */
+declare function resolveFarmDesktopBlock(input: FarmDesktopConfigInput, context: FarmDesktopContext, cache?: FarmDesktopBlockCache): Promise<FarmDesktopUserConfig>;
+/** Called by `farm dev|build --desktop` before any config resolves. */
+declare function installFarmDesktopSetup(options: FarmDesktopSetupOptions): void;
+
+declare const DEFAULT_FARM_API_BASE_PATH = "/api";
+interface FarmAPIConfigResolverContext {
+    root: string;
+    mode: "development" | "production";
+    env: ResolvedFarmEnv;
+}
+type FarmAPIConfigValue = string | undefined | ((context: FarmAPIConfigResolverContext) => string | undefined | Promise<string | undefined>);
+interface FarmAPIConfig {
+    /**
+     * Public API root. An origin-only URL is joined with `basePath`; a URL that
+     * already has a path is used as-is. May be resolved from deployment context.
+     */
+    baseURL?: FarmAPIConfigValue;
+    /** Public API path and same-origin server mount used when `baseURL` has no path. @default "/api" */
+    basePath?: FarmAPIConfigValue;
+}
+interface ResolvedFarmAPIConfig {
+    /** Fully resolved public API root, either absolute or root-relative. */
+    baseURL: string;
+    /** Effective pathname of `baseURL`. */
+    basePath: string;
+}
+declare function resolveFarmAPIConfig(config: FarmAPIConfig | undefined, context: FarmAPIConfigResolverContext): Promise<ResolvedFarmAPIConfig>;
+/** Normalize already-resolved API strings. */
+declare function normalizeFarmAPIConfig(config: {
+    baseURL?: string;
+    basePath?: string;
+} | undefined): ResolvedFarmAPIConfig;
+declare function normalizeFarmAPIBasePath(value: string): string;
+/** Read the API root embedded by Farm's Vite build. */
+declare function getFarmAPIBaseURL(): string;
+/** Resolve a canonical Farm route such as `/api/users` against an API root. */
+declare function resolveFarmAPIRequestURL(routePath: string, baseURL?: string, fallbackOrigin?: string): URL;
+
+declare const FARM_RESOLVED_CUSTOM_CONTEXT: unique symbol;
+
+interface RedirectConfig {
+    source: string;
+    destination: string;
+    permanent?: boolean;
+    statusCode?: FarmRedirectStatus;
+}
+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;
+    /**
+     * Path where the raw OpenAPI spec is served as JSON, so agents and API tools
+     * can fetch it at a predictable URL. Set to `false` to disable.
+     *
+     * @default "/openapi.json"
+     */
+    specRoute?: string | false;
+    title?: string;
+    description?: string;
+    version?: string;
+    /** Default authentication requirement for operations without an endpoint override. */
+    security?: OpenAPISecurityMode;
+    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;
+    /** Compose opted-in API routes and standalone tools through an authenticated MCP transport. */
+    mcp?: FarmMCPUserConfig;
+    /** 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;
+    /**
+     * The native desktop app `farm dev --desktop` and `farm build --desktop` produce: a block, or a
+     * function of `{ os, mode, command, profile, env, root }` that returns one. A web build checks
+     * a static block's shape, never calls the function, and ships neither.
+     */
+    desktop?: FarmDesktopConfigInput;
+    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;
+    distDir?: string;
+    generateBuildId?: () => string | Promise<string>;
+    compress?: boolean;
+    devIndicators?: FarmDevIndicatorsConfig;
+    serverRuntimeConfig?: Record<string, any>;
+    publicRuntimeConfig?: Record<string, any>;
+    env?: FarmEnvConfig<any, any>;
+    vite?: UserConfig | ((config: UserConfig) => UserConfig);
+    [key: string]: any;
+}
+interface ResolvedFarmConfig extends Required<Omit<FarmUserConfig, "extends" | "plugins" | "vite" | "deploy" | "docs" | "md" | "mdx" | "migrations" | "cron" | "workflows" | "api" | "env" | "server" | "serverActions" | "devtools" | "devIndicators" | "images" | "i18n" | "auth" | "mcp" | "performance" | "security" | "theme" | "renderer" | "agent" | "desktop">> {
+    agent: ResolvedFarmAgentConfig;
+    /** Set only in a desktop dev session or build (`--desktop`); `null` on the web. */
+    desktop: ResolvedFarmDesktopConfig | null;
+    /** @internal Tracks whether `context` came from user/layer config instead of the default noop. */
+    [FARM_RESOLVED_CUSTOM_CONTEXT]?: boolean;
+    root: string;
+    extends: readonly FarmLayerEntry[];
+    layers: ResolvedFarmLayer[];
+    plugins: FarmPlugin[];
+    vite: UserConfig;
+    deploy: ResolvedFarmDeployConfig;
+    docs: FarmDocsResolvedConfig;
+    md: FarmMarkdownResolvedConfig;
+    mdx: FarmMdxResolvedConfig;
+    migrations: ResolvedFarmMigrationsConfig;
+    cron: FarmCronResolvedConfig;
+    workflows: FarmWorkflowsResolvedConfig;
+    api: ResolvedFarmAPIConfig;
+    env: ResolvedFarmEnv;
+    server: ResolvedFarmServerConfig;
+    serverActions: ResolvedFarmServerActionsConfig;
+    devtools: ResolvedFarmDevtoolsConfig;
+    devIndicators: ResolvedFarmDevIndicatorsConfig;
+    images: ResolvedFarmImageConfig;
+    i18n: ResolvedFarmI18nConfig;
+    auth: ResolvedFarmAuthConfig;
+    mcp: ResolvedFarmMCPConfig;
+    performance: ResolvedFarmPerformanceConfig;
+    security: ResolvedFarmSecurityConfig;
+    theme: ResolvedFarmThemeConfig;
+    renderer: FarmRenderer;
+    routeRules: FarmRouteRules;
+    notFound: NotFoundConfig;
+}
+type FarmLayerConfig = Omit<FarmUserConfig, "root" | "outDir" | "distDir" | "deploy" | "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;
+    /** Build environment consulted for platform detection. Tests inject this. */
+    env?: NodeJS.ProcessEnv;
+}): 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>;
+
+type FarmRouteRuntime = "auto" | "node" | "edge";
+type FarmRouteRegions = "auto" | readonly string[];
+type FarmRouteMaxDuration = "auto" | number;
+/** Portable execution controls shared by file, programmatic, and config routes. */
+interface FarmRouteRuntimeConfig {
+    runtime?: FarmRouteRuntime;
+    regions?: FarmRouteRegions;
+    maxDuration?: FarmRouteMaxDuration;
+}
+interface ResolvedFarmRouteRuntimeConfig {
+    runtime: FarmRouteRuntime;
+    regions?: string[];
+    maxDuration?: number;
+}
+type FarmRouteRuntimeEntryKind = "page" | "api" | "metadata" | "rule";
+type FarmRouteRenderingMode = "static" | "dynamic";
+interface FarmRouteRuntimeManifestEntry extends ResolvedFarmRouteRuntimeConfig {
+    kind: FarmRouteRuntimeEntryKind;
+    pattern: string;
+    rendering: FarmRouteRenderingMode;
+    source?: string;
+}
+interface FarmRouteRuntimeManifest {
+    version: 1;
+    routes: FarmRouteRuntimeManifestEntry[];
+}
+declare function normalizeFarmRouteRuntimeConfig(value: FarmRouteRuntimeConfig | null | undefined, source?: string): FarmRouteRuntimeConfig;
+/** Merge from lowest to highest precedence. Explicit "auto" values reset inherited hints. */
+declare function mergeFarmRouteRuntimeConfigs(...configs: Array<FarmRouteRuntimeConfig | null | undefined>): FarmRouteRuntimeConfig;
+declare function resolveFarmRouteRuntimeConfig(config: FarmRouteRuntimeConfig | null | undefined, source?: string): ResolvedFarmRouteRuntimeConfig;
+declare function hasFarmRouteRuntimeControls(config: FarmRouteRuntimeConfig | null | undefined): boolean;
+declare function getFarmRouteRuntimeConfig(value: unknown): FarmRouteRuntimeConfig;
+declare function createFarmRouteRuntimeKey(config: ResolvedFarmRouteRuntimeConfig): string;
+/** Resolve matching route rules from broadest to most specific. */
+declare function resolveFarmRouteRuleRuntimeConfig(pathname: string, routeRules: Record<string, FarmRouteRuntimeConfig> | null | undefined): FarmRouteRuntimeConfig;
+declare function farmRouteRuleMatches(pattern: string, pathname: string): boolean;
+
+type FarmRouteRuleRenderMode = "static" | "dynamic";
+type FarmRouteRuleRedirect = string | {
+    to: string;
+    statusCode?: FarmRedirectStatus;
+    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>;
+
+declare global {
+    namespace FarmJS {
+        /** @internal Application route patterns registered by generated types. */
+        interface RouteRegistry {
+        }
+    }
+}
+/** A renderer-neutral component accepted by Farm's file-system router. */
+type FarmComponentType<TProps = Record<string, unknown>> = ((props: TProps) => any) | (new (props: TProps) => any);
+/** 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;
+    /** Generate and canonicalize non-root application page URLs with a trailing slash. */
+    trailingSlash?: boolean;
+    /**
+     * Component renderer used for JSX compilation, SSR, and browser hydration.
+     * React is used when omitted.
+     */
+    renderer?: FarmRenderer;
+    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;
+    /** Rules for the tables plugins and integrations declare, such as which app tables they may add columns to. */
+    schema?: FarmSchemaConfig;
+    /** 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;
+    /** Public base URL and path used by Farm's browser API clients. */
+    api?: FarmAPIConfig;
+    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;
+    /** Opt-in agent-readiness primitives (JSON-LD and related). Off by default. */
+    agent?: FarmAgentUserConfig;
+    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;
+    /** Optional project-relative module used for unmatched page routes. */
+    notFound?: {
+        component?: string;
+    };
+    /** Server-only application runtime values. */
+    serverRuntimeConfig?: Record<string, unknown>;
+    /** Serializable application values exposed to `src/client.ts`. */
+    publicRuntimeConfig?: Record<string, unknown>;
+    docs?: FarmDocsUserConfig | FarmDocsResolvedConfig;
+    md?: FarmMarkdownUserConfig | FarmMarkdownResolvedConfig | boolean;
+    mdx?: FarmMdxUserConfig | FarmMdxResolvedConfig;
+    observability?: FarmObservabilityUserConfig;
+    /** Farm product telemetry for deployed server runtimes. Set to false to disable. */
+    telemetry?: boolean;
+    /**
+     * Request and MCP tool analytics for a Farm Infra project. On only when the server
+     * environment sets `FARMJS_API_KEY` (plus `FARMJS_PROJECT_ID` for a key reaching several
+     * projects). Set to false to never send them.
+     */
+    analytics?: boolean;
+    /**
+     * Development-only runtime inspector. Enabled by default during `farm dev`.
+     *
+     * @deprecated The built-in dashboard is deprecated. Install `@farm.js/devtools` and add
+     * `devtools()` to `plugins` instead; it reuses this runtime and owns the maintained UI.
+     * `devtools: false` and `shortcut` remain supported for the transition.
+     */
+    devtools?: FarmDevtoolsUserConfig;
+    /** Development-only browser feedback for build and HMR activity. */
+    devIndicators?: FarmDevIndicatorsConfig;
+    /**
+     * 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?: {
+        /**
+         * React Server Components. `true` is `{ mode: "rsc" }`: `farm dev` and `farm build` run
+         * React's Flight pipeline from `@farm.js/plugin/rsc`. `{ mode: "islands" }` is reserved for
+         * Farm's own engine (RFC 0003). Pages and layouts are server components either way.
+         */
+        serverComponents?: FarmServerComponentsConfig;
+        serverActions?: boolean;
+        /**
+         * Enables Partial Prerendering (static-shell caching). Routes still opt in
+         * individually with `export const ppr = true`, the Next-compatible
+         * `export const experimental_ppr = true`, or a `"use ppr"` directive;
+         * without this flag those declarations are inert and the route renders
+         * fully dynamically.
+         *
+         * @experimental
+         * @default false
+         */
+        ppr?: boolean;
+        /**
+         * Controls non-RSC hydration ownership for server modules that import
+         * leaf `"use client"` components.
+         *
+         * - `"off"` keeps the current route-wide hydration boundary.
+         * - `"analyze"` reports eligible boundaries without changing runtime behavior.
+         * - `"enabled"` hydrates eligible client leaves independently and falls
+         *   back to route-wide hydration for unsupported module graphs.
+         *
+         * This does not enable React Server Components. `"use client"` remains a
+         * valid client-boundary declaration in normal SSR applications.
+         *
+         * @experimental
+         * @default "off"
+         */
+        isolatedClientHydration?: FarmIsolatedClientHydrationMode;
+        /**
+         * 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;
+}
+type FarmIsolatedClientHydrationMode = "off" | "analyze" | "enabled";
+/**
+ * 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: any;
+    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> = FarmComponentType<PageProps<TRoute>>;
+type Layout<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = FarmComponentType<LayoutProps<TRoute>>;
+type Loading<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = FarmComponentType<LoadingProps<TRoute>>;
+type ErrorBoundary<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = FarmComponentType<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`.
+     * Requires `experimental.ppr` in `farm.config.ts`; inert without it.
+     */
+    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;
+    viewport?: Viewport;
+    generateViewport?: (props: MetadataProps<TRoute>) => Promise<Viewport> | Viewport;
+}
+/** 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;
+    viewport?: Viewport;
+    generateViewport?: (props: LayoutMetadataProps<TRoute>) => Promise<Viewport> | Viewport;
+}
+/** A schema.org JSON-LD object, such as `{ "@context": "https://schema.org", "@type": "Article" }`. */
+type MetadataJsonLd = object;
+/** A `theme-color` entry, optionally for one `prefers-color-scheme` media query. */
+interface ThemeColorDescriptor {
+    color: string;
+    media?: string;
+}
+/**
+ * The `viewport` export of a layout or page, and the return value of `generateViewport()`, as in
+ * Next.js. Layouts and the page merge from root to page over the default
+ * `width=device-width, initial-scale=1`.
+ */
+interface Viewport {
+    width?: string | number;
+    height?: string | number;
+    initialScale?: number;
+    minimumScale?: number;
+    maximumScale?: number;
+    userScalable?: boolean;
+    viewportFit?: "auto" | "cover" | "contain";
+    interactiveWidget?: "resizes-visual" | "resizes-content" | "overlays-content";
+    themeColor?: string | ThemeColorDescriptor | ThemeColorDescriptor[];
+    colorScheme?: string;
+}
+interface Metadata {
+    metadataBase?: string | URL;
+    /** `absolute` names a page exactly, past any parent `template` (as in Next.js). */
+    title?: string | {
+        default?: string;
+        template?: string;
+        absolute?: string;
+    };
+    description?: string;
+    keywords?: string | string[];
+    /**
+     * schema.org structured data rendered as `<script type="application/ld+json">`,
+     * one per object. Layout entries come first, then the page's. Renders
+     * alongside the site-level `agent.jsonLd`.
+     */
+    jsonLd?: MetadataJsonLd | MetadataJsonLd[];
+    author?: string;
+    authors?: Array<{
+        name: string;
+        url?: string;
+    }>;
+    creator?: string;
+    /** Site ownership tokens for search consoles, one `<meta>` per token. */
+    verification?: {
+        /** `google-site-verification` */
+        google?: string | string[];
+        /** `msvalidate.01` */
+        bing?: string | string[];
+        /** `yandex-verification` */
+        yandex?: string | string[];
+        /** Any other verification meta name, keyed by name. */
+        other?: Record<string, string | string[]>;
+    };
+    publisher?: string;
+    robots?: string | MetadataRobots;
+    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;
+        /**
+         * `og:video` entries. Point `url` at the media file itself (an MP4, for
+         * example) rather than a player page; relative URLs resolve against
+         * `metadataBase` like `images`.
+         */
+        videos?: string | {
+            url: string;
+            secureUrl?: string;
+            width?: number;
+            height?: number;
+            type?: string;
+        } | Array<{
+            url: string;
+            secureUrl?: string;
+            width?: number;
+            height?: number;
+            type?: string;
+        }>;
+        type?: string;
+        locale?: string;
+        /** `article:published_time`, rendered when `type` is `"article"`. */
+        publishedTime?: string | Date;
+        /** `article:modified_time`, rendered when `type` is `"article"`. */
+        modifiedTime?: string | Date;
+        /** `article:author` profile URLs or names, rendered when `type` is `"article"`. */
+        authors?: string | string[];
+        /** `article:section`, rendered when `type` is `"article"`. */
+        section?: string;
+        /** `article:tag`, rendered when `type` is `"article"`. */
+        tags?: string | 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>;
+        /**
+         * Alternate representations keyed by MIME type, such as an RSS feed.
+         * `text/markdown` replaces the link Farm adds for a page's Markdown mirror.
+         */
+        types?: Record<string, string | Array<{
+            url: string;
+            title?: 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;
+    /** Extra `<meta name content>` tags, keyed by name. An array renders one tag per value. */
+    other?: Record<string, string | number | Array<string | number>>;
+}
+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[];
+}
+/** Crawler directives for a robots `<meta>` tag. Unset fields are omitted. */
+interface MetadataRobotsDirectives {
+    index?: boolean;
+    follow?: boolean;
+    noarchive?: boolean;
+    nosnippet?: boolean;
+    noimageindex?: boolean;
+    /** Maximum text snippet length; `-1` means no limit and `0` means no snippet. */
+    "max-snippet"?: number;
+    "max-image-preview"?: "none" | "standard" | "large";
+    /** Maximum video preview length in seconds; `-1` means no limit. */
+    "max-video-preview"?: number;
+    /** Date after which the page should drop out of results, for example an ISO 8601 date. */
+    unavailable_after?: string;
+}
+interface MetadataRobots extends MetadataRobotsDirectives {
+    /** Directives for a separate `<meta name="googlebot">` tag. */
+    googleBot?: string | MetadataRobotsDirectives;
+}
+
+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 extends {
+    primaryKey: true;
+} ? TField["type"] extends "id" | "uuid" | "string" | "integer" ? "id" : never : TField["type"] extends "id" | "uuid" | "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 FarmIntegrationOrmModelShape = {
+    fields: Record<string, unknown>;
+};
+type InferFarmIntegrationOrmFields<TModel extends FarmIntegrationOrmModelShape> = {
+    [TFieldKey in keyof TModel["fields"] & string]: InferFarmIntegrationOrmField<Extract<TModel["fields"][TFieldKey], FarmIntegrationSchemaField>>;
+};
+type ReplaceRecord<TBase, TReplacement> = Omit<TBase, keyof TReplacement> & TReplacement;
+type SchemaExtensions<TSchema extends FarmIntegrationSchema> = NonNullable<TSchema["extend"]>;
+type SchemaOverrides<TSchema extends FarmIntegrationSchema> = NonNullable<TSchema["override"]>;
+type SchemaModelFields<TModel> = TModel extends {
+    fields: infer TFields;
+} ? TFields : TModel extends {
+    fields?: infer TFields;
+} ? NonNullable<TFields> : {};
+type ExtendedSchemaModelFields<TSchema extends FarmIntegrationSchema, TModelKey extends PropertyKey> = ReplaceRecord<TModelKey extends keyof TSchema["models"] ? SchemaModelFields<TSchema["models"][TModelKey]> : {}, TModelKey extends keyof SchemaExtensions<TSchema> ? SchemaModelFields<SchemaExtensions<TSchema>[TModelKey]> : {}>;
+type OverrideSchemaModelFields<TSchema extends FarmIntegrationSchema, TModelKey extends PropertyKey> = TModelKey extends keyof SchemaOverrides<TSchema> ? SchemaModelFields<SchemaOverrides<TSchema>[TModelKey]> : {};
+type ResolvedSchemaModelFields<TSchema extends FarmIntegrationSchema, TModelKey extends PropertyKey, TExtendedFields = ExtendedSchemaModelFields<TSchema, TModelKey>, TOverrideFields = OverrideSchemaModelFields<TSchema, TModelKey>> = {
+    [TFieldKey in keyof TExtendedFields | keyof TOverrideFields]: TFieldKey extends keyof TOverrideFields ? TFieldKey extends keyof TExtendedFields ? ReplaceRecord<TExtendedFields[TFieldKey], TOverrideFields[TFieldKey]> : TOverrideFields[TFieldKey] : TFieldKey extends keyof TExtendedFields ? TExtendedFields[TFieldKey] : never;
+};
+type ResolvedFarmIntegrationSchemaModels<TSchema extends FarmIntegrationSchema> = {
+    [TModelKey in (keyof TSchema["models"] | keyof SchemaExtensions<TSchema>) & string]: {
+        fields: ResolvedSchemaModelFields<TSchema, TModelKey>;
+    };
+};
+type InferFarmIntegrationOrmSchema<TSchema extends FarmIntegrationSchema> = SchemaDefinition<{
+    [TModelKey in keyof ResolvedFarmIntegrationSchemaModels<TSchema> & string]: ModelDefinition<InferFarmIntegrationOrmFields<Extract<ResolvedFarmIntegrationSchemaModels<TSchema>[TModelKey], FarmIntegrationOrmModelShape>>, {}>;
+}>;
+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;
+
+declare function isFarmIntegration(value: unknown): value is FarmIntegration;
+/**
+ * @internal Whether an integration's middleware matcher (a `protectedRoutes` guard, say)
+ * covers `pathname`, a route path without the base path. With `catchAllProbe`, a path no
+ * route uses, only matchers naming particular paths count: middleware without a matcher,
+ * or one that also meets the probe, covers every path and is left out.
+ */
+declare function integrationMiddlewareMayHandlePath(integrations: FarmIntegrationsUserConfig | undefined, pathname: string, catchAllProbe?: string): boolean;
+/**
+ * @internal Runtime config key holding the app's same-origin API path. The built server keeps the
+ * user's raw `api` config, whose values may be resolver functions, so the build records the
+ * resolved path here; development configs carry the resolved `api` itself.
+ */
+declare const FARM_INTEGRATION_API_BASE_PATH_KEY = "__farmAPIServerBasePath";
+
+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";
+/**
+ * Request-context key under which an integration middleware can hand
+ * `Set-Cookie` values to the runtime when it returns `void` (i.e. lets the
+ * request continue to the downstream route/page handler). The runtime reads
+ * this key back after a `void` middleware return and forwards the cookies onto
+ * the response it ultimately sends, so a server-side session refresh (or any
+ * other cookie rotation) reaches the browser instead of being dropped.
+ */
+declare const FARM_INTEGRATION_SET_COOKIES_KEY = "farm:integration:set-cookies";
+/**
+ * Forward `Set-Cookie` values from an integration middleware that returns
+ * `void` (the authenticated/passthrough branch) to the runtime, so they are
+ * merged onto the response the runtime sends for the matched route. This is
+ * the passthrough counterpart to appending `Set-Cookie` to a `Response` the
+ * middleware returns directly (e.g. a failure redirect): both paths can rotate
+ * auth cookies, and both must be able to reach the browser.
+ */
+declare function forwardIntegrationSetCookies(context: Pick<FarmIntegrationHandlerContext, "req">, cookies: string[]): void;
+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 FarmIntegrationProviderComponentReference {
+    /** Client-safe module specifier using `@/`, a path relative to the app root, or a package. */
+    module: string;
+    /** Named export to use. Defaults to the module's default export. */
+    export?: string;
+}
+interface FarmIntegrationProvider {
+    name: string;
+    type: string;
+    props?: Record<string, unknown>;
+    /**
+     * The provider can be instantiated independently around each isolated
+     * client root without relying on context or state owned by the route root.
+     * Providers are treated as route-wide unless they explicitly opt in.
+     */
+    supportsIsolatedHydration?: boolean;
+    component?: ComponentType<FarmIntegrationProviderProps> | FarmIntegrationProviderComponentReference;
+}
+interface FarmIntegrationDocumentNavigation {
+    matcher: string | readonly string[];
+}
+/** @deprecated Use `FarmSchemaFieldType`. */
+type FarmIntegrationSchemaFieldType = FarmSchemaFieldType;
+/** @deprecated Use `FarmSchemaReference`. */
+type FarmIntegrationSchemaReference = FarmSchemaReference;
+/** @deprecated Use `FarmSchemaField`. */
+type FarmIntegrationSchemaField = FarmSchemaField;
+/** @deprecated Use `FarmSchemaConstraint`. */
+type FarmIntegrationSchemaConstraint = FarmSchemaConstraint;
+/** @deprecated Use `FarmSchemaModel`. */
+type FarmIntegrationSchemaModel = FarmSchemaModel;
+/** @deprecated Use `FarmSchemaModelExtension`. */
+type FarmIntegrationSchemaModelExtension = FarmSchemaModelExtension;
+/** @deprecated Use `FarmSchemaModelOverride`. */
+type FarmIntegrationSchemaModelOverride = FarmSchemaModelOverride;
+/** @deprecated Use `FarmSchema`. */
+type FarmIntegrationSchema = FarmSchema;
+/** @deprecated Use `defineSchema`. This is an exact alias, not a wrapper. */
+declare const defineIntegrationSchema: typeof defineSchema;
+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>;
+    query<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, "QUERY", 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 resolveIntegrationPlugins(integrations: FarmIntegrationsUserConfig | undefined): FarmPlugin[];
+declare function getIntegrationProviders(integrations: FarmIntegrationsUserConfig | undefined): FarmIntegrationProvider[];
+declare function isFarmIntegrationProviderComponentReference(value: FarmIntegrationProvider["component"]): value is FarmIntegrationProviderComponentReference;
+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;
+    /**
+     * Receives `Set-Cookie` values that a middleware forwarded via
+     * forwardIntegrationSetCookies while returning `void`, when this dispatch
+     * ends without a Response of its own. The request continues downstream, so
+     * the caller owns merging them onto whatever response it finally produces.
+     * Only called on the `null` return path: a Response returned from here has
+     * already had the forwarded cookies appended.
+     */
+    onForwardedCookies?: (cookies: string[]) => void;
+    /**
+     * Middleware entries that already ran for this request, shared across dispatches. A
+     * `ctx.rewrite()` target is guarded by a second dispatch, which skips these so each guard runs
+     * at most once per request, as app middleware does.
+     */
+    ranMiddleware?: Set<object>;
+    /** The peer address the server adapter reports, used unless `server.trustProxy` applies. */
+    clientAddress?: string;
+}): Promise<Response | null>;
+/**
+ * Run every configured integration's middleware and routes for one request.
+ *
+ * Integration middleware is not route scoped: it is the mechanism behind
+ * `protectedRoutes` guards and provider session refresh, so it has to run for
+ * ordinary page and API requests that match no integration route at all. That
+ * makes this, not `matchIntegrationRoute`, the correct entry point for a
+ * runtime dispatching integrations for every request.
+ *
+ * The first integration that produces a Response short-circuits the rest.
+ * `Set-Cookie` values forwarded by middleware that returned `void` are
+ * collected: they ride the short-circuiting Response when there is one, and are
+ * otherwise handed back so the caller can merge them onto the downstream
+ * response.
+ */
+declare function dispatchIntegrationRequests(integrations: FarmIntegrationsUserConfig | undefined, runtime: Omit<RegisteredIntegrationRuntime, "integration">, request: Request, options?: {
+    currentRequest?: Request;
+    ranMiddleware?: Set<object>;
+    clientAddress?: string;
+}): Promise<{
+    response: Response | null;
+    setCookies: string[];
+}>;
+
+export { type FarmPluginDefinition as $, type FarmRouteMaxDuration as A, type BundleResultPayload as B, type FarmRedirectSignal as C, type FarmRedirectStatus as D, getFarmRedirectError as E, type FarmPlugin as F, isFarmNotFoundError as G, isFarmRedirectError as H, notFound as I, permanentRedirect as J, redirect as K, type LayoutProps as L, type Metadata as M, loadConfig as N, resolveConfig as O, type ParsedRoute as P, resolveDeployConfig as Q, type ResolvedFarmDesktopConfig as R, type APIHandlerLifecyclePayload as S, type APIRouteDiscoveredPayload as T, type BundleLifecyclePayload as U, type ErrorLifecyclePayload as V, FARM_NODE_RESPONSE_END_PENDING as W, type FarmDevtoolsUserConfig as X, type FarmPluginBuildHooks as Y, type FarmPluginClientConfig as Z, type FarmPluginDatabase as _, type FarmIntegration as a, type FarmIsolatedClientHydrationMode as a$, type FarmPluginDevHooks as a0, type FarmPluginDiscoveredRoute as a1, type FarmPluginIntegrationContext as a2, type FarmPluginLifecycle as a3, type FarmPluginRenderHooks as a4, type FarmPluginRouteRuntimePayload as a5, type FarmPluginRouterHooks as a6, type FarmPluginRuntimeAfterEvent as a7, type FarmPluginRuntimeBaseEvent as a8, type FarmPluginRuntimeBeforeEvent as a9, type RoutesGeneratedPayload as aA, type ShutdownPayload as aB, definePlugin as aC, resolveFarmDevtoolsConfig as aD, type MiddlewareProps as aE, type FarmContextFactory as aF, type FarmMCPCatalogDetails as aG, type ResolvedFarmAppManifestConfig as aH, type ReadonlyMiddlewareStore as aI, type FarmMiddlewareConfig as aJ, type MiddlewareModule as aK, type MiddlewareConfig$1 as aL, type MiddlewareContext as aM, type FarmServerComponentsMode as aN, type ResolvedFarmConfig as aO, type SSGCollectionResult as aP, type SSGPage as aQ, type FarmAgentJsonLd as aR, type FarmMCPServerRegistration as aS, type FarmMarkdownResolvedConfig as aT, type FarmConfig as aU, type AppRoutePattern as aV, type BuildOptions as aW, type ErrorBoundary as aX, type ErrorProps as aY, type FarmComponentType as aZ, type FarmContextFactoryInput as a_, type FarmPluginRuntimeCloseEvent as aa, type FarmPluginRuntimeContextEvent as ab, type FarmPluginRuntimeEndpoint as ac, type FarmPluginRuntimeEndpointEvent as ad, type FarmPluginRuntimeErrorEvent as ae, type FarmPluginRuntimeHooks as af, type FarmPluginRuntimeKind as ag, type FarmPluginRuntimeRequestHandler as ah, type FarmPluginRuntimeRequestOptions as ai, type FarmPluginRuntimeSession as aj, type FarmPluginRuntimeStartEvent as ak, type FarmPluginSetupContext as al, type FarmPluginStateContext as am, type FarmRequestPluginContext as an, type FarmRequestStore as ao, FarmRuntimeShutdownError as ap, type HMRUpdatePayload as aq, type MiddlewareDiscoveredPayload as ar, type NitroBuildLifecyclePayload as as, PluginManager as at, type PluginRequestContext as au, type RenderLifecyclePayload as av, type ResolvedFarmDevtoolsConfig as aw, type RouteDiscoveredPayload as ax, type RouteMatchPayload as ay, type RouteMatchResultPayload as az, type FarmDesktopConfigInput as b, type FarmAppManifestConfig as b$, type FarmMCPUserConfig as b0, type FarmMigrationCommand as b1, type FarmMigrationsConfig as b2, type FarmMigrationsUserConfig as b3, type GenerateStaticParams as b4, type Layout as b5, type LayoutMetadataProps as b6, type LayoutModule as b7, type Loading as b8, type LoadingProps as b9, type ResolvedFarmPerformanceConfig as bA, type ResolvedFarmSecurityConfig as bB, type ResolvedSchemaField as bC, type FarmSqlStatement as bD, type FarmSqlDialect as bE, type CollectedSchemaModel as bF, type FarmSchemaMigrationStep as bG, type OpenAPIConfig as bH, type ApplyMarkdownNegotiationHeadersOptions as bI, type CookieJar as bJ, type CookieOptions as bK, type CreateIntegrationOrmOptions as bL, type CreateMarkdownMirrorResponseOptions as bM, DEFAULT_FARM_API_BASE_PATH as bN, DEFAULT_FARM_DEVTOOLS_SHORTCUT as bO, type DefinedIntegration as bP, FARM_DEVTOOLS_LAUNCH_PARAM as bQ, FARM_DEVTOOLS_PATH as bR, FARM_INTEGRATION_API_BASE_PATH_KEY as bS, FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY as bT, FARM_INTEGRATION_SET_COOKIES_KEY as bU, FARM_MARKDOWN_PAGE_CHECK_HEADER as bV, type FarmAPIConfig as bW, type FarmAPIConfigResolverContext as bX, type FarmAPIConfigValue as bY, type FarmAgentCrawlers as bZ, type FarmAgentUserConfig as b_, type MetadataJsonLd as ba, type MetadataProps as bb, type MetadataRobots as bc, type MetadataRobotsDirectives as bd, type NitroPreset as be, type Page as bf, type PagePropsWithMiddleware as bg, type PageRouteParams as bh, type ResolvedFarmMigrationsConfig as bi, type ServerAction as bj, type StaticPathParams as bk, type StaticPathPrimitive as bl, type StaticRouteParams as bm, type ThemeColorDescriptor as bn, type Viewport as bo, resolveFarmMCPConfig as bp, resolveFarmMCPPlugin as bq, _findFarmMCPEndpointTool as br, _publishFarmMCPCatalog as bs, registerFarmMCPServer as bt, type ResolvedFarmRouteRuntimeConfig as bu, type ApplicationMetadataRouteKind as bv, type ResolvedFarmAPIConfig as bw, type FarmDocsResolvedConfig as bx, type ResolvedFarmDevIndicatorsConfig as by, type ResolvedFarmAuthConfig as bz, type FarmDesktopContext as c, type FarmIntegrationRoutesFactory as c$, type FarmAuthConfig as c0, type FarmAuthDatabaseConfig as c1, type FarmAuthEmailAndPasswordConfig as c2, type FarmAuthSessionConfig as c3, type FarmAuthUserConfig as c4, type FarmBuildActivityPosition as c5, type FarmCrawlerPolicy as c6, type FarmCspConfig as c7, type FarmCspDirectiveValue as c8, type FarmCspDirectives as c9, type FarmIntegrationLifecycleLogLevel as cA, type FarmIntegrationLifecycleLogger as cB, type FarmIntegrationLogEvent as cC, type FarmIntegrationLogPhase as cD, type FarmIntegrationLogger as cE, type FarmIntegrationMiddleware as cF, type FarmIntegrationOrmClient as cG, type FarmIntegrationOrmSchema as cH, type FarmIntegrationPluginOwner as cI, type FarmIntegrationProvider as cJ, type FarmIntegrationProviderComponentReference as cK, type FarmIntegrationProviderProps as cL, type FarmIntegrationRequestContextStore as cM, type FarmIntegrationRoute as cN, type FarmIntegrationRouteArgs as cO, type FarmIntegrationRouteDb as cP, type FarmIntegrationRouteFactory as cQ, type FarmIntegrationRouteHook as cR, type FarmIntegrationRouteHookContext as cS, type FarmIntegrationRouteInput as cT, type FarmIntegrationRouteInputSchemas as cU, type FarmIntegrationRouteInputSource as cV, type FarmIntegrationRouteMethod as cW, type FarmIntegrationRouteMiddleware as cX, type FarmIntegrationRouteParamValue as cY, type FarmIntegrationRouteParams as cZ, type FarmIntegrationRouteStorageArgs as c_, type FarmCspOptions as ca, type FarmDeployConfig as cb, type FarmDeployTarget as cc, type FarmDevIndicatorsConfig as cd, type FarmDevtoolsConfig as ce, type FarmDocsConfigInput as cf, type FarmDocsNavigationConfig as cg, type FarmDocsSidebarItem as ch, type FarmDocsSocialImageConfig as ci, type FarmDocsSocialImageFonts as cj, type FarmDocsUserConfig as ck, type FarmIntegrationCategory as cl, type FarmIntegrationConfigContext as cm, type FarmIntegrationConfigDefinition as cn, type FarmIntegrationConfigInput as co, type FarmIntegrationContributedPlugin as cp, type FarmIntegrationData as cq, type FarmIntegrationDocumentNavigation as cr, type FarmIntegrationEndpointValue as cs, type FarmIntegrationEndpoints as ct, type FarmIntegrationEndpointsFactory as cu, type FarmIntegrationEndpointsFactoryContext as cv, type FarmIntegrationHandlerContext as cw, type FarmIntegrationInputSchema as cx, type FarmIntegrationLifecycleContext as cy, type FarmIntegrationLifecycleHook as cz, type FarmDesktopUserConfig as d, type FarmTypedIntegrationRoute as d$, type FarmIntegrationRoutesFactoryContext as d0, type FarmIntegrationSchema as d1, type FarmIntegrationSchemaConstraint as d2, type FarmIntegrationSchemaField as d3, type FarmIntegrationSchemaFieldType as d4, type FarmIntegrationSchemaModel as d5, type FarmIntegrationSchemaModelExtension as d6, type FarmIntegrationSchemaModelOverride as d7, type FarmIntegrationSchemaReference as d8, type FarmIntegrationSlot as d9, type FarmMarkdownMirrorTarget as dA, type FarmMarkdownResolvedRoute as dB, type FarmMarkdownRouteInput as dC, type FarmMarkdownUserConfig as dD, type FarmPageFormAction as dE, type FarmPageFormField as dF, type FarmPageFormOption as dG, type FarmPageFormSubmit as dH, type FarmPerformanceConfig as dI, type FarmPluginFactory as dJ, FarmPluginOptionsError as dK, type FarmPluginOptionsIssue as dL, type FarmPluginOptionsSchema as dM, type FarmPreloadMode as dN, type FarmPreloadUserConfig as dO, type FarmRouteRenderingMode as dP, type FarmRouteRule as dQ, type FarmRouteRuleCors as dR, type FarmRouteRuleRedirect as dS, type FarmRouteRuleRenderMode as dT, type FarmRouteRules as dU, type FarmRouteRuntimeEntryKind as dV, type FarmRouteRuntimeManifest as dW, type FarmRouteRuntimeManifestEntry as dX, type FarmSecurityConfig as dY, type FarmServerComponentsConfig as dZ, type FarmServerComponentsOptions as d_, type FarmIntegrationStandardValidationResult as da, type FarmIntegrationValidationErrorLike as db, type FarmIntegrationValidationIssue as dc, type FarmIntegrationValidationPathSegment as dd, type FarmIntegrationValidationResult as de, type FarmIntegrationsUserConfig as df, type FarmLayerConfig as dg, type FarmMCPAuthorization as dh, type FarmMCPAuthorizeContext as di, type FarmMCPConfig as dj, type FarmMCPEndpoint as dk, type FarmMCPEndpointTool as dl, type FarmMCPExecuteContext as dm, type FarmMCPOAuthConfig as dn, type FarmMCPPrompt as dp, type FarmMCPPromptMessage as dq, type FarmMCPResource as dr, type FarmMCPResourceContent as ds, type FarmMCPResourceContext as dt, type FarmMCPResourceListing as du, type FarmMCPServer as dv, type FarmMCPServerFunction as dw, type FarmMCPStandaloneTool as dx, type FarmMCPTool as dy, type FarmMCPToolDefinition as dz, type FarmDesktopWindowConfig as e, getFarmMarkdownMirrorPath as e$, type HeaderConfig as e0, type I18nConfig as e1, type ImageConfig as e2, type InferFarmIntegrationOrmClient as e3, type InferFarmIntegrationOrmField as e4, type InferFarmIntegrationOrmFields as e5, type InferFarmIntegrationOrmSchema as e6, type InferPluginOptionsInput as e7, type InferPluginOptionsOutput as e8, type IntegrationOriginPolicy as e9, _getFarmMarkdownPageCheckToken as eA, _isFarmMarkdownPageCheck as eB, applyMarkdownNegotiationHeaders as eC, collectSchemaModels as eD, createFarmRouteRuntimeKey as eE, createIntegrationOrm as eF, createIntegrationRoute as eG, createMarkdownMirrorResponse as eH, defineIntegration as eI, defineIntegrationSchema as eJ, describeIntegrationOriginRejection as eK, describeSchemaReference as eL, dispatchIntegrationRequest as eM, dispatchIntegrationRequests as eN, escapeSqlString as eO, extractFarmPageActions as eP, farmAcceptQuality as eQ, farmIntegrationSchemaToOrmSchema as eR, farmRouteRuleMatches as eS, forwardIntegrationSetCookies as eT, generateFarmDevIndicatorsClientRuntime as eU, generateSqlStatements as eV, getDeployTargetForPreset as eW, getFarmAPIBaseURL as eX, getFarmIntegrationPluginOwner as eY, getFarmIntegrationPluginServerRuntime as eZ, getFarmMarkdownAlternatePath as e_, type IntegrationOriginRejection as ea, type IntegrationOriginResult as eb, type IntegrationOrmModelNames as ec, type MemoryRateLimitStorageOptions as ed, MetadataRoute as ee, type MetadataRouteContext as ef, type MiddlewareChain as eg, type MiddlewareConfig as eh, type MiddlewareFunction as ei, type MiddlewareResult as ej, type MiddlewareStore as ek, type NextFunction as el, type RateLimitConfig as em, type RateLimitIncrementResult as en, type RateLimitStatus as eo, type RateLimitStorage as ep, type RedirectConfig as eq, type RequestMiddleware as er, type RequestMiddlewareContext as es, type ResolveMarkdownMirrorTargetOptions as et, type ResolvedFarmCspConfig as eu, type ResolvedFarmDeployConfig as ev, type ResolvedFarmMCPConfig as ew, type ResolvedFarmPreloadConfig as ex, type ResolvedSchemaModel as ey, type RewriteConfig as ez, type FarmRouteRuntimeConfig as f, manageFarmDocumentPreloads as f$, getFarmRouteRuntimeConfig as f0, getIntegrationDocumentNavigationMatchers as f1, getIntegrationProviders as f2, getIntegrationSchemas as f3, getPresetForDeployTarget as f4, getRegisteredIntegrationAPIManifest as f5, getRegisteredIntegrationRuntime as f6, getRegisteredIntegrationSchemas as f7, getRegisteredIntegrations as f8, getSqlColumnType as f9, resolveFarmRouteRuntimeConfig as fA, resolveIntegrationAllowedOrigins as fB, resolveIntegrationOrmRuntimeClient as fC, resolveIntegrationPlugins as fD, resolveMarkdownConfig as fE, resolveMarkdownMirrorTarget as fF, resolveMigrationsConfig as fG, resolveSchemaModels as fH, routeRulesToHeaders as fI, routeRulesToNitroRouteRules as fJ, routeRulesToRedirects as fK, toCamelCase as fL, toPascalCase as fM, toSnakeCase as fN, validateIntegrationRequestOrigin as fO, type FarmLlmsTxtLink as fP, type FarmLlmsTxtUserConfig as fQ, type ResolvedFarmLlmsTxtConfig as fR, applyFarmCspNonceToResponse as fS, collectFarmLlmsTxtPages as fT, createFarmAgentRobots as fU, createFarmCspNonce as fV, createFarmDefaultLlmsTxt as fW, createFarmDefaultSitemap as fX, createFarmLlmsFullRenderer as fY, createFarmLlmsMarkdownReader as fZ, createFarmMetadataRouteResponse as f_, getSqlDefaultExpression as fa, hasFarmRouteRuntimeControls as fb, htmlToMarkdown as fc, integrationMiddlewareMayHandlePath as fd, integrationRoute as fe, isFarmIntegration as ff, isFarmIntegrationProviderComponentReference as fg, isFarmMarkdownMirrorExposed as fh, isNullableField as fi, matchIntegrationRoute as fj, matchRegisteredIntegrationRoute as fk, matchesFarmMarkdownRoutePattern as fl, mergeFarmRouteRuntimeConfigs as fm, normalizeDeployTarget as fn, normalizeFarmAPIBasePath as fo, normalizeFarmAPIConfig as fp, normalizeFarmRouteRuntimeConfig as fq, normalizeRouteRules as fr, quoteSqlIdentifier as fs, renderSqlSchemaFile as ft, requestAcceptsMarkdown as fu, resolveDeployOutputPath as fv, resolveFarmAPIConfig as fw, resolveFarmAPIRequestURL as fx, resolveFarmDevIndicatorsConfig as fy, resolveFarmRouteRuleRuntimeConfig as fz, type FarmMdxComponents as g, manageFarmHtmlPreloads as g0, manageFarmLinkHeaderPreloads as g1, renderFarmLlmsFullTxt as g2, reportFarmPreloadWarnings as g3, resolveFarmLlmsTxtConfig as g4, resolveFarmSecurityConfig as g5, stampFarmCspNonce as g6, type FarmDesktopDevSession as g7, type FarmDesktopSetupOptions as g8, createFarmDesktopContext as g9, getFarmDesktopOutputDirs as ga, installFarmDesktopSetup as gb, resolveFarmDesktopBlock as gc, resolveFarmDesktopConfig as gd, setFarmDesktopDevSession as ge, validateFarmDesktopConfig as gf, type FarmMdxResolvedConfig as h, type RouteModule as i, FARM_MARKDOWN_CONTENT_TYPE as j, createFarmMarkdownErrorBody as k, farmRequestWantsMarkdown as l, type FarmMdxComponent as m, type FarmMdxUserConfig as n, resolveMdxConfig as o, type FarmUserConfig as p, type RouteSegment as q, resolveFarmMdxComponentsModulePath as r, type FarmRequest as s, type FarmResponse as t, type FarmPluginContext as u, type FarmAppContext as v, type PageProps as w, type PluginContextProps as x, type FarmRouteRuntime as y, type FarmRouteRegions as z };