@farm.js/core 0.1.60 → 0.1.61

package/dist/renderer-client.d.ts

@@ -1,126 +0,0 @@
-import { FarmRouterRouteInput } from './router.js';
-import { a as FarmNavigationState, b as FarmNavigateOptions } from './spa-router.d-DAtnNoBe.js';
-import { F as FarmClientCacheStatus } from './client-cache.d-Deoqq-nM.js';
-import { ServerFn } from './server-fn.js';
-import { ServerQuery } from './server-query.js';
-import { S as ServerQueryFetchOptions } from './server-query-runtime.d-DXRNhX_3.js';
-import { F as FarmThemeSnapshot, a as FarmThemePreference } from './types.d-DQnyD3VD.js';
-import { a as FarmI18nClientSnapshot, d as FarmTranslator, c as FarmI18nLocale } from './types.d-C41ePjvP.js';
-export { F as FarmNavigationDelegate, a as FarmNavigationDelegateContext, d as delegateNavigation } from './navigation-delegate.d-JXx40JzR.js';
-import './client-plugins.d-vXrbcfJ1.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 './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 './server-fn-error.d-DrcH9cc1.js';
-import './layers.d-CcS42OGR.js';
-import 'rolldown/utils';
-import 'rolldown';
-import './image-config.d-CeDgNyX4.js';
-import './config.d-DqZkLwef.js';
-import './font.js';
-import './island.d-CfGru1MO.js';
-import './render-plan.d-B9lAP3uX.js';
-
-interface FarmClientStore<TSnapshot> {
-    getSnapshot(): TSnapshot;
-    subscribe(listener: () => void): () => void;
-}
-interface FarmRendererRouterOptions {
-    basePath?: string;
-    routes?: readonly FarmRouterRouteInput[];
-}
-interface FarmRendererRouterSnapshot {
-    pathname: string;
-    searchParams: URLSearchParams;
-    params: Record<string, string>;
-    pageState: unknown;
-    navigation: FarmNavigationState;
-}
-interface FarmRendererRouter extends FarmClientStore<FarmRendererRouterSnapshot> {
-    push(href: string, options?: Omit<FarmNavigateOptions, "replace">): Promise<void>;
-    replace(href: string, options?: Omit<FarmNavigateOptions, "replace">): Promise<void>;
-    refresh(options?: Omit<FarmNavigateOptions, "replace" | "refresh">): Promise<void>;
-    prefetch(href: string): Promise<void>;
-    back(): void;
-    forward(): void;
-    pushState<TState>(state: TState, href?: string): void;
-    replaceState<TState>(state: TState, href?: string): void;
-}
-declare function createRendererRouter(options?: FarmRendererRouterOptions): FarmRendererRouter;
-type FarmActionStatus = "idle" | "pending" | "success" | "error";
-interface FarmActionSnapshot<TResult, TError extends Error = Error> {
-    pending: boolean;
-    status: FarmActionStatus;
-    data: TResult | null;
-    error: TError | null;
-}
-interface FarmActionOptions<TInput, TResult, TError extends Error = Error> {
-    initialResult?: TResult | null;
-    resetOnSubmit?: boolean;
-    optimistic?: (context: {
-        input: TInput | FormData | undefined;
-        formData?: FormData;
-        current: TResult | null;
-    }) => TResult | null | undefined;
-    rollbackOnError?: boolean;
-    onSuccess?: (result: TResult) => void;
-    onError?: (error: TError) => void;
-    onSettled?: (result: TResult | null, error: TError | null) => void;
-}
-type FarmActionSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;
-type FarmAction<TInput, TResult, TError extends Error = Error> = FarmClientStore<FarmActionSnapshot<TResult, TError>> & {
-    submit: FarmActionSubmit<TInput, TResult>;
-    reset(): void;
-};
-type FarmRouteActionTarget<TServerFn extends ServerFn<any, any, any>> = {
-    readonly action: TServerFn;
-};
-declare function createRendererAction<TInput, TResult, TError extends Error = Error>(target: ServerFn<TInput, TResult, TError> | FarmRouteActionTarget<ServerFn<TInput, TResult, TError>>, options?: FarmActionOptions<TInput, TResult, TError>): FarmAction<TInput, TResult, TError>;
-interface FarmRendererQueryOptions extends ServerQueryFetchOptions {
-    enabled?: boolean;
-    refetchOnWindowFocus?: boolean;
-    refetchOnReconnect?: boolean;
-}
-interface FarmRendererQuerySnapshot<TData> {
-    data: TData | undefined;
-    error: Error | null;
-    status: FarmClientCacheStatus;
-    pending: boolean;
-    fetching: boolean;
-    stale: boolean;
-}
-interface FarmRendererQuery<TData> extends FarmClientStore<FarmRendererQuerySnapshot<TData>> {
-    refetch(): Promise<TData>;
-    dispose(): void;
-}
-declare function createRendererQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: FarmRendererQueryOptions): FarmRendererQuery<TData>;
-interface FarmRendererTheme extends FarmClientStore<FarmThemeSnapshot> {
-    setTheme(theme: FarmThemePreference): void;
-    toggleTheme(): FarmThemeSnapshot["resolvedTheme"];
-}
-declare function createRendererTheme(): FarmRendererTheme;
-interface FarmRendererI18n extends FarmClientStore<FarmI18nClientSnapshot | undefined> {
-    readonly t: FarmTranslator;
-    setLocale(locale: FarmI18nLocale): void;
-}
-declare function createRendererI18n(): FarmRendererI18n;
-
-export { type FarmAction, type FarmActionOptions, type FarmActionSnapshot, type FarmActionStatus, type FarmActionSubmit, type FarmClientStore, FarmI18nClientSnapshot, FarmI18nLocale, type FarmRendererI18n, type FarmRendererQuery, type FarmRendererQueryOptions, type FarmRendererQuerySnapshot, type FarmRendererRouter, type FarmRendererRouterOptions, type FarmRendererRouterSnapshot, type FarmRendererTheme, type FarmRouteActionTarget, FarmTranslator, createRendererAction, createRendererI18n, createRendererQuery, createRendererRouter, createRendererTheme };

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-BiicaNxb.d.ts

@@ -1,24 +0,0 @@
-import './client-plugins.d-vXrbcfJ1.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 };