@farm.js/core 0.1.61 → 0.1.62

package/dist/client-cache.d-Deoqq-nM.d.ts

@@ -0,0 +1,76 @@
+import { RouteDataCacheKey } from './cache.js';
+
+type FarmClientCacheKey = RouteDataCacheKey;
+type FarmClientCacheStatus = "idle" | "pending" | "success" | "error";
+type FarmClientCacheEntry<TData = unknown> = {
+    data: TData;
+    updatedAt: number;
+    staleAt: number;
+    gcAt?: number;
+    invalidatedAt?: number;
+    status?: FarmClientCacheStatus;
+    error?: Error | null;
+    fetching?: boolean;
+    /** Marks an entry the persistence layer may write to its adapter. */
+    persist?: boolean;
+};
+/** @internal Observation seam for the client cache persistence engine. */
+type FarmClientCachePersistenceSink = {
+    onSet(key: string, entry: FarmClientCacheEntry): void;
+    onDelete(key: string): void;
+    onClear(): void;
+};
+type FarmClientCacheListener = (event?: "invalidate") => void;
+declare class FarmClientDataCache {
+    private entries;
+    private aliases;
+    private aliasesByTarget;
+    private invalidatedAt;
+    private listeners;
+    private inflight;
+    private pendingMetadataSweeps;
+    private unsubscribeInvalidation;
+    private gcTimer;
+    private readonly gcSweepIntervalMs;
+    private persistence;
+    constructor(options?: {
+        subscribeToInvalidation?: boolean;
+        gcSweepIntervalMs?: number | false;
+    });
+    private static subscribeWeakCache;
+    get size(): number;
+    /** @internal Attach or detach the persistence engine's observation sink. */
+    attachPersistence(sink: FarmClientCachePersistenceSink | undefined): void;
+    resolveKey(key: string): string;
+    get<TData = unknown>(key: string, now?: number): FarmClientCacheEntry<TData> | undefined;
+    set<TData>(key: string, entry: FarmClientCacheEntry<TData>): this;
+    delete(key: string): boolean;
+    clear(): void;
+    dispose(): void;
+    isStale(key: string, now?: number): boolean;
+    invalidate(key: string, now?: number): void;
+    private applyInvalidation;
+    private hasMetadataOwner;
+    alias(alias: string, key: string): void;
+    subscribe(key: string, listener: FarmClientCacheListener): () => void;
+    getInflight<TData>(key: string): Promise<TData> | undefined;
+    setInflight<TData>(key: string, promise: Promise<TData>): void;
+    deleteInflight(key: string): void;
+    private scheduleGcSweep;
+    private sweepExpiredEntries;
+    /**
+     * Entry eviction alone leaves the per-key metadata behind. `invalidatedAt`
+     * marks and provisional aliases are created per query invocation, so with
+     * dynamic keys they accumulate for the lifetime of the page even though the
+     * entries they describe are long gone.
+     */
+    private sweepEntryMetadata;
+    private removeAlias;
+    private sweepPendingEntryMetadata;
+    private emit;
+    private notifyListeners;
+}
+declare function getFarmClientDataCache(): FarmClientDataCache;
+declare function normalizeFarmClientCacheKey(key: FarmClientCacheKey): string;
+
+export { type FarmClientCacheStatus as F, type FarmClientCacheEntry as a, type FarmClientCacheKey as b, getFarmClientDataCache as g, normalizeFarmClientCacheKey as n };

package/dist/client-cache.d-di_Nasxa.d.mts

@@ -0,0 +1,76 @@
+import { RouteDataCacheKey } from './cache.mjs';
+
+type FarmClientCacheKey = RouteDataCacheKey;
+type FarmClientCacheStatus = "idle" | "pending" | "success" | "error";
+type FarmClientCacheEntry<TData = unknown> = {
+    data: TData;
+    updatedAt: number;
+    staleAt: number;
+    gcAt?: number;
+    invalidatedAt?: number;
+    status?: FarmClientCacheStatus;
+    error?: Error | null;
+    fetching?: boolean;
+    /** Marks an entry the persistence layer may write to its adapter. */
+    persist?: boolean;
+};
+/** @internal Observation seam for the client cache persistence engine. */
+type FarmClientCachePersistenceSink = {
+    onSet(key: string, entry: FarmClientCacheEntry): void;
+    onDelete(key: string): void;
+    onClear(): void;
+};
+type FarmClientCacheListener = (event?: "invalidate") => void;
+declare class FarmClientDataCache {
+    private entries;
+    private aliases;
+    private aliasesByTarget;
+    private invalidatedAt;
+    private listeners;
+    private inflight;
+    private pendingMetadataSweeps;
+    private unsubscribeInvalidation;
+    private gcTimer;
+    private readonly gcSweepIntervalMs;
+    private persistence;
+    constructor(options?: {
+        subscribeToInvalidation?: boolean;
+        gcSweepIntervalMs?: number | false;
+    });
+    private static subscribeWeakCache;
+    get size(): number;
+    /** @internal Attach or detach the persistence engine's observation sink. */
+    attachPersistence(sink: FarmClientCachePersistenceSink | undefined): void;
+    resolveKey(key: string): string;
+    get<TData = unknown>(key: string, now?: number): FarmClientCacheEntry<TData> | undefined;
+    set<TData>(key: string, entry: FarmClientCacheEntry<TData>): this;
+    delete(key: string): boolean;
+    clear(): void;
+    dispose(): void;
+    isStale(key: string, now?: number): boolean;
+    invalidate(key: string, now?: number): void;
+    private applyInvalidation;
+    private hasMetadataOwner;
+    alias(alias: string, key: string): void;
+    subscribe(key: string, listener: FarmClientCacheListener): () => void;
+    getInflight<TData>(key: string): Promise<TData> | undefined;
+    setInflight<TData>(key: string, promise: Promise<TData>): void;
+    deleteInflight(key: string): void;
+    private scheduleGcSweep;
+    private sweepExpiredEntries;
+    /**
+     * Entry eviction alone leaves the per-key metadata behind. `invalidatedAt`
+     * marks and provisional aliases are created per query invocation, so with
+     * dynamic keys they accumulate for the lifetime of the page even though the
+     * entries they describe are long gone.
+     */
+    private sweepEntryMetadata;
+    private removeAlias;
+    private sweepPendingEntryMetadata;
+    private emit;
+    private notifyListeners;
+}
+declare function getFarmClientDataCache(): FarmClientDataCache;
+declare function normalizeFarmClientCacheKey(key: FarmClientCacheKey): string;
+
+export { type FarmClientCacheStatus as F, type FarmClientCacheEntry as a, type FarmClientCacheKey as b, getFarmClientDataCache as g, normalizeFarmClientCacheKey as n };

package/dist/client-component.d-Bgt3x5Fu.d.ts

@@ -0,0 +1,207 @@
+import { R as RouteRenderingOptions, D as DirectiveRenderingConfig, a as RouteRenderingConfig } from './route-rendering.d-DYqZMIf4.js';
+import { i as RouteModule, b6 as SSGCollectionResult, b7 as SSGPage } from './client-plugins.d-BcqIy4au.js';
+import { F as FarmIslandStrategy } from './island.d-CfGru1MO.js';
+
+/**
+ * Farm.js SSG (Static Site Generation) Module
+ *
+ * Handles collection and pre-rendering of SSG pages at build time.
+ *
+ * SSR is the default - pages render on each request
+ * SSG is opt-in via `export const ssg = true`, Next-compatible route
+ * config exports, or a top-of-file rendering directive.
+ *
+ * @example
+ * ```tsx
+ * // SSG Page
+ * export const ssg = true;
+ * export default function AboutPage() {
+ *   return <h1>About</h1>;
+ * }
+ *
+ * // SSG with ISR
+ * export const ssg = true;
+ * export const revalidate = 60;
+ * export default async function ProductsPage() {
+ *   const products = await fetchProducts();
+ *   return <ProductList products={products} />;
+ * }
+ *
+ * // Dynamic SSG
+ * export const ssg = true;
+ * export async function getStaticPaths() {
+ *   const posts = await fetchPosts();
+ *   return posts.map(post => ({ slug: post.slug }));
+ * }
+ * export default async function BlogPost({ params }) {
+ *   return <article>{params.slug}</article>;
+ * }
+ *
+ * // Next-compatible route config
+ * export const dynamic = "force-static";
+ * export const revalidate = 60;
+ *
+ * // PPR/static-shell route
+ * export const experimental_ppr = true;
+ * export const revalidate = 60;
+ *
+ * // Directive config
+ * "use ssg; 60";
+ * export default function DocsPage() {
+ *   return <h1>Docs</h1>;
+ * }
+ * ```
+ */
+
+interface RouteEntry {
+    path: string;
+    filePath: string;
+    isDynamic: boolean;
+    pattern: string;
+}
+
+interface StaticRouteCandidateAnalysis {
+    candidate: boolean;
+    blockers: string[];
+}
+/**
+ * Resolve the effective rendering mode. Direct request reads make an explicitly
+ * static route dynamic so request-specific HTML cannot enter a shared artifact.
+ */
+declare function resolveRouteRenderingConfig(mod: RouteModule | null | undefined, source?: string, options?: RouteRenderingOptions): RouteRenderingConfig;
+declare function resolveRouteRenderingConfigFromFile(mod: RouteModule | null | undefined, filePath: string, options?: RouteRenderingOptions): Promise<RouteRenderingConfig>;
+/**
+ * Conservatively identify a route that may be safe to pre-render.
+ *
+ * This intentionally produces a suggestion rather than changing rendering:
+ * request-bound work can live in a transitive import, which source inspection
+ * of the route module cannot prove safe. Explicit route config always wins.
+ */
+declare function analyzeStaticRouteCandidate(mod: RouteModule | null | undefined, source: string | undefined, options?: {
+    isDynamic?: boolean;
+}): StaticRouteCandidateAnalysis;
+declare function findRequestBoundSourceBlockers(source: string): string[];
+declare function parseRouteRenderingDirective(source: string | undefined): DirectiveRenderingConfig | undefined;
+/**
+ * A route's rendering directive as the production runtime needs it: the parsed directive plus
+ * whether its source reads request state. The runtime only sees module exports, so the build
+ * decides `requestBound` here and bakes it into the generated server entry, where
+ * `mergeRouteRenderingDirectiveConfig` combines it with the module's exports.
+ */
+declare function readRouteRenderingDirectiveFromFile(modulePath: string): DirectiveRenderingConfig | undefined;
+/**
+ * Collect SSG pages from route modules
+ *
+ * Scans all routes and categorizes them into:
+ * - SSG pages: Pre-rendered at build time
+ * - SSR routes: Rendered on each request
+ *
+ * @param routes - Array of route entries
+ * @param loadModule - Function to load a route module
+ * @returns SSG pages and SSR routes
+ */
+declare function collectSSGPages(routes: RouteEntry[], loadModule: (filePath: string) => Promise<RouteModule>, options?: {
+    suggestStaticRendering?: boolean;
+    /**
+     * Routes a docs adapter renders, which ignore route config: a static candidate among them
+     * is pointed at `docs.prerender` instead of `force-static`, or not at all once it is set.
+     */
+    docsAdapterRoutes?: {
+        owns: (routePath: string) => boolean;
+        prerender: boolean;
+    };
+}): Promise<SSGCollectionResult>;
+/**
+ * Check if a route module is SSG
+ */
+declare function isSSGModule(mod: RouteModule | null | undefined): boolean;
+/**
+ * Check if a route module has ISR (Incremental Static Regeneration)
+ */
+declare function hasISR(mod: RouteModule | null | undefined): boolean;
+/**
+ * Get revalidation interval for a module
+ */
+declare function getRevalidateInterval(mod: RouteModule | null | undefined): number | undefined;
+/**
+ * Check if a route module has PPR/static-shell caching enabled.
+ */
+declare function hasPPR(mod: RouteModule | null | undefined, options?: RouteRenderingOptions): boolean;
+/**
+ * Generate SSG manifest for production builds
+ */
+declare function generateSSGManifest(pages: SSGPage[]): string;
+/**
+ * Check if a URL path matches an SSG page
+ */
+declare function matchSSGPage(urlPath: string, ssgPages: SSGPage[]): SSGPage | undefined;
+
+/**
+ * The browser copy of a programmatic page or layout imports only the module that defines its
+ * component, never the routes file. Guards, data hooks, static paths, generated metadata, API
+ * handlers, and whatever the routes file imports for them stay out of the client graph because
+ * the client graph never reaches the routes file.
+ *
+ * Farm already evaluates the routes file on the server to build its route table. That
+ * evaluation also tells it where each component lives: the server module graph holds every
+ * module the routes file reached, with its exports, so the module that exports the very
+ * function (or object) a route uses as its `component` is that component's own module. This
+ * works for any way the route list is built (helpers, re-exported lists, assignments, aliases)
+ * because it reads the evaluated value instead of the routes file's syntax. A component that no
+ * other module exports (declared in the routes file, or computed there) has no module to
+ * import, so a client build that needs it fails with an actionable error.
+ *
+ * A module that holds route definitions is never a component's client import, however it holds
+ * them: Farm finds definitions in every evaluated module's exports (inside objects, arrays,
+ * maps, and sets), and route factories record the module that called them while routes are
+ * evaluated, which also finds definitions kept behind a function. A definition written as an
+ * object literal and kept out of every export can't be traced, so then a component module is
+ * accepted only when neither it nor anything it imports holds route-defining code.
+ */
+type ProgrammaticClientRouteKind = "page" | "layout";
+interface ProgrammaticClientModuleExport {
+    /** Absolute path of the module that exports the value. */
+    file: string;
+    /** The export name that holds it. */
+    exportName: string;
+}
+interface ProgrammaticClientRoute {
+    kind: ProgrammaticClientRouteKind;
+    path: string;
+    /** Absolute path of the routes file that defines the route. */
+    routesFile: string;
+    component?: ProgrammaticClientModuleExport;
+    pending?: ProgrammaticClientModuleExport;
+    /**
+     * The route options the server resolves into the page's props (params, search, guard, data).
+     * The browser copy renders only from props the server resolved.
+     */
+    serverProps?: string[];
+    /** Why the browser copy can't be generated, when it can't. */
+    problem?: string;
+}
+interface ProgrammaticClientRoutes {
+    /** Keyed by {@link programmaticClientRouteKey}. */
+    routes: ReadonlyMap<string, ProgrammaticClientRoute>;
+    /**
+     * Routes files and the modules that export route definitions. None of them may enter the
+     * client graph.
+     */
+    routeSourceFiles: ReadonlySet<string>;
+}
+
+interface IsolatedClientBoundaryReference {
+    /** Absolute source path. Converted to a Vite URL only at the manifest edge. */
+    modulePath: string;
+    islandStrategy: FarmIslandStrategy;
+}
+/**
+ * Packages the browser loads only once a page renders, so Vite's optimizer finds them late,
+ * optimizes again and can leave two copies of React on the page. Under `directory`: every bare
+ * import of a `"use client"` module, and every package a server module imports that is a client
+ * boundary (`"use client"`). Imports a server module makes of anything else stay out: they may
+ * not run in a browser.
+ */
+declare function collectFarmClientPackageImports(directory: string, root: string): string[];
+
+export { type IsolatedClientBoundaryReference as I, type ProgrammaticClientRoutes as P, type StaticRouteCandidateAnalysis as S, analyzeStaticRouteCandidate as a, collectSSGPages as b, collectFarmClientPackageImports as c, getRevalidateInterval as d, hasPPR as e, findRequestBoundSourceBlockers as f, generateSSGManifest as g, hasISR as h, isSSGModule as i, resolveRouteRenderingConfig as j, resolveRouteRenderingConfigFromFile as k, matchSSGPage as m, parseRouteRenderingDirective as p, readRouteRenderingDirectiveFromFile as r };

package/dist/client-component.d-BoqC2MLC.d.mts

@@ -0,0 +1,207 @@
+import { R as RouteRenderingOptions, D as DirectiveRenderingConfig, a as RouteRenderingConfig } from './route-rendering.d-CYxlzaFm.mjs';
+import { i as RouteModule, b6 as SSGCollectionResult, b7 as SSGPage } from './client-plugins.d-CWyYBxXf.mjs';
+import { F as FarmIslandStrategy } from './island.d-CfGru1MO.mjs';
+
+/**
+ * Farm.js SSG (Static Site Generation) Module
+ *
+ * Handles collection and pre-rendering of SSG pages at build time.
+ *
+ * SSR is the default - pages render on each request
+ * SSG is opt-in via `export const ssg = true`, Next-compatible route
+ * config exports, or a top-of-file rendering directive.
+ *
+ * @example
+ * ```tsx
+ * // SSG Page
+ * export const ssg = true;
+ * export default function AboutPage() {
+ *   return <h1>About</h1>;
+ * }
+ *
+ * // SSG with ISR
+ * export const ssg = true;
+ * export const revalidate = 60;
+ * export default async function ProductsPage() {
+ *   const products = await fetchProducts();
+ *   return <ProductList products={products} />;
+ * }
+ *
+ * // Dynamic SSG
+ * export const ssg = true;
+ * export async function getStaticPaths() {
+ *   const posts = await fetchPosts();
+ *   return posts.map(post => ({ slug: post.slug }));
+ * }
+ * export default async function BlogPost({ params }) {
+ *   return <article>{params.slug}</article>;
+ * }
+ *
+ * // Next-compatible route config
+ * export const dynamic = "force-static";
+ * export const revalidate = 60;
+ *
+ * // PPR/static-shell route
+ * export const experimental_ppr = true;
+ * export const revalidate = 60;
+ *
+ * // Directive config
+ * "use ssg; 60";
+ * export default function DocsPage() {
+ *   return <h1>Docs</h1>;
+ * }
+ * ```
+ */
+
+interface RouteEntry {
+    path: string;
+    filePath: string;
+    isDynamic: boolean;
+    pattern: string;
+}
+
+interface StaticRouteCandidateAnalysis {
+    candidate: boolean;
+    blockers: string[];
+}
+/**
+ * Resolve the effective rendering mode. Direct request reads make an explicitly
+ * static route dynamic so request-specific HTML cannot enter a shared artifact.
+ */
+declare function resolveRouteRenderingConfig(mod: RouteModule | null | undefined, source?: string, options?: RouteRenderingOptions): RouteRenderingConfig;
+declare function resolveRouteRenderingConfigFromFile(mod: RouteModule | null | undefined, filePath: string, options?: RouteRenderingOptions): Promise<RouteRenderingConfig>;
+/**
+ * Conservatively identify a route that may be safe to pre-render.
+ *
+ * This intentionally produces a suggestion rather than changing rendering:
+ * request-bound work can live in a transitive import, which source inspection
+ * of the route module cannot prove safe. Explicit route config always wins.
+ */
+declare function analyzeStaticRouteCandidate(mod: RouteModule | null | undefined, source: string | undefined, options?: {
+    isDynamic?: boolean;
+}): StaticRouteCandidateAnalysis;
+declare function findRequestBoundSourceBlockers(source: string): string[];
+declare function parseRouteRenderingDirective(source: string | undefined): DirectiveRenderingConfig | undefined;
+/**
+ * A route's rendering directive as the production runtime needs it: the parsed directive plus
+ * whether its source reads request state. The runtime only sees module exports, so the build
+ * decides `requestBound` here and bakes it into the generated server entry, where
+ * `mergeRouteRenderingDirectiveConfig` combines it with the module's exports.
+ */
+declare function readRouteRenderingDirectiveFromFile(modulePath: string): DirectiveRenderingConfig | undefined;
+/**
+ * Collect SSG pages from route modules
+ *
+ * Scans all routes and categorizes them into:
+ * - SSG pages: Pre-rendered at build time
+ * - SSR routes: Rendered on each request
+ *
+ * @param routes - Array of route entries
+ * @param loadModule - Function to load a route module
+ * @returns SSG pages and SSR routes
+ */
+declare function collectSSGPages(routes: RouteEntry[], loadModule: (filePath: string) => Promise<RouteModule>, options?: {
+    suggestStaticRendering?: boolean;
+    /**
+     * Routes a docs adapter renders, which ignore route config: a static candidate among them
+     * is pointed at `docs.prerender` instead of `force-static`, or not at all once it is set.
+     */
+    docsAdapterRoutes?: {
+        owns: (routePath: string) => boolean;
+        prerender: boolean;
+    };
+}): Promise<SSGCollectionResult>;
+/**
+ * Check if a route module is SSG
+ */
+declare function isSSGModule(mod: RouteModule | null | undefined): boolean;
+/**
+ * Check if a route module has ISR (Incremental Static Regeneration)
+ */
+declare function hasISR(mod: RouteModule | null | undefined): boolean;
+/**
+ * Get revalidation interval for a module
+ */
+declare function getRevalidateInterval(mod: RouteModule | null | undefined): number | undefined;
+/**
+ * Check if a route module has PPR/static-shell caching enabled.
+ */
+declare function hasPPR(mod: RouteModule | null | undefined, options?: RouteRenderingOptions): boolean;
+/**
+ * Generate SSG manifest for production builds
+ */
+declare function generateSSGManifest(pages: SSGPage[]): string;
+/**
+ * Check if a URL path matches an SSG page
+ */
+declare function matchSSGPage(urlPath: string, ssgPages: SSGPage[]): SSGPage | undefined;
+
+/**
+ * The browser copy of a programmatic page or layout imports only the module that defines its
+ * component, never the routes file. Guards, data hooks, static paths, generated metadata, API
+ * handlers, and whatever the routes file imports for them stay out of the client graph because
+ * the client graph never reaches the routes file.
+ *
+ * Farm already evaluates the routes file on the server to build its route table. That
+ * evaluation also tells it where each component lives: the server module graph holds every
+ * module the routes file reached, with its exports, so the module that exports the very
+ * function (or object) a route uses as its `component` is that component's own module. This
+ * works for any way the route list is built (helpers, re-exported lists, assignments, aliases)
+ * because it reads the evaluated value instead of the routes file's syntax. A component that no
+ * other module exports (declared in the routes file, or computed there) has no module to
+ * import, so a client build that needs it fails with an actionable error.
+ *
+ * A module that holds route definitions is never a component's client import, however it holds
+ * them: Farm finds definitions in every evaluated module's exports (inside objects, arrays,
+ * maps, and sets), and route factories record the module that called them while routes are
+ * evaluated, which also finds definitions kept behind a function. A definition written as an
+ * object literal and kept out of every export can't be traced, so then a component module is
+ * accepted only when neither it nor anything it imports holds route-defining code.
+ */
+type ProgrammaticClientRouteKind = "page" | "layout";
+interface ProgrammaticClientModuleExport {
+    /** Absolute path of the module that exports the value. */
+    file: string;
+    /** The export name that holds it. */
+    exportName: string;
+}
+interface ProgrammaticClientRoute {
+    kind: ProgrammaticClientRouteKind;
+    path: string;
+    /** Absolute path of the routes file that defines the route. */
+    routesFile: string;
+    component?: ProgrammaticClientModuleExport;
+    pending?: ProgrammaticClientModuleExport;
+    /**
+     * The route options the server resolves into the page's props (params, search, guard, data).
+     * The browser copy renders only from props the server resolved.
+     */
+    serverProps?: string[];
+    /** Why the browser copy can't be generated, when it can't. */
+    problem?: string;
+}
+interface ProgrammaticClientRoutes {
+    /** Keyed by {@link programmaticClientRouteKey}. */
+    routes: ReadonlyMap<string, ProgrammaticClientRoute>;
+    /**
+     * Routes files and the modules that export route definitions. None of them may enter the
+     * client graph.
+     */
+    routeSourceFiles: ReadonlySet<string>;
+}
+
+interface IsolatedClientBoundaryReference {
+    /** Absolute source path. Converted to a Vite URL only at the manifest edge. */
+    modulePath: string;
+    islandStrategy: FarmIslandStrategy;
+}
+/**
+ * Packages the browser loads only once a page renders, so Vite's optimizer finds them late,
+ * optimizes again and can leave two copies of React on the page. Under `directory`: every bare
+ * import of a `"use client"` module, and every package a server module imports that is a client
+ * boundary (`"use client"`). Imports a server module makes of anything else stay out: they may
+ * not run in a browser.
+ */
+declare function collectFarmClientPackageImports(directory: string, root: string): string[];
+
+export { type IsolatedClientBoundaryReference as I, type ProgrammaticClientRoutes as P, type StaticRouteCandidateAnalysis as S, analyzeStaticRouteCandidate as a, collectSSGPages as b, collectFarmClientPackageImports as c, getRevalidateInterval as d, hasPPR as e, findRequestBoundSourceBlockers as f, generateSSGManifest as g, hasISR as h, isSSGModule as i, resolveRouteRenderingConfig as j, resolveRouteRenderingConfigFromFile as k, matchSSGPage as m, parseRouteRenderingDirective as p, readRouteRenderingDirectiveFromFile as r };

package/dist/client-plugins.cjs

@@ -1,9 +1,9 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
-var _chunkVB6UCX3Vcjs = require('./chunk-VB6UCX3V.cjs');
-require('./chunk-S3JO3N4H.cjs');
+var _chunk2XGBJSDVcjs = require('./chunk-2XGBJSDV.cjs');
+require('./chunk-BTZ5O6VM.cjs');
 
 
 
-exports.FarmClientPluginManager = _chunkVB6UCX3Vcjs.FarmClientPluginManager; exports.createClientPluginManager = _chunkVB6UCX3Vcjs.createClientPluginManager;
+exports.FarmClientPluginManager = _chunk2XGBJSDVcjs.FarmClientPluginManager; exports.createClientPluginManager = _chunk2XGBJSDVcjs.createClientPluginManager;