@farm.js/core 0.1.42 → 0.1.43

package/dist/{chunk-ECKF2BAM.cjs → chunk-2GVF3C2F.cjs}

@@ -1,12 +1,29 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
-var _chunkWWFTAUFGcjs = require('./chunk-WWFTAUFG.cjs');
+
+var _chunkSBH2JLLFcjs = require('./chunk-SBH2JLLF.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkH7BLEEAEcjs = require('./chunk-H7BLEEAE.cjs');
 
 
 var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
 
 // src/client/isolated-boundary.ts
+var ISLAND_SELECTOR = `${_chunkH7BLEEAEcjs.FARM_ISLAND_ELEMENT}[src]`;
+var runtimeTagged = /* @__PURE__ */ new WeakSet();
 var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element");
 var LEGACY_REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element");
 var BOUNDARY_GRAPH_CONTEXT = /* @__PURE__ */ Symbol.for("farm.isolated-hydration.client-graph-context");
@@ -23,6 +40,9 @@ function getBoundaryGraphContext(ReactRuntime) {
 }
 _chunkS3JO3N4Hcjs.__name.call(void 0, getBoundaryGraphContext, "getBoundaryGraphContext");
 function serializeBoundaryProps(value, seen = /* @__PURE__ */ new Set()) {
+  const codec = _chunkH7BLEEAEcjs.getFarmIslandValuesServer.call(void 0, );
+  const leaf = _optionalChain([codec, 'optionalAccess', _ => _.encodeLeaf, 'call', _2 => _2(value)]);
+  if (leaf) return leaf;
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
   if (typeof value === "number") {
     if (!Number.isFinite(value)) throw new TypeError("non-finite numbers are not serializable");
@@ -31,6 +51,10 @@ function serializeBoundaryProps(value, seen = /* @__PURE__ */ new Set()) {
   if (typeof value === "undefined") {
     throw new TypeError("undefined values are not serializable");
   }
+  if (typeof value === "function") {
+    const actionId = _chunkSBH2JLLFcjs.getFarmActionId.call(void 0, value);
+    if (actionId) return { [_chunkH7BLEEAEcjs.FARM_TAG]: _chunkH7BLEEAEcjs.FARM_ACTION_TAG, [_chunkH7BLEEAEcjs.FARM_TAG_VALUE]: actionId };
+  }
   if (typeof value !== "object") {
     throw new TypeError(`${typeof value} values are not serializable`);
   }
@@ -41,22 +65,143 @@ function serializeBoundaryProps(value, seen = /* @__PURE__ */ new Set()) {
   seen.add(value);
   try {
     if (Array.isArray(value)) return value.map((entry) => serializeBoundaryProps(entry, seen));
+    if (codec && value instanceof Map) {
+      return {
+        [_chunkH7BLEEAEcjs.FARM_TAG]: "M",
+        [_chunkH7BLEEAEcjs.FARM_TAG_VALUE]: Array.from(value, ([key, entry]) => [
+          serializeBoundaryProps(key, seen),
+          serializeBoundaryProps(entry, seen)
+        ])
+      };
+    }
+    if (codec && value instanceof Set) {
+      return {
+        [_chunkH7BLEEAEcjs.FARM_TAG]: "S",
+        [_chunkH7BLEEAEcjs.FARM_TAG_VALUE]: Array.from(value, (entry) => serializeBoundaryProps(entry, seen))
+      };
+    }
     const prototype = Object.getPrototypeOf(value);
     if (prototype !== Object.prototype && prototype !== null) {
       throw new TypeError("class instances are not serializable");
     }
-    return Object.fromEntries(
+    const serialized = Object.fromEntries(
       Object.entries(value).map(([key, entry]) => [key, serializeBoundaryProps(entry, seen)])
     );
+    return codec && !runtimeTagged.has(value) && Object.prototype.hasOwnProperty.call(value, _chunkH7BLEEAEcjs.FARM_TAG) ? { [_chunkH7BLEEAEcjs.FARM_TAG]: _chunkH7BLEEAEcjs.FARM_OBJECT_TAG, [_chunkH7BLEEAEcjs.FARM_TAG_VALUE]: serialized } : serialized;
   } finally {
     seen.delete(value);
   }
 }
 _chunkS3JO3N4Hcjs.__name.call(void 0, serializeBoundaryProps, "serializeBoundaryProps");
 function serializeBoundaryPayload(value) {
-  return JSON.stringify(serializeBoundaryProps(value)).replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  return escapeScriptJson(JSON.stringify(serializeBoundaryProps(value)));
 }
 _chunkS3JO3N4Hcjs.__name.call(void 0, serializeBoundaryPayload, "serializeBoundaryPayload");
+function escapeScriptJson(json) {
+  return json.replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, escapeScriptJson, "escapeScriptJson");
+var SLOT_ELEMENT = _chunkH7BLEEAEcjs.FARM_SLOT_ELEMENT;
+function isReactElementValue(value) {
+  const type = _optionalChain([value, 'optionalAccess', _3 => _3.$$typeof]);
+  return type === REACT_ELEMENT_TYPE || type === LEGACY_REACT_ELEMENT_TYPE;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isReactElementValue, "isReactElementValue");
+function slotReference(id) {
+  const reference = { [_chunkH7BLEEAEcjs.FARM_TAG]: _chunkH7BLEEAEcjs.FARM_SLOT_TAG, [_chunkH7BLEEAEcjs.FARM_TAG_VALUE]: id };
+  runtimeTagged.add(reference);
+  return reference;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, slotReference, "slotReference");
+function splitSlotProps(ReactRuntime, value, slotPrefix, counter) {
+  if (isReactElementValue(value)) {
+    const id = `${slotPrefix}${counter.next++}`;
+    return {
+      render: ReactRuntime.createElement(
+        SLOT_ELEMENT,
+        { key: _nullishCoalesce(value.key, () => ( id)), name: id, style: { display: "contents" } },
+        value
+      ),
+      wire: slotReference(id)
+    };
+  }
+  if (Array.isArray(value)) {
+    const parts = value.map((entry) => splitSlotProps(ReactRuntime, entry, slotPrefix, counter));
+    return { render: parts.map((part) => part.render), wire: parts.map((part) => part.wire) };
+  }
+  if (value && typeof value === "object") {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) return { render: value, wire: value };
+    const render = {};
+    const wire = {};
+    for (const [key, entry] of Object.entries(value)) {
+      const part = splitSlotProps(ReactRuntime, entry, slotPrefix, counter);
+      render[key] = part.render;
+      wire[key] = part.wire;
+    }
+    return { render, wire };
+  }
+  return { render: value, wire: value };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, splitSlotProps, "splitSlotProps");
+var FARM_NOT_A_MARKER = /* @__PURE__ */ Symbol.for("farm.codec.not-a-marker");
+function reviveSlotProps(ReactRuntime, value, container, actions, decode) {
+  if (Array.isArray(value)) {
+    let changed2 = false;
+    const revived2 = value.map((entry) => {
+      const next = reviveSlotProps(ReactRuntime, entry, container, actions, decode);
+      if (next !== entry) changed2 = true;
+      return next;
+    });
+    return changed2 ? revived2 : value;
+  }
+  if (!value || typeof value !== "object") return value;
+  const tag = decode || actions ? _chunkH7BLEEAEcjs.getFarmTag.call(void 0, value) : void 0;
+  const data = tag === void 0 ? void 0 : value[_chunkH7BLEEAEcjs.FARM_TAG_VALUE];
+  if (tag === _chunkH7BLEEAEcjs.FARM_ACTION_TAG && typeof data === "string") {
+    if (!actions) throw new Error("server action props need islands mode");
+    return actions(data);
+  }
+  if (tag === _chunkH7BLEEAEcjs.FARM_SLOT_TAG && typeof data === "string") {
+    let html = "";
+    for (const slot of container.querySelectorAll(SLOT_ELEMENT)) {
+      if (slot.getAttribute("name") === data) {
+        html = slot.innerHTML;
+        break;
+      }
+    }
+    return ReactRuntime.createElement(SLOT_ELEMENT, {
+      key: data,
+      name: data,
+      style: { display: "contents" },
+      suppressHydrationWarning: true,
+      dangerouslySetInnerHTML: { __html: html }
+    });
+  }
+  if (tag === _chunkH7BLEEAEcjs.FARM_REFERENCE_TAG) throw new Error(`island value ${String(data)} was not resolved`);
+  if (tag !== void 0) {
+    if (!decode) throw new Error("typed props need islands mode");
+    const decoded = decode(
+      value,
+      (child) => reviveSlotProps(ReactRuntime, child, container, actions, decode)
+    );
+    if (decoded !== FARM_NOT_A_MARKER) return decoded;
+  }
+  let changed = false;
+  const revived = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const next = reviveSlotProps(ReactRuntime, entry, container, actions, decode);
+    Object.defineProperty(revived, key, {
+      value: next,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+    if (next !== entry) changed = true;
+  }
+  return changed ? revived : value;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, reviveSlotProps, "reviveSlotProps");
 function wrapFarmIsolatedClientGraph(ReactRuntime, element) {
   const Context = getBoundaryGraphContext(ReactRuntime);
   return ReactRuntime.createElement(Context.Provider, { value: true }, element);
@@ -68,7 +213,7 @@ function isolateFarmServerPageGraph(ReactRuntime, element) {
 }
 _chunkS3JO3N4Hcjs.__name.call(void 0, isolateFarmServerPageGraph, "isolateFarmServerPageGraph");
 var warnedUnserializableBoundaries = /* @__PURE__ */ new Set();
-function createFarmIsolatedClientBoundary(ReactRuntime, Component, moduleReference, exportName, islandStrategy) {
+function createFarmIsolatedClientBoundary(ReactRuntime, Component, moduleReference, exportName, islandStrategy, boundaryOptions = {}) {
   function FarmIsolatedClientBoundary(props) {
     const Context = getBoundaryGraphContext(ReactRuntime);
     const belongsToParentClientGraph = ReactRuntime.useContext(Context);
@@ -77,8 +222,30 @@ function createFarmIsolatedClientBoundary(ReactRuntime, Component, moduleReferen
       return ReactRuntime.createElement(Component, props);
     }
     let serializedProps;
+    let renderProps = props;
+    let valueScripts = [];
     try {
-      serializedProps = serializeBoundaryPayload(props);
+      if (boundaryOptions.slots) {
+        const { render, wire } = splitSlotProps(ReactRuntime, props, `${boundaryId}s`, { next: 0 });
+        renderProps = render;
+        const values = boundaryOptions.values ? _chunkH7BLEEAEcjs.getFarmIslandValuesServer.call(void 0, ) : void 0;
+        if (values) {
+          const addressed = values.address(serializeBoundaryProps(wire));
+          serializedProps = escapeScriptJson(addressed.json);
+          valueScripts = values.select(addressed, values.held()).map(
+            (value) => ReactRuntime.createElement("script", {
+              key: value.key,
+              type: _chunkH7BLEEAEcjs.FARM_VALUE_SCRIPT_TYPE,
+              name: value.key,
+              dangerouslySetInnerHTML: { __html: escapeScriptJson(value.json) }
+            })
+          );
+        } else {
+          serializedProps = serializeBoundaryPayload(wire);
+        }
+      } else {
+        serializedProps = serializeBoundaryPayload(props);
+      }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       const warningKey = `${moduleReference}#${exportName}:${message}`;
@@ -93,31 +260,32 @@ function createFarmIsolatedClientBoundary(ReactRuntime, Component, moduleReferen
     return ReactRuntime.createElement(
       ReactRuntime.Fragment,
       null,
+      ...valueScripts,
       ReactRuntime.createElement(
-        "farm-client-boundary",
+        _chunkH7BLEEAEcjs.FARM_ISLAND_ELEMENT,
         {
-          "data-farm-client-boundary": moduleReference,
-          "data-farm-client-id": boundaryId,
-          "data-farm-client-export": exportName,
-          "data-farm-island-strategy": islandStrategy,
+          src: moduleReference,
+          export: exportName,
+          props: boundaryId,
+          strategy: islandStrategy,
           style: { display: "contents" }
         },
         ReactRuntime.createElement(
           Context.Provider,
           { value: true },
-          ReactRuntime.createElement(Component, props)
+          ReactRuntime.createElement(Component, renderProps)
         )
       ),
       ReactRuntime.createElement("script", {
-        type: "application/json",
-        "data-farm-client-props": boundaryId,
+        type: _chunkH7BLEEAEcjs.FARM_PROPS_SCRIPT_TYPE,
+        htmlFor: boundaryId,
         dangerouslySetInnerHTML: { __html: serializedProps }
       })
     );
   }
   _chunkS3JO3N4Hcjs.__name.call(void 0, FarmIsolatedClientBoundary, "FarmIsolatedClientBoundary");
   FarmIsolatedClientBoundary.displayName = `FarmIsolated(${Component.displayName || Component.name || exportName})`;
-  _chunkWWFTAUFGcjs.markFarmClientReference.call(void 0, FarmIsolatedClientBoundary, {
+  _chunkSBH2JLLFcjs.markFarmClientReference.call(void 0, FarmIsolatedClientBoundary, {
     reference: moduleReference,
     exportName,
     Component
@@ -131,13 +299,13 @@ function isEarlyHydrationUpdate(error) {
 _chunkS3JO3N4Hcjs.__name.call(void 0, isEarlyHydrationUpdate, "isEarlyHydrationUpdate");
 function findBoundaryPayload(container, boundaryId) {
   const sibling = container.nextElementSibling;
-  if (sibling instanceof HTMLScriptElement && sibling.type === "application/json" && sibling.getAttribute("data-farm-client-props") === boundaryId) {
+  if (sibling instanceof HTMLScriptElement && sibling.type === _chunkH7BLEEAEcjs.FARM_PROPS_SCRIPT_TYPE && sibling.getAttribute("for") === boundaryId) {
     return sibling;
   }
   for (const candidate of container.ownerDocument.querySelectorAll(
-    'script[type="application/json"][data-farm-client-props]'
+    `script[type="${_chunkH7BLEEAEcjs.FARM_PROPS_SCRIPT_TYPE}"]`
   )) {
-    if (candidate.getAttribute("data-farm-client-props") === boundaryId) return candidate;
+    if (candidate.getAttribute("for") === boundaryId) return candidate;
   }
   return null;
 }
@@ -153,7 +321,7 @@ function createFarmIsolatedHydrationRuntime(options) {
     );
     queueMicrotask(() => {
       try {
-        _optionalChain([roots, 'access', _ => _.get, 'call', _2 => _2(container), 'optionalAccess', _3 => _3.root, 'access', _4 => _4.unmount, 'call', _5 => _5()]);
+        _optionalChain([roots, 'access', _4 => _4.get, 'call', _5 => _5(container), 'optionalAccess', _6 => _6.root, 'access', _7 => _7.unmount, 'call', _8 => _8()]);
       } catch (e) {
       }
       roots.delete(container);
@@ -191,23 +359,73 @@ function createFarmIsolatedHydrationRuntime(options) {
       )
     );
   }, "createBoundaryGraph");
-  async function hydrate(scope = document, signal) {
-    const candidates = Array.from(
-      scope.querySelectorAll("farm-client-boundary[data-farm-client-boundary]")
+  function readBoundaryProps(container, boundaryId) {
+    const payload = findBoundaryPayload(container, boundaryId);
+    if (!payload) throw new Error(`serialized props ${boundaryId} were not found`);
+    const parsedProps = JSON.parse(payload.textContent || "{}");
+    if (!parsedProps || typeof parsedProps !== "object" || Array.isArray(parsedProps)) {
+      throw new Error("serialized props must be an object");
+    }
+    let resolvedProps = parsedProps;
+    if (_optionalChain([payload, 'access', _9 => _9.textContent, 'optionalAccess', _10 => _10.includes, 'call', _11 => _11(`"${_chunkH7BLEEAEcjs.FARM_TAG}":"${_chunkH7BLEEAEcjs.FARM_REFERENCE_TAG}"`)])) {
+      if (!options.values) throw new Error("island values need islands mode");
+      options.values.ingest(container.ownerDocument);
+      resolvedProps = options.values.resolve(parsedProps);
+    }
+    return reviveSlotProps(
+      options.ReactRuntime,
+      resolvedProps,
+      container,
+      options.actions,
+      options.decode
     );
-    if (scope instanceof Element && scope.matches("farm-client-boundary[data-farm-client-boundary]")) {
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, readBoundaryProps, "readBoundaryProps");
+  const topLevelBoundaries = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (scope) => Array.from(scope.querySelectorAll(ISLAND_SELECTOR)).filter(
+    (container) => !_optionalChain([container, 'access', _12 => _12.parentElement, 'optionalAccess', _13 => _13.closest, 'call', _14 => _14(ISLAND_SELECTOR)])
+  ), "topLevelBoundaries");
+  const boundaryKey = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (container) => `${container.getAttribute("src")}#${container.getAttribute("export") || "default"}`, "boundaryKey");
+  function carryOver(current, next) {
+    const live = /* @__PURE__ */ new Map();
+    for (const container of topLevelBoundaries(current)) {
+      if (!roots.has(container)) continue;
+      const key = boundaryKey(container);
+      live.set(key, [..._nullishCoalesce(live.get(key), () => ( [])), container]);
+    }
+    let carried = 0;
+    for (const container of topLevelBoundaries(next)) {
+      const previous = _optionalChain([live, 'access', _15 => _15.get, 'call', _16 => _16(boundaryKey(container)), 'optionalAccess', _17 => _17.shift, 'call', _18 => _18()]);
+      const record = previous && roots.get(previous);
+      const boundaryId = container.getAttribute("props");
+      if (!previous || !record || !boundaryId) continue;
+      try {
+        const props = readBoundaryProps(container, boundaryId);
+        record.root.render(createBoundaryGraph(record.Component, props, record.restore));
+        record.props = props;
+        container.replaceWith(previous);
+        carried++;
+      } catch (error) {
+        report(`Could not keep ${boundaryKey(container)} across the refresh.`, error);
+      }
+    }
+    return carried;
+  }
+  _chunkS3JO3N4Hcjs.__name.call(void 0, carryOver, "carryOver");
+  async function hydrate(scope = document, signal) {
+    const candidates = Array.from(scope.querySelectorAll(ISLAND_SELECTOR));
+    if (scope instanceof Element && scope.matches(ISLAND_SELECTOR)) {
       candidates.unshift(scope);
     }
     const boundaries = candidates.filter((container) => {
       if (roots.has(container) || pending.has(container)) return false;
-      return !_optionalChain([container, 'access', _6 => _6.parentElement, 'optionalAccess', _7 => _7.closest, 'call', _8 => _8("farm-client-boundary[data-farm-client-boundary]")]);
+      return !_optionalChain([container, 'access', _19 => _19.parentElement, 'optionalAccess', _20 => _20.closest, 'call', _21 => _21(ISLAND_SELECTOR)]);
     });
     await Promise.all(
       boundaries.map(async (container) => {
-        const reference = container.getAttribute("data-farm-client-boundary");
-        const boundaryId = container.getAttribute("data-farm-client-id");
-        const exportName = container.getAttribute("data-farm-client-export") || "default";
-        const strategy = _nullishCoalesce(container.getAttribute("data-farm-island-strategy"), () => ( "load"));
+        const reference = container.getAttribute("src");
+        const boundaryId = container.getAttribute("props");
+        const exportName = container.getAttribute("export") || "default";
+        const strategy = _nullishCoalesce(container.getAttribute("strategy"), () => ( "load"));
         if (!reference || !boundaryId) {
           report("An isolated client boundary is missing its module reference or payload ID.");
           return;
@@ -219,10 +437,10 @@ function createFarmIsolatedHydrationRuntime(options) {
         }, "releasePending");
         controller.signal.addEventListener("abort", releasePending, { once: true });
         const abort = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => controller.abort(), "abort");
-        if (_optionalChain([signal, 'optionalAccess', _9 => _9.aborted])) abort();
-        else _optionalChain([signal, 'optionalAccess', _10 => _10.addEventListener, 'call', _11 => _11("abort", abort, { once: true })]);
+        if (_optionalChain([signal, 'optionalAccess', _22 => _22.aborted])) abort();
+        else _optionalChain([signal, 'optionalAccess', _23 => _23.addEventListener, 'call', _24 => _24("abort", abort, { once: true })]);
         const cleanup = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
-          _optionalChain([signal, 'optionalAccess', _12 => _12.removeEventListener, 'call', _13 => _13("abort", abort)]);
+          _optionalChain([signal, 'optionalAccess', _25 => _25.removeEventListener, 'call', _26 => _26("abort", abort)]);
           releasePending();
         }, "cleanup");
         let scheduled;
@@ -238,16 +456,11 @@ function createFarmIsolatedHydrationRuntime(options) {
                 const module = await options.load(reference);
                 if (controller.signal.aborted || !container.isConnected) return;
                 const originals = module.__farm_client_boundary_originals__;
-                const Component = _optionalChain([originals, 'optionalAccess', _14 => _14[exportName]]);
+                const Component = _optionalChain([originals, 'optionalAccess', _27 => _27[exportName]]);
                 if (typeof Component !== "function" && typeof Component !== "object") {
                   throw new Error("compiled original export was not found");
                 }
-                const payload = findBoundaryPayload(container, boundaryId);
-                if (!payload) throw new Error(`serialized props ${boundaryId} were not found`);
-                const props = JSON.parse(payload.textContent || "{}");
-                if (!props || typeof props !== "object" || Array.isArray(props)) {
-                  throw new Error("serialized props must be an object");
-                }
+                const props = readBoundaryProps(container, boundaryId);
                 let rootFailure;
                 const restore = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (error) => {
                   if (rootFailure !== void 0) return;
@@ -271,6 +484,7 @@ function createFarmIsolatedHydrationRuntime(options) {
                 });
                 roots.set(container, {
                   root,
+                  Component,
                   dispose() {
                     disposing = true;
                     try {
@@ -313,10 +527,10 @@ function createFarmIsolatedHydrationRuntime(options) {
   _chunkS3JO3N4Hcjs.__name.call(void 0, hydrate, "hydrate");
   function updateModule(reference, module) {
     const originals = module.__farm_client_boundary_originals__;
-    let updated = _chunkWWFTAUFGcjs.updateFarmServerTreeModule.call(void 0, reference, module);
+    let updated = _chunkSBH2JLLFcjs.updateFarmServerTreeModule.call(void 0, reference, module);
     for (const [container, record] of roots) {
       if (record.reference !== reference) continue;
-      const Component = _optionalChain([originals, 'optionalAccess', _15 => _15[record.exportName]]);
+      const Component = _optionalChain([originals, 'optionalAccess', _28 => _28[record.exportName]]);
       if (typeof Component !== "function" && typeof Component !== "object") {
         failRoot(
           container,
@@ -361,6 +575,7 @@ function createFarmIsolatedHydrationRuntime(options) {
   _chunkS3JO3N4Hcjs.__name.call(void 0, dispose, "dispose");
   return {
     hydrate,
+    carryOver,
     updateModule,
     dispose,
     rootCount: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => roots.size, "rootCount")
@@ -374,9 +589,7 @@ function createFarmServerPageBoundary(ReactRuntime, runtime) {
     ReactRuntime.useLayoutEffect(() => {
       const page = ref.current;
       if (!page) return;
-      const islands = Array.from(
-        page.querySelectorAll("farm-client-boundary[data-farm-client-boundary]")
-      );
+      const islands = Array.from(page.querySelectorAll(ISLAND_SELECTOR));
       if (islands.length === 0) return;
       const controller = new AbortController();
       runtime.hydrate(page, controller.signal).catch((error) => {

package/dist/chunk-2NXO5SBY.mjs

@@ -0,0 +1,57 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/client/island-value-protocol.ts
+var FARM_ISLAND_ELEMENT = "f-island";
+var FARM_PROPS_SCRIPT_TYPE = "f/props";
+var FARM_VALUE_SCRIPT_TYPE = "f/value";
+var FARM_SLOT_ELEMENT = "f-slot";
+var FARM_TAG = "$";
+var FARM_TAG_VALUE = "v";
+var FARM_REFERENCE_TAG = "r";
+var FARM_SLOT_TAG = "s";
+var FARM_ACTION_TAG = "a";
+var FARM_OBJECT_TAG = "o";
+var FARM_VALUES_HEADER = "F-Values";
+function getFarmTag(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const tag = value[FARM_TAG];
+  if (typeof tag !== "string") return void 0;
+  const keys = Object.keys(value);
+  return keys.length === 1 || keys.length === 2 && FARM_TAG_VALUE in value ? tag : void 0;
+}
+__name(getFarmTag, "getFarmTag");
+var FARM_VALUE_KEY_PATTERN = /^[0-9a-z]{14}$/;
+var FARM_MAX_HELD_VALUES = 128;
+var FARM_ISLAND_VALUE_STORE_KEY = /* @__PURE__ */ Symbol.for("islx.values");
+var ISLAND_VALUES_SERVER_KEY = /* @__PURE__ */ Symbol.for("farm.island-values.server");
+function getFarmIslandValuesServer() {
+  return globalThis[ISLAND_VALUES_SERVER_KEY];
+}
+__name(getFarmIslandValuesServer, "getFarmIslandValuesServer");
+function getFarmIslandValueHeaders() {
+  const scope = globalThis;
+  const held = scope[FARM_ISLAND_VALUE_STORE_KEY]?.heldHeader();
+  return held ? { [FARM_VALUES_HEADER]: held } : {};
+}
+__name(getFarmIslandValueHeaders, "getFarmIslandValueHeaders");
+
+export {
+  FARM_ISLAND_ELEMENT,
+  FARM_PROPS_SCRIPT_TYPE,
+  FARM_VALUE_SCRIPT_TYPE,
+  FARM_SLOT_ELEMENT,
+  FARM_TAG,
+  FARM_TAG_VALUE,
+  FARM_REFERENCE_TAG,
+  FARM_SLOT_TAG,
+  FARM_ACTION_TAG,
+  FARM_OBJECT_TAG,
+  FARM_VALUES_HEADER,
+  getFarmTag,
+  FARM_VALUE_KEY_PATTERN,
+  FARM_MAX_HELD_VALUES,
+  getFarmIslandValuesServer,
+  getFarmIslandValueHeaders
+};

package/dist/chunk-3BROEWFY.cjs

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkP4TYB4SFcjs = require('./chunk-P4TYB4SF.cjs');
+
+
+
+var _chunkOX6O6WVAcjs = require('./chunk-OX6O6WVA.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/form-actions.ts
+var _server = require('@farm.js/islx/server');
+var FARM_FORM_ACTION_HEADER = "F-Action";
+function registerFarmFormAction(action, id) {
+  return _server.registerServerReference.call(void 0, action, id);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, registerFarmFormAction, "registerFarmFormAction");
+function handleFarmFormActionRequest(request, config) {
+  return _server.handleAction.call(void 0, request, {
+    allowedOrigins: config.allowedOrigins,
+    bodySizeLimit: config.bodySizeLimit,
+    run: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (actionRequest, action) => _chunkP4TYB4SFcjs.runWithServerActionRequest.call(void 0, actionRequest, action), "run"),
+    mapError(error) {
+      const redirect = _chunkOX6O6WVAcjs.getFarmRedirectError.call(void 0, error);
+      if (redirect) return { redirect: redirect.url };
+      if (_chunkOX6O6WVAcjs.isFarmNotFoundError.call(void 0, error)) return { status: 404 };
+      return void 0;
+    },
+    onError: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (error) => console.error("[Farm.js] Server action failed:", error), "onError")
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, handleFarmFormActionRequest, "handleFarmFormActionRequest");
+
+
+
+
+
+exports.FARM_FORM_ACTION_HEADER = FARM_FORM_ACTION_HEADER; exports.registerFarmFormAction = registerFarmFormAction; exports.handleFarmFormActionRequest = handleFarmFormActionRequest;

package/dist/{chunk-NU25TRIO.mjs → chunk-4MRQ5OKQ.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
@@ -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
     },