@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-QGJ4FI2G.mjs

@@ -0,0 +1,723 @@
+import {
+  getFarmActionId,
+  getFarmClientReference,
+  subscribeFarmServerTreeUpdates
+} from "./chunk-FHURJABM.mjs";
+import {
+  FARM_REFERENCE_TAG,
+  FARM_TAG,
+  FARM_VALUE_SCRIPT_TYPE,
+  getFarmIslandValuesServer
+} from "./chunk-NBIVGHAT.mjs";
+
+// 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 = "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",
+  "datalist",
+  "head",
+  "html",
+  "iframe",
+  "math",
+  "noscript",
+  "optgroup",
+  "option",
+  "script",
+  "select",
+  "style",
+  "svg",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "title",
+  "tr"
+]);
+var UnsupportedNode = class extends Error {
+};
+var UnsupportedInParserSensitiveElement = class extends Error {
+};
+function getHooksDispatcherSlot(ReactRuntime) {
+  const runtime = ReactRuntime;
+  const react19 = runtime.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+  if (react19 && "H" in react19) {
+    return {
+      get: () => react19.H,
+      set: (value) => {
+        react19.H = value;
+      }
+    };
+  }
+  const react18 = runtime.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED?.ReactCurrentDispatcher;
+  if (react18) {
+    return {
+      get: () => react18.current,
+      set: (value) => {
+        react18.current = value;
+      }
+    };
+  }
+  return null;
+}
+var unsupportedHooksDispatcher = /* @__PURE__ */ new Proxy(
+  {},
+  {
+    get(_target, name) {
+      return () => {
+        throw new UnsupportedNode(`calls ${String(name)}()`);
+      };
+    }
+  }
+);
+function callServerComponent(ReactRuntime, render, props, forwardRef) {
+  const slot = getHooksDispatcherSlot(ReactRuntime);
+  const previous = slot?.get();
+  slot?.set(unsupportedHooksDispatcher);
+  try {
+    return forwardRef ? render(props, null) : render(props);
+  } finally {
+    slot?.set(previous);
+  }
+}
+function isThenable(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function serverHtmlNode(state, node, key, context) {
+  if (context.parserSensitive) throw new UnsupportedInParserSensitiveElement();
+  const id = state.nextId++;
+  state.serverHtml.set(id, node);
+  return key === null ? { $: "x", i: id } : { $: "x", i: id, k: String(key) };
+}
+async function resolveProps(state, props, context, host) {
+  const entries = await Promise.all(
+    Object.entries(props).map(async ([name, value]) => {
+      if (value === void 0 && (host || !state.codec)) return null;
+      if (name === "ref") {
+        if (value === null) return null;
+        throw new UnsupportedNode("receives a ref");
+      }
+      if (host && typeof value === "function") {
+        throw new UnsupportedNode(`passes a function to <${String(name)}>`);
+      }
+      return [name, await resolveValue(state, value, context, /* @__PURE__ */ new Set())];
+    })
+  );
+  return Object.fromEntries(entries.filter((entry) => entry !== null));
+}
+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);
+  }
+  if (isThenable(value)) {
+    try {
+      return { $: "P", v: await resolveValue(state, await value, context, seen) };
+    } catch (error) {
+      if (error instanceof UnsupportedInParserSensitiveElement) throw error;
+      throw new UnsupportedNode("passes a promise that does not resolve to a serializable value");
+    }
+  }
+  if (seen.has(value)) throw new UnsupportedNode("passes a circular value");
+  seen.add(value);
+  try {
+    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 || codec).map(
+        async ([name, entry]) => [
+          name,
+          await resolveValue(state, entry, context, seen)
+        ]
+      )
+    );
+    const object = Object.fromEntries(entries);
+    return Object.prototype.hasOwnProperty.call(object, "$") ? { $: "o", v: object } : object;
+  } finally {
+    seen.delete(value);
+  }
+}
+async function resolveElement(state, element, context) {
+  const { ReactRuntime } = state;
+  const key = element.key === null || element.key === void 0 ? null : String(element.key);
+  const withKey = (node) => key === null ? node : { ...node, k: key };
+  let type = element.type;
+  const props = element.props ?? {};
+  try {
+    if (typeof type === "string") {
+      const parserSensitive = context.parserSensitive || PARSER_SENSITIVE_TAGS.has(type);
+      try {
+        const { children, ...rest } = props;
+        const resolved2 = await resolveProps(state, rest, context, true);
+        if (children !== void 0) {
+          resolved2.children = await resolveValue(state, children, { parserSensitive }, /* @__PURE__ */ new Set());
+        }
+        return withKey({ $: "h", t: type, p: resolved2 });
+      } catch (error) {
+        if (error instanceof UnsupportedInParserSensitiveElement && !context.parserSensitive) {
+          return serverHtmlNode(state, element, key, context);
+        }
+        throw error;
+      }
+    }
+    if (type === ReactRuntime.Fragment || type === ReactRuntime.StrictMode) {
+      return withKey({
+        $: "f",
+        c: await resolveValue(state, props.children, context, /* @__PURE__ */ new Set())
+      });
+    }
+    if (type === ReactRuntime.Suspense) {
+      const id = state.nextId++;
+      const fallback = await resolveValue(state, props.fallback, context, /* @__PURE__ */ new Set());
+      const encoded = resolveValue(state, props.children, context, /* @__PURE__ */ new Set()).catch((error) => {
+        if (error instanceof UnsupportedNode) {
+          return serverHtmlNode(
+            state,
+            ReactRuntime.createElement(
+              ReactRuntime.Fragment,
+              null,
+              props.children
+            ),
+            null,
+            { parserSensitive: false }
+          );
+        }
+        throw error;
+      });
+      encoded.catch(() => {
+      });
+      state.chunks.set(id, { encoded });
+      return withKey({ $: "p", f: fallback, i: id });
+    }
+    const clientReference = getFarmClientReference(type);
+    if (clientReference) {
+      const { children, ...rest } = props;
+      const resolved2 = await resolveProps(state, rest, context, false);
+      if (children !== void 0) {
+        resolved2.children = await resolveValue(state, children, context, /* @__PURE__ */ new Set());
+      }
+      state.components.set(
+        `${clientReference.reference}#${clientReference.exportName}`,
+        clientReference.Component
+      );
+      return withKey({
+        $: "c",
+        r: clientReference.reference,
+        e: clientReference.exportName,
+        p: resolved2
+      });
+    }
+    let forwardRef = false;
+    while (type && typeof type === "object") {
+      const typeOf = type.$$typeof;
+      if (typeOf === MEMO_TYPE) {
+        type = type.type;
+        if (getFarmClientReference(type)) {
+          return resolveElement(
+            state,
+            ReactRuntime.createElement(type, {
+              ...props,
+              key: element.key
+            }),
+            context
+          );
+        }
+        continue;
+      }
+      if (typeOf === FORWARD_REF_TYPE) {
+        type = type.render;
+        forwardRef = true;
+        break;
+      }
+      throw new UnsupportedNode("is not a function component");
+    }
+    if (typeof type !== "function") throw new UnsupportedNode("is not a function component");
+    if (type.prototype?.isReactComponent) {
+      throw new UnsupportedNode("is a class component");
+    }
+    let rendered = callServerComponent(
+      ReactRuntime,
+      type,
+      props,
+      forwardRef
+    );
+    if (isThenable(rendered)) rendered = await rendered;
+    const resolved = await resolveValue(state, rendered, context, /* @__PURE__ */ new Set());
+    return key === null ? resolved : { $: "f", k: key, c: resolved };
+  } catch (error) {
+    if (error instanceof UnsupportedNode) return serverHtmlNode(state, element, key, context);
+    throw error;
+  }
+}
+function serializeTreePayload(value) {
+  return escapeTreeJson(JSON.stringify(value));
+}
+function escapeTreeJson(json) {
+  return json.replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+var chunkComponents = /* @__PURE__ */ new WeakMap();
+function getChunkComponent(ReactRuntime) {
+  const existing = chunkComponents.get(ReactRuntime.createElement);
+  if (existing) return existing;
+  function FarmServerTreeChunk({ chunk }) {
+    if (chunk.status === "fulfilled") return chunk.value;
+    if (chunk.status === "rejected") throw chunk.reason;
+    const use = ReactRuntime.use;
+    if (typeof use === "function") return use(chunk.promise);
+    throw chunk.promise;
+  }
+  chunkComponents.set(ReactRuntime.createElement, FarmServerTreeChunk);
+  return FarmServerTreeChunk;
+}
+function fulfilledThenable(value) {
+  const promise = Promise.resolve(value);
+  promise.status = "fulfilled";
+  promise.value = value;
+  return promise;
+}
+function createTreeChildren(ReactRuntime, children, resolver) {
+  if (children === void 0) return [];
+  const node = createTreeValue(ReactRuntime, children, resolver);
+  return Array.isArray(children) ? node : [node];
+}
+function createTreeProps(ReactRuntime, props, resolver, key) {
+  const { children, ...rest } = props;
+  const created = {};
+  for (const [name, value] of Object.entries(rest)) {
+    created[name] = createTreeValue(ReactRuntime, value, resolver);
+  }
+  if (typeof key === "string") created.key = key;
+  return { props: created, children: createTreeChildren(ReactRuntime, children, resolver) };
+}
+function createTreeValue(ReactRuntime, value, resolver) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value))
+    return value.map((entry) => createTreeValue(ReactRuntime, entry, resolver));
+  switch (value.$) {
+    case "h": {
+      const { props, children } = createTreeProps(
+        ReactRuntime,
+        value.p,
+        resolver,
+        value.k
+      );
+      return ReactRuntime.createElement(value.t, props, ...children);
+    }
+    case "c": {
+      const { props, children } = createTreeProps(
+        ReactRuntime,
+        value.p,
+        resolver,
+        value.k
+      );
+      return ReactRuntime.createElement(
+        resolver.component(value.r, value.e),
+        props,
+        ...children
+      );
+    }
+    case "f":
+      return ReactRuntime.createElement(
+        ReactRuntime.Fragment,
+        typeof value.k === "string" ? { key: value.k } : null,
+        ...createTreeChildren(ReactRuntime, value.c, resolver)
+      );
+    case "p":
+      return ReactRuntime.createElement(
+        ReactRuntime.Suspense,
+        {
+          ...typeof value.k === "string" ? { key: value.k } : {},
+          fallback: createTreeValue(
+            ReactRuntime,
+            value.f,
+            resolver
+          )
+        },
+        ReactRuntime.createElement(getChunkComponent(ReactRuntime), {
+          chunk: resolver.chunk(value.i)
+        })
+      );
+    case "x":
+      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": {
+      const object = value.v;
+      return Object.fromEntries(
+        Object.entries(object).map(([name, entry]) => [
+          name,
+          createTreeValue(ReactRuntime, entry, resolver)
+        ])
+      );
+    }
+    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)
+        ])
+      );
+    }
+  }
+}
+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
+  );
+}
+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_SCRIPT_TYPE, "", json, values)
+  );
+}
+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;
+}
+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
+        )
+      );
+    })
+  );
+}
+async function renderFarmServerTreePage(ReactRuntime, element, options) {
+  const state = {
+    ReactRuntime,
+    nextId: 0,
+    components: /* @__PURE__ */ new Map(),
+    serverHtml: /* @__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 = (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)])
+    };
+  };
+  const resolver = {
+    component(reference, exportName) {
+      const Component = state.components.get(`${reference}#${exportName}`);
+      if (!Component)
+        throw new Error(`client reference ${reference}#${exportName} was not resolved`);
+      return Component;
+    },
+    chunk(id) {
+      const entry = state.chunks.get(id);
+      if (entry.chunk) return entry.chunk;
+      const chunk = {
+        status: "pending",
+        promise: entry.encoded.then(
+          (encoded) => {
+            chunk.value = ReactRuntime.createElement(
+              ReactRuntime.Fragment,
+              null,
+              createTreeValue(ReactRuntime, encoded, resolver),
+              (() => {
+                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;
+          },
+          (error) => {
+            chunk.status = "rejected";
+            chunk.reason = error;
+            throw error;
+          }
+        )
+      };
+      chunk.promise.catch(() => {
+      });
+      entry.chunk = chunk;
+      return chunk;
+    },
+    serverHtml(id, key) {
+      return ReactRuntime.createElement(
+        SERVER_HTML_TAG,
+        {
+          ...key === null ? {} : { key },
+          [SERVER_HTML_ATTRIBUTE]: String(id),
+          style: { display: "contents" }
+        },
+        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 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(function FarmServerTreePage() {
+    return page;
+  });
+}
+function collectReferences(value, references) {
+  if (value === null || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    for (const entry of value) collectReferences(entry, references);
+    return;
+  }
+  if (value.$ === "c") references.add(`${value.r}#${value.e}`);
+  for (const entry of Object.values(value)) collectReferences(entry, references);
+}
+function parseHtml(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  return template.content;
+}
+function originalExport(module, exportName) {
+  const Component = module.__farm_client_boundary_originals__?.[exportName];
+  if (typeof Component !== "function" && typeof Component !== "object") {
+    throw new Error(`compiled original export ${exportName} was not found`);
+  }
+  return Component;
+}
+async function createFarmServerTreeElement(ReactRuntime, source, options) {
+  const root = typeof source === "string" ? parseHtml(source) : source;
+  const script = root.querySelector(
+    `script[type="${FARM_SERVER_TREE_SCRIPT_TYPE}"]`
+  );
+  if (!script) return null;
+  const json = script.textContent ?? "";
+  let ingested = false;
+  const parsePayload = (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);
+  };
+  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[type="${SERVER_TREE_CHUNK_SCRIPT_TYPE}"]`
+  )) {
+    const chunkJson = chunkScript.textContent ?? "";
+    chunks.set(Number(chunkScript.getAttribute("name")), {
+      tree: parsePayload(chunkJson).t,
+      json: chunkJson,
+      values: readTreeValueScripts(chunkScript)
+    });
+  }
+  const references = /* @__PURE__ */ new Set();
+  collectReferences(payload.t, references);
+  for (const chunk of chunks.values()) collectReferences(chunk.tree, references);
+  const components = /* @__PURE__ */ new Map();
+  await Promise.all(
+    Array.from(references, async (key) => {
+      const separator = key.lastIndexOf("#");
+      const reference = key.slice(0, separator);
+      components.set(key, originalExport(await options.load(reference), key.slice(separator + 1)));
+    })
+  );
+  const serverHtml = /* @__PURE__ */ new Map();
+  for (const container of root.querySelectorAll(`${SERVER_HTML_TAG}[${SERVER_HTML_ATTRIBUTE}]`)) {
+    serverHtml.set(Number(container.getAttribute(SERVER_HTML_ATTRIBUTE)), container.innerHTML);
+  }
+  const resolver = {
+    component(reference, exportName) {
+      const Component = components.get(`${reference}#${exportName}`);
+      if (!Component) throw new Error(`client reference ${reference}#${exportName} was not loaded`);
+      return Component;
+    },
+    chunk(id) {
+      const chunk = chunks.get(id);
+      if (!chunk) throw new Error(`server tree chunk ${id} was not found`);
+      const value = ReactRuntime.createElement(
+        ReactRuntime.Fragment,
+        null,
+        createTreeValue(ReactRuntime, chunk.tree, resolver),
+        createTreeScript(
+          ReactRuntime,
+          SERVER_TREE_CHUNK_SCRIPT_TYPE,
+          String(id),
+          chunk.json,
+          chunk.values
+        )
+      );
+      return { status: "fulfilled", value, promise: Promise.resolve(value) };
+    },
+    serverHtml(id, key) {
+      const html = serverHtml.get(id);
+      if (html === void 0) throw new Error(`server HTML ${id} was not found`);
+      return ReactRuntime.createElement(options.ServerHtml, {
+        ...key === null ? {} : { key },
+        as: SERVER_HTML_TAG,
+        [SERVER_HTML_ATTRIBUTE]: String(id),
+        style: { display: "contents" },
+        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 = () => createTreePage(ReactRuntime, payload.t, json, resolver, void 0, values);
+  build();
+  function FarmServerTreePage() {
+    const [, setVersion] = ReactRuntime.useState(0);
+    ReactRuntime.useEffect(() => {
+      const listener = (reference, module) => {
+        let changed = false;
+        for (const key of components.keys()) {
+          const separator = key.lastIndexOf("#");
+          if (key.slice(0, separator) !== reference) continue;
+          components.set(key, originalExport(module, key.slice(separator + 1)));
+          changed = true;
+        }
+        if (changed) setVersion((version) => version + 1);
+        return changed;
+      };
+      return subscribeFarmServerTreeUpdates(listener);
+    }, []);
+    return build();
+  }
+  return ReactRuntime.createElement(
+    FarmServerTreePage,
+    options.key === void 0 ? null : { key: options.key }
+  );
+}
+
+export {
+  FARM_SERVER_TREE_SCRIPT_TYPE,
+  FARM_SERVER_TREE_PAYLOAD_ONLY_ATTRIBUTE,
+  renderFarmServerTreePage,
+  createFarmServerTreeElement
+};