@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-N33DLJBC.mjs

@@ -0,0 +1,272 @@
+import {
+  readFarmEnvironmentValue
+} from "./chunk-WXFY5JIY.mjs";
+
+// src/env.ts
+var FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
+var FARM_ENV_RUNTIME_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env.runtime");
+var farmEnvGlobal = globalThis;
+var currentEnv = getInitialEnv();
+function resolveEnv(config, source = getProcessEnv()) {
+  const resolved = {
+    server: resolveEnvScope(config?.server, source, "server"),
+    public: resolveEnvScope(config?.public, source, "public")
+  };
+  return resolved;
+}
+function createBundledEnv(env2, source = getProcessEnv()) {
+  const resolved = normalizeResolvedEnv(env2 ?? {});
+  const server = {};
+  const runtime = {};
+  for (const [key, value] of Object.entries(resolved.server)) {
+    const raw = source[key];
+    const type = getRuntimeEnvType(value);
+    if (raw !== void 0 && isSameEnvValue(coerceRuntimeEnvValue(raw, type), value)) {
+      runtime[key] = type;
+    } else {
+      server[key] = value;
+    }
+  }
+  return {
+    server,
+    public: resolved.public,
+    ...Object.keys(runtime).length > 0 ? { runtime: { server: runtime } } : {}
+  };
+}
+function setEnv(env2) {
+  currentEnv = prepareEnv(env2);
+  if (typeof window === "undefined") {
+    farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
+  }
+}
+function getResolvedEnv() {
+  const env2 = getCurrentEnv();
+  if (typeof window === "undefined") readRuntimeServerEnv(env2);
+  return env2;
+}
+function getEnv(key) {
+  const server = getEnvScope("server");
+  if (key === void 0) {
+    return server;
+  }
+  return readServerEnvKey(server, key);
+}
+function getPublicEnv(key) {
+  if (key === void 0) {
+    return getCurrentEnv().public;
+  }
+  return getCurrentEnv().public[key];
+}
+var env = createEnvProxy("server");
+var serverEnv = env;
+var publicEnv = createEnvProxy("public");
+function resolveEnvScope(shape, source, scope) {
+  if (!shape) {
+    return {};
+  }
+  const resolved = {};
+  for (const [key, parser] of Object.entries(shape)) {
+    try {
+      resolved[key] = parseEnvValue(parser, source[key], key, scope);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid ${scope} env "${key}": ${message}`);
+    }
+  }
+  return resolved;
+}
+function parseEnvValue(parser, value, key, scope) {
+  if (typeof parser === "function") {
+    return parser(value, { key, scope });
+  }
+  if (parser && typeof parser.parse === "function") {
+    return parser.parse(value);
+  }
+  throw new Error("expected a parser function or schema with parse()");
+}
+function createEnvProxy(scope) {
+  return new Proxy(
+    {},
+    {
+      get(_target, property) {
+        if (typeof property === "symbol") {
+          return void 0;
+        }
+        const env2 = getEnvScope(scope);
+        return scope === "server" ? readServerEnvKey(env2, property) : env2[property];
+      },
+      ownKeys() {
+        return Reflect.ownKeys(getEnvScope(scope));
+      },
+      getOwnPropertyDescriptor(_target, property) {
+        const env2 = getEnvScope(scope);
+        if (!(property in env2)) {
+          return void 0;
+        }
+        return {
+          enumerable: true,
+          configurable: true,
+          value: env2[property]
+        };
+      },
+      has(_target, property) {
+        return property in getEnvScope(scope);
+      }
+    }
+  );
+}
+function getEnvScope(scope) {
+  const env2 = getCurrentEnv();
+  if (scope === "server") {
+    assertServerEnvAccess();
+    readRuntimeServerEnv(env2);
+  }
+  return env2[scope] || {};
+}
+function readServerEnvKey(server, key) {
+  const value = server[key];
+  if (value === void 0) {
+    const state = getCurrentEnv()[FARM_ENV_RUNTIME_SYMBOL];
+    if (state && key in state.pending && !state.warned.has(key)) {
+      state.warned.add(key);
+      console.warn(
+        `[Farm] Server env "${key}" was set when this app was built but is not set where the server runs, so it reads as undefined. Farm reads server env at runtime and does not store it in the build output; set "${key}" in the server's environment.`
+      );
+    }
+  }
+  return value;
+}
+function readRuntimeServerEnv(env2) {
+  const state = env2[FARM_ENV_RUNTIME_SYMBOL];
+  if (!state) return;
+  for (const [key, type] of Object.entries(state.pending)) {
+    const raw = readFarmEnvironmentValue(key);
+    if (raw === void 0) continue;
+    env2.server[key] = coerceRuntimeEnvValue(raw, type);
+    delete state.pending[key];
+  }
+}
+function getRuntimeEnvType(value) {
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (value !== null && typeof value === "object" && !(value instanceof Date)) return "json";
+  return "string";
+}
+function coerceRuntimeEnvValue(raw, type) {
+  if (type === "number") {
+    const value = Number(raw);
+    return raw.trim() !== "" && Number.isFinite(value) ? value : raw;
+  }
+  if (type === "boolean") {
+    if (/^(true|1)$/i.test(raw.trim())) return true;
+    if (/^(false|0|)$/i.test(raw.trim())) return false;
+    return raw;
+  }
+  if (type === "json") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+function isSameEnvValue(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => isSameEnvValue(item, right[index]));
+  }
+  if (!isPlainObject(left) || !isPlainObject(right)) return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every(
+    (key) => Object.prototype.hasOwnProperty.call(right, key) && isSameEnvValue(left[key], right[key])
+  );
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function prepareEnv(env2) {
+  const normalized = normalizeResolvedEnv(env2);
+  const runtime = env2.runtime?.server;
+  if (!isRecord(runtime) || Object.keys(runtime).length === 0) return normalized;
+  const prepared = { server: { ...normalized.server }, public: normalized.public };
+  Object.defineProperty(prepared, FARM_ENV_RUNTIME_SYMBOL, {
+    value: {
+      pending: { ...runtime },
+      warned: /* @__PURE__ */ new Set()
+    },
+    enumerable: false
+  });
+  return prepared;
+}
+function assertServerEnvAccess() {
+  if (typeof window !== "undefined") {
+    throw new Error("Farm server env is not available in the browser. Use publicEnv.");
+  }
+}
+function getInitialEnv() {
+  const injectedEnv = getInjectedEnv();
+  if (injectedEnv) {
+    return injectedEnv;
+  }
+  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
+    return normalizeResolvedEnv(farmEnvGlobal[FARM_ENV_SYMBOL]);
+  }
+  return {
+    server: {},
+    public: getInjectedPublicEnv()
+  };
+}
+function getCurrentEnv() {
+  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
+    return farmEnvGlobal[FARM_ENV_SYMBOL];
+  }
+  return currentEnv;
+}
+function getInjectedEnv() {
+  try {
+    if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
+      return prepareEnv(__FARM_ENV__);
+    }
+  } catch {
+  }
+  return null;
+}
+function getInjectedPublicEnv() {
+  try {
+    if (typeof __FARM_PUBLIC_ENV__ !== "undefined" && __FARM_PUBLIC_ENV__) {
+      return __FARM_PUBLIC_ENV__;
+    }
+  } catch {
+  }
+  return {};
+}
+function normalizeResolvedEnv(env2) {
+  return {
+    server: isRecord(env2.server) ? env2.server : {},
+    public: isRecord(env2.public) ? env2.public : {}
+  };
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getProcessEnv() {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env;
+  }
+  return {};
+}
+
+export {
+  resolveEnv,
+  createBundledEnv,
+  setEnv,
+  getResolvedEnv,
+  getEnv,
+  getPublicEnv,
+  env,
+  serverEnv,
+  publicEnv
+};

package/dist/chunk-N35YPV4N.mjs

@@ -0,0 +1,48 @@
+import {
+  bundleNodeModule
+} from "./chunk-VFXE6NWR.mjs";
+
+// src/instrumentation.ts
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+var INSTRUMENTATION_EXTENSIONS = ["ts", "mts", "js", "mjs"];
+function resolveFarmInstrumentationFile(root, srcDir = "src") {
+  const candidates = [
+    ...INSTRUMENTATION_EXTENSIONS.map(
+      (extension) => path.join(root, srcDir, `instrumentation.${extension}`)
+    ),
+    ...INSTRUMENTATION_EXTENSIONS.map(
+      (extension) => path.join(root, `instrumentation.${extension}`)
+    )
+  ].filter((candidate) => fs.existsSync(candidate));
+  if (candidates.length > 1) {
+    throw new Error(
+      `Farm.js found multiple instrumentation files:
+${candidates.map((candidate) => `- ${path.relative(root, candidate)}`).join("\n")}
+Keep only one instrumentation file in the project root or ${srcDir}/.`
+    );
+  }
+  return candidates[0] ?? null;
+}
+async function loadFarmInstrumentation(filePath, root) {
+  if (!filePath) return null;
+  const outputDirectory = path.join(root, ".farm", ".instrumentation-loader");
+  const outputFile = path.join(outputDirectory, "instrumentation.mjs");
+  await fs.promises.mkdir(outputDirectory, { recursive: true });
+  await bundleNodeModule({
+    root,
+    entry: filePath,
+    outfile: outputFile,
+    target: "node20",
+    externalPackages: true
+  });
+  const url = pathToFileURL(outputFile);
+  url.searchParams.set("t", String(Date.now()));
+  return await import(url.href);
+}
+
+export {
+  resolveFarmInstrumentationFile,
+  loadFarmInstrumentation
+};

package/dist/chunk-N6SIQJEJ.mjs

@@ -0,0 +1,390 @@
+import {
+  getFarmRouteLabel
+} from "./chunk-NRFUVDTH.mjs";
+import {
+  classifyFarmAgent
+} from "./chunk-N77JBPLC.mjs";
+import {
+  onFarmEvent
+} from "./chunk-2DA7CLY7.mjs";
+import {
+  getCurrentRequestOrNull
+} from "./chunk-6HRAK7I5.mjs";
+
+// src/plugins/infra-analytics.ts
+import { AsyncLocalStorage } from "async_hooks";
+var FARM_PRERENDER_ENV = "FARM_PRERENDER";
+var DEFAULT_URL = "https://app.farmjs.dev";
+var EVENTS_PATH = "/api/telemetry/v1/events";
+var INGESTION_KEY = /^fti_[A-Za-z0-9_-]{43}$/;
+var API_KEY = /^farmjs_[A-Za-z0-9_-]{32}$/;
+var PROJECT = /^proj_[0-9a-f-]{36}$/;
+var ENVIRONMENTS = ["production", "staging", "development"];
+var METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "QUERY"]);
+var MAX_QUEUE = 500;
+var MAX_AGE = 3e5;
+var MAX_ATTEMPTS = 5;
+var FLUSH_BUDGET = 5e3;
+var TIMEOUT = 2e3;
+var encoder = new TextEncoder();
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var uuid = () => globalThis.crypto.randomUUID();
+function processEnv() {
+  return globalThis.process?.env ?? {};
+}
+function defaultFarmInfraEnvironment(env = processEnv()) {
+  const explicit = env.FARMJS_ENVIRONMENT;
+  if (explicit && ENVIRONMENTS.includes(explicit)) return explicit;
+  if (env.VERCEL_ENV === "production") return "production";
+  if (env.VERCEL_ENV === "preview") return "staging";
+  if (env.VERCEL_ENV === "development") return "development";
+  return env.NODE_ENV === "production" ? "production" : "development";
+}
+function resolveFarmInfraAnalytics(env = processEnv()) {
+  const key = env.FARMJS_API_KEY?.trim();
+  if (!key || env[FARM_PRERENDER_ENV] === "1") return { off: null };
+  const ingestionKey = INGESTION_KEY.test(key);
+  const projectId = env.FARMJS_PROJECT_ID?.trim() || void 0;
+  if (!ingestionKey && !projectId) return { off: null };
+  if (!ingestionKey && !API_KEY.test(key)) {
+    return {
+      off: "FARMJS_API_KEY isn't a Farm Infra API key (farmjs_\u2026) or write-only key (fti_\u2026)"
+    };
+  }
+  if (!ingestionKey && !PROJECT.test(projectId)) {
+    return { off: "FARMJS_PROJECT_ID isn't a Farm Infra project ID (proj_\u2026)" };
+  }
+  if (env.FARMJS_ENVIRONMENT && !ENVIRONMENTS.includes(env.FARMJS_ENVIRONMENT)) {
+    return { off: "FARMJS_ENVIRONMENT must be production, staging or development" };
+  }
+  let endpoint;
+  try {
+    endpoint = new URL(EVENTS_PATH, env.FARMJS_API_URL?.trim() || DEFAULT_URL);
+  } catch {
+    return { off: "FARMJS_API_URL isn't a URL" };
+  }
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(endpoint.hostname);
+  if (endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && loopback) || endpoint.username || endpoint.password) {
+    return { off: "FARMJS_API_URL must use HTTPS (HTTP only for localhost)" };
+  }
+  return {
+    options: {
+      endpoint: endpoint.href,
+      key,
+      ...ingestionKey ? {} : { projectId, environment: defaultFarmInfraEnvironment(env) }
+    }
+  };
+}
+function classifyFarmInfraAgent(userAgent) {
+  return classifyFarmAgent(userAgent);
+}
+function routeTemplate(pattern) {
+  return typeof pattern === "string" && pattern.length <= 256 && /^\/(?!\/)[a-zA-Z0-9_./:[\]()*-]*$/.test(pattern) ? pattern : "/[unmatched]";
+}
+function duration(value) {
+  return Number.isFinite(value) ? Math.min(864e5, Math.max(0, value)) : 0;
+}
+function isToolEvent(value) {
+  if (!value || typeof value !== "object") return false;
+  const event = value;
+  return event.type === "mcp.tool.complete" && typeof event.tool === "string" && /^[a-zA-Z0-9_.:/-]{1,128}$/.test(event.tool) && (event.outcome === "success" || event.outcome === "error") && typeof event.durationMs === "number" && Number.isFinite(event.durationMs);
+}
+function retryAt(value, now) {
+  if (!value) return now;
+  if (/^\d+$/.test(value.trim())) return now + Math.min(Number(value), 86400) * 1e3;
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(now, Math.min(date, now + 864e5)) : now;
+}
+function createFarmInfraAnalyticsExporter(options, send = (input, init) => fetch(input, init)) {
+  const requestHeaders = {
+    "content-type": "application/json",
+    authorization: `Bearer ${options.key}`
+  };
+  if (!INGESTION_KEY.test(options.key)) {
+    requestHeaders["x-farm-project"] = options.projectId;
+    requestHeaders["x-farm-environment"] = options.environment ?? defaultFarmInfraEnvironment();
+  }
+  const queue = [];
+  let stopped = false;
+  let closing = false;
+  let pending;
+  let notBefore = 0;
+  let active;
+  let inFlight = /* @__PURE__ */ new Set();
+  const diagnostic = (event) => {
+    try {
+      void Promise.resolve(options.onDiagnostic?.(event)).catch(() => {
+      });
+    } catch {
+    }
+  };
+  const expired = (item, now) => !inFlight.has(item) && (now - item.enqueuedAt >= MAX_AGE || item.attempts >= MAX_ATTEMPTS);
+  function prune() {
+    const now = Date.now();
+    let count = 0;
+    for (let i = queue.length - 1; i >= 0; i--) {
+      if (expired(queue[i], now)) {
+        queue.splice(i, 1);
+        count++;
+      }
+    }
+    if (count) diagnostic({ code: "dropped", count });
+  }
+  function remove(batch) {
+    const sent = new Set(batch);
+    for (let i = queue.length - 1; i >= 0; i--) if (sent.has(queue[i])) queue.splice(i, 1);
+  }
+  function enqueue(event) {
+    if (stopped || closing) return;
+    prune();
+    if (queue.length >= MAX_QUEUE) {
+      diagnostic({ code: "dropped", count: 1 });
+      return;
+    }
+    queue.push({ event, enqueuedAt: Date.now(), attempts: 0 });
+  }
+  async function drain() {
+    const deadline = Date.now() + FLUSH_BUDGET;
+    await sleep(25);
+    while (!stopped && queue.length && Date.now() < deadline) {
+      prune();
+      if (!queue.length || notBefore >= deadline) break;
+      if (notBefore > Date.now()) await sleep(notBefore - Date.now());
+      if (stopped || Date.now() >= deadline) break;
+      const batch = queue.slice(0, 50);
+      const body = JSON.stringify({ schemaVersion: 1, events: batch.map(({ event }) => event) });
+      if (encoder.encode(body).length > 128 * 1024) {
+        queue.splice(0, batch.length);
+        diagnostic({ code: "dropped", count: batch.length });
+        continue;
+      }
+      for (const item of batch) item.attempts++;
+      inFlight = new Set(batch);
+      active = new AbortController();
+      const timeout = setTimeout(() => active?.abort(), Math.min(TIMEOUT, deadline - Date.now()));
+      let status;
+      try {
+        const response = await send(options.endpoint, {
+          method: "POST",
+          redirect: "error",
+          signal: active.signal,
+          headers: requestHeaders,
+          body
+        });
+        status = response.status;
+        void response.body?.cancel().catch(() => {
+        });
+        if (response.ok) {
+          remove(batch);
+          continue;
+        }
+        if ([400, 401, 403, 404, 413, 415].includes(status) || status >= 300 && status < 400) {
+          stopped = true;
+          queue.length = 0;
+          diagnostic({ code: "disabled", status });
+          break;
+        }
+        if (status !== 408 && status !== 429 && status < 500) {
+          remove(batch);
+          diagnostic({ code: "dropped", count: batch.length, status });
+          continue;
+        }
+        notBefore = Math.max(notBefore, retryAt(response.headers.get("retry-after"), Date.now()));
+      } catch {
+      } finally {
+        clearTimeout(timeout);
+        active = void 0;
+        inFlight.clear();
+      }
+      notBefore = Math.max(
+        notBefore,
+        Date.now() + Math.min(3e4, 500 * 2 ** (batch[0].attempts - 1))
+      );
+      diagnostic({ code: "retry", ...status === void 0 ? {} : { status } });
+    }
+  }
+  function flush() {
+    if (stopped || !queue.length || notBefore > Date.now() + FLUSH_BUDGET)
+      return pending ?? Promise.resolve();
+    pending ?? (pending = drain().catch(() => {
+    }).finally(() => {
+      pending = void 0;
+    }));
+    return pending;
+  }
+  async function close() {
+    if (closing) {
+      await pending;
+      return;
+    }
+    closing = true;
+    await flush();
+    stopped = true;
+    active?.abort();
+    if (queue.length) diagnostic({ code: "dropped", count: queue.length });
+    queue.length = 0;
+  }
+  return { enqueue, flush, close };
+}
+var CONTEXT_KEY = "farm.infra.analytics";
+function beginRequest(request, route, waitUntil) {
+  return {
+    id: uuid(),
+    agent: classifyFarmInfraAgent(request.headers.get("user-agent")),
+    route,
+    completed: false,
+    waitUntil
+  };
+}
+function requestEvent(metadata, method, status, durationMs) {
+  return {
+    id: uuid(),
+    requestId: metadata.id,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    route: routeTemplate(getFarmRouteLabel(metadata.route)),
+    agent: metadata.agent,
+    kind: "request",
+    method,
+    status,
+    durationMs: duration(durationMs)
+  };
+}
+function toolEvent(metadata, event) {
+  return {
+    id: uuid(),
+    requestId: metadata.id,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    route: routeTemplate(getFarmRouteLabel(metadata.route)),
+    agent: metadata.agent,
+    kind: "mcp.tool",
+    tool: event.tool,
+    outcome: event.outcome,
+    durationMs: duration(event.durationMs)
+  };
+}
+function farmInfraAnalyticsPlugin(options, send) {
+  const contextKey = `${CONTEXT_KEY}.${uuid()}`;
+  return {
+    name: "farm:infra-analytics",
+    enforce: "post",
+    setup(context) {
+      const state = { exporter: createFarmInfraAnalyticsExporter(options, send) };
+      context.lifecycle.onShutdown(async () => {
+        state.unsubscribe?.();
+        await state.exporter.close();
+      });
+      return state;
+    },
+    runtime: {
+      // Recording a request decides nothing about who may read the response.
+      cache: "public",
+      start(context) {
+        const { exporter } = context.state;
+        context.state.unsubscribe = onFarmEvent(
+          (event) => {
+            if (!isToolEvent(event)) return;
+            const request = getCurrentRequestOrNull();
+            if (!request) return;
+            const metadata = context.requestContext.get(request, contextKey);
+            if (!metadata) return;
+            exporter.enqueue(toolEvent(metadata, event));
+            metadata.waitUntil(exporter.flush());
+          },
+          { unfiltered: true }
+        );
+      },
+      before(event) {
+        if (event.kind === "asset" || !event.state) return;
+        event.req.set(contextKey, beginRequest(event.request, event.route, event.waitUntil));
+      },
+      after(event) {
+        const metadata = event.req.get(contextKey) ?? (event.kind === "endpoint" ? beginRequest(event.request, event.route, event.waitUntil) : void 0);
+        if (!metadata || metadata.completed || !event.state) return;
+        metadata.completed = true;
+        if (!METHODS.has(event.request.method)) return;
+        event.state.exporter.enqueue(
+          requestEvent(metadata, event.request.method, event.response.status, event.durationMs)
+        );
+        event.waitUntil(event.state.exporter.flush());
+      },
+      // Unhandled exceptions have no final HTTP status at this boundary. Do not fabricate a 500.
+      error(event) {
+        const metadata = event.req.get(contextKey);
+        if (metadata) metadata.completed = true;
+        if (event.state) event.waitUntil(event.state.exporter.flush());
+      }
+    }
+  };
+}
+function farmInfraAnalyticsRecorder(options, send) {
+  const exporter = createFarmInfraAnalyticsExporter(options, send);
+  const requests = new AsyncLocalStorage();
+  const unsubscribe = onFarmEvent(
+    (event) => {
+      if (!isToolEvent(event)) return;
+      const metadata = requests.getStore();
+      if (!metadata) return;
+      exporter.enqueue(toolEvent(metadata, event));
+      metadata.waitUntil(exporter.flush());
+    },
+    { unfiltered: true }
+  );
+  return {
+    async record(request, runtime, waitUntil, handler) {
+      if (runtime.kind === "asset") return handler();
+      const background = (promise) => waitUntil ? waitUntil(promise) : void promise.catch(() => {
+      });
+      const metadata = beginRequest(request, runtime.route, background);
+      const startedAt = performance.now();
+      let response;
+      try {
+        response = await requests.run(metadata, handler);
+      } catch (error) {
+        background(exporter.flush());
+        throw error;
+      }
+      if (METHODS.has(request.method)) {
+        exporter.enqueue(
+          requestEvent(metadata, request.method, response.status, performance.now() - startedAt)
+        );
+      }
+      background(exporter.flush());
+      return response;
+    },
+    close() {
+      unsubscribe();
+      return exporter.close();
+    }
+  };
+}
+function linkedOptions(env, warn) {
+  const resolved = resolveFarmInfraAnalytics(env);
+  if ("off" in resolved) {
+    if (resolved.off) warn(`[Farm] Farm Infra analytics is off: ${resolved.off}.`);
+    return null;
+  }
+  return {
+    ...resolved.options,
+    onDiagnostic(event) {
+      if (event.code === "disabled") {
+        warn(
+          `[Farm] Farm Infra analytics stopped: Farm Infra answered ${event.status}. Check FARMJS_API_KEY and FARMJS_PROJECT_ID, then restart the server.`
+        );
+      }
+    }
+  };
+}
+function createFarmInfraAnalyticsPlugin(env = processEnv(), warn = console.warn) {
+  const options = linkedOptions(env, warn);
+  return options ? farmInfraAnalyticsPlugin(options) : null;
+}
+function createFarmInfraAnalyticsRecorder(env = processEnv(), warn = console.warn) {
+  const options = linkedOptions(env, warn);
+  return options ? farmInfraAnalyticsRecorder(options) : null;
+}
+
+export {
+  FARM_PRERENDER_ENV,
+  createFarmInfraAnalyticsPlugin,
+  createFarmInfraAnalyticsRecorder
+};