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

package/dist/nitro-QO5LV6QK.mjs

@@ -0,0 +1,689 @@
+import {
+  routeRulesToNitroRouteRules
+} from "./chunk-YW7OBE6Q.mjs";
+import {
+  prepareFarmWorkflowsForNitro
+} from "./chunk-XIVV5IWN.mjs";
+import {
+  createFarmCronCloudflareConfig,
+  mergeScheduledTasks,
+  prepareFarmCronForNitro
+} from "./chunk-GXASWWJU.mjs";
+import "./chunk-GQVGIUSN.mjs";
+import {
+  __name
+} from "./chunk-CGILA3WO.mjs";
+
+// src/nitro/index.ts
+import path from "path";
+async function createNitroConfig(config, routeManager, apiRouteManager, serverRenderer, preset = "node-server") {
+  const root = config.root || process.cwd();
+  const srcDir = config.srcDir || "src";
+  const distDir = ".farm";
+  const nitroBuildDir = path.join(root, distDir, ".nitro");
+  const outputDir = path.join(root, distDir, ".output");
+  const serverDir = path.join(nitroBuildDir, "server");
+  const { mkdir, writeFile } = await import("fs/promises");
+  await mkdir(serverDir, { recursive: true });
+  await mkdir(path.join(serverDir, "api"), { recursive: true });
+  await mkdir(path.join(serverDir, "routes"), { recursive: true });
+  const farmWorkflows = await prepareFarmWorkflowsForNitro({
+    ...config,
+    distDir
+  });
+  const farmCron = await prepareFarmCronForNitro({
+    ...config,
+    distDir
+  });
+  const scheduledTasks = mergeScheduledTasks(farmWorkflows.scheduledTasks, farmCron.scheduledTasks);
+  const cloudflareCronConfig = createFarmCronCloudflareConfig(farmCron.jobs);
+  const registryFile = path.join(serverDir, "farm-registry.ts");
+  const routePaths = {};
+  for (const [pattern, entry] of routeManager.getRoutes()) {
+    const bundledPath = entry.modulePath.replace(/.*\/src\/app\//, "").replace(/\.(tsx?|jsx?)$/, ".js");
+    routePaths[pattern] = bundledPath;
+  }
+  const clientManifestPath = path.join(root, distDir, "client", "farm-client-manifest.json");
+  await writeFile(
+    registryFile,
+    `
+// Auto-generated by Farm.js
+// Runtime registry for route managers and renderers
+export const farmRegistry: {
+  apiRouteManager?: any;
+  routeManager?: any;
+  serverRenderer?: any;
+  env?: any;
+  deploymentId?: string;
+  basePath?: string;
+  clientManifest?: any;
+  routePaths?: Record<string, string>;
+} = {
+  env: ${JSON.stringify(config.env || { server: {}, public: {} }, null, 2)},
+  deploymentId: ${JSON.stringify(config.deploymentId)},
+  basePath: ${JSON.stringify(config.basePath)},
+  routePaths: ${JSON.stringify(routePaths, null, 2)},
+};
+`,
+    "utf-8"
+  );
+  const apiHandlerFile = path.join(serverDir, "api", "[...].ts");
+  await mkdir(path.dirname(apiHandlerFile), { recursive: true });
+  await writeFile(
+    apiHandlerFile,
+    `
+// Auto-generated by Farm.js
+// This handler intercepts all /api/* requests
+import { defineEventHandler, getHeaders, readBody, sendWebResponse, setResponseStatus, getRequestURL } from 'h3';
+import type { H3Event } from 'h3';
+import { farmRegistry } from '../farm-registry';
+
+export default defineEventHandler(async (event: H3Event) => {
+  // Get URL using H3's abstraction (works in all environments)
+  const url = getRequestURL(event);
+  const urlPath = url.pathname;
+  
+  // Only handle API routes - for Vercel, Nitro routes /api/* to this handler
+  // According to https://nitro.build/deploy/providers/vercel
+  // This handler should process all /api/* routes
+  if (!urlPath.startsWith('/api/')) {
+    // Return undefined to let Nitro's routing system handle non-API routes
+    return undefined;
+  }
+  
+  // Ensure registry is populated (lazy initialization)
+  // In serverless environments, the registry needs to be initialized at runtime
+  if (!farmRegistry.apiRouteManager) {
+    // Try to initialize from global if available (set during build)
+    if (typeof globalThis !== 'undefined' && (globalThis as any).__FARM_REGISTRY__) {
+      Object.assign(farmRegistry, (globalThis as any).__FARM_REGISTRY__);
+    }
+    // If still not available, try the init function (if it exists)
+    if (!farmRegistry.apiRouteManager && (farmRegistry as any).__INIT__) {
+      (farmRegistry as any).__INIT__();
+    }
+  }
+  
+  const apiRouteManager = farmRegistry.apiRouteManager;
+  if (!apiRouteManager) {
+    console.error('API route manager not initialized. Registry keys:', Object.keys(farmRegistry));
+    setResponseStatus(event, 500);
+    return { error: 'API route manager not initialized. Please check server logs.' };
+  }
+  
+  const startTime = Date.now();
+  const method = event.method || 'GET';
+  const host = url.host || 'localhost';
+  
+  // Log API request (only in development)
+  if (process.env.NODE_ENV === 'development' || !process.env.NODE_ENV) {
+    try {
+      const pc = await import('picocolors');
+      const log = [
+        pc.default.dim('[') + pc.default.bold(pc.default.blue('FARM')) + pc.default.dim(']'),
+        pc.default.dim('[') + pc.default.bold(pc.default.white(method.padEnd(3))) + pc.default.dim(']'),
+        pc.default.cyan('[API]'),
+        pc.default.gray(\`\${url.protocol}//\${host}\${urlPath}\`),
+      ].join(' ');
+      console.log(log);
+    } catch {
+      // picocolors not available, use simple log
+      console.log(\`[FARM] [\${method}] [API] \${urlPath}\`);
+    }
+  }
+  
+  try {
+    // Convert H3 event to Web Request using H3 abstractions
+    const protocol = url.protocol.replace(':', '') || 'http';
+    const host = url.host || 'localhost';
+    const fullUrl = url.toString();
+    
+    const headers = new Headers();
+    const h3Headers = getHeaders(event);
+    
+    for (const [key, value] of Object.entries(h3Headers)) {
+      if (value) {
+        headers.set(key, Array.isArray(value) ? value.join(', ') : String(value));
+      }
+    }
+    
+    // Get body
+    let body: string | undefined;
+    const method = event.method || 'GET';
+    if (method !== 'GET' && method !== 'HEAD') {
+      const bodyData = await readBody(event).catch(() => undefined);
+      if (bodyData) {
+        body = typeof bodyData === 'string' ? bodyData : JSON.stringify(bodyData);
+      }
+    }
+    
+    // Create Web Request
+    const request = new Request(fullUrl, {
+      method,
+      headers,
+      body: body || undefined,
+    });
+    
+    // Call better-call handler
+    const betterCallHandler = apiRouteManager.getHandler();
+    if (!betterCallHandler) {
+      setResponseStatus(event, 404);
+      return { error: 'API handler not found' };
+    }
+    
+    const response = await betterCallHandler(request);
+    
+    // Log API response (only in development)
+    if (process.env.NODE_ENV === 'development' || !process.env.NODE_ENV) {
+      const duration = Date.now() - startTime;
+      const status = response.status;
+      try {
+        const pc = await import('picocolors');
+        let statusColor = pc.default.green;
+        if (status >= 500) statusColor = pc.default.red;
+        else if (status >= 400) statusColor = pc.default.yellow;
+        else if (status >= 300) statusColor = pc.default.cyan;
+
+        const log = [
+          pc.default.dim('[') + pc.default.bold(pc.default.blue('FARM')) + pc.default.dim(']'),
+          status >= 400 ? pc.default.red('\u2717') : pc.default.green('\u2713'),
+          pc.default.cyan('[API]'),
+          pc.default.gray(urlPath),
+          pc.default.dim('-'),
+          statusColor(status.toString()),
+          pc.default.dim(\`(\${duration}ms)\`),
+        ].join(' ');
+        console.log(log);
+      } catch {
+        // picocolors not available, use simple log
+        console.log(\`[FARM] [\${method}] [API] \${urlPath} - \${response.status} (\${duration}ms)\`);
+      }
+    }
+    
+    return sendWebResponse(response);
+  } catch (error: any) {
+    console.error('API handler error:', error);
+    setResponseStatus(event, 500);
+    return {
+      error: error.message || 'Internal Server Error',
+    };
+  }
+});
+`,
+    "utf-8"
+  );
+  const ssrHandlerFile = path.join(serverDir, "routes", "[...].ts");
+  await mkdir(path.dirname(ssrHandlerFile), { recursive: true });
+  await writeFile(
+    ssrHandlerFile,
+    `
+// Auto-generated by Farm.js
+// This handler handles all page routes (SSR)
+import { defineEventHandler, setResponseStatus, getRequestURL, setHeader, getHeaders, readBody, sendWebResponse, setCookie } from 'h3';
+import type { H3Event } from 'h3';
+import { farmRegistry } from '../farm-registry';
+import React from 'react';
+import { renderToString } from 'react-dom/server';
+
+export default defineEventHandler(async (event: H3Event) => {
+  try {
+    // Ensure registry is populated (lazy initialization)
+    // In serverless environments, the registry needs to be initialized at runtime
+    if (!farmRegistry.routeManager || !farmRegistry.serverRenderer) {
+      // Try to initialize from global if available (set during build)
+      if (typeof globalThis !== 'undefined' && (globalThis as any).__FARM_REGISTRY__) {
+        Object.assign(farmRegistry, (globalThis as any).__FARM_REGISTRY__);
+      }
+      // If still not available, try the init function (if it exists)
+      if ((!farmRegistry.routeManager || !farmRegistry.serverRenderer) && (farmRegistry as any).__INIT__) {
+        (farmRegistry as any).__INIT__();
+      }
+    }
+    
+    const routeManager = farmRegistry.routeManager;
+    const serverRenderer = farmRegistry.serverRenderer;
+    
+    if (!routeManager || !serverRenderer) {
+      console.error('Route manager or renderer not initialized. Registry keys:', Object.keys(farmRegistry));
+      setResponseStatus(event, 500);
+      setHeader(event, 'Content-Type', 'text/html; charset=utf-8');
+      return '<!DOCTYPE html><html><head><title>Error</title></head><body><h1>500 Internal Server Error</h1><p>Route manager or renderer not initialized. Please check server logs.</p></body></html>';
+    }
+    
+    // Get URL from H3 event
+    const url = getRequestURL(event);
+    const pathname = url.pathname;
+    const redirectMatch = routeManager.matchRedirect(pathname);
+    if (redirectMatch) {
+      setResponseStatus(event, redirectMatch.statusCode);
+      setHeader(event, 'Location', redirectMatch.destination);
+      return \`Redirecting to \${redirectMatch.destination}\`;
+    }
+    const apiRouteManager = farmRegistry.apiRouteManager;
+
+    if (apiRouteManager?.matchRoute(pathname)) {
+      const handler = apiRouteManager.getHandler();
+      if (!handler) {
+        setResponseStatus(event, 404);
+        return { error: 'API handler not found' };
+      }
+
+      const headers = new Headers();
+      const h3Headers = getHeaders(event);
+      for (const [key, value] of Object.entries(h3Headers)) {
+        if (value) {
+          headers.set(key, Array.isArray(value) ? value.join(', ') : String(value));
+        }
+      }
+
+      let body: string | undefined;
+      const method = event.method || 'GET';
+      if (method !== 'GET' && method !== 'HEAD') {
+        const bodyData = await readBody(event).catch(() => undefined);
+        if (bodyData) {
+          body = typeof bodyData === 'string' ? bodyData : JSON.stringify(bodyData);
+        }
+      }
+
+      const response = await handler(new Request(url.toString(), {
+        method,
+        headers,
+        body: body || undefined,
+      }));
+
+      return sendWebResponse(response);
+    }
+
+    // Skip API routes - let the API handler process them
+    if (pathname.startsWith('/api/')) {
+      // Return undefined to let Nitro's API handler process
+      return undefined;
+    }
+    
+    // Skip static assets - let Nitro serve them
+    // Only skip if it's clearly a static file (has extension and not in root)
+    if (pathname.startsWith('/assets/') || (pathname.includes('.') && !pathname.startsWith('/api/'))) {
+      // Check if it's a static file by extension
+      const staticExtensions = ['.js', '.css', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.woff', '.woff2', '.ttf', '.eot'];
+      const hasStaticExtension = staticExtensions.some(ext => pathname.toLowerCase().endsWith(ext));
+      if (hasStaticExtension) {
+        return; // Let Nitro's static file handler process
+      }
+    }
+    
+    // Try to use Node.js req/res if available (for node-server preset)
+    if (event.node && event.node.req && event.node.res) {
+      await serverRenderer.renderPage(event.node.req as any, event.node.res as any);
+      return undefined; // Response already sent
+    }
+
+    if (farmRegistry.deploymentId) {
+      setHeader(event, 'x-farm-deployment-id', farmRegistry.deploymentId);
+      setCookie(event, '__farm_deployment', farmRegistry.deploymentId, {
+        httpOnly: true,
+        sameSite: 'lax',
+        secure: url.protocol === 'https:',
+        path: farmRegistry.basePath || '/',
+      });
+    }
+    
+    // For serverless (Vercel), render to string and send HTML
+    try {
+      // Match route
+      const { route, params, layouts } = routeManager.matchRoute(pathname);
+      
+      if (!route) {
+        setResponseStatus(event, 404);
+        setHeader(event, 'Content-Type', 'text/html; charset=utf-8');
+        return '<!DOCTYPE html><html><head><title>404 Not Found</title></head><body><h1>404 Not Found</h1></body></html>';
+      }
+      
+      // Get search params
+      const searchParamsObject: Record<string, string | string[] | undefined> = {};
+      url.searchParams.forEach((value, key) => {
+        const existing = searchParamsObject[key];
+        if (existing) {
+          if (Array.isArray(existing)) {
+            existing.push(value);
+          } else {
+            searchParamsObject[key] = [existing, value];
+          }
+        } else {
+          searchParamsObject[key] = value;
+        }
+      });
+      
+      // Load route module - in production, use bundled SSR output
+      // Get bundled path from registry or construct it
+      let routeModule;
+      const routePaths = farmRegistry.routePaths || {};
+      const bundledPath = routePaths[pathname] || route.modulePath
+        .replace(/.*\\/src\\/app\\//, '')
+        .replace(/\\.(tsx?|jsx?)$/, '.js');
+      
+      try {
+        // Try to load from bundled SSR output (copied to Nitro's server/farm directory)
+        // Nitro bundles everything, so we need to use the correct import path
+        routeModule = await import('./farm/' + bundledPath);
+      } catch (importError) {
+        // Fallback: try route manager's load method (for node-server preset)
+        try {
+          routeModule = await routeManager.loadRouteModule(route.modulePath);
+        } catch (loadError) {
+          // Last resort: try just the filename
+          const bundledName = bundledPath.split('/').pop() || 'page.js';
+          try {
+            routeModule = await import('./farm/' + bundledName);
+          } catch {
+            throw new Error(\`Failed to load route module: \${route.modulePath}. Tried: ./farm/\${bundledPath}, ./farm/\${bundledName}\`);
+          }
+        }
+      }
+      
+      if (!routeModule.default) {
+        throw new Error(\`Route module \${route.modulePath} does not export a default component\`);
+      }
+      
+      // Load layout modules
+      const layoutModules = await Promise.all(
+        layouts.map(async (layout) => {
+          const bundledPath = layout.modulePath
+            .replace(/.*\\/src\\/app\\//, '')
+            .replace(/\\.(tsx?|jsx?)$/, '.js');
+          
+          try {
+            // Try to load from bundled SSR output
+            return await import('./farm/' + bundledPath);
+          } catch {
+            // Fallback to route manager's load method
+            try {
+              return await routeManager.loadLayoutModule(layout.modulePath);
+            } catch {
+              // Last resort: try just the filename
+              const bundledName = bundledPath.split('/').pop() || 'layout.js';
+              try {
+                return await import('./farm/' + bundledName);
+              } catch {
+                // Return a dummy layout if all fails
+                return { default: ({ children }: any) => children };
+              }
+            }
+          }
+        })
+      );
+      
+      // Create page props
+      const rawPageProps = {
+        params,
+        searchParams: Promise.resolve(searchParamsObject),
+        path: pathname,
+      };
+      const pageProps = routeModule.__farmResolveRouteProps
+        ? await routeModule.__farmResolveRouteProps(rawPageProps)
+        : (() => {
+            const routeSchemas = routeModule.__farmRouteParsesProps
+              ? {}
+              : routeModule.__farmRouteSchemas || {};
+            const parsedParams = routeSchemas.params?.parse
+              ? routeSchemas.params.parse(params)
+              : params;
+            const parsedSearch = routeSchemas.search?.parse
+              ? routeSchemas.search.parse(searchParamsObject)
+              : searchParamsObject;
+            return {
+              ...rawPageProps,
+              params: parsedParams,
+              search: parsedSearch,
+              searchParams: Promise.resolve(parsedSearch),
+            };
+          })();
+      
+      // Create page element
+      const PageComponent = routeModule.default;
+      let pageElement;
+      if (PageComponent.constructor.name === "AsyncFunction" || PageComponent.toString().includes("async")) {
+        pageElement = await PageComponent(pageProps);
+      } else {
+        pageElement = React.createElement(PageComponent, pageProps);
+      }
+      
+      // Wrap with layouts
+      for (let i = layoutModules.length - 1; i >= 0; i--) {
+        const layoutModule = layoutModules[i];
+        const LayoutComponent = layoutModule.default;
+        pageElement = React.createElement(LayoutComponent, {
+          children: pageElement,
+          params,
+        } as any);
+      }
+      
+      // Render to string
+      const html = renderToString(pageElement);
+      
+      // Get client script path from manifest
+      const clientManifest = farmRegistry.clientManifest || {};
+      // Find the client script for this route - check manifest structure
+      let clientScript = '/assets/page-wbYjx1yQ.js'; // Default fallback
+      if (clientManifest && typeof clientManifest === 'object') {
+        // Manifest structure: { "assets/page-xxx.js": { ... } }
+        const manifestEntry = Object.values(clientManifest).find((entry: any) => 
+          entry && entry.name === 'page'
+        ) as any;
+        if (manifestEntry && manifestEntry.chunks && manifestEntry.chunks[0]) {
+          clientScript = '/' + manifestEntry.chunks[0];
+        } else if (Object.keys(clientManifest).length > 0) {
+          // Fallback to first asset in manifest
+          clientScript = '/' + Object.keys(clientManifest)[0];
+        }
+      }
+      
+      // Build full HTML
+      const serializedDeploymentId = JSON.stringify(farmRegistry.deploymentId || '').replace(/</g, '\\u003c');
+      const fullHtml = \`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link rel="icon" href="data:,">
+  <title>Farm.js App</title>
+  <script>
+    window.__FARM_DEPLOYMENT_ID__ = \${serializedDeploymentId};
+    window.__FARM_PROPS__ = \${JSON.stringify(pageProps)};
+    window.__FARM_PATH__ = \${JSON.stringify(pathname)};
+  </script>
+</head>
+<body>
+  <div id="root">\${html}</div>
+  <script type="module" src="\${clientScript}"></script>
+</body>
+</html>\`;
+      
+      setHeader(event, 'Content-Type', 'text/html; charset=utf-8');
+      return fullHtml;
+      
+    } catch (renderError: any) {
+      setResponseStatus(event, 500);
+      setHeader(event, 'Content-Type', 'text/html; charset=utf-8');
+      return \`<!DOCTYPE html><html><head><title>Error</title></head><body><h1>Error</h1><p>\${renderError.message || 'Internal Server Error'}</p></body></html>\`;
+    }
+  } catch (error: any) {
+    setResponseStatus(event, 500);
+    setHeader(event, 'Content-Type', 'text/html; charset=utf-8');
+    return \`<!DOCTYPE html><html><head><title>Error</title></head><body><h1>Error</h1><p>\${error.message || 'Internal Server Error'}</p></body></html>\`;
+  }
+});
+`,
+    "utf-8"
+  );
+  const nitroConfig = {
+    preset,
+    // rootDir must be the project root for Nitro to correctly resolve paths
+    rootDir: root,
+    // srcDir should point to where source files are (for scanning)
+    // But we're using scanDirs to point to our server directory
+    srcDir: root,
+    // buildDir is where Nitro builds (temporary working directory)
+    buildDir: nitroBuildDir,
+    // output.dir is where the final deployable output goes
+    // This ensures everything ends up in .farm/.output
+    compatibilityDate: "2024-12-01",
+    // Vercel-specific configuration
+    ...preset === "vercel" ? {
+      vercel: {
+        // Ensure proper function configuration
+        config: {}
+      }
+    } : {},
+    // Tell Nitro to scan the server directory we created
+    // This ensures our handlers are discovered by Nitro
+    scanDirs: [serverDir],
+    tasks: {
+      ...farmWorkflows.tasks,
+      ...farmCron.tasks
+    },
+    scheduledTasks,
+    ...preset === "cloudflare-module" && cloudflareCronConfig ? {
+      cloudflare: cloudflareCronConfig
+    } : {},
+    handlers: farmWorkflows.handlerPath ? [
+      {
+        route: `${config.workflows.route}/**`,
+        handler: farmWorkflows.handlerPath
+      }
+    ] : [],
+    // Route rules for Vercel
+    routeRules: {
+      "/api/**": {
+        cors: true,
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "*",
+          "Access-Control-Allow-Headers": "*"
+        }
+      },
+      "/**": {
+        prerender: false
+      },
+      ...routeRulesToNitroRouteRules(config.routeRules)
+    },
+    // // Exclude certain directories from scanning
+    // scanDirsExclude: [
+    //   '**/node_modules/**',
+    //   '**/.git/**',
+    //   '**/.output/**',
+    //   '**/.nitro/**',
+    // ],
+    output: {
+      // CRITICAL: All output MUST go to .farm/.output (NOT .nitro/.output)
+      // This ensures consistency and that deployment always uses .farm/.output
+      // By explicitly setting dir, serverDir, and publicDir, we prevent Nitro
+      // from creating its own .output directory inside .nitro
+      dir: outputDir,
+      // .farm/.output
+      serverDir: path.join(outputDir, "server"),
+      // .farm/.output/server
+      publicDir: path.join(outputDir, "public")
+      // .farm/.output/public
+    },
+    // Use Nitro hooks to populate the runtime registry
+    // This allows us to pass complex objects (route managers, renderers) at runtime
+    hooks: {
+      "build:before": /* @__PURE__ */ __name(async (nitro) => {
+        const registryPath = path.join(serverDir, "farm-registry.ts");
+        const { farmRegistry } = await import(
+          /* @vite-ignore */
+          registryPath
+        );
+        const routePaths2 = {};
+        for (const [pattern, entry] of routeManager.getRoutes()) {
+          const bundledPath = entry.modulePath.replace(/.*\/src\/app\//, "").replace(/\.(tsx?|jsx?)$/, ".js");
+          routePaths2[pattern] = bundledPath;
+        }
+        farmRegistry.routePaths = routePaths2;
+        try {
+          const clientManifestPath2 = path.join(
+            root,
+            distDir,
+            "client",
+            "farm-client-manifest.json"
+          );
+          const { readFile } = await import("fs/promises");
+          const manifestContent = await readFile(clientManifestPath2, "utf-8");
+          farmRegistry.clientManifest = JSON.parse(manifestContent);
+        } catch (error) {
+          farmRegistry.clientManifest = {};
+        }
+        farmRegistry.__INIT__ = () => {
+          farmRegistry.apiRouteManager = apiRouteManager;
+          farmRegistry.routeManager = routeManager;
+          farmRegistry.serverRenderer = serverRenderer;
+          farmRegistry.env = config.env || { server: {}, public: {} };
+          farmRegistry.deploymentId = config.deploymentId;
+          farmRegistry.basePath = config.basePath;
+        };
+        if (typeof globalThis !== "undefined") {
+          globalThis.__FARM_REGISTRY__ = {
+            apiRouteManager,
+            routeManager,
+            serverRenderer,
+            env: farmRegistry.env,
+            deploymentId: farmRegistry.deploymentId,
+            basePath: farmRegistry.basePath,
+            clientManifest: farmRegistry.clientManifest,
+            routePaths: farmRegistry.routePaths
+          };
+        }
+      }, "build:before")
+    },
+    // API base URL (default is /api)
+    apiBaseURL: "/api",
+    // Include public directory and client build
+    publicAssets: [
+      {
+        baseURL: "/",
+        dir: path.join(root, "public")
+      },
+      // Include client build assets
+      {
+        baseURL: "/",
+        dir: path.join(root, distDir, "client")
+      }
+    ],
+    // Build configuration
+    minify: process.env.NODE_ENV === "production",
+    sourceMap: true,
+    // Bundle all dependencies to avoid workspace issues on Vercel
+    // This ensures all farm package code is bundled into the serverless function
+    // so it doesn't need to resolve workspace dependencies at runtime
+    // This is similar to how Next.js and Nuxt bundle their core packages
+    // bundle: true,
+    // External dependencies that should NOT be bundled (provided by runtime)
+    // We exclude React/ReactDOM to reduce bundle size (they're in node_modules)
+    externals: {
+      external: ["react", "react-dom"]
+      // Keep React external - it's in the serverless function's node_modules
+      // This reduces bundle size significantly
+    },
+    // Runtime config
+    runtimeConfig: {
+      public: {}
+    },
+    // Experimental features
+    experimental: {
+      tasks: farmWorkflows.workflows.length > 0 || farmCron.jobs.length > 0,
+      wasm: false
+      // Disable for now to avoid issues
+    }
+  };
+  return nitroConfig;
+}
+__name(createNitroConfig, "createNitroConfig");
+function getNitroPreset(preset) {
+  return preset || "node-server";
+}
+__name(getNitroPreset, "getNitroPreset");
+export {
+  createNitroConfig,
+  getNitroPreset
+};
+//# sourceMappingURL=nitro-QO5LV6QK.mjs.map