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

package/dist/index.cjs

@@ -4842,6 +4842,72 @@ var init_cache_invalidation = __esm({
   }
 });
 
+// src/server-fn-error.ts
+function isServerFnFailure(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate[FARM_SERVER_FN_FAILURE_SYMBOL] === true && candidate.name === "ServerFnFailure" && typeof candidate.code === "string" && Number.isInteger(candidate.status) && (candidate.status ?? 0) >= 400 && (candidate.status ?? 0) <= 599;
+}
+function serializeServerFnFailure(value) {
+  if (!isServerFnFailure(value)) return null;
+  return {
+    name: "ServerFnFailure",
+    message: value.message,
+    code: value.code,
+    status: value.status,
+    data: value.data
+  };
+}
+function createServerFnTransportError(value) {
+  if (isSerializedServerFnFailure(value)) {
+    return new ServerFnFailure(value.code, value.data, {
+      status: value.status,
+      message: value.message
+    });
+  }
+  const message = value && typeof value === "object" && "message" in value && typeof value.message === "string" ? value.message : "Server function failed";
+  return new ServerActionError(message);
+}
+function isSerializedServerFnFailure(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate.name === "ServerFnFailure" && typeof candidate.message === "string" && typeof candidate.code === "string" && Number.isInteger(candidate.status) && (candidate.status ?? 0) >= 400 && (candidate.status ?? 0) <= 599 && "data" in candidate;
+}
+var FARM_SERVER_FN_FAILURE_SYMBOL, _ServerFnFailure, ServerFnFailure, _ServerActionError, ServerActionError;
+var init_server_fn_error = __esm({
+  "src/server-fn-error.ts"() {
+    "use strict";
+    FARM_SERVER_FN_FAILURE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn.failure");
+    _ServerFnFailure = class _ServerFnFailure extends Error {
+      constructor(code, data, options) {
+        super(options.message);
+        this.name = "ServerFnFailure";
+        this.code = code;
+        this.data = data;
+        this.status = options.status;
+        Object.defineProperty(this, FARM_SERVER_FN_FAILURE_SYMBOL, {
+          value: true,
+          enumerable: false
+        });
+      }
+    };
+    __name(_ServerFnFailure, "ServerFnFailure");
+    ServerFnFailure = _ServerFnFailure;
+    _ServerActionError = class _ServerActionError extends Error {
+      constructor(message = "Server function failed") {
+        super(message);
+        this.name = "ServerActionError";
+      }
+    };
+    __name(_ServerActionError, "ServerActionError");
+    ServerActionError = _ServerActionError;
+    __name(isServerFnFailure, "isServerFnFailure");
+    __name(serializeServerFnFailure, "serializeServerFnFailure");
+    __name(createServerFnTransportError, "createServerFnTransportError");
+    __name(isSerializedServerFnFailure, "isSerializedServerFnFailure");
+  }
+});
+
 // src/server-action-security.ts
 function resolveServerActionsConfig(config) {
   const allowedOrigins = (config?.allowedOrigins ?? []).map(normalizeAllowedOriginPattern);
@@ -4928,7 +4994,9 @@ function createServerActionRequestErrorResponse(error) {
     headers: headers2
   });
 }
-function sanitizeServerActionError(_error) {
+function sanitizeServerActionError(error) {
+  const declaredFailure = serializeServerFnFailure(error);
+  if (declaredFailure) return declaredFailure;
   return {
     name: "ServerActionError",
     message: "Server function failed"
@@ -5227,6 +5295,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;
     _ServerActionRequestError = class _ServerActionRequestError extends Error {
       constructor(code, status, message) {
@@ -10252,6 +10321,15 @@ var init_deferred = __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");
@@ -10370,6 +10448,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");
     _FarmDeploymentMismatchError = class _FarmDeploymentMismatchError extends Error {
       constructor(clientDeploymentId, serverDeploymentId) {
         super("The application was updated while this page was open. Refresh before trying again.");
@@ -15968,13 +16047,13 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
   }
   const middleware2 = normalizeEndpointMiddleware(options.middleware);
   const errors = normalizeEndpointErrors(options.errors);
-  const fail = createEndpointFail(errors);
+  const error = createEndpointErrorHandler(errors);
   const wrappedHandler = /* @__PURE__ */ __name((async (ctx) => {
     const execution = await runEndpointMiddleware(
       middleware2,
       ctx,
       handler,
-      fail,
+      error,
       options.invalidates
     );
     return execution.result;
@@ -15994,7 +16073,7 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
   endpoint2.__method = options.method || "GET";
   endpoint2.__autoPath = !path32;
   endpoint2.__handler = wrappedHandler;
-  endpoint2.__farmInvoke = (ctx) => runEndpointMiddleware(middleware2, ctx, handler, fail, options.invalidates);
+  endpoint2.__farmInvoke = (ctx) => runEndpointMiddleware(middleware2, ctx, handler, error, options.invalidates);
   endpoint2.__middleware = middleware2;
   endpoint2.__sourceHandler = handler;
   endpoint2.__invalidates = options.invalidates;
@@ -16025,8 +16104,9 @@ function normalizeEndpointErrors(definitions) {
     if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
       throw new TypeError(`Endpoint error "${code}" status must be an integer between 400 and 599`);
     }
-    if (!definition.schema || typeof definition.schema.parse !== "function") {
-      throw new TypeError(`Endpoint error "${code}" requires a schema with parse()`);
+    const dataSchema = resolveEndpointErrorSchema(definition);
+    if (!dataSchema || typeof dataSchema.parse !== "function") {
+      throw new TypeError(`Endpoint error "${code}" requires a data schema with parse()`);
     }
     if (definition.message !== void 0 && typeof definition.message !== "string") {
       throw new TypeError(`Endpoint error "${code}" message must be a string`);
@@ -16035,13 +16115,19 @@ function normalizeEndpointErrors(definitions) {
   }
   return Object.freeze(normalized);
 }
-function createEndpointFail(definitions) {
+function resolveEndpointErrorSchema(definition) {
+  if (definition.data && definition.schema) {
+    throw new TypeError("Endpoint errors cannot define both data and schema");
+  }
+  return definition.data ?? definition.schema;
+}
+function createEndpointErrorHandler(definitions) {
   return ((code, data) => {
     const definition = definitions[code];
     if (!definition) {
       throw new TypeError(`Endpoint error "${code}" is not declared`);
     }
-    const parsed = definition.schema.parse(data);
+    const parsed = resolveEndpointErrorSchema(definition).parse(data);
     throw new EndpointFailure(code, parsed, {
       status: definition.status,
       message: definition.message ?? "Request failed"
@@ -16061,7 +16147,7 @@ function normalizeEndpointMiddleware(middleware2) {
   }
   return Object.freeze(normalized);
 }
-async function runEndpointMiddleware(middleware2, handlerContext, handler, fail, invalidations) {
+async function runEndpointMiddleware(middleware2, handlerContext, handler, error, invalidations) {
   let context = createInitialEndpointContext(handlerContext.context);
   for (let index = 0; index < middleware2.length; index++) {
     const result2 = await middleware2[index]({ ...handlerContext, context });
@@ -16089,7 +16175,7 @@ async function runEndpointMiddleware(middleware2, handlerContext, handler, fail,
     }
     context = mergeEndpointContext(context, result2, index);
   }
-  const result = await handler({ ...handlerContext, context, fail });
+  const result = await handler({ ...handlerContext, context, error, fail: error });
   return {
     result,
     context,
@@ -16219,7 +16305,8 @@ var init_endpoint = __esm({
     EMPTY_ENDPOINT_CONTEXT = Object.freeze(/* @__PURE__ */ Object.create(null));
     UNSAFE_ENDPOINT_CONTEXT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
     __name(normalizeEndpointErrors, "normalizeEndpointErrors");
-    __name(createEndpointFail, "createEndpointFail");
+    __name(resolveEndpointErrorSchema, "resolveEndpointErrorSchema");
+    __name(createEndpointErrorHandler, "createEndpointErrorHandler");
     __name(normalizeEndpointMiddleware, "normalizeEndpointMiddleware");
     __name(runEndpointMiddleware, "runEndpointMiddleware");
     __name(applyEndpointInvalidations, "applyEndpointInvalidations");
@@ -17824,6 +17911,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(route2) {
   if (route2.segments.length === 0) return "/";
   return "/" + route2.segments.map((seg) => {
@@ -17846,39 +17940,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 = path14.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 route2 = parseRoutePath(file);
+        const pattern = createRoutePattern(route2);
+        routeModulePatterns.add(pattern);
         if (route2.type === "page") {
-          const pattern = createRoutePattern(route2);
           patterns.add(pattern);
         }
       }
     }
     for (const route2 of await discoverProgrammaticRoutePaths(source.root, source.srcDir)) {
       patterns.add(route2);
+      routeModulePatterns.add(route2);
     }
   }
   for (const route2 of extraRoutes) {
     if (route2.startsWith("/")) {
       patterns.add(route2);
+      routeModulePatterns.add(route2);
     }
   }
   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 = `./${path14.basename(outPath).replace(/\.d\.ts$/, "")}`;
-  const augmentationBlock = suppressLintOnLink ? "" : `
+  const linkAugmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
   interface LinkDefaultRoute {
     _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
@@ -17902,14 +18005,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;
 }
@@ -17926,6 +18040,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");
@@ -18226,7 +18342,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_path8.join)(root, srcDir, "farm.d.ts");
   const shouldRefreshUnifiedTypes = shouldGenerateRoutes && !options.routeTypesOutFile || shouldGenerateEnv && !options.envTypesOutFile || shouldGenerateI18n && !options.i18nTypesOutFile;
@@ -18242,22 +18359,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_path8.resolve)(root, options.apiTypesOutFile) : (0, import_path8.join)(root, srcDir, "lib", "api.generated.ts");
     const content = generator.generateAPIRouter(apiRoutes, { outFile: apiTypesPath });
-    (0, import_fs4.mkdirSync)((0, import_path8.dirname)(apiTypesPath), { recursive: true });
-    writeFileIfChanged(apiTypesPath, content);
+    writeOrCheckGeneratedFile(apiTypesPath, content, options.check, result.stalePaths);
     result.apiTypesPath = apiTypesPath;
     result.apiRoutes = apiRoutes;
   }
@@ -18275,36 +18399,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_path8.dirname)(unifiedTypesPath), { recursive: true });
-    writeFileIfChanged(
+    writeOrCheckGeneratedFile(
       unifiedTypesPath,
       `/**
  * Generated by Farm.js. Do not edit.
@@ -18313,13 +18464,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_path8.isAbsolute)(outFile)) return (0, import_path8.resolve)(outFile);
+  return (0, import_path8.resolve)(root, relativeToSrc ? (0, import_path8.join)(srcDir, outFile) : outFile);
+}
+function writeOrCheckGeneratedFile(filePath, content, check, stalePaths) {
+  if (check) {
+    checkGeneratedFile(filePath, content, stalePaths);
+    return;
+  }
+  (0, import_fs4.mkdirSync)((0, import_path8.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_path8.join)(root, srcDir, fileName);
@@ -18330,6 +18505,13 @@ function removeLegacyTypeArtifacts(root, srcDir) {
     }
   }
 }
+function collectLegacyTypeArtifacts(root, srcDir, stalePaths) {
+  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
+    const filePath = (0, import_path8.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_path8, LEGACY_TYPE_ARTIFACTS;
 var init_type_artifacts = __esm({
   "src/type-artifacts.ts"() {
@@ -18345,6 +18527,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"],
@@ -18352,6 +18537,7 @@ var init_type_artifacts = __esm({
       ["farm-i18n.d.ts", "Generated by Farm.js"]
     ];
     __name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
+    __name(collectLegacyTypeArtifacts, "collectLegacyTypeArtifacts");
   }
 });
 
@@ -18708,7 +18894,7 @@ var init_environment_vite = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.0-beta.13";
+    version = "0.1.0-beta.16";
   }
 });
 
@@ -31927,6 +32113,7 @@ __export(src_exports, {
   FARM_DEVTOOLS_LAUNCH_PARAM: () => FARM_DEVTOOLS_LAUNCH_PARAM,
   FARM_DEVTOOLS_PATH: () => FARM_DEVTOOLS_PATH,
   FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY: () => FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY,
+  FARM_SERVER_FN_FAILURE_SYMBOL: () => FARM_SERVER_FN_FAILURE_SYMBOL,
   FARM_SERVER_FN_SYMBOL: () => FARM_SERVER_FN_SYMBOL,
   FARM_SERVER_QUERY_SYMBOL: () => FARM_SERVER_QUERY_SYMBOL,
   FarmClientPluginManager: () => FarmClientPluginManager,
@@ -31949,7 +32136,9 @@ __export(src_exports, {
   PluginManager: () => PluginManager,
   SPARouter: () => SPARouter,
   ScalarAPIDocumentation: () => ScalarAPIDocumentation,
+  ServerActionError: () => ServerActionError,
   ServerActionRequestError: () => ServerActionRequestError,
+  ServerFnFailure: () => ServerFnFailure,
   _parseServerFnSchema: () => _parseServerFnSchema,
   _runWithAfterNodeResponse: () => _runWithAfterNodeResponse,
   _runWithAfterRequest: () => _runWithAfterRequest,
@@ -32038,6 +32227,7 @@ __export(src_exports, {
   createServerAPIClient: () => createServerAPIClient,
   createServerActionRequestErrorResponse: () => createServerActionRequestErrorResponse,
   createServerFn: () => createServerFn,
+  createServerFnTransportError: () => createServerFnTransportError,
   createServerMiddleware: () => createServerMiddleware,
   createServerOnlyFn: () => createServerOnlyFn,
   createServerQuery: () => createServerQuery,
@@ -32091,6 +32281,7 @@ __export(src_exports, {
   getFarmDocsRouteTypeEntries: () => getFarmDocsRouteTypeEntries,
   getFarmIntegrationPluginServerRuntime: () => getFarmIntegrationPluginServerRuntime,
   getFarmLayerAliases: () => getFarmLayerAliases,
+  getFarmPresetRuntime: () => getFarmPresetRuntime,
   getFarmRedirectError: () => getFarmRedirectError,
   getFarmRequestDeploymentId: () => getFarmRequestDeploymentId,
   getFarmResponseDeploymentId: () => getFarmResponseDeploymentId,
@@ -32154,6 +32345,7 @@ __export(src_exports, {
   isProgrammaticRouteManifest: () => isProgrammaticRouteManifest,
   isProgrammaticRoutesFileName: () => isProgrammaticRoutesFileName,
   isSSGModule: () => isSSGModule,
+  isServerFnFailure: () => isServerFnFailure,
   isWebResponse: () => isWebResponse2,
   jsonStream: () => jsonStream,
   layout: () => layout,
@@ -35702,6 +35894,8 @@ init_image_types();
 init_server_action_security();
 init_request_bridge();
 init_cache();
+init_server_fn_error();
+init_server_fn_error();
 var FARM_SERVER_FN_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn");
 var UNSAFE_FORM_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function createServerMiddleware(options) {
@@ -35724,6 +35918,8 @@ function createServerFn(options) {
     throw new TypeError("createServerFn requires a handler function");
   }
   const middleware2 = resolveServerFnMiddleware(options.middleware);
+  const errors = normalizeServerFnErrors(options.errors);
+  const error = createServerFnErrorHandler(errors);
   const serverFn = /* @__PURE__ */ __name(async (value) => {
     const formData = isFormData2(value) ? value : void 0;
     const rawInput = formData ? formDataToObject2(formData) : value;
@@ -35741,7 +35937,7 @@ function createServerFn(options) {
     let resolvedContext = Object.freeze(/* @__PURE__ */ Object.create(null));
     const result = await runServerFnMiddleware(middleware2, handlerContext, async (context) => {
       resolvedContext = context.context;
-      return options.handler(context);
+      return options.handler({ ...context, error });
     });
     const parsedResult = await _parseServerFnSchema(options.output, result, "output");
     if (options.invalidates) {
@@ -35771,6 +35967,10 @@ function createServerFn(options) {
       value: options.output,
       enumerable: false
     },
+    __farmServerFnError: {
+      value: void 0,
+      enumerable: false
+    },
     __farmServerFnMiddleware: {
       value: middleware2,
       enumerable: false
@@ -35809,6 +36009,78 @@ async function runServerFnMiddleware(middleware2, handlerContext, handler) {
   return dispatch(0, Object.freeze(/* @__PURE__ */ Object.create(null)));
 }
 __name(runServerFnMiddleware, "runServerFnMiddleware");
+function normalizeServerFnErrors(definitions) {
+  if (definitions === void 0) return Object.freeze({});
+  if (!isPlainServerFnObject(definitions)) {
+    throw new TypeError("createServerFn errors must be an object");
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [code, definition] of Object.entries(definitions)) {
+    if (!code.trim()) {
+      throw new TypeError("Server function error codes cannot be empty");
+    }
+    if (!definition || typeof definition !== "object") {
+      throw new TypeError(`Server function error "${code}" must be an object`);
+    }
+    if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
+      throw new TypeError(
+        `Server function error "${code}" status must be an integer between 400 and 599`
+      );
+    }
+    if (!definition.data || typeof definition.data.parse !== "function" && typeof definition.data.safeParse !== "function") {
+      throw new TypeError(
+        `Server function error "${code}" data must provide synchronous parse() or safeParse()`
+      );
+    }
+    if (definition.message !== void 0 && typeof definition.message !== "string") {
+      throw new TypeError(`Server function error "${code}" message must be a string`);
+    }
+    normalized[code] = Object.freeze({ ...definition });
+  }
+  return Object.freeze(normalized);
+}
+__name(normalizeServerFnErrors, "normalizeServerFnErrors");
+function createServerFnErrorHandler(definitions) {
+  return ((code, data) => {
+    const definition = definitions[code];
+    if (!definition) {
+      throw new TypeError(`Server function error "${code}" is not declared`);
+    }
+    const parsed = parseServerFnFailureData(code, definition.data, data);
+    throw new ServerFnFailure(code, parsed, {
+      status: definition.status,
+      message: definition.message ?? "Server function failed"
+    });
+  });
+}
+__name(createServerFnErrorHandler, "createServerFnErrorHandler");
+function parseServerFnFailureData(code, schema, value) {
+  if (typeof schema.safeParse === "function") {
+    const result2 = schema.safeParse(value);
+    if (isPromiseLike2(result2)) {
+      throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+    }
+    return unwrapSafeParseResult(result2);
+  }
+  const result = schema.parse(value);
+  if (isPromiseLike2(result)) {
+    throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+  }
+  return result;
+}
+__name(parseServerFnFailureData, "parseServerFnFailureData");
+function isPlainServerFnObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainServerFnObject, "isPlainServerFnObject");
+function isPromiseLike2(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function"
+  );
+}
+__name(isPromiseLike2, "isPromiseLike");
 function resolveServerFnMiddleware(middleware2) {
   const resolved = [];
   const seen = /* @__PURE__ */ new Set();
@@ -36421,6 +36693,7 @@ init_fonts();
 
 // src/route-runtime-manifest.ts
 var import_path10 = __toESM(require("path"));
+init_deployment();
 init_route_runtime();
 init_ssg();
 var FARM_ROUTE_RUNTIME_MANIFEST = "route-runtime-manifest.json";
@@ -36481,10 +36754,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 route2 of manifest.routes) {
     if (route2.rendering === "static") continue;
+    if (runtime === "unknown" && route2.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" && route2.runtime !== "auto" && route2.runtime !== runtime) {
       throw new Error(
         `Route "${route2.pattern}" requires the ${route2.runtime} runtime, but preset "${preset}" emits ${runtime} functions. Choose a compatible preset or change the route runtime.`
@@ -36504,16 +36782,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);
@@ -44506,6 +44774,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   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,
@@ -44528,7 +44797,9 @@ __name(decodeCookiePart, "decodeCookiePart");
   PluginManager,
   SPARouter,
   ScalarAPIDocumentation,
+  ServerActionError,
   ServerActionRequestError,
+  ServerFnFailure,
   _parseServerFnSchema,
   _runWithAfterNodeResponse,
   _runWithAfterRequest,
@@ -44617,6 +44888,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   createServerAPIClient,
   createServerActionRequestErrorResponse,
   createServerFn,
+  createServerFnTransportError,
   createServerMiddleware,
   createServerOnlyFn,
   createServerQuery,
@@ -44670,6 +44942,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   getFarmDocsRouteTypeEntries,
   getFarmIntegrationPluginServerRuntime,
   getFarmLayerAliases,
+  getFarmPresetRuntime,
   getFarmRedirectError,
   getFarmRequestDeploymentId,
   getFarmResponseDeploymentId,
@@ -44733,6 +45006,7 @@ __name(decodeCookiePart, "decodeCookiePart");
   isProgrammaticRouteManifest,
   isProgrammaticRoutesFileName,
   isSSGModule,
+  isServerFnFailure,
   isWebResponse,
   jsonStream,
   layout,