@farm.js/core 0.1.61 → 0.1.62

package/dist/renderer-client.mjs

@@ -1,64 +1,67 @@
 "use client";
 import {
   createFarmClientTranslator
-} from "./chunk-AHGECQEW.mjs";
+} from "./chunk-JRHGJVJH.mjs";
+import {
+  attachRevalidationListeners
+} from "./chunk-Z64V4WZI.mjs";
 import {
-  attachRevalidationListeners,
   createServerQueryCallKey,
   fetchServerQuery,
   isFarmServerQueryBrowserRuntime
-} from "./chunk-LYV44OIR.mjs";
+} from "./chunk-XMHERKSE.mjs";
 import {
   getTheme,
   setTheme,
   subscribeTheme,
   toggleTheme
-} from "./chunk-N46M65CI.mjs";
+} from "./chunk-6BLAY2VQ.mjs";
 import {
   createFarmRouter
-} from "./chunk-6NT6S2VQ.mjs";
-import "./chunk-OT6ZEW74.mjs";
+} from "./chunk-BPAXGCKX.mjs";
 import {
   getRouter,
   readPageState,
   subscribeHistoryChange
-} from "./chunk-XCMCS4DA.mjs";
+} from "./chunk-25T5VXOE.mjs";
 import {
   getFarmI18nClientState,
   subscribeFarmI18n
-} from "./chunk-F2SE2VDO.mjs";
-import "./chunk-2PQNJXFM.mjs";
-import "./chunk-5SJWVY6R.mjs";
+} from "./chunk-PTLXHRJZ.mjs";
+import {
+  delegateNavigation
+} from "./chunk-RSEAX5MW.mjs";
+import "./chunk-NCIAP562.mjs";
 import {
   getFarmClientDataCache
-} from "./chunk-XNPDONUH.mjs";
-import "./chunk-QVYLBY73.mjs";
-import "./chunk-KGB5UXJJ.mjs";
+} from "./chunk-C64XOPBZ.mjs";
+import "./chunk-H227LYHT.mjs";
+import "./chunk-N7XWC6BN.mjs";
 import {
   createFarmLocaleCookie
-} from "./chunk-GCXWJJKH.mjs";
-import "./chunk-JM5XPKWH.mjs";
-import "./chunk-CXEN47J3.mjs";
-import "./chunk-SKNL7VA2.mjs";
-import "./chunk-2A3EQHXX.mjs";
-import "./chunk-JNZ4TDWM.mjs";
-import "./chunk-C4NCTZLM.mjs";
-import "./chunk-CNOQY6Z7.mjs";
-import "./chunk-4SIYUGRY.mjs";
+} from "./chunk-K76CBYQM.mjs";
+import "./chunk-AY2YD5ZX.mjs";
+import "./chunk-MFQGU5CC.mjs";
+import "./chunk-S6O2L47H.mjs";
+import "./chunk-NBIVGHAT.mjs";
+import "./chunk-WCLLPR6H.mjs";
+import "./chunk-UAQD67HM.mjs";
+import "./chunk-K5EW7GUU.mjs";
+import "./chunk-M25IONJP.mjs";
+import "./chunk-GLOICKDO.mjs";
+import "./chunk-AZQXXXDX.mjs";
 import {
   localizeFarmHref,
   stripFarmLocaleFromPathname
-} from "./chunk-L3KT7IXV.mjs";
+} from "./chunk-7S7AAK2D.mjs";
 import {
   applyFarmBasePath,
   getFarmBasePath,
   normalizeFarmBasePath,
   stripFarmBasePath
-} from "./chunk-4RB44K6Z.mjs";
-import "./chunk-55YI3RRB.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
+} from "./chunk-SF3JB56B.mjs";
+import "./chunk-AYP2YFVN.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 
 // src/renderer-client.ts
 function createRendererRouter(options = {}) {
@@ -66,19 +69,19 @@ function createRendererRouter(options = {}) {
   const matcher = options.routes?.length ? createFarmRouter([...options.routes]) : null;
   const router = getRouter();
   let snapshot = readRendererRouterSnapshot(basePath, matcher, router.getNavigationState());
-  const read = /* @__PURE__ */ __name(() => {
+  const read = () => {
     snapshot = readRendererRouterSnapshot(basePath, matcher, router.getNavigationState());
     return snapshot;
-  }, "read");
+  };
   return {
-    getSnapshot: /* @__PURE__ */ __name(() => snapshot, "getSnapshot"),
+    getSnapshot: () => snapshot,
     subscribe(listener) {
       if (typeof window === "undefined") return () => {
       };
-      const notify = /* @__PURE__ */ __name(() => {
+      const notify = () => {
         read();
         listener();
-      }, "notify");
+      };
       const unsubscribeNavigation = router.subscribeNavigation(notify);
       const unsubscribeHistory = subscribeHistoryChange(notify);
       read();
@@ -96,8 +99,8 @@ function createRendererRouter(options = {}) {
         replace: true
       });
     },
-    refresh: /* @__PURE__ */ __name((refreshOptions) => typeof window === "undefined" ? Promise.resolve() : router.refresh(refreshOptions), "refresh"),
-    prefetch: /* @__PURE__ */ __name((href) => typeof window === "undefined" ? Promise.resolve() : router.prefetch(resolveRendererHref(href, basePath)), "prefetch"),
+    refresh: (refreshOptions) => typeof window === "undefined" ? Promise.resolve() : router.refresh(refreshOptions),
+    prefetch: (href) => typeof window === "undefined" ? Promise.resolve() : router.prefetch(resolveRendererHref(href, basePath)),
     back() {
       if (typeof window !== "undefined") window.history.back();
     },
@@ -118,7 +121,6 @@ function createRendererRouter(options = {}) {
     }
   };
 }
-__name(createRendererRouter, "createRendererRouter");
 function createRendererAction(target, options = {}) {
   const serverFn = resolveRendererServerFn(target);
   const listeners = /* @__PURE__ */ new Set();
@@ -132,12 +134,12 @@ function createRendererAction(target, options = {}) {
     data: initialResult,
     error: null
   };
-  const update = /* @__PURE__ */ __name((next) => {
+  const update = (next) => {
     snapshot = next;
     for (const listener of listeners) listener();
-  }, "update");
+  };
   return {
-    getSnapshot: /* @__PURE__ */ __name(() => snapshot, "getSnapshot"),
+    getSnapshot: () => snapshot,
     subscribe(listener) {
       listeners.add(listener);
       return () => listeners.delete(listener);
@@ -199,7 +201,6 @@ function createRendererAction(target, options = {}) {
     }
   };
 }
-__name(createRendererAction, "createRendererAction");
 function createRendererQuery(query, input, options = {}) {
   if (!isFarmServerQueryBrowserRuntime()) {
     const snapshot = {
@@ -211,10 +212,10 @@ function createRendererQuery(query, input, options = {}) {
       stale: true
     };
     return {
-      getSnapshot: /* @__PURE__ */ __name(() => snapshot, "getSnapshot"),
-      subscribe: /* @__PURE__ */ __name(() => () => {
-      }, "subscribe"),
-      refetch: /* @__PURE__ */ __name(() => fetchServerQuery(query, input), "refetch"),
+      getSnapshot: () => snapshot,
+      subscribe: () => () => {
+      },
+      refetch: () => fetchServerQuery(query, input),
       dispose() {
       }
     };
@@ -224,8 +225,8 @@ function createRendererQuery(query, input, options = {}) {
   const listeners = /* @__PURE__ */ new Set();
   let unsubscribeCache;
   let cleanupBrowser;
-  const run = /* @__PURE__ */ __name((force = false) => fetchServerQuery(query, input, { ...options, force }), "run");
-  const ensureStarted = /* @__PURE__ */ __name(() => {
+  const run = (force = false) => fetchServerQuery(query, input, { ...options, force });
+  const ensureStarted = () => {
     if (options.enabled === false || unsubscribeCache) return;
     unsubscribeCache = cache.subscribe(key, () => {
       for (const listener of listeners) listener();
@@ -240,7 +241,7 @@ function createRendererQuery(query, input, options = {}) {
         refetchOnReconnect: options.refetchOnReconnect
       }
     );
-  }, "ensureStarted");
+  };
   return {
     getSnapshot() {
       const entry = cache.get(key);
@@ -259,7 +260,7 @@ function createRendererQuery(query, input, options = {}) {
       ensureStarted();
       return () => listeners.delete(listener);
     },
-    refetch: /* @__PURE__ */ __name(() => run(true), "refetch"),
+    refetch: () => run(true),
     dispose() {
       unsubscribeCache?.();
       cleanupBrowser?.();
@@ -269,7 +270,6 @@ function createRendererQuery(query, input, options = {}) {
     }
   };
 }
-__name(createRendererQuery, "createRendererQuery");
 function createRendererTheme() {
   return {
     getSnapshot: getTheme,
@@ -278,7 +278,6 @@ function createRendererTheme() {
     toggleTheme
   };
 }
-__name(createRendererTheme, "createRendererTheme");
 function createRendererI18n() {
   return {
     getSnapshot: getFarmI18nClientState,
@@ -297,7 +296,6 @@ function createRendererI18n() {
     }
   };
 }
-__name(createRendererI18n, "createRendererI18n");
 function readRendererRouterSnapshot(basePath, matcher, navigation) {
   if (typeof window === "undefined") {
     return {
@@ -320,11 +318,9 @@ function readRendererRouterSnapshot(basePath, matcher, navigation) {
     navigation
   };
 }
-__name(readRendererRouterSnapshot, "readRendererRouterSnapshot");
 function resolveRendererHref(href, basePath) {
   return applyFarmBasePath(href, basePath);
 }
-__name(resolveRendererHref, "resolveRendererHref");
 function resolveRendererServerFn(target) {
   if (typeof target === "function") return target;
   if (target && typeof target.action === "function") return target.action;
@@ -332,22 +328,20 @@ function resolveRendererServerFn(target) {
     "createRendererAction requires a server function or a route with a declared action"
   );
 }
-__name(resolveRendererServerFn, "resolveRendererServerFn");
 function normalizeRendererClientError(cause) {
   if (cause instanceof Error) return cause;
   const error = new Error(typeof cause === "string" ? cause : "FARMJS client operation failed");
   error.cause = cause;
   return error;
 }
-__name(normalizeRendererClientError, "normalizeRendererClientError");
 function isRendererFormData(value) {
   return typeof FormData !== "undefined" && value instanceof FormData;
 }
-__name(isRendererFormData, "isRendererFormData");
 export {
   createRendererAction,
   createRendererI18n,
   createRendererQuery,
   createRendererRouter,
-  createRendererTheme
+  createRendererTheme,
+  delegateNavigation
 };

package/dist/renderer.cjs

@@ -13,8 +13,8 @@
 
 
 
-var _chunkPSV6XKPOcjs = require('./chunk-PSV6XKPO.cjs');
-require('./chunk-S3JO3N4H.cjs');
+var _chunkRD623KW4cjs = require('./chunk-RD623KW4.cjs');
+require('./chunk-BTZ5O6VM.cjs');
 
 
 
@@ -30,4 +30,4 @@ require('./chunk-S3JO3N4H.cjs');
 
 
 
-exports.FARM_COMPONENT_EXTENSIONS = _chunkPSV6XKPOcjs.FARM_COMPONENT_EXTENSIONS; exports.REACT_RENDERER = _chunkPSV6XKPOcjs.REACT_RENDERER; exports.assertFarmRendererStreamingRuntime = _chunkPSV6XKPOcjs.assertFarmRendererStreamingRuntime; exports.defineRenderer = _chunkPSV6XKPOcjs.defineRenderer; exports.getFarmRendererCapabilities = _chunkPSV6XKPOcjs.getFarmRendererCapabilities; exports.getFarmRendererComponentExtensions = _chunkPSV6XKPOcjs.getFarmRendererComponentExtensions; exports.getFarmRendererStreamingCapabilitiesForRuntime = _chunkPSV6XKPOcjs.getFarmRendererStreamingCapabilitiesForRuntime; exports.isReactRenderer = _chunkPSV6XKPOcjs.isReactRenderer; exports.loadFarmRendererVitePlugins = _chunkPSV6XKPOcjs.loadFarmRendererVitePlugins; exports.readFarmRendererWebStream = _chunkPSV6XKPOcjs.readFarmRendererWebStream; exports.resolveFarmComponentExtensions = _chunkPSV6XKPOcjs.resolveFarmComponentExtensions; exports.resolveFarmRenderer = _chunkPSV6XKPOcjs.resolveFarmRenderer; exports.resolveFarmRendererAppSetup = _chunkPSV6XKPOcjs.resolveFarmRendererAppSetup; exports.resolveFarmRendererModule = _chunkPSV6XKPOcjs.resolveFarmRendererModule;
+exports.FARM_COMPONENT_EXTENSIONS = _chunkRD623KW4cjs.FARM_COMPONENT_EXTENSIONS; exports.REACT_RENDERER = _chunkRD623KW4cjs.REACT_RENDERER; exports.assertFarmRendererStreamingRuntime = _chunkRD623KW4cjs.assertFarmRendererStreamingRuntime; exports.defineRenderer = _chunkRD623KW4cjs.defineRenderer; exports.getFarmRendererCapabilities = _chunkRD623KW4cjs.getFarmRendererCapabilities; exports.getFarmRendererComponentExtensions = _chunkRD623KW4cjs.getFarmRendererComponentExtensions; exports.getFarmRendererStreamingCapabilitiesForRuntime = _chunkRD623KW4cjs.getFarmRendererStreamingCapabilitiesForRuntime; exports.isReactRenderer = _chunkRD623KW4cjs.isReactRenderer; exports.loadFarmRendererVitePlugins = _chunkRD623KW4cjs.loadFarmRendererVitePlugins; exports.readFarmRendererWebStream = _chunkRD623KW4cjs.readFarmRendererWebStream; exports.resolveFarmComponentExtensions = _chunkRD623KW4cjs.resolveFarmComponentExtensions; exports.resolveFarmRenderer = _chunkRD623KW4cjs.resolveFarmRenderer; exports.resolveFarmRendererAppSetup = _chunkRD623KW4cjs.resolveFarmRendererAppSetup; exports.resolveFarmRendererModule = _chunkRD623KW4cjs.resolveFarmRendererModule;

package/dist/renderer.d.mts

@@ -0,0 +1,260 @@
+import { FarmPresetRuntime } from './deployment.mjs';
+
+/**
+ * A rendering-library integration used by Farm's compiler, server renderer,
+ * and browser hydration runtime.
+ *
+ * Renderer descriptors intentionally contain module identifiers instead of
+ * implementation functions. This keeps farm.config.ts serializable and lets
+ * every module resolve from the application that selected the renderer.
+ */
+interface FarmRenderer {
+    /** Stable public identifier used in diagnostics and generated manifests. */
+    name: string;
+    /** Module exporting the renderer's Vite plugin factory. */
+    vite: string;
+    /** Module exporting Farm's server-renderer compatibility contract. */
+    server: string;
+    /** Module exporting Farm's browser-renderer compatibility contract. */
+    client: string;
+    /** JSX import source written to generated TypeScript configuration. */
+    jsxImportSource?: string;
+    /** Additional file extensions used for renderer-owned route components. */
+    componentExtensions?: readonly string[];
+    /** Packages that must share one module instance in a Farm application. */
+    dedupe?: readonly string[];
+    /** Renderer packages seeded into Vite's dependency optimizer. */
+    optimizeDeps?: readonly string[];
+    /**
+     * Scheduling policy for the production client and SSR graphs.
+     *
+     * Most renderer plugins are safe to run in parallel. Renderers whose
+     * compiler plugins keep process-global mutable state can opt into serial
+     * builds so one graph cannot invalidate the other's transforms.
+     */
+    buildConcurrency?: "parallel" | "serial";
+    /** Runtime features this renderer intentionally supports. */
+    capabilities?: FarmRendererCapabilitiesInput;
+    /**
+     * Serializable options consumed by the renderer's Vite integration.
+     *
+     * Keeping renderer-owned configuration on the descriptor lets one rendering
+     * library expose multiple compiler modes without teaching Farm's core about
+     * each option.
+     */
+    options?: Readonly<Record<string, unknown>>;
+    /**
+     * Module that configures each app instance the renderer creates, relative to the project
+     * root. Farm imports it in the server and client entries and passes its default export to
+     * the renderer's `configureApp()`, which both renderer runtime modules must export.
+     */
+    appSetup?: string;
+}
+type FarmRendererRuntime = Exclude<FarmPresetRuntime, "unknown">;
+interface FarmRendererStreamingPrimitives {
+    /** Supports Node.js writable streams through renderToPipeableStream(). */
+    node: boolean;
+    /** Supports WHATWG ReadableStream output through renderToReadableStream(). */
+    web: boolean;
+}
+interface FarmRendererStreamingCapabilities extends FarmRendererStreamingPrimitives {
+    /**
+     * Overrides the default stream primitives for a deployment runtime.
+     *
+     * The top-level values remain the fallback for development and unknown
+     * presets. Runtime overrides let a renderer describe packages whose exports
+     * change with bundler conditions, such as React DOM's Node and edge builds.
+     */
+    runtimes?: Partial<Record<FarmRendererRuntime, FarmRendererStreamingPrimitives>>;
+}
+interface FarmRendererCapabilities {
+    streaming: FarmRendererStreamingCapabilities;
+    /**
+     * Whether re-rendering an existing root diffs the new tree against the live
+     * DOM instead of rebuilding it.
+     *
+     * Virtual-DOM renderers (React, Preact, Vue) compare the incoming tree with
+     * what is mounted, so a client navigation that re-renders a shared layout
+     * keeps the matching DOM nodes, their focus, and their component state.
+     *
+     * Compile-time fine-grained renderers (Solid, Svelte) have no virtual DOM to
+     * diff against. Their updates flow through bindings created when elements
+     * were constructed, so handing them a freshly materialized tree replaces the
+     * nodes. That is a property of those runtimes, not a gap in their adapters,
+     * and callers that need state to survive a re-render must keep it in a root
+     * they do not re-render rather than expect reconciliation here.
+     */
+    reconcilesRerenders: boolean;
+    /**
+     * Whether this renderer can render a plain function component: one that
+     * takes props and returns an element tree, rather than a component built by
+     * the renderer's own compiler.
+     *
+     * React-shaped renderers do this natively. A compile-time renderer needs its
+     * adapter to recognize such a component and call it, because its own
+     * components are functions too and the two are otherwise indistinguishable.
+     * Farm uses this to decide whether integration provider components can be
+     * rendered at all, so it defaults to false and each adapter opts in once it
+     * handles them.
+     */
+    functionComponents: boolean;
+}
+interface FarmRendererCapabilitiesInput {
+    streaming?: Partial<FarmRendererStreamingPrimitives> & {
+        runtimes?: Partial<Record<FarmRendererRuntime, Partial<FarmRendererStreamingPrimitives>>>;
+    };
+    reconcilesRerenders?: boolean;
+    functionComponents?: boolean;
+}
+/** A client layout participating in a renderer-owned route update. */
+interface FarmRendererRouteLayout {
+    /** Stable route pattern used to decide whether the mounted layout chain changed. */
+    pattern: string;
+    /** Renderer-native layout component. */
+    Component: unknown;
+}
+/**
+ * Renderer-neutral route state supplied during hydration and client navigation.
+ *
+ * Virtual-DOM renderers can ignore this and keep rendering `element`. A
+ * fine-grained renderer can implement `renderRoute()` and keep the matching
+ * layout chain mounted while it updates the page slot and route params through
+ * its native reactive primitives.
+ */
+interface FarmRendererRouteState {
+    /** Fully composed fallback tree for renderers that only implement render(). */
+    element: unknown;
+    /** Applicable layouts in outermost-to-innermost order. */
+    layouts: readonly FarmRendererRouteLayout[];
+    /** Page boundary or page element placed in the innermost layout slot. */
+    page: unknown;
+    /** Current dynamic route params. */
+    params: Readonly<Record<string, string>>;
+    /** Framework wrappers, such as integration providers, applied outside layouts. */
+    wrap?: (element: unknown) => unknown;
+}
+/** Browser root contract implemented by renderer client adapters. */
+interface FarmRendererClientRoot {
+    render(element: unknown): void;
+    /** Optional renderer-native route update that preserves matching layouts. */
+    renderRoute?(state: FarmRendererRouteState): void;
+    unmount(): void;
+}
+/** Browser entry exported by a renderer client module. */
+interface FarmRendererClientRuntime {
+    createRoot(container: Element): FarmRendererClientRoot;
+    /**
+     * Non-React renderers receive route state as the optional third argument so
+     * a renderer-owned root can establish its native reactive route bindings
+     * during initial hydration.
+     */
+    hydrateRoot(container: Element, element: unknown, routeState?: FarmRendererRouteState): FarmRendererClientRoot;
+}
+declare function getFarmRendererCapabilities(renderer?: Pick<FarmRenderer, "capabilities">): FarmRendererCapabilities;
+declare function getFarmRendererStreamingCapabilitiesForRuntime(renderer: Pick<FarmRenderer, "capabilities"> | undefined, runtime: FarmRendererRuntime | "unknown"): FarmRendererStreamingPrimitives;
+declare function assertFarmRendererStreamingRuntime(name: string, renderer: Pick<FarmRenderer, "capabilities"> | undefined, runtimeModule: Pick<Partial<FarmServerRendererRuntime>, "capabilities" | "renderToPipeableStream" | "renderToReadableStream">, runtime: FarmRendererRuntime | "unknown"): FarmRendererStreamingPrimitives;
+declare const FARM_COMPONENT_EXTENSIONS: readonly [".ts", ".tsx", ".js", ".jsx"];
+declare function resolveFarmComponentExtensions(extensions?: readonly string[]): string[];
+declare function getFarmRendererComponentExtensions(renderer?: Pick<FarmRenderer, "componentExtensions">): string[];
+interface FarmRendererViteModule {
+    createFarmRendererPlugin(options?: {
+        ssr?: boolean;
+        /** Shared only within a production build; aborted after all graphs close. */
+        buildLifetime?: AbortSignal;
+        rendererOptions?: Readonly<Record<string, unknown>>;
+    }): unknown | readonly unknown[] | Promise<unknown | readonly unknown[]>;
+}
+/**
+ * Per-render options Farm passes to a server renderer. A renderer that emits
+ * its own inline scripts (hydration data, streaming reveals) puts `nonce` on
+ * them; under `security.csp.nonce` any script without it is blocked.
+ */
+interface FarmRendererRenderOptions {
+    /** CSP nonce of the response being rendered. */
+    nonce?: string;
+}
+interface FarmServerRendererRuntime {
+    readonly name: string;
+    readonly Fragment: unknown;
+    readonly Suspense: unknown;
+    createElement(type: unknown, props?: unknown, ...children: unknown[]): unknown;
+    isValidElement(value: unknown): boolean;
+    /** Wraps a route-owned client tree so compiled leaf boundaries stay inside that React root. */
+    wrapClientGraph?(element: unknown): unknown;
+    /** Lets a server-only page under a route-owned client tree render its own isolated islands. */
+    isolateServerPageGraph?(element: unknown): unknown;
+    /** Resolves an async page below a hydrating layout into a tree the browser rebuilds there. */
+    renderServerTreePage?(element: unknown, options?: {
+        values?: boolean;
+    }): Promise<unknown>;
+    /**
+     * Optional: tag a plain function component so a renderer that compiles its
+     * own components can tell the two apart. Renderers without the hook treat
+     * every component the same way and do not need it.
+     */
+    markFunctionComponent?<T>(component: T): T;
+    /**
+     * Optional: locate where a streamed chunk stops being the static shell.
+     *
+     * Partial prerendering caches everything before the first dynamic boundary
+     * and refreshes the rest on the client, so it has to know where that
+     * boundary is. The markers are renderer-specific (React streams Fizz
+     * boundary ids and `$RC`/`$RS` reveal calls, Solid streams `<template
+     * id="pl-N">` with `$df(N)`), so the renderer that emits them owns finding
+     * them. Returns the index to cut at, or -1 when the chunk is entirely
+     * static.
+     *
+     * A renderer that does not implement this gets no static shell at all:
+     * guessing would mean caching a per-request response as if it were shared.
+     */
+    findStaticShellBoundary?(chunk: string): number;
+    renderToString(element: unknown, options?: FarmRendererRenderOptions): string | Promise<string>;
+    /**
+     * Optional variant for renderers whose components emit document-head markup
+     * during render (e.g. <svelte:head>). `html` is the body markup exactly as
+     * renderToString would produce it; `head` is injected into the assembled
+     * document's <head>.
+     */
+    renderToStringWithHead?(element: unknown, options?: FarmRendererRenderOptions): {
+        html: string;
+        head: string;
+    } | Promise<{
+        html: string;
+        head: string;
+    }>;
+    /** Optional runtime copy of the descriptor capabilities for diagnostics. */
+    readonly capabilities?: FarmRendererCapabilitiesInput;
+    /** Optional bootstrap required before this renderer hydrates server markup. */
+    generateHydrationScript?: () => string;
+    /** Optional component used to render route-level failures. */
+    ErrorBoundary?: unknown;
+    /** Optional streaming primitive. Renderers without one use buffered SSR. */
+    renderToPipeableStream?: (element: unknown, callbacks: {
+        onShellReady(): void;
+        onShellError(error: unknown): void;
+        onError(error: unknown): void;
+        /** CSP nonce forwarded to renderer-owned inline streaming scripts. */
+        nonce?: string;
+    }) => {
+        pipe(destination: NodeJS.WritableStream): void;
+        /** Stop rendering; pending boundaries report `reason` to `onError`. */
+        abort?(reason?: unknown): void;
+    };
+    /** WHATWG streaming primitive used by Web-stream-capable renderers. */
+    renderToReadableStream?: (element: unknown, options?: FarmRendererRenderOptions) => ReadableStream<Uint8Array | string> | Promise<ReadableStream<Uint8Array | string>>;
+}
+declare const REACT_RENDERER: Readonly<FarmRenderer>;
+declare function defineRenderer<const TRenderer extends FarmRenderer>(renderer: TRenderer): TRenderer;
+declare function resolveFarmRenderer(renderer?: FarmRenderer): FarmRenderer;
+declare function readFarmRendererWebStream(stream: ReadableStream<Uint8Array | string>): Promise<string>;
+declare function isReactRenderer(renderer: Pick<FarmRenderer, "name"> | undefined): boolean;
+/** Absolute path of the renderer's app setup module, or null when the app has none. */
+declare function resolveFarmRendererAppSetup(root: string, renderer: Pick<FarmRenderer, "name" | "appSetup">): string | null;
+/** Resolve an optional renderer module from the application's dependency graph. */
+declare function resolveFarmRendererModule(root: string, specifier: string): string;
+declare function loadFarmRendererVitePlugins(renderer: FarmRenderer, root: string, options?: {
+    ssr?: boolean;
+    buildLifetime?: AbortSignal;
+}): Promise<unknown[]>;
+
+export { FARM_COMPONENT_EXTENSIONS, type FarmRenderer, type FarmRendererCapabilities, type FarmRendererCapabilitiesInput, type FarmRendererClientRoot, type FarmRendererClientRuntime, type FarmRendererRenderOptions, type FarmRendererRouteLayout, type FarmRendererRouteState, type FarmRendererRuntime, type FarmRendererStreamingCapabilities, type FarmRendererStreamingPrimitives, type FarmRendererViteModule, type FarmServerRendererRuntime, REACT_RENDERER, assertFarmRendererStreamingRuntime, defineRenderer, getFarmRendererCapabilities, getFarmRendererComponentExtensions, getFarmRendererStreamingCapabilitiesForRuntime, isReactRenderer, loadFarmRendererVitePlugins, readFarmRendererWebStream, resolveFarmComponentExtensions, resolveFarmRenderer, resolveFarmRendererAppSetup, resolveFarmRendererModule };