@farm.js/core 0.1.0-beta.13 → 0.1.0-beta.16

package/dist/index.mjs

@@ -9,12 +9,12 @@ import {
 } from "./chunk-VCANOYFI.mjs";
 import {
   build
-} from "./chunk-VSDZEB5M.mjs";
+} from "./chunk-AN3PQVKH.mjs";
 import "./chunk-4S3ORGFA.mjs";
 import "./chunk-SL6HTIOK.mjs";
 import {
   useServerFn
-} from "./chunk-32W4QEJP.mjs";
+} from "./chunk-KFTGPFRD.mjs";
 import {
   cookies,
   headers
@@ -30,7 +30,7 @@ import {
   isFarmDocsRequest,
   loadFarmDocsPage,
   resolveFarmDocsContentDir
-} from "./chunk-OPHK6OJN.mjs";
+} from "./chunk-SLDBGSC3.mjs";
 import "./chunk-V7RBCSDJ.mjs";
 import {
   farmMiddlewarePlugin,
@@ -46,7 +46,7 @@ import {
 } from "./chunk-EJ7T4TPB.mjs";
 import {
   farmApiPlugin
-} from "./chunk-JDEOUK5V.mjs";
+} from "./chunk-6YXKHAFU.mjs";
 import {
   FarmEnvironmentError,
   createClientOnlyFn,
@@ -56,13 +56,13 @@ import {
 import {
   FARM_SERVER_QUERY_SYMBOL,
   createServerQuery
-} from "./chunk-65A7QIKI.mjs";
+} from "./chunk-UMVLB3PN.mjs";
 import {
   FARM_SERVER_FN_SYMBOL,
   _parseServerFnSchema,
   createServerFn,
   createServerMiddleware
-} from "./chunk-VY2UYN5R.mjs";
+} from "./chunk-VPCFICID.mjs";
 import {
   getDeployTargetForPreset,
   getPresetForDeployTarget,
@@ -72,7 +72,7 @@ import {
   resolveDeployConfig,
   resolveDeployOutputPath,
   resolveMigrationsConfig
-} from "./chunk-L2PE36GQ.mjs";
+} from "./chunk-T2KL7VEL.mjs";
 import {
   defineConfig,
   defineFarmConfig
@@ -96,7 +96,7 @@ import {
   createStore,
   useFetcher,
   useMutation
-} from "./chunk-WDU6QXNK.mjs";
+} from "./chunk-UCYWGN2P.mjs";
 import {
   installChunkErrorRecovery,
   isChunkLoadError
@@ -148,7 +148,7 @@ import {
   parseRouteRenderingDirective,
   resolveRouteRenderingConfig,
   resolveRouteRenderingConfigFromFile
-} from "./chunk-Z3YG4OZT.mjs";
+} from "./chunk-OSWV5IJB.mjs";
 import {
   APITypeGenerator
 } from "./chunk-LGHEOHBU.mjs";
@@ -170,7 +170,7 @@ import "./chunk-USWZZUEH.mjs";
 import {
   usePathname,
   useSearchParams
-} from "./chunk-H3TE3LOV.mjs";
+} from "./chunk-XMFTIVJH.mjs";
 import {
   getFarmRedirectError,
   isFarmNotFoundError,
@@ -203,17 +203,22 @@ import "./chunk-7ZVN3YZI.mjs";
 import "./chunk-GY2STC2S.mjs";
 import {
   DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT,
+  FARM_SERVER_FN_FAILURE_SYMBOL,
+  ServerActionError,
   ServerActionRequestError,
+  ServerFnFailure,
   createServerActionRequestErrorResponse,
+  createServerFnTransportError,
   getServerActionExecutionContext,
   getServerActionInvalidations,
   getServerActionSignal,
+  isServerFnFailure,
   prepareServerActionRequest,
   resolveServerActionsConfig,
   runWithServerActionRequest,
   sanitizeServerActionError,
   validateServerActionRequest
-} from "./chunk-UB5UOSHB.mjs";
+} from "./chunk-ZVMV3THA.mjs";
 import {
   createFarmMarkdownRouteModule,
   createFarmMarkdownRouteModuleFromFile,
@@ -332,7 +337,7 @@ import "./chunk-QGOHVJ6J.mjs";
 import {
   APIRouteManager,
   API_ROUTE_METHODS
-} from "./chunk-Z5CQMP54.mjs";
+} from "./chunk-ARRYKOI5.mjs";
 import "./chunk-2ED5Q2GH.mjs";
 import "./chunk-GN72QAIH.mjs";
 import "./chunk-FQYDHKKU.mjs";
@@ -389,12 +394,12 @@ import {
   isWebResponse,
   matchAPIRoute,
   normalizeRouteResponse
-} from "./chunk-PFE6GMNE.mjs";
+} from "./chunk-HMRFYJK6.mjs";
 import {
   getCurrentRequest
 } from "./chunk-RHIFZZUI.mjs";
 import "./chunk-LM2YNO4U.mjs";
-import "./chunk-3WIRO3N7.mjs";
+import "./chunk-BWJC5ZOD.mjs";
 import {
   SPARouter,
   getRouter,
@@ -408,7 +413,7 @@ import {
   usePageState,
   useRouter,
   useScrollRestoration
-} from "./chunk-KLA67WKG.mjs";
+} from "./chunk-B3FFOIWS.mjs";
 import "./chunk-ITN462YM.mjs";
 import {
   FARM_DEPLOYMENT_COOKIE,
@@ -422,12 +427,13 @@ import {
   createFarmDeploymentMismatchResponse,
   createFarmDeploymentRequestHeaders,
   getFarmDeploymentMismatch,
+  getFarmPresetRuntime,
   getFarmRequestDeploymentId,
   getFarmResponseDeploymentId,
   isFarmDeploymentMismatchResponse,
   normalizeFarmDeploymentId,
   withFarmDeploymentResponse
-} from "./chunk-B232I2GP.mjs";
+} from "./chunk-3HIVDX7J.mjs";
 import {
   api,
   defineIntegrationAPI,
@@ -633,6 +639,7 @@ export {
   FARM_DEVTOOLS_LAUNCH_PARAM,
   FARM_DEVTOOLS_PATH,
   FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY,
+  FARM_SERVER_FN_FAILURE_SYMBOL,
   FARM_SERVER_FN_SYMBOL,
   FARM_SERVER_QUERY_SYMBOL,
   FarmClientPluginManager,
@@ -655,7 +662,9 @@ export {
   PluginManager,
   SPARouter,
   ScalarAPIDocumentation,
+  ServerActionError,
   ServerActionRequestError,
+  ServerFnFailure,
   _parseServerFnSchema,
   _runWithAfterNodeResponse,
   _runWithAfterRequest,
@@ -744,6 +753,7 @@ export {
   createServerAPIClient,
   createServerActionRequestErrorResponse,
   createServerFn,
+  createServerFnTransportError,
   createServerMiddleware,
   createServerOnlyFn,
   createServerQuery,
@@ -797,6 +807,7 @@ export {
   getFarmDocsRouteTypeEntries,
   getFarmIntegrationPluginServerRuntime,
   getFarmLayerAliases,
+  getFarmPresetRuntime,
   getFarmRedirectError,
   getFarmRequestDeploymentId,
   getFarmResponseDeploymentId,
@@ -860,6 +871,7 @@ export {
   isProgrammaticRouteManifest,
   isProgrammaticRoutesFileName,
   isSSGModule,
+  isServerFnFailure,
   isWebResponse,
   jsonStream,
   layout,

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/provider.tsx","../src/openapi/scalar-component.tsx","../src/openapi/docs-route.tsx"],"sourcesContent":["import React, { createContext, useContext, type ReactNode } from \"react\";\nimport type { FarmConfig } from \"./types\";\n\ninterface FarmContextValue {\n  config: FarmConfig;\n  basePath: string;\n}\n\nconst FarmContext = createContext<FarmContextValue | null>(null);\n\ninterface FarmProviderProps {\n  children: ReactNode;\n  config: FarmConfig;\n}\n\n/**\n * Farm.js context provider for client-side components\n */\nexport function FarmProvider({ children, config }: FarmProviderProps) {\n  const value: FarmContextValue = {\n    config,\n    basePath: config.basePath || \"/\",\n  };\n\n  return <FarmContext.Provider value={value}>{children}</FarmContext.Provider>;\n}\n\n/**\n * Hook to access Farm.js configuration and utilities\n */\nexport function useFarm(): FarmContextValue {\n  const context = useContext(FarmContext);\n\n  if (!context) {\n    throw new Error(\"useFarm must be used within a FarmProvider\");\n  }\n\n  return context;\n}\n\n/**\n * Hook to get the current base path\n */\nexport function useBasePath(): string {\n  const { basePath } = useFarm();\n  return basePath;\n}\n","import React from \"react\";\n\ninterface ScalarAPIDocumentationProps {\n  spec: any;\n  config?: {\n    theme?: \"default\" | \"purple\" | \"blue\" | \"green\" | \"red\" | \"yellow\";\n    layout?: \"modern\" | \"classic\";\n    showSidebar?: boolean;\n    hideDownloadButton?: boolean;\n    hideTryItPanel?: boolean;\n  };\n}\n\nexport function ScalarAPIDocumentation({ spec, config = {} }: ScalarAPIDocumentationProps) {\n  const [isLoaded, setIsLoaded] = React.useState(false);\n\n  React.useEffect(() => {\n    // Dynamically import Scalar components\n    const loadScalar = async () => {\n      try {\n        // Load Scalar CSS\n        const cssLink = document.createElement(\"link\");\n        cssLink.rel = \"stylesheet\";\n        cssLink.href = \"https://cdn.jsdelivr.net/npm/@scalar/api-reference@latest/dist/style.css\";\n        document.head.appendChild(cssLink);\n\n        // Load Scalar JS\n        const script = document.createElement(\"script\");\n        script.src =\n          \"https://cdn.jsdelivr.net/npm/@scalar/api-reference@latest/dist/browser/standalone.js\";\n        script.onload = () => setIsLoaded(true);\n        document.head.appendChild(script);\n      } catch (error) {\n        console.error(\"Failed to load Scalar:\", error);\n      }\n    };\n\n    loadScalar();\n  }, []);\n\n  React.useEffect(() => {\n    if (isLoaded && window.ScalarApiReference) {\n      // Initialize Scalar\n      const container = document.getElementById(\"scalar-api-reference\");\n      if (container) {\n        window.ScalarApiReference({\n          spec,\n          theme: config.theme || \"default\",\n          layout: config.layout || \"modern\",\n          showSidebar: config.showSidebar !== false,\n          hideDownloadButton: config.hideDownloadButton || false,\n          hideTryItPanel: config.hideTryItPanel || false,\n        });\n      }\n    }\n  }, [isLoaded, spec, config]);\n\n  return (\n    <div className=\"scalar-container\">\n      <div id=\"scalar-api-reference\" style={{ height: \"100vh\", width: \"100%\" }} />\n    </div>\n  );\n}\n\n// Extend window type for Scalar\ndeclare global {\n  interface Window {\n    ScalarApiReference: (config: any) => void;\n  }\n}\n","import React from \"react\";\nimport { ScalarAPIDocumentation } from \"./scalar-component\";\n\ninterface DocsRouteProps {\n  spec: any;\n  config?: any;\n}\n\nexport function DocsRoute({ spec, config }: DocsRouteProps) {\n  return (\n    <html lang=\"en\">\n      <head>\n        <meta charSet=\"utf-8\" />\n        <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n        <link rel=\"icon\" href=\"data:,\" />\n        <title>{config?.title || \"API Documentation\"}</title>\n        <style>{`\n          body {\n            margin: 0;\n            padding: 0;\n            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;\n          }\n          .scalar-container {\n            height: 100vh;\n            width: 100%;\n          }\n        `}</style>\n      </head>\n      <body>\n        <ScalarAPIDocumentation spec={spec} config={config} />\n      </body>\n    </html>\n  );\n}\n"],"mappings":"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","names":["createContext","createContext","React","jsx","React","jsx"]}
+{"version":3,"sources":["../src/provider.tsx","../src/openapi/scalar-component.tsx","../src/openapi/docs-route.tsx"],"sourcesContent":["import React, { createContext, useContext, type ReactNode } from \"react\";\nimport type { FarmConfig } from \"./types\";\n\ninterface FarmContextValue {\n  config: FarmConfig;\n  basePath: string;\n}\n\nconst FarmContext = createContext<FarmContextValue | null>(null);\n\ninterface FarmProviderProps {\n  children: ReactNode;\n  config: FarmConfig;\n}\n\n/**\n * Farm.js context provider for client-side components\n */\nexport function FarmProvider({ children, config }: FarmProviderProps) {\n  const value: FarmContextValue = {\n    config,\n    basePath: config.basePath || \"/\",\n  };\n\n  return <FarmContext.Provider value={value}>{children}</FarmContext.Provider>;\n}\n\n/**\n * Hook to access Farm.js configuration and utilities\n */\nexport function useFarm(): FarmContextValue {\n  const context = useContext(FarmContext);\n\n  if (!context) {\n    throw new Error(\"useFarm must be used within a FarmProvider\");\n  }\n\n  return context;\n}\n\n/**\n * Hook to get the current base path\n */\nexport function useBasePath(): string {\n  const { basePath } = useFarm();\n  return basePath;\n}\n","import React from \"react\";\n\ninterface ScalarAPIDocumentationProps {\n  spec: any;\n  config?: {\n    theme?: \"default\" | \"purple\" | \"blue\" | \"green\" | \"red\" | \"yellow\";\n    layout?: \"modern\" | \"classic\";\n    showSidebar?: boolean;\n    hideDownloadButton?: boolean;\n    hideTryItPanel?: boolean;\n  };\n}\n\nexport function ScalarAPIDocumentation({ spec, config = {} }: ScalarAPIDocumentationProps) {\n  const [isLoaded, setIsLoaded] = React.useState(false);\n\n  React.useEffect(() => {\n    // Dynamically import Scalar components\n    const loadScalar = async () => {\n      try {\n        // Load Scalar CSS\n        const cssLink = document.createElement(\"link\");\n        cssLink.rel = \"stylesheet\";\n        cssLink.href = \"https://cdn.jsdelivr.net/npm/@scalar/api-reference@latest/dist/style.css\";\n        document.head.appendChild(cssLink);\n\n        // Load Scalar JS\n        const script = document.createElement(\"script\");\n        script.src =\n          \"https://cdn.jsdelivr.net/npm/@scalar/api-reference@latest/dist/browser/standalone.js\";\n        script.onload = () => setIsLoaded(true);\n        document.head.appendChild(script);\n      } catch (error) {\n        console.error(\"Failed to load Scalar:\", error);\n      }\n    };\n\n    loadScalar();\n  }, []);\n\n  React.useEffect(() => {\n    if (isLoaded && window.ScalarApiReference) {\n      // Initialize Scalar\n      const container = document.getElementById(\"scalar-api-reference\");\n      if (container) {\n        window.ScalarApiReference({\n          spec,\n          theme: config.theme || \"default\",\n          layout: config.layout || \"modern\",\n          showSidebar: config.showSidebar !== false,\n          hideDownloadButton: config.hideDownloadButton || false,\n          hideTryItPanel: config.hideTryItPanel || false,\n        });\n      }\n    }\n  }, [isLoaded, spec, config]);\n\n  return (\n    <div className=\"scalar-container\">\n      <div id=\"scalar-api-reference\" style={{ height: \"100vh\", width: \"100%\" }} />\n    </div>\n  );\n}\n\n// Extend window type for Scalar\ndeclare global {\n  interface Window {\n    ScalarApiReference: (config: any) => void;\n  }\n}\n","import React from \"react\";\nimport { ScalarAPIDocumentation } from \"./scalar-component\";\n\ninterface DocsRouteProps {\n  spec: any;\n  config?: any;\n}\n\nexport function DocsRoute({ spec, config }: DocsRouteProps) {\n  return (\n    <html lang=\"en\">\n      <head>\n        <meta charSet=\"utf-8\" />\n        <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n        <link rel=\"icon\" href=\"data:,\" />\n        <title>{config?.title || \"API Documentation\"}</title>\n        <style>{`\n          body {\n            margin: 0;\n            padding: 0;\n            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;\n          }\n          .scalar-container {\n            height: 100vh;\n            width: 100%;\n          }\n        `}</style>\n      </head>\n      <body>\n        <ScalarAPIDocumentation spec={spec} config={config} />\n      </body>\n    </html>\n  );\n}\n"],"mappings":"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","names":["createContext","createContext","React","jsx","React","jsx"]}

package/dist/internal/build-runtime.cjs

@@ -4303,6 +4303,13 @@ var init_cache_invalidation = __esm({
   }
 });
 
+// src/server-fn-error.ts
+var init_server_fn_error = __esm({
+  "src/server-fn-error.ts"() {
+    "use strict";
+  }
+});
+
 // src/server-action-security.ts
 function resolveServerActionsConfig(config) {
   const allowedOrigins = (config?.allowedOrigins ?? []).map(normalizeAllowedOriginPattern);
@@ -4396,6 +4403,7 @@ var init_server_action_security = __esm({
     "use strict";
     import_node_async_hooks = require("async_hooks");
     init_cache_invalidation();
+    init_server_fn_error();
     DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = 1e6;
     SERVER_ACTION_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionStorage");
     __name(resolveServerActionsConfig, "resolveServerActionsConfig");
@@ -4865,6 +4873,15 @@ var init_layers = __esm({
 });
 
 // src/deployment.ts
+function getFarmPresetRuntime(preset) {
+  if (preset === "cloudflare" || preset === "cloudflare-pages" || preset === "cloudflare-module" || preset === "netlify-edge" || preset === "vercel-edge" || preset === "deno") {
+    return "edge";
+  }
+  if (preset === "node-server" || preset === "vercel" || preset === "netlify" || preset === "aws-lambda" || preset === "azure" || preset === "firebase" || preset === "bun" || preset === "self-host" || preset === "farm") {
+    return "node";
+  }
+  return "unknown";
+}
 function normalizeFarmDeploymentId(value) {
   if (typeof value !== "string" || value.trim() === "") {
     throw new TypeError("Farm deploymentId must be a non-empty string");
@@ -4940,6 +4957,7 @@ var init_deployment = __esm({
     FARM_DEPLOYMENT_COOKIE = "__farm_deployment";
     FARM_DEPLOYMENT_MISMATCH_CODE = "FARM_DEPLOYMENT_MISMATCH";
     FARM_DEPLOYMENT_MISMATCH_STATUS = 409;
+    __name(getFarmPresetRuntime, "getFarmPresetRuntime");
     __name(normalizeFarmDeploymentId, "normalizeFarmDeploymentId");
     __name(getFarmRequestDeploymentId, "getFarmRequestDeploymentId");
     __name(getFarmDeploymentMismatch, "getFarmDeploymentMismatch");
@@ -16340,6 +16358,13 @@ function routePatternToTsTypeLiterals(pattern) {
 function routePatternToRouteLiteral(pattern) {
   return JSON.stringify(pattern);
 }
+function renderTypeUnion(values) {
+  return values.length <= 1 ? values[0] || "never" : `
+  | ${values.join("\n  | ")}`;
+}
+function renderTypeAlias(name, value) {
+  return `export type ${name} =${value.startsWith("\n") ? "" : " "}${value};`;
+}
 function createRoutePattern(route) {
   if (route.segments.length === 0) return "/";
   return "/" + route.segments.map((seg) => {
@@ -16362,39 +16387,48 @@ async function createRouteTypeDeclarations(options, outPath) {
   const { root, srcDir = "src", extraRoutes = [], suppressLintOnLink = false } = options;
   const sourceRoots = options.sourceRoots ?? [{ name: "project", root, srcDir, layer: false }];
   const patterns = /* @__PURE__ */ new Set();
+  const routeModulePatterns = /* @__PURE__ */ new Set();
   const glob = await import("fast-glob");
   for (const source of sourceRoots) {
     const appDir = path20.join(source.root, source.srcDir, "app");
     if (fs5.existsSync(appDir)) {
-      const pageFiles = await glob.default("**/page.{ts,tsx,js,jsx,md,mdx}", {
-        cwd: appDir,
-        absolute: false
-      });
-      for (const file of pageFiles) {
+      const routeModuleFiles = await glob.default(
+        "**/{page,layout,loading,error}.{ts,tsx,js,jsx,md,mdx}",
+        {
+          cwd: appDir,
+          absolute: false
+        }
+      );
+      for (const file of routeModuleFiles) {
         if (parseRouteSlotFile(file)) continue;
         const route = parseRoutePath(file);
+        const pattern = createRoutePattern(route);
+        routeModulePatterns.add(pattern);
         if (route.type === "page") {
-          const pattern = createRoutePattern(route);
           patterns.add(pattern);
         }
       }
     }
     for (const route of await discoverProgrammaticRoutePaths(source.root, source.srcDir)) {
       patterns.add(route);
+      routeModulePatterns.add(route);
     }
   }
   for (const route of extraRoutes) {
     if (route.startsWith("/")) {
       patterns.add(route);
+      routeModulePatterns.add(route);
     }
   }
   const sortedPatterns = Array.from(patterns).sort();
   const typeLiterals = Array.from(new Set(sortedPatterns.flatMap(routePatternToTsTypeLiterals)));
   const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
-  const routePathType = suppressLintOnLink ? "string" : typeLiterals.length ? typeLiterals.join(" | ") : "never";
-  const routePatternType = suppressLintOnLink ? "string" : patternLiterals.length ? patternLiterals.join(" | ") : "never";
+  const routeModulePatternLiterals = Array.from(routeModulePatterns).sort().map(routePatternToRouteLiteral);
+  const routePathType = suppressLintOnLink ? "string" : renderTypeUnion(typeLiterals);
+  const routePatternType = suppressLintOnLink ? "string" : renderTypeUnion(patternLiterals);
+  const routeModulePatternType = renderTypeUnion(routeModulePatternLiterals);
   const routeTypesImportPath = `./${path20.basename(outPath).replace(/\.d\.ts$/, "")}`;
-  const augmentationBlock = suppressLintOnLink ? "" : `
+  const linkAugmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
   interface LinkDefaultRoute {
     _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
@@ -16418,14 +16452,25 @@ declare module "@farm.js/core/dist/client.js" {
     pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
 }
+`;
+  const routeModuleAugmentationBlock = `
+declare global {
+  namespace FarmJS {
+    interface RouteRegistry {
+      pattern: import(${JSON.stringify(routeTypesImportPath)}).RouteModulePattern;
+    }
+  }
+}
 `;
   const content = `/**
  * Auto-generated route types from src/app.
- * Link href is typed automatically via module augmentation. Regenerated on dev start and when routes change.
+ * Link href and route component props are typed automatically from generated declarations.
+ * Regenerated on dev start and when routes change.
  * Set suppressLintOnLink: true in farm.config.ts to accept any string on Link href.
  */
-export type RoutePath = ${routePathType};
-export type RoutePattern = ${routePatternType};${augmentationBlock}
+${renderTypeAlias("RoutePath", routePathType)}
+${renderTypeAlias("RoutePattern", routePatternType)}
+${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentationBlock}${routeModuleAugmentationBlock}
 `;
   return content;
 }
@@ -16442,6 +16487,8 @@ var init_generate_route_types = __esm({
     __name(routeSegmentsToTsTypeLiteral, "routeSegmentsToTsTypeLiteral");
     __name(routePatternToTsTypeLiterals, "routePatternToTsTypeLiterals");
     __name(routePatternToRouteLiteral, "routePatternToRouteLiteral");
+    __name(renderTypeUnion, "renderTypeUnion");
+    __name(renderTypeAlias, "renderTypeAlias");
     __name(createRoutePattern, "createRoutePattern");
     DEFAULT_OUT_FILE = "farm-routes.d.ts";
     __name(generateRouteTypes, "generateRouteTypes");
@@ -16742,7 +16789,8 @@ async function generateFarmTypeArtifacts(options) {
   const sourceRoots = getFarmSourceRoots({ root, srcDir, layers: options.layers });
   const appDirs = getFarmAppDirectories({ root, srcDir, layers: options.layers });
   const result = {
-    apiRoutes: []
+    apiRoutes: [],
+    stalePaths: []
   };
   const unifiedTypesPath = (0, import_path11.join)(root, srcDir, "farm.d.ts");
   const shouldRefreshUnifiedTypes = shouldGenerateRoutes && !options.routeTypesOutFile || shouldGenerateEnv && !options.envTypesOutFile || shouldGenerateI18n && !options.i18nTypesOutFile;
@@ -16758,22 +16806,29 @@ async function generateFarmTypeArtifacts(options) {
     unifiedSections.push(await createRouteTypeDeclarations(routeOptions, unifiedTypesPath));
     result.routeTypesPath = unifiedTypesPath;
   } else if (shouldGenerateRoutes) {
-    result.routeTypesPath = await generateRouteTypes({
+    const routeOptions = {
       root,
       srcDir,
       outFile: options.routeTypesOutFile,
       extraRoutes: options.extraRoutes || [],
       suppressLintOnLink: options.suppressLintOnLink,
       sourceRoots
-    });
+    };
+    if (options.check) {
+      const routeTypesPath = resolveGeneratedPath(root, srcDir, options.routeTypesOutFile);
+      const content = await createRouteTypeDeclarations(routeOptions, routeTypesPath);
+      checkGeneratedFile(routeTypesPath, content, result.stalePaths);
+      result.routeTypesPath = routeTypesPath;
+    } else {
+      result.routeTypesPath = await generateRouteTypes(routeOptions);
+    }
   }
   if (shouldGenerateApi) {
     const generator = new APITypeGenerator(appDirs);
     const apiRoutes = generator.scanAPIRoutes();
     const apiTypesPath = options.apiTypesOutFile ? (0, import_path11.resolve)(root, options.apiTypesOutFile) : (0, import_path11.join)(root, srcDir, "lib", "api.generated.ts");
     const content = generator.generateAPIRouter(apiRoutes, { outFile: apiTypesPath });
-    (0, import_fs4.mkdirSync)((0, import_path11.dirname)(apiTypesPath), { recursive: true });
-    writeFileIfChanged(apiTypesPath, content);
+    writeOrCheckGeneratedFile(apiTypesPath, content, options.check, result.stalePaths);
     result.apiTypesPath = apiTypesPath;
     result.apiRoutes = apiRoutes;
   }
@@ -16791,36 +16846,63 @@ async function generateFarmTypeArtifacts(options) {
     );
     result.envTypesPath = unifiedTypesPath;
   } else if (shouldGenerateEnv) {
-    result.envTypesPath = await generateEnvTypes({
+    const envOptions = {
       root,
       srcDir,
       outFile: options.envTypesOutFile,
       configPath: options.configPath,
       layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
-    });
+    };
+    if (options.check) {
+      const envTypesPath = resolveGeneratedPath(root, srcDir, options.envTypesOutFile);
+      checkGeneratedFile(
+        envTypesPath,
+        createEnvTypeDeclarations(envOptions, envTypesPath),
+        result.stalePaths
+      );
+      result.envTypesPath = envTypesPath;
+    } else {
+      result.envTypesPath = await generateEnvTypes(envOptions);
+    }
   }
   if (shouldGenerateImages && options.imageTypesOutFile) {
-    result.imageTypesPath = generateFarmImageTypes({
-      root,
-      srcDir,
-      outFile: options.imageTypesOutFile
-    });
+    const imageTypesPath = resolveGeneratedPath(root, srcDir, options.imageTypesOutFile, false);
+    if (options.check) {
+      checkGeneratedFile(imageTypesPath, createFarmImageTypeDeclarations(), result.stalePaths);
+      result.imageTypesPath = imageTypesPath;
+    } else {
+      result.imageTypesPath = generateFarmImageTypes({
+        root,
+        srcDir,
+        outFile: options.imageTypesOutFile
+      });
+    }
   }
   if (shouldRefreshUnifiedTypes && options.i18nConfig?.enabled && !options.i18nTypesOutFile) {
     const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
     unifiedSections.push(renderFarmI18nTypes(options.i18nConfig.locales, signatures));
     result.i18nTypesPath = unifiedTypesPath;
   } else if (shouldGenerateI18n && options.i18nConfig) {
-    result.i18nTypesPath = await generateFarmI18nTypes({
-      root,
-      srcDir,
-      config: options.i18nConfig,
-      outFile: options.i18nTypesOutFile
-    });
+    if (options.check) {
+      const i18nTypesPath = resolveGeneratedPath(root, srcDir, options.i18nTypesOutFile, false);
+      const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
+      checkGeneratedFile(
+        i18nTypesPath,
+        renderFarmI18nTypes(options.i18nConfig.locales, signatures),
+        result.stalePaths
+      );
+      result.i18nTypesPath = i18nTypesPath;
+    } else {
+      result.i18nTypesPath = await generateFarmI18nTypes({
+        root,
+        srcDir,
+        config: options.i18nConfig,
+        outFile: options.i18nTypesOutFile
+      });
+    }
   }
   if (shouldRefreshUnifiedTypes) {
-    (0, import_fs4.mkdirSync)((0, import_path11.dirname)(unifiedTypesPath), { recursive: true });
-    writeFileIfChanged(
+    writeOrCheckGeneratedFile(
       unifiedTypesPath,
       `/**
  * Generated by Farm.js. Do not edit.
@@ -16829,13 +16911,37 @@ async function generateFarmTypeArtifacts(options) {
 
 import "@farm.js/core/image";
 
-${unifiedSections.join("\n")}`
+${unifiedSections.map((section) => section.trimEnd()).join("\n\n")}
+`,
+      options.check,
+      result.stalePaths
     );
     result.typesPath = unifiedTypesPath;
-    removeLegacyTypeArtifacts(root, srcDir);
+    if (options.check) {
+      collectLegacyTypeArtifacts(root, srcDir, result.stalePaths);
+    } else {
+      removeLegacyTypeArtifacts(root, srcDir);
+    }
   }
   return result;
 }
+function resolveGeneratedPath(root, srcDir, outFile, relativeToSrc = true) {
+  if ((0, import_path11.isAbsolute)(outFile)) return (0, import_path11.resolve)(outFile);
+  return (0, import_path11.resolve)(root, relativeToSrc ? (0, import_path11.join)(srcDir, outFile) : outFile);
+}
+function writeOrCheckGeneratedFile(filePath, content, check, stalePaths) {
+  if (check) {
+    checkGeneratedFile(filePath, content, stalePaths);
+    return;
+  }
+  (0, import_fs4.mkdirSync)((0, import_path11.dirname)(filePath), { recursive: true });
+  writeFileIfChanged(filePath, content);
+}
+function checkGeneratedFile(filePath, content, stalePaths) {
+  if (!(0, import_fs4.existsSync)(filePath) || (0, import_fs4.readFileSync)(filePath, "utf8") !== content) {
+    stalePaths.push(filePath);
+  }
+}
 function removeLegacyTypeArtifacts(root, srcDir) {
   for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
     const filePath = (0, import_path11.join)(root, srcDir, fileName);
@@ -16846,6 +16952,13 @@ function removeLegacyTypeArtifacts(root, srcDir) {
     }
   }
 }
+function collectLegacyTypeArtifacts(root, srcDir, stalePaths) {
+  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
+    const filePath = (0, import_path11.join)(root, srcDir, fileName);
+    if (!(0, import_fs4.existsSync)(filePath)) continue;
+    if ((0, import_fs4.readFileSync)(filePath, "utf8").includes(marker)) stalePaths.push(filePath);
+  }
+}
 var import_fs4, import_path11, LEGACY_TYPE_ARTIFACTS;
 var init_type_artifacts = __esm({
   "src/type-artifacts.ts"() {
@@ -16861,6 +16974,9 @@ var init_type_artifacts = __esm({
     init_layers();
     init_write_file_if_changed();
     __name(generateFarmTypeArtifacts, "generateFarmTypeArtifacts");
+    __name(resolveGeneratedPath, "resolveGeneratedPath");
+    __name(writeOrCheckGeneratedFile, "writeOrCheckGeneratedFile");
+    __name(checkGeneratedFile, "checkGeneratedFile");
     LEGACY_TYPE_ARTIFACTS = [
       ["farm-routes.d.ts", "Auto-generated route types"],
       ["farm-env.d.ts", "Auto-generated env types"],
@@ -16868,6 +16984,7 @@ var init_type_artifacts = __esm({
       ["farm-i18n.d.ts", "Generated by Farm.js"]
     ];
     __name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
+    __name(collectLegacyTypeArtifacts, "collectLegacyTypeArtifacts");
   }
 });
 
@@ -16875,7 +16992,7 @@ var init_type_artifacts = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.0-beta.13";
+    version = "0.1.0-beta.16";
   }
 });
 
@@ -29170,6 +29287,7 @@ init_fonts();
 
 // src/route-runtime-manifest.ts
 var import_path8 = __toESM(require("path"));
+init_deployment();
 init_route_runtime();
 init_ssg();
 var FARM_ROUTE_RUNTIME_MANIFEST = "route-runtime-manifest.json";
@@ -29230,10 +29348,15 @@ async function writeFarmRouteRuntimeManifest(directory, manifest) {
 }
 __name(writeFarmRouteRuntimeManifest, "writeFarmRouteRuntimeManifest");
 function validateFarmRouteRuntimeDeployment(manifest, preset) {
-  const runtime = getPresetRuntime(preset);
+  const runtime = getFarmPresetRuntime(preset);
   const warnings = /* @__PURE__ */ new Set();
   for (const route of manifest.routes) {
     if (route.rendering === "static") continue;
+    if (runtime === "unknown" && route.runtime !== "auto") {
+      warnings.add(
+        `Preset "${preset}" has an unknown runtime, so Farm could not verify routes that explicitly require node or edge.`
+      );
+    }
     if (runtime !== "unknown" && route.runtime !== "auto" && route.runtime !== runtime) {
       throw new Error(
         `Route "${route.pattern}" requires the ${route.runtime} runtime, but preset "${preset}" emits ${runtime} functions. Choose a compatible preset or change the route runtime.`
@@ -29253,16 +29376,6 @@ function validateFarmRouteRuntimeDeployment(manifest, preset) {
   return { runtime, warnings: Array.from(warnings) };
 }
 __name(validateFarmRouteRuntimeDeployment, "validateFarmRouteRuntimeDeployment");
-function getPresetRuntime(preset) {
-  if (preset === "cloudflare" || preset === "cloudflare-pages" || preset === "cloudflare-module" || preset === "netlify-edge" || preset === "vercel-edge" || preset === "deno") {
-    return "edge";
-  }
-  if (preset === "node-server" || preset === "vercel" || preset === "netlify" || preset === "aws-lambda" || preset === "azure" || preset === "firebase" || preset === "bun") {
-    return "node";
-  }
-  return "unknown";
-}
-__name(getPresetRuntime, "getPresetRuntime");
 function normalizeManifestSource(root, modulePath) {
   const queryIndex = modulePath.indexOf("?");
   const filePath = queryIndex === -1 ? modulePath : modulePath.slice(0, queryIndex);