@farm.js/core 0.1.47 → 0.1.48

package/dist/app-VK9sHDn5.d.ts

@@ -0,0 +1,562 @@
+import { aU as FarmConfig, P as ParsedRoute, bu as ResolvedFarmRouteRuntimeConfig, bv as ApplicationMetadataRouteKind, i as RouteModule, b7 as LayoutModule, aP as SSGCollectionResult, s as FarmRequest, t as FarmResponse, bw as ResolvedFarmAPIConfig, bx as FarmDocsResolvedConfig, aT as FarmMarkdownResolvedConfig, h as FarmMdxResolvedConfig, aw as ResolvedFarmDevtoolsConfig, by as ResolvedFarmDevIndicatorsConfig, bz as ResolvedFarmAuthConfig, bA as ResolvedFarmPerformanceConfig, bB as ResolvedFarmSecurityConfig } from './client-plugins-DqjCsKMN.js';
+import { F as FarmWorkflowsResolvedConfig } from './workflows-Df1C_7OG.js';
+import { FarmCronResolvedConfig } from './cron.js';
+import { R as ResolvedFarmImageConfig } from './image-config-CeDgNyX4.js';
+import { ProgrammaticRedirectRoute, ProgrammaticRouteSearchClientOptions } from './routes.js';
+import { P as ProgrammaticClientRoutes } from './programmatic-routes-client-DviwGeAv.js';
+import { ViteDevServer } from 'vite';
+import { F as FarmIslandStrategy } from './island-CfGru1MO.js';
+import { M as MetadataImageKind, c as createFarmDefaultMCPServer } from './agent-mcp-DAjB8Eyu.js';
+import { FarmServerRendererRuntime, FarmRenderer } from './renderer.js';
+import { F as FarmRouteRenderPlan } from './render-plan-DqWXo3-B.js';
+import { R as ResolvedFarmI18nConfig } from './types--Wh02r5_.js';
+import { F as FarmI18nRuntime } from './runtime-B9HmxiZc.js';
+import { R as ResolvedFarmThemeConfig } from './types-DQnyD3VD.js';
+
+interface IsolatedClientBoundaryReference {
+    /** Absolute source path. Converted to a Vite URL only at the manifest edge. */
+    modulePath: string;
+    islandStrategy: FarmIslandStrategy;
+}
+
+declare const STATIC_METADATA_IMAGE_EXTENSIONS: readonly ["png", "jpg", "jpeg", "gif", "webp"];
+type StaticMetadataImageExtension = (typeof STATIC_METADATA_IMAGE_EXTENSIONS)[number];
+interface StaticMetadataImageInfo {
+    extension: StaticMetadataImageExtension;
+    contentType: string;
+    width: number;
+    height: number;
+    alt?: string;
+    hash: string;
+    byteLength: number;
+}
+
+interface RouteEntry {
+    route: ParsedRoute;
+    modulePath: string;
+    markdownSourcePath?: string;
+    /**
+     * A page's URL pattern. Layouts, loading and error boundaries use their app
+     * directory instead, route groups included (`/(auth)`), because a group adds
+     * no URL segment and two of them can share one URL.
+     */
+    pattern: string;
+    /** A page's directory pattern, set only when it differs from `pattern` (route groups). */
+    directory?: string;
+    source?: "file" | "programmatic";
+    sourceRoot: string;
+}
+interface RouteSlotEntry extends RouteEntry {
+    name: string;
+    ownerPattern: string;
+    /**
+     * The owning layout's pattern when route groups make it differ from
+     * `ownerPattern` (a URL pattern); slots render into the layout with this pattern.
+     */
+    ownerDirectory?: string;
+    interception: boolean;
+    fallback: boolean;
+    containerId: string;
+}
+interface MatchedRouteSlot {
+    name: string;
+    ownerPattern: string;
+    /** See `RouteSlotEntry.ownerDirectory`. */
+    ownerDirectory?: string;
+    containerId: string;
+    interception: boolean;
+    fallback: boolean;
+    route: RouteSlotEntry;
+    params: Record<string, string>;
+}
+interface FarmClientRouteManifest {
+    routes: Array<{
+        pattern: string;
+        /** The page's directory pattern when route groups make it differ from `pattern`. */
+        directory?: string;
+        modulePath: string;
+        shouldHydrate: boolean;
+        isClientComponent: boolean;
+        islandStrategy: FarmIslandStrategy | null;
+        hasIsolatedClientBoundaries?: true;
+        isolatedBoundaries?: IsolatedClientBoundaryReference[];
+        /** The async page renders as a server tree inside its hydrating layout's root. */
+        serverTree?: true;
+        renderPlan: FarmRouteRenderPlan;
+        suppressedAsyncHydration?: true;
+        /** Why an async page's client components could not become islands. */
+        suppressedAsyncHydrationReason?: string;
+        search?: ProgrammaticRouteSearchClientOptions;
+        segments: Array<{
+            segment: string;
+            isDynamic: boolean;
+            isCatchAll?: boolean;
+            isOptional?: boolean;
+        }>;
+    }>;
+    layouts: Array<{
+        pattern: string;
+        modulePath: string;
+        shouldHydrate: boolean;
+        isClientComponent: boolean;
+        islandStrategy: FarmIslandStrategy | null;
+        hasIsolatedClientBoundaries?: true;
+        isolatedBoundaries?: IsolatedClientBoundaryReference[];
+        suppressedAsyncHydration?: true;
+        /** Why an async layout's client-side hydration could not become islands. */
+        suppressedAsyncHydrationReason?: string;
+        /** Islands mode: the browser rebuilds this layout from its server tree, not its module. */
+        serverTree?: true;
+    }>;
+    slots: Array<{
+        name: string;
+        ownerPattern: string;
+        pattern: string;
+        modulePath: string;
+        containerId: string;
+        interception: boolean;
+        fallback: boolean;
+        shouldHydrate: boolean;
+        isClientComponent: boolean;
+        segments: RouteEntry["route"]["segments"];
+    }>;
+}
+interface MetadataImageEntry extends RouteEntry {
+    kind: MetadataImageKind;
+    fileName: "opengraph-image" | "twitter-image";
+    sourceType: "module" | "static";
+    staticInfo?: StaticMetadataImageInfo;
+}
+interface ApplicationMetadataRouteEntry extends RouteEntry {
+    kind: ApplicationMetadataRouteKind;
+    fileName: "sitemap" | "robots" | "manifest" | "llms" | "llms-full";
+    outputName: "sitemap.xml" | "robots.txt" | "manifest.webmanifest" | "llms.txt" | "llms-full.txt";
+}
+/**
+ * Manages route discovery and matching for the Farm.js application
+ */
+declare class RouteManager {
+    private config;
+    private routes;
+    private pageRouteShapes;
+    private layouts;
+    private orderedLayouts;
+    private routeSlots;
+    private routeSlotOwnerSegments;
+    private loadings;
+    private errors;
+    private metadataImages;
+    private metadataRoutes;
+    private redirects;
+    private programmaticPages;
+    private programmaticLayouts;
+    private programmaticClientRoutes;
+    private rendererRuntime?;
+    private viteServer?;
+    private clientManifestCache?;
+    private reportedIslandsErrors;
+    constructor(config: Required<FarmConfig>, viteServer?: ViteDevServer);
+    setRendererRuntime(rendererRuntime: FarmServerRendererRuntime): void;
+    /**
+     * Discover all routes in the app directory
+     */
+    discoverRoutes(): Promise<void>;
+    /**
+     * Find matching route for a given URL path
+     */
+    matchRoute(pathname: string, options?: {
+        interceptFrom?: string;
+    }): {
+        route: RouteEntry | null;
+        params: Record<string, string>;
+        layouts: RouteEntry[];
+        slots: MatchedRouteSlot[];
+    };
+    /**
+     * Get all registered routes
+     */
+    getRoutes(): Map<string, RouteEntry>;
+    /**
+     * Get all registered layouts
+     */
+    getLayouts(): Map<string, RouteEntry>;
+    getRouteSlots(): Map<string, RouteSlotEntry>;
+    /** Resolve route rules, inherited layouts, and the page export in precedence order. */
+    resolveRouteRuntimeConfig(pattern: string): Promise<ResolvedFarmRouteRuntimeConfig>;
+    /**
+     * Get all route-level loading boundaries.
+     */
+    getLoadings(): Map<string, RouteEntry>;
+    /**
+     * Get all route-level error boundaries.
+     */
+    getErrors(): Map<string, RouteEntry>;
+    getMetadataImages(): Map<string, MetadataImageEntry>;
+    getMetadataRoutes(): Map<string, ApplicationMetadataRouteEntry>;
+    getRedirects(): ProgrammaticRedirectRoute[];
+    matchRedirect(pathname: string, search?: string): {
+        redirect: ProgrammaticRedirectRoute;
+        destination: string;
+        statusCode: number;
+        params: Record<string, string>;
+    } | null;
+    /**
+     * Return the nearest matching loading boundary for a pathname. Pass the page
+     * `matchRoute` selected when it is known (`null` for none); otherwise the page is
+     * matched only if a boundary inside a route group needs it.
+     */
+    getMatchingLoading(pathname: string, route?: RouteEntry | null): RouteEntry | null;
+    /**
+     * Return the nearest matching error boundary for a pathname. `route` works as it
+     * does for `getMatchingLoading`.
+     */
+    getMatchingError(pathname: string, route?: RouteEntry | null): RouteEntry | null;
+    matchMetadataImage(pathname: string): {
+        image: MetadataImageEntry;
+        params: Record<string, string>;
+        pagePath: string;
+    } | null;
+    matchMetadataRoute(pathname: string): {
+        metadata: ApplicationMetadataRouteEntry;
+        params: Record<string, string>;
+        routePath: string;
+    } | null;
+    getMatchingMetadataRoute(pathname: string, kind: ApplicationMetadataRouteKind): {
+        metadata: ApplicationMetadataRouteEntry;
+        params: Record<string, string>;
+        routePath: string;
+    } | null;
+    resolveMetadataRoutePath(metadata: ApplicationMetadataRouteEntry, params?: Record<string, string>): string;
+    getMatchingMetadataImage(pathname: string, kind: MetadataImageKind): {
+        image: MetadataImageEntry;
+        params: Record<string, string>;
+    } | null;
+    resolveMetadataImagePath(image: MetadataImageEntry, params?: Record<string, string>): string;
+    /**
+     * Generate the compiled route decisions consumed by SPA navigation.
+     * Requests still fetch route data, but never inspect component source.
+     */
+    generateClientManifest(projectRoot?: string): FarmClientRouteManifest;
+    /**
+     * Rebuild route metadata transactionally for HMR. If a file is temporarily
+     * invalid while it is being edited, keep the last usable plan so unrelated
+     * updates and the next repair can still compare against it.
+     *
+     * @internal
+     */
+    regenerateClientManifest(projectRoot?: string): FarmClientRouteManifest;
+    /**
+     * Where each programmatic page and layout's component lives, read from the evaluated routes
+     * files. The client build imports those modules instead of the routes files.
+     */
+    getProgrammaticClientRoutes(): ProgrammaticClientRoutes;
+    /** @internal Client modules selected by the compiled hydration ownership plan. */
+    getIsolatedClientBoundaryModules(projectRoot?: string): ReadonlySet<string>;
+    /**
+     * @internal Islands-mode pages with a client component that cannot become an island. Hydrating
+     * such a page whole would ship its server code to the browser, so it stays static instead.
+     */
+    getIslandsErrors(projectRoot?: string): readonly string[];
+    /**
+     * Invalidate build-time route metadata after a page or layout changes in dev.
+     * Navigation requests reuse the cached manifest and never inspect source files.
+     */
+    invalidateClientManifest(): void;
+    /**
+     * Load a route module dynamically
+     */
+    loadRouteModule(modulePath: string): Promise<RouteModule>;
+    /**
+     * Load a layout module dynamically
+     */
+    loadLayoutModule(modulePath: string): Promise<LayoutModule>;
+    /**
+     * Create a route pattern from parsed route
+     */
+    private createRoutePattern;
+    private registerPageRoute;
+    private discoverFileRoutes;
+    private discoverProgrammaticRoutes;
+    private loadProgrammaticRoutesModule;
+    /**
+     * Find all layouts that should wrap a given path. A layout inside a route group
+     * wraps only the pages in that group, so it needs the selected page.
+     */
+    private findMatchingLayouts;
+    private matchPageRoute;
+    private findMatchingRouteSlots;
+    private matchesRoutePrefix;
+    private findNearestBoundary;
+    /**
+     * Log discovered routes for debugging
+     */
+    private logRoutes;
+    /**
+     * Collect SSG pages for static generation
+     *
+     * Returns all pages marked with `export const ssg = true` along with
+     * their pre-computed paths (for dynamic routes using getStaticPaths)
+     */
+    collectSSGPages(): Promise<SSGCollectionResult>;
+    private toRoutePathname;
+    private localizeRedirectDestination;
+    private getI18nConfig;
+    /**
+     * Check if a route is SSG
+     */
+    isRouteSSG(modulePath: string): Promise<boolean>;
+    /**
+     * Check if a route has ISR (Incremental Static Regeneration)
+     */
+    hasRouteISR(modulePath: string): Promise<boolean>;
+    /**
+     * Get revalidation interval for a route
+     */
+    getRouteRevalidateInterval(modulePath: string): Promise<number | undefined>;
+}
+
+interface FarmNavigationFragmentLayout {
+    pattern: string;
+    module: {
+        default?: any;
+    };
+}
+interface FarmNavigationFragmentSlot {
+    name: string;
+    ownerPattern: string;
+    /** The owning layout's pattern when route groups make it differ from `ownerPattern`. */
+    ownerDirectory?: string;
+    containerId: string;
+    module: {
+        default?: any;
+    };
+    props: Record<string, unknown>;
+}
+interface FarmNavigationFragmentInput {
+    PageComponent: any;
+    LoadingComponent?: any;
+    pageProps: Record<string, unknown>;
+    params: Record<string, string>;
+    layouts: FarmNavigationFragmentLayout[];
+    /** First destination layout that changed compared with the active shell. */
+    layoutStartIndex?: number;
+    slots?: FarmNavigationFragmentSlot[];
+    pageShouldHydrate: boolean;
+    layoutShouldHydrate: boolean;
+    islandStrategy?: FarmIslandStrategy | null;
+    /** The page renders as a server tree inside its hydrating layout's root. */
+    serverTree?: boolean;
+}
+declare class ServerRenderer {
+    private config;
+    private routeManager;
+    private ssgManifest;
+    private dataCache;
+    private i18nRuntime?;
+    private viteServer?;
+    private rendererRuntime;
+    private appliedAppSetupModule;
+    private security;
+    private apiRouteExists?;
+    private middlewareRoutes?;
+    private defaultMCPServer?;
+    constructor(config: Required<FarmConfig>, routeManager: RouteManager, i18nRuntime?: FarmI18nRuntime, viteServer?: ViteDevServer);
+    initialize(): Promise<void>;
+    /**
+     * Pass the app's renderer setup module (`renderer.appSetup`) to the renderer. In development
+     * the module runner returns the cached module until the file changes, so an edit is
+     * re-applied on the next request without restarting.
+     */
+    private applyRendererAppSetup;
+    private createPageBoundary;
+    private devGlobalStylesheetHref;
+    private devGlobalStylesheetLink;
+    private devGlobalStylesheetAssets;
+    private collectDevStyleHrefs;
+    private collectDevStyleLinks;
+    private createLayoutBoundary;
+    private wrapClientGraph;
+    /** The page a hydrating layout keeps as server HTML: islands again, or a server tree. */
+    private isolateServerPage;
+    private renderElementToCompleteHTML;
+    /**
+     * Buffered render carrying document-head markup for renderers that emit it
+     * during render (e.g. <svelte:head>). Other renderers return an empty head.
+     */
+    private renderElementToDocumentParts;
+    /** Islands mode sends large prop values once, keyed by content (RFC 0003). */
+    private islandValues;
+    /**
+     * Render the route tree used by client navigation without producing a second
+     * document response. Layout markers let the browser preserve the longest
+     * common shell and replace only the first changed boundary.
+     */
+    renderNavigationFragment(input: FarmNavigationFragmentInput): Promise<string>;
+    runWithRequestContext<T>(request: Request, fn: () => T | Promise<T>): Promise<T>;
+    resolveRouteContext(input: {
+        request: Request;
+        rawRequest?: FarmRequest;
+        params: Record<string, string>;
+        search: Record<string, string | string[] | undefined>;
+        path: string;
+    }): Promise<unknown>;
+    /**
+     * Load SSG manifest from build output
+     */
+    private loadSSGManifest;
+    /**
+     * Check if a path should be served from SSG cache
+     */
+    private shouldServeSSG;
+    private getSSGCacheKey;
+    private getPPRCacheKey;
+    private getCachedSSGPage;
+    private cacheSSGPage;
+    private getCachedPPRShell;
+    private cachePPRShell;
+    private getPPRShellBypassReason;
+    private getPPRHeaders;
+    private serveCachedPPRShell;
+    /**
+     * Regenerate an SSG page in the background (ISR)
+     */
+    private regenerateSSGPage;
+    /**
+     * Serve a pre-rendered SSG page
+     */
+    private serveSSGPage;
+    renderPage(req: FarmRequest, res: FarmResponse): Promise<void>;
+    private renderPageInContext;
+    private wrapWithIntegrationProviders;
+    private resolveRouteMetadata;
+    private resolveMetadataImageReference;
+    private renderMetadataRoute;
+    /** `/llms.txt` and `/llms-full.txt` from `agent.llmsTxt` when no file route owns them. */
+    private getGeneratedLlmsKind;
+    private renderGeneratedLlmsTxt;
+    private getAgentCrawlers;
+    /** `/robots.txt` from `agent.crawlers` when no robots.ts owns it. */
+    private renderGeneratedRobotsTxt;
+    private getAgentSitemap;
+    /** `/sitemap.xml` from `agent.sitemap` when no sitemap.ts owns it. */
+    private renderGeneratedSitemap;
+    /** Lets the default MCP server see the app's API routes, which the dev server owns. */
+    setAPIRouteLookup(exists: (path: string) => boolean): void;
+    /** The dev server's file middleware, so public page listings can leave guarded pages out. */
+    setMiddlewareRouteLookup(routes: () => readonly {
+        path: string;
+    }[]): void;
+    /**
+     * The static pages sitemap.xml, llms.txt and the default MCP server may list: not one a
+     * path-specific guard (non-root middleware.ts, a config or integration middleware
+     * matcher) covers, as the production build decides.
+     */
+    private getAgentListedRoutes;
+    /**
+     * The default read-only MCP server (`agent.mcp`), or undefined when the app has an MCP
+     * server of its own: a route that answers /mcp, an API route at /api/mcp, `@farm.js/mcp`,
+     * or a registered server such as the docs engine's. Production applies the same rules.
+     */
+    getDefaultMCPServer(): ReturnType<typeof createFarmDefaultMCPServer> | undefined;
+    private renderDefaultMCP;
+    /** Same inputs the production server gives llms.txt: static pages and root metadata. */
+    private createLlmsTxtContext;
+    /**
+     * Reads page mirrors back through this dev server, the way its .md handler
+     * renders pages, so Markdown sources and agent overrides are included. Requests
+     * go to the server's own socket address: the page URLs carry the Host header,
+     * which a client controls, and fetching them would let anyone who can reach a
+     * network-exposed dev server point it at other hosts. Over HTTPS the certificate
+     * is still checked against the requested hostname. HEAD reads nothing, since its
+     * body is discarded.
+     */
+    private createDevMarkdownReader;
+    private renderMetadataImage;
+    private writeMetadataImageResponse;
+    private writeStaticMetadataImageResponse;
+    private renderRouteErrorBoundary;
+    private renderBufferedSSR;
+    /**
+     * Whether the root layout returns its own `<html>` document, checked as the client's layout
+     * boundary checks it: call a plain synchronous layout and look at what it returns. Knowing
+     * this up front keeps a route's first request on the buffered path too; a layout this cannot
+     * call (async, a class, or one using hooks) falls back to detection from the stream.
+     */
+    private rootLayoutRendersDocument;
+    private renderWithSSR;
+    /**
+     * Answer a redirect() or notFound() thrown by middleware, before anything was
+     * sent. Returns false for any other error.
+     */
+    respondToNavigationError(req: FarmRequest, res: FarmResponse, error: unknown): Promise<boolean>;
+    private localizeRedirectUrl;
+    /** The app's not-found component, or null when it relies on the built-in page. */
+    private loadNotFoundModule;
+    private loadNotFoundComponent;
+    /** The not-found document's head: layout and not-found metadata, as production renders it. */
+    private notFoundMetadataHead;
+    private defaultNotFoundContent;
+    /**
+     * A redirect() or notFound() thrown after the shell was sent can no longer
+     * change the status. Like Next.js, finish the document so it recovers:
+     * redirect in the browser, or swap the page for the not-found UI and mark
+     * the document noindex.
+     */
+    private createLateNavigationRecoveryHTML;
+    private render404;
+    private renderError;
+    /**
+     * Where i18n hreflang alternates resolve to absolute URLs: the route's
+     * metadataBase, otherwise the request origin under the same trustProxy rule
+     * as every other request URL.
+     */
+    private getI18nAlternateOptions;
+    private createFullHTML;
+    private getCspNonce;
+    /** Stamp the response nonce on markup Farm generates (never on rendered app output). */
+    private stampFarmScripts;
+    /**
+     * The last pass over a document that holds rendered app output: scripts
+     * keep the response nonce only when Farm or the app (through getCspNonce())
+     * gave it to them.
+     */
+    private secureDocumentHTML;
+    private applyDeploymentHeaders;
+    private getDeploymentId;
+}
+
+type NormalizedFarmConfig = Omit<Required<FarmConfig>, "api" | "devtools" | "devIndicators" | "images" | "i18n" | "performance" | "security" | "theme"> & {
+    api: ResolvedFarmAPIConfig;
+    docs: FarmDocsResolvedConfig;
+    md: FarmMarkdownResolvedConfig;
+    mdx: FarmMdxResolvedConfig;
+    cron: FarmCronResolvedConfig;
+    workflows: FarmWorkflowsResolvedConfig;
+    devtools: ResolvedFarmDevtoolsConfig;
+    devIndicators: ResolvedFarmDevIndicatorsConfig;
+    images: ResolvedFarmImageConfig;
+    i18n: ResolvedFarmI18nConfig;
+    auth: ResolvedFarmAuthConfig;
+    performance: ResolvedFarmPerformanceConfig;
+    security: ResolvedFarmSecurityConfig;
+    theme: ResolvedFarmThemeConfig;
+    renderer: FarmRenderer;
+};
+declare class FarmApp {
+    private config;
+    private routeManager;
+    private serverRenderer;
+    private i18nRuntime;
+    private viteServer?;
+    constructor(config?: FarmConfig, viteServer?: ViteDevServer);
+    initialize(): Promise<void>;
+    getRouteManager(): RouteManager;
+    getServerRenderer(): ServerRenderer;
+    getI18nRuntime(): FarmI18nRuntime;
+    getConfig(): NormalizedFarmConfig;
+    private normalizeConfig;
+    private verifyAppStructure;
+}
+declare function createFarmApp(config?: FarmConfig, viteServer?: ViteDevServer): FarmApp;
+
+export { FarmApp as F, RouteManager as R, ServerRenderer as S, createFarmApp as c };

package/dist/app-manifest-BUu7YGAx.d.ts

@@ -0,0 +1,120 @@
+import { aG as FarmMCPCatalogDetails, aH as ResolvedFarmAppManifestConfig } from './client-plugins-DqjCsKMN.js';
+
+interface FarmAppManifestWebMCPTool {
+    name: string;
+    title?: string;
+    description?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+    /** The input JSON Schema when the source writes it out; omitted when it's computed. */
+    inputSchema?: Record<string, unknown>;
+    /** `"computed"` when the schema is built at runtime, so it can't be read from source. */
+    inputSchemaSource: "literal" | "computed" | "none";
+}
+
+type FarmAppManifestToolSource = "endpoint" | "defineTool" | "serverFunction";
+interface FarmAppManifestTool {
+    name: string;
+    title?: string;
+    description?: string;
+    /** How the app defined it: an API endpoint, `defineTool`, or a server function. */
+    source: FarmAppManifestToolSource;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+    /**
+     * JSON Schemas, when the server published them (`@farm.js/mcp` does) and
+     * `agent.manifest.mcp.schemas` isn't `false`.
+     */
+    inputSchema?: Readonly<Record<string, unknown>>;
+    outputSchema?: Readonly<Record<string, unknown>>;
+}
+type ServerDetails = NonNullable<FarmMCPCatalogDetails>;
+interface FarmAppManifestServer {
+    name: string;
+    version: string;
+    path: string;
+    /**
+     * `"required"` when the server runs `authorize` or a guard covers its path: an anonymous
+     * client lists nothing, so `tools`, `resources` and `prompts` are empty.
+     */
+    authorization: "none" | "required";
+    tools: FarmAppManifestTool[];
+    resources: NonNullable<ServerDetails["resources"]>;
+    prompts: NonNullable<ServerDetails["prompts"]>;
+}
+/**
+ * The manifest document. A section the app hid with `agent.manifest` is `null`, unlike an
+ * empty list, which means there is nothing to show.
+ */
+interface FarmAppManifest {
+    schemaVersion: 1;
+    /** `farm`, `renderer` and `build` are left out when `agent.manifest.app` hides them. */
+    app: {
+        farm?: string;
+        renderer?: string;
+        basePath: string;
+        build?: string;
+    } | null;
+    /**
+     * Installed versions of the app's `@farm.js/*` and `@farming-labs/*` packages; `null`
+     * versions with `agent.manifest.packages: "names"`.
+     */
+    packages: Record<string, string | null> | null;
+    mcp: {
+        servers: FarmAppManifestServer[];
+    } | null;
+    /** Browser tools from `@farm.js/webmcp`, read from the app's source. */
+    webmcp: {
+        enabled: boolean;
+        tools: FarmAppManifestWebMCPTool[];
+    } | null;
+    /** The app's integrations: which slot each fills and which provider, never their config. */
+    integrations: {
+        key: string;
+        category: string;
+        type: string;
+    }[] | null;
+    agent: {
+        apiCatalog: string | null;
+        llmsTxt: boolean;
+        openapi: string | null;
+    } | null;
+    plugins: string[] | null;
+}
+/** What the manifest reads from config; serializable, so a production build embeds it. */
+interface FarmAppManifestInput {
+    renderer: string;
+    basePath: string;
+    /** The build's ID, or "development". */
+    build: string;
+    packages: Record<string, string>;
+    webmcp: NonNullable<FarmAppManifest["webmcp"]>;
+    integrations: NonNullable<FarmAppManifest["integrations"]>;
+    agent: NonNullable<FarmAppManifest["agent"]>;
+    plugins: string[];
+    /** Resolved `agent.manifest` options; every section is shown without them. */
+    sections?: ResolvedFarmAppManifestConfig;
+    /**
+     * The default read-only MCP server (`agent.mcp`) while the app would serve it. Set by the
+     * server at runtime, not serialized: it answers only while no other MCP server is listed.
+     */
+    defaultMCP?: () => {
+        name: string;
+        version: string;
+        path: string;
+    } | undefined;
+    /**
+     * Whether a guard written for a path (middleware, an integration's `protectedRoutes`)
+     * covers an MCP server's endpoint. Set by the server at runtime: such a server is listed
+     * as requiring authorization, without its tools, resources or prompts.
+     */
+    guardCoversPath?: (path: string) => boolean;
+}
+/** Answers `/.well-known/farmjs.json`: the same public document for every request. */
+declare function createFarmAppManifestResponse(request: Request, input: FarmAppManifestInput): Promise<Response>;
+
+export { type FarmAppManifest as F, type FarmAppManifestServer as a, type FarmAppManifestTool as b, createFarmAppManifestResponse as c };