@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-PAKCHVUS.mjs

@@ -0,0 +1,450 @@
+// src/server-components-mode.ts
+function resolveFarmServerComponentsMode(value) {
+  if (value === void 0 || value === null || value === false) return void 0;
+  if (value === true) return "rsc";
+  const mode = typeof value === "object" ? value.mode : void 0;
+  if (mode === "rsc" || mode === "islands") return mode;
+  throw new TypeError(
+    'experimental.serverComponents must be true, false, { mode: "rsc" } or { mode: "islands" }.'
+  );
+}
+function isExplicitFarmServerComponentsMode(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/dev-indicators.ts
+function resolveFarmDevIndicatorsConfig(config, mode = "development") {
+  return {
+    buildActivity: mode === "development" && (config?.buildActivity ?? true),
+    buildActivityPosition: config?.buildActivityPosition ?? "bottom-right"
+  };
+}
+function generateFarmDevIndicatorsClientRuntime(config) {
+  if (!config.buildActivity) return "";
+  const position = {
+    "bottom-right": "right: 16px; bottom: 16px;",
+    "bottom-left": "left: 16px; bottom: 16px;",
+    "top-right": "right: 16px; top: 16px;",
+    "top-left": "left: 16px; top: 16px;"
+  }[config.buildActivityPosition];
+  const styles = `
+    #__farm_build_activity__ {
+      position: fixed;
+      ${position}
+      z-index: 2147483645;
+      display: inline-flex;
+      align-items: center;
+      min-height: 34px;
+      padding: 0 11px;
+      border: 1px solid rgb(255 255 255 / 0.16);
+      border-radius: 6px;
+      background: rgb(8 8 8 / 0.94);
+      box-shadow: 0 8px 24px rgb(0 0 0 / 0.2);
+      color: rgb(250 250 250);
+      font: 500 10px/1 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+      letter-spacing: 0;
+      opacity: 0;
+      pointer-events: none;
+      transform: translateY(4px);
+      transition: opacity 120ms ease-out, transform 120ms ease-out;
+      -webkit-backdrop-filter: blur(12px);
+      backdrop-filter: blur(12px);
+    }
+    #__farm_build_activity__[data-visible="true"] {
+      opacity: 1;
+      transform: translateY(0);
+    }
+    .farm-build-activity__brand {
+      display: inline-flex;
+      align-items: center;
+      gap: 7px;
+      flex: none;
+    }
+    .farm-build-activity__mark {
+      width: 17px;
+      height: 16px;
+      flex: none;
+    }
+    .farm-build-activity__wordmark {
+      color: rgb(255 255 255);
+      font-size: 11px;
+      font-weight: 400;
+      line-height: 1;
+    }
+    .farm-build-activity__wordmark-suffix { color: rgb(255 255 255 / 0.52); }
+    .farm-build-activity__divider {
+      width: 1px;
+      height: 14px;
+      margin: 0 9px;
+      flex: none;
+      background: rgb(255 255 255 / 0.14);
+    }
+    .farm-build-activity__loader {
+      display: grid;
+      width: 15px;
+      grid-template-columns: repeat(3, 4px);
+      gap: 1.5px;
+      flex: none;
+    }
+    .farm-build-activity__cell {
+      width: 4px;
+      height: 4px;
+      border-radius: 1px;
+      background: currentColor;
+      opacity: 0.15;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell {
+      animation: farm-build-activity-pixel-on 650ms ease-in-out infinite;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(1),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(5),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(7) {
+      animation-delay: 90ms;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(2),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(6),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(8) {
+      animation-delay: 180ms;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(3),
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(9) {
+      animation-delay: 270ms;
+    }
+    #__farm_build_activity__[data-state="building"] .farm-build-activity__cell:nth-child(4) {
+      animation-delay: 0ms;
+    }
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell,
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell {
+      opacity: 0.08;
+    }
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(3),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(5),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(6),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(7),
+    #__farm_build_activity__[data-state="ready"] .farm-build-activity__cell:nth-child(8),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(1),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(3),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(5),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(7),
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__cell:nth-child(9) {
+      opacity: 1;
+    }
+    .farm-build-activity__label {
+      margin-left: 7px;
+      color: rgb(255 255 255 / 0.62);
+      font-size: 9px;
+      letter-spacing: 0.06em;
+      text-transform: uppercase;
+      white-space: nowrap;
+    }
+    .farm-build-activity__sr-only {
+      position: absolute;
+      width: 1px;
+      height: 1px;
+      padding: 0;
+      margin: -1px;
+      overflow: hidden;
+      clip: rect(0, 0, 0, 0);
+      white-space: nowrap;
+      border: 0;
+    }
+    #__farm_build_activity__[data-state="error"] {
+      border-color: rgb(248 113 113 / 0.55);
+    }
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__loader,
+    #__farm_build_activity__[data-state="error"] .farm-build-activity__label {
+      color: rgb(254 202 202);
+    }
+    @keyframes farm-build-activity-pixel-on {
+      0%, 32%, 100% { opacity: 0.15; }
+      14% { opacity: 1; }
+    }
+    @media (prefers-reduced-motion: reduce) {
+      #__farm_build_activity__ { transition: none; }
+      #__farm_build_activity__[data-state="building"] .farm-build-activity__cell {
+        animation: none;
+        opacity: 0.28;
+      }
+    }
+  `;
+  return `
+if (import.meta.hot) {
+  (() => {
+    const hot = import.meta.hot;
+    const indicatorId = "__farm_build_activity__";
+    const styleId = "__farm_build_activity_styles__";
+    const runtimeKey = "__FARM_BUILD_ACTIVITY_RUNTIME__";
+    const reloadMarker = "__FARM_BUILD_ACTIVITY_RELOADING__";
+    let hideTimer;
+
+    const createBrandMark = () => {
+      const namespace = "http://www.w3.org/2000/svg";
+      const mark = document.createElementNS(namespace, "svg");
+      mark.setAttribute("class", "farm-build-activity__mark");
+      mark.setAttribute("viewBox", "125 68 161 152");
+      mark.setAttribute("fill", "none");
+      mark.setAttribute("aria-hidden", "true");
+
+      const shapes = [
+        ["M157 68H133C128.582 68 125 71.5817 125 76V100C125 104.418 128.582 108 133 108H157C161.418 108 165 104.418 165 100V76C165 71.5817 161.418 68 157 68Z", "#F5F5F4"],
+        ["M182.383 68H280.617C282.045 68 283.414 68.8429 284.423 70.3431C285.433 71.8434 286 73.8783 286 76V100C286 102.122 285.433 104.157 284.423 105.657C283.414 107.157 282.045 108 280.617 108H182.383C180.955 108 179.586 107.157 178.577 105.657C177.567 104.157 177 102.122 177 100V76C177 73.8783 177.567 71.8434 178.577 70.3431C179.586 68.8429 180.955 68 182.383 68ZM271.852 81C270.747 81 269.852 81.8954 269.852 83V93C269.852 94.1046 270.747 95 271.852 95H277.272C278.376 95 279.272 94.1046 279.272 93V83C279.272 81.8954 278.376 81 277.272 81H271.852Z", "#F5F5F4"],
+        ["M157 124H133C128.582 124 125 127.582 125 132V156C125 160.418 128.582 164 133 164H157C161.418 164 165 160.418 165 156V132C165 127.582 161.418 124 157 124Z", "#A3A3A3"],
+        ["M280.334 124H182.666C179.537 124 177 127.582 177 132V156C177 160.418 179.537 164 182.666 164H280.334C283.463 164 286 160.418 286 156V132C286 127.582 283.463 124 280.334 124Z", "#A3A3A3"],
+        ["M157 180H133C128.582 180 125 183.582 125 188V212C125 216.418 128.582 220 133 220H157C161.418 220 165 216.418 165 212V188C165 183.582 161.418 180 157 180Z", "#595959"],
+        ["M230.189 180H182.811C179.602 180 177 183.582 177 188V212C177 216.418 179.602 220 182.811 220H230.189C233.398 220 236 216.418 236 212V188C236 183.582 233.398 180 230.189 180Z", "#595959"],
+      ];
+      for (const [index, [pathData, fill]] of shapes.entries()) {
+        const path = document.createElementNS(namespace, "path");
+        path.setAttribute("d", pathData);
+        path.setAttribute("fill", fill);
+        if (index === 1) {
+          path.setAttribute("fill-rule", "evenodd");
+          path.setAttribute("clip-rule", "evenodd");
+        }
+        mark.appendChild(path);
+      }
+      return mark;
+    };
+
+    const ensureIndicator = () => {
+      let style = document.getElementById(styleId);
+      if (!style) {
+        style = document.createElement("style");
+        style.id = styleId;
+        style.textContent = ${JSON.stringify(styles)};
+        document.head.appendChild(style);
+      }
+
+      let indicator = document.getElementById(indicatorId);
+      if (!indicator) {
+        indicator = document.createElement("div");
+        indicator.id = indicatorId;
+        indicator.setAttribute("role", "status");
+        indicator.setAttribute("aria-live", "polite");
+
+        const brand = document.createElement("span");
+        brand.className = "farm-build-activity__brand";
+        brand.setAttribute("aria-hidden", "true");
+        const wordmark = document.createElement("span");
+        wordmark.className = "farm-build-activity__wordmark";
+        const suffix = document.createElement("span");
+        suffix.className = "farm-build-activity__wordmark-suffix";
+        suffix.textContent = ".JS";
+        wordmark.append("FARM", suffix);
+        brand.append(createBrandMark(), wordmark);
+
+        const divider = document.createElement("span");
+        divider.className = "farm-build-activity__divider";
+        divider.setAttribute("aria-hidden", "true");
+
+        const loader = document.createElement("span");
+        loader.className = "farm-build-activity__loader";
+        loader.setAttribute("aria-hidden", "true");
+        for (let index = 0; index < 9; index += 1) {
+          const cell = document.createElement("span");
+          cell.className = "farm-build-activity__cell";
+          loader.appendChild(cell);
+        }
+
+        const label = document.createElement("span");
+        label.className = "farm-build-activity__label";
+        label.setAttribute("aria-hidden", "true");
+        label.dataset.farmBuildLabel = "";
+        const message = document.createElement("span");
+        message.className = "farm-build-activity__sr-only";
+        message.dataset.farmBuildMessage = "";
+        indicator.append(loader, label, divider, brand, message);
+        document.body.appendChild(indicator);
+      }
+      return indicator;
+    };
+
+    const show = (state, label, message) => {
+      window.clearTimeout(hideTimer);
+      const indicator = ensureIndicator();
+      indicator.dataset.state = state;
+      indicator.dataset.visible = "true";
+      indicator.querySelector("[data-farm-build-label]").textContent = label;
+      indicator.querySelector("[data-farm-build-message]").textContent = message;
+    };
+    const hide = () => {
+      const indicator = document.getElementById(indicatorId);
+      if (indicator) indicator.dataset.visible = "false";
+    };
+    const onBeforeUpdate = () => show("building", "Updating", "Farm.js updating");
+    const onAfterUpdate = () => {
+      show("ready", "Ready", "Farm.js ready");
+      hideTimer = window.setTimeout(hide, 500);
+    };
+    const onError = () => show("error", "Build failed", "Farm.js build failed");
+    const onBeforeFullReload = () => {
+      try {
+        window.sessionStorage.setItem(reloadMarker, "1");
+      } catch {}
+      show("building", "Updating", "Farm.js updating");
+    };
+
+    window[runtimeKey]?.dispose?.();
+    ensureIndicator();
+    let completedReload = false;
+    try {
+      completedReload = window.sessionStorage.getItem(reloadMarker) === "1";
+      window.sessionStorage.removeItem(reloadMarker);
+    } catch {}
+    if (completedReload) onAfterUpdate();
+    else hide();
+    hot.on("vite:beforeUpdate", onBeforeUpdate);
+    hot.on("vite:afterUpdate", onAfterUpdate);
+    hot.on("vite:error", onError);
+    hot.on("vite:beforeFullReload", onBeforeFullReload);
+    window[runtimeKey] = {
+      dispose() {
+        window.clearTimeout(hideTimer);
+        hot.off("vite:beforeUpdate", onBeforeUpdate);
+        hot.off("vite:afterUpdate", onAfterUpdate);
+        hot.off("vite:error", onError);
+        hot.off("vite:beforeFullReload", onBeforeFullReload);
+        document.getElementById(indicatorId)?.remove();
+      },
+    };
+  })();
+}
+`;
+}
+
+// src/utils/source-dir.ts
+import path from "path";
+var FARM_PROJECT_SOURCE_DIRS = /* @__PURE__ */ Symbol.for("farm.projectSourceDirs");
+function getProjectSourceDirs() {
+  const globalState = globalThis;
+  return globalState[FARM_PROJECT_SOURCE_DIRS] ?? (globalState[FARM_PROJECT_SOURCE_DIRS] = /* @__PURE__ */ new Map());
+}
+function setFarmProjectSourceDir(root, srcDir) {
+  getProjectSourceDirs().set(path.resolve(root), srcDir);
+}
+function getFarmProjectSourceDir(root) {
+  return getProjectSourceDirs().get(path.resolve(root)) ?? "src";
+}
+
+// src/auth-config.ts
+import { createRequire } from "module";
+import path2 from "path";
+import { pathToFileURL } from "url";
+function resolveFarmAuthConfig(input) {
+  const config = input === true ? {} : input && typeof input === "object" ? input : {};
+  const passwordConfig = typeof config.emailAndPassword === "object" ? config.emailAndPassword : {};
+  const resolved = {
+    enabled: input !== void 0 && input !== false && config.enabled !== false,
+    appName: config.appName,
+    basePath: normalizeBasePath(config.basePath),
+    emailAndPassword: {
+      enabled: config.emailAndPassword !== false,
+      requireEmailVerification: passwordConfig.requireEmailVerification ?? false,
+      minPasswordLength: passwordConfig.minPasswordLength ?? 8,
+      maxPasswordLength: passwordConfig.maxPasswordLength ?? 128
+    },
+    session: {
+      expiresIn: config.session?.expiresIn ?? 60 * 60 * 24 * 7,
+      updateAge: config.session?.updateAge ?? 60 * 60 * 24
+    },
+    database: {
+      url: config.database?.url,
+      path: config.database?.path || ".farm/auth.sqlite",
+      migrateInDevelopment: config.database?.migrateInDevelopment ?? true
+    }
+  };
+  validateFarmAuthConfig(resolved);
+  return resolved;
+}
+async function resolveFarmAuthIntegration(config, options) {
+  if (!config.enabled) return void 0;
+  const root = path2.resolve(options.root);
+  let modulePath;
+  try {
+    const resolveFromApp = createRequire(path2.join(root, "package.json"));
+    modulePath = resolveFromApp.resolve("@farm.js/auth/internal");
+  } catch {
+    throw new Error(
+      "The `auth` config requires @farm.js/auth. Install it with `pnpm add @farm.js/auth` and try again."
+    );
+  }
+  const runtime = await import(
+    /* @vite-ignore */
+    pathToFileURL(modulePath).href
+  );
+  if (typeof runtime.createFarmAuthIntegration !== "function") {
+    throw new Error(
+      "The installed @farm.js/auth package is incompatible with this version of @farm.js/core."
+    );
+  }
+  return runtime.createFarmAuthIntegration(config, {
+    ...options,
+    root
+  });
+}
+function normalizeBasePath(value) {
+  const route = (value || "/api/auth").trim();
+  if (!route) return "/api/auth";
+  assertStableBasePath(route);
+  const withLeadingSlash = route.startsWith("/") ? route : `/${route}`;
+  const normalized = withLeadingSlash.replace(/\/+/g, "/").replace(/\/+$/, "");
+  return normalized || "/api/auth";
+}
+function assertStableBasePath(route) {
+  if (route.includes("?") || route.includes("#")) {
+    throw new Error("auth.basePath cannot contain a query string or fragment.");
+  }
+  if (route.startsWith("//") || /^[a-z][a-z\d+.-]*:\/\//i.test(route)) {
+    throw new Error('auth.basePath must be an application pathname such as "/api/auth".');
+  }
+  if (hasUnstablePathCharacters(route)) {
+    throw new Error("auth.basePath cannot contain backslashes or control characters.");
+  }
+  for (const segment of route.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+    }
+    if (hasUnstablePathCharacters(decoded) || decoded.includes("/")) {
+      throw new Error("auth.basePath cannot contain encoded path separators.");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new Error('auth.basePath cannot contain "." or ".." path segments.');
+    }
+  }
+}
+function hasUnstablePathCharacters(value) {
+  return value.includes("\\") || Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+}
+function validateFarmAuthConfig(config) {
+  const { minPasswordLength, maxPasswordLength } = config.emailAndPassword;
+  if (!Number.isInteger(minPasswordLength) || minPasswordLength < 1) {
+    throw new Error("auth.emailAndPassword.minPasswordLength must be a positive integer.");
+  }
+  if (!Number.isInteger(maxPasswordLength) || maxPasswordLength < minPasswordLength) {
+    throw new Error(
+      "auth.emailAndPassword.maxPasswordLength must be an integer greater than or equal to minPasswordLength."
+    );
+  }
+  if (!Number.isInteger(config.session.expiresIn) || config.session.expiresIn < 1) {
+    throw new Error("auth.session.expiresIn must be a positive integer.");
+  }
+  if (!Number.isInteger(config.session.updateAge) || config.session.updateAge < 0) {
+    throw new Error("auth.session.updateAge must be a non-negative integer.");
+  }
+}
+
+export {
+  resolveFarmServerComponentsMode,
+  isExplicitFarmServerComponentsMode,
+  setFarmProjectSourceDir,
+  getFarmProjectSourceDir,
+  resolveFarmDevIndicatorsConfig,
+  generateFarmDevIndicatorsClientRuntime,
+  resolveFarmAuthConfig,
+  resolveFarmAuthIntegration
+};

package/dist/chunk-PEHL3IZL.cjs

@@ -0,0 +1,203 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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; } async function _asyncOptionalChain(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 = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkKORZ6PREcjs = require('./chunk-KORZ6PRE.cjs');
+
+
+var _chunk4DCWVSL2cjs = require('./chunk-4DCWVSL2.cjs');
+
+
+var _chunk5566GNEGcjs = require('./chunk-5566GNEG.cjs');
+
+// src/metadata-image.ts
+var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element");
+var REACT_TRANSITIONAL_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element");
+var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+function isResponse(value) {
+  return typeof Response !== "undefined" && (value instanceof Response || Boolean(
+    value && typeof value === "object" && typeof value.arrayBuffer === "function" && value.headers
+  ));
+}
+function isThenable(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function"
+  );
+}
+function isReactElement(value) {
+  if (!value || typeof value !== "object") return false;
+  const marker = value.$$typeof;
+  return marker === REACT_ELEMENT_TYPE || marker === REACT_TRANSITIONAL_ELEMENT_TYPE;
+}
+function isMetadataImageElement(value, renderer) {
+  return renderer ? renderer.isValidElement(value) : isReactElement(value);
+}
+async function prepareMetadataImageNode(node, renderer) {
+  if (isThenable(node)) {
+    return prepareMetadataImageNode(await node, renderer);
+  }
+  if (Array.isArray(node)) {
+    return Promise.all(node.map((child) => prepareMetadataImageNode(child, renderer)));
+  }
+  if (!isMetadataImageElement(node, renderer)) {
+    return node;
+  }
+  const element = node;
+  const type = element.type;
+  const props = element.props || {};
+  if (typeof type === "function") {
+    if (_optionalChain([type, 'access', _ => _.prototype, 'optionalAccess', _2 => _2.isReactComponent])) {
+      throw new Error(
+        "Metadata image components must be stateless function components; React class components are not supported."
+      );
+    }
+    return prepareMetadataImageNode(await type(props), renderer);
+  }
+  if (type && typeof type === "object") {
+    if (type.$$typeof === REACT_MEMO_TYPE) {
+      const { createElement: createElement2 } = await import("react");
+      return prepareMetadataImageNode(createElement2(type.type, props), renderer);
+    }
+    if (type.$$typeof === REACT_FORWARD_REF_TYPE) {
+      return prepareMetadataImageNode(await type.render(props, null), renderer);
+    }
+    if (type.$$typeof === REACT_LAZY_TYPE) {
+      const { createElement: createElement2 } = await import("react");
+      let resolvedType;
+      try {
+        resolvedType = type._init(type._payload);
+      } catch (suspension) {
+        if (suspension && typeof suspension.then === "function") {
+          await suspension;
+          resolvedType = type._init(type._payload);
+        } else {
+          throw suspension;
+        }
+      }
+      return prepareMetadataImageNode(createElement2(resolvedType, props), renderer);
+    }
+  }
+  const preparedChildren = await prepareMetadataImageNode(props.children, renderer);
+  const preparedProps = { ...props };
+  if (typeof preparedProps.className === "string") {
+    preparedProps.tw = [preparedProps.tw, preparedProps.className].filter(Boolean).join(" ");
+    delete preparedProps.className;
+  }
+  delete preparedProps.children;
+  const createElement = await _asyncNullishCoalesce(await _asyncOptionalChain([renderer, 'optionalAccess', async _3 => _3.createElement]), async () => ( (await import("react")).createElement));
+  return createElement(type, {
+    ...preparedProps,
+    key: element.key,
+    children: preparedChildren
+  });
+}
+async function normalizeFonts(fonts) {
+  if (!_optionalChain([fonts, 'optionalAccess', _4 => _4.length])) return void 0;
+  return Promise.all(
+    fonts.map(async (font) => {
+      const data = await font.data;
+      const arrayBuffer = ArrayBuffer.isView(data) ? toArrayBuffer(data) : data;
+      return { ...font, data: arrayBuffer };
+    })
+  );
+}
+function resolveCacheControl(revalidate) {
+  if (revalidate === false) {
+    return "public, max-age=31536000, immutable";
+  }
+  if (typeof revalidate === "number" && Number.isFinite(revalidate) && revalidate > 0) {
+    return `public, s-maxage=${Math.floor(revalidate)}, stale-while-revalidate=300`;
+  }
+  return "public, max-age=0, must-revalidate";
+}
+function toArrayBuffer(value) {
+  if (value instanceof ArrayBuffer) return value;
+  const bytes = new Uint8Array(value.byteLength);
+  bytes.set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  return bytes.buffer;
+}
+async function createEntityTag(body) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", body);
+  const hash = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 32);
+  return `"${hash}"`;
+}
+async function finalizeMetadataImageResponse(body, headers, options) {
+  const responseHeaders = new Headers(headers);
+  const etag = await createEntityTag(body);
+  responseHeaders.set("ETag", etag);
+  responseHeaders.set("Content-Length", String(body.byteLength));
+  responseHeaders.set("X-Content-Type-Options", "nosniff");
+  if (_chunk5566GNEGcjs.matchesFarmIfNoneMatch.call(void 0, options.ifNoneMatch, etag)) {
+    return new Response(null, { status: 304, headers: responseHeaders });
+  }
+  return new Response(_optionalChain([options, 'access', _5 => _5.method, 'optionalAccess', _6 => _6.toUpperCase, 'call', _7 => _7()]) === "HEAD" ? null : body, {
+    status: 200,
+    headers: responseHeaders
+  });
+}
+async function loadVercelOg() {
+  try {
+    return await import("@vercel/og");
+  } catch (error) {
+    if (!_chunkKORZ6PREcjs.isMissingPackageError.call(void 0, error, "@vercel/og")) throw error;
+    throw _chunkKORZ6PREcjs.withOptionalPeerCause.call(void 0, 
+      new Error(
+        `Rendering a metadata image from JSX needs @vercel/og, which is not installed. ${_chunkKORZ6PREcjs.VERCEL_OG_INSTALL_HINT}`
+      ),
+      error
+    );
+  }
+}
+async function createFarmMetadataImageResponse(value, imageModule, options = {}) {
+  const method = (options.method || "GET").toUpperCase();
+  if (method !== "GET" && method !== "HEAD") {
+    return new Response(null, { status: 405, headers: { Allow: "GET, HEAD" } });
+  }
+  if (isResponse(value)) {
+    return method === "HEAD" ? _chunk4DCWVSL2cjs.omitFarmResponseBody.call(void 0, value) : value;
+  }
+  const cacheControl = resolveCacheControl(imageModule.revalidate);
+  const explicitContentType = _optionalChain([imageModule, 'access', _8 => _8.contentType, 'optionalAccess', _9 => _9.split, 'call', _10 => _10(";", 1), 'access', _11 => _11[0], 'optionalAccess', _12 => _12.trim, 'call', _13 => _13(), 'access', _14 => _14.toLowerCase, 'call', _15 => _15()]);
+  const { renderer } = options;
+  const isElement = isMetadataImageElement(value, renderer);
+  if (isElement && explicitContentType !== "image/svg+xml") {
+    const { ImageResponse } = await loadVercelOg();
+    const element = await prepareMetadataImageNode(value, renderer);
+    const response = new ImageResponse(element, {
+      width: _optionalChain([imageModule, 'access', _16 => _16.size, 'optionalAccess', _17 => _17.width]) || 1200,
+      height: _optionalChain([imageModule, 'access', _18 => _18.size, 'optionalAccess', _19 => _19.height]) || 630,
+      fonts: await normalizeFonts(imageModule.fonts),
+      emoji: imageModule.emoji,
+      debug: imageModule.debug,
+      headers: { "cache-control": cacheControl }
+    });
+    const headers = new Headers(response.headers);
+    headers.set("Cache-Control", cacheControl);
+    return finalizeMetadataImageResponse(await response.arrayBuffer(), headers, options);
+  }
+  let body;
+  if (typeof value === "string") {
+    body = toArrayBuffer(new TextEncoder().encode(value));
+  } else if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    body = toArrayBuffer(value);
+  } else if (isElement) {
+    const markup = renderer ? await renderer.renderToString(value) : (await import("react-dom/server")).renderToStaticMarkup(value);
+    body = toArrayBuffer(new TextEncoder().encode(markup));
+  } else {
+    throw new Error("Metadata image must return a Response, string, bytes, or React element");
+  }
+  return finalizeMetadataImageResponse(
+    body,
+    {
+      "Content-Type": imageModule.contentType || "image/svg+xml; charset=utf-8",
+      "Cache-Control": cacheControl
+    },
+    options
+  );
+}
+
+
+
+exports.createFarmMetadataImageResponse = createFarmMetadataImageResponse;