@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-RVGLYMJM.cjs

@@ -0,0 +1,259 @@
+"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(); } } 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 _chunkBBPDJGCUcjs = require('./chunk-BBPDJGCU.cjs');
+
+
+var _chunkVOQ7XZZTcjs = require('./chunk-VOQ7XZZT.cjs');
+
+
+var _chunkAOKXITZ6cjs = require('./chunk-AOKXITZ6.cjs');
+
+
+var _chunkOWQV6MLMcjs = require('./chunk-OWQV6MLM.cjs');
+
+// src/i18n/server.ts
+var _async_hooks = require('async_hooks');
+
+// src/i18n/runtime.ts
+var _intlmessageformat = require('intl-messageformat'); var _intlmessageformat2 = _interopRequireDefault(_intlmessageformat);
+var FarmI18nRuntime = class {
+  constructor(config, catalogs = {}) {
+    this.compiled = /* @__PURE__ */ new Map();
+    this.warnedMissing = /* @__PURE__ */ new Set();
+    this.config = config;
+    this.catalogs = catalogs;
+  }
+  async initialize() {
+    if (!this.config.enabled) return;
+    const bundle = await _chunkBBPDJGCUcjs.readFarmI18nCatalogs.call(void 0, this.config);
+    this.replaceCatalogs(bundle.catalogs);
+  }
+  async reload() {
+    await this.initialize();
+  }
+  replaceCatalogs(catalogs) {
+    this.catalogs = catalogs;
+    this.compiled.clear();
+    this.warnedMissing.clear();
+  }
+  getCatalogs() {
+    return Object.fromEntries(
+      Object.entries(this.catalogs).map(([locale, catalog]) => [locale, { ...catalog }])
+    );
+  }
+  resolveRequest(request, options = {}) {
+    return _chunkVOQ7XZZTcjs.resolveFarmLocaleRequest.call(void 0, request, this.config, options);
+  }
+  translate(locale, key, values) {
+    const result = this.formatMessage(locale, key, values);
+    if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
+      throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
+    }
+    return Array.isArray(result) ? result.join("") : String(result);
+  }
+  translateRich(locale, key, values) {
+    const result = this.formatMessage(locale, key, values);
+    return Array.isArray(result) && result.length === 1 ? result[0] : result;
+  }
+  getRawMessage(locale, key) {
+    return this.resolveMessage(locale, key);
+  }
+  hasMessage(locale, key) {
+    return this.readOwnMessage(locale, key) !== void 0;
+  }
+  getClientSnapshot(resolution) {
+    return {
+      locale: resolution.locale,
+      source: resolution.source,
+      locales: this.config.locales,
+      defaultLocale: this.config.defaultLocale,
+      routing: this.config.routing,
+      basePath: this.config.basePath,
+      cookie: this.config.cookie,
+      direction: _chunkOWQV6MLMcjs.getFarmLocaleDirection.call(void 0, resolution.locale, this.config.direction),
+      messages: {
+        ...this.catalogs[this.config.fallbackLocale],
+        ...this.catalogs[resolution.locale]
+      }
+    };
+  }
+  formatMessage(locale, key, values) {
+    const message = this.resolveMessage(locale, key);
+    const cacheKey = `${locale}\0${key}\0${message}`;
+    let formatter = this.compiled.get(cacheKey);
+    if (!formatter) {
+      formatter = new (0, _intlmessageformat2.default)(message, locale);
+      this.compiled.set(cacheKey, formatter);
+    }
+    return formatter.format(values);
+  }
+  // Look up a message by own-property only. A key named after an
+  // Object.prototype member (toString, valueOf, constructor, ...) must resolve
+  // to a real catalog entry or undefined, never the inherited prototype value
+  // (mirrors the own-property handling added to catalog.ts in #454).
+  readOwnMessage(locale, key) {
+    const direct = this.catalogs[locale];
+    if (direct && Object.prototype.hasOwnProperty.call(direct, key)) return direct[key];
+    const fallback = this.catalogs[this.config.fallbackLocale];
+    if (fallback && Object.prototype.hasOwnProperty.call(fallback, key)) return fallback[key];
+    return void 0;
+  }
+  resolveMessage(locale, key) {
+    const message = this.readOwnMessage(locale, key);
+    if (message !== void 0) return message;
+    if (this.config.strict) {
+      throw new Error(`Missing Farm i18n message "${key}" for locale "${locale}".`);
+    }
+    const warningKey = `${locale}:${key}`;
+    if (!this.warnedMissing.has(warningKey)) {
+      this.warnedMissing.add(warningKey);
+      console.warn(`[Farm.js] Missing i18n message "${key}" for locale "${locale}".`);
+    }
+    return key;
+  }
+};
+function createFarmI18nRuntime(config, catalogs) {
+  return new FarmI18nRuntime(config, catalogs);
+}
+
+// src/i18n/server.ts
+var FARM_I18N_REQUEST_STORE = /* @__PURE__ */ Symbol.for("farm.i18n.requestStore");
+var FARM_I18N_DEFAULT_RUNTIME = /* @__PURE__ */ Symbol.for("farm.i18n.defaultRuntime");
+function getRequestStore() {
+  const state = globalThis;
+  return _nullishCoalesce(state[FARM_I18N_REQUEST_STORE], () => ( (state[FARM_I18N_REQUEST_STORE] = new (0, _async_hooks.AsyncLocalStorage)())));
+}
+function getState() {
+  const state = getRequestStore().getStore();
+  if (!state) {
+    throw new Error(
+      "No Farm i18n request context is active. Use this API while rendering, inside an API route, or use createTranslator(locale)."
+    );
+  }
+  return state;
+}
+function _setDefaultFarmI18nRuntime(runtime) {
+  globalThis[FARM_I18N_DEFAULT_RUNTIME] = runtime;
+}
+async function _runWithFarmI18nRequest(runtime, request, fn, options = {}) {
+  const resolution = runtime.resolveRequest(request, options);
+  const state = {
+    runtime,
+    resolution,
+    snapshot: runtime.getClientSnapshot(resolution)
+  };
+  return getRequestStore().run(state, () => fn(resolution));
+}
+async function runWithLocale(locale, fn) {
+  const runtime = getDefaultRuntime();
+  assertLocale(runtime, locale);
+  const resolution = {
+    locale,
+    source: "explicit",
+    pathname: "/",
+    persist: false
+  };
+  const state = {
+    runtime,
+    resolution,
+    snapshot: runtime.getClientSnapshot(resolution)
+  };
+  return getRequestStore().run(state, fn);
+}
+function getLocale() {
+  return getState().resolution.locale;
+}
+function getLocaleSource() {
+  return getState().resolution.source;
+}
+var t = createTranslatorFromState(() => getState());
+function createTranslator(locale) {
+  const runtime = getDefaultRuntime();
+  assertLocale(runtime, locale);
+  return createTranslatorFromState(() => ({
+    runtime,
+    resolution: {
+      locale,
+      source: "explicit",
+      pathname: "/",
+      persist: false
+    },
+    snapshot: runtime.getClientSnapshot({
+      locale,
+      source: "explicit",
+      pathname: "/",
+      persist: false
+    })
+  }));
+}
+function getFarmI18nClientSnapshot() {
+  return _optionalChain([getRequestStore, 'call', _ => _(), 'access', _2 => _2.getStore, 'call', _3 => _3(), 'optionalAccess', _4 => _4.snapshot]);
+}
+var format = {
+  number(value, options) {
+    return new Intl.NumberFormat(getLocale(), options).format(value);
+  },
+  currency(value, currency, options = {}) {
+    return new Intl.NumberFormat(getLocale(), {
+      ...options,
+      style: "currency",
+      currency
+    }).format(value);
+  },
+  date(value, options) {
+    return new Intl.DateTimeFormat(getLocale(), options).format(value);
+  },
+  relativeTime(value, unit, options) {
+    return new Intl.RelativeTimeFormat(getLocale(), options).format(value, unit);
+  },
+  list(values, options) {
+    const ListFormat = Intl.ListFormat;
+    return new ListFormat(getLocale(), options).format(Array.from(values));
+  }
+};
+function getDefaultRuntime() {
+  const runtime = globalThis[FARM_I18N_DEFAULT_RUNTIME];
+  if (!_optionalChain([runtime, 'optionalAccess', _5 => _5.config, 'access', _6 => _6.enabled])) {
+    throw new Error("Farm i18n is not configured for this application.");
+  }
+  return runtime;
+}
+function assertLocale(runtime, locale) {
+  if (!runtime.config.locales.includes(locale)) {
+    throw new Error(`Unsupported Farm i18n locale "${locale}".`);
+  }
+}
+function createTranslatorFromState(resolveState) {
+  const translator = ((key, values) => {
+    const state = resolveState();
+    return state.runtime.translate(state.resolution.locale, key, values);
+  });
+  translator.rich = (key, values) => {
+    const state = resolveState();
+    return state.runtime.translateRich(state.resolution.locale, key, values);
+  };
+  translator.raw = (key) => {
+    const state = resolveState();
+    return state.runtime.getRawMessage(state.resolution.locale, key);
+  };
+  translator.has = (key) => {
+    const state = resolveState();
+    return state.runtime.hasMessage(state.resolution.locale, key);
+  };
+  return translator;
+}
+_chunkAOKXITZ6cjs._setFarmI18nSnapshotResolver.call(void 0, () => getFarmI18nClientSnapshot());
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FarmI18nRuntime = FarmI18nRuntime; exports.createFarmI18nRuntime = createFarmI18nRuntime; exports._setDefaultFarmI18nRuntime = _setDefaultFarmI18nRuntime; exports._runWithFarmI18nRequest = _runWithFarmI18nRequest; exports.runWithLocale = runWithLocale; exports.getLocale = getLocale; exports.getLocaleSource = getLocaleSource; exports.t = t; exports.createTranslator = createTranslator; exports.getFarmI18nClientSnapshot = getFarmI18nClientSnapshot; exports.format = format;

package/dist/chunk-RYDDUCNJ.mjs

@@ -0,0 +1,433 @@
+import {
+  getFarmRouteLabel
+} from "./chunk-DGVVVYKD.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 && !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 && projectId && !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 ? { 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;
+}
+var REFUSALS = {
+  project: "project",
+  api_key_permission: "permission",
+  api_key_environment: "environment"
+};
+async function refusal(response) {
+  const reader = response.body?.getReader();
+  if (!reader) return void 0;
+  let text = "";
+  const decoder = new TextDecoder();
+  const deadline = Date.now() + 500;
+  try {
+    while (text.length < 1024 && Date.now() < deadline) {
+      let timer;
+      const chunk = await Promise.race([
+        reader.read(),
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve({ done: true }), deadline - Date.now());
+        })
+      ]).finally(() => clearTimeout(timer));
+      if (chunk.done) break;
+      text += decoder.decode(chunk.value, { stream: true });
+    }
+    const code = JSON.parse(text).error;
+    return typeof code === "string" && Object.prototype.hasOwnProperty.call(REFUSALS, code) ? REFUSALS[code] : void 0;
+  } catch {
+    return void 0;
+  } finally {
+    void reader.cancel().catch(() => {
+    });
+  }
+}
+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)) {
+    if (options.projectId) 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;
+        const reason = status === 400 || status === 403 ? await refusal(response) : void 0;
+        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, ...reason ? { reason } : {} });
+          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") return;
+      if (event.reason === "environment") return;
+      warn(`[Farm] Farm Infra analytics stopped: ${stopReason(event)}`);
+    }
+  };
+}
+var KEYS_PAGE = "the API keys page (https://app.farmjs.dev/dashboard/settings)";
+function stopReason(event) {
+  if (event.reason === "project") {
+    return "FARMJS_API_KEY reaches more than one project. Set FARMJS_PROJECT_ID or use a key scoped to one project, then restart the server.";
+  }
+  if (event.reason === "permission") {
+    return `this key can't send analytics. Create a Site analytics key on ${KEYS_PAGE}, set it as FARMJS_API_KEY, then restart the server.`;
+  }
+  if (event.status === 401) {
+    return `Farm Infra answered 401: FARMJS_API_KEY was revoked or has expired. Create a new Site analytics key on ${KEYS_PAGE}, then restart the server.`;
+  }
+  return `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
+};

package/dist/chunk-S32PDOLO.mjs

@@ -0,0 +1,13 @@
+// src/island.ts
+var FARM_ISLAND_STRATEGIES = ["load", "interaction", "visible", "idle"];
+function isFarmIslandStrategy(value) {
+  return FARM_ISLAND_STRATEGIES.includes(value);
+}
+var FARM_ISLAND_ACTIVATION_EVENTS = ["click", "submit", "pointerdown", "focusin"];
+var FARM_ISLAND_REPLAYABLE_SELECTOR = 'button,[role="button"],input[type="button"],input[type="submit"],input[type="reset"]';
+
+export {
+  isFarmIslandStrategy,
+  FARM_ISLAND_ACTIVATION_EVENTS,
+  FARM_ISLAND_REPLAYABLE_SELECTOR
+};