@farm.js/core 0.1.25 → 0.1.27

package/dist/{client-plugins-DPG0NeZN.d.mts → client-plugins-1GS4zubE.d.mts}

@@ -1,16 +1,17 @@
 import { n as FarmClientPlugin } from './lifecycle-DK06VuKP.mjs';
-import { R as RouteMethod, g as PluginRoutes, P as PluginRoutesFactory } from './route-B0XrsrFk.mjs';
-import { T as TypedEndpoint, d as EndpointMCPMetadata, R as RouteSchema, a as RouteSchemaOutput, c as RouteSchemaInput, Y as OpenAPISecurityMode } from './endpoint-DAc96i93.mjs';
+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-0y4FXJpC.mjs';
+import { Y as OpenAPISecurityMode, T as TypedEndpoint, E as EndpointMCPMetadata, R as RouteSchema, b as RouteSchemaOutput, d as RouteSchemaInput } from './endpoint-CCHFqyTE.mjs';
 import { FarmRenderer } from './renderer.mjs';
 import { IncomingMessage, ServerResponse } from 'http';
-import { FarmMarkdownResolvedConfig, FarmMarkdownUserConfig } from './markdown.mjs';
+import { ServerFn } from './server-fn.mjs';
+import { ServerQuery } from './server-query.mjs';
+import { g as FarmI18nUserConfig, R as ResolvedFarmI18nConfig } from './types-Z0aotQ8w.mjs';
 import { d as FarmStorageUserConfig } from './types-Cc8l9IqS.mjs';
 import { FarmSchemaField, FarmSchema, FarmSchemaModel, FarmSchemaReference, FarmSchemaFieldType, FarmSchemaConstraint, FarmSchemaModelExtension, FarmSchemaModelOverride, defineSchema, FarmSchemaConfig } from './schema.mjs';
 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.mjs';
 import { OrmClient, SchemaDefinition, ModelDefinition, FieldBuilder, JsonValue, AnyModelDefinition, SchemaModels } from '@farming-labs/orm';
 import { a as FarmDocsUserConfig, F as FarmDocsResolvedConfig } from './types-DFbjpjXX.mjs';
-import { FarmObservabilityUserConfig } from './observability.mjs';
+import { L as FarmObservabilityUserConfig } from './observability-BupkiN0m.mjs';
 import * as vite from 'vite';
 import { ViteDevServer, UserConfig, Plugin as Plugin$1, Connect } from 'vite';
 import { k as FarmWorkflowsUserConfig, a as FarmServerConfig, F as FarmWorkflowsResolvedConfig, R as ResolvedFarmServerConfig } from './workflows-CR9ex-gz.mjs';
@@ -20,339 +21,232 @@ 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.mjs';
-import { g as FarmI18nUserConfig, R as ResolvedFarmI18nConfig } from './types-Z0aotQ8w.mjs';
 import { FarmCacheUserConfig } from './cache.mjs';
-import { ServerFn } from './server-fn.mjs';
-import { ServerQuery } from './server-query.mjs';
 import { R as ResolvedFarmThemeConfig, d as FarmThemeConfig } from './types-DQnyD3VD.mjs';
 import { FarmLayoutFonts } from './font.mjs';
 import { _withAfterNodeMiddleware } from './after.mjs';
 import { F as FarmIslandStrategy } from './island-CfGru1MO.mjs';
 
-interface FarmLlmsTxtLink {
-    title: string;
-    url: string;
-    description?: string;
-}
-interface FarmLlmsTxtSection {
-    title: string;
-    links: FarmLlmsTxtLink[];
-}
-interface FarmLlmsTxt {
-    /** Site or project name, rendered as the `# H1`. Required by the format. */
-    title: string;
-    /** One-sentence summary, rendered as a `> blockquote`. */
-    summary?: string;
-    /** Free-form Markdown placed after the summary. */
-    details?: string;
-    /** `## H2` sections of links. A section titled "Optional" marks skippable links. */
-    sections?: FarmLlmsTxtSection[];
+/** @internal The environment registry is owned and closed by Vite. */
+interface FarmDevModuleServer {
+    environments: Record<string, unknown>;
 }
-/** 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;
+/** @internal Distinguishes an unsupported runtime from a module evaluation error. */
+declare class FarmDevEnvironmentError extends Error {
 }
-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[];
+/** @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;
+};
+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;
-}): 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.
+ * 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: () => Promise<string>) => 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;
+/** 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 ResolvedFarmAgentCrawlers {
-    enabled: boolean;
-    search?: FarmCrawlerPolicy;
-    training?: FarmCrawlerPolicy;
-    rules: MetadataRoute.RobotsRule[];
-    sitemap?: string[];
+interface ResolvedClientCacheAdapterEntry {
+    /** Absolute adapter module path with forward slashes, ready for codegen. */
+    importPath: string;
+    options: {
+        version?: string;
+        flushDelayMs?: number;
+    };
 }
-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;
+interface ClientCachePersistenceEntryCode {
+    imports: string;
+    init: string;
 }
-/** The robots.txt `agent.crawlers` serves. */
-declare function createFarmAgentRobots(options: FarmAgentRobotsOptions): MetadataRoute.Robots;
-
 /**
- * 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.
+ * 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;
 
-/** 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. `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;
+type FarmRedirectStatus = 301 | 302 | 303 | 307 | 308;
+interface FarmRedirectSignal {
+    url: string;
+    status: FarmRedirectStatus;
 }
+declare function redirect(url: string, status?: FarmRedirectStatus): never;
+declare function permanentRedirect(url: string): never;
+declare function notFound(): never;
+declare function isFarmRedirectError(error: unknown): boolean;
+declare function getFarmRedirectError(error: unknown): FarmRedirectSignal | null;
+declare function isFarmNotFoundError(error: unknown): boolean;
 
 /**
  * Integration auth routes accept ordinary form posts, which browsers send
@@ -445,1011 +339,1164 @@ 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>;
-}
-/** @internal Distinguishes an unsupported runtime from a module evaluation error. */
-declare class FarmDevEnvironmentError extends Error {
-}
-/** @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;
-};
-type ResolvedSchemaModel = Omit<FarmSchemaModel, "fields"> & {
-    name: string;
-    fields: Record<string, ResolvedSchemaField>;
-};
-/**
- * Resolve a schema's extensions, overrides, and name mappings.
- *
- * Table and column names fall back to the schema's own keys, which is what the
- * runtime ORM uses. Any other default would generate artifacts describing
- * tables the app cannot actually read.
- */
-declare function resolveSchemaModels(ownerKey: string, schema: FarmSchema): Record<string, ResolvedSchemaModel>;
-
-type FarmSqlDialect = "postgres" | "mysql" | "sqlite";
-type CollectedSchemaModel = {
-    /** Namespace that owns the model: an integration key or a plugin name. */
-    ownerKey: string;
-    modelKey: string;
-    modelName: string;
-    exportName: string;
-    prismaModelName: string;
-    model: ResolvedSchemaModel;
-    /**
-     * Real table and column for references to models this owner describes but
-     * does not create (external, or outside its `models`), keyed by field. Only
-     * shown in comments: Farm never creates a foreign key to them.
-     */
-    referenceTargets?: Record<string, {
-        table: string;
-        column: string;
-    }>;
-    /**
-     * References to tables other owners create that may carry a real foreign
-     * key, keyed by field. Set by migrate after checking the database; only a
-     * table created now gets one inline.
-     */
-    foreignKeys?: Record<string, {
-        table: string;
-        column: string;
-        onDelete: NonNullable<FarmSchemaReference["onDelete"]>;
-    }>;
-};
-/** `table.column` a field's reference points at, using real names when known. */
-declare function describeSchemaReference(model: CollectedSchemaModel, fieldKey: string): string;
-/**
- * Flatten owners' schemas into one list, rejecting two models that would
- * resolve to the same table.
- *
- * `only` narrows an owner to the models it actually controls; an owner handed a
- * schema it shares with the rest of the app should not claim all of it.
- */
-declare function collectSchemaModels(entries: ReadonlyArray<readonly [string, FarmSchema, (readonly string[])?]>): CollectedSchemaModel[];
-type FarmSqlStatement = {
-    kind: "table" | "index" | "column";
-    /** The object this statement creates, for drift reporting. */
-    target: string;
-    sql: string;
+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;
 };
-/**
- * Emit create statements for a set of models.
- *
- * Everything here is derivable from the schema: nothing is inferred from a live
- * database, so the output is stable and reviewable before it is applied.
- */
-declare function generateSqlStatements(models: readonly CollectedSchemaModel[], dialect: FarmSqlDialect): FarmSqlStatement[];
-/** Render models as a standalone `.sql` file. */
-declare function renderSqlSchemaFile(models: readonly CollectedSchemaModel[], dialect: FarmSqlDialect): string;
-declare function getSqlColumnType(field: ResolvedSchemaField, dialect: FarmSqlDialect): "BOOLEAN" | "INTEGER" | "DOUBLE PRECISION" | "TIMESTAMPTZ" | "JSONB" | "TEXT" | "INT" | "DOUBLE" | "DATETIME" | "JSON" | "VARCHAR(255)" | "REAL";
-declare function getSqlDefaultExpression(field: ResolvedSchemaField, dialect: FarmSqlDialect): string | null;
-declare function isNullableField(field: ResolvedSchemaField): boolean;
-declare function quoteSqlIdentifier(dialect: FarmSqlDialect, value: string): string;
-declare function toSnakeCase(value: string): string;
-declare function toPascalCase(value: string): string;
-declare function toCamelCase(value: string): string;
-declare function escapeSqlString(value: string, dialect?: FarmSqlDialect): string;
-
-/**
- * An ordered change a plugin release makes to its own tables that Farm will
- * not infer: a rename looks exactly like a removal plus an addition. Each step
- * runs once per database, in the order listed.
- *
- * Names are the plugin's own: `model` and `to` are keys in the current
- * schema, so the app's renames apply; `from` is the old name in the database.
- */
-type FarmSchemaMigrationStep = {
-    id: string;
-    description?: string;
-} & ({
-    renameColumn: {
-        model: string;
-        from: string;
-        to: string;
-    };
-} | {
-    renameTable: {
-        from: string;
-        to: string;
-    };
+interface FarmIntegrationRouteInput<TBody = unknown, TQuery = unknown> {
+    body?: TBody;
+    query?: TQuery;
 }
-/**
- * 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;
-    };
+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;
 } | {
-    /** 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;
+    success: false;
+    error: FarmIntegrationValidationErrorLike;
 };
-interface FarmPluginOptionsIssue {
-    readonly message: string;
-    readonly path?: ReadonlyArray<FarmPluginOptionsIssuePathSegment> | undefined;
-}
-type FarmPluginOptionsResult<TOutput> = {
-    readonly value: TOutput;
-    readonly issues?: undefined;
+type FarmIntegrationStandardValidationResult<TValue> = {
+    value: TValue;
 } | {
-    readonly issues: ReadonlyArray<FarmPluginOptionsIssue>;
+    issues: readonly {
+        path?: readonly FarmIntegrationValidationPathSegment[];
+        code?: string;
+        message: string;
+    }[];
 };
-/** The part of the Standard Schema interface plugin options need. */
-interface FarmPluginOptionsSchema<TInput = unknown, TOutput = TInput> {
-    readonly "~standard": {
-        readonly version: 1;
-        readonly vendor: string;
-        readonly validate: (value: unknown) => MaybePromise$2<FarmPluginOptionsResult<TOutput>>;
-        readonly types?: {
-            readonly input: TInput;
-            readonly output: TOutput;
-        } | undefined;
-    };
-}
-/** What the app passes to the plugin factory. */
-type InferPluginOptionsInput<TSchema> = TSchema extends FarmPluginOptionsSchema<infer TInput, any> ? TInput : never;
-/** What the plugin receives, after parsing and defaults. */
-type InferPluginOptionsOutput<TSchema> = TSchema extends FarmPluginOptionsSchema<any, infer TOutput> ? TOutput : never;
-/**
- * The factory a plugin exports. Options can be left out when every option is
- * optional, so `plugin()` and `plugin({})` mean the same thing.
- */
-type FarmPluginFactory<TInput, TPlugin> = {} extends TInput ? (options?: TInput) => TPlugin : (options: TInput) => TPlugin;
-/** Thrown when an app passes options its plugin's schema rejects. */
-declare class FarmPluginOptionsError extends TypeError {
-    readonly issues: ReadonlyArray<FarmPluginOptionsIssue>;
-    constructor(issues: ReadonlyArray<FarmPluginOptionsIssue>);
-}
-
-interface ResolvedClientCacheAdapterEntry {
-    /** Absolute adapter module path with forward slashes, ready for codegen. */
-    importPath: string;
-    options: {
-        version?: string;
-        flushDelayMs?: number;
+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 ClientCachePersistenceEntryCode {
-    imports: string;
-    init: string;
+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 `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.
+ * 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 resolveFarmClientCacheAdapterEntry(root: string, cache: FarmCacheUserConfig | undefined): ResolvedClientCacheAdapterEntry | undefined;
+declare const FARM_INTEGRATION_SET_COOKIES_KEY = "farm:integration:set-cookies";
 /**
- * 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.
+ * 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 generateClientCachePersistenceCode(entry: ResolvedClientCacheAdapterEntry | undefined): ClientCachePersistenceEntryCode;
-
-type FarmRedirectStatus = 301 | 302 | 303 | 307 | 308;
-interface FarmRedirectSignal {
-    url: string;
-    status: FarmRedirectStatus;
+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>>;
 }
-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 FarmIntegrationRouteArgs<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    db: FarmIntegrationRouteDb<TSchema>;
+    getDb(): Promise<FarmIntegrationRouteDb<TSchema>>;
+    storage: FarmIntegrationRouteStorageArgs<TSchema>;
 }
-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 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;
 }
-/**
- * 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 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 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";
+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>;
 /**
- * Cookie management interface
+ * Small per-call integration metadata. Values received over HTTP are
+ * client-controlled and should be validated before authorization decisions.
  */
-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>;
+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 RateLimitIncrementResult {
-    count: number;
-    /** Unix epoch timestamp in milliseconds when the fixed window resets. */
-    resetAt: number;
+interface FarmIntegrationRouteHookContext<TBody = unknown, TQuery = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationHandlerContext<TBody, TQuery, TSchema> {
+    response?: Response;
 }
-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;
+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 MemoryRateLimitStorageOptions {
-    /** Maximum number of active keys retained by this process. */
-    maxEntries?: number;
+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 RateLimitConfig {
-    requests: number;
-    window: string;
-    keyGenerator?: (ctx: MiddlewareContext) => string;
-    onLimit?: (ctx: MiddlewareContext) => void | Response | Promise<void | Response>;
-    storage?: RateLimitStorage;
+interface FarmIntegrationRouteMiddleware<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, TSchema>): Promise<Response | void> | Response | void;
 }
-interface RateLimitStatus {
-    requests: number;
-    limit: number;
-    remaining: number;
-    resetIn: number | null;
-    resetAt: Date | null;
-    isLimited: boolean;
+interface FarmIntegrationMiddleware<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    matcher?: string | string[];
+    handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, TSchema>): Promise<Response | void> | Response | void;
 }
-/**
- * Middleware configuration
- */
-type MiddlewareMatcher = string | RegExp | ((ctx: MiddlewareContext) => boolean);
-interface MiddlewareConfig$1 {
-    matcher?: MiddlewareMatcher | MiddlewareMatcher[];
-    exclude?: (string | RegExp)[];
-    runtime?: "nodejs" | "edge";
+interface FarmIntegrationProviderProps {
+    children: ReactNode;
 }
-interface MiddlewareConfigEntry extends MiddlewareConfig$1 {
-    handler?: MiddlewareFunction;
-    handlers?: MiddlewareFunction[];
+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 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;
+interface FarmIntegrationProvider {
+    name: string;
+    type: string;
+    props?: Record<string, unknown>;
     /**
-     * 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
+     * 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.
      */
-    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;
+    supportsIsolatedHydration?: boolean;
+    component?: ComponentType<FarmIntegrationProviderProps> | FarmIntegrationProviderComponentReference;
 }
-
-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 FarmIntegrationDocumentNavigation {
+    matcher: string | readonly string[];
 }
-interface FarmMdxResolvedConfig {
-    components?: string | FarmMdxComponents;
-    markdownRoutes: boolean;
-    className: string;
+/** @deprecated Use `FarmSchemaFieldType`. */
+type FarmIntegrationSchemaFieldType = FarmSchemaFieldType;
+/** @deprecated Use `FarmSchemaReference`. */
+type FarmIntegrationSchemaReference = FarmSchemaReference;
+/** @deprecated Use `FarmSchemaField`. */
+type FarmIntegrationSchemaField = FarmSchemaField;
+/** @deprecated Use `FarmSchemaConstraint`. */
+type FarmIntegrationSchemaConstraint = FarmSchemaConstraint;
+/** @deprecated Use `FarmSchemaModel`. */
+type FarmIntegrationSchemaModel = FarmSchemaModel;
+/** @deprecated Use `FarmSchemaModelExtension`. */
+type FarmIntegrationSchemaModelExtension = FarmSchemaModelExtension;
+/** @deprecated Use `FarmSchemaModelOverride`. */
+type FarmIntegrationSchemaModelOverride = FarmSchemaModelOverride;
+/** @deprecated Use `FarmSchema`. */
+type FarmIntegrationSchema = FarmSchema;
+/** @deprecated Use `defineSchema`. This is an exact alias, not a wrapper. */
+declare const defineIntegrationSchema: typeof defineSchema;
+type FarmIntegrationLogPhase = "registered" | "validate" | "setup" | "ready" | "dispose" | "request:start" | "request:end" | "request:error";
+interface FarmIntegrationLogEvent {
+    category: FarmIntegrationCategory;
+    /** @deprecated Use category instead. */
+    slot: FarmIntegrationCategory;
+    type: string;
+    phase: FarmIntegrationLogPhase;
+    route?: {
+        kind: "route" | "middleware";
+        path: string;
+        methods: readonly string[];
+    };
+    requestId?: string;
+    request?: Request;
+    response?: Response;
+    error?: unknown;
+    durationMs?: number;
+    level?: FarmIntegrationLifecycleLogLevel;
+    message?: string;
+    meta?: Record<string, unknown>;
+    context: Map<string, unknown>;
 }
-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;
+type FarmIntegrationLogger = (event: FarmIntegrationLogEvent) => void | Promise<void>;
+interface FarmIntegrationPluginOwner {
+    key: string;
+    category: FarmIntegrationCategory;
+    type: string;
+    source: "lifecycle" | "contribution";
+    serverRuntime: boolean;
 }
-interface ResolvedFarmRouteRuntimeConfig {
-    runtime: FarmRouteRuntime;
-    regions?: string[];
-    maxDuration?: number;
+/** 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 FarmRouteRuntimeEntryKind = "page" | "api" | "metadata" | "rule";
-type FarmRouteRenderingMode = "static" | "dynamic";
-interface FarmRouteRuntimeManifestEntry extends ResolvedFarmRouteRuntimeConfig {
-    kind: FarmRouteRuntimeEntryKind;
-    pattern: string;
-    rendering: FarmRouteRenderingMode;
-    source?: string;
+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 FarmRouteRuntimeManifest {
-    version: 1;
-    routes: FarmRouteRuntimeManifestEntry[];
+interface FarmIntegrationRoutesFactoryContext<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
+    route: FarmIntegrationRouteFactory<TSchema>;
+    integrationRoute: FarmIntegrationRouteFactory<TSchema>;
 }
-declare function normalizeFarmRouteRuntimeConfig(value: FarmRouteRuntimeConfig | null | undefined, source?: string): FarmRouteRuntimeConfig;
-/** Merge from lowest to highest precedence. Explicit "auto" values reset inherited hints. */
-declare function mergeFarmRouteRuntimeConfigs(...configs: Array<FarmRouteRuntimeConfig | null | undefined>): FarmRouteRuntimeConfig;
-declare function resolveFarmRouteRuntimeConfig(config: FarmRouteRuntimeConfig | null | undefined, source?: string): ResolvedFarmRouteRuntimeConfig;
-declare function hasFarmRouteRuntimeControls(config: FarmRouteRuntimeConfig | null | undefined): boolean;
-declare function getFarmRouteRuntimeConfig(value: unknown): FarmRouteRuntimeConfig;
-declare function createFarmRouteRuntimeKey(config: ResolvedFarmRouteRuntimeConfig): string;
-/** Resolve matching route rules from broadest to most specific. */
-declare function resolveFarmRouteRuleRuntimeConfig(pathname: string, routeRules: Record<string, FarmRouteRuntimeConfig> | null | undefined): FarmRouteRuntimeConfig;
-declare function farmRouteRuleMatches(pattern: string, pathname: string): boolean;
-
-type FarmRouteRuleRenderMode = "static" | "dynamic";
-type FarmRouteRuleRedirect = string | {
-    to: string;
-    statusCode?: FarmRedirectStatus;
-    permanent?: boolean;
+type 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 FarmRouteRuleCors = boolean | {
-    origin?: string;
-    methods?: string | readonly string[];
-    headers?: string | readonly string[];
+type FarmIntegrationEndpoints<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = {
+    readonly [key: string]: FarmIntegrationEndpointValue<TSchema> | undefined;
 };
-interface FarmRouteRule extends FarmRouteRuntimeConfig {
-    prerender?: boolean;
-    render?: FarmRouteRuleRenderMode;
-    ssr?: boolean;
-    swr?: boolean | number;
-    isr?: boolean | number;
-    cors?: FarmRouteRuleCors;
-    headers?: Record<string, string>;
-    redirect?: FarmRouteRuleRedirect;
+interface FarmIntegrationEndpointsFactoryContext<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationRoutesFactoryContext<TSchema> {
+    endpoint: FarmIntegrationRouteFactory<TSchema>;
 }
-type FarmRouteRules = Record<string, FarmRouteRule>;
-declare function normalizeRouteRules(routeRules: FarmRouteRules | undefined): FarmRouteRules;
-declare function routeRulesToRedirects(routeRules: FarmRouteRules): RedirectConfig[];
-declare function routeRulesToHeaders(routeRules: FarmRouteRules): HeaderConfig[];
-declare function routeRulesToNitroRouteRules(routeRules: FarmRouteRules): Record<string, any>;
-
-type OxcTransform = (typeof rolldown_utils)["transform"];
-type FarmLayerEntry = string;
-interface ResolvedFarmLayer {
-    /** The value used in `extends`. */
-    source: string;
-    /** Stable name used by the `#layers/<name>` alias. */
-    name: string;
-    /** Absolute layer package or directory root. */
-    root: string;
-    /** Source directory relative to the layer root. */
-    srcDir: string;
-    /** Resolved layer config file when one exists. */
-    configFile?: string;
-}
-interface FarmSourceRoot {
-    name: string;
-    root: string;
-    srcDir: string;
-    layer: boolean;
-}
-interface ResolveFarmLayersOptions {
-    root: string;
-    mode: "development" | "production";
-}
-interface FarmLayerResolution<TConfig extends Record<string, any>> {
-    config: TConfig & {
-        extends?: readonly FarmLayerEntry[];
-        layers: ResolvedFarmLayer[];
+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[];
     };
-    layers: ResolvedFarmLayer[];
-}
-declare function resolveFarmLayers<TConfig extends Record<string, any>>(projectConfig: TConfig, options: ResolveFarmLayersOptions): Promise<FarmLayerResolution<TConfig>>;
-declare function getFarmSourceRoots(config: {
-    root?: string;
-    srcDir?: string;
-    layers?: readonly ResolvedFarmLayer[];
-}): FarmSourceRoot[];
-declare function getFarmAppDirectories(config: {
-    root?: string;
-    srcDir?: string;
-    layers?: readonly ResolvedFarmLayer[];
-}): string[];
-declare function getFarmLayerAliases(layers: readonly ResolvedFarmLayer[] | undefined): Record<string, string>;
-declare function createFarmConfigResolutionPlugin(options: {
-    transform: OxcTransform;
-}): Plugin;
-declare function loadFarmConfigFile<TConfig = Record<string, any>>(configPath: string, options: {
-    root: string;
-    cacheRoot?: string;
-}): Promise<TConfig>;
+    params: FarmIntegrationRouteParams;
+} | null;
+declare function matchRegisteredIntegrationRoute(input: {
+    pathname: string;
+    method?: string;
+}): {
+    key: string;
+    integration: FarmIntegration;
+    route: {
+        path: string;
+        methods: readonly string[];
+    };
+    params: FarmIntegrationRouteParams;
+} | null;
+declare function getRegisteredIntegrationAPIManifest(): Record<string, FarmIntegrationAPI>;
+declare function dispatchIntegrationRequest(runtime: RegisteredIntegrationRuntime, request: Request, options?: {
+    currentRequest?: Request;
+    data?: FarmIntegrationData;
+    internal?: boolean;
+    /**
+     * Receives `Set-Cookie` values that a middleware forwarded via
+     * forwardIntegrationSetCookies while returning `void`, when this dispatch
+     * ends without a Response of its own. The request continues downstream, so
+     * the caller owns merging them onto whatever response it finally produces.
+     * Only called on the `null` return path: a Response returned from here has
+     * already had the forwarded cookies appended.
+     */
+    onForwardedCookies?: (cookies: string[]) => void;
+}): Promise<Response | null>;
+/**
+ * Run every configured integration's middleware and routes for one request.
+ *
+ * Integration middleware is not route scoped: it is the mechanism behind
+ * `protectedRoutes` guards and provider session refresh, so it has to run for
+ * ordinary page and API requests that match no integration route at all. That
+ * makes this, not `matchIntegrationRoute`, the correct entry point for a
+ * runtime dispatching integrations for every request.
+ *
+ * The first integration that produces a Response short-circuits the rest.
+ * `Set-Cookie` values forwarded by middleware that returned `void` are
+ * collected: they ride the short-circuiting Response when there is one, and are
+ * otherwise handed back so the caller can merge them onto the downstream
+ * response.
+ */
+declare function dispatchIntegrationRequests(integrations: FarmIntegrationsUserConfig | undefined, runtime: Omit<RegisteredIntegrationRuntime, "integration">, request: Request, options?: {
+    currentRequest?: Request;
+}): Promise<{
+    response: Response | null;
+    setCookies: string[];
+}>;
 
-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.
+ * Farm.js Middleware System
+ *
+ * Type definitions for the middleware system
  */
-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. */
-    buildActivity?: boolean;
-    /** Corner used by the build activity indicator. */
-    buildActivityPosition?: FarmBuildActivityPosition;
-}
-interface ResolvedFarmDevIndicatorsConfig {
-    buildActivity: boolean;
-    buildActivityPosition: FarmBuildActivityPosition;
+/**
+ * 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>]
+    ]>;
 }
-declare function resolveFarmDevIndicatorsConfig(config: FarmDevIndicatorsConfig | undefined, mode?: "development" | "production"): ResolvedFarmDevIndicatorsConfig;
-declare function generateFarmDevIndicatorsClientRuntime(config: ResolvedFarmDevIndicatorsConfig): string;
-
-interface FarmAuthEmailAndPasswordConfig {
-    /** Require a verified email before creating a session. @default false */
-    requireEmailVerification?: boolean;
-    /** Smallest accepted password length. @default 8 */
-    minPasswordLength?: number;
-    /** Largest accepted password length. @default 128 */
-    maxPasswordLength?: number;
+interface 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 FarmAuthSessionConfig {
-    /** Session lifetime in seconds. @default 604800 */
-    expiresIn?: number;
-    /** Session refresh interval in seconds. @default 86400 */
-    updateAge?: number;
+/**
+ * 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 FarmAuthDatabaseConfig {
-    /**
-     * Postgres connection string. Defaults to DATABASE_URL.
-     * Local development falls back to SQLite when no URL is present.
-     */
-    url?: string;
-    /** Local SQLite path. @default ".farm/auth.sqlite" */
+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;
-    /** Automatically update the auth schema in development. @default true */
-    migrateInDevelopment?: boolean;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: "strict" | "lax" | "none";
 }
-interface FarmAuthConfig {
-    /** Set false to disable auth without removing its configuration. @default true */
-    enabled?: boolean;
-    /** Display name used by authentication emails and metadata. */
-    appName?: string;
-    /** Route prefix for the auth endpoints. @default "/api/auth" */
-    basePath?: string;
+/**
+ * Cookie management interface
+ */
+interface CookieJar {
+    get(name: string): string | undefined;
+    set(name: string, value: string, options?: CookieOptions): void;
     /**
-     * Email/password authentication. It is enabled by default; set false to
-     * disable it when adding another sign-in method.
+     * Remove a cookie. Pass the `path`/`domain` it was set with; a tombstone only
+     * matches a cookie with the same scope.
      */
-    emailAndPassword?: boolean | FarmAuthEmailAndPasswordConfig;
-    session?: FarmAuthSessionConfig;
-    database?: FarmAuthDatabaseConfig;
+    delete(name: string, options?: CookieOptions): void;
+    getAll(): Record<string, string>;
 }
-type FarmAuthUserConfig = boolean | FarmAuthConfig;
-interface ResolvedFarmAuthConfig {
-    enabled: boolean;
-    appName?: string;
-    basePath: string;
-    emailAndPassword: {
-        enabled: boolean;
-        requireEmailVerification: boolean;
-        minPasswordLength: number;
-        maxPasswordLength: number;
-    };
-    session: {
-        expiresIn: number;
-        updateAge: number;
-    };
-    database: {
-        url?: string;
-        path: string;
-        migrateInDevelopment: boolean;
-    };
+interface RateLimitIncrementResult {
+    count: number;
+    /** Unix epoch timestamp in milliseconds when the fixed window resets. */
+    resetAt: number;
 }
-
-/** 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 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;
 }
-/** 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;
+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;
 }
 /**
- * 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.
+ * Middleware configuration
  */
-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;
-});
-interface FarmMCPServer {
-    readonly name: string;
-    readonly version: string;
-    readonly path: `/api/${string}`;
+type MiddlewareMatcher = string | RegExp | ((ctx: MiddlewareContext) => boolean);
+interface MiddlewareConfig$1 {
+    matcher?: MiddlewareMatcher | MiddlewareMatcher[];
+    exclude?: (string | RegExp)[];
+    runtime?: "nodejs" | "edge";
 }
-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[];
+interface MiddlewareConfigEntry extends MiddlewareConfig$1 {
+    handler?: MiddlewareFunction;
+    handlers?: MiddlewareFunction[];
 }
-interface FarmMCPAuthorizeContext {
-    request: Request;
-    /** Untrusted requested name for a tools/call; authorization runs separately for every JSON-RPC batch item. */
-    tool?: 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;
+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;
 }
-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[];
-    /** 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;
+/**
+ * Middleware chain interface
+ */
+interface MiddlewareChain {
+    use(fn: MiddlewareFunction): MiddlewareChain;
     /**
-     * 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`.
+     * 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
      */
-    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;
+    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;
+    };
 }
-type FarmMCPUserConfig = FarmMCPConfig | false;
-interface ResolvedFarmMCPConfig extends FarmMCPConfig {
-    enabled: boolean;
+/**
+ * Middleware module export
+ */
+interface MiddlewareModule {
+    default?: MiddlewareChain | MiddlewareFunction;
+    middleware?: RequestMiddleware;
+    config?: MiddlewareConfig$1;
 }
 
-type FarmPreloadMode = "warn" | "enforce";
-interface FarmPreloadUserConfig {
-    /** Report excess hints or remove the lower-priority hints. @default "enforce" */
-    mode?: FarmPreloadMode;
-    /** Maximum image preload hints per document. @default 1 */
-    maxImages?: number;
-    /** Maximum font preload hints per document. @default 2 */
-    maxFonts?: number;
-}
-interface ResolvedFarmPreloadConfig {
-    mode: FarmPreloadMode;
-    maxImages: number;
-    maxFonts: number;
-}
-interface FarmPerformanceConfig {
-    preload?: FarmPreloadUserConfig;
-}
-interface ResolvedFarmPerformanceConfig {
-    preload: ResolvedFarmPreloadConfig;
-}
-type FarmPreloadKind = "image" | "font";
-interface FarmPreloadBudgetWarning {
-    kind: FarmPreloadKind;
-    count: number;
-    budget: number;
-    removed: number;
-}
-interface FarmManagedPreloads {
-    value: string;
-    warnings: FarmPreloadBudgetWarning[];
+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 FarmManagedDocumentPreloads {
-    html: string;
-    linkHeader: string;
-    warnings: FarmPreloadBudgetWarning[];
+interface FarmMdxResolvedConfig {
+    components?: string | FarmMdxComponents;
+    markdownRoutes: boolean;
+    className: string;
 }
+declare function resolveMdxConfig(config: FarmMdxUserConfig | undefined): FarmMdxResolvedConfig;
 /**
- * Apply image and font budgets to HTML preload elements. High-priority image
- * hints are retained before ordinary hints, making an explicitly preloaded LCP
- * image the winner when a document contains too many React-generated hints.
+ * 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 manageFarmHtmlPreloads(html: string, config: ResolvedFarmPreloadConfig): FarmManagedPreloads;
-/** Apply the same budgets to HTTP Link preload hints, including Farm fonts. */
-declare function manageFarmLinkHeaderPreloads(value: string, config: ResolvedFarmPreloadConfig): FarmManagedPreloads;
-/** Apply a single document budget across HTML and HTTP Link header hints. */
-declare function manageFarmDocumentPreloads(html: string, linkHeader: string, config: ResolvedFarmPreloadConfig): FarmManagedDocumentPreloads;
-/** Rate-limit identical route-and-budget warnings within a server process. */
-declare function reportFarmPreloadWarnings(warnings: FarmPreloadBudgetWarning[], context?: string): void;
+declare function resolveFarmMdxComponentsModulePath(config: FarmMdxResolvedConfig | undefined, root: string): string | undefined;
 
-type FarmCspDirectiveValue = string | readonly string[] | boolean | null | undefined;
-type FarmCspDirectives = Readonly<Record<string, FarmCspDirectiveValue>>;
-interface FarmCspOptions {
-    /** A pre-serialized CSP value. Cannot be combined with directives. */
-    policy?: string;
-    /** CSP directives using camelCase or kebab-case names. */
-    directives?: FarmCspDirectives;
-    /** Emit Content-Security-Policy-Report-Only instead of enforcing the policy. */
-    reportOnly?: boolean;
-    /**
-     * Generate a fresh nonce for every dynamic HTML response and per-page
-     * script hashes for prerendered HTML. Farm adds the matching sources to the
-     * governing script directive and stamps dynamic script elements with the
-     * response nonce.
-     */
-    nonce?: boolean;
+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;
 }
-type FarmCspConfig = string | FarmCspOptions;
-interface FarmSecurityConfig {
-    /** App-wide CSP for dynamic responses and prerendered output. */
-    csp?: FarmCspConfig | false;
-    /** @deprecated Use csp. */
-    contentSecurityPolicy?: never;
+interface ResolvedFarmRouteRuntimeConfig {
+    runtime: FarmRouteRuntime;
+    regions?: string[];
+    maxDuration?: number;
 }
-interface ResolvedFarmCspConfig {
-    value: string;
-    reportOnly: boolean;
-    nonce: boolean;
+type FarmRouteRuntimeEntryKind = "page" | "api" | "metadata" | "rule";
+type FarmRouteRenderingMode = "static" | "dynamic";
+interface FarmRouteRuntimeManifestEntry extends ResolvedFarmRouteRuntimeConfig {
+    kind: FarmRouteRuntimeEntryKind;
+    pattern: string;
+    rendering: FarmRouteRenderingMode;
+    source?: string;
 }
-interface ResolvedFarmSecurityConfig {
-    csp: ResolvedFarmCspConfig | false;
+interface FarmRouteRuntimeManifest {
+    version: 1;
+    routes: FarmRouteRuntimeManifestEntry[];
 }
-declare function resolveFarmSecurityConfig(input: FarmSecurityConfig | ResolvedFarmSecurityConfig | undefined): ResolvedFarmSecurityConfig;
-declare function applyFarmCspNonceToResponse(response: Response, security: ResolvedFarmSecurityConfig): Response;
+declare function normalizeFarmRouteRuntimeConfig(value: FarmRouteRuntimeConfig | null | undefined, source?: string): FarmRouteRuntimeConfig;
+/** Merge from lowest to highest precedence. Explicit "auto" values reset inherited hints. */
+declare function mergeFarmRouteRuntimeConfigs(...configs: Array<FarmRouteRuntimeConfig | null | undefined>): FarmRouteRuntimeConfig;
+declare function resolveFarmRouteRuntimeConfig(config: FarmRouteRuntimeConfig | null | undefined, source?: string): ResolvedFarmRouteRuntimeConfig;
+declare function hasFarmRouteRuntimeControls(config: FarmRouteRuntimeConfig | null | undefined): boolean;
+declare function getFarmRouteRuntimeConfig(value: unknown): FarmRouteRuntimeConfig;
+declare function createFarmRouteRuntimeKey(config: ResolvedFarmRouteRuntimeConfig): string;
+/** Resolve matching route rules from broadest to most specific. */
+declare function resolveFarmRouteRuleRuntimeConfig(pathname: string, routeRules: Record<string, FarmRouteRuntimeConfig> | null | undefined): FarmRouteRuntimeConfig;
+declare function farmRouteRuleMatches(pattern: string, pathname: string): boolean;
 
-declare const DEFAULT_FARM_API_BASE_PATH = "/api";
-interface FarmAPIConfigResolverContext {
-    root: string;
-    mode: "development" | "production";
-    env: ResolvedFarmEnv;
-}
-type FarmAPIConfigValue = string | undefined | ((context: FarmAPIConfigResolverContext) => string | undefined | Promise<string | undefined>);
-interface FarmAPIConfig {
-    /**
-     * Public API root. An origin-only URL is joined with `basePath`; a URL that
-     * already has a path is used as-is. May be resolved from deployment context.
-     */
-    baseURL?: FarmAPIConfigValue;
-    /** Public API path and same-origin server mount used when `baseURL` has no path. @default "/api" */
-    basePath?: FarmAPIConfigValue;
-}
-interface ResolvedFarmAPIConfig {
-    /** Fully resolved public API root, either absolute or root-relative. */
-    baseURL: string;
-    /** Effective pathname of `baseURL`. */
-    basePath: string;
+type FarmRouteRuleRenderMode = "static" | "dynamic";
+type FarmRouteRuleRedirect = string | {
+    to: string;
+    statusCode?: FarmRedirectStatus;
+    permanent?: boolean;
+};
+type FarmRouteRuleCors = boolean | {
+    origin?: string;
+    methods?: string | readonly string[];
+    headers?: string | readonly string[];
+};
+interface FarmRouteRule extends FarmRouteRuntimeConfig {
+    prerender?: boolean;
+    render?: FarmRouteRuleRenderMode;
+    ssr?: boolean;
+    swr?: boolean | number;
+    isr?: boolean | number;
+    cors?: FarmRouteRuleCors;
+    headers?: Record<string, string>;
+    redirect?: FarmRouteRuleRedirect;
 }
-declare function resolveFarmAPIConfig(config: FarmAPIConfig | undefined, context: FarmAPIConfigResolverContext): Promise<ResolvedFarmAPIConfig>;
-/** Normalize already-resolved API strings. */
-declare function normalizeFarmAPIConfig(config: {
-    baseURL?: string;
-    basePath?: string;
-} | undefined): ResolvedFarmAPIConfig;
-declare function normalizeFarmAPIBasePath(value: string): string;
-/** Read the API root embedded by Farm's Vite build. */
-declare function getFarmAPIBaseURL(): string;
-/** Resolve a canonical Farm route such as `/api/users` against an API root. */
-declare function resolveFarmAPIRequestURL(routePath: string, baseURL?: string, fallbackOrigin?: string): URL;
-
-declare const FARM_RESOLVED_CUSTOM_CONTEXT: unique symbol;
+type FarmRouteRules = Record<string, FarmRouteRule>;
+declare function normalizeRouteRules(routeRules: FarmRouteRules | undefined): FarmRouteRules;
+declare function routeRulesToRedirects(routeRules: FarmRouteRules): RedirectConfig[];
+declare function routeRulesToHeaders(routeRules: FarmRouteRules): HeaderConfig[];
+declare function routeRulesToNitroRouteRules(routeRules: FarmRouteRules): Record<string, any>;
 
-interface RedirectConfig {
+type OxcTransform = (typeof rolldown_utils)["transform"];
+type FarmLayerEntry = string;
+interface ResolvedFarmLayer {
+    /** The value used in `extends`. */
     source: string;
-    destination: string;
-    permanent?: boolean;
-    statusCode?: FarmRedirectStatus;
+    /** Stable name used by the `#layers/<name>` alias. */
+    name: string;
+    /** Absolute layer package or directory root. */
+    root: string;
+    /** Source directory relative to the layer root. */
+    srcDir: string;
+    /** Resolved layer config file when one exists. */
+    configFile?: string;
 }
-interface HeaderConfig {
-    source: string;
-    headers: Array<{
-        key: string;
-        value: string;
-    }>;
+interface FarmSourceRoot {
+    name: string;
+    root: string;
+    srcDir: string;
+    layer: boolean;
 }
-interface RewriteConfig {
-    source: string;
-    destination: string;
+interface ResolveFarmLayersOptions {
+    root: string;
+    mode: "development" | "production";
 }
-/** @deprecated Use FarmImageConfig. */
-type ImageConfig = FarmImageConfig;
-/** @deprecated Use FarmI18nUserConfig. */
-type I18nConfig = FarmI18nUserConfig;
-interface OpenAPIConfig {
+interface FarmLayerResolution<TConfig extends Record<string, any>> {
+    config: TConfig & {
+        extends?: readonly FarmLayerEntry[];
+        layers: ResolvedFarmLayer[];
+    };
+    layers: ResolvedFarmLayer[];
+}
+declare function resolveFarmLayers<TConfig extends Record<string, any>>(projectConfig: TConfig, options: ResolveFarmLayersOptions): Promise<FarmLayerResolution<TConfig>>;
+declare function getFarmSourceRoots(config: {
+    root?: string;
+    srcDir?: string;
+    layers?: readonly ResolvedFarmLayer[];
+}): FarmSourceRoot[];
+declare function getFarmAppDirectories(config: {
+    root?: string;
+    srcDir?: string;
+    layers?: readonly ResolvedFarmLayer[];
+}): string[];
+declare function getFarmLayerAliases(layers: readonly ResolvedFarmLayer[] | undefined): Record<string, string>;
+declare function createFarmConfigResolutionPlugin(options: {
+    transform: OxcTransform;
+}): Plugin;
+declare function loadFarmConfigFile<TConfig = Record<string, any>>(configPath: string, options: {
+    root: string;
+    cacheRoot?: string;
+}): Promise<TConfig>;
+
+declare const DEFAULT_FARM_DEVTOOLS_SHORTCUT = "mod+shift+.";
+declare const FARM_DEVTOOLS_PATH = "/__farm/devtools";
+declare const FARM_DEVTOOLS_LAUNCH_PARAM = "__farm_devtools";
+/**
+ * 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;
-    route?: string;
+    /** 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. */
+    buildActivity?: boolean;
+    /** Corner used by the build activity indicator. */
+    buildActivityPosition?: FarmBuildActivityPosition;
+}
+interface ResolvedFarmDevIndicatorsConfig {
+    buildActivity: boolean;
+    buildActivityPosition: FarmBuildActivityPosition;
+}
+declare function resolveFarmDevIndicatorsConfig(config: FarmDevIndicatorsConfig | undefined, mode?: "development" | "production"): ResolvedFarmDevIndicatorsConfig;
+declare function generateFarmDevIndicatorsClientRuntime(config: ResolvedFarmDevIndicatorsConfig): string;
+
+interface FarmAuthEmailAndPasswordConfig {
+    /** Require a verified email before creating a session. @default false */
+    requireEmailVerification?: boolean;
+    /** Smallest accepted password length. @default 8 */
+    minPasswordLength?: number;
+    /** Largest accepted password length. @default 128 */
+    maxPasswordLength?: number;
+}
+interface FarmAuthSessionConfig {
+    /** Session lifetime in seconds. @default 604800 */
+    expiresIn?: number;
+    /** Session refresh interval in seconds. @default 86400 */
+    updateAge?: number;
+}
+interface FarmAuthDatabaseConfig {
     /**
-     * Path where the raw OpenAPI spec is served as JSON, so agents and API tools
-     * can fetch it at a predictable URL. Set to `false` to disable.
-     *
-     * @default "/openapi.json"
+     * Postgres connection string. Defaults to DATABASE_URL.
+     * Local development falls back to SQLite when no URL is present.
      */
-    specRoute?: string | false;
-    title?: string;
-    description?: string;
-    version?: string;
-    /** Default authentication requirement for operations without an endpoint override. */
-    security?: OpenAPISecurityMode;
-    servers?: Array<{
-        url: string;
-        description?: string;
-    }>;
-    contact?: {
-        name?: string;
-        email?: string;
-        url?: string;
-    };
-    license?: {
-        name: string;
-        url?: string;
-    };
-}
-type MiddlewareConfig = FarmMiddlewareConfig;
-interface NotFoundConfig {
-    /** Path to a custom 404 page component (e.g., "./src/app/not-found.tsx") */
-    component?: string;
+    url?: string;
+    /** Local SQLite path. @default ".farm/auth.sqlite" */
+    path?: string;
+    /** Automatically update the auth schema in development. @default true */
+    migrateInDevelopment?: boolean;
 }
-type FarmDeployTarget = "vercel" | "cloudflare" | "netlify" | "node" | string;
-interface FarmDeployConfig {
+interface FarmAuthConfig {
+    /** Set false to disable auth without removing its configuration. @default true */
+    enabled?: boolean;
+    /** Display name used by authentication emails and metadata. */
+    appName?: string;
+    /** Route prefix for the auth endpoints. @default "/api/auth" */
+    basePath?: string;
     /**
-     * Deployment platform. When present, Farm picks the matching Nitro preset and
-     * output directory unless explicitly overridden.
+     * Email/password authentication. It is enabled by default; set false to
+     * disable it when adding another sign-in method.
      */
-    target?: FarmDeployTarget;
-    /** Nitro preset override. Usually inferred from target. */
-    preset?: FarmConfig["preset"];
-    /** Deployable output directory, relative to project root unless absolute. */
-    outputDir?: string;
-    /** Alias for outputDir for terser config. */
-    output?: string;
-    /** Cloudflare Pages project name used by `farm deploy --cloudflare`. */
-    projectName?: string;
-    vercel?: {
-        outputDirectory?: string;
-        buildCommand?: string;
-        installCommand?: string;
-        framework?: string | null;
+    emailAndPassword?: boolean | FarmAuthEmailAndPasswordConfig;
+    session?: FarmAuthSessionConfig;
+    database?: FarmAuthDatabaseConfig;
+}
+type FarmAuthUserConfig = boolean | FarmAuthConfig;
+interface ResolvedFarmAuthConfig {
+    enabled: boolean;
+    appName?: string;
+    basePath: string;
+    emailAndPassword: {
+        enabled: boolean;
+        requireEmailVerification: boolean;
+        minPasswordLength: number;
+        maxPasswordLength: number;
     };
-    cloudflare?: {
-        outputDir?: string;
-        projectName?: string;
+    session: {
+        expiresIn: number;
+        updateAge: number;
     };
-    netlify?: {
-        outputDir?: string;
-        site?: string;
+    database: {
+        url?: string;
+        path: string;
+        migrateInDevelopment: boolean;
     };
 }
-interface ResolvedFarmDeployConfig extends Omit<FarmDeployConfig, "output"> {
-    target?: FarmDeployTarget;
-    preset: FarmConfig["preset"];
-    outputDir: string;
+
+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 FarmUserConfig extends Omit<FarmConfig, "vite" | "docs" | "env" | "layers"> {
-    /** Reusable Farm directories or installed packages, applied from left to right. */
-    extends?: readonly FarmLayerEntry[];
-    /** Global plugins. Integration-bound plugins must be contributed through an integration. */
-    plugins?: FarmPlugin<any, any, any, any, unknown, false>[];
-    integrations?: FarmIntegrationsUserConfig;
+interface ResolvedFarmPreloadConfig {
+    mode: FarmPreloadMode;
+    maxImages: number;
+    maxFonts: number;
+}
+interface FarmPerformanceConfig {
+    preload?: FarmPreloadUserConfig;
+}
+interface ResolvedFarmPerformanceConfig {
+    preload: ResolvedFarmPreloadConfig;
+}
+type FarmPreloadKind = "image" | "font";
+interface FarmPreloadBudgetWarning {
+    kind: FarmPreloadKind;
+    count: number;
+    budget: number;
+    removed: number;
+}
+interface FarmManagedPreloads {
+    value: string;
+    warnings: FarmPreloadBudgetWarning[];
+}
+interface FarmManagedDocumentPreloads {
+    html: string;
+    linkHeader: string;
+    warnings: FarmPreloadBudgetWarning[];
+}
+/**
+ * Apply image and font budgets to HTML preload elements. High-priority image
+ * hints are retained before ordinary hints, making an explicitly preloaded LCP
+ * image the winner when a document contains too many React-generated hints.
+ */
+declare function manageFarmHtmlPreloads(html: string, config: ResolvedFarmPreloadConfig): FarmManagedPreloads;
+/** Apply the same budgets to HTTP Link preload hints, including Farm fonts. */
+declare function manageFarmLinkHeaderPreloads(value: string, config: ResolvedFarmPreloadConfig): FarmManagedPreloads;
+/** Apply a single document budget across HTML and HTTP Link header hints. */
+declare function manageFarmDocumentPreloads(html: string, linkHeader: string, config: ResolvedFarmPreloadConfig): FarmManagedDocumentPreloads;
+/** Rate-limit identical route-and-budget warnings within a server process. */
+declare function reportFarmPreloadWarnings(warnings: FarmPreloadBudgetWarning[], context?: string): void;
+
+type FarmCspDirectiveValue = string | readonly string[] | boolean | null | undefined;
+type FarmCspDirectives = Readonly<Record<string, FarmCspDirectiveValue>>;
+interface FarmCspOptions {
+    /** A pre-serialized CSP value. Cannot be combined with directives. */
+    policy?: string;
+    /** CSP directives using camelCase or kebab-case names. */
+    directives?: FarmCspDirectives;
+    /** Emit Content-Security-Policy-Report-Only instead of enforcing the policy. */
+    reportOnly?: boolean;
     /**
-     * Farm-native authentication. `true` enables email/password auth with
-     * server helpers from `@farm.js/auth/server` and React APIs from
-     * `@farm.js/auth/client`.
+     * Generate a fresh nonce for every dynamic HTML response and per-page
+     * script hashes for prerendered HTML. Farm adds the matching sources to the
+     * governing script directive and stamps dynamic script elements with the
+     * response nonce.
      */
-    auth?: FarmAuthUserConfig;
-    /** Compose opted-in API routes and standalone tools through an authenticated MCP transport. */
-    mcp?: FarmMCPUserConfig;
-    /** Shared application data, route, ISR, and PPR cache. */
-    cache?: FarmCacheUserConfig;
-    migrations?: FarmMigrationsUserConfig;
-    /** Map portable cron schedules to ordinary GET API routes. */
+    nonce?: boolean;
+}
+type FarmCspConfig = string | FarmCspOptions;
+interface FarmSecurityConfig {
+    /** App-wide CSP for dynamic responses and prerendered output. */
+    csp?: FarmCspConfig | false;
+    /** @deprecated Use csp. */
+    contentSecurityPolicy?: never;
+}
+interface ResolvedFarmCspConfig {
+    value: string;
+    reportOnly: boolean;
+    nonce: boolean;
+}
+interface ResolvedFarmSecurityConfig {
+    csp: ResolvedFarmCspConfig | false;
+}
+declare function resolveFarmSecurityConfig(input: FarmSecurityConfig | ResolvedFarmSecurityConfig | undefined): ResolvedFarmSecurityConfig;
+declare function applyFarmCspNonceToResponse(response: Response, security: ResolvedFarmSecurityConfig): Response;
+
+declare const DEFAULT_FARM_API_BASE_PATH = "/api";
+interface FarmAPIConfigResolverContext {
+    root: string;
+    mode: "development" | "production";
+    env: ResolvedFarmEnv;
+}
+type FarmAPIConfigValue = string | undefined | ((context: FarmAPIConfigResolverContext) => string | undefined | Promise<string | undefined>);
+interface FarmAPIConfig {
+    /**
+     * Public API root. An origin-only URL is joined with `basePath`; a URL that
+     * already has a path is used as-is. May be resolved from deployment context.
+     */
+    baseURL?: FarmAPIConfigValue;
+    /** Public API path and same-origin server mount used when `baseURL` has no path. @default "/api" */
+    basePath?: FarmAPIConfigValue;
+}
+interface ResolvedFarmAPIConfig {
+    /** Fully resolved public API root, either absolute or root-relative. */
+    baseURL: string;
+    /** Effective pathname of `baseURL`. */
+    basePath: string;
+}
+declare function resolveFarmAPIConfig(config: FarmAPIConfig | undefined, context: FarmAPIConfigResolverContext): Promise<ResolvedFarmAPIConfig>;
+/** Normalize already-resolved API strings. */
+declare function normalizeFarmAPIConfig(config: {
+    baseURL?: string;
+    basePath?: string;
+} | undefined): ResolvedFarmAPIConfig;
+declare function normalizeFarmAPIBasePath(value: string): string;
+/** Read the API root embedded by Farm's Vite build. */
+declare function getFarmAPIBaseURL(): string;
+/** Resolve a canonical Farm route such as `/api/users` against an API root. */
+declare function resolveFarmAPIRequestURL(routePath: string, baseURL?: string, fallbackOrigin?: string): URL;
+
+declare const FARM_RESOLVED_CUSTOM_CONTEXT: unique symbol;
+
+interface RedirectConfig {
+    source: string;
+    destination: string;
+    permanent?: boolean;
+    statusCode?: FarmRedirectStatus;
+}
+interface HeaderConfig {
+    source: string;
+    headers: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+interface RewriteConfig {
+    source: string;
+    destination: string;
+}
+/** @deprecated Use FarmImageConfig. */
+type ImageConfig = FarmImageConfig;
+/** @deprecated Use FarmI18nUserConfig. */
+type I18nConfig = FarmI18nUserConfig;
+interface OpenAPIConfig {
+    enabled?: boolean;
+    route?: string;
+    /**
+     * Path where the raw OpenAPI spec is served as JSON, so agents and API tools
+     * can fetch it at a predictable URL. Set to `false` to disable.
+     *
+     * @default "/openapi.json"
+     */
+    specRoute?: string | false;
+    title?: string;
+    description?: string;
+    version?: string;
+    /** Default authentication requirement for operations without an endpoint override. */
+    security?: OpenAPISecurityMode;
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    contact?: {
+        name?: string;
+        email?: string;
+        url?: string;
+    };
+    license?: {
+        name: string;
+        url?: string;
+    };
+}
+type MiddlewareConfig = FarmMiddlewareConfig;
+interface NotFoundConfig {
+    /** Path to a custom 404 page component (e.g., "./src/app/not-found.tsx") */
+    component?: string;
+}
+type FarmDeployTarget = "vercel" | "cloudflare" | "netlify" | "node" | string;
+interface FarmDeployConfig {
+    /**
+     * Deployment platform. When present, Farm picks the matching Nitro preset and
+     * output directory unless explicitly overridden.
+     */
+    target?: FarmDeployTarget;
+    /** Nitro preset override. Usually inferred from target. */
+    preset?: FarmConfig["preset"];
+    /** Deployable output directory, relative to project root unless absolute. */
+    outputDir?: string;
+    /** Alias for outputDir for terser config. */
+    output?: string;
+    /** Cloudflare Pages project name used by `farm deploy --cloudflare`. */
+    projectName?: string;
+    vercel?: {
+        outputDirectory?: string;
+        buildCommand?: string;
+        installCommand?: string;
+        framework?: string | null;
+    };
+    cloudflare?: {
+        outputDir?: string;
+        projectName?: string;
+    };
+    netlify?: {
+        outputDir?: string;
+        site?: string;
+    };
+}
+interface ResolvedFarmDeployConfig extends Omit<FarmDeployConfig, "output"> {
+    target?: FarmDeployTarget;
+    preset: FarmConfig["preset"];
+    outputDir: string;
+}
+interface FarmUserConfig extends Omit<FarmConfig, "vite" | "docs" | "env" | "layers"> {
+    /** Reusable Farm directories or installed packages, applied from left to right. */
+    extends?: readonly FarmLayerEntry[];
+    /** Global plugins. Integration-bound plugins must be contributed through an integration. */
+    plugins?: FarmPlugin<any, any, any, any, unknown, false>[];
+    integrations?: FarmIntegrationsUserConfig;
+    /**
+     * Farm-native authentication. `true` enables email/password auth with
+     * server helpers from `@farm.js/auth/server` and React APIs from
+     * `@farm.js/auth/client`.
+     */
+    auth?: FarmAuthUserConfig;
+    /** Compose opted-in API routes and standalone tools through an authenticated MCP transport. */
+    mcp?: FarmMCPUserConfig;
+    /** Shared application data, route, ISR, and PPR cache. */
+    cache?: FarmCacheUserConfig;
+    migrations?: FarmMigrationsUserConfig;
+    /** Map portable cron schedules to ordinary GET API routes. */
     cron?: FarmCronUserConfig | FarmCronResolvedConfig | false;
     workflows?: FarmWorkflowsUserConfig | boolean;
     preset?: FarmConfig["preset"];
@@ -1591,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;
@@ -1758,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>;
@@ -1782,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;
@@ -1809,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. */
@@ -1838,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>;
@@ -2000,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`. */
@@ -2041,482 +2088,698 @@ 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;
+/** 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 FarmIntegrationValidationIssue {
-    source: FarmIntegrationRouteInputSource;
-    path?: readonly (string | number)[];
-    code?: string;
-    message: string;
+/** 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;
 }
-interface FarmIntegrationValidationErrorLike {
-    issues?: readonly {
-        path?: readonly FarmIntegrationValidationPathSegment[];
-        code?: string;
-        message?: string;
-    }[];
-    message?: string;
+/**
+ * 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[]>>;
 }
-type FarmIntegrationValidationResult<TValue> = {
-    success: true;
-    data: TValue;
+/**
+ * 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;
 } | {
-    success: false;
-    error: FarmIntegrationValidationErrorLike;
-};
-type FarmIntegrationStandardValidationResult<TValue> = {
-    value: TValue;
+    json: unknown;
 } | {
-    issues: readonly {
-        path?: readonly FarmIntegrationValidationPathSegment[];
-        code?: string;
-        message: string;
-    }[];
+    blob: Uint8Array | ArrayBuffer;
+    mimeType?: string;
 };
-interface FarmIntegrationInputSchema<TValue = unknown> {
-    _output?: TValue;
-    parse?(value: unknown): MaybePromise<TValue>;
-    safeParse?(value: unknown): MaybePromise<FarmIntegrationValidationResult<TValue>>;
-    safeParseAsync?(value: unknown): Promise<FarmIntegrationValidationResult<TValue>>;
-    "~standard"?: {
-        validate(value: unknown): MaybePromise<FarmIntegrationStandardValidationResult<TValue>>;
-        types?: {
-            output: TValue;
-        };
-    };
-}
-interface FarmIntegrationRouteInputSchemas<TBody = unknown, TQuery = unknown> {
-    body?: FarmIntegrationInputSchema<TBody>;
-    query?: FarmIntegrationInputSchema<TQuery>;
+/** One concrete URI a templated resource lists. */
+interface FarmMCPResourceListing {
+    uri: string;
+    name?: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
 }
-/** @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 server-only MCP resource: read-only context an agent can load, at a fixed
+ * `uri` or at every URI matching an RFC 6570 `uriTemplate`.
  */
-declare const FARM_INTEGRATION_SET_COOKIES_KEY = "farm:integration:set-cookies";
+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;
+}
 /**
- * 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.
+ * 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.
  */
-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 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 FarmIntegrationRouteArgs<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
-    db: FarmIntegrationRouteDb<TSchema>;
-    getDb(): Promise<FarmIntegrationRouteDb<TSchema>>;
-    storage: FarmIntegrationRouteStorageArgs<TSchema>;
+interface FarmMCPServer {
+    readonly name: string;
+    readonly version: string;
+    readonly path: `/api/${string}`;
 }
-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 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 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>;
+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;
 }
-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 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 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 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 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.
+ * @internal Publishes one MCP server's tools, replacing an earlier catalog for
+ * the same endpoint. Returns a function that removes it.
  */
-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;
+declare function _publishFarmMCPCatalog(server: FarmMCPServer, tools: readonly FarmMCPTool[]): () => void;
+interface FarmMCPEndpointTool {
+    /** The MCP tool name. */
+    name: string;
+    /** The public path of the MCP endpoint that serves the tool. */
+    endpoint: string;
 }
-interface FarmIntegrationRouteHookContext<TBody = unknown, TQuery = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationHandlerContext<TBody, TQuery, TSchema> {
-    response?: Response;
+/**
+ * @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
+     */
+    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;
 }
-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 FarmMarkdownResolvedRoute {
+    route: string;
+    title?: string;
+    cache?: number | false;
 }
-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 FarmMarkdownResolvedConfig {
+    enabled: boolean;
+    expose: true | FarmMarkdownResolvedRoute[];
+    cache: number | false;
+    includeMetadata: boolean;
 }
-interface FarmIntegrationRouteMiddleware<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
-    handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, TSchema>): Promise<Response | void> | Response | void;
+interface FarmMarkdownMirrorTarget {
+    pathname: string;
+    route: FarmMarkdownResolvedRoute | null;
 }
-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 ResolveMarkdownMirrorTargetOptions {
+    accept?: string | null;
 }
-interface FarmIntegrationProviderProps {
-    children: ReactNode;
+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;
 }
-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;
+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 FarmIntegrationProvider {
+interface FarmPageFormField {
     name: string;
+    /** The input type, or `select`, `textarea`, `radio`, or `checkbox` for a group. */
     type: string;
-    props?: Record<string, unknown>;
+    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";
     /**
-     * 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.
+     * 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.
      */
-    supportsIsolatedHydration?: boolean;
-    component?: ComponentType<FarmIntegrationProviderProps> | FarmIntegrationProviderComponentReference;
+    action?: string;
+    /** Present for POST forms. */
+    enctype?: string;
+    requiresJavaScript?: true;
+    fields: FarmPageFormField[];
+    submit: FarmPageFormSubmit[];
+    /** A React server action form: the id React put in its hidden `$ACTION_` fields. */
+    serverAction?: {
+        id: string;
+    };
+    /**
+     * The MCP tool that runs the same API endpoint, when `@farm.js/mcp` exposes
+     * it: the tool `name` and the MCP `endpoint` to call it at. The caller's
+     * `authorize` policy still decides whether that tool is available to it.
+     */
+    tool?: FarmMCPEndpointTool;
 }
-interface FarmIntegrationDocumentNavigation {
-    matcher: string | readonly string[];
+/**
+ * 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;
 }
-/** @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>;
+interface FarmLlmsTxtSection {
+    title: string;
+    links: FarmLlmsTxtLink[];
 }
-type FarmIntegrationLogger = (event: FarmIntegrationLogEvent) => void | Promise<void>;
-interface FarmIntegrationPluginOwner {
-    key: string;
-    category: FarmIntegrationCategory;
-    type: string;
-    source: "lifecycle" | "contribution";
-    serverRuntime: boolean;
+interface FarmLlmsTxt {
+    /** Site or project name, rendered as the `# H1`. Required by the format. */
+    title: string;
+    /** One-sentence summary, rendered as a `> blockquote`. */
+    summary?: string;
+    /** Free-form Markdown placed after the summary. */
+    details?: string;
+    /** `## H2` sections of links. A section titled "Optional" marks skippable links. */
+    sections?: FarmLlmsTxtSection[];
 }
-/** A 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>>[];
+/** 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 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 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 FarmIntegrationRoutesFactoryContext<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
-    route: FarmIntegrationRouteFactory<TSchema>;
-    integrationRoute: FarmIntegrationRouteFactory<TSchema>;
+interface ResolvedFarmLlmsTxtConfig {
+    enabled: boolean;
+    title?: string;
+    summary?: string;
+    details?: string;
+    include: string[];
+    exclude: string[];
+    full: boolean;
+    revalidate?: number;
 }
-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 FarmLlmsTxtPageSource {
+    pattern: string;
+    metadata?: unknown;
 }
-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;
+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;
+    }
     /**
-     * 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.
+     * 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`.
      */
-    onForwardedCookies?: (cookies: string[]) => void;
-}): Promise<Response | null>;
+    type LlmsTxt = FarmLlmsTxt;
+    type LlmsTxtSection = FarmLlmsTxtSection;
+    type LlmsTxtLink = FarmLlmsTxtLink;
+    /** A static page of the app, usable directly as an llms.txt link. */
+    type LlmsTxtPage = FarmLlmsTxtPage;
+    /** What an `llms.ts` default-export function receives. */
+    interface LlmsTxtContext extends MetadataRouteContext {
+        /** The app's static pages, linking to their Markdown mirrors when exposed. */
+        pages: LlmsTxtPage[];
+        /** The llms.txt that `agent.llmsTxt` would serve, to extend instead of replace. */
+        defaults: LlmsTxt;
+    }
+    /**
+     * What an `llms-full.ts` default-export function receives. Returning an
+     * `LlmsTxt` object inlines each same-origin link's Markdown; returning a string
+     * serves it as the complete file.
+     */
+    interface LlmsFullTxtContext extends LlmsTxtContext {
+        /** A page's Markdown mirror, read without the request's cookies; `null` if unavailable. */
+        markdown(url: string): Promise<string | null>;
+    }
+}
+interface MetadataRouteContext {
+    request: Request;
+    params: Record<string, string>;
+    searchParams: URLSearchParams;
+    /** The concrete route-segment path that owns the metadata file. */
+    path: string;
+}
+interface FarmMetadataRouteModule {
+    revalidate?: number | false;
+}
+interface FarmMetadataRouteResponseOptions {
+    method?: string;
+    /** The request being answered, so llms.txt reads can be reported as agent traffic. */
+    request?: Request;
+}
+/** @internal */
+declare function createFarmMetadataRouteResponse(kind: ApplicationMetadataRouteKind, value: unknown, routeModule?: FarmMetadataRouteModule, options?: FarmMetadataRouteResponseOptions): Response;
+
+type FarmCrawlerPolicy = "allow" | "block";
+interface FarmAgentCrawlers {
+    /** Set to `false` to stop serving the generated robots.txt while keeping these options. */
+    enabled?: boolean;
+    /**
+     * AI search and user-triggered agents such as OAI-SearchBot, Claude-SearchBot,
+     * and PerplexityBot. Left unset, they follow the `User-agent: *` rules.
+     */
+    search?: FarmCrawlerPolicy;
+    /**
+     * AI training crawlers such as GPTBot, ClaudeBot, Google-Extended, and CCBot.
+     * Left unset, they follow the `User-agent: *` rules.
+     */
+    training?: FarmCrawlerPolicy;
+    /**
+     * More robots.txt groups, written after the generated ones. Crawlers combine
+     * groups that name the same agent. A rule for `*` replaces the default
+     * `User-agent: *` / `Allow: /` group.
+     */
+    rules?: MetadataRoute.RobotsRule[];
+    /**
+     * Absolute sitemap URLs. Defaults to the app's `sitemap.ts` route, resolved
+     * against the root layout's `metadataBase`; with neither, no `Sitemap:` line.
+     */
+    sitemap?: string | string[];
+}
+interface ResolvedFarmAgentCrawlers {
+    enabled: boolean;
+    search?: FarmCrawlerPolicy;
+    training?: FarmCrawlerPolicy;
+    rules: MetadataRoute.RobotsRule[];
+    sitemap?: string[];
+}
+interface FarmAgentRobotsOptions {
+    crawlers: ResolvedFarmAgentCrawlers;
+    /** The app's root sitemap route, such as `/sitemap.xml`, when it has one. */
+    sitemapPath?: string;
+    /** The root layout's `metadataBase`, which makes the sitemap URL absolute. */
+    metadataBase?: unknown;
+    basePath?: string;
+}
+/** The robots.txt `agent.crawlers` serves. */
+declare function createFarmAgentRobots(options: FarmAgentRobotsOptions): MetadataRoute.Robots;
+
 /**
- * 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: 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.
  */
-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. `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;
+}
 
 declare global {
     namespace FarmJS {
@@ -3173,4 +3436,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 FarmPluginRuntimeAfterEvent 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 FarmMCPUserConfig as bL, type ResolvedFarmMCPConfig as bM, type PluginRequestContext as bN, type FarmPluginIntegrationContext as bO, type FarmPluginLifecycle as bP, type FarmRequestPluginContext as bQ, type FarmRequestStore as bR, type FarmPluginRuntimeKind as bS, type FarmPluginRouteRuntimePayload as bT, type FarmPluginSetupContext as bU, type FarmPluginStateContext as bV, type FarmPluginRuntimeBaseEvent as bW, type FarmPluginRuntimeContextEvent as bX, type FarmPluginRuntimeEndpoint as bY, type FarmPluginRuntimeEndpointEvent as bZ, type FarmPluginRuntimeBeforeEvent 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 FarmIntegrationRouteInputSchemas as c$, type FarmPluginRuntimeErrorEvent as c0, type FarmPluginRuntimeStartEvent as c1, type FarmPluginRuntimeCloseEvent as c2, type FarmPluginRuntimeHooks as c3, type FarmPluginRuntimeRequestOptions as c4, type FarmPluginRuntimeRequestHandler as c5, type FarmPluginRuntimeSession as c6, type FarmPluginDiscoveredRoute as c7, type FarmPluginRouterHooks as c8, type FarmPluginRenderHooks as c9, describeSchemaReference as cA, collectSchemaModels as cB, generateSqlStatements as cC, renderSqlSchemaFile as cD, getSqlColumnType as cE, getSqlDefaultExpression as cF, isNullableField as cG, quoteSqlIdentifier as cH, toSnakeCase as cI, toPascalCase as cJ, toCamelCase as cK, escapeSqlString as cL, resolveSchemaModels as cM, type ResolvedSchemaModel as cN, type FarmIntegrationCategory as cO, type FarmIntegrationSlot as cP, type FarmIntegrationRouteParamValue as cQ, type FarmIntegrationRouteParams as cR, type FarmIntegrationRouteMethod as cS, type FarmIntegrationRouteInputSource as cT, type FarmIntegrationValidationPathSegment as cU, type FarmIntegrationRouteInput as cV, type FarmIntegrationValidationIssue as cW, type FarmIntegrationValidationErrorLike as cX, type FarmIntegrationValidationResult as cY, type FarmIntegrationStandardValidationResult as cZ, type FarmIntegrationInputSchema as c_, type FarmPluginBuildHooks as ca, type FarmPluginDevHooks as cb, type FarmPluginClientConfig as cc, type RouteDiscoveredPayload as cd, type RoutesGeneratedPayload as ce, type MiddlewareDiscoveredPayload as cf, type APIRouteDiscoveredPayload as cg, type RouteMatchPayload as ch, type RouteMatchResultPayload as ci, type RenderLifecyclePayload as cj, type APIHandlerLifecyclePayload as ck, type ErrorLifecyclePayload as cl, type HMRUpdatePayload as cm, type BundleLifecyclePayload as cn, type NitroBuildLifecyclePayload as co, type ShutdownPayload as cp, type ResolvedFarmConfig as cq, type RedirectConfig as cr, type HeaderConfig as cs, type RewriteConfig as ct, type ImageConfig as cu, type I18nConfig as cv, type MiddlewareConfig as cw, type FarmDeployConfig as cx, type ResolvedFarmDeployConfig as cy, type FarmDeployTarget as cz, type FarmRedirectStatus as d, getRegisteredIntegrationSchemas as d$, type FarmIntegrationRequestContextStore as d0, FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY as d1, FARM_INTEGRATION_SET_COOKIES_KEY as d2, forwardIntegrationSetCookies as d3, type FarmIntegrationRouteDb as d4, type FarmIntegrationRouteStorageArgs as d5, type FarmIntegrationRouteArgs as d6, type FarmIntegrationConfigContext as d7, type FarmIntegrationConfigDefinition as d8, type FarmIntegrationConfigInput as d9, type FarmIntegrationLogPhase as dA, type FarmIntegrationLogEvent as dB, type FarmIntegrationLogger as dC, type FarmIntegrationPluginOwner as dD, type FarmIntegrationContributedPlugin as dE, type FarmIntegrationsUserConfig as dF, getFarmIntegrationPluginServerRuntime as dG, getFarmIntegrationPluginOwner as dH, type FarmIntegrationRouteFactory as dI, type FarmIntegrationRoutesFactoryContext as dJ, type FarmIntegrationRoutesFactory as dK, type FarmIntegrationEndpointValue as dL, type FarmIntegrationEndpoints as dM, type FarmIntegrationEndpointsFactoryContext as dN, type FarmIntegrationEndpointsFactory as dO, createIntegrationRoute as dP, integrationRoute as dQ, type DefinedIntegration as dR, defineIntegration as dS, isFarmIntegration as dT, resolveIntegrationPlugins as dU, getIntegrationProviders as dV, isFarmIntegrationProviderComponentReference as dW, getIntegrationDocumentNavigationMatchers as dX, getIntegrationSchemas as dY, getRegisteredIntegrationRuntime as dZ, getRegisteredIntegrations as d_, type FarmIntegrationLifecycleLogLevel as da, type FarmIntegrationLifecycleLogger as db, type FarmIntegrationLifecycleContext as dc, type FarmIntegrationLifecycleHook as dd, type FarmIntegrationData as de, type FarmIntegrationHandlerContext as df, type FarmIntegrationRouteHookContext as dg, type FarmIntegrationRouteHook as dh, type FarmIntegrationRoute as di, type FarmTypedIntegrationRoute as dj, type FarmIntegrationRouteMiddleware as dk, type FarmIntegrationMiddleware as dl, type FarmIntegrationProviderProps as dm, type FarmIntegrationProviderComponentReference as dn, type FarmIntegrationProvider as dp, type FarmIntegrationDocumentNavigation as dq, type FarmIntegrationSchemaFieldType as dr, type FarmIntegrationSchemaReference as ds, type FarmIntegrationSchemaField as dt, type FarmIntegrationSchemaConstraint as du, type FarmIntegrationSchemaModel as dv, type FarmIntegrationSchemaModelExtension as dw, type FarmIntegrationSchemaModelOverride as dx, type FarmIntegrationSchema as dy, defineIntegrationSchema as dz, type FarmRequest as e, createFarmRouteRuntimeKey as e$, matchIntegrationRoute as e0, matchRegisteredIntegrationRoute as e1, getRegisteredIntegrationAPIManifest as e2, dispatchIntegrationRequest as e3, dispatchIntegrationRequests as e4, describeIntegrationOriginRejection as e5, resolveIntegrationAllowedOrigins as e6, validateIntegrationRequestOrigin as e7, type IntegrationOriginPolicy as e8, type IntegrationOriginRejection as e9, type CookieJar as eA, type CookieOptions as eB, type RateLimitConfig as eC, type RateLimitIncrementResult as eD, type RateLimitStorage as eE, type RateLimitStatus as eF, type MemoryRateLimitStorageOptions as eG, type NextFunction as eH, type MiddlewareResult as eI, type FarmRouteRuleRenderMode as eJ, type FarmRouteRuleRedirect as eK, type FarmRouteRuleCors as eL, type FarmRouteRule as eM, type FarmRouteRules as eN, normalizeRouteRules as eO, routeRulesToRedirects as eP, routeRulesToHeaders as eQ, routeRulesToNitroRouteRules as eR, type FarmRouteRuntimeEntryKind as eS, type FarmRouteRenderingMode as eT, type FarmRouteRuntimeManifestEntry as eU, type FarmRouteRuntimeManifest as eV, normalizeFarmRouteRuntimeConfig as eW, mergeFarmRouteRuntimeConfigs as eX, resolveFarmRouteRuntimeConfig as eY, hasFarmRouteRuntimeControls as eZ, getFarmRouteRuntimeConfig as e_, type IntegrationOriginResult as ea, type FarmIntegrationOrmSchema as eb, type FarmIntegrationOrmClient as ec, type InferFarmIntegrationOrmField as ed, type InferFarmIntegrationOrmFields as ee, type InferFarmIntegrationOrmSchema as ef, type InferFarmIntegrationOrmClient as eg, type CreateIntegrationOrmOptions as eh, createIntegrationOrm as ei, resolveIntegrationOrmRuntimeClient as ej, farmIntegrationSchemaToOrmSchema as ek, type IntegrationOrmModelNames as el, DEFAULT_FARM_API_BASE_PATH as em, type FarmAPIConfigResolverContext as en, type FarmAPIConfigValue as eo, type FarmAPIConfig as ep, resolveFarmAPIConfig as eq, normalizeFarmAPIConfig as er, normalizeFarmAPIBasePath as es, getFarmAPIBaseURL as et, resolveFarmAPIRequestURL as eu, type MiddlewareFunction as ev, type RequestMiddleware as ew, type RequestMiddlewareContext as ex, type MiddlewareStore as ey, type MiddlewareChain as ez, type FarmResponse as f, resolveFarmRouteRuleRuntimeConfig as f0, farmRouteRuleMatches as f1, DEFAULT_FARM_DEVTOOLS_SHORTCUT as f2, FARM_DEVTOOLS_PATH as f3, FARM_DEVTOOLS_LAUNCH_PARAM as f4, type FarmDevtoolsConfig as f5, type FarmDevtoolsUserConfig as f6, resolveFarmDevtoolsConfig as f7, type FarmBuildActivityPosition as f8, type FarmDevIndicatorsConfig as f9, resolveFarmDevIndicatorsConfig as fa, generateFarmDevIndicatorsClientRuntime as fb, farmI18nClientBridgePlugin as fc, farmServerOnlyEntriesPlugin as fd, withFarmRequestTracing as fe, rewriteEarlySsrRelativeImports as ff, transformIsolatedClientBoundaryModule as fg, shouldEmitFarmClientRootHmr as fh, generateClientCachePersistenceCode as fi, resolveFarmClientCacheAdapterEntry as fj, type ClientCachePersistenceEntryCode as fk, FARM_NODE_RESPONSE_END_PENDING as fl, loadFarmDevModule as fm, FarmDevEnvironmentError as fn, type FarmDevModuleServer as fo, 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 };