@farm.js/core 0.1.61 → 0.1.62

package/dist/renderer.d.ts

@@ -0,0 +1,260 @@
+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/renderer.mjs

@@ -13,8 +13,8 @@ import {
   resolveFarmRenderer,
   resolveFarmRendererAppSetup,
   resolveFarmRendererModule
-} from "./chunk-DAATZTKJ.mjs";
-import "./chunk-LPEX4YW6.mjs";
+} from "./chunk-ES2LD2YD.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 export {
   FARM_COMPONENT_EXTENSIONS,
   REACT_RENDERER,

package/dist/request.cjs

@@ -1,8 +1,8 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkUXFQ3UDAcjs = require('./chunk-UXFQ3UDA.cjs');
-require('./chunk-U4KT7QP3.cjs');
-require('./chunk-S3JO3N4H.cjs');
+var _chunkHNAISJFDcjs = require('./chunk-HNAISJFD.cjs');
+require('./chunk-3BIASUGR.cjs');
+require('./chunk-BTZ5O6VM.cjs');
 
 
-exports.getCurrentRequest = _chunkUXFQ3UDAcjs.getCurrentRequest;
+exports.getCurrentRequest = _chunkHNAISJFDcjs.getCurrentRequest;

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

@@ -0,0 +1,24 @@
+import './client-plugins.d-BcqIy4au.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-CUrPnCW7.d.mts

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

@@ -0,0 +1,34 @@
+export { g as getCurrentRequest } from './request.d-CUrPnCW7.mjs';
+import './client-plugins.d-CWyYBxXf.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-qt-mE8O5.mjs';
+import './types.d-DQnyD3VD.mjs';
+import './font.mjs';

package/dist/request.d.ts

@@ -0,0 +1,34 @@
+export { g as getCurrentRequest } from './request.d-BB8M8bcD.js';
+import './client-plugins.d-BcqIy4au.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-qt-mE8O5.js';
+import './types.d-DQnyD3VD.js';
+import './font.js';

package/dist/request.mjs

@@ -1,8 +1,8 @@
 import {
   getCurrentRequest
-} from "./chunk-FDR64H6B.mjs";
-import "./chunk-IZY3V5XW.mjs";
-import "./chunk-LPEX4YW6.mjs";
+} from "./chunk-6HRAK7I5.mjs";
+import "./chunk-VIXTAVEA.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 export {
   getCurrentRequest
 };

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

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

package/dist/resolver.d-JnZKKsc5.d.mts

@@ -0,0 +1,14 @@
+import { b as FarmI18nLocaleSource, R as ResolvedFarmI18nConfig } from './types.d-C41ePjvP.mjs';
+
+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 };

package/dist/response.d-BolW0Vx_.d.mts

@@ -0,0 +1,10 @@
+import { ServerResponse } from 'node:http';
+
+declare function sendWebResponse(res: ServerResponse, response: Response): Promise<void>;
+/**
+ * Forward a config rewrite to another origin. `fetch()` decodes a compressed body but keeps the
+ * upstream's `Content-Encoding` and `Content-Length`, which then describe bytes the client never gets.
+ */
+declare function fetchFarmExternalRewrite(request: Request): Promise<Response>;
+
+export { fetchFarmExternalRewrite as f, sendWebResponse as s };

package/dist/response.d-BolW0Vx_.d.ts

@@ -0,0 +1,10 @@
+import { ServerResponse } from 'node:http';
+
+declare function sendWebResponse(res: ServerResponse, response: Response): Promise<void>;
+/**
+ * Forward a config rewrite to another origin. `fetch()` decodes a compressed body but keeps the
+ * upstream's `Content-Encoding` and `Content-Length`, which then describe bytes the client never gets.
+ */
+declare function fetchFarmExternalRewrite(request: Request): Promise<Response>;
+
+export { fetchFarmExternalRewrite as f, sendWebResponse as s };

package/dist/route-pattern.d-CVsVbq5n.d.mts

@@ -0,0 +1,13 @@
+type APIRouteParamValue = string | string[];
+type APIRouteParams = Record<string, APIRouteParamValue>;
+interface APIRouteMatch<T extends {
+    path: string;
+}> {
+    route: T;
+    params: APIRouteParams;
+}
+declare function matchAPIRoute<T extends {
+    path: string;
+}>(routes: Map<string, T>, pathname: string): APIRouteMatch<T> | null;
+
+export { type APIRouteMatch as A, type APIRouteParamValue as a, type APIRouteParams as b, matchAPIRoute as m };

package/dist/route-pattern.d-CVsVbq5n.d.ts

@@ -0,0 +1,13 @@
+type APIRouteParamValue = string | string[];
+type APIRouteParams = Record<string, APIRouteParamValue>;
+interface APIRouteMatch<T extends {
+    path: string;
+}> {
+    route: T;
+    params: APIRouteParams;
+}
+declare function matchAPIRoute<T extends {
+    path: string;
+}>(routes: Map<string, T>, pathname: string): APIRouteMatch<T> | null;
+
+export { type APIRouteMatch as A, type APIRouteParamValue as a, type APIRouteParams as b, matchAPIRoute as m };

package/dist/route-rendering.d-CYxlzaFm.d.mts

@@ -0,0 +1,44 @@
+import { i as RouteModule } from './client-plugins.d-CWyYBxXf.mjs';
+
+/**
+ * The rendering-mode merge shared by every consumer of route directives.
+ *
+ * Development resolves `"use ssg; 60"` and friends by reading the route
+ * source; production output cannot read files, so the build bakes the parsed
+ * directive into each route registration and the generated server entry
+ * merges it here with the module's exports - the same precedence, one
+ * implementation, no filesystem dependency so edge presets stay clean.
+ */
+type RouteRenderingDynamic = NonNullable<RouteModule["dynamic"]>;
+interface RouteRenderingConfig {
+    ssg: boolean;
+    ppr: boolean;
+    revalidate?: number;
+    dynamic?: RouteRenderingDynamic;
+    directive?: string;
+}
+interface RouteRenderingOptions {
+    /**
+     * Whether `experimental.ppr` is enabled in the app config. Route-level PPR
+     * opt-ins (`ppr`, `experimental_ppr`, `"use ppr"`) are inert without it.
+     */
+    experimentalPPR?: boolean;
+}
+interface DirectiveRenderingConfig {
+    ssg: boolean;
+    ppr: boolean;
+    revalidate?: number;
+    dynamic?: RouteRenderingDynamic;
+    directive: string;
+    /**
+     * The route's source reads request state (headers, cookies, search params),
+     * so its HTML is per request and must never enter a shared artifact or a
+     * shared cache. Determined from source at build time, because the runtime
+     * only ever sees module exports.
+     */
+    requestBound?: boolean;
+}
+/** Merge a parsed rendering directive with a route module's explicit exports. */
+declare function mergeRouteRenderingDirectiveConfig(directiveConfig: DirectiveRenderingConfig | undefined, mod: RouteModule | null | undefined, options?: RouteRenderingOptions): RouteRenderingConfig;
+
+export { type DirectiveRenderingConfig as D, type RouteRenderingOptions as R, type RouteRenderingConfig as a, type RouteRenderingDynamic as b, mergeRouteRenderingDirectiveConfig as m };

package/dist/route-rendering.d-DYqZMIf4.d.ts

@@ -0,0 +1,44 @@
+import { i as RouteModule } from './client-plugins.d-BcqIy4au.js';
+
+/**
+ * The rendering-mode merge shared by every consumer of route directives.
+ *
+ * Development resolves `"use ssg; 60"` and friends by reading the route
+ * source; production output cannot read files, so the build bakes the parsed
+ * directive into each route registration and the generated server entry
+ * merges it here with the module's exports - the same precedence, one
+ * implementation, no filesystem dependency so edge presets stay clean.
+ */
+type RouteRenderingDynamic = NonNullable<RouteModule["dynamic"]>;
+interface RouteRenderingConfig {
+    ssg: boolean;
+    ppr: boolean;
+    revalidate?: number;
+    dynamic?: RouteRenderingDynamic;
+    directive?: string;
+}
+interface RouteRenderingOptions {
+    /**
+     * Whether `experimental.ppr` is enabled in the app config. Route-level PPR
+     * opt-ins (`ppr`, `experimental_ppr`, `"use ppr"`) are inert without it.
+     */
+    experimentalPPR?: boolean;
+}
+interface DirectiveRenderingConfig {
+    ssg: boolean;
+    ppr: boolean;
+    revalidate?: number;
+    dynamic?: RouteRenderingDynamic;
+    directive: string;
+    /**
+     * The route's source reads request state (headers, cookies, search params),
+     * so its HTML is per request and must never enter a shared artifact or a
+     * shared cache. Determined from source at build time, because the runtime
+     * only ever sees module exports.
+     */
+    requestBound?: boolean;
+}
+/** Merge a parsed rendering directive with a route module's explicit exports. */
+declare function mergeRouteRenderingDirectiveConfig(directiveConfig: DirectiveRenderingConfig | undefined, mod: RouteModule | null | undefined, options?: RouteRenderingOptions): RouteRenderingConfig;
+
+export { type DirectiveRenderingConfig as D, type RouteRenderingOptions as R, type RouteRenderingConfig as a, type RouteRenderingDynamic as b, mergeRouteRenderingDirectiveConfig as m };