@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-WPJQN64R.mjs

@@ -1,755 +0,0 @@
-import {
-  getFarmActionId,
-  getFarmClientReference,
-  subscribeFarmServerTreeUpdates
-} 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";
-
-// 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 _UnsupportedNode extends Error {
-};
-__name(_UnsupportedNode, "UnsupportedNode");
-var UnsupportedNode = _UnsupportedNode;
-var _UnsupportedInParserSensitiveElement = class _UnsupportedInParserSensitiveElement extends Error {
-};
-__name(_UnsupportedInParserSensitiveElement, "UnsupportedInParserSensitiveElement");
-var UnsupportedInParserSensitiveElement = _UnsupportedInParserSensitiveElement;
-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: /* @__PURE__ */ __name(() => react19.H, "get"),
-      set: /* @__PURE__ */ __name((value) => {
-        react19.H = value;
-      }, "set")
-    };
-  }
-  const react18 = runtime.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED?.ReactCurrentDispatcher;
-  if (react18) {
-    return {
-      get: /* @__PURE__ */ __name(() => react18.current, "get"),
-      set: /* @__PURE__ */ __name((value) => {
-        react18.current = value;
-      }, "set")
-    };
-  }
-  return null;
-}
-__name(getHooksDispatcherSlot, "getHooksDispatcherSlot");
-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);
-  }
-}
-__name(callServerComponent, "callServerComponent");
-function isThenable(value) {
-  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-__name(isThenable, "isThenable");
-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) };
-}
-__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 && (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));
-}
-__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);
-  }
-  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);
-  }
-}
-__name(resolveValue, "resolveValue");
-async function resolveElement(state, element, context) {
-  const { ReactRuntime } = state;
-  const key = element.key === null || element.key === void 0 ? null : String(element.key);
-  const withKey = /* @__PURE__ */ __name((node) => key === null ? node : { ...node, k: key }, "withKey");
-  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;
-  }
-}
-__name(resolveElement, "resolveElement");
-function serializeTreePayload(value) {
-  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);
-  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;
-  }
-  __name(FarmServerTreeChunk, "FarmServerTreeChunk");
-  chunkComponents.set(ReactRuntime.createElement, FarmServerTreeChunk);
-  return FarmServerTreeChunk;
-}
-__name(getChunkComponent, "getChunkComponent");
-function fulfilledThenable(value) {
-  const promise = Promise.resolve(value);
-  promise.status = "fulfilled";
-  promise.value = value;
-  return promise;
-}
-__name(fulfilledThenable, "fulfilledThenable");
-function createTreeChildren(ReactRuntime, children, resolver) {
-  if (children === void 0) return [];
-  const node = createTreeValue(ReactRuntime, children, resolver);
-  return Array.isArray(children) ? node : [node];
-}
-__name(createTreeChildren, "createTreeChildren");
-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) };
-}
-__name(createTreeProps, "createTreeProps");
-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)
-        ])
-      );
-    }
-  }
-}
-__name(createTreeValue, "createTreeValue");
-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, values = []) {
-  return ReactRuntime.createElement(
-    ReactRuntime.Fragment,
-    key === void 0 ? null : { key },
-    createTreeValue(ReactRuntime, tree, resolver),
-    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(),
-    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}`);
-      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(/* @__PURE__ */ __name(function FarmServerTreePage() {
-    return page;
-  }, "FarmServerTreePage"));
-}
-__name(renderFarmServerTreePage, "renderFarmServerTreePage");
-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);
-}
-__name(collectReferences, "collectReferences");
-function parseHtml(html) {
-  const template = document.createElement("template");
-  template.innerHTML = html;
-  return template.content;
-}
-__name(parseHtml, "parseHtml");
-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;
-}
-__name(originalExport, "originalExport");
-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 = /* @__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[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 = /* @__PURE__ */ __name(() => createTreePage(ReactRuntime, payload.t, json, resolver, void 0, values), "build");
-  build();
-  function FarmServerTreePage() {
-    const [, setVersion] = ReactRuntime.useState(0);
-    ReactRuntime.useEffect(() => {
-      const listener = /* @__PURE__ */ __name((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;
-      }, "listener");
-      return subscribeFarmServerTreeUpdates(listener);
-    }, []);
-    return build();
-  }
-  __name(FarmServerTreePage, "FarmServerTreePage");
-  return ReactRuntime.createElement(
-    FarmServerTreePage,
-    options.key === void 0 ? null : { key: options.key }
-  );
-}
-__name(createFarmServerTreeElement, "createFarmServerTreeElement");
-
-export {
-  FARM_SERVER_TREE_SCRIPT_TYPE,
-  FARM_SERVER_TREE_PAYLOAD_ONLY_ATTRIBUTE,
-  renderFarmServerTreePage,
-  createFarmServerTreeElement
-};