@farm.js/core 0.1.14 → 0.1.16

package/dist/index.cjs

@@ -14902,9 +14902,10 @@ function collectIsolatedClientBoundaries(ownerPath, root, options = {}) {
     const importedBindings = getStaticImportBindings(content);
     let estimatedBoundaryCount2 = 0;
     for (const specifier of new Set(getImportSpecifiers(content))) {
-      const importedPath = resolveImportedModuleSourcePath(moduleSourcePath, specifier, root);
+      const imported = resolveImportedModule(moduleSourcePath, specifier, root);
+      const importedPath = imported.path;
       if (!importedPath) continue;
-      if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+      if (!imported.local) {
         const packageMetadata = inspectPackageClientBoundary(importedPath, root, /* @__PURE__ */ new Set());
         if (packageMetadata.shouldHydrate) {
           if (options.staticPackageBoundaries) {
@@ -14972,8 +14973,8 @@ function inspectClientModuleMetadata(resolvedPath, root, visited, inspectIslandE
   let importsClientBoundary = false;
   let importedIslandStrategy = null;
   for (const specifier of getImportSpecifiers(content)) {
-    const importedPath = resolveImportedModuleSourcePath(resolvedPath, specifier, root);
-    const importedMetadata = !specifier.startsWith(".") && !specifier.startsWith("/") ? inspectPackageClientBoundary(importedPath, root, visited) : inspectClientModuleMetadata(importedPath, root, visited, false);
+    const imported = resolveImportedModule(resolvedPath, specifier, root);
+    const importedMetadata = imported.local ? inspectClientModuleMetadata(imported.path, root, visited, false) : inspectPackageClientBoundary(imported.path, root, visited);
     if (importedMetadata.isClientComponent || importedMetadata.shouldHydrate) {
       importsClientBoundary = true;
       if (importedIslandStrategy === null) {
@@ -15098,6 +15099,161 @@ function isTypeOnlyNamedClause(tokens, startIndex, endIndex) {
   }
   return true;
 }
+function resolveImportedModule(importerPath, specifier, root) {
+  if (specifier.startsWith(".") || specifier.startsWith("/")) {
+    return { path: resolveImportedModuleSourcePath(importerPath, specifier, root), local: true };
+  }
+  const aliased = resolveProjectAliasSourcePath(specifier, root);
+  if (aliased !== void 0) return { path: aliased, local: true };
+  return { path: resolvePackageModuleSourcePath(importerPath, specifier, root), local: false };
+}
+function resolveProjectAliasSourcePath(specifier, root) {
+  if (!root) return void 0;
+  const projectRoot = import_path4.default.resolve(root);
+  let match;
+  for (const alias of getProjectImportAliases(projectRoot)) {
+    const captured = matchProjectImportAlias(alias, specifier);
+    if (captured === null) continue;
+    if (!match || alias.prefix.length > match.alias.prefix.length) match = { alias, captured };
+  }
+  if (!match) return void 0;
+  return resolveSourceCandidate(
+    match.alias.targets.map(
+      (target) => import_path4.default.normalize(match.alias.wildcard ? target.replace("*", match.captured) : target)
+    )
+  );
+}
+function matchProjectImportAlias(alias, specifier) {
+  if (!alias.wildcard) return specifier === alias.prefix ? "" : null;
+  if (specifier.length < alias.prefix.length + alias.suffix.length || !specifier.startsWith(alias.prefix) || !specifier.endsWith(alias.suffix)) {
+    return null;
+  }
+  return specifier.slice(alias.prefix.length, specifier.length - alias.suffix.length);
+}
+function getProjectImportAliases(projectRoot) {
+  const stamp = PROJECT_ALIAS_FILES.map((file) => {
+    try {
+      return String(import_fs2.default.statSync(import_path4.default.join(projectRoot, file)).mtimeMs);
+    } catch {
+      return "-";
+    }
+  }).join(":");
+  const cached = projectImportAliasCache.get(projectRoot);
+  if (cached?.stamp === stamp) return cached.aliases;
+  const aliases = [
+    ...readTsconfigPathAliases(projectRoot),
+    ...readPackageImportAliases(projectRoot)
+  ];
+  if (!aliases.some((alias) => alias.prefix === "@/")) {
+    aliases.push({
+      prefix: "@/",
+      suffix: "",
+      wildcard: true,
+      targets: [import_path4.default.join(projectRoot, "src", "*")]
+    });
+  }
+  projectImportAliasCache.set(projectRoot, { stamp, aliases });
+  return aliases;
+}
+function readTsconfigPathAliases(projectRoot) {
+  for (const name2 of ["tsconfig.json", "jsconfig.json"]) {
+    const configPath = import_path4.default.join(projectRoot, name2);
+    if (!import_fs2.default.existsSync(configPath)) continue;
+    const resolved = readTsconfigPaths(configPath, /* @__PURE__ */ new Set());
+    if (!resolved?.paths) return [];
+    const base = resolved.baseUrl ?? resolved.pathsDirectory;
+    return Object.entries(resolved.paths).flatMap(([pattern, targets]) => {
+      if (!Array.isArray(targets)) return [];
+      const wildcardIndex = pattern.indexOf("*");
+      return [
+        {
+          prefix: wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex),
+          suffix: wildcardIndex === -1 ? "" : pattern.slice(wildcardIndex + 1),
+          wildcard: wildcardIndex !== -1,
+          targets: targets.filter((target) => typeof target === "string").map((target) => import_path4.default.resolve(base, target))
+        }
+      ];
+    });
+  }
+  return [];
+}
+function readTsconfigPaths(configPath, visited) {
+  if (visited.has(configPath)) return null;
+  visited.add(configPath);
+  const config = readJsonWithComments(configPath);
+  if (!config) return null;
+  const directory = import_path4.default.dirname(configPath);
+  const parents = (Array.isArray(config.extends) ? config.extends : [config.extends]).filter(
+    (parent) => typeof parent === "string" && parent.startsWith(".")
+  );
+  let inherited = null;
+  for (const parent of parents) {
+    const parentPath = import_path4.default.resolve(
+      directory,
+      parent.endsWith(".json") ? parent : `${parent}.json`
+    );
+    inherited = readTsconfigPaths(parentPath, visited) ?? inherited;
+  }
+  const options = config.compilerOptions ?? {};
+  const baseUrl = typeof options.baseUrl === "string" ? import_path4.default.resolve(directory, options.baseUrl) : inherited?.baseUrl;
+  if (options.paths && typeof options.paths === "object") {
+    return { paths: options.paths, pathsDirectory: directory, baseUrl };
+  }
+  return inherited ? { ...inherited, baseUrl } : { pathsDirectory: directory, baseUrl };
+}
+function readPackageImportAliases(projectRoot) {
+  const imports = readPackageJson(import_path4.default.join(projectRoot, "package.json"))?.imports;
+  if (!imports || typeof imports !== "object") return [];
+  return Object.entries(imports).flatMap(([pattern, value]) => {
+    const target = resolveConditionalExportTarget(value);
+    if (!pattern.startsWith("#") || !target?.startsWith("./")) return [];
+    const wildcardIndex = pattern.indexOf("*");
+    return [
+      {
+        prefix: wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex),
+        suffix: wildcardIndex === -1 ? "" : pattern.slice(wildcardIndex + 1),
+        wildcard: wildcardIndex !== -1,
+        targets: [import_path4.default.resolve(projectRoot, target)]
+      }
+    ];
+  });
+}
+function readJsonWithComments(filePath) {
+  let source;
+  try {
+    source = import_fs2.default.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  let output = "";
+  let inString = false;
+  for (let index = 0; index < source.length; index++) {
+    const char = source[index];
+    if (inString) {
+      output += char;
+      if (char === "\\") output += source[++index] ?? "";
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+    } else if (char === "/" && source[index + 1] === "/") {
+      while (index < source.length && source[index] !== "\n") index++;
+      output += "\n";
+    } else if (char === "/" && source[index + 1] === "*") {
+      const end = source.indexOf("*/", index + 2);
+      index = end === -1 ? source.length : end + 1;
+    } else {
+      output += char;
+    }
+  }
+  try {
+    return JSON.parse(output.replace(/,(\s*[}\]])/g, "$1"));
+  } catch {
+    return null;
+  }
+}
 function resolveImportedModuleSourcePath(importerPath, specifier, root) {
   if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
     return resolvePackageModuleSourcePath(importerPath, specifier, root);
@@ -15228,7 +15384,7 @@ function resolveSourceCandidate(candidates) {
   }
   return null;
 }
-var import_fs2, import_path4, import_url3, FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES, RESOLVABLE_SOURCE_EXTENSIONS, REGEXP_PREFIX_PUNCTUATION, REGEXP_PREFIX_KEYWORDS, PARSER_SENSITIVE_JSX_CONTAINERS;
+var import_fs2, import_path4, import_url3, FARM_ISOLATED_HYDRATION_MAX_BOUNDARIES, RESOLVABLE_SOURCE_EXTENSIONS, REGEXP_PREFIX_PUNCTUATION, REGEXP_PREFIX_KEYWORDS, PARSER_SENSITIVE_JSX_CONTAINERS, projectImportAliasCache, PROJECT_ALIAS_FILES;
 var init_client_component = __esm({
   "src/utils/client-component.ts"() {
     "use strict";
@@ -15334,6 +15490,16 @@ var init_client_component = __esm({
     __name(inspectPackageClientBoundary, "inspectPackageClientBoundary");
     __name(getImportSpecifiers, "getImportSpecifiers");
     __name(isTypeOnlyNamedClause, "isTypeOnlyNamedClause");
+    __name(resolveImportedModule, "resolveImportedModule");
+    projectImportAliasCache = /* @__PURE__ */ new Map();
+    PROJECT_ALIAS_FILES = ["tsconfig.json", "jsconfig.json", "package.json"];
+    __name(resolveProjectAliasSourcePath, "resolveProjectAliasSourcePath");
+    __name(matchProjectImportAlias, "matchProjectImportAlias");
+    __name(getProjectImportAliases, "getProjectImportAliases");
+    __name(readTsconfigPathAliases, "readTsconfigPathAliases");
+    __name(readTsconfigPaths, "readTsconfigPaths");
+    __name(readPackageImportAliases, "readPackageImportAliases");
+    __name(readJsonWithComments, "readJsonWithComments");
     __name(resolveImportedModuleSourcePath, "resolveImportedModuleSourcePath");
     __name(resolvePackageModuleSourcePath, "resolvePackageModuleSourcePath");
     __name(findPackageDirectory, "findPackageDirectory");
@@ -21872,7 +22038,7 @@ var init_server3 = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.14";
+    version = "0.1.16";
   }
 });
 
@@ -26207,21 +26373,40 @@ function resolveEnv(config, source = getProcessEnv()) {
   };
   return resolved;
 }
+function createBundledEnv(env2, source = getProcessEnv()) {
+  const resolved = normalizeResolvedEnv(env2 ?? {});
+  const server = {};
+  const runtime3 = {};
+  for (const [key, value] of Object.entries(resolved.server)) {
+    if (source[key] === void 0) {
+      server[key] = value;
+    } else {
+      runtime3[key] = getRuntimeEnvType(value);
+    }
+  }
+  return {
+    server,
+    public: resolved.public,
+    ...Object.keys(runtime3).length > 0 ? { runtime: { server: runtime3 } } : {}
+  };
+}
 function setEnv(env2) {
-  currentEnv = normalizeResolvedEnv(env2);
+  currentEnv = prepareEnv(env2);
   if (typeof window === "undefined") {
     farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
   }
 }
 function getResolvedEnv() {
-  return getCurrentEnv();
+  const env2 = getCurrentEnv();
+  if (typeof window === "undefined") readRuntimeServerEnv(env2);
+  return env2;
 }
 function getEnv(key) {
-  assertServerEnvAccess();
+  const server = getEnvScope("server");
   if (key === void 0) {
-    return getCurrentEnv().server;
+    return server;
   }
-  return getCurrentEnv().server[key];
+  return readServerEnvKey(server, key);
 }
 function getPublicEnv(key) {
   if (key === void 0) {
@@ -26262,7 +26447,7 @@ function createEnvProxy(scope) {
           return void 0;
         }
         const env2 = getEnvScope(scope);
-        return env2[property];
+        return scope === "server" ? readServerEnvKey(env2, property) : env2[property];
       },
       ownKeys() {
         return Reflect.ownKeys(getEnvScope(scope));
@@ -26285,10 +26470,75 @@ function createEnvProxy(scope) {
   );
 }
 function getEnvScope(scope) {
+  const env2 = getCurrentEnv();
   if (scope === "server") {
     assertServerEnvAccess();
+    readRuntimeServerEnv(env2);
+  }
+  return env2[scope] || {};
+}
+function readServerEnvKey(server, key) {
+  const value = server[key];
+  if (value === void 0) {
+    const state = getCurrentEnv()[FARM_ENV_RUNTIME_SYMBOL];
+    if (state && key in state.pending && !state.warned.has(key)) {
+      state.warned.add(key);
+      console.warn(
+        `[Farm] Server env "${key}" was set when this app was built but is not set where the server runs, so it reads as undefined. Farm reads server env at runtime and does not store it in the build output; set "${key}" in the server's environment.`
+      );
+    }
+  }
+  return value;
+}
+function readRuntimeServerEnv(env2) {
+  const state = env2[FARM_ENV_RUNTIME_SYMBOL];
+  if (!state) return;
+  const source = getProcessEnv();
+  for (const [key, type] of Object.entries(state.pending)) {
+    const raw = source[key];
+    if (raw === void 0) continue;
+    env2.server[key] = coerceRuntimeEnvValue(raw, type);
+    delete state.pending[key];
+  }
+}
+function getRuntimeEnvType(value) {
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (value !== null && typeof value === "object" && !(value instanceof Date)) return "json";
+  return "string";
+}
+function coerceRuntimeEnvValue(raw, type) {
+  if (type === "number") {
+    const value = Number(raw);
+    return raw.trim() !== "" && Number.isFinite(value) ? value : raw;
+  }
+  if (type === "boolean") {
+    if (/^(true|1)$/i.test(raw.trim())) return true;
+    if (/^(false|0|)$/i.test(raw.trim())) return false;
+    return raw;
+  }
+  if (type === "json") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
   }
-  return getCurrentEnv()[scope] || {};
+  return raw;
+}
+function prepareEnv(env2) {
+  const normalized = normalizeResolvedEnv(env2);
+  const runtime3 = env2.runtime?.server;
+  if (!isRecord4(runtime3) || Object.keys(runtime3).length === 0) return normalized;
+  const prepared = { server: { ...normalized.server }, public: normalized.public };
+  Object.defineProperty(prepared, FARM_ENV_RUNTIME_SYMBOL, {
+    value: {
+      pending: { ...runtime3 },
+      warned: /* @__PURE__ */ new Set()
+    },
+    enumerable: false
+  });
+  return prepared;
 }
 function assertServerEnvAccess() {
   if (typeof window !== "undefined") {
@@ -26317,7 +26567,7 @@ function getCurrentEnv() {
 function getInjectedEnv() {
   try {
     if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
-      return normalizeResolvedEnv(__FARM_ENV__);
+      return prepareEnv(__FARM_ENV__);
     }
   } catch {
   }
@@ -26347,14 +26597,16 @@ function getProcessEnv() {
   }
   return {};
 }
-var FARM_ENV_SYMBOL, farmEnvGlobal, currentEnv, env, serverEnv, publicEnv;
+var FARM_ENV_SYMBOL, FARM_ENV_RUNTIME_SYMBOL, farmEnvGlobal, currentEnv, env, serverEnv, publicEnv;
 var init_env = __esm({
   "src/env.ts"() {
     "use strict";
     FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
+    FARM_ENV_RUNTIME_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env.runtime");
     farmEnvGlobal = globalThis;
     currentEnv = getInitialEnv();
     __name(resolveEnv, "resolveEnv");
+    __name(createBundledEnv, "createBundledEnv");
     __name(setEnv, "setEnv");
     __name(getResolvedEnv, "getResolvedEnv");
     __name(getEnv, "getEnv");
@@ -26366,6 +26618,11 @@ var init_env = __esm({
     __name(parseEnvValue, "parseEnvValue");
     __name(createEnvProxy, "createEnvProxy");
     __name(getEnvScope, "getEnvScope");
+    __name(readServerEnvKey, "readServerEnvKey");
+    __name(readRuntimeServerEnv, "readRuntimeServerEnv");
+    __name(getRuntimeEnvType, "getRuntimeEnvType");
+    __name(coerceRuntimeEnvValue, "coerceRuntimeEnvValue");
+    __name(prepareEnv, "prepareEnv");
     __name(assertServerEnvAccess, "assertServerEnvAccess");
     __name(getInitialEnv, "getInitialEnv");
     __name(getCurrentEnv, "getCurrentEnv");
@@ -39632,7 +39889,7 @@ function getEnvDefines(config, configEnv) {
     )
   };
   if (configEnv?.isSsrBuild) {
-    defines.__FARM_ENV__ = JSON.stringify(getFullEnvDefine(config));
+    defines.__FARM_ENV__ = JSON.stringify(createBundledEnv(getFullEnvDefine(config)));
   }
   return defines;
 }
@@ -44027,6 +44284,7 @@ var fs14, path38, import_node_url11, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifact
 var init_vite2 = __esm({
   "src/vite.ts"() {
     "use strict";
+    init_env();
     init_app();
     init_utils();
     init_plugin();
@@ -45097,7 +45355,7 @@ export const farmRegistry: {
   clientManifest?: any;
   routePaths?: Record<string, string>;
 } = {
-  env: ${JSON.stringify(config.env || { server: {}, public: {} }, null, 2)},
+  env: ${JSON.stringify(createBundledEnv(config.env), null, 2)},
   deploymentId: ${JSON.stringify(config.deploymentId)},
   basePath: ${JSON.stringify(config.basePath)},
   apiBasePath: ${JSON.stringify(apiBasePath)},
@@ -45601,7 +45859,7 @@ export default defineEventHandler(async (event: H3Event) => {
           farmRegistry.apiRouteManager = apiRouteManager;
           farmRegistry.routeManager = routeManager;
           farmRegistry.serverRenderer = serverRenderer;
-          farmRegistry.env = config.env || { server: {}, public: {} };
+          farmRegistry.env = createBundledEnv(config.env);
           farmRegistry.deploymentId = config.deploymentId;
           farmRegistry.basePath = config.basePath;
         };
@@ -45666,6 +45924,7 @@ var import_path16;
 var init_nitro = __esm({
   "src/nitro/index.ts"() {
     "use strict";
+    init_env();
     import_path16 = __toESM(require("path"));
     init_workflows();
     init_cron();
@@ -45748,7 +46007,11 @@ __export(src_exports, {
   ServerActionRequestError: () => ServerActionRequestError,
   ServerFnFailure: () => ServerFnFailure,
   UnsupportedRateLimitStorageError: () => UnsupportedRateLimitStorageError,
+  _attachServerFunctionDescriptor: () => _attachServerFunctionDescriptor,
+  _describeServerFunction: () => _describeServerFunction,
+  _invokeServerFunction: () => _invokeServerFunction,
   _parseServerFnSchema: () => _parseServerFnSchema,
+  _runServerFunctionForCaller: () => _runServerFunctionForCaller,
   _runWithAfterNodeResponse: () => _runWithAfterNodeResponse,
   _runWithAfterRequest: () => _runWithAfterRequest,
   _runWithMiddlewareContext: () => _runWithMiddlewareContext,
@@ -45794,6 +46057,7 @@ __export(src_exports, {
   cookies: () => cookies,
   createAPIClient: () => createAPIClient,
   createApiClients: () => createApiClients,
+  createBundledEnv: () => createBundledEnv,
   createClientOnlyFn: () => createClientOnlyFn,
   createClientPluginManager: () => createClientPluginManager,
   createCompressionPlugin: () => createCompressionPlugin,
@@ -45856,6 +46120,7 @@ __export(src_exports, {
   createServerActionRequestErrorResponse: () => createServerActionRequestErrorResponse,
   createServerFn: () => createServerFn,
   createServerFnTransportError: () => createServerFnTransportError,
+  createServerFunctionDescriptor: () => createServerFunctionDescriptor,
   createServerMiddleware: () => createServerMiddleware,
   createServerOnlyFn: () => createServerOnlyFn,
   createServerQuery: () => createServerQuery,
@@ -52627,8 +52892,74 @@ init_server_action_security();
 init_request_bridge();
 init_cache();
 init_server_fn_error();
+init_navigation_errors();
 init_server_fn_error();
 var FARM_SERVER_FN_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn");
+var FARM_SERVER_FUNCTION_DESCRIPTOR = /* @__PURE__ */ Symbol.for("farm.server-function.descriptor");
+var _ServerFnInputError = class _ServerFnInputError extends Error {
+  constructor(cause) {
+    super("Server function input is invalid");
+    this.cause = cause;
+  }
+};
+__name(_ServerFnInputError, "ServerFnInputError");
+var ServerFnInputError = _ServerFnInputError;
+function createServerFunctionDescriptor(kind, options, run) {
+  return Object.freeze({
+    kind,
+    input: options.input,
+    output: options.output,
+    mcp: options.mcp === void 0 ? void 0 : Object.freeze({ ...options.mcp }),
+    run
+  });
+}
+__name(createServerFunctionDescriptor, "createServerFunctionDescriptor");
+function _attachServerFunctionDescriptor(target, descriptor) {
+  Object.defineProperty(target, FARM_SERVER_FUNCTION_DESCRIPTOR, {
+    value: descriptor,
+    enumerable: false
+  });
+}
+__name(_attachServerFunctionDescriptor, "_attachServerFunctionDescriptor");
+function getServerFunctionRunner(value) {
+  if (typeof value !== "function") return void 0;
+  return value[FARM_SERVER_FUNCTION_DESCRIPTOR];
+}
+__name(getServerFunctionRunner, "getServerFunctionRunner");
+function _runServerFunctionForCaller(value, input) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) throw new TypeError("Expected a function created with createServerFn");
+  return runner.run(input);
+}
+__name(_runServerFunctionForCaller, "_runServerFunctionForCaller");
+function _describeServerFunction(value) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) return void 0;
+  const { kind, input, output, mcp } = runner;
+  return Object.freeze({ kind, input, output, mcp });
+}
+__name(_describeServerFunction, "_describeServerFunction");
+async function _invokeServerFunction(value, input, request2) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) {
+    throw new TypeError("Expected a function created with createServerFn or createServerQuery");
+  }
+  try {
+    const data = await runWithServerActionRequest(request2, () => runner.run(input));
+    return { ok: true, data };
+  } catch (error) {
+    if (error instanceof ServerFnInputError) {
+      return { ok: false, reason: "input", error: error.cause };
+    }
+    if (isServerFnFailure(error)) return { ok: false, reason: "failure", failure: error };
+    const redirect3 = getFarmRedirectError(error);
+    if (redirect3) {
+      return { ok: false, reason: "redirect", url: redirect3.url, status: redirect3.status };
+    }
+    return { ok: false, reason: "error", error };
+  }
+}
+__name(_invokeServerFunction, "_invokeServerFunction");
 var UNSAFE_FORM_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function createServerMiddleware(options) {
   if (!options || typeof options.handler !== "function") {
@@ -52652,10 +52983,15 @@ function createServerFn(options) {
   const middleware2 = resolveServerFnMiddleware(options.middleware);
   const errors = normalizeServerFnErrors(options.errors);
   const error = createServerFnErrorHandler(errors);
-  const serverFn = /* @__PURE__ */ __name(async (value) => {
+  const run = /* @__PURE__ */ __name(async (value, labelInputErrors) => {
     const formData = isFormData2(value) ? value : void 0;
     const rawInput = formData ? formDataToObject2(formData) : value;
-    const input = await _parseServerFnSchema(options.input, rawInput, "input");
+    let input;
+    try {
+      input = await _parseServerFnSchema(options.input, rawInput, "input");
+    } catch (cause) {
+      throw labelInputErrors ? new ServerFnInputError(cause) : cause;
+    }
     const executionContext = getServerActionExecutionContext();
     const request2 = executionContext?.request ?? _resolveCurrentRequest();
     const signal = executionContext?.signal ?? request2?.signal ?? getServerActionSignal();
@@ -52681,7 +53017,8 @@ function createServerFn(options) {
       await applyFarmCacheInvalidationTargets(declaration);
     }
     return parsedResult;
-  }, "serverFn");
+  }, "run");
+  const serverFn = /* @__PURE__ */ __name((value) => run(value, false), "serverFn");
   Object.defineProperties(serverFn, {
     [FARM_SERVER_FN_SYMBOL]: {
       value: true,
@@ -52712,6 +53049,10 @@ function createServerFn(options) {
       enumerable: false
     }
   });
+  _attachServerFunctionDescriptor(
+    serverFn,
+    createServerFunctionDescriptor("action", options, (value) => run(value, true))
+  );
   return serverFn;
 }
 __name(createServerFn, "createServerFn");
@@ -53263,6 +53604,16 @@ function createServerQuery(options) {
       enumerable: false
     }
   });
+  _attachServerFunctionDescriptor(
+    query,
+    createServerFunctionDescriptor("query", options, async (value) => {
+      const result = await _runServerFunctionForCaller(
+        execute,
+        value
+      );
+      return result.data;
+    })
+  );
   return query;
 }
 __name(createServerQuery, "createServerQuery");
@@ -53620,6 +53971,7 @@ init_deployment();
 init_generate_route_types();
 
 // src/build/index.ts
+init_env();
 init_config4();
 var import_path17 = __toESM(require("path"));
 var import_node_fs15 = require("fs");
@@ -53630,6 +53982,7 @@ init_server_path();
 init_layers();
 
 // src/nitro/universal-build.ts
+init_env();
 init_config4();
 
 // src/nitro/client-css-href.ts
@@ -58314,7 +58667,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
       },
       define: {
         __FARM_API_BASE_URL__: JSON.stringify(config.api.baseURL),
-        __FARM_ENV__: JSON.stringify(config.env || { server: {}, public: {} }),
+        __FARM_ENV__: JSON.stringify(createBundledEnv(config.env)),
         __FARM_PUBLIC_ENV__: JSON.stringify(config.env?.public || {})
       },
       plugins: [
@@ -63765,7 +64118,7 @@ async function buildSSR(viteBuild, config, root, srcDir, outputDir) {
     },
     define: {
       __FARM_API_BASE_URL__: JSON.stringify(config.api.baseURL),
-      __FARM_ENV__: JSON.stringify(config.env || { server: {}, public: {} }),
+      __FARM_ENV__: JSON.stringify(createBundledEnv(config.env)),
       __FARM_PUBLIC_ENV__: JSON.stringify(config.env?.public || {})
     },
     plugins: [
@@ -63848,7 +64201,7 @@ async function buildNitro(config, routeManager, apiRouteManager, serverRenderer,
     farmRegistry.apiRouteManager = apiRouteManager;
     farmRegistry.routeManager = routeManager;
     farmRegistry.serverRenderer = serverRenderer;
-    farmRegistry.env = config.env || { server: {}, public: {} };
+    farmRegistry.env = createBundledEnv(config.env);
     const routePaths = {};
     for (const [pattern, entry] of routeManager.getRoutes()) {
       const bundledPath = entry.modulePath.replace(/.*\/src\/app\//, "").replace(/\.(tsx?|jsx?)$/, ".js");
@@ -67391,7 +67744,11 @@ __name(cookies, "cookies");
   ServerActionRequestError,
   ServerFnFailure,
   UnsupportedRateLimitStorageError,
+  _attachServerFunctionDescriptor,
+  _describeServerFunction,
+  _invokeServerFunction,
   _parseServerFnSchema,
+  _runServerFunctionForCaller,
   _runWithAfterNodeResponse,
   _runWithAfterRequest,
   _runWithMiddlewareContext,
@@ -67437,6 +67794,7 @@ __name(cookies, "cookies");
   cookies,
   createAPIClient,
   createApiClients,
+  createBundledEnv,
   createClientOnlyFn,
   createClientPluginManager,
   createCompressionPlugin,
@@ -67499,6 +67857,7 @@ __name(cookies, "cookies");
   createServerActionRequestErrorResponse,
   createServerFn,
   createServerFnTransportError,
+  createServerFunctionDescriptor,
   createServerMiddleware,
   createServerOnlyFn,
   createServerQuery,