@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-LA6O5EL2.mjs

@@ -0,0 +1,254 @@
+import {
+  FARM_VERSION
+} from "./chunk-RFYL5OLP.mjs";
+
+// src/deployment-environment.ts
+function isFarmProductionDeploymentEnvironment(env = process.env) {
+  const environment = normalizeEnvironment(env.VERCEL_ENV);
+  const targetEnvironment = normalizeEnvironment(env.VERCEL_TARGET_ENV);
+  if (environment && environment !== "production") return false;
+  if (targetEnvironment && targetEnvironment !== "production") return false;
+  if (isTrue(env.NETLIFY)) {
+    const context = normalizeEnvironment(env.CONTEXT);
+    if (context && context !== "production") return false;
+  }
+  if (isTrue(env.IS_PULL_REQUEST)) return false;
+  return true;
+}
+function isFarmPreviewDeploymentEnvironment(env) {
+  return resolveFarmPreviewDeployment(env, false);
+}
+function resolveFarmPreviewDeployment(env, builtAsPreview) {
+  const explicit = env?.FARM_PREVIEW;
+  if (isTrue(explicit)) return true;
+  if (isFalse(explicit)) return false;
+  if (builtAsPreview || !env) return builtAsPreview;
+  if (normalizeEnvironment(env.VERCEL_ENV) === "preview") return true;
+  if (isTrue(env.NETLIFY)) {
+    const context = normalizeEnvironment(env.CONTEXT);
+    if (context === "deploy-preview" || context === "branch-deploy") return true;
+  }
+  return isTrue(env.IS_PULL_REQUEST);
+}
+function normalizeEnvironment(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized || void 0;
+}
+function isTrue(value) {
+  return value !== void 0 && ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+function isFalse(value) {
+  return value !== void 0 && ["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+
+// src/product-telemetry.ts
+var FARM_PRODUCTION_SITE_TELEMETRY_SCHEMA_VERSION = 1;
+var FARM_PRODUCTION_SITE_TELEMETRY_EVENT_TYPE = "production_site_active";
+var FARM_PRODUCTION_SITE_TELEMETRY_PACKAGE_NAME = "@farm.js/core";
+var FARM_PRODUCTION_SITE_ATTESTATION_PATH = "/.well-known/farm-telemetry";
+var FARM_PRODUCTION_SITE_ATTESTATION_EVENT_TYPE = "production_site_attestation";
+var DEFAULT_SITE_TELEMETRY_ENDPOINT = "https://farmjs.dev/api/telemetry/v1/sites";
+var REQUEST_TIMEOUT_MS = 3e3;
+var REPORT_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var RETRY_INTERVAL_MS = 5 * 60 * 1e3;
+var MAX_ORIGINS_PER_INSTANCE = 32;
+var SAFE_DETAIL_PATTERN = /^[0-9A-Za-z._-]{1,64}$/;
+function detectFarmProductionSiteOrigin(value) {
+  try {
+    const url = value instanceof URL ? value : new URL(value);
+    return normalizeFarmProductionSiteOrigin(url.origin);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeFarmProductionSiteOrigin(value) {
+  const candidate = value.trim();
+  if (!candidate || candidate.length > 2048) return void 0;
+  try {
+    const url = new URL(candidate);
+    const hostname = url.hostname.toLowerCase();
+    const isIpv4 = /^\d{1,3}(?:\.\d{1,3}){3}$/.test(hostname);
+    const isIpv6 = hostname.startsWith("[") && hostname.endsWith("]");
+    const isLocal = hostname === "localhost" || hostname.endsWith(".localhost") || hostname.endsWith(".local");
+    const isSingleLabel = !hostname.includes(".");
+    if (url.protocol !== "https:" || url.username || url.password || url.search || url.hash || url.pathname !== "/" || isIpv4 || isIpv6 || isLocal || isSingleLabel || hostname.endsWith(".")) {
+      return void 0;
+    }
+    return url.origin;
+  } catch {
+    return void 0;
+  }
+}
+function createFarmProductionSiteReporter(options) {
+  const now = options.now ?? Date.now;
+  const reportIntervalMs = options.reportIntervalMs ?? REPORT_INTERVAL_MS;
+  const retryIntervalMs = options.retryIntervalMs ?? RETRY_INTERVAL_MS;
+  const send = options.fetch ?? globalThis.fetch;
+  const reportStates = /* @__PURE__ */ new Map();
+  let reportingSkipped;
+  const attestation = {
+    schemaVersion: FARM_PRODUCTION_SITE_TELEMETRY_SCHEMA_VERSION,
+    eventType: FARM_PRODUCTION_SITE_ATTESTATION_EVENT_TYPE,
+    packageName: FARM_PRODUCTION_SITE_TELEMETRY_PACKAGE_NAME,
+    packageVersion: sanitizeDetail(FARM_VERSION, "unknown"),
+    renderer: sanitizeDetail(options.renderer, "custom"),
+    deployTarget: sanitizeDetail(options.deployTarget, "custom")
+  };
+  return {
+    handleAttestation(request) {
+      if (!request.url.includes(FARM_PRODUCTION_SITE_ATTESTATION_PATH)) return null;
+      if (productionTelemetryDisabled()) return null;
+      let pathname;
+      try {
+        pathname = new URL(request.url).pathname;
+      } catch {
+        return null;
+      }
+      if (pathname !== FARM_PRODUCTION_SITE_ATTESTATION_PATH) return null;
+      if (request.method !== "GET" && request.method !== "HEAD") {
+        return new Response("Method Not Allowed", {
+          status: 405,
+          headers: {
+            allow: "GET, HEAD",
+            "cache-control": "no-store",
+            "content-type": "text/plain; charset=utf-8",
+            "x-content-type-options": "nosniff"
+          }
+        });
+      }
+      return new Response(request.method === "HEAD" ? null : JSON.stringify(attestation), {
+        status: 200,
+        headers: {
+          "cache-control": "no-store",
+          "content-type": "application/json; charset=utf-8",
+          "x-content-type-options": "nosniff"
+        }
+      });
+    },
+    report(requestUrl, waitUntil) {
+      if (reportingSkipped === void 0) {
+        reportingSkipped = productionTelemetryDisabled() ? "disabled" : isFarmProductionDeploymentEnvironment() ? false : "not-production";
+        if (reportingSkipped === "not-production") {
+          debug("production-site check-in skipped outside a production deployment");
+        }
+      }
+      if (reportingSkipped) return;
+      const siteUrl = detectFarmProductionSiteOrigin(requestUrl);
+      if (!siteUrl) return;
+      let state = reportStates.get(siteUrl);
+      if (!state) {
+        if (reportStates.size >= MAX_ORIGINS_PER_INSTANCE) return;
+        state = { nextReportAt: 0 };
+        reportStates.set(siteUrl, state);
+      }
+      const attemptedAt = now();
+      if (state.pending || attemptedAt < state.nextReportAt) return;
+      state.nextReportAt = attemptedAt + reportIntervalMs;
+      const payload = {
+        schemaVersion: FARM_PRODUCTION_SITE_TELEMETRY_SCHEMA_VERSION,
+        eventType: FARM_PRODUCTION_SITE_TELEMETRY_EVENT_TYPE,
+        siteUrl,
+        packageName: FARM_PRODUCTION_SITE_TELEMETRY_PACKAGE_NAME,
+        packageVersion: attestation.packageVersion,
+        renderer: attestation.renderer,
+        deployTarget: attestation.deployTarget
+      };
+      state.pending = deliver(send, resolveSiteTelemetryEndpoint(options.endpoint), payload).then((delivered) => {
+        if (!delivered) state.nextReportAt = now() + retryIntervalMs;
+      }).catch(() => {
+        state.nextReportAt = now() + retryIntervalMs;
+      }).finally(() => {
+        state.pending = void 0;
+      });
+      if (waitUntil) {
+        try {
+          waitUntil(state.pending);
+        } catch {
+        }
+      } else {
+        void state.pending;
+      }
+    }
+  };
+}
+async function deliver(send, endpoint, payload) {
+  if (!endpoint) {
+    debug("invalid or insecure production-site telemetry endpoint; check-in skipped");
+    return false;
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  timeout.unref?.();
+  try {
+    const response = await send(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      debug(`production-site check-in rejected with HTTP ${response.status}`);
+      return false;
+    }
+    try {
+      const result = await response.json();
+      if (result && result.stored === false) {
+        debug("production-site check-in was accepted but not stored");
+        return false;
+      }
+    } catch {
+    }
+    return true;
+  } catch {
+    debug("production-site check-in failed");
+    return false;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function resolveSiteTelemetryEndpoint(explicit) {
+  const candidate = explicit || process.env.FARM_TELEMETRY_SITE_ENDPOINT;
+  if (!candidate) return DEFAULT_SITE_TELEMETRY_ENDPOINT;
+  try {
+    const url = new URL(candidate);
+    const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+    const isLocal = ["localhost", "127.0.0.1", "::1"].includes(hostname);
+    if (url.protocol === "https:" || url.protocol === "http:" && isLocal) {
+      return url.toString();
+    }
+  } catch {
+  }
+  return void 0;
+}
+function productionTelemetryDisabled() {
+  if (process.env.DO_NOT_TRACK !== void 0 && !isFalse2(process.env.DO_NOT_TRACK)) return true;
+  if (isTrue2(process.env.FARM_TELEMETRY_DISABLED)) return true;
+  return isFalse2(process.env.FARM_TELEMETRY);
+}
+function sanitizeDetail(value, fallback) {
+  return value && SAFE_DETAIL_PATTERN.test(value) ? value : fallback;
+}
+function isTrue2(value) {
+  return value !== void 0 && ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+function isFalse2(value) {
+  return value !== void 0 && ["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+function debug(message) {
+  if (!isTrue2(process.env.FARM_TELEMETRY_DEBUG)) return;
+  process.stderr.write(`[farm.telemetry] ${message}
+`);
+}
+
+export {
+  isFarmPreviewDeploymentEnvironment,
+  resolveFarmPreviewDeployment,
+  FARM_PRODUCTION_SITE_TELEMETRY_SCHEMA_VERSION,
+  FARM_PRODUCTION_SITE_TELEMETRY_EVENT_TYPE,
+  FARM_PRODUCTION_SITE_TELEMETRY_PACKAGE_NAME,
+  FARM_PRODUCTION_SITE_ATTESTATION_PATH,
+  FARM_PRODUCTION_SITE_ATTESTATION_EVENT_TYPE,
+  detectFarmProductionSiteOrigin,
+  normalizeFarmProductionSiteOrigin,
+  createFarmProductionSiteReporter
+};

package/dist/chunk-LEJDW34D.cjs

@@ -0,0 +1,115 @@
+"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 _chunkYN6BHOYYcjs = require('./chunk-YN6BHOYY.cjs');
+
+
+
+var _chunk4EBC7EMWcjs = require('./chunk-4EBC7EMW.cjs');
+
+
+var _chunk4P5634G6cjs = require('./chunk-4P5634G6.cjs');
+
+// src/mobile/native-server-fn-handler.ts
+var MOBILE_APP_HEADER = "x-farm-mobile";
+var FETCH_METADATA = ["sec-fetch-site", "sec-fetch-mode", "sec-fetch-dest", "sec-fetch-user"];
+var ID = /^[\w-]{1,64}$/;
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function hasUnsafeKey(value, depth = 0) {
+  if (depth > 64) return true;
+  if (Array.isArray(value)) return value.some((item) => hasUnsafeKey(item, depth + 1));
+  if (!value || typeof value !== "object") return false;
+  return Object.keys(value).some(
+    (key) => UNSAFE_KEYS.has(key) || hasUnsafeKey(value[key], depth + 1)
+  );
+}
+function json(status, body) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json", "cache-control": "private, no-store" }
+  });
+}
+function refuse(status, code, message) {
+  return json(status, { error: { code, message } });
+}
+async function handleFarmNativeServerFnRequest(request, options, parsed) {
+  if (request.method !== "POST") {
+    return refuse(405, "method_not_allowed", "Call server functions with POST.");
+  }
+  const origin = request.headers.get("origin");
+  if (!request.headers.get(MOBILE_APP_HEADER) || FETCH_METADATA.some((name) => request.headers.has(name)) || origin !== null && origin !== new URL(request.url).origin) {
+    return refuse(403, "not_native", "Only the app's native screens call server functions here.");
+  }
+  const length = Number(_nullishCoalesce(request.headers.get("content-length"), () => ( "0")));
+  if (length > _chunk4P5634G6cjs.DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT) {
+    return refuse(413, "body_too_large", "The call's input is too large.");
+  }
+  let call;
+  if (parsed !== void 0) call = parsed;
+  else {
+    const text = await request.text();
+    if (text.length > _chunk4P5634G6cjs.DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT) {
+      return refuse(413, "body_too_large", "The call's input is too large.");
+    }
+    try {
+      call = JSON.parse(text);
+    } catch (e) {
+      return refuse(400, "invalid_body", 'Send { "id", "input" } as JSON.');
+    }
+  }
+  if (typeof _optionalChain([call, 'optionalAccess', _ => _.id]) !== "string" || !ID.test(call.id)) {
+    return refuse(400, "invalid_body", 'Send { "id", "input" } as JSON.');
+  }
+  if (hasUnsafeKey(call.input)) {
+    return refuse(400, "invalid_body", "The input has a key that is not allowed.");
+  }
+  const fn = await options.resolve(call.id);
+  if (fn === void 0 || _chunkYN6BHOYYcjs._describeServerFunction.call(void 0, fn) === void 0) {
+    return refuse(
+      404,
+      "unknown_function",
+      "No server function with this id is open to native screens."
+    );
+  }
+  const outcome = await _chunkYN6BHOYYcjs._invokeServerFunction.call(void 0, fn, call.input, request);
+  if (outcome.ok) {
+    try {
+      return json(200, { data: _nullishCoalesce(outcome.data, () => ( null)) });
+    } catch (error) {
+      console.error("[Farm] A server function's result for a native screen is not JSON:", error);
+      return refuse(500, "server_error", "Server function failed");
+    }
+  }
+  switch (outcome.reason) {
+    case "input":
+      return refuse(
+        400,
+        "invalid_input",
+        outcome.error instanceof Error ? outcome.error.message : "The input is invalid."
+      );
+    case "failure": {
+      const { code, status, message, data } = outcome.failure;
+      return json(status, { error: { code, status, message, data } });
+    }
+    case "redirect":
+      return json(200, { redirect: { url: outcome.url, status: outcome.status } });
+    default:
+      console.error("[Farm] A server function called from a native screen failed:", outcome.error);
+      return refuse(500, "server_error", "Server function failed");
+  }
+}
+function createFarmNativeServerFnPlugin(options) {
+  return {
+    name: _chunk4EBC7EMWcjs.FARM_NATIVE_SERVER_FN_PLUGIN,
+    routes: ({ route }) => [
+      route.post(_chunk4EBC7EMWcjs.FARM_NATIVE_SERVER_FN_PATH, {
+        handler: (request, { input }) => handleFarmNativeServerFnRequest(request, options, input.body)
+      })
+    ]
+  };
+}
+
+
+
+
+exports.handleFarmNativeServerFnRequest = handleFarmNativeServerFnRequest; exports.createFarmNativeServerFnPlugin = createFarmNativeServerFnPlugin;

package/dist/chunk-LFFSDZ4Y.cjs

@@ -0,0 +1,141 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkANXU3D32cjs = require('./chunk-ANXU3D32.cjs');
+
+
+var _chunkPIUTGRDIcjs = require('./chunk-PIUTGRDI.cjs');
+
+// src/mobile/native-server-fns.ts
+var _crypto = require('crypto');
+var _fs = require('fs');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var SCRIPT = /\.(?:tsx|ts|jsx|js|mjs)$/;
+var NATIVE_SCREEN = /^(?:page|layout)\.(?:native|android|ios)\.(?:tsx|ts|jsx|js)$/;
+var IMPORT_SPECIFIERS = /(?:^|[^\w$.])(?:import|export)\s*(?:type\s+)?(?:[\w$*{}\s,]+\s+from\s*)?["']([^"']+)["']|import\(\s*["']([^"']+)["']\s*\)/g;
+function posix(file) {
+  return file.split(_path2.default.sep).join("/");
+}
+function real(file) {
+  try {
+    return _fs.realpathSync.call(void 0, file);
+  } catch (e) {
+    return file;
+  }
+}
+function farmNativeServerFnId(root, file, exportName) {
+  const relative = posix(_path2.default.relative(real(root), real(file)));
+  return _crypto.createHash.call(void 0, "sha256").update(`${relative}#${exportName}`).digest("base64url").slice(0, 20);
+}
+function describeFarmNativeServerFnModule(root, file, code) {
+  if (!code.includes("createServerFn") && !code.includes("createServerQuery")) return void 0;
+  let analysis;
+  try {
+    analysis = _chunkPIUTGRDIcjs.transformFarmServerFns.call(void 0, code, file, { environment: "client" });
+  } catch (error) {
+    const named = new Error(`${file}: ${error instanceof Error ? error.message : String(error)}`);
+    named.cause = error;
+    throw named;
+  }
+  if (!analysis || analysis.exports.length === 0) return void 0;
+  return {
+    file,
+    exports: analysis.exports.map((name) => ({ name, id: farmNativeServerFnId(root, file, name) }))
+  };
+}
+function findFarmNativeScreenFiles(appDirs) {
+  const files = [];
+  const visit = (dir) => {
+    let entries;
+    try {
+      entries = _fs.readdirSync.call(void 0, dir, { withFileTypes: true });
+    } catch (e2) {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+      const file = _path2.default.join(dir, entry.name);
+      if (entry.isDirectory()) visit(file);
+      else if (NATIVE_SCREEN.test(entry.name)) files.push(file);
+    }
+  };
+  for (const dir of appDirs) visit(dir);
+  return files.sort();
+}
+function collectFarmNativeServerFns(options) {
+  const { root, srcDir } = options;
+  const aliases = _chunkANXU3D32cjs.readAliases.call(void 0, root, srcDir);
+  const seen = /* @__PURE__ */ new Set();
+  const found = /* @__PURE__ */ new Map();
+  const queue = [...options.entries];
+  while (queue.length > 0) {
+    const file = queue.pop();
+    if (seen.has(file)) continue;
+    seen.add(file);
+    let code;
+    try {
+      code = _fs.readFileSync.call(void 0, file, "utf8");
+    } catch (e3) {
+      continue;
+    }
+    const module = describeFarmNativeServerFnModule(root, file, code);
+    if (module) {
+      found.set(file, module);
+      continue;
+    }
+    for (const match of code.matchAll(IMPORT_SPECIFIERS)) {
+      const specifier = _nullishCoalesce(match[1], () => ( match[2]));
+      let candidates;
+      if (specifier.startsWith(".")) candidates = [_path2.default.resolve(_path2.default.dirname(file), specifier)];
+      else {
+        const alias = aliases.find(
+          (entry) => specifier.startsWith(entry.prefix) || specifier === entry.prefix.replace(/\/$/, "")
+        );
+        if (alias) {
+          candidates = alias.targets.map(
+            (target) => _path2.default.join(target, specifier.slice(alias.prefix.length))
+          );
+        }
+      }
+      for (const candidate of _nullishCoalesce(candidates, () => ( []))) {
+        const resolved = _chunkANXU3D32cjs.resolveFile.call(void 0, candidate);
+        if (resolved && SCRIPT.test(resolved) && !resolved.includes(`${_path2.default.sep}node_modules${_path2.default.sep}`)) {
+          queue.push(resolved);
+          break;
+        }
+      }
+    }
+  }
+  return [...found.values()].sort((left, right) => left.file < right.file ? -1 : 1);
+}
+var FARM_DEV_SERVER_MODULE_LOADER = /* @__PURE__ */ Symbol.for("farm.dev.loadServerModule");
+function createFarmDevNativeServerFnResolver(options) {
+  return async (id) => {
+    const modules = collectFarmNativeServerFns({
+      root: options.root,
+      srcDir: options.srcDir,
+      entries: findFarmNativeScreenFiles(options.appDirs())
+    });
+    for (const module of modules) {
+      const entry = module.exports.find((candidate) => candidate.id === id);
+      if (!entry) continue;
+      const load = globalThis[FARM_DEV_SERVER_MODULE_LOADER];
+      if (!load) {
+        throw new Error(
+          "Native server function calls need the Farm dev server or a production build."
+        );
+      }
+      return (await load(module.file))[entry.name];
+    }
+    return void 0;
+  };
+}
+
+
+
+
+
+
+
+
+exports.farmNativeServerFnId = farmNativeServerFnId; exports.describeFarmNativeServerFnModule = describeFarmNativeServerFnModule; exports.findFarmNativeScreenFiles = findFarmNativeScreenFiles; exports.collectFarmNativeServerFns = collectFarmNativeServerFns; exports.FARM_DEV_SERVER_MODULE_LOADER = FARM_DEV_SERVER_MODULE_LOADER; exports.createFarmDevNativeServerFnResolver = createFarmDevNativeServerFnResolver;

package/dist/chunk-LLZSYFOM.mjs

@@ -0,0 +1,6 @@
+// src/mobile/native-tree-type.ts
+var FARM_NATIVE_TREE_CONTENT_TYPE = "application/vnd.farm.native+json";
+
+export {
+  FARM_NATIVE_TREE_CONTENT_TYPE
+};

package/dist/chunk-LM55GS4R.mjs

@@ -0,0 +1,38 @@
+// src/owned-response.ts
+var OWNED_RESPONSES = /* @__PURE__ */ Symbol.for("farm.ownedResponses");
+function registry() {
+  const state = globalThis;
+  return state[OWNED_RESPONSES] ?? (state[OWNED_RESPONSES] = /* @__PURE__ */ new WeakSet());
+}
+function _markFarmOwnedResponse(response) {
+  registry().add(response);
+  return response;
+}
+function _isFarmOwnedResponse(response) {
+  return registry().has(response);
+}
+function _withFarmResponseHeaders(response, edit) {
+  if (registry().has(response)) {
+    try {
+      edit(response.headers);
+      return response;
+    } catch (error) {
+      if (!(error instanceof TypeError)) throw error;
+    }
+  }
+  const headers = new Headers(response.headers);
+  edit(headers);
+  return _markFarmOwnedResponse(
+    new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    })
+  );
+}
+
+export {
+  _markFarmOwnedResponse,
+  _isFarmOwnedResponse,
+  _withFarmResponseHeaders
+};