@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/api.cjs

@@ -0,0 +1,4100 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api/index.ts
+var api_exports = {};
+__export(api_exports, {
+  APIClientError: () => APIClientError,
+  APIRouteManager: () => APIRouteManager,
+  API_ROUTE_METHODS: () => API_ROUTE_METHODS,
+  DELETE: () => DELETE,
+  EndpointFailure: () => EndpointFailure,
+  FARM_API_ROUTE_META_SYMBOL: () => FARM_API_ROUTE_META_SYMBOL,
+  FARM_API_ROUTE_REF_SYMBOL: () => FARM_API_ROUTE_REF_SYMBOL,
+  GET: () => GET,
+  HEAD: () => HEAD,
+  OPTIONS: () => OPTIONS,
+  PATCH: () => PATCH,
+  POST: () => POST,
+  PUT: () => PUT,
+  createAPIClient: () => createAPIClient,
+  createEndpoint: () => createEndpoint,
+  createServerAPIClient: () => createServerAPIClient,
+  farmApiPlugin: () => farmApiPlugin,
+  getAPIRouteRefMetadata: () => getAPIRouteRefMetadata,
+  invokeAPIRouteEndpoint: () => invokeAPIRouteEndpoint,
+  isAPIRouteRef: () => isAPIRouteRef,
+  isEndpointFailure: () => isEndpointFailure,
+  isFarmAPIStream: () => isFarmAPIStream,
+  isJSONStreamResponse: () => isJSONStreamResponse,
+  isMultipartSchema: () => isMultipartSchema,
+  isWebResponse: () => isWebResponse,
+  jsonStream: () => jsonStream,
+  matchAPIRoute: () => matchAPIRoute,
+  multipart: () => multipart,
+  normalizeRouteResponse: () => normalizeRouteResponse,
+  readJSONStream: () => readJSONStream,
+  toFormData: () => toFormData
+});
+module.exports = __toCommonJS(api_exports);
+
+// src/api/endpoint.ts
+var import_better_call = require("better-call");
+
+// src/observability.ts
+var runtimeHandlers = /* @__PURE__ */ new Set();
+var observabilityState = {
+  logs: false,
+  handlers: []
+};
+function emitFarmEvent(input) {
+  const event = {
+    timestamp: Date.now(),
+    level: inferFarmEventLevel(input.type),
+    ...input
+  };
+  if (!shouldEmitFarmEvent(event)) {
+    return event;
+  }
+  if (observabilityState.logs) {
+    logFarmEvent(event);
+  }
+  for (const handler of [...observabilityState.handlers, ...runtimeHandlers]) {
+    try {
+      Promise.resolve(handler(event)).catch((error) => {
+        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+      });
+    } catch (error) {
+      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+    }
+  }
+  return event;
+}
+__name(emitFarmEvent, "emitFarmEvent");
+function shouldEmitFarmEvent(event) {
+  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
+    return false;
+  }
+  if (observabilityState.events && !observabilityState.events.has(event.type)) {
+    return false;
+  }
+  return true;
+}
+__name(shouldEmitFarmEvent, "shouldEmitFarmEvent");
+function inferFarmEventLevel(type) {
+  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
+    return "error";
+  }
+  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
+    return "warn";
+  }
+  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
+    return "debug";
+  }
+  return "info";
+}
+__name(inferFarmEventLevel, "inferFarmEventLevel");
+function logFarmEvent(event) {
+  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
+  switch (event.level) {
+    case "error":
+      console.error(message);
+      break;
+    case "warn":
+      console.warn(message);
+      break;
+    default:
+      console.log(message);
+      break;
+  }
+}
+__name(logFarmEvent, "logFarmEvent");
+function formatFarmEventDetails(event) {
+  const details = [];
+  const record = event;
+  for (const key of [
+    "route",
+    "pathname",
+    "method",
+    "status",
+    "key",
+    "tag",
+    "path",
+    "reason",
+    "durationMs",
+    "integration",
+    "operation",
+    "plugin",
+    "hook",
+    "target",
+    "count"
+  ]) {
+    const value = record[key];
+    if (value !== void 0) {
+      details.push(`${key}=${formatDetailValue(value)}`);
+    }
+  }
+  return details.length > 0 ? ` ${details.join(" ")}` : "";
+}
+__name(formatFarmEventDetails, "formatFarmEventDetails");
+function formatDetailValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+__name(formatDetailValue, "formatDetailValue");
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(formatError, "formatError");
+
+// src/cache-invalidation.ts
+var FARM_CACHE_INVALIDATION_HEADER = "x-farm-cache-invalidations";
+var FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationState");
+var globalState = globalThis;
+function getFarmCacheInvalidationState() {
+  return globalState[FARM_CACHE_INVALIDATION_STATE] ?? (globalState[FARM_CACHE_INVALIDATION_STATE] = {
+    listeners: /* @__PURE__ */ new Set(),
+    taskListeners: /* @__PURE__ */ new Set()
+  });
+}
+__name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
+function notifyFarmCacheInvalidation(key) {
+  if (typeof key !== "string" || key.length === 0) return;
+  for (const listener of getFarmCacheInvalidationState().listeners) {
+    listener(key);
+  }
+}
+__name(notifyFarmCacheInvalidation, "notifyFarmCacheInvalidation");
+function notifyFarmCacheTask(task) {
+  for (const listener of getFarmCacheInvalidationState().taskListeners) {
+    listener(task);
+  }
+}
+__name(notifyFarmCacheTask, "notifyFarmCacheTask");
+function applyFarmCacheInvalidations(keys) {
+  if (!Array.isArray(keys)) return;
+  for (const key of keys) {
+    if (typeof key === "string") {
+      notifyFarmCacheInvalidation(key);
+    }
+  }
+}
+__name(applyFarmCacheInvalidations, "applyFarmCacheInvalidations");
+function encodeFarmCacheInvalidations(keys) {
+  const normalized = Array.from(
+    new Set(keys.filter((key) => typeof key === "string" && key.length > 0))
+  );
+  if (normalized.length === 0) return null;
+  return encodeURIComponent(JSON.stringify(normalized));
+}
+__name(encodeFarmCacheInvalidations, "encodeFarmCacheInvalidations");
+function decodeFarmCacheInvalidations(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(decodeURIComponent(value));
+    return Array.isArray(parsed) ? Array.from(
+      new Set(parsed.filter((key) => typeof key === "string" && key.length > 0))
+    ) : [];
+  } catch {
+    return [];
+  }
+}
+__name(decodeFarmCacheInvalidations, "decodeFarmCacheInvalidations");
+function subscribeFarmCacheInvalidation(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.listeners.add(listener);
+  return () => state.listeners.delete(listener);
+}
+__name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
+
+// src/i18n/bridge.ts
+var FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
+function _setFarmI18nSnapshotResolver(resolver) {
+  globalThis[FARM_I18N_SNAPSHOT_RESOLVER] = resolver;
+}
+__name(_setFarmI18nSnapshotResolver, "_setFarmI18nSnapshotResolver");
+
+// src/cache.ts
+var _FarmDataCache = class _FarmDataCache {
+  constructor(config = {}) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
+    this.version = 0;
+    this.namespace = "farm";
+    this.local = true;
+    this.lease = {
+      enabled: true,
+      ttlMs: 1e4,
+      waitTimeoutMs: 1e4,
+      pollIntervalMs: 25
+    };
+    this.configure(config);
+  }
+  configure(config = {}) {
+    this.adapter = config.adapter;
+    this.namespace = normalizeCacheNamespace(config.namespace || "farm");
+    this.local = !config.adapter;
+    this.lease = config.lease === false ? { ...this.lease, enabled: false } : {
+      enabled: true,
+      ttlMs: normalizePositiveDuration(config.lease?.ttlMs, 1e4, "cache.lease.ttlMs"),
+      waitTimeoutMs: normalizePositiveDuration(
+        config.lease?.waitTimeoutMs,
+        1e4,
+        "cache.lease.waitTimeoutMs"
+      ),
+      pollIntervalMs: normalizePositiveDuration(
+        config.lease?.pollIntervalMs,
+        25,
+        "cache.lease.pollIntervalMs"
+      )
+    };
+    if (!this.local) {
+      this.entries.clear();
+      this.inflight.clear();
+      this.invalidatedTagVersions.clear();
+      this.version = 0;
+    }
+  }
+  get adapterName() {
+    return this.adapter?.name || (this.adapter ? "custom" : "memory");
+  }
+  get hasAdapter() {
+    return this.adapter !== void 0;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get(key, options = {}) {
+    return this.getEntry(key, options)?.value;
+  }
+  getEntry(key, options = {}) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      emitFarmEvent({ type: "cache.miss", key });
+      return void 0;
+    }
+    const stale = this.isStale(entry, options.now);
+    if (stale) {
+      emitFarmEvent({
+        type: "cache.stale",
+        key,
+        tags: Array.from(entry.tags),
+        revalidate: entry.revalidate
+      });
+    }
+    if (!options.allowStale && stale) {
+      emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
+      return void 0;
+    }
+    emitFarmEvent({
+      type: "cache.hit",
+      key,
+      tags: Array.from(entry.tags),
+      revalidate: entry.revalidate,
+      stale
+    });
+    return this.toPublicEntry(entry);
+  }
+  async getEntryAsync(key, options = {}) {
+    if (this.local) {
+      const localEntry = this.getEntry(key, options);
+      if (localEntry) return localEntry;
+    }
+    if (!this.adapter) {
+      return this.local ? void 0 : this.getEntry(key, options);
+    }
+    const entry = await this.adapter.get(this.createAdapterKey(key));
+    if (!entry) {
+      emitFarmEvent({ type: "cache.miss", key });
+      return void 0;
+    }
+    assertFarmCacheEntry(entry, key);
+    const stale = await this.isAdapterEntryStale(entry, options.now);
+    if (stale) {
+      emitFarmEvent({
+        type: "cache.stale",
+        key,
+        tags: [...entry.tags],
+        revalidate: entry.revalidate
+      });
+      if (!options.allowStale) {
+        emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
+        return void 0;
+      }
+    }
+    emitFarmEvent({
+      type: "cache.hit",
+      key,
+      tags: [...entry.tags],
+      revalidate: entry.revalidate,
+      stale
+    });
+    if (this.local && !stale) {
+      this.hydrateLocalEntry(entry);
+    }
+    return { ...entry, key };
+  }
+  set(key, value, options = {}) {
+    const tags = /* @__PURE__ */ new Set();
+    for (const tag of options.tags ?? []) {
+      tags.add(normalizeCacheTag(tag));
+    }
+    for (const routePath of options.paths ?? []) {
+      tags.add(createPathCacheTag(routePath));
+    }
+    const entry = {
+      key,
+      value,
+      tags,
+      tagVersions: void 0,
+      createdAt: options.createdAt ?? Date.now(),
+      createdVersion: ++this.version,
+      revalidate: normalizeRevalidate(options.revalidate)
+    };
+    this.entries.set(key, entry);
+    emitFarmEvent({
+      type: "cache.set",
+      key,
+      tags: Array.from(tags),
+      revalidate: entry.revalidate
+    });
+    return this.toPublicEntry(entry);
+  }
+  async setAsync(key, value, options = {}, tagVersions) {
+    const tags = normalizeCacheOptionsTags(options);
+    const capturedVersions = tagVersions ?? await this.getAdapterTagVersions(Array.from(tags.values()));
+    const entry = {
+      key,
+      value,
+      tags: Array.from(tags),
+      tagVersions: capturedVersions,
+      createdAt: options.createdAt ?? Date.now(),
+      createdVersion: ++this.version,
+      revalidate: normalizeRevalidate(options.revalidate)
+    };
+    if (this.local) {
+      this.hydrateLocalEntry(entry);
+    }
+    if (this.adapter) {
+      await this.adapter.set(this.createAdapterKey(key), entry);
+    }
+    emitFarmEvent({
+      type: "cache.set",
+      key,
+      tags: [...entry.tags],
+      revalidate: entry.revalidate
+    });
+    return entry;
+  }
+  delete(key) {
+    const deleted = this.entries.delete(key);
+    emitFarmEvent({ type: "cache.delete", key, deleted });
+    return deleted;
+  }
+  async deleteAsync(key) {
+    const deleted = this.entries.delete(key);
+    if (this.adapter) {
+      await this.adapter.delete(this.createAdapterKey(key));
+    }
+    emitFarmEvent({ type: "cache.delete", key, deleted: this.adapter ? true : deleted });
+    return this.adapter ? true : deleted;
+  }
+  clear() {
+    const count = this.entries.size;
+    this.entries.clear();
+    this.inflight.clear();
+    this.invalidatedTagVersions.clear();
+    this.version = 0;
+    emitFarmEvent({ type: "cache.clear", count });
+  }
+  async clearAsync() {
+    this.clear();
+    await this.adapter?.clear?.();
+  }
+  isStale(entry, now = Date.now()) {
+    if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
+      return true;
+    }
+    for (const tag of entry.tags) {
+      const invalidatedVersion = this.invalidatedTagVersions.get(normalizeCacheTag(tag));
+      if (typeof invalidatedVersion === "number" && typeof entry.createdVersion === "number" && invalidatedVersion > entry.createdVersion) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async isStaleAsync(entry, now = Date.now()) {
+    if (this.adapter) {
+      return this.isAdapterEntryStale(entry, now);
+    }
+    return this.isStale(entry, now);
+  }
+  revalidateTag(tag, options = {}) {
+    const normalized = normalizeCacheTag(tag);
+    const count = this.invalidateTag(normalized);
+    emitFarmEvent(
+      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
+    );
+    return count;
+  }
+  async revalidateTagAsync(tag, options = {}) {
+    const normalized = normalizeCacheTag(tag);
+    const count = this.invalidateTag(normalized);
+    await this.adapter?.invalidateTags?.([this.createAdapterTag(normalized)]);
+    emitFarmEvent(
+      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
+    );
+    return count;
+  }
+  revalidatePath(routePath) {
+    const normalizedPath = normalizeRevalidatePath(routePath);
+    const pathTag = createPathCacheTag(normalizedPath);
+    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
+    const count = this.invalidateTag(pathTag);
+    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
+    if (pprCount > 0) {
+      emitFarmEvent({
+        type: "ppr.shell.invalidated",
+        route: normalizedPath,
+        reason: "revalidatePath",
+        count: pprCount
+      });
+    }
+    return count;
+  }
+  async revalidatePathAsync(routePath) {
+    const normalizedPath = normalizeRevalidatePath(routePath);
+    const pathTag = createPathCacheTag(normalizedPath);
+    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
+    const count = this.invalidateTag(pathTag);
+    await this.adapter?.invalidateTags?.([this.createAdapterTag(pathTag)]);
+    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
+    if (pprCount > 0) {
+      emitFarmEvent({
+        type: "ppr.shell.invalidated",
+        route: normalizedPath,
+        reason: "revalidatePath",
+        count: pprCount
+      });
+    }
+    return count;
+  }
+  async getOrSet(key, producer, options = {}) {
+    const cached = await this.getEntryAsync(key);
+    if (cached) {
+      return cached.value;
+    }
+    const inflight = this.inflight.get(key);
+    if (inflight) {
+      emitFarmEvent({ type: "cache.dedupe", key });
+      return inflight;
+    }
+    const tags = Array.from(normalizeCacheOptionsTags(options));
+    const promise = this.fillCacheEntry(key, producer, options, tags).catch((error) => {
+      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
+      throw error;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  async fillCacheEntry(key, producer, options, tags) {
+    const leaseKey = `${this.namespace}:lease:${key}`;
+    let leaseToken;
+    if (this.adapter?.acquireLease && this.adapter.releaseLease && this.lease.enabled) {
+      leaseToken = await this.adapter.acquireLease(leaseKey, this.lease.ttlMs);
+      if (!leaseToken) {
+        const shared = await this.waitForAdapterEntry(key);
+        if (shared) {
+          emitFarmEvent({ type: "cache.dedupe", key });
+          return shared.value;
+        }
+        leaseToken = await this.adapter.acquireLease(leaseKey, this.lease.ttlMs);
+      }
+    }
+    try {
+      const initialTagVersions = await this.getAdapterTagVersions(tags);
+      const value = await producer();
+      await this.setAsync(key, value, options, initialTagVersions);
+      return value;
+    } finally {
+      if (leaseToken && this.adapter?.releaseLease) {
+        await this.adapter.releaseLease(leaseKey, leaseToken);
+      }
+    }
+  }
+  async waitForAdapterEntry(key) {
+    const deadline = Date.now() + this.lease.waitTimeoutMs;
+    while (Date.now() < deadline) {
+      await delay(this.lease.pollIntervalMs);
+      const entry = await this.getEntryAsync(key);
+      if (entry) return entry;
+    }
+    return void 0;
+  }
+  countEntriesForTag(tag) {
+    let count = 0;
+    for (const entry of this.entries.values()) {
+      if (entry.tags.has(tag)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  countEntriesForTags(tags) {
+    let count = 0;
+    for (const entry of this.entries.values()) {
+      if (tags.every((tag) => entry.tags.has(tag))) {
+        count++;
+      }
+    }
+    return count;
+  }
+  invalidateTag(normalizedTag) {
+    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
+    return this.countEntriesForTag(normalizedTag);
+  }
+  toPublicEntry(entry) {
+    return {
+      key: entry.key,
+      value: entry.value,
+      tags: Array.from(entry.tags),
+      tagVersions: entry.tagVersions,
+      createdAt: entry.createdAt,
+      createdVersion: entry.createdVersion,
+      revalidate: entry.revalidate
+    };
+  }
+  hydrateLocalEntry(entry) {
+    this.entries.set(entry.key, {
+      key: entry.key,
+      value: entry.value,
+      tags: new Set(entry.tags.map(normalizeCacheTag)),
+      tagVersions: entry.tagVersions,
+      createdAt: entry.createdAt,
+      createdVersion: entry.createdVersion ?? ++this.version,
+      revalidate: normalizeRevalidate(entry.revalidate)
+    });
+  }
+  createAdapterKey(key) {
+    return `${this.namespace}:entry:${key}`;
+  }
+  createAdapterTag(tag) {
+    return `${this.namespace}:tag:${tag}`;
+  }
+  async getAdapterTagVersions(tags) {
+    if (!this.adapter?.getTagVersions || tags.length === 0) return {};
+    const normalized = tags.map(normalizeCacheTag);
+    const physicalTags = normalized.map((tag) => this.createAdapterTag(tag));
+    const versions = await this.adapter.getTagVersions(physicalTags);
+    return Object.fromEntries(
+      normalized.map((tag, index) => [
+        tag,
+        normalizeAdapterVersion(versions[physicalTags[index]])
+      ])
+    );
+  }
+  async isAdapterEntryStale(entry, now = Date.now()) {
+    if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
+      return true;
+    }
+    const currentVersions = await this.getAdapterTagVersions(entry.tags);
+    for (const tag of entry.tags) {
+      if (normalizeAdapterVersion(currentVersions[tag]) > normalizeAdapterVersion(entry.tagVersions?.[tag])) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+__name(_FarmDataCache, "FarmDataCache");
+var FarmDataCache = _FarmDataCache;
+var FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
+var farmDataCacheGlobal = globalThis;
+var sharedFarmDataCache = farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] ?? (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] = new FarmDataCache());
+var functionIds = /* @__PURE__ */ new WeakMap();
+var nextFunctionId = 0;
+function getFarmDataCache() {
+  return sharedFarmDataCache;
+}
+__name(getFarmDataCache, "getFarmDataCache");
+function updateTag(tag) {
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidateTagAsync(tag, { source: "updateTag" }).then(() => void 0);
+    notifyFarmCacheTask(task);
+    return task;
+  }
+  cache.revalidateTag(tag, { source: "updateTag" });
+}
+__name(updateTag, "updateTag");
+function revalidatePath(routePath) {
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidatePathAsync(routePath).then(() => void 0);
+    notifyFarmCacheTask(task);
+    return task;
+  }
+  cache.revalidatePath(routePath);
+}
+__name(revalidatePath, "revalidatePath");
+function invalidate(key) {
+  const clientKey = createRouteDataCacheKey(key);
+  const task = updateTag(createRouteDataCacheTag(key));
+  notifyFarmCacheInvalidation(clientKey);
+  return task;
+}
+__name(invalidate, "invalidate");
+async function applyFarmCacheInvalidationTargets(targets) {
+  if (!Array.isArray(targets)) {
+    throw new TypeError("Cache invalidations must resolve to an array of targets.");
+  }
+  const clientKeys = [];
+  for (const target of targets) {
+    assertFarmCacheInvalidationTarget(target);
+    if ("key" in target) {
+      await invalidate(target.key);
+      clientKeys.push(createRouteDataCacheKey(target.key));
+    } else if ("path" in target) {
+      await revalidatePath(target.path);
+    } else {
+      await updateTag(target.tag);
+    }
+  }
+  return Array.from(new Set(clientKeys));
+}
+__name(applyFarmCacheInvalidationTargets, "applyFarmCacheInvalidationTargets");
+function createPathCacheTag(routePath) {
+  return `path:${normalizeRevalidatePath(routePath)}`;
+}
+__name(createPathCacheTag, "createPathCacheTag");
+function createRouteDataCacheTag(key) {
+  return `route-data:${createRouteDataCacheKey(key)}`;
+}
+__name(createRouteDataCacheTag, "createRouteDataCacheTag");
+function createRouteDataCacheKey(key) {
+  return createFarmCacheKey(Array.isArray(key) ? key : [key]);
+}
+__name(createRouteDataCacheKey, "createRouteDataCacheKey");
+function normalizeRevalidatePath(routePath) {
+  if (typeof routePath !== "string") {
+    throw new TypeError("revalidatePath expects a path string.");
+  }
+  let normalized = routePath.trim();
+  if (!normalized) {
+    throw new Error("revalidatePath expects a non-empty path.");
+  }
+  try {
+    if (/^https?:\/\//.test(normalized)) {
+      normalized = new URL(normalized).pathname;
+    }
+  } catch {
+  }
+  normalized = normalized.split("?")[0] ?? normalized;
+  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  normalized = normalized.replace(/\/{2,}/g, "/");
+  if (normalized.length > 1) {
+    normalized = normalized.replace(/\/+$/, "");
+  }
+  return normalized || "/";
+}
+__name(normalizeRevalidatePath, "normalizeRevalidatePath");
+function createFarmCacheKey(parts) {
+  return stableSerialize(parts);
+}
+__name(createFarmCacheKey, "createFarmCacheKey");
+function normalizeRevalidate(revalidate) {
+  if (revalidate === false || revalidate === void 0) {
+    return revalidate;
+  }
+  if (!Number.isFinite(revalidate) || revalidate <= 0) {
+    return void 0;
+  }
+  return revalidate;
+}
+__name(normalizeRevalidate, "normalizeRevalidate");
+function normalizeCacheTag(tag) {
+  if (typeof tag !== "string") {
+    throw new TypeError("Cache tags must be strings.");
+  }
+  const normalized = tag.trim();
+  if (!normalized) {
+    throw new Error("Cache tags cannot be empty.");
+  }
+  return normalized;
+}
+__name(normalizeCacheTag, "normalizeCacheTag");
+function normalizeCacheNamespace(namespace) {
+  if (typeof namespace !== "string") {
+    throw new TypeError("Cache namespace must be a string.");
+  }
+  const normalized = namespace.trim().replace(/:+$/g, "");
+  if (!normalized) {
+    throw new Error("Cache namespace cannot be empty.");
+  }
+  return normalized;
+}
+__name(normalizeCacheNamespace, "normalizeCacheNamespace");
+function normalizeAdapterVersion(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+__name(normalizeAdapterVersion, "normalizeAdapterVersion");
+function normalizePositiveDuration(value, fallback, name) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new TypeError(`${name} must be a positive number of milliseconds.`);
+  }
+  return Math.floor(value);
+}
+__name(normalizePositiveDuration, "normalizePositiveDuration");
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(delay, "delay");
+function normalizeCacheOptionsTags(options) {
+  const tags = /* @__PURE__ */ new Set();
+  for (const tag of options.tags ?? []) {
+    tags.add(normalizeCacheTag(tag));
+  }
+  for (const routePath of options.paths ?? []) {
+    tags.add(createPathCacheTag(routePath));
+  }
+  return tags;
+}
+__name(normalizeCacheOptionsTags, "normalizeCacheOptionsTags");
+function assertFarmCacheEntry(entry, expectedKey) {
+  if (!entry || typeof entry !== "object" || entry.key !== expectedKey || !Array.isArray(entry.tags) || typeof entry.createdAt !== "number") {
+    throw new TypeError(
+      `Cache adapter returned an invalid entry for ${JSON.stringify(expectedKey)}.`
+    );
+  }
+}
+__name(assertFarmCacheEntry, "assertFarmCacheEntry");
+function assertFarmCacheInvalidationTarget(target) {
+  if (!target || typeof target !== "object") {
+    throw new TypeError("Cache invalidation targets must be { key }, { path }, or { tag }.");
+  }
+  if ("key" in target) {
+    const key = target.key;
+    if (typeof key === "string" || Array.isArray(key)) return;
+  } else if ("path" in target && typeof target.path === "string") {
+    return;
+  } else if ("tag" in target && typeof target.tag === "string") {
+    return;
+  }
+  throw new TypeError("Cache invalidation targets must contain a string/array key, path, or tag.");
+}
+__name(assertFarmCacheInvalidationTarget, "assertFarmCacheInvalidationTarget");
+function getFunctionCacheIdentity(fn) {
+  if (fn.name) {
+    return `name:${fn.name}`;
+  }
+  let id = functionIds.get(fn);
+  if (!id) {
+    id = ++nextFunctionId;
+    functionIds.set(fn, id);
+  }
+  return `anonymous:${id}`;
+}
+__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
+function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const valueType = typeof value;
+  if (valueType === "string") return JSON.stringify(value);
+  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
+    return `${valueType}:${String(value)}`;
+  }
+  if (valueType === "symbol") {
+    return `symbol:${String(value)}`;
+  }
+  if (valueType === "function") {
+    return `function:${getFunctionCacheIdentity(value)}`;
+  }
+  if (value instanceof Date) {
+    return `date:${value.toISOString()}`;
+  }
+  if (value instanceof URL) {
+    return `url:${value.toString()}`;
+  }
+  if (value instanceof RegExp) {
+    return `regexp:${value.toString()}`;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableSerialize(item, seen)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
+    seen.delete(value);
+    return `{${serialized}}`;
+  }
+  return String(value);
+}
+__name(stableSerialize, "stableSerialize");
+
+// src/api/transport.ts
+function multipart(schema) {
+  if (!Object.isExtensible(schema) && !isMultipartSchema(schema)) {
+    throw new TypeError("multipart() requires an extensible schema object");
+  }
+  if (!isMultipartSchema(schema)) {
+    Object.defineProperty(schema, "__farmMultipartSchema", {
+      value: true,
+      configurable: false,
+      enumerable: false,
+      writable: false
+    });
+  }
+  return schema;
+}
+__name(multipart, "multipart");
+function isMultipartSchema(value) {
+  return typeof value === "object" && value !== null && value.__farmMultipartSchema === true && typeof value.parse === "function";
+}
+__name(isMultipartSchema, "isMultipartSchema");
+function toFormData(values) {
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(values)) {
+    if (isUnsafeFormKey(key)) continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) appendFormValue(formData, key, entry);
+      continue;
+    }
+    appendFormValue(formData, key, value);
+  }
+  return formData;
+}
+__name(toFormData, "toFormData");
+function jsonStream(source, init = {}) {
+  const iterator = toAsyncIterator(source);
+  const encoder = new TextEncoder();
+  let finished = false;
+  const body = new ReadableStream(
+    {
+      async pull(controller) {
+        if (finished) return;
+        try {
+          const next = await iterator.next();
+          if (next.done) {
+            finished = true;
+            controller.close();
+            return;
+          }
+          controller.enqueue(encoder.encode(`${JSON.stringify(next.value)}
+`));
+        } catch (error) {
+          finished = true;
+          controller.error(error);
+        }
+      },
+      async cancel(reason) {
+        finished = true;
+        await iterator.return?.(reason);
+      }
+    },
+    {
+      // Do not read the next application event until the response consumer
+      // requests another chunk.
+      highWaterMark: 0
+    }
+  );
+  const headers = new Headers(init.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/x-ndjson; charset=utf-8");
+  }
+  headers.set("cache-control", headers.get("cache-control") ?? "no-store");
+  return new Response(body, {
+    ...init,
+    headers
+  });
+}
+__name(jsonStream, "jsonStream");
+function isJSONStreamResponse(response) {
+  const contentType = response.headers?.get?.("content-type")?.toLowerCase() ?? "";
+  return contentType.includes("application/x-ndjson") || contentType.includes("application/ndjson");
+}
+__name(isJSONStreamResponse, "isJSONStreamResponse");
+function readJSONStream(response) {
+  if (!response.body) {
+    throw new TypeError("Cannot read a JSON stream response without a body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let completed = false;
+  let claimed = false;
+  const iterator = {
+    async next() {
+      while (true) {
+        const lineEnd = buffer.indexOf("\n");
+        if (lineEnd >= 0) {
+          const line = buffer.slice(0, lineEnd).trim();
+          buffer = buffer.slice(lineEnd + 1);
+          if (!line) continue;
+          return { done: false, value: JSON.parse(line) };
+        }
+        if (completed) {
+          const line = buffer.trim();
+          buffer = "";
+          if (!line) return { done: true, value: void 0 };
+          return { done: false, value: JSON.parse(line) };
+        }
+        const chunk = await reader.read();
+        completed = chunk.done;
+        buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+      }
+    },
+    async return() {
+      completed = true;
+      buffer = "";
+      await reader.cancel();
+      return { done: true, value: void 0 };
+    }
+  };
+  return {
+    response,
+    async cancel(reason) {
+      completed = true;
+      buffer = "";
+      await reader.cancel(reason);
+    },
+    [Symbol.asyncIterator]() {
+      if (claimed) {
+        throw new TypeError("Farm API streams can only be consumed once");
+      }
+      claimed = true;
+      return iterator;
+    }
+  };
+}
+__name(readJSONStream, "readJSONStream");
+function isFarmAPIStream(value) {
+  return typeof value === "object" && value !== null && "response" in value && typeof value.cancel === "function" && typeof value[Symbol.asyncIterator] === "function";
+}
+__name(isFarmAPIStream, "isFarmAPIStream");
+function appendFormValue(formData, key, value) {
+  if (value === void 0) return;
+  if (value === null) {
+    formData.append(key, "");
+    return;
+  }
+  if (value instanceof Blob) {
+    formData.append(key, value);
+    return;
+  }
+  if (value instanceof Date) {
+    formData.append(key, value.toISOString());
+    return;
+  }
+  formData.append(key, String(value));
+}
+__name(appendFormValue, "appendFormValue");
+function isUnsafeFormKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+__name(isUnsafeFormKey, "isUnsafeFormKey");
+function toAsyncIterator(source) {
+  if (Symbol.asyncIterator in Object(source)) {
+    return source[Symbol.asyncIterator]();
+  }
+  const iterator = source[Symbol.iterator]();
+  return {
+    next: /* @__PURE__ */ __name(async () => iterator.next(), "next"),
+    return: iterator.return ? async (value) => iterator.return(value) : void 0
+  };
+}
+__name(toAsyncIterator, "toAsyncIterator");
+
+// src/api/endpoint.ts
+var _EndpointFailure = class _EndpointFailure extends Error {
+  constructor(code, data, options) {
+    super(options.message);
+    this.name = "EndpointFailure";
+    this.code = code;
+    this.data = data;
+    this.status = options.status;
+  }
+};
+__name(_EndpointFailure, "EndpointFailure");
+var EndpointFailure = _EndpointFailure;
+function isEndpointFailure(value) {
+  return value instanceof EndpointFailure;
+}
+__name(isEndpointFailure, "isEndpointFailure");
+function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
+  let path4;
+  let options;
+  let handler;
+  if (typeof pathOrOptions === "string") {
+    path4 = pathOrOptions;
+    options = optionsOrHandler;
+    handler = maybeHandler;
+  } else {
+    path4 = "";
+    options = pathOrOptions;
+    handler = optionsOrHandler;
+  }
+  if (typeof handler !== "function") {
+    throw new TypeError("createEndpoint requires a handler function");
+  }
+  const middleware = normalizeEndpointMiddleware(options.middleware);
+  const errors = normalizeEndpointErrors(options.errors);
+  const fail = createEndpointFail(errors);
+  const wrappedHandler = /* @__PURE__ */ __name((async (ctx) => {
+    const execution = await runEndpointMiddleware(
+      middleware,
+      ctx,
+      handler,
+      fail,
+      options.invalidates
+    );
+    return execution.result;
+  }), "wrappedHandler");
+  const {
+    middleware: _middleware,
+    errors: _errors,
+    invalidates: _invalidates,
+    ...betterCallOptions
+  } = options;
+  const endpoint = (0, import_better_call.createEndpoint)(
+    path4 || "/__farm_auto_path__",
+    betterCallOptions,
+    wrappedHandler
+  );
+  endpoint.__path = path4 || void 0;
+  endpoint.__method = options.method || "GET";
+  endpoint.__autoPath = !path4;
+  endpoint.__handler = wrappedHandler;
+  endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, fail, options.invalidates);
+  endpoint.__middleware = middleware;
+  endpoint.__sourceHandler = handler;
+  endpoint.__invalidates = options.invalidates;
+  endpoint.__errors = errors;
+  endpoint.__types = {
+    body: options.body,
+    inputBody: isMultipartSchema(options.body) ? "form-data" : options.body,
+    query: options.query,
+    headers: options.headers,
+    response: null,
+    errors
+  };
+  return endpoint;
+}
+__name(createEndpoint, "createEndpoint");
+var EMPTY_ENDPOINT_MIDDLEWARE = Object.freeze([]);
+var EMPTY_ENDPOINT_CONTEXT = Object.freeze(/* @__PURE__ */ Object.create(null));
+var UNSAFE_ENDPOINT_CONTEXT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function normalizeEndpointErrors(definitions) {
+  if (definitions === void 0) return Object.freeze({});
+  if (!isPlainEndpointContext(definitions)) {
+    throw new TypeError("createEndpoint errors must be an object");
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [code, definition] of Object.entries(definitions)) {
+    if (!code.trim()) {
+      throw new TypeError("Endpoint error codes cannot be empty");
+    }
+    if (!definition || typeof definition !== "object") {
+      throw new TypeError(`Endpoint error "${code}" must be an object`);
+    }
+    if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
+      throw new TypeError(`Endpoint error "${code}" status must be an integer between 400 and 599`);
+    }
+    if (!definition.schema || typeof definition.schema.parse !== "function") {
+      throw new TypeError(`Endpoint error "${code}" requires a schema with parse()`);
+    }
+    if (definition.message !== void 0 && typeof definition.message !== "string") {
+      throw new TypeError(`Endpoint error "${code}" message must be a string`);
+    }
+    normalized[code] = Object.freeze({ ...definition });
+  }
+  return Object.freeze(normalized);
+}
+__name(normalizeEndpointErrors, "normalizeEndpointErrors");
+function createEndpointFail(definitions) {
+  return ((code, data) => {
+    const definition = definitions[code];
+    if (!definition) {
+      throw new TypeError(`Endpoint error "${code}" is not declared`);
+    }
+    const parsed = definition.schema.parse(data);
+    throw new EndpointFailure(code, parsed, {
+      status: definition.status,
+      message: definition.message ?? "Request failed"
+    });
+  });
+}
+__name(createEndpointFail, "createEndpointFail");
+function normalizeEndpointMiddleware(middleware) {
+  if (middleware === void 0) return EMPTY_ENDPOINT_MIDDLEWARE;
+  if (!Array.isArray(middleware)) {
+    throw new TypeError("createEndpoint middleware must be an array of functions");
+  }
+  const normalized = [...middleware];
+  for (const entry of normalized) {
+    if (typeof entry !== "function") {
+      throw new TypeError("createEndpoint middleware entries must be functions");
+    }
+  }
+  return Object.freeze(normalized);
+}
+__name(normalizeEndpointMiddleware, "normalizeEndpointMiddleware");
+async function runEndpointMiddleware(middleware, handlerContext, handler, fail, invalidations) {
+  let context = createInitialEndpointContext(handlerContext.context);
+  for (let index = 0; index < middleware.length; index++) {
+    const result2 = await middleware[index]({ ...handlerContext, context });
+    if (isEndpointResponse(result2)) {
+      return {
+        result: result2,
+        context,
+        handlerExecuted: false,
+        invalidations: []
+      };
+    }
+    if (result2 === false) {
+      return {
+        result: forbiddenEndpointResponse(),
+        context,
+        handlerExecuted: false,
+        invalidations: []
+      };
+    }
+    if (result2 === true) continue;
+    if (!isPlainEndpointContext(result2)) {
+      throw new TypeError(
+        `Endpoint middleware ${index + 1} must return an object, true, false, or a Response`
+      );
+    }
+    context = mergeEndpointContext(context, result2, index);
+  }
+  const result = await handler({ ...handlerContext, context, fail });
+  return {
+    result,
+    context,
+    handlerExecuted: true,
+    invalidations: await applyEndpointInvalidations(
+      invalidations,
+      {
+        ...handlerContext,
+        context,
+        result
+      },
+      result
+    )
+  };
+}
+__name(runEndpointMiddleware, "runEndpointMiddleware");
+async function applyEndpointInvalidations(declaration, context, result) {
+  if (!declaration || isEndpointResponse(result) && result.status >= 400) {
+    return [];
+  }
+  const targets = typeof declaration === "function" ? await declaration(context) : declaration;
+  if (!Array.isArray(targets)) {
+    throw new TypeError(
+      "Endpoint invalidates must resolve to an array of { key }, { path }, or { tag } targets"
+    );
+  }
+  return applyFarmCacheInvalidationTargets(targets);
+}
+__name(applyEndpointInvalidations, "applyEndpointInvalidations");
+function createInitialEndpointContext(value) {
+  if (value === void 0 || value === null) return EMPTY_ENDPOINT_CONTEXT;
+  if (!isPlainEndpointContext(value)) {
+    throw new TypeError("Endpoint context must be a plain object");
+  }
+  return mergeEndpointContext(EMPTY_ENDPOINT_CONTEXT, value);
+}
+__name(createInitialEndpointContext, "createInitialEndpointContext");
+function mergeEndpointContext(current, added, middlewareIndex) {
+  const next = Object.assign(/* @__PURE__ */ Object.create(null), current);
+  for (const key of Reflect.ownKeys(added)) {
+    if (!Object.prototype.propertyIsEnumerable.call(added, key)) continue;
+    if (typeof key === "string" && UNSAFE_ENDPOINT_CONTEXT_KEYS.has(key)) {
+      throw new TypeError(`Endpoint middleware cannot provide the unsafe context key "${key}"`);
+    }
+    if (Object.prototype.hasOwnProperty.call(current, key)) {
+      const source = middlewareIndex === void 0 ? "Endpoint context" : `Endpoint middleware ${middlewareIndex + 1}`;
+      throw new TypeError(`${source} cannot replace the existing context key "${String(key)}"`);
+    }
+    next[key] = added[key];
+  }
+  return Object.freeze(next);
+}
+__name(mergeEndpointContext, "mergeEndpointContext");
+function isPlainEndpointContext(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainEndpointContext, "isPlainEndpointContext");
+function isEndpointResponse(value) {
+  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
+}
+__name(isEndpointResponse, "isEndpointResponse");
+function forbiddenEndpointResponse() {
+  return new Response(JSON.stringify({ error: "Forbidden" }), {
+    status: 403,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+__name(forbiddenEndpointResponse, "forbiddenEndpointResponse");
+function GET(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "GET" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "GET" }, args[1]);
+}
+__name(GET, "GET");
+function HEAD(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "HEAD" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "HEAD" }, args[1]);
+}
+__name(HEAD, "HEAD");
+function POST(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "POST" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "POST" }, args[1]);
+}
+__name(POST, "POST");
+function PUT(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "PUT" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "PUT" }, args[1]);
+}
+__name(PUT, "PUT");
+function DELETE(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "DELETE" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "DELETE" }, args[1]);
+}
+__name(DELETE, "DELETE");
+function PATCH(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "PATCH" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "PATCH" }, args[1]);
+}
+__name(PATCH, "PATCH");
+function OPTIONS(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "OPTIONS" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "OPTIONS" }, args[1]);
+}
+__name(OPTIONS, "OPTIONS");
+
+// src/api/route-manager.ts
+var fs = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+
+// src/utils.ts
+var import_path = __toESM(require("path"));
+function toViteModuleId(filePath, root) {
+  if (!import_path.default.isAbsolute(filePath)) return filePath;
+  const relativePath = import_path.default.relative(root, filePath);
+  if (relativePath && !relativePath.startsWith("..") && !import_path.default.isAbsolute(relativePath)) {
+    return `/${relativePath.split(import_path.default.sep).join("/")}`;
+  }
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  return normalizedPath.startsWith("/") ? `/@fs${normalizedPath}` : `/@fs/${normalizedPath}`;
+}
+__name(toViteModuleId, "toViteModuleId");
+var logger = {
+  info: /* @__PURE__ */ __name((message) => console.log(`[info] ${message}`), "info"),
+  success: /* @__PURE__ */ __name((message) => console.log(`[success] ${message}`), "success"),
+  warn: /* @__PURE__ */ __name((message) => console.warn(`\u26A0\uFE0F  ${message}`), "warn"),
+  error: /* @__PURE__ */ __name((message) => console.error(`\u274C ${message}`), "error"),
+  ready: /* @__PURE__ */ __name((message) => console.log(`${message}`), "ready"),
+  event: /* @__PURE__ */ __name((message) => console.log(`  ${message}`), "event")
+};
+
+// src/routes.ts
+var import_react = require("react");
+
+// src/route-runtime.ts
+function normalizeFarmRouteRuntimeConfig(value, source = "Route configuration") {
+  if (!value) return {};
+  const normalized = {};
+  if (value.runtime !== void 0) {
+    if (value.runtime !== "auto" && value.runtime !== "node" && value.runtime !== "edge") {
+      throw new TypeError(`${source} runtime must be "auto", "node", or "edge"`);
+    }
+    normalized.runtime = value.runtime;
+  }
+  if (value.regions !== void 0) {
+    if (value.regions === "auto") {
+      normalized.regions = "auto";
+    } else {
+      if (!Array.isArray(value.regions) || value.regions.length === 0) {
+        throw new TypeError(`${source} regions must be "auto" or a non-empty string array`);
+      }
+      const regions = Array.from(
+        new Set(
+          value.regions.map((region) => {
+            if (typeof region !== "string" || !region.trim() || /[\u0000-\u001f\u007f]/.test(region)) {
+              throw new TypeError(`${source} regions must contain non-empty region identifiers`);
+            }
+            return region.trim();
+          })
+        )
+      );
+      normalized.regions = regions;
+    }
+  }
+  if (value.maxDuration !== void 0) {
+    if (value.maxDuration === "auto") {
+      normalized.maxDuration = "auto";
+    } else if (typeof value.maxDuration !== "number" || !Number.isInteger(value.maxDuration) || value.maxDuration <= 0) {
+      throw new TypeError(`${source} maxDuration must be "auto" or a positive integer in seconds`);
+    } else {
+      normalized.maxDuration = value.maxDuration;
+    }
+  }
+  return normalized;
+}
+__name(normalizeFarmRouteRuntimeConfig, "normalizeFarmRouteRuntimeConfig");
+function getFarmRouteRuntimeConfig(value) {
+  if (!value || typeof value !== "object") return {};
+  const route = value;
+  return {
+    ...route.runtime !== void 0 ? { runtime: route.runtime } : {},
+    ...route.regions !== void 0 ? { regions: route.regions } : {},
+    ...route.maxDuration !== void 0 ? { maxDuration: route.maxDuration } : {}
+  };
+}
+__name(getFarmRouteRuntimeConfig, "getFarmRouteRuntimeConfig");
+
+// src/routes.ts
+var FARM_ROUTES_BRAND = /* @__PURE__ */ Symbol.for("farm.routes");
+var PROGRAMMATIC_ROUTE_FILE_NAMES = [
+  "farm.route.ts",
+  "farm.route.tsx",
+  "farm.route.js",
+  "farm.route.jsx",
+  "farm.routes.ts",
+  "farm.routes.tsx",
+  "farm.routes.js",
+  "farm.routes.jsx",
+  "routes.ts",
+  "routes.tsx",
+  "routes.js",
+  "routes.jsx"
+];
+function defineRoutes(input) {
+  const routes = typeof input === "function" ? input(routesBuilder) : input;
+  const manifest = {
+    __farmRoutes: true,
+    routes: routes.map(normalizeProgrammaticRoute)
+  };
+  Object.defineProperty(manifest, FARM_ROUTES_BRAND, {
+    value: true,
+    enumerable: false
+  });
+  return manifest;
+}
+__name(defineRoutes, "defineRoutes");
+var routesBuilder = {
+  page(path4, options) {
+    return normalizeProgrammaticRoute({
+      kind: "page",
+      path: path4,
+      ...options
+    });
+  },
+  layout(path4, options) {
+    return normalizeProgrammaticRoute({
+      kind: "layout",
+      path: path4,
+      ...options
+    });
+  },
+  api(path4, options) {
+    const { render, runtime, regions, maxDuration, ...methods } = options;
+    return normalizeProgrammaticRoute({
+      kind: "api",
+      path: path4,
+      render,
+      runtime,
+      regions,
+      maxDuration,
+      methods: normalizeApiMethods(methods)
+    });
+  },
+  redirect(source, destination, options = {}) {
+    return normalizeProgrammaticRoute({
+      kind: "redirect",
+      source,
+      destination,
+      ...options
+    });
+  }
+};
+var page = routesBuilder.page;
+var layout = routesBuilder.layout;
+var api = routesBuilder.api;
+var redirect = routesBuilder.redirect;
+function isProgrammaticRoutesFileName(fileName) {
+  const normalized = fileName.replace(/\\/g, "/");
+  const baseName = normalized.split("/").pop() || normalized;
+  return PROGRAMMATIC_ROUTE_FILE_NAMES.includes(baseName);
+}
+__name(isProgrammaticRoutesFileName, "isProgrammaticRoutesFileName");
+function getProgrammaticRouteManifest(mod) {
+  if (!mod) return null;
+  const candidates = [mod.default, mod.routes, mod.Route];
+  for (const candidate of candidates) {
+    if (isProgrammaticRouteManifest(candidate)) {
+      return candidate;
+    }
+    if (isProgrammaticRouteDefinition(candidate)) {
+      return defineRoutes([candidate]);
+    }
+    if (Array.isArray(candidate)) {
+      return defineRoutes(candidate);
+    }
+  }
+  const routeDefinitions = Object.values(mod).filter(isProgrammaticRouteDefinition);
+  if (routeDefinitions.length > 0) {
+    return defineRoutes(routeDefinitions);
+  }
+  return null;
+}
+__name(getProgrammaticRouteManifest, "getProgrammaticRouteManifest");
+function isProgrammaticRouteManifest(value) {
+  return !!value && typeof value === "object" && value.__farmRoutes === true && Array.isArray(value.routes);
+}
+__name(isProgrammaticRouteManifest, "isProgrammaticRouteManifest");
+function isProgrammaticRouteDefinition(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const kind = value.kind;
+  return kind === "page" || kind === "layout" || kind === "api" || kind === "redirect";
+}
+__name(isProgrammaticRouteDefinition, "isProgrammaticRouteDefinition");
+function createProgrammaticRouteModuleId(filePath, kind, routePath) {
+  return `${filePath}?farm-route=${kind}:${encodeURIComponent(normalizeRoutePath(routePath))}`;
+}
+__name(createProgrammaticRouteModuleId, "createProgrammaticRouteModuleId");
+function normalizeProgrammaticRoute(route) {
+  if (route.kind === "redirect") {
+    return {
+      ...route,
+      source: normalizeRoutePath(route.source)
+    };
+  }
+  if (route.kind === "api") {
+    return {
+      ...route,
+      ...normalizeFarmRouteRuntimeConfig(route, `API route "${route.path}"`),
+      path: normalizeRoutePath(route.path),
+      methods: normalizeApiMethods(route.methods)
+    };
+  }
+  return {
+    ...route,
+    ...normalizeFarmRouteRuntimeConfig(
+      route,
+      `${route.kind === "layout" ? "Layout" : "Route"} "${route.path}"`
+    ),
+    path: normalizeRoutePath(route.path)
+  };
+}
+__name(normalizeProgrammaticRoute, "normalizeProgrammaticRoute");
+function normalizeRoutePath(routePath) {
+  const withSlash = routePath.startsWith("/") ? routePath : `/${routePath}`;
+  const withoutTrailing = withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+  return withoutTrailing || "/";
+}
+__name(normalizeRoutePath, "normalizeRoutePath");
+function normalizeApiMethods(methods) {
+  const normalized = {};
+  for (const [method, handler] of Object.entries(methods)) {
+    const normalizedMethod = method.toUpperCase();
+    if (handler && isProgrammaticRouteMethod(normalizedMethod)) {
+      normalized[normalizedMethod] = handler;
+    }
+  }
+  return normalized;
+}
+__name(normalizeApiMethods, "normalizeApiMethods");
+function isProgrammaticRouteMethod(method) {
+  return method === "GET" || method === "HEAD" || method === "POST" || method === "PUT" || method === "DELETE" || method === "PATCH" || method === "OPTIONS";
+}
+__name(isProgrammaticRouteMethod, "isProgrammaticRouteMethod");
+
+// src/routes.server.ts
+var import_fs = require("fs");
+var import_path2 = require("path");
+function findProgrammaticRouteFilesInDir(srcRoot) {
+  const files = [];
+  for (const fileName of PROGRAMMATIC_ROUTE_FILE_NAMES) {
+    const filePath = (0, import_path2.join)(srcRoot, fileName);
+    if ((0, import_fs.existsSync)(filePath)) {
+      files.push(filePath);
+    }
+  }
+  return files;
+}
+__name(findProgrammaticRouteFilesInDir, "findProgrammaticRouteFilesInDir");
+
+// src/i18n/server.ts
+var import_node_async_hooks = require("async_hooks");
+
+// src/i18n/runtime.ts
+var import_intl_messageformat = __toESM(require("intl-messageformat"));
+
+// src/i18n/catalog.ts
+var import_promises = require("fs/promises");
+var import_icu_messageformat_parser = require("@formatjs/icu-messageformat-parser");
+
+// src/i18n/config.ts
+var import_node_path = __toESM(require("path"));
+var DEFAULT_FARM_I18N_COOKIE_MAX_AGE = 60 * 60 * 24 * 365;
+
+// src/i18n/server.ts
+var FARM_I18N_REQUEST_STORE = /* @__PURE__ */ Symbol.for("farm.i18n.requestStore");
+function getRequestStore() {
+  const state = globalThis;
+  return state[FARM_I18N_REQUEST_STORE] ?? (state[FARM_I18N_REQUEST_STORE] = new import_node_async_hooks.AsyncLocalStorage());
+}
+__name(getRequestStore, "getRequestStore");
+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;
+}
+__name(getState, "getState");
+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));
+}
+__name(_runWithFarmI18nRequest, "_runWithFarmI18nRequest");
+var t = createTranslatorFromState(() => getState());
+function getFarmI18nClientSnapshot() {
+  return getRequestStore().getStore()?.snapshot;
+}
+__name(getFarmI18nClientSnapshot, "getFarmI18nClientSnapshot");
+function createTranslatorFromState(resolveState) {
+  const translator = /* @__PURE__ */ __name(((key, values) => {
+    const state = resolveState();
+    return state.runtime.translate(state.resolution.locale, key, values);
+  }), "translator");
+  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;
+}
+__name(createTranslatorFromState, "createTranslatorFromState");
+_setFarmI18nSnapshotResolver(() => getFarmI18nClientSnapshot());
+
+// src/server/request.ts
+var import_node_async_hooks2 = require("async_hooks");
+
+// src/server/request-bridge.ts
+var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
+function getGlobalState() {
+  return globalThis;
+}
+__name(getGlobalState, "getGlobalState");
+function _setCurrentRequestResolver(resolver) {
+  getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY] = resolver;
+}
+__name(_setCurrentRequestResolver, "_setCurrentRequestResolver");
+
+// src/server/request.ts
+var REQUEST_STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-storage");
+function getRequestStore2() {
+  const runtime = globalThis;
+  const existing = runtime[REQUEST_STORAGE_KEY];
+  if (existing instanceof import_node_async_hooks2.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new import_node_async_hooks2.AsyncLocalStorage();
+  runtime[REQUEST_STORAGE_KEY] = storage;
+  return storage;
+}
+__name(getRequestStore2, "getRequestStore");
+var requestStore = getRequestStore2();
+_setCurrentRequestResolver(() => requestStore.getStore());
+async function _runWithCurrentRequest(request, fn) {
+  return requestStore.run(request, fn);
+}
+__name(_runWithCurrentRequest, "_runWithCurrentRequest");
+
+// src/api/runtime.ts
+function matchAPIRoute(routes, pathname) {
+  const exactRoute = routes.get(pathname);
+  if (exactRoute) {
+    return { route: exactRoute, params: {} };
+  }
+  const normalizedPathname = normalizePathname(pathname);
+  if (normalizedPathname !== pathname) {
+    const normalizedRoute = routes.get(normalizedPathname);
+    if (normalizedRoute) {
+      return { route: normalizedRoute, params: {} };
+    }
+  }
+  for (const route of routes.values()) {
+    const params = matchRoutePath(route.path, pathname);
+    if (params) {
+      return { route, params };
+    }
+  }
+  return null;
+}
+__name(matchAPIRoute, "matchAPIRoute");
+async function invokeAPIRouteEndpoint(endpoint, request, params = {}) {
+  return _runWithCurrentRequest(
+    request,
+    () => invokeAPIRouteEndpointInContext(endpoint, request, params)
+  );
+}
+__name(invokeAPIRouteEndpoint, "invokeAPIRouteEndpoint");
+async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
+  const farmHandler = endpoint.__handler || (isFarmContextHandler(endpoint) ? endpoint : null);
+  if (!farmHandler) {
+    const result = await endpoint(request, {
+      params: Promise.resolve(params)
+    });
+    return normalizeRouteResponse(result);
+  }
+  const url = new URL(request.url);
+  const query = {};
+  url.searchParams.forEach((value, key) => {
+    query[key] = value;
+  });
+  let body = void 0;
+  if (request.method.toUpperCase() !== "GET" && request.method.toUpperCase() !== "HEAD") {
+    body = await readRequestBody(request);
+  }
+  const headers = Object.fromEntries(request.headers.entries());
+  const types = endpoint.__types || {};
+  const queryValidation = validateInput(types.query, query, "Invalid query parameters");
+  if (queryValidation instanceof Response) {
+    return queryValidation;
+  }
+  const bodyValidation = validateInput(types.body, body, "Invalid request body");
+  if (bodyValidation instanceof Response) {
+    return bodyValidation;
+  }
+  const headersValidation = validateInput(types.headers, headers, "Invalid request headers");
+  if (headersValidation instanceof Response) {
+    return headersValidation;
+  }
+  const handlerContext = {
+    query: queryValidation,
+    body: bodyValidation,
+    headers: headersValidation,
+    request,
+    context: {},
+    params
+  };
+  let execution;
+  try {
+    execution = typeof endpoint.__farmInvoke === "function" ? await endpoint.__farmInvoke(handlerContext) : {
+      result: await farmHandler(handlerContext),
+      context: handlerContext.context,
+      handlerExecuted: true,
+      invalidations: []
+    };
+  } catch (error) {
+    if (isEndpointFailure(error)) {
+      return createEndpointFailureResponse(error);
+    }
+    throw error;
+  }
+  const response = normalizeRouteResponse(execution.result);
+  return attachEndpointInvalidations(response, execution.invalidations);
+}
+__name(invokeAPIRouteEndpointInContext, "invokeAPIRouteEndpointInContext");
+function normalizeRouteResponse(result) {
+  if (isWebResponse(result)) {
+    return result;
+  }
+  if (result === void 0) {
+    return new Response(null, { status: 204 });
+  }
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+__name(normalizeRouteResponse, "normalizeRouteResponse");
+function isWebResponse(value) {
+  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
+}
+__name(isWebResponse, "isWebResponse");
+function attachEndpointInvalidations(response, keys) {
+  const existing = decodeFarmCacheInvalidations(
+    response.headers.get(FARM_CACHE_INVALIDATION_HEADER)
+  );
+  const encoded = encodeFarmCacheInvalidations([...existing, ...keys]);
+  if (!encoded) return response;
+  const headers = new Headers(response.headers);
+  headers.set(FARM_CACHE_INVALIDATION_HEADER, encoded);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+__name(attachEndpointInvalidations, "attachEndpointInvalidations");
+function createEndpointFailureResponse(failure) {
+  return new Response(
+    JSON.stringify({
+      error: {
+        code: failure.code,
+        message: failure.message,
+        data: failure.data
+      }
+    }),
+    {
+      status: failure.status,
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "application/json"
+      }
+    }
+  );
+}
+__name(createEndpointFailureResponse, "createEndpointFailureResponse");
+function isFarmContextHandler(endpoint) {
+  if (typeof endpoint !== "function") {
+    return false;
+  }
+  const source = Function.prototype.toString.call(endpoint).trim();
+  const arrowMatch = source.match(/^(?:async\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*=>/);
+  const functionMatch = source.match(/^(?:async\s*)?function[^(]*\(([^)]*)\)/);
+  const firstParameter = (arrowMatch?.[1] || arrowMatch?.[2] || functionMatch?.[1] || "").split(",")[0].trim();
+  return firstParameter === "ctx" || firstParameter === "context" || firstParameter.startsWith("{");
+}
+__name(isFarmContextHandler, "isFarmContextHandler");
+async function readRequestBody(request) {
+  const contentType = request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  try {
+    if (contentType === "multipart/form-data") {
+      return formDataToObject(await request.clone().formData());
+    }
+    const text = await request.clone().text();
+    if (!text) return void 0;
+    if (contentType === "application/x-www-form-urlencoded") {
+      return searchParamsToObject(new URLSearchParams(text));
+    }
+    if (contentType === "application/json" || contentType?.endsWith("+json")) {
+      return JSON.parse(text);
+    }
+    return JSON.parse(text);
+  } catch {
+  }
+  return void 0;
+}
+__name(readRequestBody, "readRequestBody");
+function formDataToObject(formData) {
+  return entriesToObject(formData.entries());
+}
+__name(formDataToObject, "formDataToObject");
+function searchParamsToObject(searchParams) {
+  return entriesToObject(searchParams.entries());
+}
+__name(searchParamsToObject, "searchParamsToObject");
+function entriesToObject(entries) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of entries) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    const current = output[key];
+    if (current === void 0) {
+      output[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      output[key] = [current, value];
+    }
+  }
+  return output;
+}
+__name(entriesToObject, "entriesToObject");
+function validateInput(schema, value, error) {
+  if (!schema || typeof schema.parse !== "function") {
+    return value;
+  }
+  try {
+    return schema.parse(value);
+  } catch (validationError) {
+    return new Response(
+      JSON.stringify({
+        error,
+        details: validationError.errors || validationError.issues || validationError.message
+      }),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+}
+__name(validateInput, "validateInput");
+function matchRoutePath(routePath, pathname) {
+  const routeSegments = getPathSegments(routePath);
+  const pathnameSegments = getPathSegments(pathname);
+  const params = {};
+  let pathIndex = 0;
+  for (const routeSegment of routeSegments) {
+    const dynamicSegment = parseDynamicSegment(routeSegment);
+    if (dynamicSegment?.catchAll) {
+      const remainingSegments = pathnameSegments.slice(pathIndex).map(decodePathSegment);
+      if (remainingSegments.length === 0 && !dynamicSegment.optional) {
+        return null;
+      }
+      if (remainingSegments.length > 0) {
+        params[dynamicSegment.name] = remainingSegments;
+      }
+      pathIndex = pathnameSegments.length;
+      continue;
+    }
+    const pathnameSegment = pathnameSegments[pathIndex];
+    if (pathnameSegment === void 0) {
+      return null;
+    }
+    if (dynamicSegment) {
+      params[dynamicSegment.name] = decodePathSegment(pathnameSegment);
+      pathIndex++;
+      continue;
+    }
+    if (routeSegment !== pathnameSegment) {
+      return null;
+    }
+    pathIndex++;
+  }
+  return pathIndex === pathnameSegments.length ? params : null;
+}
+__name(matchRoutePath, "matchRoutePath");
+function getPathSegments(pathname) {
+  return normalizePathname(pathname).split("/").filter((segment) => segment.length > 0);
+}
+__name(getPathSegments, "getPathSegments");
+function normalizePathname(pathname) {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.replace(/\/+$/, "");
+  }
+  return pathname;
+}
+__name(normalizePathname, "normalizePathname");
+function parseDynamicSegment(segment) {
+  const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
+  if (optionalCatchAll?.[1]) {
+    return { name: optionalCatchAll[1], catchAll: true, optional: true };
+  }
+  const catchAll = segment.match(/^\[\.\.\.(.+)\]$/);
+  if (catchAll?.[1]) {
+    return { name: catchAll[1], catchAll: true, optional: false };
+  }
+  const dynamic = segment.match(/^\[(.+)\]$/);
+  if (dynamic?.[1]) {
+    return { name: dynamic[1], catchAll: false, optional: false };
+  }
+  return null;
+}
+__name(parseDynamicSegment, "parseDynamicSegment");
+function decodePathSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+__name(decodePathSegment, "decodePathSegment");
+
+// src/api/route-manager.ts
+var API_ROUTE_METHODS = [
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS"
+];
+var _APIRouteManager = class _APIRouteManager {
+  constructor(appDir, viteServer, options = {}) {
+    this.routes = /* @__PURE__ */ new Map();
+    this.appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
+    this.viteServer = viteServer;
+    this.throwOnLoadError = options.throwOnLoadError === true;
+    this.i18n = options.i18n;
+  }
+  /**
+   * Discover route.ts files in /app/api and explicit endpoints in root routes.ts
+   */
+  async discoverRoutes() {
+    this.routes.clear();
+    for (const appDir of this.appDirs) {
+      const apiDir = path3.join(appDir, "api");
+      let routeFiles = [];
+      if (fs.existsSync(apiDir)) {
+        routeFiles = this.findRouteFiles(apiDir);
+      }
+      for (const filePath of routeFiles) {
+        await this.loadRoute(filePath, appDir);
+      }
+      await this.loadRootRoutes(appDir);
+      await this.loadProgrammaticApiRoutes(appDir);
+    }
+    if (process.env.FARM_VERBOSE) {
+      logger.success(`Discovered ${this.routes.size} API routes`);
+      for (const [routePath, route] of this.routes) {
+        logger.info(`  ${route.methods.join(", ")} ${routePath}`);
+      }
+    }
+  }
+  /**
+   * Recursively find all route.ts files
+   */
+  findRouteFiles(dir) {
+    const files = [];
+    if (!fs.existsSync(dir)) {
+      return files;
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...this.findRouteFiles(fullPath));
+      } else if (entry.name === "route.ts" || entry.name === "route.tsx" || entry.name === "route.js") {
+        files.push(fullPath);
+      }
+    }
+    return files;
+  }
+  /**
+   * Load a route.ts file and extract HTTP method exports
+   */
+  async loadRoute(filePath, appDir) {
+    try {
+      const apiDir = path3.join(appDir, "api");
+      const relativePath = path3.relative(apiDir, path3.dirname(filePath));
+      const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
+      const routeModule = await this.loadModule(filePath);
+      const endpoints = {};
+      const availableMethods = [];
+      for (const method of API_ROUTE_METHODS) {
+        if (routeModule[method]) {
+          endpoints[method] = routeModule[method];
+          availableMethods.push(method);
+        }
+      }
+      if (availableMethods.length > 0) {
+        const runtimeConfig = normalizeFarmRouteRuntimeConfig(
+          getFarmRouteRuntimeConfig(routeModule),
+          `API route "${routePath}"`
+        );
+        this.routes.set(routePath, {
+          path: routePath,
+          filePath,
+          methods: availableMethods,
+          endpoints,
+          ...runtimeConfig
+        });
+      }
+    } catch (error) {
+      this.handleLoadError(`Error loading route ${filePath}`, error);
+    }
+  }
+  /**
+   * Load explicit-path endpoints from src/routes.ts-style files.
+   */
+  async loadRootRoutes(appDir) {
+    const routesFile = this.findRootRoutesFile(appDir);
+    if (!routesFile) {
+      return;
+    }
+    try {
+      const routesModule = await this.loadModule(routesFile);
+      for (const exportValue of Object.values(routesModule)) {
+        const endpoint = exportValue;
+        if (!endpoint?.__path) {
+          continue;
+        }
+        const method = String(endpoint.__method || "GET").toUpperCase();
+        this.addEndpoint(endpoint.__path, routesFile, method, endpoint);
+      }
+    } catch (error) {
+      this.handleLoadError(`Error loading root API routes ${routesFile}`, error);
+    }
+  }
+  async loadProgrammaticApiRoutes(appDir) {
+    const candidateRoots = [path3.dirname(appDir), appDir];
+    const routeFiles = Array.from(
+      new Set(candidateRoots.flatMap((srcRoot) => findProgrammaticRouteFilesInDir(srcRoot)))
+    );
+    for (const routeFile of routeFiles) {
+      try {
+        const routesModule = await this.loadModule(routeFile);
+        const manifest = getProgrammaticRouteManifest(routesModule);
+        if (!manifest) continue;
+        for (const definition of manifest.routes) {
+          if (definition.kind !== "api") continue;
+          this.addProgrammaticApiRoute(routeFile, definition);
+        }
+      } catch (error) {
+        this.handleLoadError(`Error loading programmatic API routes ${routeFile}`, error);
+      }
+    }
+  }
+  handleLoadError(message, error) {
+    logger.error(`${message}: ${error}`);
+    if (this.throwOnLoadError) {
+      throw error;
+    }
+  }
+  findRootRoutesFile(appDir) {
+    const routeNames = ["routes.ts", "routes.tsx", "routes.js"];
+    const candidateDirs = [path3.dirname(appDir), appDir];
+    const seen = /* @__PURE__ */ new Set();
+    for (const dir of candidateDirs) {
+      for (const routeName of routeNames) {
+        const routesFile = path3.join(dir, routeName);
+        if (seen.has(routesFile)) {
+          continue;
+        }
+        seen.add(routesFile);
+        if (fs.existsSync(routesFile)) {
+          return routesFile;
+        }
+      }
+    }
+    return null;
+  }
+  async loadModule(filePath) {
+    if (this.viteServer) {
+      return await this.viteServer.ssrLoadModule(filePath);
+    }
+    const fileUrl = `file://${filePath}`;
+    return await import(
+      /* @vite-ignore */
+      fileUrl
+    );
+  }
+  addEndpoint(routePath, filePath, method, endpoint, runtimeConfig = {}) {
+    const normalizedMethod = method.toUpperCase();
+    const existingRoute = this.routes.get(routePath);
+    if (existingRoute) {
+      if (!existingRoute.methods.includes(normalizedMethod)) {
+        existingRoute.methods.push(normalizedMethod);
+      }
+      existingRoute.endpoints[normalizedMethod] = endpoint;
+      Object.assign(existingRoute, runtimeConfig);
+      return;
+    }
+    this.routes.set(routePath, {
+      path: routePath,
+      filePath,
+      methods: [normalizedMethod],
+      endpoints: { [normalizedMethod]: endpoint },
+      ...runtimeConfig
+    });
+  }
+  addProgrammaticApiRoute(filePath, route) {
+    const modulePath = createProgrammaticRouteModuleId(filePath, "api", route.path);
+    const runtimeConfig = normalizeFarmRouteRuntimeConfig(route, `API route "${route.path}"`);
+    for (const [method, endpoint] of Object.entries(route.methods)) {
+      if (endpoint) {
+        this.addEndpoint(route.path, modulePath, method, endpoint, runtimeConfig);
+      }
+    }
+  }
+  /**
+   * Get the handler that directly invokes endpoint handlers
+   */
+  getHandler() {
+    if (this.routes.size === 0) {
+      return null;
+    }
+    return async (request) => {
+      const url = new URL(request.url);
+      const pathname = url.pathname;
+      const method = request.method.toUpperCase();
+      const match = matchAPIRoute(this.routes, pathname);
+      if (!match) {
+        return new Response(JSON.stringify({ error: "Not Found" }), {
+          status: 404,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const { route, params } = match;
+      const endpoint = route.endpoints[method];
+      if (!endpoint) {
+        return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+          status: 405,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const invoke = /* @__PURE__ */ __name(async () => {
+        try {
+          return await invokeAPIRouteEndpoint(endpoint, request, params);
+        } catch (error) {
+          console.error(`[API Error] ${pathname}:`, error);
+          return new Response(JSON.stringify({ error: "Internal Server Error" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      }, "invoke");
+      return this.i18n?.config.enabled ? _runWithFarmI18nRequest(this.i18n, request, invoke, {
+        redirect: false
+      }) : invoke();
+    };
+  }
+  /**
+   * Check if a path is an API route
+   */
+  isAPIRoute(pathname) {
+    return Boolean(this.matchRoute(pathname));
+  }
+  matchRoute(pathname) {
+    return matchAPIRoute(this.routes, pathname);
+  }
+  /**
+   * Get all routes for client type generation
+   */
+  getRoutes() {
+    return this.routes;
+  }
+};
+__name(_APIRouteManager, "APIRouteManager");
+var APIRouteManager = _APIRouteManager;
+
+// src/integration-client.ts
+var _IntegrationClientError = class _IntegrationClientError extends Error {
+  constructor(message, response, data) {
+    super(message);
+    this.name = "IntegrationClientError";
+    this.status = response.status;
+    this.response = response;
+    this.data = data;
+  }
+};
+__name(_IntegrationClientError, "IntegrationClientError");
+var IntegrationClientError = _IntegrationClientError;
+var INTEGRATION_RUNTIME_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("farm.integrationRuntimeRegistry");
+var CURRENT_REQUEST_RESOLVER_KEY2 = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
+var INTEGRATION_REQUEST_DISPATCHER_KEY = /* @__PURE__ */ Symbol.for("farm.integrationRequestDispatcher");
+function isOperation(value) {
+  return !!value && typeof value === "object" && value.kind === "farm-integration-api-operation";
+}
+__name(isOperation, "isOperation");
+function tryResolveSourceAPI(source) {
+  if ("kind" in source && source.kind === "farm-integration") {
+    if (!source.api) {
+      return null;
+    }
+    return source.api;
+  }
+  return source;
+}
+__name(tryResolveSourceAPI, "tryResolveSourceAPI");
+function getIntegrationRuntimeRegistry() {
+  const globalState2 = globalThis;
+  return globalState2[INTEGRATION_RUNTIME_REGISTRY_KEY] || /* @__PURE__ */ new Map();
+}
+__name(getIntegrationRuntimeRegistry, "getIntegrationRuntimeRegistry");
+function getRegisteredIntegrationRuntimeLocal(key) {
+  return getIntegrationRuntimeRegistry().get(key);
+}
+__name(getRegisteredIntegrationRuntimeLocal, "getRegisteredIntegrationRuntimeLocal");
+function getRegisteredIntegrationsLocal() {
+  return Object.fromEntries(
+    Array.from(getIntegrationRuntimeRegistry().entries()).map(([key, runtime]) => [
+      key,
+      runtime.integration
+    ])
+  );
+}
+__name(getRegisteredIntegrationsLocal, "getRegisteredIntegrationsLocal");
+function resolveCurrentRequestLocal() {
+  const globalState2 = globalThis;
+  return globalState2[CURRENT_REQUEST_RESOLVER_KEY2]?.();
+}
+__name(resolveCurrentRequestLocal, "resolveCurrentRequestLocal");
+function resolveIntegrationRequestDispatcherLocal() {
+  const globalState2 = globalThis;
+  return globalState2[INTEGRATION_REQUEST_DISPATCHER_KEY];
+}
+__name(resolveIntegrationRequestDispatcherLocal, "resolveIntegrationRequestDispatcherLocal");
+var INTEGRATION_DATA_HEADER = "x-farm-integration-data";
+var INTEGRATION_DATA_HEADER_MAX_LENGTH = 16 * 1024;
+var BLOCKED_INTEGRATION_DATA_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isIntegrationClientData(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+__name(isIntegrationClientData, "isIntegrationClientData");
+function isPlainIntegrationDataObject(value) {
+  if (!isIntegrationClientData(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainIntegrationDataObject, "isPlainIntegrationDataObject");
+function sanitizeIntegrationClientDataValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeIntegrationClientDataValue(item));
+  }
+  if (!isPlainIntegrationDataObject(value)) {
+    return value;
+  }
+  const sanitized = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (BLOCKED_INTEGRATION_DATA_KEYS.has(key)) {
+      continue;
+    }
+    sanitized[key] = sanitizeIntegrationClientDataValue(item);
+  }
+  return sanitized;
+}
+__name(sanitizeIntegrationClientDataValue, "sanitizeIntegrationClientDataValue");
+function normalizeIntegrationClientData(value) {
+  if (!isIntegrationClientData(value)) {
+    return void 0;
+  }
+  const sanitized = sanitizeIntegrationClientDataValue(value);
+  return isIntegrationClientData(sanitized) && Object.keys(sanitized).length > 0 ? sanitized : void 0;
+}
+__name(normalizeIntegrationClientData, "normalizeIntegrationClientData");
+function getIntegrationDataHeaderByteLength(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+__name(getIntegrationDataHeaderByteLength, "getIntegrationDataHeaderByteLength");
+function mergeIntegrationClientData(...values) {
+  let merged;
+  for (const value of values) {
+    const data = normalizeIntegrationClientData(value);
+    if (!data) {
+      continue;
+    }
+    merged = {
+      ...merged,
+      ...data
+    };
+  }
+  return merged && Object.keys(merged).length > 0 ? merged : void 0;
+}
+__name(mergeIntegrationClientData, "mergeIntegrationClientData");
+function serializeIntegrationClientData(data) {
+  const serialized = JSON.stringify(data);
+  if (getIntegrationDataHeaderByteLength(serialized) > INTEGRATION_DATA_HEADER_MAX_LENGTH) {
+    throw new Error(
+      `Integration client data must be smaller than ${INTEGRATION_DATA_HEADER_MAX_LENGTH} bytes when sent over HTTP headers.`
+    );
+  }
+  return serialized;
+}
+__name(serializeIntegrationClientData, "serializeIntegrationClientData");
+function appendIntegrationClientDataHeader(headers, data) {
+  if (!data) {
+    return;
+  }
+  headers.set(INTEGRATION_DATA_HEADER, serializeIntegrationClientData(data));
+}
+__name(appendIntegrationClientDataHeader, "appendIntegrationClientDataHeader");
+function resolveAutomaticClientNamespaces() {
+  const globalState2 = globalThis;
+  const manifest = globalState2.window?.__FARM_INTEGRATION_API_MANIFEST__ || globalState2.__FARM_INTEGRATION_API_MANIFEST__ || {};
+  return Object.entries(manifest).map(([key, api2]) => [key, api2, api2]);
+}
+__name(resolveAutomaticClientNamespaces, "resolveAutomaticClientNamespaces");
+function resolveAutomaticServerNamespaces() {
+  return Object.entries(getRegisteredIntegrationsLocal()).flatMap(([key, source]) => {
+    const api2 = tryResolveSourceAPI(source);
+    return api2 ? [[key, api2, source]] : [];
+  });
+}
+__name(resolveAutomaticServerNamespaces, "resolveAutomaticServerNamespaces");
+function appendQuery(url, query) {
+  if (!query) {
+    return;
+  }
+  for (const [key, value] of Object.entries(query)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item != null) {
+          url.searchParams.append(key, String(item));
+        }
+      }
+      continue;
+    }
+    url.searchParams.set(key, String(value));
+  }
+}
+__name(appendQuery, "appendQuery");
+function appendHeaders(target, source) {
+  if (!source) {
+    return;
+  }
+  const headers = new Headers(source);
+  headers.forEach((value, key) => {
+    target.set(key, value);
+  });
+}
+__name(appendHeaders, "appendHeaders");
+var DEFAULT_FORWARDED_HEADERS = [
+  "authorization",
+  "cookie",
+  "x-client-ip",
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-proto",
+  "x-real-ip"
+];
+function resolveRequestLike(request) {
+  if (!request) {
+    return void 0;
+  }
+  if (request instanceof Request) {
+    return {
+      url: request.url,
+      headers: request.headers
+    };
+  }
+  return {
+    url: request.url,
+    headers: request.headers ? new Headers(request.headers) : void 0
+  };
+}
+__name(resolveRequestLike, "resolveRequestLike");
+function resolveServerBaseURL(explicitBaseURL, request) {
+  if (explicitBaseURL) {
+    return explicitBaseURL;
+  }
+  if (request?.url) {
+    try {
+      return new URL(request.url).origin;
+    } catch {
+    }
+  }
+  const headers = request?.headers;
+  const host = headers?.get("x-forwarded-host") || headers?.get("host");
+  if (host) {
+    const proto = headers?.get("x-forwarded-proto") || "http";
+    return `${proto}://${host}`;
+  }
+  return "http://localhost:3000";
+}
+__name(resolveServerBaseURL, "resolveServerBaseURL");
+function resolveForwardHeaders(request, forwardHeaders) {
+  if (!request?.headers || forwardHeaders === false) {
+    return new Headers();
+  }
+  const allowed = Array.isArray(forwardHeaders) && forwardHeaders.length > 0 ? new Set(forwardHeaders.map((item) => item.toLowerCase())) : new Set(DEFAULT_FORWARDED_HEADERS);
+  const headers = new Headers();
+  request.headers.forEach((value, key) => {
+    if (allowed.has(key.toLowerCase())) {
+      headers.set(key, value);
+    }
+  });
+  return headers;
+}
+__name(resolveForwardHeaders, "resolveForwardHeaders");
+function createBody(format, body, headers) {
+  if (body == null || format === "none") {
+    return void 0;
+  }
+  if (format === "form") {
+    if (body instanceof FormData || body instanceof URLSearchParams) {
+      return body;
+    }
+    const form = new URLSearchParams();
+    for (const [key, value] of Object.entries(body)) {
+      if (value == null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item != null) {
+            form.append(key, String(item));
+          }
+        }
+        continue;
+      }
+      form.set(key, String(value));
+    }
+    headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+    return form;
+  }
+  headers.set("content-type", "application/json");
+  return JSON.stringify(body);
+}
+__name(createBody, "createBody");
+async function parseResponseData(response) {
+  if (response.status === 204 || response.status === 205) {
+    return void 0;
+  }
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await response.json();
+  }
+  return await response.text();
+}
+__name(parseResponseData, "parseResponseData");
+async function safeParseResponseData(response) {
+  try {
+    return await parseResponseData(response);
+  } catch {
+    return void 0;
+  }
+}
+__name(safeParseResponseData, "safeParseResponseData");
+function createResponseError(response, errorData) {
+  const message = typeof errorData === "string" ? errorData : typeof errorData === "object" && errorData ? String(
+    errorData.error || errorData.message || response.statusText
+  ) : response.statusText || "Integration request failed.";
+  return new IntegrationClientError(message, response, errorData);
+}
+__name(createResponseError, "createResponseError");
+function normalizeExecutionError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string" && error.length > 0) {
+    return new Error(error);
+  }
+  return new Error("Integration request failed.");
+}
+__name(normalizeExecutionError, "normalizeExecutionError");
+async function finalizeOperationResponse(operation, response) {
+  if (!response.ok) {
+    const errorData = await safeParseResponseData(response);
+    return {
+      data: null,
+      error: createResponseError(response, errorData)
+    };
+  }
+  if (operation.responseFormat === "response") {
+    return {
+      data: response,
+      error: null
+    };
+  }
+  return {
+    data: await parseResponseData(response),
+    error: null
+  };
+}
+__name(finalizeOperationResponse, "finalizeOperationResponse");
+async function executeClientOperation(operation, input, options, requestOptions) {
+  try {
+    if (!operation.path) {
+      return {
+        data: null,
+        error: new Error(
+          "Integration API operation path is missing. Pass a path to api.get/post/... or wrap pathless methods with api.route(path, { ... })."
+        )
+      };
+    }
+    const baseURL = options.baseURL || (typeof window !== "undefined" ? window.location.origin : "http://localhost:3000");
+    const url = new URL(operation.path, baseURL);
+    appendQuery(url, input.query);
+    const headers = new Headers({
+      "x-farm-integration-client": "1",
+      ...options.headers,
+      ...operation.headers,
+      ...requestOptions?.headers
+    });
+    if (operation.responseFormat !== "response") {
+      headers.set("accept", "application/json");
+    }
+    appendIntegrationClientDataHeader(
+      headers,
+      mergeIntegrationClientData(options.data, requestOptions?.data)
+    );
+    const response = await fetch(url.toString(), {
+      method: operation.method,
+      headers,
+      body: createBody(operation.bodyFormat, input.body, headers),
+      credentials: requestOptions?.credentials ?? operation.credentials ?? options.credentials ?? "include",
+      signal: requestOptions?.signal
+    });
+    if (!response.ok) {
+      const errorData = await safeParseResponseData(response);
+      return {
+        data: null,
+        error: createResponseError(response, errorData)
+      };
+    }
+    if (operation.responseFormat === "response") {
+      return {
+        data: response,
+        error: null
+      };
+    }
+    return {
+      data: await parseResponseData(response),
+      error: null
+    };
+  } catch (error) {
+    return {
+      data: null,
+      error: normalizeExecutionError(error)
+    };
+  }
+}
+__name(executeClientOperation, "executeClientOperation");
+async function executeServerOperation(operation, input, options, requestOptions, integrationKey, source) {
+  try {
+    if (!operation.path) {
+      return {
+        data: null,
+        error: new Error(
+          "Integration API operation path is missing. Pass a path to api.get/post/... or wrap pathless methods with api.route(path, { ... })."
+        )
+      };
+    }
+    const serverRequestOptions = requestOptions && ("request" in requestOptions || "baseURL" in requestOptions || "forwardHeaders" in requestOptions) ? requestOptions : void 0;
+    const currentRequest = serverRequestOptions?.request instanceof Request ? serverRequestOptions.request : options.request instanceof Request ? options.request : resolveCurrentRequestLocal();
+    const request = resolveRequestLike(
+      serverRequestOptions?.request ?? options.request ?? currentRequest
+    );
+    const baseURL = resolveServerBaseURL(serverRequestOptions?.baseURL ?? options.baseURL, request);
+    const url = new URL(operation.path, baseURL);
+    appendQuery(url, input.query);
+    const headers = new Headers();
+    appendHeaders(
+      headers,
+      resolveForwardHeaders(
+        request,
+        serverRequestOptions?.forwardHeaders ?? options.forwardHeaders
+      )
+    );
+    appendHeaders(headers, options.headers);
+    appendHeaders(headers, operation.headers);
+    appendHeaders(headers, requestOptions?.headers);
+    headers.set("x-farm-integration-client", "1");
+    if (operation.responseFormat !== "response") {
+      headers.set("accept", "application/json");
+    }
+    const data = mergeIntegrationClientData(options.data, requestOptions?.data);
+    if (integrationKey) {
+      const runtime = "kind" in (source || {}) && source.kind === "farm-integration" ? getRegisteredIntegrationRuntimeLocal(integrationKey) || {
+        integration: source,
+        config: {},
+        isDev: process.env.NODE_ENV !== "production",
+        isProd: process.env.NODE_ENV === "production"
+      } : getRegisteredIntegrationRuntimeLocal(integrationKey);
+      if (runtime) {
+        const dispatchIntegrationRequest = resolveIntegrationRequestDispatcherLocal();
+        const directResponse = dispatchIntegrationRequest ? await dispatchIntegrationRequest(
+          runtime,
+          new Request(url.toString(), {
+            method: operation.method,
+            headers,
+            body: createBody(operation.bodyFormat, input.body, headers)
+          }),
+          {
+            currentRequest,
+            data,
+            internal: true
+          }
+        ) : null;
+        if (directResponse) {
+          return await finalizeOperationResponse(operation, directResponse);
+        }
+      }
+    }
+    appendIntegrationClientDataHeader(headers, data);
+    const response = await fetch(url.toString(), {
+      method: operation.method,
+      headers,
+      body: createBody(operation.bodyFormat, input.body, headers),
+      credentials: requestOptions?.credentials ?? operation.credentials ?? options.credentials ?? "include",
+      signal: requestOptions?.signal
+    });
+    return await finalizeOperationResponse(operation, response);
+  } catch (error) {
+    return {
+      data: null,
+      error: normalizeExecutionError(error)
+    };
+  }
+}
+__name(executeServerOperation, "executeServerOperation");
+function createAutomaticIntegrationAliases(isServer, options = {}) {
+  const cache = isServer ? /* @__PURE__ */ new Map() : null;
+  const integrationNamespaces = new Proxy(
+    {},
+    {
+      get(_target, property) {
+        if (typeof property !== "string") {
+          return void 0;
+        }
+        if (property === "integrations") {
+          return integrationNamespaces;
+        }
+        if (cache?.has(property)) {
+          return cache.get(property);
+        }
+        const namespaces = isServer ? resolveAutomaticServerNamespaces() : resolveAutomaticClientNamespaces();
+        const match = namespaces.find(([key]) => key === property);
+        if (!match) {
+          return void 0;
+        }
+        const namespace = isServer ? createServerNamespaceProxy(
+          match[0],
+          match[2],
+          match[1],
+          options
+        ) : createNamespaceProxy(match[1], options);
+        cache?.set(property, namespace);
+        return namespace;
+      }
+    }
+  );
+  Object.defineProperty(integrationNamespaces, "integrations", {
+    value: integrationNamespaces,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return integrationNamespaces;
+}
+__name(createAutomaticIntegrationAliases, "createAutomaticIntegrationAliases");
+function integrationsClient(options = {}) {
+  return createAutomaticIntegrationAliases(
+    false,
+    options
+  );
+}
+__name(integrationsClient, "integrationsClient");
+function integrationsServer(options = {}) {
+  return createAutomaticIntegrationAliases(true, {
+    ...options,
+    isServer: true
+  });
+}
+__name(integrationsServer, "integrationsServer");
+function resolveSingleNamespaceOperation(api2) {
+  const entries = Object.entries(api2);
+  if (entries.length !== 1) {
+    return null;
+  }
+  const [, value] = entries[0];
+  return isOperation(value) ? value : null;
+}
+__name(resolveSingleNamespaceOperation, "resolveSingleNamespaceOperation");
+function createClientOperationCaller(operation, property, options) {
+  if (operation.isServer === true) {
+    return async () => {
+      throw new Error(
+        `Integration method "${property}" is registered with isServer: true and is only available from a server integration client.`
+      );
+    };
+  }
+  return async (input = {}, requestOptions) => {
+    if (typeof window === "undefined") {
+      throw new Error(
+        "Client integration API cannot be called on the server. Pass { isServer: true } to createIntegrationClient(...) during server rendering, or provide { isServer: true, request } outside it."
+      );
+    }
+    return executeClientOperation(operation, input, options, requestOptions);
+  };
+}
+__name(createClientOperationCaller, "createClientOperationCaller");
+function createServerOperationCaller(operation, options, integrationKey, source) {
+  return async (input = {}, requestOptions) => {
+    if (typeof window !== "undefined") {
+      throw new Error(
+        "Server integration API cannot be called in the browser. Remove { isServer: true } and create a client integration API instead."
+      );
+    }
+    return executeServerOperation(
+      operation,
+      input,
+      options,
+      requestOptions,
+      integrationKey,
+      source
+    );
+  };
+}
+__name(createServerOperationCaller, "createServerOperationCaller");
+function createNamespaceProxy(api2, options) {
+  const cache = /* @__PURE__ */ new Map();
+  const directOperation = resolveSingleNamespaceOperation(api2);
+  const target = directOperation ? createClientOperationCaller(directOperation, directOperation.method.toLowerCase(), options) : {};
+  return new Proxy(target, {
+    get(targetObject, property, receiver) {
+      if (typeof property !== "string") {
+        return Reflect.get(targetObject, property, receiver);
+      }
+      if (cache.has(property)) {
+        return cache.get(property);
+      }
+      const value = api2[property];
+      if (!value) {
+        return Reflect.get(targetObject, property, receiver);
+      }
+      if (isOperation(value)) {
+        const caller = createClientOperationCaller(value, property, options);
+        cache.set(property, caller);
+        return caller;
+      }
+      const namespace = createNamespaceProxy(value, options);
+      cache.set(property, namespace);
+      return namespace;
+    }
+  });
+}
+__name(createNamespaceProxy, "createNamespaceProxy");
+function createServerNamespaceProxy(integrationKey, source, api2, options) {
+  const cache = /* @__PURE__ */ new Map();
+  const directOperation = resolveSingleNamespaceOperation(api2);
+  const target = directOperation ? createServerOperationCaller(directOperation, options, integrationKey, source) : {};
+  return new Proxy(target, {
+    get(targetObject, property, receiver) {
+      if (typeof property !== "string") {
+        return Reflect.get(targetObject, property, receiver);
+      }
+      if (cache.has(property)) {
+        return cache.get(property);
+      }
+      const value = api2[property];
+      if (!value) {
+        return Reflect.get(targetObject, property, receiver);
+      }
+      if (isOperation(value)) {
+        const caller = createServerOperationCaller(value, options, integrationKey, source);
+        cache.set(property, caller);
+        return caller;
+      }
+      const namespace = createServerNamespaceProxy(
+        integrationKey,
+        source,
+        value,
+        options
+      );
+      cache.set(property, namespace);
+      return namespace;
+    }
+  });
+}
+__name(createServerNamespaceProxy, "createServerNamespaceProxy");
+
+// src/client-cache.ts
+var _FarmClientDataCache = class _FarmClientDataCache {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.aliases = /* @__PURE__ */ new Map();
+    this.invalidatedAt = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    subscribeFarmCacheInvalidation((key) => this.invalidate(key));
+  }
+  get size() {
+    return this.entries.size;
+  }
+  resolveKey(key) {
+    let resolved = key;
+    const seen = /* @__PURE__ */ new Set();
+    while (this.aliases.has(resolved) && !seen.has(resolved)) {
+      seen.add(resolved);
+      resolved = this.aliases.get(resolved);
+    }
+    return resolved;
+  }
+  get(key, now = Date.now()) {
+    const resolved = this.resolveKey(key);
+    const entry = this.entries.get(resolved);
+    if (!entry) return void 0;
+    if (entry.gcAt !== void 0 && now >= entry.gcAt) {
+      this.entries.delete(resolved);
+      this.emit(resolved);
+      return void 0;
+    }
+    return entry;
+  }
+  set(key, entry) {
+    const resolved = this.resolveKey(key);
+    const invalidatedAt = this.invalidatedAt.get(resolved);
+    const nextEntry = invalidatedAt !== void 0 && invalidatedAt > entry.updatedAt ? { ...entry, staleAt: 0, invalidatedAt } : { ...entry, invalidatedAt: void 0 };
+    if (invalidatedAt === void 0 || entry.updatedAt >= invalidatedAt) {
+      this.invalidatedAt.delete(resolved);
+    }
+    this.entries.set(resolved, nextEntry);
+    this.emit(resolved);
+    return this;
+  }
+  delete(key) {
+    const resolved = this.resolveKey(key);
+    const deleted = this.entries.delete(resolved);
+    this.inflight.delete(resolved);
+    this.emit(resolved);
+    return deleted;
+  }
+  clear() {
+    const keys = /* @__PURE__ */ new Set([...this.entries.keys(), ...this.listeners.keys()]);
+    this.entries.clear();
+    this.aliases.clear();
+    this.invalidatedAt.clear();
+    this.inflight.clear();
+    for (const key of keys) this.emit(key);
+  }
+  isStale(key, now = Date.now()) {
+    const entry = this.get(key, now);
+    return !entry || entry.invalidatedAt !== void 0 || now >= entry.staleAt;
+  }
+  invalidate(key, now = Date.now()) {
+    const resolved = this.resolveKey(key);
+    this.invalidatedAt.set(resolved, now);
+    const entry = this.entries.get(resolved);
+    if (entry) {
+      this.entries.set(resolved, {
+        ...entry,
+        staleAt: 0,
+        invalidatedAt: now
+      });
+    }
+    this.emit(resolved);
+  }
+  alias(alias, key) {
+    const resolved = this.resolveKey(key);
+    if (alias === resolved) return;
+    const aliasEntry = this.entries.get(alias);
+    if (aliasEntry && !this.entries.has(resolved)) {
+      this.entries.set(resolved, aliasEntry);
+    }
+    this.entries.delete(alias);
+    const aliasInflight = this.inflight.get(alias);
+    if (aliasInflight && !this.inflight.has(resolved)) {
+      this.inflight.set(resolved, aliasInflight);
+    }
+    this.inflight.delete(alias);
+    this.aliases.set(alias, resolved);
+    this.emit(alias);
+    this.emit(resolved);
+  }
+  subscribe(key, listener) {
+    let listeners = this.listeners.get(key);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.listeners.set(key, listeners);
+    }
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) this.listeners.delete(key);
+    };
+  }
+  getInflight(key) {
+    return this.inflight.get(this.resolveKey(key));
+  }
+  setInflight(key, promise) {
+    this.inflight.set(this.resolveKey(key), promise);
+  }
+  deleteInflight(key) {
+    this.inflight.delete(this.resolveKey(key));
+  }
+  emit(key) {
+    this.notifyListeners(key);
+    for (const [alias, target] of this.aliases) {
+      if (this.resolveKey(target) === key) {
+        this.notifyListeners(alias);
+      }
+    }
+  }
+  notifyListeners(key) {
+    for (const listener of this.listeners.get(key) ?? []) {
+      listener();
+    }
+  }
+};
+__name(_FarmClientDataCache, "FarmClientDataCache");
+var FarmClientDataCache = _FarmClientDataCache;
+var FARM_CLIENT_DATA_CACHE = /* @__PURE__ */ Symbol.for("farm.clientDataCache");
+var clientCacheGlobal = globalThis;
+var sharedFarmClientDataCache = clientCacheGlobal[FARM_CLIENT_DATA_CACHE] ?? (clientCacheGlobal[FARM_CLIENT_DATA_CACHE] = new FarmClientDataCache());
+function getFarmClientDataCache() {
+  return sharedFarmClientDataCache;
+}
+__name(getFarmClientDataCache, "getFarmClientDataCache");
+function normalizeFarmClientCacheKey(key) {
+  return typeof key === "string" ? key : createRouteDataCacheKey(key);
+}
+__name(normalizeFarmClientCacheKey, "normalizeFarmClientCacheKey");
+
+// src/api/client.ts
+var FARM_API_ROUTE_REF_SYMBOL = /* @__PURE__ */ Symbol.for("farm.api.route-ref");
+var FARM_API_ROUTE_META_SYMBOL = /* @__PURE__ */ Symbol.for("farm.api.route-meta");
+var _APIClientError = class _APIClientError extends Error {
+  constructor(code, data, options) {
+    super(options.message);
+    this.name = "APIClientError";
+    this.code = code;
+    this.data = data;
+    this.status = options.status;
+    this.response = options.response;
+  }
+};
+__name(_APIClientError, "APIClientError");
+var APIClientError = _APIClientError;
+function createAPIClient(options = {}) {
+  options ?? (options = {});
+  const baseURL = options.baseURL || (typeof window !== "undefined" ? window.location.origin : "http://localhost:3000");
+  const integrationOptions = options.integrations === false ? false : {
+    baseURL: options.baseURL,
+    headers: options.headers,
+    credentials: options.credentials,
+    ...typeof options.integrations === "object" ? options.integrations : {}
+  };
+  const rootAliases = integrationOptions === false ? void 0 : {
+    integrations: integrationsClient(integrationOptions)
+  };
+  const cacheState = getFarmClientDataCache();
+  const inflightState = /* @__PURE__ */ new Map();
+  const routeMeta = /* @__PURE__ */ new WeakMap();
+  let requestCounter = 0;
+  const fetchClient = /* @__PURE__ */ __name(async (path4, requestOptions = {}) => {
+    const url = new URL(path4, baseURL);
+    if (requestOptions.query) {
+      Object.entries(requestOptions.query).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers,
+      ...requestOptions.headers
+    };
+    const fetchOptions = {
+      method: requestOptions.method || "GET",
+      headers
+    };
+    if (requestOptions.body !== void 0) {
+      if (isFormData(requestOptions.body)) {
+        deleteHeader(headers, "content-type");
+        fetchOptions.body = requestOptions.body;
+      } else {
+        fetchOptions.body = JSON.stringify(requestOptions.body);
+      }
+    }
+    const response = await fetch(url.toString(), fetchOptions);
+    applyFarmCacheInvalidations(
+      decodeFarmCacheInvalidations(response.headers?.get?.(FARM_CACHE_INVALIDATION_HEADER))
+    );
+    let data = void 0;
+    if (response.status !== 204 && response.status !== 205) {
+      data = isJSONStreamResponse(response) ? readJSONStream(response) : await response.json();
+    }
+    return { response, data };
+  }, "fetchClient");
+  const request = /* @__PURE__ */ __name(async (path4, method, input = {}, clientOptions) => {
+    const methodUpper = method.toUpperCase();
+    const requestId = `${Date.now()}-${++requestCounter}`;
+    const cacheOptions = clientOptions?.cache ? {
+      ...options.cacheDefaults,
+      ...clientOptions.cache
+    } : void 0;
+    const configuredCacheKey = clientOptions?.key ?? cacheOptions?.key;
+    const cacheKey = normalizeFarmClientCacheKey(
+      configuredCacheKey ?? buildCacheKey(methodUpper, path4, input, baseURL)
+    );
+    const now = Date.now();
+    const emitStatus = /* @__PURE__ */ __name((phase, payload) => {
+      clientOptions?.onStatus?.({
+        phase,
+        requestId,
+        method: methodUpper,
+        key: cacheKey,
+        input,
+        timestamp: Date.now(),
+        ...payload
+      });
+    }, "emitStatus");
+    const entry = getValidCacheEntry(cacheState, cacheKey, now);
+    const policy = cacheOptions?.policy ?? (cacheOptions ? "cache-first" : "network-only");
+    const staleTime = cacheOptions?.staleTime ?? 0;
+    const isCacheEnabled = Boolean(cacheOptions) && methodUpper === "GET";
+    const isStale = entry ? isEntryStale(entry, now) : true;
+    const applyOptimisticUpdates = /* @__PURE__ */ __name(() => {
+      if (!clientOptions?.optimistic?.update?.length) return [];
+      const snapshots = [];
+      for (const update of clientOptions.optimistic.update) {
+        const [target, targetInput, updater] = update.length === 2 ? [update[0], void 0, update[1]] : [update[0], update[1], update[2]];
+        const targetKey = resolveTargetKey(routeMeta, target, targetInput, baseURL);
+        if (!targetKey) continue;
+        const targetEntry = getValidCacheEntry(cacheState, targetKey, now);
+        const previousEntry = targetEntry ? { ...targetEntry } : void 0;
+        const previousData = targetEntry?.data;
+        const nextData = updater(previousData);
+        cacheState.set(targetKey, {
+          data: nextData,
+          updatedAt: now,
+          staleAt: targetEntry?.staleAt ?? now + (cacheOptions?.staleTime ?? options.cacheDefaults?.staleTime ?? 0),
+          gcAt: targetEntry?.gcAt ?? getGcAt(now, cacheOptions?.gcTime ?? options.cacheDefaults?.gcTime),
+          invalidatedAt: targetEntry?.invalidatedAt
+        });
+        snapshots.push({ key: targetKey, entry: previousEntry });
+      }
+      return snapshots;
+    }, "applyOptimisticUpdates");
+    const rollbackOptimisticUpdates = /* @__PURE__ */ __name((snapshots) => {
+      if (!clientOptions?.optimistic?.rollbackOnError) return;
+      for (const snapshot of snapshots) {
+        if (!snapshot.entry) {
+          cacheState.delete(snapshot.key);
+          continue;
+        }
+        cacheState.set(snapshot.key, { ...snapshot.entry });
+      }
+    }, "rollbackOptimisticUpdates");
+    const executeNetwork = /* @__PURE__ */ __name(async (opts) => {
+      const dedupeMs = cacheOptions?.dedupeMs ?? 0;
+      const inflight = inflightState.get(cacheKey);
+      const allowDedupe = isCacheEnabled && dedupeMs > 0;
+      if (allowDedupe && inflight && now - inflight.startedAt < dedupeMs) {
+        emitStatus("pending", { isBackground: opts?.isBackground, data: entry?.data });
+        const result2 = await inflight.promise;
+        if (result2.error) {
+          emitStatus("error", { error: result2.error, isBackground: opts?.isBackground });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onError?.(result2.error);
+          }
+        } else {
+          emitStatus("success", { data: result2.data, isBackground: opts?.isBackground });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onSuccess?.(result2.data);
+          }
+        }
+        return result2;
+      }
+      emitStatus(opts?.isBackground ? "revalidating" : "pending", {
+        isBackground: opts?.isBackground
+      });
+      const promise = (async () => {
+        const maxRetries = Math.max(0, clientOptions?.retry?.count ?? 0);
+        let attempt = 0;
+        while (true) {
+          clientOptions?.onRequest?.({
+            requestId,
+            method: methodUpper,
+            key: cacheKey,
+            path: path4,
+            input,
+            attempt,
+            timestamp: Date.now()
+          });
+          try {
+            const { response, data } = await fetchClient(path4, {
+              ...input,
+              method: methodUpper
+            });
+            const error = response.ok ? null : createResponseError2(response, data);
+            const responseEvent = {
+              requestId,
+              method: methodUpper,
+              key: cacheKey,
+              path: path4,
+              input,
+              attempt,
+              timestamp: Date.now(),
+              response,
+              data: response.ok ? data : void 0,
+              error: error ?? void 0,
+              ok: response.ok,
+              status: response.status
+            };
+            clientOptions?.onResponse?.(response.ok ? data : void 0, error, responseEvent);
+            if (!error) {
+              return { data, error: null, key: cacheKey };
+            }
+            if (attempt >= maxRetries) {
+              return { data: void 0, error, key: cacheKey };
+            }
+          } catch (err) {
+            const error = normalizeError(err);
+            const responseEvent = {
+              requestId,
+              method: methodUpper,
+              key: cacheKey,
+              path: path4,
+              input,
+              attempt,
+              timestamp: Date.now(),
+              error,
+              ok: false
+            };
+            clientOptions?.onResponse?.(void 0, error, responseEvent);
+            if (attempt >= maxRetries) {
+              return { data: void 0, error, key: cacheKey };
+            }
+          }
+          attempt += 1;
+          const delay2 = typeof clientOptions?.retry?.delay === "function" ? clientOptions.retry.delay(attempt) : clientOptions?.retry?.delay ?? 0;
+          if (delay2 > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delay2));
+          }
+        }
+      })();
+      inflightState.set(cacheKey, { promise, startedAt: now });
+      try {
+        const result2 = await promise;
+        if (!result2.error && isCacheEnabled && !isFarmAPIStream(result2.data)) {
+          const updatedAt = Date.now();
+          cacheState.set(cacheKey, {
+            data: result2.data,
+            updatedAt,
+            staleAt: updatedAt + staleTime,
+            gcAt: getGcAt(updatedAt, cacheOptions?.gcTime),
+            invalidatedAt: void 0
+          });
+        }
+        if (result2.error) {
+          emitStatus("error", { error: result2.error, isBackground: opts?.isBackground });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onError?.(result2.error);
+          }
+        } else {
+          emitStatus("success", { data: result2.data, isBackground: opts?.isBackground });
+          if (opts?.callCallbacks !== false) {
+            clientOptions?.onSuccess?.(result2.data);
+          }
+        }
+        return result2;
+      } finally {
+        inflightState.delete(cacheKey);
+      }
+    }, "executeNetwork");
+    const invalidateTargets = /* @__PURE__ */ __name(async () => {
+      if (!clientOptions?.invalidate) return;
+      const invalidateOptions = Array.isArray(clientOptions.invalidate) ? { targets: clientOptions.invalidate, refetch: false } : {
+        targets: clientOptions.invalidate.targets,
+        refetch: clientOptions.invalidate.refetch ?? false
+      };
+      for (const target of invalidateOptions.targets) {
+        const targetKey = resolveTargetKey(routeMeta, target, void 0, baseURL);
+        if (!targetKey) continue;
+        const existing = cacheState.get(targetKey);
+        if (existing) {
+          cacheState.set(targetKey, {
+            ...existing,
+            staleAt: 0,
+            invalidatedAt: Date.now()
+          });
+        }
+        emitStatus("invalidated", { key: targetKey });
+        if (invalidateOptions.refetch && existing && targetKey === cacheKey) {
+          void executeNetwork({ isBackground: true, callCallbacks: false });
+        }
+      }
+    }, "invalidateTargets");
+    const optimisticSnapshots = applyOptimisticUpdates();
+    if (isCacheEnabled) {
+      if (entry && !isStale && policy !== "network-only") {
+        emitStatus("success", { data: entry.data });
+        clientOptions?.onSuccess?.(entry.data);
+        clientOptions?.onSettled?.(entry.data, null);
+        return { data: entry.data, error: null, key: cacheKey };
+      }
+      if (entry && isStale && policy === "stale-while-revalidate") {
+        emitStatus("success", { data: entry.data });
+        clientOptions?.onSuccess?.(entry.data);
+        clientOptions?.onSettled?.(entry.data, null);
+        void executeNetwork({ isBackground: true, callCallbacks: false });
+        return { data: entry.data, error: null, key: cacheKey };
+      }
+    }
+    const result = await executeNetwork();
+    if (result.error) {
+      rollbackOptimisticUpdates(optimisticSnapshots);
+    }
+    await invalidateTargets();
+    clientOptions?.onSettled?.(result.data, result.error);
+    return result;
+  }, "request");
+  return createNestedProxy(
+    [],
+    request,
+    routeMeta,
+    baseURL,
+    options.baseURL === void 0,
+    rootAliases
+  );
+}
+__name(createAPIClient, "createAPIClient");
+function createNestedProxy(path4, client, routeMeta, baseURL, sameOrigin, rootAliases) {
+  const target = /* @__PURE__ */ __name(() => {
+  }, "target");
+  const proxy = new Proxy(target, {
+    // When accessing a property (api.hello)
+    get(_target, prop) {
+      if (prop === FARM_API_ROUTE_REF_SYMBOL) {
+        return path4.length > 0;
+      }
+      if (prop === FARM_API_ROUTE_META_SYMBOL) {
+        const metadata = resolveRouteMeta({ path: path4, baseURL });
+        return Object.freeze({
+          path: metadata.routePath,
+          method: metadata.method,
+          baseURL,
+          sameOrigin
+        });
+      }
+      if (path4.length === 0 && typeof prop === "string" && rootAliases && prop in rootAliases) {
+        return rootAliases[prop];
+      }
+      if (typeof prop !== "string") {
+        return Reflect.get(_target, prop);
+      }
+      return createNestedProxy(
+        [...path4, prop],
+        client,
+        routeMeta,
+        baseURL,
+        sameOrigin,
+        rootAliases
+      );
+    },
+    // When calling as a function
+    apply(_target, _thisArg, args) {
+      const lastPart = path4[path4.length - 1];
+      const httpMethods = ["get", "post", "put", "delete", "patch", "options", "head"];
+      if (httpMethods.includes(lastPart)) {
+        const routePath = "/api/" + path4.slice(0, -1).join("/");
+        const method = lastPart.toUpperCase();
+        const [options, clientOptions] = args;
+        return client(routePath, method, options, clientOptions);
+      } else {
+        const routePath = "/api/" + path4.join("/");
+        const [options, clientOptions] = args;
+        return client(routePath, options?.method || "GET", options, clientOptions);
+      }
+    }
+  });
+  routeMeta.set(proxy, { path: [...path4], baseURL });
+  return proxy;
+}
+__name(createNestedProxy, "createNestedProxy");
+function isAPIRouteRef(value) {
+  return typeof value === "function" && value[FARM_API_ROUTE_REF_SYMBOL] === true;
+}
+__name(isAPIRouteRef, "isAPIRouteRef");
+function getAPIRouteRefMetadata(value) {
+  if (!isAPIRouteRef(value)) return null;
+  const metadata = value[FARM_API_ROUTE_META_SYMBOL];
+  if (!metadata || typeof metadata !== "object") return null;
+  const candidate = metadata;
+  if (typeof candidate.path !== "string" || typeof candidate.method !== "string" || typeof candidate.baseURL !== "string" || typeof candidate.sameOrigin !== "boolean") {
+    return null;
+  }
+  return {
+    path: candidate.path,
+    method: candidate.method,
+    baseURL: candidate.baseURL,
+    sameOrigin: candidate.sameOrigin
+  };
+}
+__name(getAPIRouteRefMetadata, "getAPIRouteRefMetadata");
+function createServerAPIClient(endpoints, options = {}) {
+  if (options.integrations === false || Object.prototype.hasOwnProperty.call(endpoints, "integrations")) {
+    return endpoints;
+  }
+  Object.defineProperty(endpoints, "integrations", {
+    get() {
+      return integrationsServer(
+        typeof options.integrations === "object" ? options.integrations : {}
+      );
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return endpoints;
+}
+__name(createServerAPIClient, "createServerAPIClient");
+function buildCacheKey(method, path4, input, baseURL) {
+  const keyInput = input && typeof input === "object" ? { query: input.query, body: input.body } : input;
+  const url = new URL(path4, baseURL);
+  return `${method}:${url.origin}${url.pathname}:${stableStringify(keyInput ?? {})}`;
+}
+__name(buildCacheKey, "buildCacheKey");
+function stableStringify(value) {
+  if (value === null || value === void 0) return String(value);
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const keys = Object.keys(value).sort();
+  const entries = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+  return `{${entries.join(",")}}`;
+}
+__name(stableStringify, "stableStringify");
+function getGcAt(now, gcTime) {
+  if (gcTime === void 0) return void 0;
+  if (!Number.isFinite(gcTime) || gcTime <= 0) return now;
+  return now + gcTime;
+}
+__name(getGcAt, "getGcAt");
+function getValidCacheEntry(cacheState, key, now) {
+  const entry = cacheState.get(key);
+  if (!entry) return void 0;
+  if (entry.gcAt !== void 0 && now >= entry.gcAt) {
+    cacheState.delete(key);
+    return void 0;
+  }
+  return entry;
+}
+__name(getValidCacheEntry, "getValidCacheEntry");
+function isEntryStale(entry, now) {
+  if (entry.invalidatedAt !== void 0) return true;
+  return now >= entry.staleAt;
+}
+__name(isEntryStale, "isEntryStale");
+function resolveTargetKey(routeMeta, target, input, baseURL = "http://localhost:3000") {
+  if (!target) return null;
+  if (typeof target === "string") return target;
+  if (typeof target === "function") {
+    const meta = routeMeta.get(target);
+    if (!meta) return null;
+    const { method, routePath } = resolveRouteMeta(meta);
+    return buildCacheKey(method, routePath, input ?? {}, meta.baseURL);
+  }
+  if (Array.isArray(target)) {
+    const [route, routeInput] = target;
+    if (typeof route === "function") {
+      return resolveTargetKey(routeMeta, route, routeInput, baseURL);
+    }
+    return normalizeFarmClientCacheKey(target);
+  }
+  if ("key" in target) return normalizeFarmClientCacheKey(target.key);
+  if ("path" in target) {
+    const method = target.method ?? "GET";
+    return buildCacheKey(method, target.path, target.input ?? {}, baseURL);
+  }
+  return null;
+}
+__name(resolveTargetKey, "resolveTargetKey");
+function resolveRouteMeta(meta) {
+  const httpMethods = ["get", "post", "put", "delete", "patch", "options", "head"];
+  const lastPart = meta.path[meta.path.length - 1];
+  if (lastPart && httpMethods.includes(lastPart)) {
+    return {
+      routePath: "/api/" + meta.path.slice(0, -1).join("/"),
+      method: lastPart.toUpperCase()
+    };
+  }
+  return {
+    routePath: "/api/" + meta.path.join("/"),
+    method: "GET"
+  };
+}
+__name(resolveRouteMeta, "resolveRouteMeta");
+function normalizeError(error) {
+  if (error instanceof APIClientError) return error;
+  const normalized = new APIClientError("network_error", void 0, {
+    status: 0,
+    message: error instanceof Error ? error.message : typeof error === "string" ? error : "Network request failed"
+  });
+  normalized.cause = error;
+  return normalized;
+}
+__name(normalizeError, "normalizeError");
+function isFormData(value) {
+  return typeof value === "object" && value !== null && (typeof FormData !== "undefined" && value instanceof FormData || Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function");
+}
+__name(isFormData, "isFormData");
+function deleteHeader(headers, name) {
+  const normalized = name.toLowerCase();
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === normalized) delete headers[key];
+  }
+}
+__name(deleteHeader, "deleteHeader");
+function createResponseError2(response, data) {
+  const expected = readEndpointErrorEnvelope(data);
+  if (expected) {
+    return new APIClientError(expected.code, expected.data, {
+      status: response.status,
+      message: expected.message,
+      response
+    });
+  }
+  return new APIClientError("http_error", data, {
+    status: response.status,
+    message: `HTTP ${response.status}: ${response.statusText}`,
+    response
+  });
+}
+__name(createResponseError2, "createResponseError");
+function readEndpointErrorEnvelope(data) {
+  if (!data || typeof data !== "object") return null;
+  const error = data.error;
+  if (!error || typeof error !== "object") return null;
+  const code = error.code;
+  const message = error.message;
+  if (typeof code !== "string" || typeof message !== "string") return null;
+  return {
+    code,
+    message,
+    data: error.data
+  };
+}
+__name(readEndpointErrorEnvelope, "readEndpointErrorEnvelope");
+
+// src/server/response.ts
+var import_node_events = require("events");
+async function sendWebResponse(res, response) {
+  res.statusCode = response.status;
+  const responseHeaders = response.headers;
+  const setCookies = responseHeaders.getSetCookie?.() || [];
+  if (setCookies.length > 0) {
+    res.setHeader("Set-Cookie", setCookies);
+  }
+  response.headers.forEach((value, key) => {
+    if (key.toLowerCase() === "set-cookie" && setCookies.length > 0) {
+      return;
+    }
+    res.setHeader(key, value);
+  });
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  if (typeof res.write !== "function") {
+    const body = await response.arrayBuffer();
+    res.end(Buffer.from(body));
+    return;
+  }
+  const reader = response.body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (!value || value.byteLength === 0) {
+        continue;
+      }
+      if (!res.write(value)) {
+        await (0, import_node_events.once)(res, "drain");
+      }
+    }
+    res.end();
+  } catch (error) {
+    if (!res.writableEnded) {
+      const responseError = error instanceof Error ? error : new Error(String(error));
+      if (typeof res.destroy === "function") {
+        res.destroy(responseError);
+      } else {
+        res.end();
+      }
+    }
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+}
+__name(sendWebResponse, "sendWebResponse");
+
+// src/after.ts
+var import_node_async_hooks3 = require("async_hooks");
+var AFTER_STORAGE = /* @__PURE__ */ Symbol.for("@farm.js/core/after-storage");
+function getAfterStorage() {
+  const runtime = globalThis;
+  const existing = runtime[AFTER_STORAGE];
+  if (existing instanceof import_node_async_hooks3.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new import_node_async_hooks3.AsyncLocalStorage();
+  runtime[AFTER_STORAGE] = storage;
+  return storage;
+}
+__name(getAfterStorage, "getAfterStorage");
+var afterStorage = getAfterStorage();
+function defaultAfterErrorReporter(error) {
+  console.error("[Farm.js] after() callback failed:", error);
+}
+__name(defaultAfterErrorReporter, "defaultAfterErrorReporter");
+function reportAfterError(state, error) {
+  try {
+    state.reportError(error);
+  } catch {
+  }
+}
+__name(reportAfterError, "reportAfterError");
+function createAfterRequestState(reportError = defaultAfterErrorReporter) {
+  let resolveResponseFinished;
+  let responseFinished = false;
+  const responseFinishedPromise = new Promise((resolve) => {
+    resolveResponseFinished = resolve;
+  });
+  const state = {
+    completion: Promise.resolve(),
+    finishResponse: /* @__PURE__ */ __name(() => {
+      if (responseFinished) return;
+      responseFinished = true;
+      resolveResponseFinished();
+    }, "finishResponse"),
+    phase: "open",
+    reportError,
+    tasks: []
+  };
+  state.completion = responseFinishedPromise.then(
+    () => afterStorage.run(state, async () => {
+      state.phase = "running";
+      for (let index = 0; index < state.tasks.length; index++) {
+        const task = state.tasks[index];
+        task.start();
+        try {
+          await task.result;
+        } catch (error) {
+          reportAfterError(state, error);
+        }
+      }
+      state.phase = "closed";
+    })
+  );
+  return state;
+}
+__name(createAfterRequestState, "createAfterRequestState");
+function registerPlatformLifetime(state, context) {
+  if (!context?.waitUntil) return;
+  try {
+    context.waitUntil(state.completion);
+  } catch (error) {
+    reportAfterError(state, error);
+  }
+}
+__name(registerPlatformLifetime, "registerPlatformLifetime");
+function finishSoon(state) {
+  setTimeout(state.finishResponse, 0);
+}
+__name(finishSoon, "finishSoon");
+async function _runWithAfterNodeResponse(response, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  let finished = false;
+  const finish = /* @__PURE__ */ __name(() => {
+    if (finished) return;
+    finished = true;
+    response.off("finish", finish);
+    response.off("close", finish);
+    state.finishResponse();
+  }, "finish");
+  response.once("finish", finish);
+  response.once("close", finish);
+  if (response.writableEnded) finishSoon(state);
+  registerPlatformLifetime(state, context);
+  return await afterStorage.run(state, handler);
+}
+__name(_runWithAfterNodeResponse, "_runWithAfterNodeResponse");
+function _withAfterNodeMiddleware(handler) {
+  return async (request, response, next) => {
+    await _runWithAfterNodeResponse(response, () => handler(request, response, next));
+  };
+}
+__name(_withAfterNodeMiddleware, "_withAfterNodeMiddleware");
+
+// src/api/vite-plugin.ts
+function farmApiPlugin(options = {}) {
+  const srcDir = options.srcDir ?? "src";
+  const debug = options.debug ?? false;
+  let apiRoutesCache = /* @__PURE__ */ new Map();
+  let apiRouterHandler = null;
+  let discoveryComplete = false;
+  let discoveryPromise = null;
+  const log = /* @__PURE__ */ __name((_message) => {
+  }, "log");
+  const logResponse = /* @__PURE__ */ __name((method, urlPath, status, duration) => {
+    try {
+      const pc = require("picocolors");
+      let statusColor = pc.green;
+      if (status >= 500) statusColor = pc.red;
+      else if (status >= 400) statusColor = pc.yellow;
+      else if (status >= 300) statusColor = pc.cyan;
+      const logMsg = [
+        pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
+        pc.dim("[") + pc.bold(pc.cyan("API")) + pc.dim("]"),
+        pc.dim("[") + pc.bold(pc.white(method.padEnd(3))) + pc.dim("]"),
+        pc.gray(urlPath),
+        pc.dim("-"),
+        statusColor(status.toString()),
+        pc.dim(`(${duration}ms)`)
+      ].join(" ");
+      console.log(logMsg);
+    } catch {
+      console.log(`[FARM] [API] [${method}] ${urlPath} - ${status} (${duration}ms)`);
+    }
+  }, "logResponse");
+  const addEndpoint = /* @__PURE__ */ __name((routePath, filePath, method, endpoint) => {
+    const normalizedMethod = method.toUpperCase();
+    const existing = apiRoutesCache.get(routePath);
+    if (existing) {
+      if (!existing.methods.includes(normalizedMethod)) {
+        existing.methods.push(normalizedMethod);
+      }
+      existing.endpoints[normalizedMethod] = endpoint;
+      return;
+    }
+    apiRoutesCache.set(routePath, {
+      path: routePath,
+      filePath,
+      methods: [normalizedMethod],
+      endpoints: { [normalizedMethod]: endpoint }
+    });
+  }, "addEndpoint");
+  const createRouter = /* @__PURE__ */ __name(async () => {
+    const totalEndpoints = Array.from(apiRoutesCache.values()).reduce(
+      (sum, route) => sum + route.methods.length,
+      0
+    );
+    apiRouterHandler = null;
+    if (totalEndpoints > 0) {
+      apiRouterHandler = /* @__PURE__ */ __name(async (request) => {
+        const url = new URL(request.url);
+        const method = request.method.toUpperCase();
+        const pathname = url.pathname;
+        const match = matchAPIRoute(apiRoutesCache, pathname);
+        if (!match) {
+          return new Response(JSON.stringify({ error: "Not Found" }), {
+            status: 404,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        const { route, params } = match;
+        const endpoint = route.endpoints[method];
+        if (!endpoint) {
+          return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+            status: 405,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        try {
+          return await invokeAPIRouteEndpoint(endpoint, request, params);
+        } catch (error) {
+          return new Response(JSON.stringify({ error: error.message || "Internal Server Error" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      }, "apiRouterHandler");
+      log(`API router created with ${totalEndpoints} endpoints`);
+    }
+  }, "createRouter");
+  return {
+    name: "@farm.js/core:api",
+    enforce: "pre",
+    configureServer(server) {
+      const discoverFileRoutes = /* @__PURE__ */ __name(async (apiDir) => {
+        const fs2 = await import("fs");
+        const path4 = await import("path");
+        if (!fs2.existsSync(apiDir)) {
+          log("No api directory found");
+          return;
+        }
+        const findRouteFiles = /* @__PURE__ */ __name((dir) => {
+          const files = [];
+          if (!fs2.existsSync(dir)) return files;
+          const entries = fs2.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path4.join(dir, entry.name);
+            if (entry.isDirectory()) {
+              files.push(...findRouteFiles(fullPath));
+            } else if (entry.name === "route.ts" || entry.name === "route.tsx" || entry.name === "route.js") {
+              files.push(fullPath);
+            }
+          }
+          return files;
+        }, "findRouteFiles");
+        const routeFiles = findRouteFiles(apiDir);
+        apiRoutesCache.clear();
+        for (const filePath of routeFiles) {
+          try {
+            const relativePath = path4.relative(apiDir, path4.dirname(filePath));
+            const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
+            const routeModule = await server.ssrLoadModule(filePath);
+            const endpoints = {};
+            const availableMethods = [];
+            for (const method of API_ROUTE_METHODS) {
+              if (routeModule[method]) {
+                availableMethods.push(method);
+                endpoints[method] = routeModule[method];
+              }
+            }
+            if (availableMethods.length > 0) {
+              apiRoutesCache.set(routePath, {
+                path: routePath,
+                filePath,
+                methods: availableMethods,
+                endpoints
+              });
+              log(`API route discovered: ${availableMethods.join(", ")} ${routePath}`);
+            }
+          } catch (e) {
+            log(`API route load failed at ${filePath}: ${e.message}`);
+          }
+        }
+      }, "discoverFileRoutes");
+      const discoverRootRoutes = /* @__PURE__ */ __name(async () => {
+        const fs2 = await import("fs");
+        const path4 = await import("path");
+        const routesFiles = [
+          path4.join(server.config.root, srcDir, "routes.ts"),
+          path4.join(server.config.root, srcDir, "routes.tsx"),
+          path4.join(server.config.root, srcDir, "routes.js")
+        ];
+        for (const routesFile of routesFiles) {
+          if (fs2.existsSync(routesFile)) {
+            try {
+              const routesModule = await server.ssrLoadModule(routesFile);
+              for (const [exportName, exportValue] of Object.entries(routesModule)) {
+                const endpoint = exportValue;
+                if (endpoint && endpoint.__path) {
+                  const routePath = endpoint.__path;
+                  const method = String(endpoint.__method || "GET").toUpperCase();
+                  addEndpoint(routePath, routesFile, method, endpoint);
+                  log(`Root route discovered: ${method} ${routePath}`);
+                }
+              }
+            } catch (e) {
+              log(`Root routes.ts load failed: ${e.message}`);
+            }
+            break;
+          }
+        }
+      }, "discoverRootRoutes");
+      const discoverProgrammaticRoutes = /* @__PURE__ */ __name(async () => {
+        const path4 = await import("path");
+        const srcRoot = path4.join(server.config.root, srcDir);
+        const routeFiles = findProgrammaticRouteFilesInDir(srcRoot);
+        for (const routeFile of routeFiles) {
+          try {
+            const routesModule = await server.ssrLoadModule(
+              toViteModuleId(routeFile, server.config.root)
+            );
+            const manifest = getProgrammaticRouteManifest(routesModule);
+            if (!manifest) continue;
+            for (const definition of manifest.routes) {
+              if (definition.kind !== "api") continue;
+              for (const [method, endpoint] of Object.entries(definition.methods)) {
+                if (endpoint) {
+                  addEndpoint(definition.path, routeFile, method, endpoint);
+                  log(`Programmatic route discovered: ${method} ${definition.path}`);
+                }
+              }
+            }
+          } catch (e) {
+            log(`Programmatic routes file load failed at ${routeFile}: ${e.message}`);
+          }
+        }
+      }, "discoverProgrammaticRoutes");
+      const initializeDiscovery = /* @__PURE__ */ __name(async () => {
+        const path4 = await import("path");
+        const apiDir = path4.join(server.config.root, srcDir, "api");
+        log(`Discovering API routes in: ${apiDir}`);
+        await discoverFileRoutes(apiDir);
+        await discoverRootRoutes();
+        await discoverProgrammaticRoutes();
+        await createRouter();
+        discoveryComplete = true;
+        log(`API discovery complete: ${apiRoutesCache.size} routes found`);
+      }, "initializeDiscovery");
+      discoveryPromise = initializeDiscovery().catch((e) => {
+        console.error("[FARM] API discovery error:", e);
+      });
+      server.__farmApi__ = {
+        getHandler: /* @__PURE__ */ __name(() => apiRouterHandler, "getHandler"),
+        getRoutes: /* @__PURE__ */ __name(() => apiRoutesCache, "getRoutes"),
+        isReady: /* @__PURE__ */ __name(() => discoveryComplete, "isReady"),
+        waitForDiscovery: /* @__PURE__ */ __name(() => discoveryPromise, "waitForDiscovery")
+      };
+      return () => {
+        server.middlewares.use(
+          _withAfterNodeMiddleware(async (req, res, next) => {
+            const url = req.url || "/";
+            const pathname = url.split("?")[0];
+            const method = req.method || "GET";
+            if (discoveryPromise && !discoveryComplete) {
+              await discoveryPromise;
+            }
+            if (!matchAPIRoute(apiRoutesCache, pathname)) {
+              return next();
+            }
+            if (!apiRouterHandler) {
+              return next();
+            }
+            const startTime = Date.now();
+            try {
+              const farmMiddleware = server.__farmMiddleware__;
+              if (farmMiddleware) {
+                await farmMiddleware.waitForDiscovery?.();
+                const middlewareData = /* @__PURE__ */ new Map();
+                const handled = await farmMiddleware.execute(req, res, pathname, middlewareData);
+                if (handled) {
+                  const duration2 = Date.now() - startTime;
+                  logResponse(method, pathname, res.statusCode || 200, duration2);
+                  return;
+                }
+              }
+              const fullUrl = `http://${req.headers.host || "localhost:3000"}${url}`;
+              const headers = new Headers();
+              for (const [key, value] of Object.entries(req.headers)) {
+                if (value) {
+                  headers.set(key, Array.isArray(value) ? value.join(", ") : value);
+                }
+              }
+              let body;
+              if (method !== "GET" && method !== "HEAD") {
+                body = await new Promise((resolve) => {
+                  let data = "";
+                  req.on("data", (chunk) => {
+                    data += chunk;
+                  });
+                  req.on("end", () => {
+                    resolve(data);
+                  });
+                });
+              }
+              const request = new Request(fullUrl, {
+                method,
+                headers,
+                body: body || void 0
+              });
+              const response = await apiRouterHandler(request);
+              const duration = Date.now() - startTime;
+              logResponse(method, pathname, response.status, duration);
+              await sendWebResponse(res, response);
+            } catch (error) {
+              const duration = Date.now() - startTime;
+              logResponse(method, pathname, 500, duration);
+              console.error("[FARM] API error:", error);
+              res.statusCode = 500;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: "Internal server error" }));
+            }
+          })
+        );
+      };
+    },
+    async handleHotUpdate({ file, server, modules }) {
+      const fileName = file.split("/").pop() || "";
+      if (fileName === "routes.ts" || fileName === "routes.tsx" || fileName === "routes.js" || isProgrammaticRoutesFileName(fileName)) {
+        log(`Root routes file updated: ${fileName}`);
+        for (const mod of modules) {
+          server.moduleGraph.invalidateModule(mod);
+        }
+        for (const [routePath, route] of apiRoutesCache) {
+          if (route.filePath === file) {
+            apiRoutesCache.delete(routePath);
+          }
+        }
+        try {
+          const routesModule = await server.ssrLoadModule(file);
+          for (const [exportName, exportValue] of Object.entries(routesModule)) {
+            const endpoint = exportValue;
+            if (endpoint && endpoint.__path) {
+              const routePath = endpoint.__path;
+              const method = String(endpoint.__method || "GET").toUpperCase();
+              addEndpoint(routePath, file, method, endpoint);
+              log(`Root route reloaded: ${method} ${routePath}`);
+            }
+          }
+          const manifest = getProgrammaticRouteManifest(routesModule);
+          if (manifest) {
+            for (const definition of manifest.routes) {
+              if (definition.kind !== "api") continue;
+              for (const [method, endpoint] of Object.entries(definition.methods)) {
+                if (endpoint) {
+                  addEndpoint(definition.path, file, method, endpoint);
+                  log(`Programmatic route reloaded: ${method} ${definition.path}`);
+                }
+              }
+            }
+          }
+          await createRouter();
+          log(`API router recreated`);
+        } catch (e) {
+          log(`Root routes.ts HMR failed: ${e.message}`);
+        }
+        return [];
+      }
+      if (file.includes("/api/") && fileName.startsWith("route.")) {
+        const shortPath = file.split("/api/")[1] || file;
+        log(`API route updated: ${shortPath}`);
+        for (const mod of modules) {
+          server.moduleGraph.invalidateModule(mod);
+        }
+        let routePathToUpdate = null;
+        for (const [routePath, route] of apiRoutesCache) {
+          if (route.filePath === file) {
+            routePathToUpdate = routePath;
+            break;
+          }
+        }
+        if (routePathToUpdate) {
+          try {
+            const routeModule = await server.ssrLoadModule(file);
+            const endpoints = {};
+            const availableMethods = [];
+            for (const method of API_ROUTE_METHODS) {
+              if (routeModule[method]) {
+                availableMethods.push(method);
+                endpoints[method] = routeModule[method];
+              }
+            }
+            if (availableMethods.length > 0) {
+              apiRoutesCache.set(routePathToUpdate, {
+                path: routePathToUpdate,
+                filePath: file,
+                methods: availableMethods,
+                endpoints
+              });
+              log(`API route reloaded: ${routePathToUpdate}`);
+              await createRouter();
+              log(`API router recreated`);
+            }
+          } catch (e) {
+            log(`API route HMR failed: ${e.message}`);
+          }
+        } else {
+          try {
+            const path4 = await import("path");
+            const apiDir = path4.join(server.config.root, srcDir, "api");
+            const relativePath = path4.relative(apiDir, path4.dirname(file));
+            const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
+            const routeModule = await server.ssrLoadModule(file);
+            const endpoints = {};
+            const availableMethods = [];
+            for (const method of API_ROUTE_METHODS) {
+              if (routeModule[method]) {
+                availableMethods.push(method);
+                endpoints[method] = routeModule[method];
+              }
+            }
+            if (availableMethods.length > 0) {
+              apiRoutesCache.set(routePath, {
+                path: routePath,
+                filePath: file,
+                methods: availableMethods,
+                endpoints
+              });
+              log(`New API route discovered: ${routePath}`);
+              await createRouter();
+            }
+          } catch (e) {
+            log(`New API route load failed: ${e.message}`);
+          }
+        }
+        return [];
+      }
+    }
+  };
+}
+__name(farmApiPlugin, "farmApiPlugin");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIClientError,
+  APIRouteManager,
+  API_ROUTE_METHODS,
+  DELETE,
+  EndpointFailure,
+  FARM_API_ROUTE_META_SYMBOL,
+  FARM_API_ROUTE_REF_SYMBOL,
+  GET,
+  HEAD,
+  OPTIONS,
+  PATCH,
+  POST,
+  PUT,
+  createAPIClient,
+  createEndpoint,
+  createServerAPIClient,
+  farmApiPlugin,
+  getAPIRouteRefMetadata,
+  invokeAPIRouteEndpoint,
+  isAPIRouteRef,
+  isEndpointFailure,
+  isFarmAPIStream,
+  isJSONStreamResponse,
+  isMultipartSchema,
+  isWebResponse,
+  jsonStream,
+  matchAPIRoute,
+  multipart,
+  normalizeRouteResponse,
+  readJSONStream,
+  toFormData
+});
+//# sourceMappingURL=api.cjs.map