@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/chunk-J5YWQVI5.mjs

@@ -0,0 +1,211 @@
+import {
+  getFarmClientDataCache
+} from "./chunk-TQAEEJB4.mjs";
+import {
+  isFarmServerQueryResult
+} from "./chunk-SCFX4UTD.mjs";
+import {
+  createFarmCacheKey
+} from "./chunk-V3XURYJO.mjs";
+import {
+  __name
+} from "./chunk-CGILA3WO.mjs";
+
+// src/server-query-client.ts
+import { useCallback, useEffect, useRef, useSyncExternalStore } from "react";
+var FARM_SERVER_QUERY_CLIENT_STATE = /* @__PURE__ */ Symbol.for("farm.serverQueryClientState");
+var serverQueryClientGlobal = globalThis;
+var serverQueryClientState = serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] ?? (serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] = {
+  functionIds: /* @__PURE__ */ new WeakMap(),
+  nextFunctionId: 0,
+  active: []
+});
+function beginFarmServerQueryAction(actionId, args) {
+  const active = serverQueryClientState.active.at(-1);
+  return {
+    actionId,
+    args,
+    provisionalKey: active?.provisionalKey
+  };
+}
+__name(beginFarmServerQueryAction, "beginFarmServerQueryAction");
+function completeFarmServerQueryAction(invocation, value) {
+  if (!isFarmServerQueryResult(value)) return value;
+  const cache = getFarmClientDataCache();
+  const metadata = value.__farmServerQuery;
+  if (invocation.provisionalKey) {
+    cache.alias(invocation.provisionalKey, metadata.key);
+  }
+  cache.set(metadata.key, {
+    data: value.data,
+    updatedAt: metadata.updatedAt,
+    staleAt: metadata.staleTime === false ? Number.POSITIVE_INFINITY : metadata.updatedAt + metadata.staleTime,
+    status: "success",
+    error: null,
+    fetching: false
+  });
+  return value.data;
+}
+__name(completeFarmServerQueryAction, "completeFarmServerQueryAction");
+async function fetchServerQuery(query, input, options = {}) {
+  const cache = getFarmClientDataCache();
+  const provisionalKey = createServerQueryCallKey(query, input);
+  const entry = cache.get(provisionalKey);
+  const stale = cache.isStale(provisionalKey);
+  const inflight = cache.getInflight(provisionalKey);
+  if (inflight) return inflight;
+  if (!options.force && entry && !stale && entry.status !== "error") {
+    return entry.data;
+  }
+  if (!options.force && entry && stale && entry.status !== "pending" && entry.status !== "error" && (options.swr ?? true)) {
+    void executeServerQuery(query, input, provisionalKey, options).catch(() => void 0);
+    return entry.data;
+  }
+  return executeServerQuery(query, input, provisionalKey, options);
+}
+__name(fetchServerQuery, "fetchServerQuery");
+function prefetchServerQuery(query, input, options = {}) {
+  return fetchServerQuery(query, input, options);
+}
+__name(prefetchServerQuery, "prefetchServerQuery");
+function useServerQuery(query, input, options = {}) {
+  const cache = getFarmClientDataCache();
+  const key = createServerQueryCallKey(query, input);
+  const inputRef = useRef(input);
+  const optionsRef = useRef(options);
+  const mountedKeyRef = useRef(void 0);
+  inputRef.current = input;
+  optionsRef.current = options;
+  const subscribe = useCallback(
+    (listener) => cache.subscribe(key, listener),
+    [cache, key]
+  );
+  const getSnapshot = useCallback(() => cache.get(key), [cache, key]);
+  const entry = useSyncExternalStore(subscribe, getSnapshot, () => void 0);
+  const run = useCallback(
+    (force = false) => fetchServerQuery(query, inputRef.current, {
+      ...optionsRef.current,
+      force
+    }),
+    [query]
+  );
+  useEffect(() => {
+    if (options.enabled === false) return;
+    const firstReadForKey = mountedKeyRef.current !== key;
+    if (firstReadForKey) mountedKeyRef.current = key;
+    if (firstReadForKey && (!entry || cache.isStale(key)) || entry?.invalidatedAt !== void 0 && !entry.fetching) {
+      void run().catch(() => void 0);
+    }
+  }, [cache, entry, key, options.enabled, run]);
+  useEffect(() => {
+    if (options.enabled === false || typeof window === "undefined") return;
+    const refreshIfStale = /* @__PURE__ */ __name(() => {
+      if (cache.isStale(key)) void run().catch(() => void 0);
+    }, "refreshIfStale");
+    const onFocus = options.refetchOnWindowFocus === false ? void 0 : refreshIfStale;
+    const onOnline = options.refetchOnReconnect === false ? void 0 : refreshIfStale;
+    if (onFocus) window.addEventListener("focus", onFocus);
+    if (onOnline) window.addEventListener("online", onOnline);
+    return () => {
+      if (onFocus) window.removeEventListener("focus", onFocus);
+      if (onOnline) window.removeEventListener("online", onOnline);
+    };
+  }, [cache, key, options.enabled, options.refetchOnReconnect, options.refetchOnWindowFocus, run]);
+  const status = entry?.status ?? (entry ? "success" : "idle");
+  const fetching = entry?.fetching ?? false;
+  return {
+    data: entry?.data,
+    error: entry?.error ?? null,
+    status,
+    pending: status === "pending" && (entry?.updatedAt ?? 0) === 0,
+    fetching,
+    stale: cache.isStale(key),
+    refetch: /* @__PURE__ */ __name(() => run(true), "refetch")
+  };
+}
+__name(useServerQuery, "useServerQuery");
+function createServerQueryCallKey(query, input) {
+  let id = serverQueryClientState.functionIds.get(query);
+  if (!id) {
+    id = ++serverQueryClientState.nextFunctionId;
+    serverQueryClientState.functionIds.set(query, id);
+  }
+  return createFarmCacheKey(["server-query-call", id, input]);
+}
+__name(createServerQueryCallKey, "createServerQueryCallKey");
+async function executeServerQuery(query, input, provisionalKey, options) {
+  const cache = getFarmClientDataCache();
+  const inflight = cache.getInflight(provisionalKey);
+  if (inflight) return inflight;
+  const previous = cache.get(provisionalKey);
+  cache.set(provisionalKey, {
+    data: previous?.data,
+    updatedAt: previous?.updatedAt ?? 0,
+    staleAt: previous?.staleAt ?? 0,
+    gcAt: previous?.gcAt,
+    invalidatedAt: previous?.invalidatedAt,
+    status: "pending",
+    error: null,
+    fetching: true
+  });
+  const promise = (async () => {
+    try {
+      serverQueryClientState.active.push({ provisionalKey });
+      let pending;
+      try {
+        pending = query(input);
+      } finally {
+        serverQueryClientState.active.pop();
+      }
+      const data = await pending;
+      const transported = cache.get(provisionalKey);
+      if (!transported || transported.fetching) {
+        const updatedAt = Date.now();
+        cache.set(provisionalKey, {
+          data,
+          updatedAt,
+          staleAt: options.staleTime === false ? Number.POSITIVE_INFINITY : updatedAt + (options.staleTime ?? 0),
+          status: "success",
+          error: null,
+          fetching: false
+        });
+      }
+      return data;
+    } catch (cause) {
+      const error = normalizeServerQueryError(cause);
+      const current = cache.get(provisionalKey);
+      cache.set(provisionalKey, {
+        data: current?.data,
+        updatedAt: current?.updatedAt ?? 0,
+        staleAt: current?.staleAt ?? 0,
+        gcAt: current?.gcAt,
+        invalidatedAt: current?.invalidatedAt,
+        status: "error",
+        error,
+        fetching: false
+      });
+      throw error;
+    } finally {
+      cache.deleteInflight(provisionalKey);
+    }
+  })();
+  cache.setInflight(provisionalKey, promise);
+  return promise;
+}
+__name(executeServerQuery, "executeServerQuery");
+function normalizeServerQueryError(cause) {
+  if (cause instanceof Error) return cause;
+  const error = new Error(typeof cause === "string" ? cause : "Server query failed");
+  error.cause = cause;
+  return error;
+}
+__name(normalizeServerQueryError, "normalizeServerQueryError");
+
+export {
+  beginFarmServerQueryAction,
+  completeFarmServerQueryAction,
+  fetchServerQuery,
+  prefetchServerQuery,
+  useServerQuery
+};
+//# sourceMappingURL=chunk-J5YWQVI5.mjs.map

package/dist/chunk-J5YWQVI5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server-query-client.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback, useEffect, useRef, useSyncExternalStore } from \"react\";\nimport { createFarmCacheKey } from \"./cache\";\nimport {\n  getFarmClientDataCache,\n  type FarmClientCacheEntry,\n  type FarmClientCacheStatus,\n} from \"./client-cache\";\nimport type { ServerQuery } from \"./server-query\";\nimport { isFarmServerQueryResult, type FarmServerQueryResult } from \"./server-query-protocol\";\n\nexport type ServerQueryFetchOptions = {\n  /** Used only when a non-Farm transport returns plain data. Farm transports use the declaration. */\n  staleTime?: number | false;\n  /** Return stale data immediately while refreshing it in the background. Default true. */\n  swr?: boolean;\n  /** Always wait for a new result. */\n  force?: boolean;\n};\n\nexport type UseServerQueryOptions = ServerQueryFetchOptions & {\n  enabled?: boolean;\n  refetchOnWindowFocus?: boolean;\n  refetchOnReconnect?: boolean;\n};\n\nexport type UseServerQueryResult<TData> = {\n  data: TData | undefined;\n  error: Error | null;\n  status: FarmClientCacheStatus;\n  pending: boolean;\n  fetching: boolean;\n  stale: boolean;\n  refetch: () => Promise<TData>;\n};\n\nexport type FarmServerQueryActionInvocation = {\n  actionId: string;\n  args: readonly unknown[];\n  provisionalKey?: string;\n};\n\ntype ActiveServerQueryInvocation = {\n  provisionalKey: string;\n};\n\ntype ServerQueryClientState = {\n  functionIds: WeakMap<Function, number>;\n  nextFunctionId: number;\n  active: ActiveServerQueryInvocation[];\n};\n\nconst FARM_SERVER_QUERY_CLIENT_STATE = Symbol.for(\"farm.serverQueryClientState\");\nconst serverQueryClientGlobal = globalThis as typeof globalThis & {\n  [FARM_SERVER_QUERY_CLIENT_STATE]?: ServerQueryClientState;\n};\nconst serverQueryClientState = (serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] ??= {\n  functionIds: new WeakMap(),\n  nextFunctionId: 0,\n  active: [],\n});\n\nexport function beginFarmServerQueryAction(\n  actionId: string,\n  args: readonly unknown[],\n): FarmServerQueryActionInvocation {\n  const active = serverQueryClientState.active.at(-1);\n  return {\n    actionId,\n    args,\n    provisionalKey: active?.provisionalKey,\n  };\n}\n\nexport function completeFarmServerQueryAction<TData>(\n  invocation: FarmServerQueryActionInvocation,\n  value: TData | FarmServerQueryResult<TData>,\n): TData {\n  if (!isFarmServerQueryResult(value)) return value as TData;\n\n  const cache = getFarmClientDataCache();\n  const metadata = value.__farmServerQuery;\n  if (invocation.provisionalKey) {\n    cache.alias(invocation.provisionalKey, metadata.key);\n  }\n\n  cache.set(metadata.key, {\n    data: value.data,\n    updatedAt: metadata.updatedAt,\n    staleAt:\n      metadata.staleTime === false\n        ? Number.POSITIVE_INFINITY\n        : metadata.updatedAt + metadata.staleTime,\n    status: \"success\",\n    error: null,\n    fetching: false,\n  });\n\n  return value.data as TData;\n}\n\nexport async function fetchServerQuery<TInput, TData>(\n  query: ServerQuery<TInput, TData>,\n  input: TInput,\n  options: ServerQueryFetchOptions = {},\n): Promise<TData> {\n  const cache = getFarmClientDataCache();\n  const provisionalKey = createServerQueryCallKey(query, input);\n  const entry = cache.get<TData>(provisionalKey);\n  const stale = cache.isStale(provisionalKey);\n  const inflight = cache.getInflight<TData>(provisionalKey);\n\n  if (inflight) return inflight;\n\n  if (!options.force && entry && !stale && entry.status !== \"error\") {\n    return entry.data;\n  }\n\n  if (\n    !options.force &&\n    entry &&\n    stale &&\n    entry.status !== \"pending\" &&\n    entry.status !== \"error\" &&\n    (options.swr ?? true)\n  ) {\n    void executeServerQuery(query, input, provisionalKey, options).catch(() => undefined);\n    return entry.data;\n  }\n\n  return executeServerQuery(query, input, provisionalKey, options);\n}\n\nexport function prefetchServerQuery<TInput, TData>(\n  query: ServerQuery<TInput, TData>,\n  input: TInput,\n  options: Omit<ServerQueryFetchOptions, \"force\"> = {},\n): Promise<TData> {\n  return fetchServerQuery(query, input, options);\n}\n\nexport function useServerQuery<TInput, TData>(\n  query: ServerQuery<TInput, TData>,\n  input: TInput,\n  options: UseServerQueryOptions = {},\n): UseServerQueryResult<TData> {\n  const cache = getFarmClientDataCache();\n  const key = createServerQueryCallKey(query, input);\n  const inputRef = useRef(input);\n  const optionsRef = useRef(options);\n  const mountedKeyRef = useRef<string | undefined>(undefined);\n  inputRef.current = input;\n  optionsRef.current = options;\n\n  const subscribe = useCallback(\n    (listener: () => void) => cache.subscribe(key, listener),\n    [cache, key],\n  );\n  const getSnapshot = useCallback(() => cache.get<TData>(key), [cache, key]);\n  const entry = useSyncExternalStore(subscribe, getSnapshot, () => undefined);\n\n  const run = useCallback(\n    (force = false) =>\n      fetchServerQuery(query, inputRef.current, {\n        ...optionsRef.current,\n        force,\n      }),\n    [query],\n  );\n\n  useEffect(() => {\n    if (options.enabled === false) return;\n\n    const firstReadForKey = mountedKeyRef.current !== key;\n    if (firstReadForKey) mountedKeyRef.current = key;\n\n    if (\n      (firstReadForKey && (!entry || cache.isStale(key))) ||\n      (entry?.invalidatedAt !== undefined && !entry.fetching)\n    ) {\n      void run().catch(() => undefined);\n    }\n  }, [cache, entry, key, options.enabled, run]);\n\n  useEffect(() => {\n    if (options.enabled === false || typeof window === \"undefined\") return;\n\n    const refreshIfStale = () => {\n      if (cache.isStale(key)) void run().catch(() => undefined);\n    };\n    const onFocus = options.refetchOnWindowFocus === false ? undefined : refreshIfStale;\n    const onOnline = options.refetchOnReconnect === false ? undefined : refreshIfStale;\n\n    if (onFocus) window.addEventListener(\"focus\", onFocus);\n    if (onOnline) window.addEventListener(\"online\", onOnline);\n    return () => {\n      if (onFocus) window.removeEventListener(\"focus\", onFocus);\n      if (onOnline) window.removeEventListener(\"online\", onOnline);\n    };\n  }, [cache, key, options.enabled, options.refetchOnReconnect, options.refetchOnWindowFocus, run]);\n\n  const status = entry?.status ?? (entry ? \"success\" : \"idle\");\n  const fetching = entry?.fetching ?? false;\n\n  return {\n    data: entry?.data,\n    error: entry?.error ?? null,\n    status,\n    pending: status === \"pending\" && (entry?.updatedAt ?? 0) === 0,\n    fetching,\n    stale: cache.isStale(key),\n    refetch: () => run(true),\n  };\n}\n\nfunction createServerQueryCallKey<TInput, TData>(\n  query: ServerQuery<TInput, TData>,\n  input: TInput,\n): string {\n  let id = serverQueryClientState.functionIds.get(query);\n  if (!id) {\n    id = ++serverQueryClientState.nextFunctionId;\n    serverQueryClientState.functionIds.set(query, id);\n  }\n  return createFarmCacheKey([\"server-query-call\", id, input]);\n}\n\nasync function executeServerQuery<TInput, TData>(\n  query: ServerQuery<TInput, TData>,\n  input: TInput,\n  provisionalKey: string,\n  options: ServerQueryFetchOptions,\n): Promise<TData> {\n  const cache = getFarmClientDataCache();\n  const inflight = cache.getInflight<TData>(provisionalKey);\n  if (inflight) return inflight;\n\n  const previous = cache.get<TData>(provisionalKey);\n  cache.set(provisionalKey, {\n    data: previous?.data as TData,\n    updatedAt: previous?.updatedAt ?? 0,\n    staleAt: previous?.staleAt ?? 0,\n    gcAt: previous?.gcAt,\n    invalidatedAt: previous?.invalidatedAt,\n    status: \"pending\",\n    error: null,\n    fetching: true,\n  });\n\n  const promise = (async () => {\n    try {\n      serverQueryClientState.active.push({ provisionalKey });\n      let pending: Promise<TData>;\n      try {\n        pending = query(input);\n      } finally {\n        serverQueryClientState.active.pop();\n      }\n\n      const data = await pending;\n      const transported = cache.get<TData>(provisionalKey);\n      if (!transported || transported.fetching) {\n        const updatedAt = Date.now();\n        cache.set(provisionalKey, {\n          data,\n          updatedAt,\n          staleAt:\n            options.staleTime === false\n              ? Number.POSITIVE_INFINITY\n              : updatedAt + (options.staleTime ?? 0),\n          status: \"success\",\n          error: null,\n          fetching: false,\n        });\n      }\n      return data;\n    } catch (cause) {\n      const error = normalizeServerQueryError(cause);\n      const current = cache.get<TData>(provisionalKey);\n      cache.set(provisionalKey, {\n        data: current?.data as TData,\n        updatedAt: current?.updatedAt ?? 0,\n        staleAt: current?.staleAt ?? 0,\n        gcAt: current?.gcAt,\n        invalidatedAt: current?.invalidatedAt,\n        status: \"error\",\n        error,\n        fetching: false,\n      });\n      throw error;\n    } finally {\n      cache.deleteInflight(provisionalKey);\n    }\n  })();\n\n  cache.setInflight(provisionalKey, promise);\n  return promise;\n}\n\nfunction normalizeServerQueryError(cause: unknown): Error {\n  if (cause instanceof Error) return cause;\n  const error = new Error(typeof cause === \"string\" ? cause : \"Server query failed\");\n  (error as Error & { cause?: unknown }).cause = cause;\n  return error;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-JDEOUK5V.mjs

@@ -0,0 +1,427 @@
+import {
+  _withAfterNodeMiddleware
+} from "./chunk-E6EPN5BT.mjs";
+import {
+  sendWebResponse
+} from "./chunk-QGOHVJ6J.mjs";
+import {
+  API_ROUTE_METHODS,
+  findProgrammaticRouteFilesInDir
+} from "./chunk-Z5CQMP54.mjs";
+import {
+  getProgrammaticRouteManifest,
+  isProgrammaticRoutesFileName
+} from "./chunk-C2ROET2V.mjs";
+import {
+  toViteModuleId
+} from "./chunk-J4FNJ5IU.mjs";
+import {
+  invokeAPIRouteEndpoint,
+  matchAPIRoute
+} from "./chunk-PFE6GMNE.mjs";
+import {
+  __name,
+  __require
+} from "./chunk-CGILA3WO.mjs";
+
+// src/api/vite-plugin.ts
+function farmApiPlugin(options = {}) {
+  const srcDir = options.srcDir ?? "src";
+  const debug = options.debug ?? false;
+  let apiRoutesCache = /* @__PURE__ */ new Map();
+  let apiRouterHandler = null;
+  let discoveryComplete = false;
+  let discoveryPromise = null;
+  const log = /* @__PURE__ */ __name((_message) => {
+  }, "log");
+  const logResponse = /* @__PURE__ */ __name((method, urlPath, status, duration) => {
+    try {
+      const pc = __require("picocolors");
+      let statusColor = pc.green;
+      if (status >= 500) statusColor = pc.red;
+      else if (status >= 400) statusColor = pc.yellow;
+      else if (status >= 300) statusColor = pc.cyan;
+      const logMsg = [
+        pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
+        pc.dim("[") + pc.bold(pc.cyan("API")) + pc.dim("]"),
+        pc.dim("[") + pc.bold(pc.white(method.padEnd(3))) + pc.dim("]"),
+        pc.gray(urlPath),
+        pc.dim("-"),
+        statusColor(status.toString()),
+        pc.dim(`(${duration}ms)`)
+      ].join(" ");
+      console.log(logMsg);
+    } catch {
+      console.log(`[FARM] [API] [${method}] ${urlPath} - ${status} (${duration}ms)`);
+    }
+  }, "logResponse");
+  const addEndpoint = /* @__PURE__ */ __name((routePath, filePath, method, endpoint) => {
+    const normalizedMethod = method.toUpperCase();
+    const existing = apiRoutesCache.get(routePath);
+    if (existing) {
+      if (!existing.methods.includes(normalizedMethod)) {
+        existing.methods.push(normalizedMethod);
+      }
+      existing.endpoints[normalizedMethod] = endpoint;
+      return;
+    }
+    apiRoutesCache.set(routePath, {
+      path: routePath,
+      filePath,
+      methods: [normalizedMethod],
+      endpoints: { [normalizedMethod]: endpoint }
+    });
+  }, "addEndpoint");
+  const createRouter = /* @__PURE__ */ __name(async () => {
+    const totalEndpoints = Array.from(apiRoutesCache.values()).reduce(
+      (sum, route) => sum + route.methods.length,
+      0
+    );
+    apiRouterHandler = null;
+    if (totalEndpoints > 0) {
+      apiRouterHandler = /* @__PURE__ */ __name(async (request) => {
+        const url = new URL(request.url);
+        const method = request.method.toUpperCase();
+        const pathname = url.pathname;
+        const match = matchAPIRoute(apiRoutesCache, pathname);
+        if (!match) {
+          return new Response(JSON.stringify({ error: "Not Found" }), {
+            status: 404,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        const { route, params } = match;
+        const endpoint = route.endpoints[method];
+        if (!endpoint) {
+          return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+            status: 405,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        try {
+          return await invokeAPIRouteEndpoint(endpoint, request, params);
+        } catch (error) {
+          return new Response(JSON.stringify({ error: error.message || "Internal Server Error" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      }, "apiRouterHandler");
+      log(`API router created with ${totalEndpoints} endpoints`);
+    }
+  }, "createRouter");
+  return {
+    name: "@farm.js/core:api",
+    enforce: "pre",
+    configureServer(server) {
+      const discoverFileRoutes = /* @__PURE__ */ __name(async (apiDir) => {
+        const fs = await import("fs");
+        const path = await import("path");
+        if (!fs.existsSync(apiDir)) {
+          log("No api directory found");
+          return;
+        }
+        const findRouteFiles = /* @__PURE__ */ __name((dir) => {
+          const files = [];
+          if (!fs.existsSync(dir)) return files;
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+              files.push(...findRouteFiles(fullPath));
+            } else if (entry.name === "route.ts" || entry.name === "route.tsx" || entry.name === "route.js") {
+              files.push(fullPath);
+            }
+          }
+          return files;
+        }, "findRouteFiles");
+        const routeFiles = findRouteFiles(apiDir);
+        apiRoutesCache.clear();
+        for (const filePath of routeFiles) {
+          try {
+            const relativePath = path.relative(apiDir, path.dirname(filePath));
+            const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
+            const routeModule = await server.ssrLoadModule(filePath);
+            const endpoints = {};
+            const availableMethods = [];
+            for (const method of API_ROUTE_METHODS) {
+              if (routeModule[method]) {
+                availableMethods.push(method);
+                endpoints[method] = routeModule[method];
+              }
+            }
+            if (availableMethods.length > 0) {
+              apiRoutesCache.set(routePath, {
+                path: routePath,
+                filePath,
+                methods: availableMethods,
+                endpoints
+              });
+              log(`API route discovered: ${availableMethods.join(", ")} ${routePath}`);
+            }
+          } catch (e) {
+            log(`API route load failed at ${filePath}: ${e.message}`);
+          }
+        }
+      }, "discoverFileRoutes");
+      const discoverRootRoutes = /* @__PURE__ */ __name(async () => {
+        const fs = await import("fs");
+        const path = await import("path");
+        const routesFiles = [
+          path.join(server.config.root, srcDir, "routes.ts"),
+          path.join(server.config.root, srcDir, "routes.tsx"),
+          path.join(server.config.root, srcDir, "routes.js")
+        ];
+        for (const routesFile of routesFiles) {
+          if (fs.existsSync(routesFile)) {
+            try {
+              const routesModule = await server.ssrLoadModule(routesFile);
+              for (const [exportName, exportValue] of Object.entries(routesModule)) {
+                const endpoint = exportValue;
+                if (endpoint && endpoint.__path) {
+                  const routePath = endpoint.__path;
+                  const method = String(endpoint.__method || "GET").toUpperCase();
+                  addEndpoint(routePath, routesFile, method, endpoint);
+                  log(`Root route discovered: ${method} ${routePath}`);
+                }
+              }
+            } catch (e) {
+              log(`Root routes.ts load failed: ${e.message}`);
+            }
+            break;
+          }
+        }
+      }, "discoverRootRoutes");
+      const discoverProgrammaticRoutes = /* @__PURE__ */ __name(async () => {
+        const path = await import("path");
+        const srcRoot = path.join(server.config.root, srcDir);
+        const routeFiles = findProgrammaticRouteFilesInDir(srcRoot);
+        for (const routeFile of routeFiles) {
+          try {
+            const routesModule = await server.ssrLoadModule(
+              toViteModuleId(routeFile, server.config.root)
+            );
+            const manifest = getProgrammaticRouteManifest(routesModule);
+            if (!manifest) continue;
+            for (const definition of manifest.routes) {
+              if (definition.kind !== "api") continue;
+              for (const [method, endpoint] of Object.entries(definition.methods)) {
+                if (endpoint) {
+                  addEndpoint(definition.path, routeFile, method, endpoint);
+                  log(`Programmatic route discovered: ${method} ${definition.path}`);
+                }
+              }
+            }
+          } catch (e) {
+            log(`Programmatic routes file load failed at ${routeFile}: ${e.message}`);
+          }
+        }
+      }, "discoverProgrammaticRoutes");
+      const initializeDiscovery = /* @__PURE__ */ __name(async () => {
+        const path = await import("path");
+        const apiDir = path.join(server.config.root, srcDir, "api");
+        log(`Discovering API routes in: ${apiDir}`);
+        await discoverFileRoutes(apiDir);
+        await discoverRootRoutes();
+        await discoverProgrammaticRoutes();
+        await createRouter();
+        discoveryComplete = true;
+        log(`API discovery complete: ${apiRoutesCache.size} routes found`);
+      }, "initializeDiscovery");
+      discoveryPromise = initializeDiscovery().catch((e) => {
+        console.error("[FARM] API discovery error:", e);
+      });
+      server.__farmApi__ = {
+        getHandler: /* @__PURE__ */ __name(() => apiRouterHandler, "getHandler"),
+        getRoutes: /* @__PURE__ */ __name(() => apiRoutesCache, "getRoutes"),
+        isReady: /* @__PURE__ */ __name(() => discoveryComplete, "isReady"),
+        waitForDiscovery: /* @__PURE__ */ __name(() => discoveryPromise, "waitForDiscovery")
+      };
+      return () => {
+        server.middlewares.use(
+          _withAfterNodeMiddleware(async (req, res, next) => {
+            const url = req.url || "/";
+            const pathname = url.split("?")[0];
+            const method = req.method || "GET";
+            if (discoveryPromise && !discoveryComplete) {
+              await discoveryPromise;
+            }
+            if (!matchAPIRoute(apiRoutesCache, pathname)) {
+              return next();
+            }
+            if (!apiRouterHandler) {
+              return next();
+            }
+            const startTime = Date.now();
+            try {
+              const farmMiddleware = server.__farmMiddleware__;
+              if (farmMiddleware) {
+                await farmMiddleware.waitForDiscovery?.();
+                const middlewareData = /* @__PURE__ */ new Map();
+                const handled = await farmMiddleware.execute(req, res, pathname, middlewareData);
+                if (handled) {
+                  const duration2 = Date.now() - startTime;
+                  logResponse(method, pathname, res.statusCode || 200, duration2);
+                  return;
+                }
+              }
+              const fullUrl = `http://${req.headers.host || "localhost:3000"}${url}`;
+              const headers = new Headers();
+              for (const [key, value] of Object.entries(req.headers)) {
+                if (value) {
+                  headers.set(key, Array.isArray(value) ? value.join(", ") : value);
+                }
+              }
+              let body;
+              if (method !== "GET" && method !== "HEAD") {
+                body = await new Promise((resolve) => {
+                  let data = "";
+                  req.on("data", (chunk) => {
+                    data += chunk;
+                  });
+                  req.on("end", () => {
+                    resolve(data);
+                  });
+                });
+              }
+              const request = new Request(fullUrl, {
+                method,
+                headers,
+                body: body || void 0
+              });
+              const response = await apiRouterHandler(request);
+              const duration = Date.now() - startTime;
+              logResponse(method, pathname, response.status, duration);
+              await sendWebResponse(res, response);
+            } catch (error) {
+              const duration = Date.now() - startTime;
+              logResponse(method, pathname, 500, duration);
+              console.error("[FARM] API error:", error);
+              res.statusCode = 500;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: "Internal server error" }));
+            }
+          })
+        );
+      };
+    },
+    async handleHotUpdate({ file, server, modules }) {
+      const fileName = file.split("/").pop() || "";
+      if (fileName === "routes.ts" || fileName === "routes.tsx" || fileName === "routes.js" || isProgrammaticRoutesFileName(fileName)) {
+        log(`Root routes file updated: ${fileName}`);
+        for (const mod of modules) {
+          server.moduleGraph.invalidateModule(mod);
+        }
+        for (const [routePath, route] of apiRoutesCache) {
+          if (route.filePath === file) {
+            apiRoutesCache.delete(routePath);
+          }
+        }
+        try {
+          const routesModule = await server.ssrLoadModule(file);
+          for (const [exportName, exportValue] of Object.entries(routesModule)) {
+            const endpoint = exportValue;
+            if (endpoint && endpoint.__path) {
+              const routePath = endpoint.__path;
+              const method = String(endpoint.__method || "GET").toUpperCase();
+              addEndpoint(routePath, file, method, endpoint);
+              log(`Root route reloaded: ${method} ${routePath}`);
+            }
+          }
+          const manifest = getProgrammaticRouteManifest(routesModule);
+          if (manifest) {
+            for (const definition of manifest.routes) {
+              if (definition.kind !== "api") continue;
+              for (const [method, endpoint] of Object.entries(definition.methods)) {
+                if (endpoint) {
+                  addEndpoint(definition.path, file, method, endpoint);
+                  log(`Programmatic route reloaded: ${method} ${definition.path}`);
+                }
+              }
+            }
+          }
+          await createRouter();
+          log(`API router recreated`);
+        } catch (e) {
+          log(`Root routes.ts HMR failed: ${e.message}`);
+        }
+        return [];
+      }
+      if (file.includes("/api/") && fileName.startsWith("route.")) {
+        const shortPath = file.split("/api/")[1] || file;
+        log(`API route updated: ${shortPath}`);
+        for (const mod of modules) {
+          server.moduleGraph.invalidateModule(mod);
+        }
+        let routePathToUpdate = null;
+        for (const [routePath, route] of apiRoutesCache) {
+          if (route.filePath === file) {
+            routePathToUpdate = routePath;
+            break;
+          }
+        }
+        if (routePathToUpdate) {
+          try {
+            const routeModule = await server.ssrLoadModule(file);
+            const endpoints = {};
+            const availableMethods = [];
+            for (const method of API_ROUTE_METHODS) {
+              if (routeModule[method]) {
+                availableMethods.push(method);
+                endpoints[method] = routeModule[method];
+              }
+            }
+            if (availableMethods.length > 0) {
+              apiRoutesCache.set(routePathToUpdate, {
+                path: routePathToUpdate,
+                filePath: file,
+                methods: availableMethods,
+                endpoints
+              });
+              log(`API route reloaded: ${routePathToUpdate}`);
+              await createRouter();
+              log(`API router recreated`);
+            }
+          } catch (e) {
+            log(`API route HMR failed: ${e.message}`);
+          }
+        } else {
+          try {
+            const path = await import("path");
+            const apiDir = path.join(server.config.root, srcDir, "api");
+            const relativePath = path.relative(apiDir, path.dirname(file));
+            const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
+            const routeModule = await server.ssrLoadModule(file);
+            const endpoints = {};
+            const availableMethods = [];
+            for (const method of API_ROUTE_METHODS) {
+              if (routeModule[method]) {
+                availableMethods.push(method);
+                endpoints[method] = routeModule[method];
+              }
+            }
+            if (availableMethods.length > 0) {
+              apiRoutesCache.set(routePath, {
+                path: routePath,
+                filePath: file,
+                methods: availableMethods,
+                endpoints
+              });
+              log(`New API route discovered: ${routePath}`);
+              await createRouter();
+            }
+          } catch (e) {
+            log(`New API route load failed: ${e.message}`);
+          }
+        }
+        return [];
+      }
+    }
+  };
+}
+__name(farmApiPlugin, "farmApiPlugin");
+
+export {
+  farmApiPlugin
+};
+//# sourceMappingURL=chunk-JDEOUK5V.mjs.map