@farm.js/core 0.1.26 → 0.1.28

package/dist/{client-plugins-bPBf4haK.d.ts → client-plugins-Fl9Og3yB.d.ts}

@@ -1,13 +1,14 @@
 import { n as FarmClientPlugin } from './lifecycle-DK06VuKP.js';
-import { R as RouteMethod, g as PluginRoutes, P as PluginRoutesFactory } from './route-DOEpbyWZ.js';
-import { T as TypedEndpoint, d as EndpointMCPMetadata, R as RouteSchema, a as RouteSchemaOutput, c as RouteSchemaInput, Y as OpenAPISecurityMode } from './endpoint-1zA994xL.js';
+import { F as FarmIntegrationAPI, e as FarmIntegrationAPIMethod, c as FarmIntegrationAPIBodyFormat, f as FarmIntegrationAPIOperation, g as FarmIntegrationAPIResponseFormat, h as FarmIntegrationRouteOperationCarrier, I as InferIntegrationAPIFromRoutes, p as PluginRoutes, P as PluginRoutesFactory, R as RouteMethod } from './integration-api-BPJo5oXb.js';
+import { Y as OpenAPISecurityMode, T as TypedEndpoint, E as EndpointMCPMetadata, R as RouteSchema, b as RouteSchemaOutput, d as RouteSchemaInput } from './endpoint-CA-TNX60.js';
 import { FarmRenderer } from './renderer.js';
 import { IncomingMessage, ServerResponse } from 'http';
-import { FarmMarkdownResolvedConfig, FarmMarkdownUserConfig } from './markdown.js';
+import { ServerFn } from './server-fn.js';
+import { ServerQuery } from './server-query.js';
+import { g as FarmI18nUserConfig, R as ResolvedFarmI18nConfig } from './types-Z0aotQ8w.js';
 import { d as FarmStorageUserConfig } from './types-Cc8l9IqS.js';
 import { FarmSchemaField, FarmSchema, FarmSchemaModel, FarmSchemaReference, FarmSchemaFieldType, FarmSchemaConstraint, FarmSchemaModelExtension, FarmSchemaModelOverride, defineSchema, FarmSchemaConfig } from './schema.js';
 import React__default, { ComponentType, ReactNode } from 'react';
-import { F as FarmIntegrationAPI, e as FarmIntegrationAPIMethod, c as FarmIntegrationAPIBodyFormat, f as FarmIntegrationAPIOperation, g as FarmIntegrationAPIResponseFormat, h as FarmIntegrationRouteOperationCarrier, I as InferIntegrationAPIFromRoutes } from './integration-api-BbaiokCC.js';
 import { OrmClient, SchemaDefinition, ModelDefinition, FieldBuilder, JsonValue, AnyModelDefinition, SchemaModels } from '@farming-labs/orm';
 import { a as FarmDocsUserConfig, F as FarmDocsResolvedConfig } from './types-DFbjpjXX.js';
 import { L as FarmObservabilityUserConfig } from './observability-BupkiN0m.js';
@@ -20,377 +21,281 @@ import { FarmServerActionsConfig, ResolvedFarmServerActionsConfig } from './serv
 import * as rolldown_utils from 'rolldown/utils';
 import { Plugin } from 'rolldown';
 import { F as FarmImageConfig, R as ResolvedFarmImageConfig } from './image-config-Duob7wER.js';
-import { g as FarmI18nUserConfig, R as ResolvedFarmI18nConfig } from './types-Z0aotQ8w.js';
 import { FarmCacheUserConfig } from './cache.js';
-import { ServerFn } from './server-fn.js';
-import { ServerQuery } from './server-query.js';
 import { R as ResolvedFarmThemeConfig, d as FarmThemeConfig } from './types-DQnyD3VD.js';
 import { FarmLayoutFonts } from './font.js';
 import { _withAfterNodeMiddleware } from './after.js';
 import { F as FarmIslandStrategy } from './island-CfGru1MO.js';
 
-interface FarmLlmsTxtLink {
-    title: string;
-    url: string;
-    description?: string;
+/** @internal The environment registry is owned and closed by Vite. */
+interface FarmDevModuleServer {
+    environments: Record<string, unknown>;
 }
-interface FarmLlmsTxtSection {
-    title: string;
-    links: FarmLlmsTxtLink[];
+/** @internal Distinguishes an unsupported runtime from a module evaluation error. */
+declare class FarmDevEnvironmentError extends Error {
 }
-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[];
+/** @internal Load in the selected environment without sharing SSR/RSC module state. */
+declare function loadFarmDevModule<T = Record<string, any>>(server: FarmDevModuleServer, id: string, environmentName?: "ssr" | "rsc"): Promise<T>;
+
+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;
 }
-/** 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;
+type FarmDevtoolsUserConfig = boolean | FarmDevtoolsConfig;
+interface ResolvedFarmDevtoolsConfig {
+    enabled: boolean;
+    shortcut: string | false;
 }
-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[];
+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;
     /**
-     * Also serve `/llms-full.txt`, the index with each page's Markdown mirror inlined.
-     *
-     * @default true
+     * 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.
      */
-    full?: boolean;
+    referenceTargets?: Record<string, {
+        table: string;
+        column: string;
+    }>;
     /**
-     * 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.
+     * 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.
      */
-    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 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;
-}): FarmLlmsTxt;
+    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;
 /**
- * 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.
+ * 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 createFarmLlmsMarkdownReader(fetchMarkdown: (request: Request) => Promise<Response>): (url: string) => Promise<string | null>;
+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;
+};
 /**
- * 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.
+ * 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 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>;
+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;
+
 /**
- * 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.
+ * 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.
  */
-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 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;
+});
 
-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;
+/**
+ * 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;
 }
-interface FarmMetadataRouteModule {
-    revalidate?: number | false;
+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;
+    };
 }
-interface FarmMetadataRouteResponseOptions {
-    method?: string;
-    /** The request being answered, so llms.txt reads can be reported as agent traffic. */
-    request?: Request;
+/** 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>);
 }
-/** @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 ResolvedClientCacheAdapterEntry {
+    /** Absolute adapter module path with forward slashes, ready for codegen. */
+    importPath: string;
+    options: {
+        version?: string;
+        flushDelayMs?: number;
+    };
 }
-interface ResolvedFarmAgentCrawlers {
-    enabled: boolean;
-    search?: FarmCrawlerPolicy;
-    training?: FarmCrawlerPolicy;
-    rules: MetadataRoute.RobotsRule[];
-    sitemap?: string[];
+interface ClientCachePersistenceEntryCode {
+    imports: string;
+    init: 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;
+/**
+ * Resolve `cache.client.adapter` from configuration to an absolute module
+ * path for the generated client entries. Fails the build with an actionable
+ * error when the option is set but the module cannot be found.
+ */
+declare function resolveFarmClientCacheAdapterEntry(root: string, cache: FarmCacheUserConfig | undefined): ResolvedClientCacheAdapterEntry | undefined;
+/**
+ * Code fragments for the generated client entries: an import of the user's
+ * adapter module and an init call that runs before hydration starts. Empty
+ * strings when persistence is not configured, so entries stay unchanged.
+ */
+declare function generateClientCachePersistenceCode(entry: ResolvedClientCacheAdapterEntry | undefined): ClientCachePersistenceEntryCode;
+
+type FarmRedirectStatus = 301 | 302 | 303 | 307 | 308;
+interface FarmRedirectSignal {
+    url: string;
+    status: FarmRedirectStatus;
 }
-/** The robots.txt `agent.crawlers` serves. */
-declare function createFarmAgentRobots(options: FarmAgentRobotsOptions): MetadataRoute.Robots;
+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;
 
 /**
- * Agent-readiness configuration: opt-in primitives that make a Farm site easier
- * for AI agents and crawlers to discover, resolve, and use. Off by default so
- * sites that do not want agent exposure (internal tools, private dashboards) are
- * unaffected.
+ * 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.
  */
-
-/** schema.org JSON-LD emitted in the document head to identify the site. */
-interface FarmAgentJsonLd {
+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[];
     /**
-     * schema.org `@type`. Common values: `"Organization"` for a company or
-     * project, `"SoftwareApplication"` for a product, `"WebSite"`, `"Person"`.
+     * Whether a request carrying no origin metadata at all must be rejected.
      *
-     * @default "Organization"
+     * 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.
      */
-    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. `true` emits an `Organization` built from the
-     * site's metadata; an object customizes the type and fields.
-     *
-     * @default false
-     */
-    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;
-     * an object sets the title, summary, details, and which routes to list. A
-     * `src/app/llms.ts` metadata route replaces the generated file.
-     *
-     * @default false
-     */
-    llmsTxt?: boolean | FarmLlmsTxtUserConfig;
-    /**
-     * 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;
-}
-interface ResolvedFarmAgentConfig {
-    jsonLd: FarmAgentJsonLd | false;
-    noindexPreviews: boolean;
-    llmsTxt: ResolvedFarmLlmsTxtConfig;
-    crawlers: ResolvedFarmAgentCrawlers;
-    apiCatalog: boolean;
-}
-
-/**
- * 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;
+    requireOriginMetadata?: boolean;
 }
 /**
  * Resolve configured origin patterns once, at integration construction, so an
@@ -455,499 +360,755 @@ declare function resolveIntegrationOrmRuntimeClient<TClient = unknown>(options:
 declare function farmIntegrationSchemaToOrmSchema(schema: FarmIntegrationSchema): Promise<FarmIntegrationOrmSchema>;
 type IntegrationOrmModelNames<TSchema extends FarmIntegrationOrmSchema> = keyof SchemaModels<TSchema> & string;
 
-/** @internal The environment registry is owned and closed by Vite. */
-interface FarmDevModuleServer {
-    environments: Record<string, unknown>;
+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$1<T> = T | Promise<T>;
+type FarmIntegrationValidationPathSegment = PropertyKey | {
+    readonly key: PropertyKey;
+};
+interface FarmIntegrationRouteInput<TBody = unknown, TQuery = unknown> {
+    body?: TBody;
+    query?: TQuery;
 }
-/** @internal Distinguishes an unsupported runtime from a module evaluation error. */
-declare class FarmDevEnvironmentError extends Error {
+interface FarmIntegrationValidationIssue {
+    source: FarmIntegrationRouteInputSource;
+    path?: readonly (string | number)[];
+    code?: string;
+    message: string;
 }
-/** @internal Load in the selected environment without sharing SSR/RSC module state. */
-declare function loadFarmDevModule<T = Record<string, any>>(server: FarmDevModuleServer, id: string, environmentName?: "ssr" | "rsc"): Promise<T>;
-
-type ResolvedSchemaField = FarmSchemaField & {
-    name: 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 ResolvedSchemaModel = Omit<FarmSchemaModel, "fields"> & {
-    name: string;
-    fields: Record<string, ResolvedSchemaField>;
+type FarmIntegrationStandardValidationResult<TValue> = {
+    value: TValue;
+} | {
+    issues: readonly {
+        path?: readonly FarmIntegrationValidationPathSegment[];
+        code?: string;
+        message: string;
+    }[];
 };
+interface FarmIntegrationInputSchema<TValue = unknown> {
+    _output?: TValue;
+    parse?(value: unknown): MaybePromise$1<TValue>;
+    safeParse?(value: unknown): MaybePromise$1<FarmIntegrationValidationResult<TValue>>;
+    safeParseAsync?(value: unknown): Promise<FarmIntegrationValidationResult<TValue>>;
+    "~standard"?: {
+        validate(value: unknown): MaybePromise$1<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";
 /**
- * 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.
+ * 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 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;
+declare const FARM_INTEGRATION_SET_COOKIES_KEY = "farm:integration:set-cookies";
 /**
- * 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.
+ * 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 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;
-};
+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$1<Partial<TConfig>>);
+    input?: Partial<TConfig> | ((context: FarmIntegrationConfigContext<TSchema>) => MaybePromise$1<Partial<TConfig>>);
+    resolve?(context: FarmIntegrationConfigContext<TSchema>): MaybePromise$1<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$1<void>): Promise<void>;
+}
+type FarmIntegrationLifecycleHook<TConfig = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = (context: FarmIntegrationLifecycleContext<TConfig, TSchema>) => MaybePromise$1<void>;
 /**
- * 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.
+ * Small per-call integration metadata. Values received over HTTP are
+ * client-controlled and should be validated before authorization decisions.
  */
-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;
+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;
     };
-} | {
-    renameTable: {
-        from: string;
-        to: string;
+    route: {
+        kind: "route" | "middleware";
+        path: string;
+        methods: readonly string[];
     };
+    req: FarmRequestStore;
+    /** @deprecated Use `req` instead. */
+    requestContext: FarmRequestStore;
+    config: FarmPluginContext["config"];
+    isDev: boolean;
+    isProd: boolean;
 }
-/**
- * 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;
+interface FarmIntegrationRouteHookContext<TBody = unknown, TQuery = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationHandlerContext<TBody, TQuery, TSchema> {
+    response?: Response;
 }
-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;
-    };
+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;
 }
-/** 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>);
+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 ResolvedClientCacheAdapterEntry {
-    /** Absolute adapter module path with forward slashes, ready for codegen. */
-    importPath: string;
-    options: {
-        version?: string;
-        flushDelayMs?: number;
-    };
+interface FarmIntegrationRouteMiddleware<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, TSchema>): Promise<Response | void> | Response | void;
 }
-interface ClientCachePersistenceEntryCode {
-    imports: string;
-    init: string;
+interface FarmIntegrationMiddleware<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    matcher?: string | string[];
+    handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, TSchema>): Promise<Response | void> | Response | void;
 }
-/**
- * Resolve `cache.client.adapter` from configuration to an absolute module
- * path for the generated client entries. Fails the build with an actionable
- * error when the option is set but the module cannot be found.
- */
-declare function resolveFarmClientCacheAdapterEntry(root: string, cache: FarmCacheUserConfig | undefined): ResolvedClientCacheAdapterEntry | undefined;
-/**
- * Code fragments for the generated client entries: an import of the user's
- * adapter module and an init call that runs before hydration starts. Empty
- * strings when persistence is not configured, so entries stay unchanged.
- */
-declare function generateClientCachePersistenceCode(entry: ResolvedClientCacheAdapterEntry | undefined): ClientCachePersistenceEntryCode;
-
-type FarmRedirectStatus = 301 | 302 | 303 | 307 | 308;
-interface FarmRedirectSignal {
-    url: string;
-    status: FarmRedirectStatus;
+interface FarmIntegrationProviderProps {
+    children: ReactNode;
 }
-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;
-
-/**
- * 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 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 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;
+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;
 }
-/**
- * Middleware function signature
- */
-type MiddlewareFunction = (ctx: MiddlewareContext, next: NextFunction) => MiddlewareResult | Promise<MiddlewareResult>;
-/**
- * Context passed to a named, request-first middleware export.
- * `locals` and the get/set helpers stay on the server. `data` can be exposed
- * through page props and should contain only serializable, client-safe values.
- */
-interface RequestMiddlewareContext<TLocals extends Record<string, any> = Record<string, any>, TData extends Record<string, any> = Record<string, any>> {
-    readonly url: URL;
-    readonly pathname: string;
-    readonly searchParams: URLSearchParams;
-    readonly method: string;
-    readonly params: Record<string, string>;
-    readonly route: string;
-    readonly locals: MiddlewareStore<TLocals>;
-    readonly data: MiddlewareStore<TData>;
-    readonly headers: Map<string, string>;
-    readonly cookies: CookieJar;
-    get<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): TLocals[TKey] | undefined;
-    has<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): boolean;
-    set<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey, value: TLocals[TKey]): void;
-    delete<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): boolean;
-    redirect(url: string, status?: number): void;
-    rewrite(url: string): void;
-    json(data: any, status?: number): void;
-    text(content: string, status?: number): void;
-    html(content: string, status?: number): void;
+interface FarmIntegrationDocumentNavigation {
+    matcher: string | readonly string[];
 }
-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;
+/** @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>;
 }
-/**
- * Middleware configuration
- */
-type MiddlewareMatcher = string | RegExp | ((ctx: MiddlewareContext) => boolean);
-interface MiddlewareConfig$1 {
-    matcher?: MiddlewareMatcher | MiddlewareMatcher[];
-    exclude?: (string | RegExp)[];
-    runtime?: "nodejs" | "edge";
+type FarmIntegrationLogger = (event: FarmIntegrationLogEvent) => void | Promise<void>;
+interface FarmIntegrationPluginOwner {
+    key: string;
+    category: FarmIntegrationCategory;
+    type: string;
+    source: "lifecycle" | "contribution";
+    serverRuntime: boolean;
 }
-interface MiddlewareConfigEntry extends MiddlewareConfig$1 {
-    handler?: MiddlewareFunction;
-    handlers?: MiddlewareFunction[];
+/** 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 FarmMiddlewareConfig = MiddlewareConfig$1 | MiddlewareConfigEntry | MiddlewareConfigEntry[];
-/**
- * Middleware context - the main object passed to middleware functions
- */
-interface MiddlewareContext {
-    request: IncomingMessage;
-    response: ServerResponse;
-    url: URL;
-    pathname: string;
-    searchParams: URLSearchParams;
-    method: string;
-    params: Record<string, string>;
-    route: string;
-    parent?: {
-        data: Map<string, any>;
-        locals?: Map<string, any>;
-        headers: Record<string, string>;
-    };
-    vite: {
-        isDev: boolean;
-        hmr: boolean;
-        server?: ViteDevServer;
-    };
-    data: Map<string, any>;
-    locals: Map<string, any>;
-    headers: Map<string, string>;
-    cookies: CookieJar;
-    _handled: boolean;
-    _redirectUrl?: string;
-    _rewriteUrl?: string;
-    redirect(url: string, status?: number): void;
-    rewrite(url: string): void;
-    json(data: any, status?: number): void;
-    text(content: string, status?: number): void;
-    html(content: string, status?: number): void;
+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>;
 }
-/**
- * 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;
-    };
+interface FarmIntegrationRoutesFactoryContext<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    route: FarmIntegrationRouteFactory<TSchema>;
+    integrationRoute: FarmIntegrationRouteFactory<TSchema>;
 }
-/**
- * Middleware module export
- */
-interface MiddlewareModule {
-    default?: MiddlewareChain | MiddlewareFunction;
-    middleware?: RequestMiddleware;
-    config?: MiddlewareConfig$1;
+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 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;
+type FarmIntegrationEndpointsFactory<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = (context: FarmIntegrationEndpointsFactoryContext<TSchema>) => FarmIntegrationEndpoints<TSchema>;
+declare function createIntegrationRoute<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined>(_schema?: TSchema): FarmIntegrationRouteFactory<TSchema>;
+declare const integrationRoute: FarmIntegrationRouteFactory<undefined>;
+type RegisteredIntegrationRuntime = {
+    integration: FarmIntegration;
+    config: FarmPluginContext["config"];
+    isDev: boolean;
+    isProd: boolean;
+};
+type FarmIntegrationRoutesInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = readonly FarmIntegrationRoute<any, any, TSchema>[] | FarmIntegrationRoutesFactory<TSchema>;
+type FarmIntegrationEndpointsInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = FarmIntegrationEndpoints<TSchema> | FarmIntegrationEndpointsFactory<TSchema>;
+type FarmIntegrationInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined, TConfig = unknown, TInstance = unknown> = Omit<FarmIntegration<TSchema, TConfig, TInstance>, "kind" | "category" | "slot" | "instance" | "config" | "routes" | "endpoints" | "plugins"> & {
+    instance: TInstance;
+    config?: FarmIntegrationConfigInput<TConfig, TSchema>;
+    routes?: FarmIntegrationRoutesInput<TSchema>;
+    endpoints?: FarmIntegrationEndpointsInput<TSchema>;
+    plugins?: readonly FarmIntegrationContributedPlugin<NoInfer<TInstance>>[];
+} & ({
+    category: FarmIntegrationCategory;
+    slot?: FarmIntegrationCategory;
+} | {
+    category?: FarmIntegrationCategory;
+    slot: FarmIntegrationCategory;
+});
+type FarmIntegrationCategoryInput = {
+    category: FarmIntegrationCategory;
+    slot?: FarmIntegrationCategory;
+} | {
+    category?: FarmIntegrationCategory;
+    slot: FarmIntegrationCategory;
+};
+type FarmIntegrationShapeForInference = FarmIntegrationCategoryInput & {
+    api?: FarmIntegrationAPI;
+    schema?: FarmIntegrationSchema;
+    config?: unknown;
+    routes?: unknown;
+    endpoints?: unknown;
+};
+type ExtractIntegrationSchema<TIntegration> = TIntegration extends {
+    schema: infer TSchema extends FarmIntegrationSchema;
+} ? TSchema : undefined;
+type ResolveIntegrationRoutesInput<TRoutes, TSchema extends FarmIntegrationSchema | undefined> = TRoutes extends FarmIntegrationRoutesFactory<TSchema> ? ReturnType<TRoutes> : TRoutes;
+type ResolveIntegrationEndpointsInput<TEndpoints, TSchema extends FarmIntegrationSchema | undefined> = TEndpoints extends FarmIntegrationEndpointsFactory<TSchema> ? ReturnType<TEndpoints> : TEndpoints;
+type ExtractIntegrationRoutesFromRoutesInput<TRoutes, TSchema extends FarmIntegrationSchema | undefined> = ResolveIntegrationRoutesInput<TRoutes, TSchema> extends readonly (infer TRoute)[] ? TRoute : never;
+type ExtractIntegrationRoutesFromEndpointValue<TValue> = TValue extends FarmIntegrationRouteOperationCarrier<string, any> ? TValue : TValue extends readonly (infer TItem)[] ? ExtractIntegrationRoutesFromEndpointValue<TItem> : TValue extends object ? ExtractIntegrationRoutesFromEndpointValue<TValue[keyof TValue]> : never;
+type ExtractIntegrationRoutesFromEndpointsInput<TEndpoints, TSchema extends FarmIntegrationSchema | undefined> = ExtractIntegrationRoutesFromEndpointValue<ResolveIntegrationEndpointsInput<TEndpoints, TSchema>>;
+type ExtractIntegrationRouteUnion<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = (TIntegration extends {
+    routes: infer TRoutes;
+} ? ExtractIntegrationRoutesFromRoutesInput<TRoutes, TSchema> : never) | (TIntegration extends {
+    endpoints: infer TEndpoints;
+} ? ExtractIntegrationRoutesFromEndpointsInput<TEndpoints, TSchema> : never);
+type ExtractDefinedIntegrationRoutes<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = [ExtractIntegrationRouteUnion<TIntegration, TSchema>] extends [never] ? undefined : readonly ExtractIntegrationRouteUnion<TIntegration, TSchema>[];
+type ExtractDefinedIntegrationEndpoints<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = TIntegration extends {
+    endpoints: infer TEndpoints;
+} ? ResolveIntegrationEndpointsInput<TEndpoints, TSchema> : undefined;
+type ExtractIntegrationAPIRoutes<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = Extract<ExtractIntegrationRouteUnion<TIntegration, TSchema>, FarmIntegrationRouteOperationCarrier<string, any>>;
+type ExtractIntegrationCategory<TIntegration extends FarmIntegrationCategoryInput> = TIntegration extends {
+    category: infer TCategory extends FarmIntegrationCategory;
+} ? TCategory : TIntegration extends {
+    slot: infer TSlot extends FarmIntegrationCategory;
+} ? TSlot : FarmIntegrationCategory;
+type ExtractDerivedIntegrationAPI<TIntegration extends FarmIntegrationShapeForInference, TSchema extends FarmIntegrationSchema | undefined = ExtractIntegrationSchema<TIntegration>> = TIntegration extends {
+    api: infer TAPI extends FarmIntegrationAPI;
+} ? TAPI : [ExtractIntegrationAPIRoutes<TIntegration, TSchema>] extends [never] ? FarmIntegrationAPI | undefined : InferIntegrationAPIFromRoutes<readonly ExtractIntegrationAPIRoutes<TIntegration, TSchema>[]>;
+type DefinedIntegration<TIntegration extends FarmIntegrationShapeForInference, TSchema extends FarmIntegrationSchema | undefined = ExtractIntegrationSchema<TIntegration>> = Omit<TIntegration, "kind" | "category" | "slot" | "api" | "routes" | "endpoints"> & {
+    readonly kind: "farm-integration";
+    category: ExtractIntegrationCategory<TIntegration>;
+    slot: ExtractIntegrationCategory<TIntegration>;
+    routes: ExtractDefinedIntegrationRoutes<TIntegration, TSchema>;
+    endpoints: ExtractDefinedIntegrationEndpoints<TIntegration, TSchema>;
+    api: ExtractDerivedIntegrationAPI<TIntegration, TSchema>;
+};
+declare function defineIntegration<const TSchema extends FarmIntegrationSchema | undefined, const TConfig, TIntegration extends FarmIntegrationInput<TSchema, TConfig, any>>(integration: TIntegration & FarmIntegrationInput<TSchema, TConfig, NoInfer<TIntegration["instance"]>>): DefinedIntegration<TIntegration, TSchema>;
+declare function isFarmIntegration(value: unknown): value is FarmIntegration;
+declare function resolveIntegrationPlugins(integrations: FarmIntegrationsUserConfig | undefined): FarmPlugin[];
+declare function getIntegrationProviders(integrations: FarmIntegrationsUserConfig | undefined): 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;
     /**
-     * Serve source-authored markdown pages at `/route.md`.
-     * Enabled by default for `page.md` and `page.mdx`.
+     * 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.
      */
-    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;
+    onForwardedCookies?: (cookies: string[]) => void;
+}): Promise<Response | null>;
 /**
- * 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.
+ * 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 resolveFarmMdxComponentsModulePath(config: FarmMdxResolvedConfig | undefined, root: string): string | undefined;
+declare function dispatchIntegrationRequests(integrations: FarmIntegrationsUserConfig | undefined, runtime: Omit<RegisteredIntegrationRuntime, "integration">, request: Request, options?: {
+    currentRequest?: Request;
+}): Promise<{
+    response: Response | null;
+    setCookies: string[];
+}>;
 
-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;
+/**
+ * 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 ResolvedFarmRouteRuntimeConfig {
-    runtime: FarmRouteRuntime;
-    regions?: string[];
-    maxDuration?: number;
+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;
 }
-type FarmRouteRuntimeEntryKind = "page" | "api" | "metadata" | "rule";
-type FarmRouteRenderingMode = "static" | "dynamic";
-interface FarmRouteRuntimeManifestEntry extends ResolvedFarmRouteRuntimeConfig {
-    kind: FarmRouteRuntimeEntryKind;
-    pattern: string;
-    rendering: FarmRouteRenderingMode;
-    source?: string;
+/**
+ * Middleware function signature
+ */
+type MiddlewareFunction = (ctx: MiddlewareContext, next: NextFunction) => MiddlewareResult | Promise<MiddlewareResult>;
+/**
+ * Context passed to a named, request-first middleware export.
+ * `locals` and the get/set helpers stay on the server. `data` can be exposed
+ * through page props and should contain only serializable, client-safe values.
+ */
+interface RequestMiddlewareContext<TLocals extends Record<string, any> = Record<string, any>, TData extends Record<string, any> = Record<string, any>> {
+    readonly url: URL;
+    readonly pathname: string;
+    readonly searchParams: URLSearchParams;
+    readonly method: string;
+    readonly params: Record<string, string>;
+    readonly route: string;
+    readonly locals: MiddlewareStore<TLocals>;
+    readonly data: MiddlewareStore<TData>;
+    readonly headers: Map<string, string>;
+    readonly cookies: CookieJar;
+    get<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): TLocals[TKey] | undefined;
+    has<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): boolean;
+    set<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey, value: TLocals[TKey]): void;
+    delete<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): boolean;
+    redirect(url: string, status?: number): void;
+    rewrite(url: string): void;
+    json(data: any, status?: number): void;
+    text(content: string, status?: number): void;
+    html(content: string, status?: number): void;
 }
-interface FarmRouteRuntimeManifest {
-    version: 1;
-    routes: FarmRouteRuntimeManifestEntry[];
+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";
 }
-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;
+/**
+ * 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";
+}
+interface MiddlewareConfigEntry extends MiddlewareConfig$1 {
+    handler?: MiddlewareFunction;
+    handlers?: MiddlewareFunction[];
+}
+type FarmMiddlewareConfig = MiddlewareConfig$1 | MiddlewareConfigEntry | MiddlewareConfigEntry[];
+/**
+ * Middleware context - the main object passed to middleware functions
+ */
+interface MiddlewareContext {
+    request: IncomingMessage;
+    response: ServerResponse;
+    url: URL;
+    pathname: string;
+    searchParams: URLSearchParams;
+    method: string;
+    params: Record<string, string>;
+    route: string;
+    parent?: {
+        data: Map<string, any>;
+        locals?: Map<string, any>;
+        headers: Record<string, string>;
+    };
+    vite: {
+        isDev: boolean;
+        hmr: boolean;
+        server?: ViteDevServer;
+    };
+    data: Map<string, any>;
+    locals: Map<string, any>;
+    headers: Map<string, string>;
+    cookies: CookieJar;
+    _handled: boolean;
+    _redirectUrl?: string;
+    _rewriteUrl?: string;
+    redirect(url: string, status?: number): void;
+    rewrite(url: string): void;
+    json(data: any, status?: number): void;
+    text(content: string, status?: number): void;
+    html(content: string, status?: number): void;
+}
+/**
+ * Middleware chain interface
+ */
+interface MiddlewareChain {
+    use(fn: MiddlewareFunction): MiddlewareChain;
+    /**
+     * Conditionally run middleware based on a condition.
+     * Supports boolean values or functions that evaluate to boolean.
+     *
+     * @example
+     * .when(true, (ctx, next) => { ... })  // Always run
+     * .when((ctx) => ctx.data.get('flag'), (ctx, next) => { ... })  // Conditional
+     */
+    when(condition: boolean | ((ctx: MiddlewareContext) => boolean), fn: MiddlewareFunction | ((chain: MiddlewareChain) => void)): MiddlewareChain;
+    rateLimit(config: RateLimitConfig): MiddlewareChain;
+    redirect(source: string, destination: string, permanent?: boolean): MiddlewareChain;
+    /**
+     * Rewrite the current route to a new destination.
+     * In route-specific middleware, this rewrites the middleware's route.
+     *
+     * @param destination - The destination path to rewrite to
+     * @param condition - Optional boolean or function that evaluates to boolean. If false, rewrite is skipped.
+     *
+     * @example
+     * // In /contact/middleware.ts
+     * .rewrite('/about')  // Always rewrites /contact to /about
+     * .rewrite('/about', true)  // Always rewrites
+     * .rewrite('/about', false)  // Never rewrites
+     * .rewrite('/about', (ctx) => ctx.data.get('shouldRewrite'))  // Conditional rewrite
+     */
+    rewrite(destination: string, condition?: boolean | ((ctx: MiddlewareContext) => boolean)): MiddlewareChain;
+    build(): {
+        handlers: MiddlewareFunction[];
+        config?: MiddlewareConfig$1;
+    };
+}
+/**
+ * Middleware module export
+ */
+interface MiddlewareModule {
+    default?: MiddlewareChain | MiddlewareFunction;
+    middleware?: RequestMiddleware;
+    config?: MiddlewareConfig$1;
+}
+
+type FarmMdxComponent = React__default.ComponentType<any> | keyof React__default.JSX.IntrinsicElements;
+type FarmMdxComponents = Record<string, FarmMdxComponent>;
+interface FarmMdxUserConfig {
+    /**
+     * Component map or module path that exports `components` or a default component map.
+     * Relative paths resolve from the project root.
+     */
+    components?: string | FarmMdxComponents;
+    /**
+     * Serve source-authored markdown pages at `/route.md`.
+     * Enabled by default for `page.md` and `page.mdx`.
+     */
+    markdownRoutes?: boolean;
+    /** Class name used for the wrapper around rendered markdown content. */
+    className?: string;
+}
+interface FarmMdxResolvedConfig {
+    components?: string | FarmMdxComponents;
+    markdownRoutes: boolean;
+    className: string;
+}
+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;
+
+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. */
@@ -1032,27 +1193,6 @@ declare function loadFarmConfigFile<TConfig = Record<string, any>>(configPath: s
     cacheRoot?: string;
 }): Promise<TConfig>;
 
-declare const DEFAULT_FARM_DEVTOOLS_SHORTCUT = "mod+shift+.";
-declare const FARM_DEVTOOLS_PATH = "/__farm/devtools";
-declare const FARM_DEVTOOLS_LAUNCH_PARAM = "__farm_devtools";
-/**
- * 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 FarmBuildActivityPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left";
 interface FarmDevIndicatorsConfig {
     /** Show build and HMR activity in the browser during development. */
@@ -1129,199 +1269,19 @@ interface ResolvedFarmAuthConfig {
     };
 }
 
-/** 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;
+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;
 }
-/** 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}`;
-}
-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;
-    /** 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;
-    /**
-     * 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;
-}
-
-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 ResolvedFarmPreloadConfig {
+    mode: FarmPreloadMode;
+    maxImages: number;
+    maxFonts: number;
 }
 interface FarmPerformanceConfig {
     preload?: FarmPreloadUserConfig;
@@ -1678,7 +1638,7 @@ declare function shouldEmitFarmClientRootHmr(renderer?: FarmRenderer): boolean;
 declare function farmPlugin(options?: FarmVitePluginOptions, initialPluginManager?: PluginManager): Plugin$1;
 declare function defineConfig(config?: FarmVitePluginOptions): Promise<UserConfig>;
 
-type MaybePromise$1<T> = T | Promise<T>;
+type MaybePromise<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;
@@ -1845,7 +1805,7 @@ interface FarmPluginRuntimeEndpointEvent<TState = unknown, TIntegrationInstance
 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>;
+    handler(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeEndpointEvent<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise<Response>;
 }
 interface FarmPluginRuntimeBeforeEvent<TState = unknown, TRequestContext extends object = Record<string, unknown>, TIntegrationInstance = unknown> extends FarmPluginRuntimeBaseEvent<TState, TIntegrationInstance> {
     ctx: Readonly<TRequestContext>;
@@ -1869,19 +1829,19 @@ type FarmPluginRuntimeEventFor<TEvent, TIntegrationInstance, TIntegrationBound e
 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>[];
-    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>;
+    start?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeStartEvent<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise<void>;
+    context?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeContextEvent<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise<TRequestContext>;
+    before?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeBeforeEvent<TState, TRequestContext, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise<Request | Response | void>;
+    after?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeAfterEvent<TState, TRequestContext, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise<Response | void>;
+    error?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeErrorEvent<TState, TRequestContext, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise<void>;
+    close?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeCloseEvent<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise<void>;
 }
 interface FarmPluginRuntimeRequestOptions {
     kind?: FarmPluginRuntimeKind;
     route?: FarmPluginRouteRuntimePayload;
     waitUntil?: (promise: Promise<unknown>) => void;
 }
-type FarmPluginRuntimeRequestHandler = (request: Request) => MaybePromise$1<Response>;
+type FarmPluginRuntimeRequestHandler = (request: Request) => MaybePromise<Response>;
 interface FarmPluginRuntimeSession {
     request: Request;
     response?: Response;
@@ -1896,23 +1856,23 @@ type FarmPluginDiscoveredRoute = RouteDiscoveredPayload | ({
     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>;
+    discovered?(route: FarmPluginDiscoveredRoute, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise<void>;
+    generated?(routes: RoutesGeneratedPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise<void>;
+    before?(route: RouteMatchPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise<void>;
+    after?(result: RouteMatchResultPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise<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>;
+    before?(render: RenderLifecyclePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise<void>;
+    html?(html: string, render: RenderLifecyclePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise<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>;
+    before?(bundle: BundleLifecyclePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise<void>;
+    configure?(buildConfig: any, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise<any>;
+    after?(result: BundleResultPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise<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>;
+    server?(viteServer: ViteDevServer, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise<void>;
+    update?(update: HMRUpdatePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise<void>;
 }
 interface FarmPluginClientConfig<TState = unknown, TPublic = undefined> extends FarmClientPlugin<TState, TPublic> {
     /** Explicitly public, JSON-safe data embedded in the browser bundle. */
@@ -1925,9 +1885,9 @@ interface FarmPlugin<TState = any, TRequestContext extends object = Record<strin
     /** 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>;
+    configure?: (config: FarmConfig, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => MaybePromise<FarmConfig | void>;
     /** Initialize private plugin state once for this plugin manager. */
-    setup?: (context: FarmPluginSetupContextFor<TIntegrationInstance, TIntegrationBound>) => MaybePromise$1<TState>;
+    setup?: (context: FarmPluginSetupContextFor<TIntegrationInstance, TIntegrationBound>) => MaybePromise<TState>;
     runtime?: FarmPluginRuntimeHooks<TState, TRequestContext, TIntegrationInstance, TIntegrationBound>;
     router?: FarmPluginRouterHooks<TState, TIntegrationInstance, TIntegrationBound>;
     render?: FarmPluginRenderHooks<TState, TIntegrationInstance, TIntegrationBound>;
@@ -2087,9 +2047,9 @@ type FarmPluginDefinition<TState = undefined, TRequestContext extends object = R
      */
     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>;
+    configure?: (config: FarmConfig, context: WithPluginOptions<FarmPluginContextFor<TIntegrationInstance, false>, TSchema>) => MaybePromise<FarmConfig | void>;
     /** Initialize private plugin state once for this plugin manager. */
-    setup?: (context: WithPluginOptions<FarmPluginSetupContextFor<TIntegrationInstance, false>, TSchema>) => MaybePromise$1<TState>;
+    setup?: (context: WithPluginOptions<FarmPluginSetupContextFor<TIntegrationInstance, false>, TSchema>) => MaybePromise<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`. */
@@ -2128,482 +2088,701 @@ declare namespace definePlugin {
     function forIntegration<TIntegrationInstance>(): <TState = undefined, TRequestContext extends object = Record<string, never>, TClientState = unknown, TClientPublic = undefined>(plugin: FarmPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, true>) => FarmPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, true>;
 }
 
-type FarmIntegrationCategory = "auth" | "payment" | "monitoring" | "logging" | (string & {});
-/** @deprecated Use FarmIntegrationCategory instead. */
-type FarmIntegrationSlot = FarmIntegrationCategory;
-type FarmIntegrationRouteParamValue = string | string[];
-type FarmIntegrationRouteParams = Record<string, FarmIntegrationRouteParamValue>;
-type FarmIntegrationRouteMethod = FarmIntegrationAPIMethod | Lowercase<FarmIntegrationAPIMethod> | "ALL" | "all";
-type FarmIntegrationRouteInputSource = "body" | "query";
-type MaybePromise<T> = T | Promise<T>;
-type FarmIntegrationValidationPathSegment = PropertyKey | {
-    readonly key: PropertyKey;
-};
-interface FarmIntegrationRouteInput<TBody = unknown, TQuery = unknown> {
-    body?: TBody;
-    query?: TQuery;
-}
-interface FarmIntegrationValidationIssue {
-    source: FarmIntegrationRouteInputSource;
-    path?: readonly (string | number)[];
-    code?: string;
-    message: string;
-}
-interface FarmIntegrationValidationErrorLike {
-    issues?: readonly {
-        path?: readonly FarmIntegrationValidationPathSegment[];
-        code?: string;
-        message?: string;
-    }[];
-    message?: string;
-}
-type FarmIntegrationValidationResult<TValue> = {
-    success: true;
-    data: TValue;
-} | {
-    success: false;
-    error: FarmIntegrationValidationErrorLike;
-};
-type FarmIntegrationStandardValidationResult<TValue> = {
-    value: TValue;
-} | {
-    issues: readonly {
-        path?: readonly FarmIntegrationValidationPathSegment[];
-        code?: string;
-        message: string;
-    }[];
-};
-interface FarmIntegrationInputSchema<TValue = unknown> {
-    _output?: TValue;
-    parse?(value: unknown): MaybePromise<TValue>;
-    safeParse?(value: unknown): MaybePromise<FarmIntegrationValidationResult<TValue>>;
-    safeParseAsync?(value: unknown): Promise<FarmIntegrationValidationResult<TValue>>;
-    "~standard"?: {
-        validate(value: unknown): MaybePromise<FarmIntegrationStandardValidationResult<TValue>>;
-        types?: {
-            output: TValue;
-        };
-    };
+/** 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;
 }
-interface FarmIntegrationRouteInputSchemas<TBody = unknown, TQuery = unknown> {
-    body?: FarmIntegrationInputSchema<TBody>;
-    query?: FarmIntegrationInputSchema<TQuery>;
+/** 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;
 }
-/** @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.
+ * 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.
  */
-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;
+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[]>>;
 }
-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>;
+/**
+ * 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;
 }
-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;
+/**
+ * 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 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>;
+interface FarmMCPPromptMessage {
+    role: "user" | "assistant";
+    text: string;
 }
-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.
+ * 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.
  */
-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;
+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[]>;
 }
-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 FarmMCPServer {
+    readonly name: string;
+    readonly version: string;
+    readonly path: `/api/${string}`;
 }
-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 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 FarmIntegrationRouteMiddleware<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
-    handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, TSchema>): Promise<Response | void> | Response | void;
+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 FarmIntegrationMiddleware<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
-    matcher?: string | string[];
-    handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, TSchema>): Promise<Response | void> | Response | void;
+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;
+    /** 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;
+    /**
+     * 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 FarmIntegrationProviderProps {
-    children: ReactNode;
+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;
 }
-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;
+type FarmMCPUserConfig = FarmMCPConfig | false;
+interface ResolvedFarmMCPConfig extends FarmMCPConfig {
+    enabled: boolean;
 }
-interface FarmIntegrationProvider {
+
+/**
+ * @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[]): () => void;
+interface FarmMCPEndpointTool {
+    /** The MCP tool name. */
     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.
+    /** 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";
+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
      */
-    supportsIsolatedHydration?: boolean;
-    component?: ComponentType<FarmIntegrationProviderProps> | FarmIntegrationProviderComponentReference;
+    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 FarmIntegrationDocumentNavigation {
-    matcher: string | readonly string[];
+interface FarmMarkdownResolvedRoute {
+    route: string;
+    title?: string;
+    cache?: number | false;
 }
-/** @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;
+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;
-    phase: FarmIntegrationLogPhase;
-    route?: {
-        kind: "route" | "middleware";
-        path: string;
-        methods: readonly 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;
     };
-    requestId?: string;
-    request?: Request;
-    response?: Response;
-    error?: unknown;
-    durationMs?: number;
-    level?: FarmIntegrationLifecycleLogLevel;
-    message?: string;
-    meta?: Record<string, unknown>;
-    context: Map<string, unknown>;
+    /**
+     * 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;
 }
-type FarmIntegrationLogger = (event: FarmIntegrationLogEvent) => void | Promise<void>;
-interface FarmIntegrationPluginOwner {
-    key: string;
-    category: FarmIntegrationCategory;
-    type: string;
-    source: "lifecycle" | "contribution";
-    serverRuntime: boolean;
+/**
+ * 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;
 }
-/** 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>>[];
+interface FarmLlmsTxtSection {
+    title: string;
+    links: FarmLlmsTxtLink[];
 }
-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 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[];
 }
-interface FarmIntegrationRoutesFactoryContext<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
-    route: FarmIntegrationRouteFactory<TSchema>;
-    integrationRoute: FarmIntegrationRouteFactory<TSchema>;
+/** 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;
 }
-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>;
+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 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;
+}): 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;
 }
-type FarmIntegrationEndpointsFactory<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = (context: FarmIntegrationEndpointsFactoryContext<TSchema>) => FarmIntegrationEndpoints<TSchema>;
-declare function createIntegrationRoute<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined>(_schema?: TSchema): FarmIntegrationRouteFactory<TSchema>;
-declare const integrationRoute: FarmIntegrationRouteFactory<undefined>;
-type RegisteredIntegrationRuntime = {
-    integration: FarmIntegration;
-    config: FarmPluginContext["config"];
-    isDev: boolean;
-    isProd: boolean;
-};
-type FarmIntegrationRoutesInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = readonly FarmIntegrationRoute<any, any, TSchema>[] | FarmIntegrationRoutesFactory<TSchema>;
-type FarmIntegrationEndpointsInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = FarmIntegrationEndpoints<TSchema> | FarmIntegrationEndpointsFactory<TSchema>;
-type FarmIntegrationInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined, TConfig = unknown, TInstance = unknown> = Omit<FarmIntegration<TSchema, TConfig, TInstance>, "kind" | "category" | "slot" | "instance" | "config" | "routes" | "endpoints" | "plugins"> & {
-    instance: TInstance;
-    config?: FarmIntegrationConfigInput<TConfig, TSchema>;
-    routes?: FarmIntegrationRoutesInput<TSchema>;
-    endpoints?: FarmIntegrationEndpointsInput<TSchema>;
-    plugins?: readonly FarmIntegrationContributedPlugin<NoInfer<TInstance>>[];
-} & ({
-    category: FarmIntegrationCategory;
-    slot?: FarmIntegrationCategory;
-} | {
-    category?: FarmIntegrationCategory;
-    slot: FarmIntegrationCategory;
-});
-type FarmIntegrationCategoryInput = {
-    category: FarmIntegrationCategory;
-    slot?: FarmIntegrationCategory;
-} | {
-    category?: FarmIntegrationCategory;
-    slot: FarmIntegrationCategory;
-};
-type FarmIntegrationShapeForInference = FarmIntegrationCategoryInput & {
-    api?: FarmIntegrationAPI;
-    schema?: FarmIntegrationSchema;
-    config?: unknown;
-    routes?: unknown;
-    endpoints?: unknown;
-};
-type ExtractIntegrationSchema<TIntegration> = TIntegration extends {
-    schema: infer TSchema extends FarmIntegrationSchema;
-} ? TSchema : undefined;
-type ResolveIntegrationRoutesInput<TRoutes, TSchema extends FarmIntegrationSchema | undefined> = TRoutes extends FarmIntegrationRoutesFactory<TSchema> ? ReturnType<TRoutes> : TRoutes;
-type ResolveIntegrationEndpointsInput<TEndpoints, TSchema extends FarmIntegrationSchema | undefined> = TEndpoints extends FarmIntegrationEndpointsFactory<TSchema> ? ReturnType<TEndpoints> : TEndpoints;
-type ExtractIntegrationRoutesFromRoutesInput<TRoutes, TSchema extends FarmIntegrationSchema | undefined> = ResolveIntegrationRoutesInput<TRoutes, TSchema> extends readonly (infer TRoute)[] ? TRoute : never;
-type ExtractIntegrationRoutesFromEndpointValue<TValue> = TValue extends FarmIntegrationRouteOperationCarrier<string, any> ? TValue : TValue extends readonly (infer TItem)[] ? ExtractIntegrationRoutesFromEndpointValue<TItem> : TValue extends object ? ExtractIntegrationRoutesFromEndpointValue<TValue[keyof TValue]> : never;
-type ExtractIntegrationRoutesFromEndpointsInput<TEndpoints, TSchema extends FarmIntegrationSchema | undefined> = ExtractIntegrationRoutesFromEndpointValue<ResolveIntegrationEndpointsInput<TEndpoints, TSchema>>;
-type ExtractIntegrationRouteUnion<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = (TIntegration extends {
-    routes: infer TRoutes;
-} ? ExtractIntegrationRoutesFromRoutesInput<TRoutes, TSchema> : never) | (TIntegration extends {
-    endpoints: infer TEndpoints;
-} ? ExtractIntegrationRoutesFromEndpointsInput<TEndpoints, TSchema> : never);
-type ExtractDefinedIntegrationRoutes<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = [ExtractIntegrationRouteUnion<TIntegration, TSchema>] extends [never] ? undefined : readonly ExtractIntegrationRouteUnion<TIntegration, TSchema>[];
-type ExtractDefinedIntegrationEndpoints<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = TIntegration extends {
-    endpoints: infer TEndpoints;
-} ? ResolveIntegrationEndpointsInput<TEndpoints, TSchema> : undefined;
-type ExtractIntegrationAPIRoutes<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = Extract<ExtractIntegrationRouteUnion<TIntegration, TSchema>, FarmIntegrationRouteOperationCarrier<string, any>>;
-type ExtractIntegrationCategory<TIntegration extends FarmIntegrationCategoryInput> = TIntegration extends {
-    category: infer TCategory extends FarmIntegrationCategory;
-} ? TCategory : TIntegration extends {
-    slot: infer TSlot extends FarmIntegrationCategory;
-} ? TSlot : FarmIntegrationCategory;
-type ExtractDerivedIntegrationAPI<TIntegration extends FarmIntegrationShapeForInference, TSchema extends FarmIntegrationSchema | undefined = ExtractIntegrationSchema<TIntegration>> = TIntegration extends {
-    api: infer TAPI extends FarmIntegrationAPI;
-} ? TAPI : [ExtractIntegrationAPIRoutes<TIntegration, TSchema>] extends [never] ? FarmIntegrationAPI | undefined : InferIntegrationAPIFromRoutes<readonly ExtractIntegrationAPIRoutes<TIntegration, TSchema>[]>;
-type DefinedIntegration<TIntegration extends FarmIntegrationShapeForInference, TSchema extends FarmIntegrationSchema | undefined = ExtractIntegrationSchema<TIntegration>> = Omit<TIntegration, "kind" | "category" | "slot" | "api" | "routes" | "endpoints"> & {
-    readonly kind: "farm-integration";
-    category: ExtractIntegrationCategory<TIntegration>;
-    slot: ExtractIntegrationCategory<TIntegration>;
-    routes: ExtractDefinedIntegrationRoutes<TIntegration, TSchema>;
-    endpoints: ExtractDefinedIntegrationEndpoints<TIntegration, TSchema>;
-    api: ExtractDerivedIntegrationAPI<TIntegration, TSchema>;
-};
-declare function defineIntegration<const TSchema extends FarmIntegrationSchema | undefined, const TConfig, TIntegration extends FarmIntegrationInput<TSchema, TConfig, any>>(integration: TIntegration & FarmIntegrationInput<TSchema, TConfig, NoInfer<TIntegration["instance"]>>): DefinedIntegration<TIntegration, TSchema>;
-declare function isFarmIntegration(value: unknown): value is FarmIntegration;
-declare function resolveIntegrationPlugins(integrations: FarmIntegrationsUserConfig | undefined): FarmPlugin[];
-declare function getIntegrationProviders(integrations: FarmIntegrationsUserConfig | undefined): 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;
+interface FarmMetadataRouteResponseOptions {
     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;
+    /** 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;
     /**
-     * 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.
+     * AI search and user-triggered agents such as OAI-SearchBot, Claude-SearchBot,
+     * and PerplexityBot. Left unset, they follow the `User-agent: *` rules.
      */
-    onForwardedCookies?: (cookies: string[]) => void;
-}): Promise<Response | null>;
+    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;
+
 /**
- * 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.
+ * 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) are on by default; the ones that expose more
+ * (crawler rules, an API catalog) are opt-in. Each one turns off with `false`.
  */
-declare function dispatchIntegrationRequests(integrations: FarmIntegrationsUserConfig | undefined, runtime: Omit<RegisteredIntegrationRuntime, "integration">, request: Request, options?: {
-    currentRequest?: Request;
-}): Promise<{
-    response: Response | null;
-    setCookies: string[];
-}>;
+
+/** 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 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;
+}
+interface ResolvedFarmAgentConfig {
+    jsonLd: FarmAgentJsonLd | false;
+    noindexPreviews: boolean;
+    llmsTxt: ResolvedFarmLlmsTxtConfig;
+    crawlers: ResolvedFarmAgentCrawlers;
+    apiCatalog: boolean;
+}
 
 declare global {
     namespace FarmJS {
@@ -3260,4 +3439,4 @@ interface MetadataRobots extends MetadataRobotsDirectives {
     googleBot?: string | MetadataRobotsDirectives;
 }
 
-export { type LayoutMetadataProps as $, type FarmAgentJsonLd as A, type FarmContextFactory as B, type MiddlewareProps as C, type BundleResultPayload as D, type FarmIntegration as E, type FarmRouteRuntimeConfig as F, type FarmConfig as G, farmPlugin as H, defineConfig as I, type FarmComponentType as J, type AppRoutePattern as K, type LayoutProps as L, type Metadata as M, type PageRouteParams as N, type NitroPreset as O, type ParsedRoute as P, type FarmMigrationCommand as Q, type RouteSegment as R, type FarmMigrationsConfig as S, type FarmMigrationsUserConfig as T, type ResolvedFarmMigrationsConfig as U, type FarmContextFactoryInput as V, type FarmIsolatedClientHydrationMode as W, type LoadingProps as X, type ErrorProps as Y, type PagePropsWithMiddleware as Z, type MetadataProps as _, type FarmPlugin as a, definePlugin as a$, type Page as a0, type Layout as a1, type Loading as a2, type ErrorBoundary as a3, type StaticPathPrimitive as a4, type StaticPathParams as a5, type StaticRouteParams as a6, type GenerateStaticParams as a7, type LayoutModule as a8, type MetadataJsonLd as a9, type ResolvedFarmDevIndicatorsConfig as aA, type ResolvedFarmAuthConfig as aB, type ResolvedFarmPerformanceConfig as aC, type ResolvedFarmSecurityConfig as aD, type APIRequestRuntime as aE, createFarmMetadataRouteResponse as aF, createFarmAgentRobots as aG, collectFarmLlmsTxtPages as aH, createFarmDefaultLlmsTxt as aI, createFarmLlmsMarkdownReader as aJ, renderFarmLlmsFullTxt as aK, createFarmLlmsFullRenderer as aL, manageFarmDocumentPreloads as aM, manageFarmHtmlPreloads as aN, manageFarmLinkHeaderPreloads as aO, reportFarmPreloadWarnings as aP, applyFarmCspNonceToResponse as aQ, resolveFarmSecurityConfig as aR, type ResolvedSchemaField as aS, type FarmSqlDialect as aT, type FarmSqlStatement as aU, type CollectedSchemaModel as aV, type FarmSchemaMigrationStep as aW, type OpenAPIConfig as aX, type FarmAgentUserConfig as aY, type FarmAgentCrawlers as aZ, type FarmCrawlerPolicy as a_, type ServerAction as aa, type BuildOptions as ab, type SSGPage as ac, type SSGCollectionResult as ad, type MetadataRobotsDirectives as ae, type MetadataRobots as af, type FarmLayerEntry as ag, type ResolvedFarmLayer as ah, type FarmSourceRoot as ai, type ResolveFarmLayersOptions as aj, type FarmLayerResolution as ak, resolveFarmLayers as al, getFarmSourceRoots as am, getFarmAppDirectories as an, getFarmLayerAliases as ao, createFarmConfigResolutionPlugin as ap, loadFarmConfigFile as aq, type ReadonlyMiddlewareStore as ar, type FarmMiddlewareConfig as as, type MiddlewareModule as at, type MiddlewareConfig$1 as au, type MiddlewareContext as av, type ResolvedFarmRouteRuntimeConfig as aw, type ApplicationMetadataRouteKind as ax, type ResolvedFarmAPIConfig as ay, type ResolvedFarmDevtoolsConfig as az, isFarmRedirectError as b, type FarmPluginStateContext as b$, FarmRuntimeShutdownError as b0, PluginManager as b1, type FarmPluginDatabase as b2, type FarmPluginDefinition as b3, FarmPluginOptionsError as b4, type FarmPluginFactory as b5, type FarmPluginOptionsIssue as b6, type FarmPluginOptionsSchema as b7, type InferPluginOptionsInput as b8, type InferPluginOptionsOutput as b9, type FarmMCPAuthorization as bA, type FarmMCPEndpoint as bB, type FarmMCPServerFunction as bC, type FarmMCPToolDefinition as bD, type FarmMCPStandaloneTool as bE, type FarmMCPExecuteContext as bF, type FarmMCPTool as bG, type FarmMCPServer as bH, type FarmMCPAuthorizeContext as bI, type FarmMCPConfig as bJ, type FarmMCPOAuthConfig as bK, type FarmMCPPrompt as bL, type FarmMCPPromptMessage as bM, type FarmMCPResource as bN, type FarmMCPResourceContent as bO, type FarmMCPResourceContext as bP, type FarmMCPResourceListing as bQ, type FarmMCPUserConfig as bR, type ResolvedFarmMCPConfig as bS, type PluginRequestContext as bT, type FarmPluginIntegrationContext as bU, type FarmPluginLifecycle as bV, type FarmRequestPluginContext as bW, type FarmRequestStore as bX, type FarmPluginRuntimeKind as bY, type FarmPluginRouteRuntimePayload as bZ, type FarmPluginSetupContext as b_, resolveConfig as ba, loadConfig as bb, resolveDeployConfig as bc, resolveMigrationsConfig as bd, resolveDeployOutputPath as be, normalizeDeployTarget as bf, getDeployTargetForPreset as bg, getPresetForDeployTarget as bh, type FarmLayerConfig as bi, type FarmPerformanceConfig as bj, type FarmPreloadMode as bk, type FarmPreloadUserConfig as bl, type ResolvedFarmPreloadConfig as bm, type FarmCspConfig as bn, type FarmCspDirectives as bo, type FarmCspDirectiveValue as bp, type FarmCspOptions as bq, type FarmSecurityConfig as br, type ResolvedFarmCspConfig as bs, MetadataRoute as bt, type MetadataRouteContext as bu, type FarmAuthConfig as bv, type FarmAuthDatabaseConfig as bw, type FarmAuthEmailAndPasswordConfig as bx, type FarmAuthSessionConfig as by, type FarmAuthUserConfig as bz, type FarmRedirectSignal as c, type FarmIntegrationRouteInput as c$, type FarmPluginRuntimeBaseEvent as c0, type FarmPluginRuntimeContextEvent as c1, type FarmPluginRuntimeEndpoint as c2, type FarmPluginRuntimeEndpointEvent as c3, type FarmPluginRuntimeBeforeEvent as c4, type FarmPluginRuntimeAfterEvent as c5, type FarmPluginRuntimeErrorEvent as c6, type FarmPluginRuntimeStartEvent as c7, type FarmPluginRuntimeCloseEvent as c8, type FarmPluginRuntimeHooks as c9, type ImageConfig as cA, type I18nConfig as cB, type MiddlewareConfig as cC, type FarmDeployConfig as cD, type ResolvedFarmDeployConfig as cE, type FarmDeployTarget as cF, describeSchemaReference as cG, collectSchemaModels as cH, generateSqlStatements as cI, renderSqlSchemaFile as cJ, getSqlColumnType as cK, getSqlDefaultExpression as cL, isNullableField as cM, quoteSqlIdentifier as cN, toSnakeCase as cO, toPascalCase as cP, toCamelCase as cQ, escapeSqlString as cR, resolveSchemaModels as cS, type ResolvedSchemaModel as cT, type FarmIntegrationCategory as cU, type FarmIntegrationSlot as cV, type FarmIntegrationRouteParamValue as cW, type FarmIntegrationRouteParams as cX, type FarmIntegrationRouteMethod as cY, type FarmIntegrationRouteInputSource as cZ, type FarmIntegrationValidationPathSegment as c_, type FarmPluginRuntimeRequestOptions as ca, type FarmPluginRuntimeRequestHandler as cb, type FarmPluginRuntimeSession as cc, type FarmPluginDiscoveredRoute as cd, type FarmPluginRouterHooks as ce, type FarmPluginRenderHooks as cf, type FarmPluginBuildHooks as cg, type FarmPluginDevHooks as ch, type FarmPluginClientConfig as ci, type RouteDiscoveredPayload as cj, type RoutesGeneratedPayload as ck, type MiddlewareDiscoveredPayload as cl, type APIRouteDiscoveredPayload as cm, type RouteMatchPayload as cn, type RouteMatchResultPayload as co, type RenderLifecyclePayload as cp, type APIHandlerLifecyclePayload as cq, type ErrorLifecyclePayload as cr, type HMRUpdatePayload as cs, type BundleLifecyclePayload as ct, type NitroBuildLifecyclePayload as cu, type ShutdownPayload as cv, type ResolvedFarmConfig as cw, type RedirectConfig as cx, type HeaderConfig as cy, type RewriteConfig as cz, type FarmRedirectStatus as d, getIntegrationProviders as d$, type FarmIntegrationValidationIssue as d0, type FarmIntegrationValidationErrorLike as d1, type FarmIntegrationValidationResult as d2, type FarmIntegrationStandardValidationResult as d3, type FarmIntegrationInputSchema as d4, type FarmIntegrationRouteInputSchemas as d5, type FarmIntegrationRequestContextStore as d6, FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY as d7, FARM_INTEGRATION_SET_COOKIES_KEY as d8, forwardIntegrationSetCookies as d9, type FarmIntegrationSchemaConstraint as dA, type FarmIntegrationSchemaModel as dB, type FarmIntegrationSchemaModelExtension as dC, type FarmIntegrationSchemaModelOverride as dD, type FarmIntegrationSchema as dE, defineIntegrationSchema as dF, type FarmIntegrationLogPhase as dG, type FarmIntegrationLogEvent as dH, type FarmIntegrationLogger as dI, type FarmIntegrationPluginOwner as dJ, type FarmIntegrationContributedPlugin as dK, type FarmIntegrationsUserConfig as dL, getFarmIntegrationPluginServerRuntime as dM, getFarmIntegrationPluginOwner as dN, type FarmIntegrationRouteFactory as dO, type FarmIntegrationRoutesFactoryContext as dP, type FarmIntegrationRoutesFactory as dQ, type FarmIntegrationEndpointValue as dR, type FarmIntegrationEndpoints as dS, type FarmIntegrationEndpointsFactoryContext as dT, type FarmIntegrationEndpointsFactory as dU, createIntegrationRoute as dV, integrationRoute as dW, type DefinedIntegration as dX, defineIntegration as dY, isFarmIntegration as dZ, resolveIntegrationPlugins as d_, type FarmIntegrationRouteDb as da, type FarmIntegrationRouteStorageArgs as db, type FarmIntegrationRouteArgs as dc, type FarmIntegrationConfigContext as dd, type FarmIntegrationConfigDefinition as de, type FarmIntegrationConfigInput as df, type FarmIntegrationLifecycleLogLevel as dg, type FarmIntegrationLifecycleLogger as dh, type FarmIntegrationLifecycleContext as di, type FarmIntegrationLifecycleHook as dj, type FarmIntegrationData as dk, type FarmIntegrationHandlerContext as dl, type FarmIntegrationRouteHookContext as dm, type FarmIntegrationRouteHook as dn, type FarmIntegrationRoute as dp, type FarmTypedIntegrationRoute as dq, type FarmIntegrationRouteMiddleware as dr, type FarmIntegrationMiddleware as ds, type FarmIntegrationProviderProps as dt, type FarmIntegrationProviderComponentReference as du, type FarmIntegrationProvider as dv, type FarmIntegrationDocumentNavigation as dw, type FarmIntegrationSchemaFieldType as dx, type FarmIntegrationSchemaReference as dy, type FarmIntegrationSchemaField as dz, type FarmRequest as e, type FarmRouteRuntimeManifest as e$, isFarmIntegrationProviderComponentReference as e0, getIntegrationDocumentNavigationMatchers as e1, getIntegrationSchemas as e2, getRegisteredIntegrationRuntime as e3, getRegisteredIntegrations as e4, getRegisteredIntegrationSchemas as e5, matchIntegrationRoute as e6, matchRegisteredIntegrationRoute as e7, getRegisteredIntegrationAPIManifest as e8, dispatchIntegrationRequest as e9, resolveFarmAPIRequestURL as eA, type MiddlewareFunction as eB, type RequestMiddleware as eC, type RequestMiddlewareContext as eD, type MiddlewareStore as eE, type MiddlewareChain as eF, type CookieJar as eG, type CookieOptions as eH, type RateLimitConfig as eI, type RateLimitIncrementResult as eJ, type RateLimitStorage as eK, type RateLimitStatus as eL, type MemoryRateLimitStorageOptions as eM, type NextFunction as eN, type MiddlewareResult as eO, type FarmRouteRuleRenderMode as eP, type FarmRouteRuleRedirect as eQ, type FarmRouteRuleCors as eR, type FarmRouteRule as eS, type FarmRouteRules as eT, normalizeRouteRules as eU, routeRulesToRedirects as eV, routeRulesToHeaders as eW, routeRulesToNitroRouteRules as eX, type FarmRouteRuntimeEntryKind as eY, type FarmRouteRenderingMode as eZ, type FarmRouteRuntimeManifestEntry as e_, dispatchIntegrationRequests as ea, describeIntegrationOriginRejection as eb, resolveIntegrationAllowedOrigins as ec, validateIntegrationRequestOrigin as ed, type IntegrationOriginPolicy as ee, type IntegrationOriginRejection as ef, type IntegrationOriginResult as eg, type FarmIntegrationOrmSchema as eh, type FarmIntegrationOrmClient as ei, type InferFarmIntegrationOrmField as ej, type InferFarmIntegrationOrmFields as ek, type InferFarmIntegrationOrmSchema as el, type InferFarmIntegrationOrmClient as em, type CreateIntegrationOrmOptions as en, createIntegrationOrm as eo, resolveIntegrationOrmRuntimeClient as ep, farmIntegrationSchemaToOrmSchema as eq, type IntegrationOrmModelNames as er, DEFAULT_FARM_API_BASE_PATH as es, type FarmAPIConfigResolverContext as et, type FarmAPIConfigValue as eu, type FarmAPIConfig as ev, resolveFarmAPIConfig as ew, normalizeFarmAPIConfig as ex, normalizeFarmAPIBasePath as ey, getFarmAPIBaseURL as ez, type FarmResponse as f, normalizeFarmRouteRuntimeConfig as f0, mergeFarmRouteRuntimeConfigs as f1, resolveFarmRouteRuntimeConfig as f2, hasFarmRouteRuntimeControls as f3, getFarmRouteRuntimeConfig as f4, createFarmRouteRuntimeKey as f5, resolveFarmRouteRuleRuntimeConfig as f6, farmRouteRuleMatches as f7, DEFAULT_FARM_DEVTOOLS_SHORTCUT as f8, FARM_DEVTOOLS_PATH as f9, FARM_DEVTOOLS_LAUNCH_PARAM as fa, type FarmDevtoolsConfig as fb, type FarmDevtoolsUserConfig as fc, resolveFarmDevtoolsConfig as fd, type FarmBuildActivityPosition as fe, type FarmDevIndicatorsConfig as ff, resolveFarmDevIndicatorsConfig as fg, generateFarmDevIndicatorsClientRuntime as fh, farmI18nClientBridgePlugin as fi, farmServerOnlyEntriesPlugin as fj, withFarmRequestTracing as fk, rewriteEarlySsrRelativeImports as fl, transformIsolatedClientBoundaryModule as fm, shouldEmitFarmClientRootHmr as fn, generateClientCachePersistenceCode as fo, resolveFarmClientCacheAdapterEntry as fp, type ClientCachePersistenceEntryCode as fq, FARM_NODE_RESPONSE_END_PENDING as fr, loadFarmDevModule as fs, FarmDevEnvironmentError as ft, type FarmDevModuleServer as fu, getFarmRedirectError as g, type FarmPluginContext as h, isFarmNotFoundError as i, type FarmRouteRuntime as j, type FarmRouteRegions as k, type FarmRouteMaxDuration as l, type FarmAppContext as m, notFound as n, type PageProps as o, permanentRedirect as p, type PluginContextProps as q, redirect as r, type RouteModule as s, type FarmMdxComponents as t, type FarmMdxResolvedConfig as u, resolveFarmMdxComponentsModulePath as v, resolveMdxConfig as w, type FarmMdxComponent as x, type FarmMdxUserConfig as y, type FarmUserConfig as z };
+export { type ErrorProps as $, createFarmMarkdownErrorBody as A, farmRequestWantsMarkdown as B, type FarmUserConfig as C, type FarmAgentJsonLd as D, type FarmContextFactory as E, type FarmRouteRuntimeConfig as F, type MiddlewareProps as G, type BundleResultPayload as H, type FarmIntegration as I, type FarmConfig as J, farmPlugin as K, type LayoutProps as L, type Metadata as M, defineConfig as N, type FarmComponentType as O, type ParsedRoute as P, type AppRoutePattern as Q, type RouteSegment as R, type PageRouteParams as S, type NitroPreset as T, type FarmMigrationCommand as U, type FarmMigrationsConfig as V, type FarmMigrationsUserConfig as W, type ResolvedFarmMigrationsConfig as X, type FarmContextFactoryInput as Y, type FarmIsolatedClientHydrationMode as Z, type LoadingProps as _, type FarmPlugin as a, type CollectedSchemaModel as a$, type PagePropsWithMiddleware as a0, type MetadataProps as a1, type LayoutMetadataProps as a2, type Page as a3, type Layout as a4, type Loading as a5, type ErrorBoundary as a6, type StaticPathPrimitive as a7, type StaticPathParams as a8, type StaticRouteParams as a9, _publishFarmMCPCatalog as aA, type ResolvedFarmRouteRuntimeConfig as aB, type ApplicationMetadataRouteKind as aC, type ResolvedFarmAPIConfig as aD, type FarmMarkdownResolvedConfig as aE, type ResolvedFarmDevtoolsConfig as aF, type ResolvedFarmDevIndicatorsConfig as aG, type ResolvedFarmAuthConfig as aH, type ResolvedFarmPerformanceConfig as aI, type ResolvedFarmSecurityConfig as aJ, type APIRequestRuntime as aK, createFarmMetadataRouteResponse as aL, createFarmAgentRobots as aM, collectFarmLlmsTxtPages as aN, createFarmDefaultLlmsTxt as aO, createFarmLlmsMarkdownReader as aP, renderFarmLlmsFullTxt as aQ, createFarmLlmsFullRenderer as aR, manageFarmDocumentPreloads as aS, manageFarmHtmlPreloads as aT, manageFarmLinkHeaderPreloads as aU, reportFarmPreloadWarnings as aV, applyFarmCspNonceToResponse as aW, resolveFarmSecurityConfig as aX, type ResolvedSchemaField as aY, type FarmSqlDialect as aZ, type FarmSqlStatement as a_, type GenerateStaticParams as aa, type LayoutModule as ab, type MetadataJsonLd as ac, type ServerAction as ad, type BuildOptions as ae, type SSGPage as af, type SSGCollectionResult as ag, type MetadataRobotsDirectives as ah, type MetadataRobots as ai, type FarmLayerEntry as aj, type ResolvedFarmLayer as ak, type FarmSourceRoot as al, type ResolveFarmLayersOptions as am, type FarmLayerResolution as an, resolveFarmLayers as ao, getFarmSourceRoots as ap, getFarmAppDirectories as aq, getFarmLayerAliases as ar, createFarmConfigResolutionPlugin as as, loadFarmConfigFile as at, type ReadonlyMiddlewareStore as au, type FarmMiddlewareConfig as av, type MiddlewareModule as aw, type MiddlewareConfig$1 as ax, type MiddlewareContext as ay, _findFarmMCPEndpointTool as az, isFarmRedirectError as b, type FarmPluginIntegrationContext as b$, type FarmSchemaMigrationStep as b0, type OpenAPIConfig as b1, type FarmAgentUserConfig as b2, type FarmAgentCrawlers as b3, type FarmCrawlerPolicy as b4, definePlugin as b5, FarmRuntimeShutdownError as b6, PluginManager as b7, type FarmPluginDatabase as b8, type FarmPluginDefinition as b9, type MetadataRouteContext as bA, type FarmMCPEndpointTool as bB, type FarmAuthConfig as bC, type FarmAuthDatabaseConfig as bD, type FarmAuthEmailAndPasswordConfig as bE, type FarmAuthSessionConfig as bF, type FarmAuthUserConfig as bG, type FarmMCPAuthorization as bH, type FarmMCPEndpoint as bI, type FarmMCPServerFunction as bJ, type FarmMCPToolDefinition as bK, type FarmMCPStandaloneTool as bL, type FarmMCPExecuteContext as bM, type FarmMCPTool as bN, type FarmMCPServer as bO, type FarmMCPAuthorizeContext as bP, type FarmMCPConfig as bQ, type FarmMCPOAuthConfig as bR, type FarmMCPPrompt as bS, type FarmMCPPromptMessage as bT, type FarmMCPResource as bU, type FarmMCPResourceContent as bV, type FarmMCPResourceContext as bW, type FarmMCPResourceListing as bX, type FarmMCPUserConfig as bY, type ResolvedFarmMCPConfig as bZ, type PluginRequestContext as b_, FarmPluginOptionsError as ba, type FarmPluginFactory as bb, type FarmPluginOptionsIssue as bc, type FarmPluginOptionsSchema as bd, type InferPluginOptionsInput as be, type InferPluginOptionsOutput as bf, resolveConfig as bg, loadConfig as bh, resolveDeployConfig as bi, resolveMigrationsConfig as bj, resolveDeployOutputPath as bk, normalizeDeployTarget as bl, getDeployTargetForPreset as bm, getPresetForDeployTarget as bn, type FarmLayerConfig as bo, type FarmPerformanceConfig as bp, type FarmPreloadMode as bq, type FarmPreloadUserConfig as br, type ResolvedFarmPreloadConfig as bs, type FarmCspConfig as bt, type FarmCspDirectives as bu, type FarmCspDirectiveValue as bv, type FarmCspOptions as bw, type FarmSecurityConfig as bx, type ResolvedFarmCspConfig as by, MetadataRoute as bz, type FarmRedirectSignal as c, type ResolvedSchemaModel as c$, type FarmPluginLifecycle as c0, type FarmRequestPluginContext as c1, type FarmRequestStore as c2, type FarmPluginRuntimeKind as c3, type FarmPluginRouteRuntimePayload as c4, type FarmPluginSetupContext as c5, type FarmPluginStateContext as c6, type FarmPluginRuntimeBaseEvent as c7, type FarmPluginRuntimeContextEvent as c8, type FarmPluginRuntimeEndpoint as c9, type BundleLifecyclePayload as cA, type NitroBuildLifecyclePayload as cB, type ShutdownPayload as cC, type ResolvedFarmConfig as cD, type RedirectConfig as cE, type HeaderConfig as cF, type RewriteConfig as cG, type ImageConfig as cH, type I18nConfig as cI, type MiddlewareConfig as cJ, type FarmDeployConfig as cK, type ResolvedFarmDeployConfig as cL, type FarmDeployTarget as cM, type FarmMarkdownUserConfig as cN, describeSchemaReference as cO, collectSchemaModels as cP, generateSqlStatements as cQ, renderSqlSchemaFile as cR, getSqlColumnType as cS, getSqlDefaultExpression as cT, isNullableField as cU, quoteSqlIdentifier as cV, toSnakeCase as cW, toPascalCase as cX, toCamelCase as cY, escapeSqlString as cZ, resolveSchemaModels as c_, type FarmPluginRuntimeEndpointEvent as ca, type FarmPluginRuntimeBeforeEvent as cb, type FarmPluginRuntimeAfterEvent as cc, type FarmPluginRuntimeErrorEvent as cd, type FarmPluginRuntimeStartEvent as ce, type FarmPluginRuntimeCloseEvent as cf, type FarmPluginRuntimeHooks as cg, type FarmPluginRuntimeRequestOptions as ch, type FarmPluginRuntimeRequestHandler as ci, type FarmPluginRuntimeSession as cj, type FarmPluginDiscoveredRoute as ck, type FarmPluginRouterHooks as cl, type FarmPluginRenderHooks as cm, type FarmPluginBuildHooks as cn, type FarmPluginDevHooks as co, type FarmPluginClientConfig as cp, type RouteDiscoveredPayload as cq, type RoutesGeneratedPayload as cr, type MiddlewareDiscoveredPayload as cs, type APIRouteDiscoveredPayload as ct, type RouteMatchPayload as cu, type RouteMatchResultPayload as cv, type RenderLifecyclePayload as cw, type APIHandlerLifecyclePayload as cx, type ErrorLifecyclePayload as cy, type HMRUpdatePayload as cz, type FarmRedirectStatus as d, type FarmIntegrationEndpointsFactoryContext as d$, type FarmIntegrationCategory as d0, type FarmIntegrationSlot as d1, type FarmIntegrationRouteParamValue as d2, type FarmIntegrationRouteParams as d3, type FarmIntegrationRouteMethod as d4, type FarmIntegrationRouteInputSource as d5, type FarmIntegrationValidationPathSegment as d6, type FarmIntegrationRouteInput as d7, type FarmIntegrationValidationIssue as d8, type FarmIntegrationValidationErrorLike as d9, type FarmIntegrationMiddleware as dA, type FarmIntegrationProviderProps as dB, type FarmIntegrationProviderComponentReference as dC, type FarmIntegrationProvider as dD, type FarmIntegrationDocumentNavigation as dE, type FarmIntegrationSchemaFieldType as dF, type FarmIntegrationSchemaReference as dG, type FarmIntegrationSchemaField as dH, type FarmIntegrationSchemaConstraint as dI, type FarmIntegrationSchemaModel as dJ, type FarmIntegrationSchemaModelExtension as dK, type FarmIntegrationSchemaModelOverride as dL, type FarmIntegrationSchema as dM, defineIntegrationSchema as dN, type FarmIntegrationLogPhase as dO, type FarmIntegrationLogEvent as dP, type FarmIntegrationLogger as dQ, type FarmIntegrationPluginOwner as dR, type FarmIntegrationContributedPlugin as dS, type FarmIntegrationsUserConfig as dT, getFarmIntegrationPluginServerRuntime as dU, getFarmIntegrationPluginOwner as dV, type FarmIntegrationRouteFactory as dW, type FarmIntegrationRoutesFactoryContext as dX, type FarmIntegrationRoutesFactory as dY, type FarmIntegrationEndpointValue as dZ, type FarmIntegrationEndpoints as d_, type FarmIntegrationValidationResult as da, type FarmIntegrationStandardValidationResult as db, type FarmIntegrationInputSchema as dc, type FarmIntegrationRouteInputSchemas as dd, type FarmIntegrationRequestContextStore as de, FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY as df, FARM_INTEGRATION_SET_COOKIES_KEY as dg, forwardIntegrationSetCookies as dh, type FarmIntegrationRouteDb as di, type FarmIntegrationRouteStorageArgs as dj, type FarmIntegrationRouteArgs as dk, type FarmIntegrationConfigContext as dl, type FarmIntegrationConfigDefinition as dm, type FarmIntegrationConfigInput as dn, type FarmIntegrationLifecycleLogLevel as dp, type FarmIntegrationLifecycleLogger as dq, type FarmIntegrationLifecycleContext as dr, type FarmIntegrationLifecycleHook as ds, type FarmIntegrationData as dt, type FarmIntegrationHandlerContext as du, type FarmIntegrationRouteHookContext as dv, type FarmIntegrationRouteHook as dw, type FarmIntegrationRoute as dx, type FarmTypedIntegrationRoute as dy, type FarmIntegrationRouteMiddleware as dz, type FarmRequest as e, type FarmRouteRules as e$, type FarmIntegrationEndpointsFactory as e0, createIntegrationRoute as e1, integrationRoute as e2, type DefinedIntegration as e3, defineIntegration as e4, isFarmIntegration as e5, resolveIntegrationPlugins as e6, getIntegrationProviders as e7, isFarmIntegrationProviderComponentReference as e8, getIntegrationDocumentNavigationMatchers as e9, DEFAULT_FARM_API_BASE_PATH as eA, type FarmAPIConfigResolverContext as eB, type FarmAPIConfigValue as eC, type FarmAPIConfig as eD, resolveFarmAPIConfig as eE, normalizeFarmAPIConfig as eF, normalizeFarmAPIBasePath as eG, getFarmAPIBaseURL as eH, resolveFarmAPIRequestURL as eI, type MiddlewareFunction as eJ, type RequestMiddleware as eK, type RequestMiddlewareContext as eL, type MiddlewareStore as eM, type MiddlewareChain as eN, type CookieJar as eO, type CookieOptions as eP, type RateLimitConfig as eQ, type RateLimitIncrementResult as eR, type RateLimitStorage as eS, type RateLimitStatus as eT, type MemoryRateLimitStorageOptions as eU, type NextFunction as eV, type MiddlewareResult as eW, type FarmRouteRuleRenderMode as eX, type FarmRouteRuleRedirect as eY, type FarmRouteRuleCors as eZ, type FarmRouteRule as e_, getIntegrationSchemas as ea, getRegisteredIntegrationRuntime as eb, getRegisteredIntegrations as ec, getRegisteredIntegrationSchemas as ed, matchIntegrationRoute as ee, matchRegisteredIntegrationRoute as ef, getRegisteredIntegrationAPIManifest as eg, dispatchIntegrationRequest as eh, dispatchIntegrationRequests as ei, describeIntegrationOriginRejection as ej, resolveIntegrationAllowedOrigins as ek, validateIntegrationRequestOrigin as el, type IntegrationOriginPolicy as em, type IntegrationOriginRejection as en, type IntegrationOriginResult as eo, type FarmIntegrationOrmSchema as ep, type FarmIntegrationOrmClient as eq, type InferFarmIntegrationOrmField as er, type InferFarmIntegrationOrmFields as es, type InferFarmIntegrationOrmSchema as et, type InferFarmIntegrationOrmClient as eu, type CreateIntegrationOrmOptions as ev, createIntegrationOrm as ew, resolveIntegrationOrmRuntimeClient as ex, farmIntegrationSchemaToOrmSchema as ey, type IntegrationOrmModelNames as ez, type FarmResponse as f, normalizeRouteRules as f0, routeRulesToRedirects as f1, routeRulesToHeaders as f2, routeRulesToNitroRouteRules as f3, type FarmRouteRuntimeEntryKind as f4, type FarmRouteRenderingMode as f5, type FarmRouteRuntimeManifestEntry as f6, type FarmRouteRuntimeManifest as f7, normalizeFarmRouteRuntimeConfig as f8, mergeFarmRouteRuntimeConfigs as f9, type FarmPageFormAction as fA, extractFarmPageActions as fB, DEFAULT_FARM_DEVTOOLS_SHORTCUT as fC, FARM_DEVTOOLS_PATH as fD, FARM_DEVTOOLS_LAUNCH_PARAM as fE, type FarmDevtoolsConfig as fF, type FarmDevtoolsUserConfig as fG, resolveFarmDevtoolsConfig as fH, type FarmBuildActivityPosition as fI, type FarmDevIndicatorsConfig as fJ, resolveFarmDevIndicatorsConfig as fK, generateFarmDevIndicatorsClientRuntime as fL, farmI18nClientBridgePlugin as fM, farmServerOnlyEntriesPlugin as fN, withFarmRequestTracing as fO, rewriteEarlySsrRelativeImports as fP, transformIsolatedClientBoundaryModule as fQ, shouldEmitFarmClientRootHmr as fR, generateClientCachePersistenceCode as fS, resolveFarmClientCacheAdapterEntry as fT, type ClientCachePersistenceEntryCode as fU, FARM_NODE_RESPONSE_END_PENDING as fV, loadFarmDevModule as fW, FarmDevEnvironmentError as fX, type FarmDevModuleServer as fY, resolveFarmRouteRuntimeConfig as fa, hasFarmRouteRuntimeControls as fb, getFarmRouteRuntimeConfig as fc, createFarmRouteRuntimeKey as fd, resolveFarmRouteRuleRuntimeConfig as fe, farmRouteRuleMatches as ff, type FarmMarkdownRouteInput as fg, type FarmMarkdownResolvedRoute as fh, type FarmMarkdownMirrorTarget as fi, type ResolveMarkdownMirrorTargetOptions as fj, type CreateMarkdownMirrorResponseOptions as fk, type ApplyMarkdownNegotiationHeadersOptions as fl, resolveMarkdownConfig as fm, resolveMarkdownMirrorTarget as fn, createMarkdownMirrorResponse as fo, applyMarkdownNegotiationHeaders as fp, htmlToMarkdown as fq, farmAcceptQuality as fr, requestAcceptsMarkdown as fs, getFarmMarkdownMirrorPath as ft, getFarmMarkdownAlternatePath as fu, isFarmMarkdownMirrorExposed as fv, matchesFarmMarkdownRoutePattern as fw, type FarmPageFormOption as fx, type FarmPageFormField as fy, type FarmPageFormSubmit as fz, getFarmRedirectError as g, type FarmPluginContext as h, isFarmNotFoundError as i, type FarmRouteRuntime as j, type FarmRouteRegions as k, type FarmRouteMaxDuration as l, type FarmAppContext as m, notFound as n, type PageProps as o, permanentRedirect as p, type PluginContextProps as q, redirect as r, type RouteModule as s, type FarmMdxComponents as t, type FarmMdxResolvedConfig as u, resolveFarmMdxComponentsModulePath as v, resolveMdxConfig as w, type FarmMdxComponent as x, type FarmMdxUserConfig as y, FARM_MARKDOWN_CONTENT_TYPE as z };