@farm.js/core 0.1.61 → 0.1.62

package/dist/internal/production-runtime.d.mts

@@ -0,0 +1,566 @@
+export { _runWithAfterRequest } from '../after.mjs';
+export { c as createFarmAppManifestResponse } from '../app-manifest.d-BpvhfKRH.mjs';
+import { g3 as MiddlewareMatcher, bo as ResolvedFarmConfig, dv as FarmIntegrationsUserConfig, b9 as StaticPathParams, eL as ResolvedFarmMCPConfig, bq as FarmMCPServerRegistration, g4 as FarmLlmsTxtLink, F as FarmPlugin, aF as FarmConfig, aM as FarmContextFactoryInput } from '../client-plugins.d-CWyYBxXf.mjs';
+export { g5 as FarmLlmsTxtUserConfig, g6 as ResolvedFarmLlmsTxtConfig, g7 as applyFarmCspNonceToResponse, g8 as collectFarmLlmsTxtPages, g9 as createFarmAgentRobots, ga as createFarmCspNonce, gb as createFarmDefaultLlmsTxt, gc as createFarmDefaultSitemap, gd as createFarmLlmsFullRenderer, ge as createFarmLlmsMarkdownReader, gf as createFarmMetadataRouteResponse, bD as createFarmSearchParams, G as getFarmRedirectError, H as isFarmNotFoundError, I as isFarmRedirectError, gg as manageFarmDocumentPreloads, gh as manageFarmHtmlPreloads, gi as manageFarmLinkHeaderPreloads, bu as registerFarmMCPServer, gj as renderFarmLlmsFullTxt, gk as reportFarmPreloadWarnings, gl as resolveFarmLlmsTxtConfig, gm as resolveFarmSecurityConfig, bE as searchParamsToObject, gn as stampFarmCspNonce } from '../client-plugins.d-CWyYBxXf.mjs';
+export { m as mergeRouteRenderingDirectiveConfig } from '../route-rendering.d-CYxlzaFm.mjs';
+import { R as ResolvedFarmServerConfig } from '../workflows.d-CRMzQZ3k.mjs';
+export { f as FarmServerConfig, z as bufferFarmRequestBody, A as cloneFarmRequestWithContext, c as createFarmNodeRequestAbortSignal, B as createFarmRequestBodyErrorResponse, C as matchesFarmIfNoneMatch, E as readFarmRequestBody, G as readNodeRequestBody, H as resolveFarmServerConfig } from '../workflows.d-CRMzQZ3k.mjs';
+export { _registerFarmStorageModules, disposeStorage as disposeFarmStorage, initStorage as initFarmStorage } from '../storage.mjs';
+export { _ as _getRequestReadCount, a as _runWithCurrentRequest, b as _runWithFarmCspNonce, g as getCurrentRequest, r as resolveFarmWebRequestOrigin } from '../request.d-CUrPnCW7.mjs';
+export { f as fetchFarmExternalRewrite } from '../response.d-BolW0Vx_.mjs';
+import { A as APIRequestRuntime } from '../server-client-bridge.d-DKWDl5NB.mjs';
+export { configureFarmCache, createFarmCacheKey, getFarmDataCache, normalizeRevalidatePath } from '../cache.mjs';
+import { k as FarmI18nUserConfig, R as ResolvedFarmI18nConfig } from '../types.d-C41ePjvP.mjs';
+export { c as createFarmLocaleCookie, g as getFarmLocaleVaryHeaders } from '../resolver.d-JnZKKsc5.mjs';
+import { F as FarmLocalePathConfig } from '../index.d-BqcfqJvt.mjs';
+export { l as localizeFarmHref, a as localizeFarmPathname, s as stripFarmLocaleFromPathname } from '../index.d-BqcfqJvt.mjs';
+import { F as FarmDefaultMCPPage } from '../agent-mcp.d-BKZ3UNbt.mjs';
+export { a as addMetadataImageReference, b as addMetadataMarkdownAlternate, d as collectFarmDefaultMCPPages, m as mergeMetadata, e as mergeModuleViewport, r as renderMetadataHead, f as renderViewportHead, g as resolveFarmDefaultMCPServer, h as resolveFarmNotFoundMetadata, i as resolveMetadataTitle } from '../agent-mcp.d-BKZ3UNbt.mjs';
+export { _ as _runWithMiddlewareContext, a as _runWithMiddlewareData, f as _withFarmGuardedResponseCache, b as applyProductionMiddlewareHeaders, c as createProductionMiddlewareRunner } from '../production-runtime.d-CcQiDko5.mjs';
+export { H as configureFarmObservability, J as emitFarmEvent, P as runWithFarmRequestSpan } from '../observability.d-B2363jB6.mjs';
+export { f as createFarmInstrumentationLifecycle, r as resolveFarmInstrumentationRuntime } from '../instrumentation-runtime.d-CX9Zh-16.mjs';
+export { _setDefaultFarmThemeConfig, getTheme } from '../theme/server.mjs';
+import { c as FarmThemeRuntime, d as FarmThemeConfig, R as ResolvedFarmThemeConfig, a as FarmThemePreference } from '../types.d-DQnyD3VD.mjs';
+export { m as matchFarmPageRoute, p as parseRoutePath } from '../utils.d-D8VfzZYn.mjs';
+export { c as applyFarmBasePath, r as resolveFarmTrailingSlashRedirect, s as setFarmBasePath, a as setFarmTrailingSlashPreference, b as stripFarmBasePath } from '../base-path.d-BOUV5ozD.mjs';
+export { _ as _checkFarmMobileShellRoute, d as _isFarmMobileShellRenderRequest } from '../shell-render.d-CG6bPiiA.mjs';
+export { handleFarmFormActionRequest } from './form-actions.mjs';
+export { g as getSharedLayoutPrefixLength, p as parseFarmLayoutChainHeader } from '../render-plan.d-BH9WF-JZ.mjs';
+import 'node:http';
+import '../lifecycle.d-C2aLBOwu.mjs';
+import '../route.d-BaVH3V0w.mjs';
+import '../endpoint.d-BkMSCRf6.mjs';
+import '../renderer.mjs';
+import '../deployment.mjs';
+import 'http';
+import '../server-fn.mjs';
+import '../server-fn-error.d-DrcH9cc1.mjs';
+import '../server-query.mjs';
+import '../types.d-BnIqOn9w.mjs';
+import 'db0';
+import 'unstorage';
+import '../schema.mjs';
+import 'react';
+import '@farming-labs/orm';
+import '@farming-labs/docs';
+import 'vite';
+import '../cron.mjs';
+import '../env.mjs';
+import '../server-action-security.mjs';
+import '../layers.d-CcS42OGR.mjs';
+import 'rolldown/utils';
+import 'rolldown';
+import '../image-config.d-CeDgNyX4.mjs';
+import '../config.d-qt-mE8O5.mjs';
+import '../font.mjs';
+import '@opentelemetry/api';
+import '../island.d-CfGru1MO.mjs';
+
+/** What the server needs to point a document at the mobile client, from `mobile-client.json`. */
+interface FarmMobileShellClient {
+    /** The web client entry as documents reference it, such as `/farm-client-h1a2b3c4d.js`. */
+    webEntry: string;
+    /** The mobile client entry that replaces it, such as `/farm-mobile-client-h5e6f7a8b.js`. */
+    entry: string;
+    /**
+     * Web client files, without the leading slash, that the mobile client does not load. Their
+     * modulepreload links are dropped from a shell's document; shared chunks keep theirs.
+     */
+    webOnly: string[];
+}
+/**
+ * Point a document at the mobile client when a mobile shell asked for it.
+ *
+ * HTML responses of an app with a mobile client always carry `Vary: X-Farm-Shell`, so a cache that
+ * honors it never hands one variant to the other. A shell's document is also `private, no-store`
+ * (as a guarded response is), so no shared cache stores it at all; `onPrivate` tells the adapter,
+ * which keeps that policy under cache route rules. Anything other than HTML passes through.
+ */
+declare function _applyFarmMobileShellClient(request: Request, response: Response, client: FarmMobileShellClient | null, onPrivate?: () => void): Response;
+
+/**
+ * The `config` a middleware file exports, read from its source at build time so prerendering
+ * knows which paths the file's own `matcher` leaves alone. Only literal matchers count (strings,
+ * regular expressions, arrays of them): anything computed, or a request-aware function, may match
+ * any path, so it reads as unknown and the page stays server-handled.
+ */
+
+interface StaticMiddlewareConfig {
+    matcher?: MiddlewareMatcher | MiddlewareMatcher[];
+    exclude?: Array<string | RegExp>;
+}
+
+/**
+ * Whether config middleware may run for a path. This reuses the runtime matcher: a
+ * separate copy drifted (`/members/(.*)` kept its trailing slash and never met
+ * `/members/secret`), and a prerendered page was frozen into a public file that
+ * middleware never sees again.
+ *
+ * @internal
+ */
+declare function configMiddlewareMayHandlePath(config: ResolvedFarmConfig["middleware"], pathname: string): boolean;
+/** @internal File middleware counterpart of `configMiddlewareMayHandlePath`. */
+declare function appMiddlewareMayHandlePath(middlewareRoutes: readonly {
+    path: string;
+    config?: StaticMiddlewareConfig | null | "unknown";
+}[], pathname: string): boolean;
+/**
+ * Whether a guard written for this page's path covers it: middleware.ts in the page's
+ * folder or a parent below the root, a config middleware matcher, or an integration's
+ * middleware matcher (`protectedRoutes`). Public listings (sitemap.xml, llms.txt, the
+ * default MCP server) leave such a page out, so its path and title stay unpublished.
+ *
+ * Guards that cover every path (a root middleware.ts, middleware without a matcher or
+ * with a catch-all or function matcher, a plugin's `runtime.before`) name no page, so
+ * they hide nothing: the listings would otherwise be empty. Their pages are still read
+ * as an anonymous visitor, so a guard there keeps the content itself private.
+ *
+ * @internal
+ */
+declare function farmPathGuardCoversPage(options: {
+    config: {
+        middleware?: ResolvedFarmConfig["middleware"];
+        integrations?: FarmIntegrationsUserConfig;
+    };
+    middlewareRoutes: readonly {
+        path: string;
+    }[];
+}, pathname: string): boolean;
+/**
+ * {@link farmPathGuardCoversPage} for an endpoint served under `/api`, such as an
+ * `apiMcp()` server: a guard written for either the `/api` route or its public
+ * `api.basePath` form covers it.
+ *
+ * @internal
+ */
+declare function farmPathGuardCoversEndpoint(options: Parameters<typeof farmPathGuardCoversPage>[0], path: string, apiServerBasePath?: string): boolean;
+
+/**
+ * Compare a caller-supplied secret against the configured one without leaking
+ * how much of it matched.
+ *
+ * `===` on strings stops at the first differing character, so the time it takes
+ * to reject a guess grows with the length of the correct prefix. Over enough
+ * requests that recovers a cron or workflow secret one character at a time. This
+ * always inspects every position instead.
+ *
+ * Deliberately not node:crypto's `timingSafeEqual`: these callers are bundled
+ * into the generated Nitro runtime, which also targets edge and browser-like
+ * environments where importing node:crypto breaks the build.
+ */
+declare function farmSecretsMatch(provided: string, expected: string): boolean;
+
+/**
+ * Internal: the production builder owns these immutable, depth-ordered descriptors.
+ *
+ * A layout's pattern is its directory, so a route group stays in it (`/(auth)`).
+ * The URL decides whether a layout covers a pathname; a layout inside a group also
+ * needs the selected page to sit in that group. `resolveRouteDirectory` finds that
+ * page's directory, and runs only when such a layout's URL matches.
+ */
+declare function createFarmLayoutSelector<T extends {
+    pattern: string;
+}>(layouts: readonly T[], resolveRouteDirectory?: (pathname: string) => string | null | undefined): (pathname: string, routeDirectory?: string | null) => T[];
+
+/**
+ * Whether a page directory sits inside a group scope. A null scope covers every page;
+ * a missing directory (no page matched) is inside no group.
+ */
+declare function isInRouteGroupScope(directory: string | null | undefined, scope: string | null): boolean;
+
+/**
+ * Static path materialization for SSG routes: `generateStaticParams()` values to URL paths.
+ * Free of Node APIs, so production runtimes can import it as well as the build.
+ */
+
+declare function materializeSSGRoutePath(routePattern: string, params: StaticPathParams): string;
+
+type FarmProductionLifecycleState = "starting" | "ready" | "draining" | "failed" | "closed";
+interface FarmProductionLifecycleOptions {
+    server: ResolvedFarmServerConfig;
+    start?: () => void | Promise<void>;
+    close?: (reason: string) => void | Promise<void>;
+}
+interface FarmResponseCompletionContext {
+    onResponseFinished?: (callback: () => void) => void;
+}
+interface FarmProductionLifecycle {
+    readonly state: FarmProductionLifecycleState;
+    readonly activeRequests: number;
+    start(): Promise<void>;
+    beginDrain(reason?: string): void;
+    waitForIdle(timeoutMs?: number): Promise<boolean>;
+    close(reason?: string): Promise<void>;
+    forceClose(reason?: string): Promise<void>;
+    handleHealthRequest(request: Request): Promise<Response | null>;
+    runRequest(handler: () => Response | Promise<Response>, context?: FarmResponseCompletionContext): Promise<Response>;
+}
+declare function createFarmProductionLifecycle(options: FarmProductionLifecycleOptions): FarmProductionLifecycle;
+
+/**
+ * What a hosting provider says about the current deployment, read from the
+ * environment variables it sets. Production-site telemetry and
+ * `agent.noindexPreviews` both read these, with opposite fallbacks: telemetry
+ * treats a deployment it cannot classify as production, and noindexPreviews
+ * treats it as not a preview. Either way an unknown setup keeps its default
+ * behavior instead of being guessed at.
+ *
+ * Cloudflare Pages is deliberately absent: it exposes `CF_PAGES_BRANCH` for both
+ * production and preview deployments and no environment flag that distinguishes
+ * them, so there is nothing here that could be read without guessing. Its
+ * preview URLs already carry `X-Robots-Tag: noindex`.
+ */
+type FarmDeploymentEnv = Readonly<Record<string, string | undefined>>;
+/**
+ * Preview status for a running server: the runtime environment, or the
+ * environment it was built in. Netlify exposes its deploy context only to the
+ * build, so the build's answer is carried into the server bundle. An explicit
+ * `FARM_PREVIEW` at runtime still wins over the build.
+ */
+declare function resolveFarmPreviewDeployment(env: FarmDeploymentEnv | undefined, builtAsPreview: boolean): boolean;
+
+/**
+ * Mark a response as not indexable. Responses with immutable headers, such as
+ * a proxied `fetch()` result, are copied first.
+ */
+declare function applyFarmPreviewRobotsTag(response: Response): Response;
+
+/** Empty when the target is not an http(s) URL; the page then stays as rendered. */
+declare function createLateRedirectRecovery(url: string, nonce?: string): string;
+/** `content` is the rendered not-found markup (the app's not-found page or the built-in one). */
+declare function createLateNotFoundRecovery(content: string, nonce?: string): string;
+
+/** Labels a route payload and returns it. A `null` label leaves the matched pattern in place. */
+declare function setFarmRouteLabel<T extends object | null | undefined>(route: T, label: string | null): T;
+/**
+ * The endpoint (or its server card) of an MCP server running in this app, for a path below
+ * the base path: registered servers (a docs runtime's) and `@farm.js/mcp` catalogs.
+ */
+declare function resolveFarmMCPRouteLabel(routePathname: string, apiServerBasePath?: string): string | null;
+interface FarmDocsRouteLabelInput {
+    /** The docs entry, such as `/docs`. */
+    path: string;
+    /** The docs API base, `/api/docs` unless a precompiled runtime names another. */
+    apiPath?: string;
+    /** The entries of `docs.roots`, served alongside `path`. */
+    roots?: readonly string[];
+}
+/**
+ * A docs page by the route the docs engine registers (`/docs` and `/docs/[...slug]`, with
+ * `.md` for its Markdown), or the docs API by its base. Null outside both.
+ */
+declare function resolveFarmDocsRouteLabel(routePathname: string, docs: FarmDocsRouteLabelInput): string | null;
+/**
+ * What the docs engine answered: a page or the API, else one of the engine's own fixed
+ * paths (`/mcp`, `/llms-full.txt`, `/.well-known/agent.json`). The engine answers only paths
+ * it publishes, but a path deeper than one name (below `/.well-known/`, two) keeps just its
+ * leading segments, so a nested path can never carry request input into the label.
+ */
+declare function resolveFarmDocsEngineRouteLabel(routePathname: string, docs: FarmDocsRouteLabelInput): string;
+/**
+ * A Markdown mirror (`/blog/hello.md`) by its page's pattern (`/blog/[slug].md`), or null when
+ * the path is not a `.md` URL of a page.
+ */
+declare function resolveFarmMarkdownRouteLabel(routePathname: string, matchPagePattern: (pathname: string) => string | null | undefined): string | null;
+
+/** The CSP nonce of the response being rendered, when `security.csp.nonce` is on. */
+declare function _resolveCurrentCspNonce(): string | undefined;
+
+/**
+ * Answer the shell's request for a page's tree. `renderPage` renders the page for a browser.
+ * Responses that are not an HTML page (a redirect, a sign-in gate, an error) go back as they are,
+ * so the shell can follow or show them as it would for the web screen.
+ */
+declare function createFarmNativeTreeResponse(options: {
+    request: Request;
+    renderPage: (request: Request) => Response | Promise<Response>;
+    /**
+     * A stylesheet's text by its href. Without it, `renderPage` serves it, as the dev server does;
+     * a production server passes the client CSS its build embedded.
+     */
+    loadStylesheet?: (href: string) => string | undefined | Promise<string | undefined>;
+}): Promise<Response>;
+
+/** Bind the owning app's live route dispatcher, never a process-wide route table. */
+declare function _runWithAPIRequestRuntime<T>(runtime: APIRequestRuntime, run: () => T): T;
+
+declare function resolveFarmI18nConfig(input: FarmI18nUserConfig | false | undefined, options?: {
+    root?: string;
+    mode?: "development" | "production";
+    basePath?: string;
+}): ResolvedFarmI18nConfig;
+
+interface FarmLocaleAlternateLinkOptions {
+    /**
+     * The route's `metadataBase`. Preferred over the request origin when it is an
+     * absolute http(s) URL, so every alternate advertises the app's canonical host.
+     */
+    metadataBase?: unknown;
+    /**
+     * The trusted request origin (`server.trustProxy` decides whether forwarded
+     * authority headers count). Used when no usable `metadataBase` is set.
+     */
+    origin?: string;
+}
+/**
+ * Render `<link rel="alternate" hreflang>` tags for every configured locale plus
+ * `x-default`. Search engines ignore relative hreflang URLs, so each href is
+ * resolved against `metadataBase`, otherwise against the request origin. With
+ * neither available the localized path is emitted as-is.
+ */
+declare function renderFarmLocaleAlternateLinks(pathname: string, config: FarmLocalePathConfig, options?: FarmLocaleAlternateLinkOptions): string;
+
+/**
+ * Start the head with `<meta charset>` and the viewport tags, as Next.js always renders both,
+ * skipping each one the layout's document already writes (a viewport, theme-color, or
+ * color-scheme tag of its own). The charset comes first because browsers only look for it in the
+ * document's first 1024 bytes. The production server uses this same function.
+ */
+declare function ensureFarmDocumentMeta(markup: string, viewport?: string): string;
+
+/**
+ * Runtime source that remounts the top-level `mcp` configuration in a built server.
+ *
+ * Production re-evaluates raw layer and application config modules instead of
+ * calling `resolveConfig`, so the internal plugin created during the build is
+ * not otherwise present in the runtime plugin list. The literal import keeps
+ * the optional MCP package traceable for server and edge bundles while disabled
+ * applications carry no import or runtime code.
+ *
+ * Shared by core's Nitro entry and the RSC entry.
+ */
+declare function generateNativeMCPPluginSource(mcp: ResolvedFarmMCPConfig | undefined): {
+    importSource: string;
+    registerSource: string;
+    pluginSource: string;
+};
+
+/** @internal Marks a Response Farm created for the current request. */
+declare function _markFarmOwnedResponse<T extends Response>(response: T): T;
+/** @internal Whether Farm created this Response for the current request. */
+declare function _isFarmOwnedResponse(response: Response): boolean;
+/**
+ * @internal Applies `edit` to a response's headers: in place when Farm owns the
+ * response, otherwise on a copy, which Farm then owns. The body is never read.
+ */
+declare function _withFarmResponseHeaders(response: Response, edit: (headers: Headers) => void): Response;
+
+/**
+ * The protocol side of the default MCP server (`agent.mcp`, see `agent-mcp.ts`): stateless
+ * Streamable HTTP with JSON responses, and three read-only tools over the app's public pages.
+ * A small JSON-RPC implementation rather than the MCP SDK, so apps that never receive an
+ * MCP request carry no SDK.
+ *
+ * Kept free of Node built-ins: the production server runs on edge runtimes too.
+ */
+
+interface FarmDefaultMCPContext {
+    server: {
+        name: string;
+        version: string;
+        title?: string;
+    };
+    /** The app's public pages for this request's origin. */
+    listPages: () => FarmDefaultMCPPage[] | Promise<FarmDefaultMCPPage[]>;
+    /** Reads a Markdown URL anonymously; null when the page does not answer with Markdown. */
+    readMarkdown: (url: string) => Promise<string | null>;
+    basePath?: string;
+}
+/**
+ * Answers one request to the default MCP endpoint: stateless Streamable HTTP, JSON
+ * responses, no sessions, and no server-initiated stream (GET answers 405).
+ */
+declare function handleFarmDefaultMCPRequest(request: Request, context: FarmDefaultMCPContext): Promise<Response>;
+
+interface FarmAiCatalogInput {
+    /** The app's basePath; the catalog lives beneath it, like the API catalog. */
+    basePath?: string;
+    /** The app's public API path, which maps to Farm's canonical `/api`. */
+    apiServerBasePath?: string;
+    /**
+     * The default read-only server (`agent.mcp`), when this app would serve it. It is
+     * listed only while no other MCP server is, the same rule that decides whether it answers.
+     */
+    defaultMCP?: () => (FarmMCPServerRegistration & {
+        path: `/${string}`;
+    }) | undefined;
+}
+/**
+ * The llms.txt links for the app's MCP servers: each endpoint, then the catalog
+ * that lists their cards. Empty when the app mounts no MCP server.
+ */
+declare function listFarmMCPLlmsTxtLinks(origin: string, input?: FarmAiCatalogInput): FarmLlmsTxtLink[];
+/**
+ * Answers `/.well-known/ai-catalog.json`, `/.well-known/ard.json`, and each
+ * `<endpoint>/server-card`, or returns `null` for any other request and when
+ * the app mounts no MCP server, so the request goes on as if Farm served nothing.
+ * Every request passes through here; `requestUrl`, the caller's parse of
+ * `request.url`, saves parsing it again.
+ */
+declare function createFarmAiCatalogResponse(request: Request, input?: FarmAiCatalogInput, requestUrl?: URL): Response | null;
+
+/**
+ * `/.well-known/api-catalog` (RFC 9727): a Linkset listing the APIs an app
+ * publishes, so an agent that knows only the origin can find the OpenAPI
+ * description and the MCP endpoint without guessing paths.
+ */
+
+interface FarmApiCatalogInput {
+    /** The app's basePath; app routes such as the OpenAPI spec live beneath it. */
+    basePath?: string;
+    /** Public base of the HTTP API, a root-relative path or an absolute URL. */
+    apiBaseURL: string;
+    /** The OpenAPI spec and reference routes, when OpenAPI is enabled. */
+    openapi?: {
+        specRoute?: string | false;
+        route?: string | false;
+    };
+    /** The public path of the MCP endpoint, when MCP is enabled. */
+    mcpPath?: string;
+}
+/** Serves the catalog: the document on GET, and the `api-catalog` Link on GET and HEAD. */
+declare function createFarmApiCatalogResponse(method: string, input: FarmApiCatalogInput, 
+/** The request being answered, so the read can be reported as agent traffic. */
+request?: Request): Response;
+
+/**
+ * Whether a server plugin's `runtime.before` runs for every request without declaring
+ * `runtime.cache: "public"`. Like middleware, it may be a guard that let this visitor through,
+ * so the responses it lets pass stay out of shared caches.
+ *
+ * @internal
+ */
+declare function _farmPluginsKeepResponsesPrivate(plugins: readonly FarmPlugin[]): boolean;
+
+declare const FARM_ROUTE_CONTEXT_SYMBOL: unique symbol;
+type FarmRouteContextCarrier<TContext = unknown> = {
+    [FARM_ROUTE_CONTEXT_SYMBOL]?: TContext;
+};
+declare function resolveFarmRouteContext(config: Pick<FarmConfig, "context">, input: FarmContextFactoryInput): Promise<unknown>;
+declare function withFarmRouteContext<TProps extends object, TContext>(props: TProps, context: TContext | undefined): TProps & FarmRouteContextCarrier<TContext>;
+
+declare global {
+    interface Window {
+        __FARM_THEME__?: FarmThemeRuntime;
+    }
+}
+interface FarmThemeDocumentParts {
+    attributes: string;
+    head: string;
+}
+declare function createFarmThemeDocumentParts(input: FarmThemeConfig | ResolvedFarmThemeConfig | false | undefined, basePath?: string, serverTheme?: FarmThemePreference): FarmThemeDocumentParts;
+declare function applyFarmThemeDocument(html: string, input: FarmThemeConfig | ResolvedFarmThemeConfig | false | undefined, basePath?: string, serverTheme?: FarmThemePreference): string;
+
+interface DefaultErrorSourceLine {
+    number: number;
+    content: string;
+    highlight?: boolean;
+}
+interface DefaultErrorSourceFrame {
+    file: string;
+    line: number;
+    column: number;
+    lines: DefaultErrorSourceLine[];
+}
+interface DefaultErrorPageOptions {
+    statusCode?: number;
+    statusText?: string;
+    requestPath?: string;
+    method?: string;
+    message?: string;
+    errorName?: string;
+    stack?: string;
+    sourceFrame?: DefaultErrorSourceFrame;
+    development?: boolean;
+    farmVersion?: string;
+    nodeVersion?: string;
+    mode?: string;
+}
+declare function resolveDefaultErrorStatus(error: unknown): number;
+declare function getDefaultErrorStatusText(statusCode: number): string;
+declare function createDefaultErrorMarkup(options?: DefaultErrorPageOptions): string;
+
+type RouteSegmentSpecificity = "static" | "dynamic" | "catch-all" | "optional-catch-all";
+/** Sort route patterns from the most specific segment sequence to the least specific. */
+declare function compareRouteSpecificity(left: readonly RouteSegmentSpecificity[], right: readonly RouteSegmentSpecificity[]): number;
+type RoutePatternSyntax = "page" | "router" | "api";
+/** Return the specificity of every URL-consuming segment in a route pattern. */
+declare function getRoutePatternSpecificity(pattern: string, syntax?: RoutePatternSyntax): RouteSegmentSpecificity[];
+
+declare function createFarmLegacyRequest<TEvent extends {
+    method?: string;
+}>(event: TEvent, input: string | URL, headers: HeadersInit, readRawBody: (event: TEvent, encoding: false) => Promise<BodyInit | null | undefined>): Promise<Request>;
+
+declare function serializeFarmInlineValue(value: unknown): string;
+declare function renderFarmLegacyHtml(options: {
+    deploymentId: unknown;
+    pageProps: unknown;
+    pathname: unknown;
+    html: string;
+    clientScript: string;
+}): string;
+declare function renderFarmLegacyErrorHtml(): string;
+
+/** Preserve an incoming query when a redirect destination does not declare one. */
+declare function appendFarmRedirectQuery(destination: string, search: string): string;
+
+/**
+ * Makes the current request's render send every value, whatever the browser holds: its HTML may
+ * be stored in a shared cache (a PPR shell, an ISR entry) and served to browsers that hold none.
+ */
+declare function ignoreFarmHeldValues(): void;
+declare function installFarmIslandValues(): void;
+
+interface FarmMobileSessionStore {
+    getItem(key: string): Promise<unknown>;
+    setItem(key: string, value: unknown): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+interface FarmMobileSessionOptions {
+    /** The app's basePath ("" or "/base"). The marker cookie's Path. */
+    basePath?: string;
+    /** The app's integrations; the first with `session()` decides who is signed in. */
+    integrations: () => Record<string, unknown> | undefined;
+    /** Defaults to `getStorage("farm-mobile")`. */
+    storage?: () => FarmMobileSessionStore;
+    /** Access token lifetime in seconds. @default 900 */
+    accessTokenTtl?: number;
+    /** Refresh token lifetime in seconds. @default 2592000 (30 days) */
+    refreshTokenTtl?: number;
+    /** Challenge nonce lifetime in seconds. @default 60 */
+    nonceTtl?: number;
+    /** Clock, for tests. */
+    now?: () => number;
+}
+declare function createFarmMobileSessionPlugin(options: FarmMobileSessionOptions): FarmPlugin;
+
+/**
+ * The endpoint React Native screens call server functions through (see `native-server-fns.ts`).
+ * Only apps with a `mobile` block get it, and it runs only the server functions its `resolve`
+ * returns: the ones a native screen imports.
+ *
+ * A call must have the shape only the app sends: `X-Farm-Mobile`, no `Sec-Fetch-*` header, and no
+ * `Origin` other than the server's own (the mobile session plugin sets that one on a signed-in
+ * device's requests). A cross-site page cannot add the header without a CORS preflight, which
+ * this endpoint never answers, so it cannot call a function as the visitor.
+ *
+ * Every function a native screen imports is a public endpoint, as server actions are: anyone can
+ * call it with any input, so it checks its input (its schema) and the caller's rights (its
+ * middleware), which run as for any other caller.
+ */
+
+interface FarmNativeServerFnOptions {
+    /** The server function with this id, if a native screen imports it. */
+    resolve(id: string): unknown | Promise<unknown>;
+}
+/**
+ * Only for apps with a `mobile` block; see `config.ts` and the production server entry. An
+ * ordinary API route, so a call passes Farm's middleware and `runtime.before` hooks first, in
+ * development and in production: the mobile session plugin turns a signed-in device's token into
+ * its session, and the function's middleware sees the same user a web page would.
+ */
+declare function createFarmNativeServerFnPlugin(options: FarmNativeServerFnOptions): FarmPlugin;
+
+declare function appendFarmLinkHeader(headers: Headers, value: string): void;
+
+export { _applyFarmMobileShellClient, _farmPluginsKeepResponsesPrivate, _isFarmOwnedResponse, _markFarmOwnedResponse, _resolveCurrentCspNonce, _runWithAPIRequestRuntime, _withFarmResponseHeaders, appMiddlewareMayHandlePath, appendFarmLinkHeader, appendFarmRedirectQuery, applyFarmPreviewRobotsTag, applyFarmThemeDocument, compareRouteSpecificity, configMiddlewareMayHandlePath, createDefaultErrorMarkup, createFarmAiCatalogResponse, createFarmApiCatalogResponse, createFarmLayoutSelector, createFarmLegacyRequest, createFarmMobileSessionPlugin, createFarmNativeServerFnPlugin, createFarmNativeTreeResponse, createFarmProductionLifecycle, createFarmThemeDocumentParts, createLateNotFoundRecovery, createLateRedirectRecovery, ensureFarmDocumentMeta, farmPathGuardCoversEndpoint, farmPathGuardCoversPage, farmSecretsMatch, generateNativeMCPPluginSource, getDefaultErrorStatusText, getRoutePatternSpecificity, handleFarmDefaultMCPRequest, ignoreFarmHeldValues, installFarmIslandValues, isInRouteGroupScope as isInFarmRouteGroupScope, listFarmMCPLlmsTxtLinks, materializeSSGRoutePath, renderFarmLegacyErrorHtml, renderFarmLegacyHtml, renderFarmLocaleAlternateLinks, resolveDefaultErrorStatus, resolveFarmDocsEngineRouteLabel, resolveFarmDocsRouteLabel, resolveFarmI18nConfig, resolveFarmMCPRouteLabel, resolveFarmMarkdownRouteLabel, resolveFarmPreviewDeployment, resolveFarmRouteContext, serializeFarmInlineValue, setFarmRouteLabel, withFarmRouteContext };