@farm.js/core 0.1.41 → 0.1.43

package/dist/{chunk-JIYYX7WU.mjs → chunk-VLXNGUKO.mjs}

@@ -17,7 +17,7 @@ import {
   planSchemaMigration,
   readSchemaState,
   withoutRenameTargets
-} from "./chunk-BYR3RQPB.mjs";
+} from "./chunk-T76H22WI.mjs";
 import {
   collectSchemaExtensions,
   describeSchemaExtensionApproval,

package/dist/{chunk-OFZUJMCU.mjs → chunk-WPJQN64R.mjs}

@@ -1,7 +1,14 @@
 import {
+  getFarmActionId,
   getFarmClientReference,
   subscribeFarmServerTreeUpdates
-} from "./chunk-NRDBW4MP.mjs";
+} from "./chunk-7IQQIPRZ.mjs";
+import {
+  FARM_REFERENCE_TAG,
+  FARM_TAG,
+  FARM_VALUE_SCRIPT_TYPE,
+  getFarmIslandValuesServer
+} from "./chunk-2NXO5SBY.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";
@@ -9,10 +16,12 @@ import {
 // src/client/server-tree.ts
 var MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
 var FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
-var SERVER_HTML_TAG = "farm-server-html";
-var FARM_SERVER_TREE_ATTRIBUTE = "data-farm-server-tree";
-var SERVER_TREE_CHUNK_ATTRIBUTE = "data-farm-server-tree-chunk";
-var SERVER_HTML_ATTRIBUTE = "data-farm-server-html";
+var SERVER_HTML_TAG = "f-html";
+var FARM_SERVER_TREE_SCRIPT_TYPE = "f/tree";
+var FARM_NOT_A_MARKER = /* @__PURE__ */ Symbol.for("farm.codec.not-a-marker");
+var SERVER_TREE_CHUNK_SCRIPT_TYPE = "f/chunk";
+var FARM_SERVER_TREE_PAYLOAD_ONLY_ATTRIBUTE = "partial";
+var SERVER_HTML_ATTRIBUTE = "name";
 var PARSER_SENSITIVE_TAGS = /* @__PURE__ */ new Set([
   "caption",
   "colgroup",
@@ -105,7 +114,7 @@ __name(serverHtmlNode, "serverHtmlNode");
 async function resolveProps(state, props, context, host) {
   const entries = await Promise.all(
     Object.entries(props).map(async ([name, value]) => {
-      if (value === void 0) return null;
+      if (value === void 0 && (host || !state.codec)) return null;
       if (name === "ref") {
         if (value === null) return null;
         throw new UnsupportedNode("receives a ref");
@@ -120,11 +129,21 @@ async function resolveProps(state, props, context, host) {
 }
 __name(resolveProps, "resolveProps");
 async function resolveValue(state, value, context, seen) {
+  const codec = state.codec;
+  const leaf = codec?.encodeLeaf(value);
+  if (leaf) return leaf;
   if (value === null || value === void 0) return null;
   if (typeof value === "string" || typeof value === "boolean") return value;
   if (typeof value === "number") {
     return Number.isFinite(value) ? value : { $: "n", v: String(value) };
   }
+  if (typeof value === "function") {
+    const actionId = getFarmActionId(value);
+    if (actionId) {
+      state.actions.set(actionId, value);
+      return { $: "a", v: actionId };
+    }
+  }
   if (typeof value !== "object") throw new UnsupportedNode(`passes a ${typeof value} value`);
   if (state.ReactRuntime.isValidElement(value)) {
     return resolveElement(state, value, context);
@@ -143,12 +162,18 @@ async function resolveValue(state, value, context, seen) {
     if (Array.isArray(value)) {
       return await Promise.all(value.map((entry) => resolveValue(state, entry, context, seen)));
     }
+    if (codec && value instanceof Map) {
+      return { $: "M", v: await resolveValue(state, Array.from(value), context, seen) };
+    }
+    if (codec && value instanceof Set) {
+      return { $: "S", v: await resolveValue(state, Array.from(value), context, seen) };
+    }
     const prototype = Object.getPrototypeOf(value);
     if (prototype !== Object.prototype && prototype !== null) {
       throw new UnsupportedNode("passes a class instance");
     }
     const entries = await Promise.all(
-      Object.entries(value).filter(([, entry]) => entry !== void 0).map(
+      Object.entries(value).filter(([, entry]) => entry !== void 0 || codec).map(
         async ([name, entry]) => [
           name,
           await resolveValue(state, entry, context, seen)
@@ -212,7 +237,7 @@ async function resolveElement(state, element, context) {
       encoded.catch(() => {
       });
       state.chunks.set(id, { encoded });
-      return withKey({ $: "s", f: fallback, i: id });
+      return withKey({ $: "p", f: fallback, i: id });
     }
     const clientReference = getFarmClientReference(type);
     if (clientReference) {
@@ -276,9 +301,13 @@ async function resolveElement(state, element, context) {
 }
 __name(resolveElement, "resolveElement");
 function serializeTreePayload(value) {
-  return JSON.stringify(value).replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  return escapeTreeJson(JSON.stringify(value));
 }
 __name(serializeTreePayload, "serializeTreePayload");
+function escapeTreeJson(json) {
+  return json.replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+__name(escapeTreeJson, "escapeTreeJson");
 var chunkComponents = /* @__PURE__ */ new WeakMap();
 function getChunkComponent(ReactRuntime) {
   const existing = chunkComponents.get(ReactRuntime.createElement);
@@ -351,7 +380,7 @@ function createTreeValue(ReactRuntime, value, resolver) {
         typeof value.k === "string" ? { key: value.k } : null,
         ...createTreeChildren(ReactRuntime, value.c, resolver)
       );
-    case "s":
+    case "p":
       return ReactRuntime.createElement(
         ReactRuntime.Suspense,
         {
@@ -370,6 +399,8 @@ function createTreeValue(ReactRuntime, value, resolver) {
       return resolver.serverHtml(value.i, typeof value.k === "string" ? value.k : null);
     case "n":
       return Number(value.v);
+    case "a":
+      return resolver.action(value.v);
     case "P":
       return fulfilledThenable(createTreeValue(ReactRuntime, value.v, resolver));
     case "o": {
@@ -381,42 +412,134 @@ function createTreeValue(ReactRuntime, value, resolver) {
         ])
       );
     }
-    default:
+    default: {
+      if (value.$ !== void 0) {
+        if (!resolver.decode) throw new Error("typed props need islands mode");
+        const decoded = resolver.decode(
+          value,
+          (child) => createTreeValue(ReactRuntime, child, resolver)
+        );
+        if (decoded !== FARM_NOT_A_MARKER) return decoded;
+      }
       return Object.fromEntries(
         Object.entries(value).map(([name, entry]) => [
           name,
           createTreeValue(ReactRuntime, entry, resolver)
         ])
       );
+    }
   }
 }
 __name(createTreeValue, "createTreeValue");
-function createTreeScript(ReactRuntime, attribute, value, json) {
-  return ReactRuntime.createElement("script", {
-    type: "application/json",
-    [attribute]: value,
+function createTreeScript(ReactRuntime, type, name, json, values = [], attributes = {}) {
+  const script = ReactRuntime.createElement("script", {
+    type,
+    ...name ? { name } : {},
+    ...attributes,
     dangerouslySetInnerHTML: { __html: json }
   });
+  if (values.length === 0) return script;
+  return ReactRuntime.createElement(
+    ReactRuntime.Fragment,
+    null,
+    ...values.map(
+      ([valueKey, valueJson]) => ReactRuntime.createElement("script", {
+        key: valueKey,
+        type: FARM_VALUE_SCRIPT_TYPE,
+        name: valueKey,
+        dangerouslySetInnerHTML: { __html: valueJson }
+      })
+    ),
+    script
+  );
 }
 __name(createTreeScript, "createTreeScript");
-function createTreePage(ReactRuntime, tree, json, resolver, key) {
+function createTreePage(ReactRuntime, tree, json, resolver, key, values = []) {
   return ReactRuntime.createElement(
     ReactRuntime.Fragment,
     key === void 0 ? null : { key },
     createTreeValue(ReactRuntime, tree, resolver),
-    createTreeScript(ReactRuntime, FARM_SERVER_TREE_ATTRIBUTE, "", json)
+    createTreeScript(ReactRuntime, FARM_SERVER_TREE_SCRIPT_TYPE, "", json, values)
   );
 }
 __name(createTreePage, "createTreePage");
+function readTreeValueScripts(script) {
+  const values = [];
+  for (let node = script.previousElementSibling; node?.tagName === "SCRIPT" && node.getAttribute("type") === FARM_VALUE_SCRIPT_TYPE; node = node.previousElementSibling) {
+    values.unshift([node.getAttribute("name") ?? "", node.textContent ?? ""]);
+  }
+  return values;
+}
+__name(readTreeValueScripts, "readTreeValueScripts");
+async function createPayloadOnlyPage(state, payload, encode, resolver) {
+  const { ReactRuntime } = state;
+  const chunks = /* @__PURE__ */ new Map();
+  for (let pending = [...state.chunks.keys()]; pending.length > 0; ) {
+    const settled = await Promise.allSettled(
+      pending.map(async (id) => [id, await state.chunks.get(id).encoded])
+    );
+    for (const result of settled) {
+      if (result.status === "rejected") return null;
+      chunks.set(result.value[0], result.value[1]);
+    }
+    pending = [...state.chunks.keys()].filter((id) => !chunks.has(id));
+  }
+  return ReactRuntime.createElement(
+    ReactRuntime.Fragment,
+    null,
+    ...Array.from(state.serverHtml.keys(), (id) => resolver.serverHtml(id, `h${id}`)),
+    ReactRuntime.createElement(
+      ReactRuntime.Fragment,
+      { key: "payload" },
+      createTreeScript(
+        ReactRuntime,
+        FARM_SERVER_TREE_SCRIPT_TYPE,
+        "",
+        payload.json,
+        payload.values,
+        {
+          [FARM_SERVER_TREE_PAYLOAD_ONLY_ATTRIBUTE]: ""
+        }
+      )
+    ),
+    ...Array.from(chunks, ([id, encoded]) => {
+      const chunk = encode({ t: encoded });
+      return ReactRuntime.createElement(
+        ReactRuntime.Fragment,
+        { key: `c${id}` },
+        createTreeScript(
+          ReactRuntime,
+          SERVER_TREE_CHUNK_SCRIPT_TYPE,
+          String(id),
+          chunk.json,
+          chunk.values
+        )
+      );
+    })
+  );
+}
+__name(createPayloadOnlyPage, "createPayloadOnlyPage");
 async function renderFarmServerTreePage(ReactRuntime, element, options) {
   const state = {
     ReactRuntime,
     nextId: 0,
     components: /* @__PURE__ */ new Map(),
     serverHtml: /* @__PURE__ */ new Map(),
-    chunks: /* @__PURE__ */ new Map()
+    chunks: /* @__PURE__ */ new Map(),
+    actions: /* @__PURE__ */ new Map(),
+    codec: options.values ? getFarmIslandValuesServer() : void 0
   };
   const tree = await resolveValue(state, element, { parserSensitive: false }, /* @__PURE__ */ new Set());
+  const values = options.values ? getFarmIslandValuesServer() : void 0;
+  const held = values ? values.held() : null;
+  const encode = /* @__PURE__ */ __name((payload2) => {
+    if (!values) return { json: serializeTreePayload(payload2), values: [] };
+    const addressed = values.address(payload2);
+    return {
+      json: escapeTreeJson(addressed.json),
+      values: values.select(addressed, held).map((value) => [value.key, escapeTreeJson(value.json)])
+    };
+  }, "encode");
   const resolver = {
     component(reference, exportName) {
       const Component = state.components.get(`${reference}#${exportName}`);
@@ -435,12 +558,16 @@ async function renderFarmServerTreePage(ReactRuntime, element, options) {
               ReactRuntime.Fragment,
               null,
               createTreeValue(ReactRuntime, encoded, resolver),
-              createTreeScript(
-                ReactRuntime,
-                SERVER_TREE_CHUNK_ATTRIBUTE,
-                String(id),
-                serializeTreePayload({ t: encoded })
-              )
+              (() => {
+                const payload2 = encode({ t: encoded });
+                return createTreeScript(
+                  ReactRuntime,
+                  SERVER_TREE_CHUNK_SCRIPT_TYPE,
+                  String(id),
+                  payload2.json,
+                  payload2.values
+                );
+              })()
             );
             chunk.status = "fulfilled";
             return chunk.value;
@@ -467,14 +594,14 @@ async function renderFarmServerTreePage(ReactRuntime, element, options) {
         },
         options.isolate(state.serverHtml.get(id))
       );
-    }
+    },
+    action(id) {
+      return state.actions.get(id);
+    },
+    decode: state.codec ? (object, decodeChild) => getFarmIslandValuesServer().decode(object, decodeChild) : void 0
   };
-  const page = createTreePage(
-    ReactRuntime,
-    tree,
-    serializeTreePayload({ v: 1, t: tree }),
-    resolver
-  );
+  const payload = encode({ v: 1, t: tree });
+  const page = options.payloadOnly && await createPayloadOnlyPage(state, payload, encode, resolver) || createTreePage(ReactRuntime, tree, payload.json, resolver, void 0, payload.values);
   return ReactRuntime.createElement(/* @__PURE__ */ __name(function FarmServerTreePage() {
     return page;
   }, "FarmServerTreePage"));
@@ -506,19 +633,34 @@ function originalExport(module, exportName) {
 __name(originalExport, "originalExport");
 async function createFarmServerTreeElement(ReactRuntime, source, options) {
   const root = typeof source === "string" ? parseHtml(source) : source;
-  const script = root.querySelector(`script[${FARM_SERVER_TREE_ATTRIBUTE}]`);
+  const script = root.querySelector(
+    `script[type="${FARM_SERVER_TREE_SCRIPT_TYPE}"]`
+  );
   if (!script) return null;
   const json = script.textContent ?? "";
-  const payload = JSON.parse(json);
+  let ingested = false;
+  const parsePayload = /* @__PURE__ */ __name((text) => {
+    const parsed = JSON.parse(text);
+    if (!text.includes(`"${FARM_TAG}":"${FARM_REFERENCE_TAG}"`)) return parsed;
+    if (!options.values) throw new Error("island values need islands mode");
+    if (!ingested) {
+      options.values.ingest(root);
+      ingested = true;
+    }
+    return options.values.resolve(parsed);
+  }, "parsePayload");
+  const payload = parsePayload(json);
   if (payload.v !== 1) throw new Error("unsupported server tree payload version");
+  const values = readTreeValueScripts(script);
   const chunks = /* @__PURE__ */ new Map();
   for (const chunkScript of root.querySelectorAll(
-    `script[${SERVER_TREE_CHUNK_ATTRIBUTE}]`
+    `script[type="${SERVER_TREE_CHUNK_SCRIPT_TYPE}"]`
   )) {
     const chunkJson = chunkScript.textContent ?? "";
-    chunks.set(Number(chunkScript.getAttribute(SERVER_TREE_CHUNK_ATTRIBUTE)), {
-      tree: JSON.parse(chunkJson).t,
-      json: chunkJson
+    chunks.set(Number(chunkScript.getAttribute("name")), {
+      tree: parsePayload(chunkJson).t,
+      json: chunkJson,
+      values: readTreeValueScripts(chunkScript)
     });
   }
   const references = /* @__PURE__ */ new Set();
@@ -549,7 +691,13 @@ async function createFarmServerTreeElement(ReactRuntime, source, options) {
         ReactRuntime.Fragment,
         null,
         createTreeValue(ReactRuntime, chunk.tree, resolver),
-        createTreeScript(ReactRuntime, SERVER_TREE_CHUNK_ATTRIBUTE, String(id), chunk.json)
+        createTreeScript(
+          ReactRuntime,
+          SERVER_TREE_CHUNK_SCRIPT_TYPE,
+          String(id),
+          chunk.json,
+          chunk.values
+        )
       );
       return { status: "fulfilled", value, promise: Promise.resolve(value) };
     },
@@ -564,9 +712,14 @@ async function createFarmServerTreeElement(ReactRuntime, source, options) {
         suppressHydrationWarning: true,
         dangerouslySetInnerHTML: { __html: html }
       });
-    }
+    },
+    action(id) {
+      if (!options.actions) throw new Error("server action props need islands mode");
+      return options.actions(id);
+    },
+    decode: options.decode ? (object, decodeChild) => options.decode(object, decodeChild) : void 0
   };
-  const build = /* @__PURE__ */ __name(() => createTreePage(ReactRuntime, payload.t, json, resolver), "build");
+  const build = /* @__PURE__ */ __name(() => createTreePage(ReactRuntime, payload.t, json, resolver, void 0, values), "build");
   build();
   function FarmServerTreePage() {
     const [, setVersion] = ReactRuntime.useState(0);
@@ -595,7 +748,8 @@ async function createFarmServerTreeElement(ReactRuntime, source, options) {
 __name(createFarmServerTreeElement, "createFarmServerTreeElement");
 
 export {
-  FARM_SERVER_TREE_ATTRIBUTE,
+  FARM_SERVER_TREE_SCRIPT_TYPE,
+  FARM_SERVER_TREE_PAYLOAD_ONLY_ATTRIBUTE,
   renderFarmServerTreePage,
   createFarmServerTreeElement
 };

package/dist/chunk-XARSG2TG.mjs

@@ -0,0 +1,144 @@
+import {
+  FARM_RSC_INSTALL_HINT,
+  findFarmAppPackageDir
+} from "./chunk-QGH2RQVF.mjs";
+import {
+  resolveDeployOutputPath
+} from "./chunk-4MRQ5OKQ.mjs";
+import {
+  loadFarmReactPlugin
+} from "./chunk-5NIWBWDD.mjs";
+import {
+  loadTailwindVitePlugin
+} from "./chunk-S34OBRMZ.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/rsc-pipeline.ts
+import { readFileSync } from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+var FARM_RSC_ENTRIES = {
+  rsc: "./.farm/rsc-entries/entry.rsc.tsx",
+  ssr: "./.farm/rsc-entries/entry.ssr.tsx",
+  client: "./.farm/rsc-entries/entry.browser.tsx"
+};
+var FARM_RSC_CONFIG_KEYS = [
+  "srcDir",
+  "extends",
+  "basePath",
+  "api",
+  "server",
+  "middleware",
+  "images",
+  "serverActions",
+  "deploymentId",
+  "generateBuildId",
+  "md",
+  "agent",
+  "mcp"
+];
+var FARM_RSC_PASSTHROUGH_KEYS = ["i18n", "cache"];
+function pickImportTarget(entry) {
+  if (typeof entry === "string") return entry;
+  if (!entry || typeof entry !== "object") return void 0;
+  for (const condition of ["import", "node", "default"]) {
+    const target = pickImportTarget(entry[condition]);
+    if (target) return target;
+  }
+  return void 0;
+}
+__name(pickImportTarget, "pickImportTarget");
+async function importFromApp(root, packageName, subpath = ".") {
+  const packageDir = findFarmAppPackageDir(root, packageName);
+  if (!packageDir) return void 0;
+  const manifest = JSON.parse(readFileSync(path.join(packageDir, "package.json"), "utf8"));
+  const exportsMap = manifest.exports;
+  const entry = exportsMap && typeof exportsMap === "object" && !Array.isArray(exportsMap) && subpath in exportsMap ? exportsMap[subpath] : subpath === "." ? exportsMap ?? manifest.module ?? manifest.main ?? "index.js" : void 0;
+  const target = pickImportTarget(entry);
+  if (!target) return void 0;
+  return import(pathToFileURL(path.join(packageDir, target)).href);
+}
+__name(importFromApp, "importFromApp");
+function hasPluginNamed(plugins, prefix) {
+  if (Array.isArray(plugins)) return plugins.some((plugin) => hasPluginNamed(plugin, prefix));
+  const name = plugins?.name;
+  return typeof name === "string" && name.startsWith(prefix);
+}
+__name(hasPluginNamed, "hasPluginNamed");
+async function createFarmRscViteConfig(userConfig, options) {
+  const root = path.resolve(options.root);
+  const renderer = userConfig.renderer;
+  if (renderer && typeof renderer === "object" && renderer.name && renderer.name !== "react") {
+    throw new Error(
+      `[Farm.js] experimental.serverComponents needs the React renderer; this app uses "${renderer.name}".`
+    );
+  }
+  const [pluginRsc, viteRsc, viteReact] = await Promise.all([
+    importFromApp(root, "@farm.js/plugin", "./rsc"),
+    importFromApp(root, "@vitejs/plugin-rsc"),
+    importFromApp(root, "@vitejs/plugin-react")
+  ]);
+  if (!pluginRsc || !viteRsc || !findFarmAppPackageDir(root, "react-server-dom-webpack")) {
+    throw new Error(
+      `[Farm.js] experimental.serverComponents runs on @farm.js/plugin and the official @vitejs/plugin-rsc. Install them: ${FARM_RSC_INSTALL_HINT}`
+    );
+  }
+  const { plugins: vitePlugins = [], ...viteOptions } = userConfig.vite ?? {};
+  const rscConfig = {};
+  for (const key of FARM_RSC_CONFIG_KEYS) {
+    if (userConfig[key] !== void 0) rscConfig[key] = userConfig[key];
+  }
+  const createReactPlugin = hasPluginNamed(vitePlugins, "vite:react") ? void 0 : viteReact?.default ?? (options.command === "serve" ? (await loadFarmReactPlugin()).default : void 0);
+  const tailwind = hasPluginNamed(vitePlugins, "@tailwindcss/vite") ? void 0 : await loadTailwindVitePlugin();
+  const farmConfig = pluginRsc.defineConfig({
+    ...rscConfig,
+    experimental: { ...userConfig.experimental, serverComponents: true },
+    port: options.port ?? userConfig.server?.port,
+    plugins: [
+      ...tailwind ? [tailwind] : [],
+      ...vitePlugins,
+      viteRsc.default({ serverHandler: false, entries: FARM_RSC_ENTRIES }),
+      ...typeof createReactPlugin === "function" ? [createReactPlugin()] : [],
+      pluginRsc.nitro({
+        server: { environmentName: "rsc" },
+        config: {
+          preset: options.preset,
+          outputDir: options.outputDir && resolveDeployOutputPath(root, options.outputDir)
+        }
+      })
+    ]
+  });
+  for (const key of FARM_RSC_PASSTHROUGH_KEYS) {
+    if (userConfig[key] !== void 0) farmConfig[key] = userConfig[key];
+  }
+  const { mergeConfig } = await import("vite");
+  return {
+    ...mergeConfig(farmConfig, viteOptions),
+    root,
+    // The Farm config is the app's config; a stray vite.config must not add a second pipeline.
+    configFile: false,
+    mode: options.command === "build" ? "production" : "development"
+  };
+}
+__name(createFarmRscViteConfig, "createFarmRscViteConfig");
+async function createFarmRscDevServer(userConfig, options) {
+  const { createServer } = await import("vite");
+  return createServer(await createFarmRscViteConfig(userConfig, { ...options, command: "serve" }));
+}
+__name(createFarmRscDevServer, "createFarmRscDevServer");
+async function buildFarmRsc(userConfig, options) {
+  const { createBuilder } = await import("vite");
+  const builder = await createBuilder(
+    await createFarmRscViteConfig(userConfig, { ...options, command: "build" })
+  );
+  await builder.buildApp();
+}
+__name(buildFarmRsc, "buildFarmRsc");
+
+export {
+  createFarmRscViteConfig,
+  createFarmRscDevServer,
+  buildFarmRsc
+};

package/dist/chunk-XUGFRFD2.mjs

@@ -0,0 +1,39 @@
+import {
+  runWithServerActionRequest
+} from "./chunk-WMHG64DA.mjs";
+import {
+  getFarmRedirectError,
+  isFarmNotFoundError
+} from "./chunk-CBBLJMR5.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/form-actions.ts
+import { handleAction, registerServerReference } from "@farm.js/islx/server";
+var FARM_FORM_ACTION_HEADER = "F-Action";
+function registerFarmFormAction(action, id) {
+  return registerServerReference(action, id);
+}
+__name(registerFarmFormAction, "registerFarmFormAction");
+function handleFarmFormActionRequest(request, config) {
+  return handleAction(request, {
+    allowedOrigins: config.allowedOrigins,
+    bodySizeLimit: config.bodySizeLimit,
+    run: /* @__PURE__ */ __name((actionRequest, action) => runWithServerActionRequest(actionRequest, action), "run"),
+    mapError(error) {
+      const redirect = getFarmRedirectError(error);
+      if (redirect) return { redirect: redirect.url };
+      if (isFarmNotFoundError(error)) return { status: 404 };
+      return void 0;
+    },
+    onError: /* @__PURE__ */ __name((error) => console.error("[Farm.js] Server action failed:", error), "onError")
+  });
+}
+__name(handleFarmFormActionRequest, "handleFarmFormActionRequest");
+
+export {
+  FARM_FORM_ACTION_HEADER,
+  registerFarmFormAction,
+  handleFarmFormActionRequest
+};

package/dist/{chunk-EH3464KF.cjs → chunk-YBDSTNMH.cjs}

@@ -1,5 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});// package.json
-var version = "0.1.41";
+var version = "0.1.43";
 
 // src/version.ts
 var FARM_VERSION = version;

package/dist/{chunk-VLPII2JJ.mjs → chunk-YGZH4T2X.mjs}

@@ -1,5 +1,5 @@
 // package.json
-var version = "0.1.41";
+var version = "0.1.43";
 
 // src/version.ts
 var FARM_VERSION = version;