@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/renderer.d.mts

@@ -1,260 +0,0 @@
-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 };

package/dist/renderer.d.ts

@@ -1,260 +0,0 @@
-import { FarmPresetRuntime } from './deployment.js';
-
-/**
- * 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 };

package/dist/request.d-D01fRn--.d.ts

@@ -1,24 +0,0 @@
-import './client-plugins.d-n3iWY1EJ.js';
-
-/** @internal Run `fn` while rendering a response that carries `nonce`. */
-declare function _runWithFarmCspNonce<T>(nonce: string | undefined, fn: () => T): T;
-interface FarmRequestURLOptions {
-    origin?: string | URL;
-    trustProxy?: boolean;
-}
-/**
- * The public origin of a web `Request`, for the production runtime. The
- * adapter's `request.url` is authoritative unless `trustProxy` is on; then
- * `X-Forwarded-Host` and `X-Forwarded-Proto` override it with the same
- * validation `resolveFarmRequestURL` applies to a Node request in development.
- */
-declare function resolveFarmWebRequestOrigin(request: Request, options?: Pick<FarmRequestURLOptions, "trustProxy">): string;
-declare function _runWithCurrentRequest<T>(request: Request, fn: () => Promise<T> | T): Promise<T>;
-declare function getCurrentRequest(): Request;
-/**
- * @internal How many times app code has read `request` (default: the current
- * request). Compare two readings to learn whether a render read the request.
- */
-declare function _getRequestReadCount(request?: Request | undefined): number;
-
-export { _getRequestReadCount as _, _runWithCurrentRequest as a, _runWithFarmCspNonce as b, getCurrentRequest as g, resolveFarmWebRequestOrigin as r };

package/dist/request.d-Dd3AFR79.d.mts

@@ -1,24 +0,0 @@
-import './client-plugins.d-DllmH8eM.mjs';
-
-/** @internal Run `fn` while rendering a response that carries `nonce`. */
-declare function _runWithFarmCspNonce<T>(nonce: string | undefined, fn: () => T): T;
-interface FarmRequestURLOptions {
-    origin?: string | URL;
-    trustProxy?: boolean;
-}
-/**
- * The public origin of a web `Request`, for the production runtime. The
- * adapter's `request.url` is authoritative unless `trustProxy` is on; then
- * `X-Forwarded-Host` and `X-Forwarded-Proto` override it with the same
- * validation `resolveFarmRequestURL` applies to a Node request in development.
- */
-declare function resolveFarmWebRequestOrigin(request: Request, options?: Pick<FarmRequestURLOptions, "trustProxy">): string;
-declare function _runWithCurrentRequest<T>(request: Request, fn: () => Promise<T> | T): Promise<T>;
-declare function getCurrentRequest(): Request;
-/**
- * @internal How many times app code has read `request` (default: the current
- * request). Compare two readings to learn whether a render read the request.
- */
-declare function _getRequestReadCount(request?: Request | undefined): number;
-
-export { _getRequestReadCount as _, _runWithCurrentRequest as a, _runWithFarmCspNonce as b, getCurrentRequest as g, resolveFarmWebRequestOrigin as r };

package/dist/request.d.mts

@@ -1,34 +0,0 @@
-export { g as getCurrentRequest } from './request.d-Dd3AFR79.mjs';
-import './client-plugins.d-DllmH8eM.mjs';
-import './lifecycle.d-C2aLBOwu.mjs';
-import './route.d-BaVH3V0w.mjs';
-import './endpoint.d-BkMSCRf6.mjs';
-import './cache.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 './observability.d-B2363jB6.mjs';
-import '@opentelemetry/api';
-import 'vite';
-import './workflows.d-CRMzQZ3k.mjs';
-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 './types.d-C41ePjvP.mjs';
-import './config.d-DqKaCr1r.mjs';
-import './types.d-DQnyD3VD.mjs';
-import './font.mjs';

package/dist/request.d.ts

@@ -1,34 +0,0 @@
-export { g as getCurrentRequest } from './request.d-D01fRn--.js';
-import './client-plugins.d-n3iWY1EJ.js';
-import './lifecycle.d-C2aLBOwu.js';
-import './route.d-DBTEqifW.js';
-import './endpoint.d-BgHn0lhl.js';
-import './cache.js';
-import './renderer.js';
-import './deployment.js';
-import 'http';
-import './server-fn.js';
-import './server-fn-error.d-DrcH9cc1.js';
-import './server-query.js';
-import './types.d-BnIqOn9w.js';
-import 'db0';
-import 'unstorage';
-import './schema.js';
-import 'react';
-import '@farming-labs/orm';
-import '@farming-labs/docs';
-import './observability.d-B2363jB6.js';
-import '@opentelemetry/api';
-import 'vite';
-import './workflows.d-CRMzQZ3k.js';
-import './cron.js';
-import './env.js';
-import './server-action-security.js';
-import './layers.d-CcS42OGR.js';
-import 'rolldown/utils';
-import 'rolldown';
-import './image-config.d-CeDgNyX4.js';
-import './types.d-C41ePjvP.js';
-import './config.d-DqKaCr1r.js';
-import './types.d-DQnyD3VD.js';
-import './font.js';

package/dist/resolver.d-BHyZgpa7.d.ts

@@ -1,14 +0,0 @@
-import { b as FarmI18nLocaleSource, R as ResolvedFarmI18nConfig } from './types.d-C41ePjvP.js';
-
-interface FarmLocaleResolution {
-    locale: string;
-    source: FarmI18nLocaleSource;
-    pathname: string;
-    redirect?: string;
-    persist: boolean;
-}
-declare function getFarmLocaleVaryHeaders(config: ResolvedFarmI18nConfig, resolution: FarmLocaleResolution): string[];
-declare function createFarmLocaleCookie(locale: string, config: Pick<ResolvedFarmI18nConfig, "cookie">): string;
-declare function matchFarmLocale(requested: string | null | undefined, locales: readonly string[]): string | undefined;
-
-export { type FarmLocaleResolution as F, createFarmLocaleCookie as c, getFarmLocaleVaryHeaders as g, matchFarmLocale as m };