@farm.js/core 0.1.42 → 0.1.44

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-NU25TRIO.mjs → chunk-WWYXIECF.mjs}

@@ -2,19 +2,20 @@ import {
   resolveFarmAuthConfig,
   resolveFarmAuthIntegration,
   resolveFarmDevIndicatorsConfig,
+  resolveFarmServerComponentsMode,
   setFarmProjectSourceDir
-} from "./chunk-HCSVR4YZ.mjs";
-import {
-  normalizeRouteRules,
-  routeRulesToHeaders,
-  routeRulesToRedirects
-} from "./chunk-GHFS7RUB.mjs";
+} from "./chunk-M3BXTWJM.mjs";
 import {
   assertPluginDependencies
 } from "./chunk-CZS6OACQ.mjs";
 import {
   resolveFarmDevtoolsConfig
 } from "./chunk-JBSVKMC5.mjs";
+import {
+  normalizeRouteRules,
+  routeRulesToHeaders,
+  routeRulesToRedirects
+} from "./chunk-GHFS7RUB.mjs";
 import {
   isReactRenderer,
   resolveFarmRenderer
@@ -68,7 +69,7 @@ import {
 } from "./chunk-AELACLOB.mjs";
 import {
   resolveIntegrationPlugins
-} from "./chunk-AX7S67YV.mjs";
+} from "./chunk-37VKVISD.mjs";
 import {
   compileMiddlewareConfig
 } from "./chunk-HKFBMHCD.mjs";
@@ -680,6 +681,7 @@ function validateConfigRouteSources(routes, field) {
 }
 __name(validateConfigRouteSources, "validateConfigRouteSources");
 async function resolveConfig(userConfig, mode) {
+  resolveFarmServerComponentsMode(userConfig.experimental?.serverComponents);
   const projectRoot = userConfig.root || process.cwd();
   const layerResolution = await resolveFarmLayers(userConfig, {
     root: projectRoot,
@@ -794,7 +796,9 @@ async function resolveConfig(userConfig, mode) {
     experimental: {
       serverComponents: false,
       serverActions: false,
-      isolatedClientHydration: "off",
+      // Islands mode hydrates client components as islands (RFC 0003); an app can still pick
+      // isolatedClientHydration itself.
+      isolatedClientHydration: resolveFarmServerComponentsMode(userConfig.experimental?.serverComponents) === "islands" ? "enabled" : "off",
       ppr: false,
       ...userConfig.experimental
     },