@farm.js/core 0.1.61 → 0.1.63

package/dist/app.d-DdWxeIGU.d.mts

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

package/dist/base-path.d-BOUV5ozD.d.mts

@@ -0,0 +1,10 @@
+/** @internal Configure the app-wide URL preference for framework link rendering. */
+declare function setFarmTrailingSlashPreference(enabled: boolean | undefined): void;
+declare function resolveFarmTrailingSlashRedirect(url: URL, enabled: boolean): string | null;
+
+/** @internal Configure the app-wide base path for framework link rendering. */
+declare function setFarmBasePath(basePath: string | undefined): void;
+declare function applyFarmBasePath(href: string, basePath?: string): string;
+declare function stripFarmBasePath(pathname: string, basePath?: string): string;
+
+export { setFarmTrailingSlashPreference as a, stripFarmBasePath as b, applyFarmBasePath as c, resolveFarmTrailingSlashRedirect as r, setFarmBasePath as s };

package/dist/base-path.d-BOUV5ozD.d.ts

@@ -0,0 +1,10 @@
+/** @internal Configure the app-wide URL preference for framework link rendering. */
+declare function setFarmTrailingSlashPreference(enabled: boolean | undefined): void;
+declare function resolveFarmTrailingSlashRedirect(url: URL, enabled: boolean): string | null;
+
+/** @internal Configure the app-wide base path for framework link rendering. */
+declare function setFarmBasePath(basePath: string | undefined): void;
+declare function applyFarmBasePath(href: string, basePath?: string): string;
+declare function stripFarmBasePath(pathname: string, basePath?: string): string;
+
+export { setFarmTrailingSlashPreference as a, stripFarmBasePath as b, applyFarmBasePath as c, resolveFarmTrailingSlashRedirect as r, setFarmBasePath as s };

package/dist/cache.cjs

@@ -15,18 +15,19 @@
 
 
 
-var _chunkYWN746UScjs = require('./chunk-YWN746US.cjs');
-require('./chunk-E3UK5IIB.cjs');
-require('./chunk-LIUGYUX3.cjs');
 
+var _chunkDMAP4RNDcjs = require('./chunk-DMAP4RND.cjs');
+require('./chunk-EVIWKPJV.cjs');
+require('./chunk-AOKXITZ6.cjs');
 
 
-var _chunkNYJMY3JAcjs = require('./chunk-NYJMY3JA.cjs');
 
+var _chunkDXUXQP2Tcjs = require('./chunk-DXUXQP2T.cjs');
 
-var _chunkZEG3OPIBcjs = require('./chunk-ZEG3OPIB.cjs');
-require('./chunk-S3JO3N4H.cjs');
 
+var _chunkUZCMMJJTcjs = require('./chunk-UZCMMJJT.cjs');
+require('./chunk-3BIASUGR.cjs');
+require('./chunk-BTZ5O6VM.cjs');
 
 
 
@@ -46,4 +47,6 @@ require('./chunk-S3JO3N4H.cjs');
 
 
 
-exports.FarmDataCache = _chunkYWN746UScjs.FarmDataCache; exports.applyFarmCacheInvalidationTargets = _chunkYWN746UScjs.applyFarmCacheInvalidationTargets; exports.applyFarmCacheInvalidations = _chunkZEG3OPIBcjs.applyFarmCacheInvalidations; exports.configureFarmCache = _chunkYWN746UScjs.configureFarmCache; exports.createFarmCacheInvalidationStream = _chunkYWN746UScjs.createFarmCacheInvalidationStream; exports.createFarmCacheKey = _chunkNYJMY3JAcjs.createFarmCacheKey; exports.createPathCacheTag = _chunkYWN746UScjs.createPathCacheTag; exports.createRouteDataCacheKey = _chunkNYJMY3JAcjs.createRouteDataCacheKey; exports.createRouteDataCacheTag = _chunkYWN746UScjs.createRouteDataCacheTag; exports.defineCacheKey = _chunkYWN746UScjs.defineCacheKey; exports.getFarmDataCache = _chunkYWN746UScjs.getFarmDataCache; exports.invalidate = _chunkYWN746UScjs.invalidate; exports.invalidateRouteData = _chunkYWN746UScjs.invalidateRouteData; exports.normalizeRevalidatePath = _chunkYWN746UScjs.normalizeRevalidatePath; exports.revalidatePath = _chunkYWN746UScjs.revalidatePath; exports.revalidateTag = _chunkYWN746UScjs.revalidateTag; exports.storageCacheAdapter = _chunkYWN746UScjs.storageCacheAdapter; exports.unstable_cache = _chunkYWN746UScjs.unstable_cache; exports.updateTag = _chunkYWN746UScjs.updateTag;
+
+
+exports.FarmDataCache = _chunkDMAP4RNDcjs.FarmDataCache; exports.PPR_SHELL_ADAPTER_TTL_SECONDS = _chunkDMAP4RNDcjs.PPR_SHELL_ADAPTER_TTL_SECONDS; exports.applyFarmCacheInvalidationTargets = _chunkDMAP4RNDcjs.applyFarmCacheInvalidationTargets; exports.applyFarmCacheInvalidations = _chunkUZCMMJJTcjs.applyFarmCacheInvalidations; exports.configureFarmCache = _chunkDMAP4RNDcjs.configureFarmCache; exports.createFarmCacheInvalidationStream = _chunkDMAP4RNDcjs.createFarmCacheInvalidationStream; exports.createFarmCacheKey = _chunkDXUXQP2Tcjs.createFarmCacheKey; exports.createPathCacheTag = _chunkDMAP4RNDcjs.createPathCacheTag; exports.createRouteDataCacheKey = _chunkDXUXQP2Tcjs.createRouteDataCacheKey; exports.createRouteDataCacheTag = _chunkDMAP4RNDcjs.createRouteDataCacheTag; exports.defineCacheKey = _chunkDMAP4RNDcjs.defineCacheKey; exports.getFarmDataCache = _chunkDMAP4RNDcjs.getFarmDataCache; exports.invalidate = _chunkDMAP4RNDcjs.invalidate; exports.invalidateRouteData = _chunkDMAP4RNDcjs.invalidateRouteData; exports.normalizeRevalidatePath = _chunkDMAP4RNDcjs.normalizeRevalidatePath; exports.revalidatePath = _chunkDMAP4RNDcjs.revalidatePath; exports.revalidateTag = _chunkDMAP4RNDcjs.revalidateTag; exports.storageCacheAdapter = _chunkDMAP4RNDcjs.storageCacheAdapter; exports.unstable_cache = _chunkDMAP4RNDcjs.unstable_cache; exports.updateTag = _chunkDMAP4RNDcjs.updateTag;