@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-A7DK663W.cjs

@@ -0,0 +1,577 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkBNH53KOTcjs = require('./chunk-BNH53KOT.cjs');
+
+
+var _chunkKBGZ5FD6cjs = require('./chunk-KBGZ5FD6.cjs');
+
+
+var _chunkP2355C6Ecjs = require('./chunk-P2355C6E.cjs');
+
+
+var _chunkEXHEPWFJcjs = require('./chunk-EXHEPWFJ.cjs');
+
+
+var _chunkJZMZKABScjs = require('./chunk-JZMZKABS.cjs');
+
+
+var _chunkSBDWCDS6cjs = require('./chunk-SBDWCDS6.cjs');
+
+
+
+
+
+
+
+var _chunkR2SEZEBCcjs = require('./chunk-R2SEZEBC.cjs');
+
+
+var _chunkE7QOEV5Zcjs = require('./chunk-E7QOEV5Z.cjs');
+
+
+var _chunkY3WG64CPcjs = require('./chunk-Y3WG64CP.cjs');
+
+
+var _chunk6XFGJBYXcjs = require('./chunk-6XFGJBYX.cjs');
+
+
+
+var _chunkXN2MB4QZcjs = require('./chunk-XN2MB4QZ.cjs');
+
+
+var _chunkZ5MZDFX4cjs = require('./chunk-Z5MZDFX4.cjs');
+
+
+
+
+var _chunk5566GNEGcjs = require('./chunk-5566GNEG.cjs');
+
+
+var _chunkHNAISJFDcjs = require('./chunk-HNAISJFD.cjs');
+
+
+
+
+var _chunkYTVSWXEZcjs = require('./chunk-YTVSWXEZ.cjs');
+
+// src/api/vite-plugin.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function farmApiPlugin(options = {}) {
+  const srcDir = _nullishCoalesce(options.srcDir, () => ( "src"));
+  const apiDirFromRoot = _nullishCoalesce(options.apiDir, () => ( _path2.default.join(srcDir, "api")));
+  const debug = _nullishCoalesce(options.debug, () => ( false));
+  const bodySizeLimit = _chunk5566GNEGcjs.resolveFarmServerConfig.call(void 0, {
+    bodySizeLimit: options.bodySizeLimit
+  }).bodySizeLimit;
+  const basePath = options.basePath;
+  let apiRoutesCache = /* @__PURE__ */ new Map();
+  let apiRouterHandler = null;
+  let projectRoot = process.cwd();
+  let devServer;
+  let pluginMergedRoutes = null;
+  const servedRoutes = () => _nullishCoalesce(pluginMergedRoutes, () => ( apiRoutesCache));
+  let routePlugins;
+  let discoveryComplete = false;
+  let discoveryPromise = null;
+  let discoveryError;
+  let recoverFailedDiscovery;
+  const endpointSources = /* @__PURE__ */ new Map();
+  const routeShapes = /* @__PURE__ */ new Map();
+  const log = (_message) => {
+  };
+  const logResponse = (method, urlPath, status, duration) => {
+    const pc = _chunkY3WG64CPcjs.createCliColors.call(void 0, );
+    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);
+  };
+  const registerRouteShape = (routePath, filePath) => {
+    _chunkYTVSWXEZcjs.assertUniqueRouteParameters.call(void 0, routePath, "api");
+    const shape = _chunkYTVSWXEZcjs.getRoutePatternShape.call(void 0, routePath, "api");
+    const existing = routeShapes.get(shape);
+    if (existing && existing.routePath !== routePath) {
+      throw new (0, _chunkYTVSWXEZcjs.AmbiguousRouteError)(
+        `Ambiguous API routes "${existing.routePath}" and "${routePath}" match the same URLs. Found ${existing.filePath} and ${filePath}. Keep only one route for this URL shape.`
+      );
+    }
+    routeShapes.set(shape, { routePath, filePath });
+  };
+  const addEndpoint = (routePath, filePath, method, endpoint) => {
+    registerRouteShape(routePath, filePath);
+    const normalizedMethod = method.toUpperCase();
+    const existing = apiRoutesCache.get(routePath);
+    const existingFile = _optionalChain([endpointSources, 'access', _ => _.get, 'call', _2 => _2(routePath), 'optionalAccess', _3 => _3.get, 'call', _4 => _4(normalizedMethod)]);
+    if (existingFile) {
+      throw new (0, _chunkEXHEPWFJcjs.APIRouteConflictError)(routePath, normalizedMethod, existingFile, filePath);
+    }
+    if (existing) {
+      if (!existing.methods.includes(normalizedMethod)) {
+        existing.methods.push(normalizedMethod);
+      }
+      existing.endpoints[normalizedMethod] = endpoint;
+      const sources = _nullishCoalesce(endpointSources.get(routePath), () => ( /* @__PURE__ */ new Map()));
+      sources.set(normalizedMethod, filePath);
+      endpointSources.set(routePath, sources);
+      return;
+    }
+    apiRoutesCache.set(routePath, {
+      path: routePath,
+      filePath,
+      methods: [normalizedMethod],
+      endpoints: { [normalizedMethod]: endpoint }
+    });
+    endpointSources.set(routePath, /* @__PURE__ */ new Map([[normalizedMethod, filePath]]));
+  };
+  const removeEndpointsFromFile = (filePath) => {
+    for (const [routePath, sources] of endpointSources) {
+      const route = apiRoutesCache.get(routePath);
+      if (!route) continue;
+      for (const [method, sourceFile] of sources) {
+        if (sourceFile !== filePath) continue;
+        sources.delete(method);
+        route.methods = route.methods.filter((candidate) => candidate !== method);
+        delete route.endpoints[method];
+      }
+      if (route.methods.length === 0) {
+        apiRoutesCache.delete(routePath);
+        endpointSources.delete(routePath);
+        routeShapes.delete(_chunkYTVSWXEZcjs.getRoutePatternShape.call(void 0, routePath, "api"));
+      } else {
+        const currentSource = sources.values().next().value;
+        if (route.filePath === filePath && currentSource) {
+          route.filePath = currentSource;
+        }
+        routeShapes.set(_chunkYTVSWXEZcjs.getRoutePatternShape.call(void 0, routePath, "api"), {
+          routePath,
+          filePath: _nullishCoalesce(currentSource, () => ( route.filePath))
+        });
+      }
+    }
+  };
+  const snapshotRouteState = () => ({
+    routes: new Map(
+      [...apiRoutesCache].map(([routePath, route]) => [
+        routePath,
+        {
+          ...route,
+          methods: [...route.methods],
+          endpoints: { ...route.endpoints }
+        }
+      ])
+    ),
+    sources: new Map(
+      [...endpointSources].map(([routePath, sources]) => [routePath, new Map(sources)])
+    ),
+    shapes: new Map(routeShapes)
+  });
+  const restoreRouteState = (snapshot) => {
+    apiRoutesCache = snapshot.routes;
+    endpointSources.clear();
+    for (const [routePath, sources] of snapshot.sources) {
+      endpointSources.set(routePath, sources);
+    }
+    routeShapes.clear();
+    for (const [shape, route] of snapshot.shapes) {
+      routeShapes.set(shape, route);
+    }
+  };
+  const createRouter = async () => {
+    const plugins = options.plugins ? await (_nullishCoalesce(routePlugins, () => ( (routePlugins = Promise.resolve(options.plugins({ root: projectRoot })))))) : [];
+    pluginMergedRoutes = plugins.length ? new Map(
+      _chunkR2SEZEBCcjs.mergePluginAPIRoutes.call(void 0, [...apiRoutesCache.values()], plugins, void 0, {
+        bodySizeLimit,
+        // A plugin calling an app endpoint (an MCP tool, say) goes back through this server,
+        // so the middleware that guards the endpoint's path runs for it.
+        dispatch: (request) => {
+          if (!devServer) throw new Error("The Farm API dev server is not running.");
+          return _chunkBNH53KOTcjs.createFarmDevServerDispatch.call(void 0, devServer)(request);
+        }
+      }).map((route) => [route.path, route])
+    ) : null;
+    const totalEndpoints = Array.from(servedRoutes().values()).reduce(
+      (sum, route) => sum + route.methods.length,
+      0
+    );
+    apiRouterHandler = null;
+    if (totalEndpoints > 0) {
+      apiRouterHandler = async (request) => {
+        const url = new URL(request.url);
+        const method = request.method.toUpperCase();
+        const pathname = url.pathname;
+        const match = _chunkR2SEZEBCcjs.matchAPIRouteAtBasePath.call(void 0, servedRoutes(), pathname, basePath);
+        if (!match) {
+          return new Response(JSON.stringify({ error: "Not Found" }), {
+            status: 404,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        const { route, params } = match;
+        const endpoint = _chunkR2SEZEBCcjs.resolveAPIRouteEndpoint.call(void 0, route, method);
+        if (!endpoint) {
+          return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+            status: 405,
+            headers: {
+              Allow: _chunkR2SEZEBCcjs.getAllowedAPIRouteMethods.call(void 0, route).join(", "),
+              "Content-Type": "application/json"
+            }
+          });
+        }
+        try {
+          return await _chunkR2SEZEBCcjs.invokeAPIRouteEndpoint.call(void 0, endpoint, request, params, bodySizeLimit);
+        } catch (error) {
+          return new Response(JSON.stringify({ error: error.message || "Internal Server Error" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      };
+      log(`API router created with ${totalEndpoints} endpoints`);
+    }
+  };
+  return {
+    name: "@farm.js/core:api",
+    enforce: "pre",
+    configureServer(server) {
+      projectRoot = server.config.root;
+      devServer = server;
+      const discoverFileRoutes = async (apiDir) => {
+        const fs = await import("fs");
+        const path = await import("path");
+        if (!fs.existsSync(apiDir)) {
+          log("No api directory found");
+          return;
+        }
+        const findRouteFiles = (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 (_chunkSBDWCDS6cjs.isFarmAPIRouteFileName.call(void 0, entry.name)) {
+              files.push(fullPath);
+            }
+          }
+          return files;
+        };
+        const routeFiles = findRouteFiles(apiDir);
+        apiRoutesCache.clear();
+        endpointSources.clear();
+        routeShapes.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 _chunk6XFGJBYXcjs.loadFarmDevModule.call(void 0, server, filePath);
+            const endpoints = {};
+            const availableMethods = [];
+            for (const method of _chunkR2SEZEBCcjs.API_ROUTE_METHODS) {
+              if (routeModule[method]) {
+                availableMethods.push(method);
+                endpoints[method] = routeModule[method];
+              }
+            }
+            if (availableMethods.length > 0) {
+              for (const method of availableMethods) {
+                addEndpoint(routePath, filePath, method, endpoints[method]);
+              }
+              log(`API route discovered: ${availableMethods.join(", ")} ${routePath}`);
+            }
+          } catch (e) {
+            if (e instanceof _chunkEXHEPWFJcjs.APIRouteConflictError || e instanceof _chunkYTVSWXEZcjs.AmbiguousRouteError) throw e;
+            log(`API route load failed at ${filePath}: ${e.message}`);
+          }
+        }
+      };
+      const discoverRootRoutes = 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 _chunk6XFGJBYXcjs.loadFarmDevModule.call(void 0, server, 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) {
+              if (e instanceof _chunkEXHEPWFJcjs.APIRouteConflictError || e instanceof _chunkYTVSWXEZcjs.AmbiguousRouteError) throw e;
+              log(`Root routes.ts load failed: ${e.message}`);
+            }
+            break;
+          }
+        }
+      };
+      const discoverProgrammaticRoutes = async () => {
+        const path = await import("path");
+        const srcRoot = path.join(server.config.root, srcDir);
+        const routeFiles = _chunkJZMZKABScjs.findProgrammaticRouteFilesInDir.call(void 0, srcRoot);
+        if (routeFiles.length === 0) return;
+        const { getProgrammaticRouteManifest } = await import("./routes.cjs");
+        for (const routeFile of routeFiles) {
+          try {
+            const routesModule = await _chunk6XFGJBYXcjs.loadFarmDevModule.call(void 0, 
+              server,
+              _chunkXN2MB4QZcjs.toViteModuleId.call(void 0, 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) {
+            if (e instanceof _chunkEXHEPWFJcjs.APIRouteConflictError || e instanceof _chunkYTVSWXEZcjs.AmbiguousRouteError) throw e;
+            log(`Programmatic routes file load failed at ${routeFile}: ${e.message}`);
+          }
+        }
+      };
+      const initializeDiscovery = async () => {
+        const path = await import("path");
+        const apiDir = path.join(server.config.root, apiDirFromRoot);
+        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`);
+      };
+      discoveryPromise = initializeDiscovery().catch((e) => {
+        discoveryError = e;
+        console.error("[FARM] API discovery error:", e);
+      });
+      const waitForDiscovery = async () => {
+        await discoveryPromise;
+        if (discoveryError) throw discoveryError;
+      };
+      recoverFailedDiscovery = async () => {
+        if (!discoveryError) return false;
+        const previousState = snapshotRouteState();
+        try {
+          await initializeDiscovery();
+          discoveryError = void 0;
+          discoveryPromise = Promise.resolve();
+        } catch (error) {
+          restoreRouteState(previousState);
+          discoveryError = error;
+          discoveryComplete = false;
+          discoveryPromise = Promise.resolve();
+          throw error;
+        }
+        return true;
+      };
+      server.__farmApi__ = {
+        getHandler: () => apiRouterHandler,
+        getRoutes: () => servedRoutes(),
+        isReady: () => discoveryComplete,
+        waitForDiscovery
+      };
+      return () => {
+        const apiMiddleware = _chunkP2355C6Ecjs._withAfterNodeMiddleware.call(void 0, async (req, res, next) => {
+          const url = req.url || "/";
+          const pathname = url.split("?")[0];
+          const method = req.method || "GET";
+          if (discoveryPromise) await waitForDiscovery();
+          if (!_chunkR2SEZEBCcjs.matchAPIRouteAtBasePath.call(void 0, servedRoutes(), pathname, basePath)) {
+            return next();
+          }
+          if (!apiRouterHandler) {
+            return next();
+          }
+          const startTime = Date.now();
+          try {
+            const farmMiddleware = server.__farmMiddleware__;
+            if (farmMiddleware) {
+              await _optionalChain([farmMiddleware, 'access', _5 => _5.waitForDiscovery, 'optionalCall', _6 => _6()]);
+              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 currentUrl = req.url || url;
+            const currentPathname = currentUrl.split("?")[0];
+            if (currentPathname !== pathname && !_chunkR2SEZEBCcjs.matchAPIRouteAtBasePath.call(void 0, servedRoutes(), currentPathname, basePath)) {
+              return next();
+            }
+            const fullUrl = _chunkHNAISJFDcjs.resolveFarmRequestURL.call(void 0, req);
+            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 _chunk5566GNEGcjs.readNodeRequestBody.call(void 0, req, bodySizeLimit);
+            }
+            const request = new Request(fullUrl, {
+              method,
+              headers,
+              body: body ? body.buffer.slice(
+                body.byteOffset,
+                body.byteOffset + body.byteLength
+              ) : void 0
+            });
+            const response = await apiRouterHandler(request);
+            const duration = Date.now() - startTime;
+            logResponse(method, currentPathname, response.status, duration);
+            await _chunkZ5MZDFX4cjs.sendWebResponse.call(void 0, res, response);
+          } catch (error) {
+            const bodyErrorResponse = _chunk5566GNEGcjs.createFarmRequestBodyErrorResponse.call(void 0, error);
+            if (bodyErrorResponse) {
+              await _chunkZ5MZDFX4cjs.sendWebResponse.call(void 0, res, bodyErrorResponse);
+              return;
+            }
+            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" }));
+          }
+        });
+        server.middlewares.use((req, res, next) => {
+          const result = _chunkKBGZ5FD6cjs._runWithAPIRequestRuntime.call(void 0, 
+            {
+              basePath: _nullishCoalesce(basePath, () => ( "/api")),
+              dispatch: async (request) => apiRouterHandler ? apiRouterHandler(request) : Response.json({ error: "Not Found" }, { status: 404 })
+            },
+            () => apiMiddleware(req, res, next)
+          );
+          return Promise.resolve(result).catch((error) => {
+            console.error(
+              `[FARM] Unhandled API error while handling ${req.method || "GET"} ${req.url || "/"}:`,
+              error
+            );
+            if (res.writableEnded) return;
+            if (res.headersSent) {
+              _optionalChain([res, 'access', _7 => _7.destroy, 'optionalCall', _8 => _8(error instanceof Error ? error : new Error(String(error)))]);
+              return;
+            }
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "Internal server error" }));
+          });
+        });
+      };
+    },
+    async handleHotUpdate({ file, server, modules }) {
+      const normalizedFile = _chunkXN2MB4QZcjs.toPosixPath.call(void 0, file);
+      const fileName = normalizedFile.split("/").pop() || "";
+      if (fileName === "routes.ts" || fileName === "routes.tsx" || fileName === "routes.js" || _chunkE7QOEV5Zcjs.isProgrammaticRoutesFileName.call(void 0, fileName)) {
+        log(`Root routes file updated: ${fileName}`);
+        for (const mod of modules) {
+          server.moduleGraph.invalidateModule(mod);
+        }
+        if (await _optionalChain([recoverFailedDiscovery, 'optionalCall', _9 => _9()])) return [];
+        const previousState = snapshotRouteState();
+        try {
+          const routesModule = await _chunk6XFGJBYXcjs.loadFarmDevModule.call(void 0, server, file);
+          removeEndpointsFromFile(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 { getProgrammaticRouteManifest } = await import("./routes.cjs");
+          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) {
+          restoreRouteState(previousState);
+          if (e instanceof _chunkEXHEPWFJcjs.APIRouteConflictError || e instanceof _chunkYTVSWXEZcjs.AmbiguousRouteError) throw e;
+          log(`Root routes.ts HMR failed: ${e.message}`);
+        }
+        return [];
+      }
+      if (normalizedFile.includes("/api/") && fileName.startsWith("route.")) {
+        const shortPath = normalizedFile.split("/api/")[1] || normalizedFile;
+        log(`API route updated: ${shortPath}`);
+        for (const mod of modules) {
+          server.moduleGraph.invalidateModule(mod);
+        }
+        if (await _optionalChain([recoverFailedDiscovery, 'optionalCall', _10 => _10()])) return [];
+        const previousState = snapshotRouteState();
+        try {
+          const path = await import("path");
+          const apiDir = path.join(server.config.root, apiDirFromRoot);
+          const relativePath = path.relative(apiDir, path.dirname(file));
+          const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
+          const fs = await import("fs");
+          if (!fs.existsSync(file)) {
+            removeEndpointsFromFile(file);
+            await createRouter();
+            log(`API route file removed: ${routePath}`);
+            return [];
+          }
+          const routeModule = await _chunk6XFGJBYXcjs.loadFarmDevModule.call(void 0, server, file);
+          removeEndpointsFromFile(file);
+          const availableMethods = [];
+          for (const method of _chunkR2SEZEBCcjs.API_ROUTE_METHODS) {
+            if (!routeModule[method]) continue;
+            availableMethods.push(method);
+            addEndpoint(routePath, file, method, routeModule[method]);
+          }
+          await createRouter();
+          log(`API route reloaded: ${availableMethods.join(", ")} ${routePath}`);
+          log(`API router recreated`);
+        } catch (e) {
+          restoreRouteState(previousState);
+          if (e instanceof _chunkEXHEPWFJcjs.APIRouteConflictError || e instanceof _chunkYTVSWXEZcjs.AmbiguousRouteError) throw e;
+          log(`API route HMR failed: ${e.message}`);
+        }
+        return [];
+      }
+    }
+  };
+}
+
+
+
+exports.farmApiPlugin = farmApiPlugin;