@farm.js/core 0.1.42 → 0.1.44

package/dist/{chunk-YWMZUGIS.mjs → chunk-R3ZFQJEF.mjs}

@@ -1,12 +1,29 @@
 import {
+  getFarmActionId,
   markFarmClientReference,
   updateFarmServerTreeModule
-} from "./chunk-NRDBW4MP.mjs";
+} from "./chunk-7IQQIPRZ.mjs";
+import {
+  FARM_ACTION_TAG,
+  FARM_ISLAND_ELEMENT,
+  FARM_OBJECT_TAG,
+  FARM_PROPS_SCRIPT_TYPE,
+  FARM_REFERENCE_TAG,
+  FARM_SLOT_ELEMENT,
+  FARM_SLOT_TAG,
+  FARM_TAG,
+  FARM_TAG_VALUE,
+  FARM_VALUE_SCRIPT_TYPE,
+  getFarmIslandValuesServer,
+  getFarmTag
+} from "./chunk-2NXO5SBY.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";
 
 // src/client/isolated-boundary.ts
+var ISLAND_SELECTOR = `${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) {
 }
 __name(getBoundaryGraphContext, "getBoundaryGraphContext");
 function serializeBoundaryProps(value, seen = /* @__PURE__ */ new Set()) {
+  const codec = getFarmIslandValuesServer();
+  const leaf = codec?.encodeLeaf(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 = getFarmActionId(value);
+    if (actionId) return { [FARM_TAG]: FARM_ACTION_TAG, [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 {
+        [FARM_TAG]: "M",
+        [FARM_TAG_VALUE]: Array.from(value, ([key, entry]) => [
+          serializeBoundaryProps(key, seen),
+          serializeBoundaryProps(entry, seen)
+        ])
+      };
+    }
+    if (codec && value instanceof Set) {
+      return {
+        [FARM_TAG]: "S",
+        [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, FARM_TAG) ? { [FARM_TAG]: FARM_OBJECT_TAG, [FARM_TAG_VALUE]: serialized } : serialized;
   } finally {
     seen.delete(value);
   }
 }
 __name(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)));
 }
 __name(serializeBoundaryPayload, "serializeBoundaryPayload");
+function escapeScriptJson(json) {
+  return json.replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+__name(escapeScriptJson, "escapeScriptJson");
+var SLOT_ELEMENT = FARM_SLOT_ELEMENT;
+function isReactElementValue(value) {
+  const type = value?.$$typeof;
+  return type === REACT_ELEMENT_TYPE || type === LEGACY_REACT_ELEMENT_TYPE;
+}
+__name(isReactElementValue, "isReactElementValue");
+function slotReference(id) {
+  const reference = { [FARM_TAG]: FARM_SLOT_TAG, [FARM_TAG_VALUE]: id };
+  runtimeTagged.add(reference);
+  return reference;
+}
+__name(slotReference, "slotReference");
+function splitSlotProps(ReactRuntime, value, slotPrefix, counter) {
+  if (isReactElementValue(value)) {
+    const id = `${slotPrefix}${counter.next++}`;
+    return {
+      render: ReactRuntime.createElement(
+        SLOT_ELEMENT,
+        { key: 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 };
+}
+__name(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 ? getFarmTag(value) : void 0;
+  const data = tag === void 0 ? void 0 : value[FARM_TAG_VALUE];
+  if (tag === FARM_ACTION_TAG && typeof data === "string") {
+    if (!actions) throw new Error("server action props need islands mode");
+    return actions(data);
+  }
+  if (tag === 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 === 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;
+}
+__name(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) {
 }
 __name(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 ? getFarmIslandValuesServer() : 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: 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,24 +260,25 @@ function createFarmIsolatedClientBoundary(ReactRuntime, Component, moduleReferen
     return ReactRuntime.createElement(
       ReactRuntime.Fragment,
       null,
+      ...valueScripts,
       ReactRuntime.createElement(
-        "farm-client-boundary",
+        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: FARM_PROPS_SCRIPT_TYPE,
+        htmlFor: boundaryId,
         dangerouslySetInnerHTML: { __html: serializedProps }
       })
     );
@@ -131,13 +299,13 @@ function isEarlyHydrationUpdate(error) {
 __name(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 === 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="${FARM_PROPS_SCRIPT_TYPE}"]`
   )) {
-    if (candidate.getAttribute("data-farm-client-props") === boundaryId) return candidate;
+    if (candidate.getAttribute("for") === boundaryId) return candidate;
   }
   return null;
 }
@@ -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 (payload.textContent?.includes(`"${FARM_TAG}":"${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]")) {
+  }
+  __name(readBoundaryProps, "readBoundaryProps");
+  const topLevelBoundaries = /* @__PURE__ */ __name((scope) => Array.from(scope.querySelectorAll(ISLAND_SELECTOR)).filter(
+    (container) => !container.parentElement?.closest(ISLAND_SELECTOR)
+  ), "topLevelBoundaries");
+  const boundaryKey = /* @__PURE__ */ __name((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, [...live.get(key) ?? [], container]);
+    }
+    let carried = 0;
+    for (const container of topLevelBoundaries(next)) {
+      const previous = live.get(boundaryKey(container))?.shift();
+      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;
+  }
+  __name(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 !container.parentElement?.closest("farm-client-boundary[data-farm-client-boundary]");
+      return !container.parentElement?.closest(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 = 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 = container.getAttribute("strategy") ?? "load";
         if (!reference || !boundaryId) {
           report("An isolated client boundary is missing its module reference or payload ID.");
           return;
@@ -242,12 +460,7 @@ function createFarmIsolatedHydrationRuntime(options) {
                 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__ */ __name((error) => {
                   if (rootFailure !== void 0) return;
@@ -271,6 +484,7 @@ function createFarmIsolatedHydrationRuntime(options) {
                 });
                 roots.set(container, {
                   root,
+                  Component,
                   dispose() {
                     disposing = true;
                     try {
@@ -361,6 +575,7 @@ function createFarmIsolatedHydrationRuntime(options) {
   __name(dispose, "dispose");
   return {
     hydrate,
+    carryOver,
     updateModule,
     dispose,
     rootCount: /* @__PURE__ */ __name(() => 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-U2UC7UGP.mjs → chunk-R4J2UOV4.mjs}

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

package/dist/chunk-S34OBRMZ.mjs

@@ -0,0 +1,109 @@
+import {
+  formatOptionalPeerInstallHint,
+  isMissingPackageError
+} from "./chunk-YOZYCI6Z.mjs";
+import {
+  logger
+} from "./chunk-KI3MESHB.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/build/tailwind.ts
+import path from "path";
+
+// src/build/vite-plugin-compat.ts
+function adaptTailwindVitePlugin(pluginOption, builder) {
+  if (builder !== "rolldown") return pluginOption;
+  return adaptPluginOption(pluginOption);
+}
+__name(adaptTailwindVitePlugin, "adaptTailwindVitePlugin");
+function adaptPluginOption(pluginOption) {
+  if (Array.isArray(pluginOption)) return pluginOption.map(adaptPluginOption);
+  if (!pluginOption || typeof pluginOption !== "object") return pluginOption;
+  const plugin = pluginOption;
+  if (!plugin.name?.startsWith("@tailwindcss/vite:generate:")) return pluginOption;
+  if (isVitePluginHook(plugin.transform)) {
+    return {
+      ...plugin,
+      transform: withVite5TransformContext(plugin.transform)
+    };
+  }
+  if (plugin.transform && typeof plugin.transform === "object" && "handler" in plugin.transform && isVitePluginHook(plugin.transform.handler)) {
+    return {
+      ...plugin,
+      transform: {
+        ...plugin.transform,
+        handler: withVite5TransformContext(plugin.transform.handler)
+      }
+    };
+  }
+  return pluginOption;
+}
+__name(adaptPluginOption, "adaptPluginOption");
+function isVitePluginHook(value) {
+  return typeof value === "function";
+}
+__name(isVitePluginHook, "isVitePluginHook");
+function withVite5TransformContext(handler) {
+  return function(...args) {
+    const context = new Proxy(this, {
+      get(target, property, receiver) {
+        if (property === "environment") return void 0;
+        return Reflect.get(target, property, receiver);
+      }
+    });
+    return handler.apply(context, args);
+  };
+}
+__name(withVite5TransformContext, "withVite5TransformContext");
+
+// src/build/tailwind.ts
+var TAILWIND_CSS_IMPORT = /@import\s+["']tailwindcss["']/;
+var TAILWIND_VITE_INSTALL_HINT = formatOptionalPeerInstallHint(
+  "@tailwindcss/vite",
+  "enable built-in Tailwind CSS support",
+  { dev: true }
+);
+var warnedMissingTailwind = false;
+async function loadTailwindVitePlugin(options = {}, importTailwind = () => import("@tailwindcss/vite")) {
+  try {
+    const tailwindVite = (await importTailwind()).default;
+    const plugin = options.builder ? adaptTailwindVitePlugin(tailwindVite(), options.builder) : tailwindVite();
+    if (options.announce) logger.info("\u{1F4E6} Enabled built-in Tailwind support (@tailwindcss/vite)");
+    return plugin;
+  } catch (error) {
+    if (isMissingPackageError(error, "@tailwindcss/vite")) return createMissingTailwindPlugin();
+    logger.warn(
+      `Tailwind plugin auto-enable failed${options.label ? ` ${options.label}` : ""}; continuing without it: ${error.message}`
+    );
+    return void 0;
+  }
+}
+__name(loadTailwindVitePlugin, "loadTailwindVitePlugin");
+function createMissingTailwindPlugin() {
+  let root = process.cwd();
+  return {
+    name: "farm:tailwind-missing",
+    enforce: "pre",
+    configResolved(config) {
+      root = config.root;
+    },
+    transform(code, id) {
+      if (warnedMissingTailwind || !/\.css(?:\?.*)?$/.test(id) || !TAILWIND_CSS_IMPORT.test(code)) {
+        return null;
+      }
+      warnedMissingTailwind = true;
+      const file = path.relative(root, id.split("?", 1)[0]).replace(/\\/g, "/");
+      logger.warn(
+        `${file} imports Tailwind CSS, but @tailwindcss/vite is not installed; continuing without Tailwind. ${TAILWIND_VITE_INSTALL_HINT}`
+      );
+      return null;
+    }
+  };
+}
+__name(createMissingTailwindPlugin, "createMissingTailwindPlugin");
+
+export {
+  loadTailwindVitePlugin
+};

package/dist/{chunk-TS4JHGUJ.mjs → chunk-S3ZEMCE6.mjs}

@@ -18,6 +18,9 @@ import {
   renderMetadataHead,
   resolveMetadataTitle
 } from "./chunk-73WX6PRY.mjs";
+import {
+  getFarmIslandValueHeaders
+} from "./chunk-2NXO5SBY.mjs";
 import {
   createFarmDeploymentMismatchError,
   createFarmDeploymentRequestHeaders,
@@ -300,7 +303,8 @@ var _SPARouter = class _SPARouter {
           replace,
           scroll,
           state,
-          url
+          url,
+          refresh
         }) : Promise.resolve()
       );
       if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
@@ -527,7 +531,7 @@ var _SPARouter = class _SPARouter {
     this.updateDocumentMetadata(options.pageData.metadata);
     _hydrateFarmI18n(options.pageData.i18n);
     if (this.onNavigate) {
-      await this.onNavigate(options.pageData);
+      await this.onNavigate(options.pageData, { refresh: options.refresh === true });
     }
     if (options.scroll) {
       if (options.url.hash) {
@@ -629,7 +633,9 @@ var _SPARouter = class _SPARouter {
         Accept: "application/x-farm-deferred+json, application/json",
         "X-Farm-SPA": "1",
         ...activeLayoutChain ? { "X-Farm-Layout-Chain": activeLayoutChain } : {},
-        ...interceptFrom ? { "X-Farm-Intercept-From": interceptFrom } : {}
+        ...interceptFrom ? { "X-Farm-Intercept-From": interceptFrom } : {},
+        // Islands mode: the server leaves out island values this browser holds.
+        ...getFarmIslandValueHeaders()
       })
     });
     if (isFarmDeploymentMismatchResponse(response, this.options.deploymentId)) {

package/dist/{chunk-WWFTAUFG.cjs → chunk-SBH2JLLF.cjs}

@@ -1,7 +1,16 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+"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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
 
+// src/client/action-reference.ts
+var ACTION_IDS_KEY = /* @__PURE__ */ Symbol.for("farm.form-actions.ids");
+function getFarmActionId(value) {
+  if (typeof value !== "function") return void 0;
+  const scope = globalThis;
+  return _optionalChain([scope, 'access', _ => _[ACTION_IDS_KEY], 'optionalAccess', _2 => _2.get, 'call', _3 => _3(value)]);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmActionId, "getFarmActionId");
+
 // src/client/client-reference.ts
 var CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("farm.isolated-hydration.client-reference");
 function markFarmClientReference(boundary, reference) {
@@ -42,4 +51,5 @@ _chunkS3JO3N4Hcjs.__name.call(void 0, updateFarmServerTreeModule, "updateFarmSer
 
 
 
-exports.markFarmClientReference = markFarmClientReference; exports.getFarmClientReference = getFarmClientReference; exports.subscribeFarmServerTreeUpdates = subscribeFarmServerTreeUpdates; exports.updateFarmServerTreeModule = updateFarmServerTreeModule;
+
+exports.getFarmActionId = getFarmActionId; exports.markFarmClientReference = markFarmClientReference; exports.getFarmClientReference = getFarmClientReference; exports.subscribeFarmServerTreeUpdates = subscribeFarmServerTreeUpdates; exports.updateFarmServerTreeModule = updateFarmServerTreeModule;