@farm.js/core 0.1.16 → 0.1.18

package/dist/api/runtime.cjs

@@ -1,2684 +1,53 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/api/runtime.ts
-var runtime_exports = {};
-__export(runtime_exports, {
-  API_ROUTE_METHODS: () => API_ROUTE_METHODS,
-  createEndpointFailureResponse: () => createEndpointFailureResponse,
-  createStaticAPIRouteMatcherAtBasePath: () => createStaticAPIRouteMatcherAtBasePath,
-  getAllowedAPIRouteMethods: () => getAllowedAPIRouteMethods,
-  invokeAPIRouteEndpoint: () => invokeAPIRouteEndpoint,
-  isFarmAPIPathname: () => isFarmAPIPathname,
-  isWebResponse: () => isWebResponse,
-  matchAPIRoute: () => matchAPIRoute,
-  matchAPIRouteAtBasePath: () => matchAPIRouteAtBasePath,
-  mergePluginAPIRoutes: () => mergePluginAPIRoutes,
-  normalizeRouteResponse: () => normalizeRouteResponse,
-  parseRouteSchema: () => parseRouteSchema,
-  registerAPIRouteShape: () => registerAPIRouteShape,
-  resolveAPIRouteEndpoint: () => resolveAPIRouteEndpoint
-});
-module.exports = __toCommonJS(runtime_exports);
 
-// src/server/request.ts
-var import_node_async_hooks = require("async_hooks");
-var import_node_stream = require("stream");
 
-// 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 getRequestStore() {
-  const runtime3 = globalThis;
-  const existing = runtime3[REQUEST_STORAGE_KEY];
-  if (existing instanceof import_node_async_hooks.AsyncLocalStorage) {
-    return existing;
-  }
-  const storage = new import_node_async_hooks.AsyncLocalStorage();
-  runtime3[REQUEST_STORAGE_KEY] = storage;
-  return storage;
-}
-__name(getRequestStore, "getRequestStore");
-var requestStore = getRequestStore();
-_setCurrentRequestResolver(() => requestStore.getStore());
-async function _runWithCurrentRequest(request, fn) {
-  return requestStore.run(request, fn);
-}
-__name(_runWithCurrentRequest, "_runWithCurrentRequest");
 
-// 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 warnFarmCacheListenerError(scope, error) {
-  const detail = error instanceof Error ? error.stack ?? error.message : String(error);
-  console.warn(`[farm:cache] ${scope} listener failed: ${detail}`);
-}
-__name(warnFarmCacheListenerError, "warnFarmCacheListenerError");
-function notifyFarmCacheInvalidation(key, source = "local") {
-  if (typeof key !== "string" || key.length === 0) return;
-  for (const listener of getFarmCacheInvalidationState().listeners) {
-    try {
-      listener(key, source);
-    } catch (error) {
-      warnFarmCacheListenerError("invalidation", error);
-    }
-  }
-}
-__name(notifyFarmCacheInvalidation, "notifyFarmCacheInvalidation");
-function notifyFarmCacheTask(task) {
-  for (const listener of getFarmCacheInvalidationState().taskListeners) {
-    try {
-      listener(task);
-    } catch (error) {
-      warnFarmCacheListenerError("task", error);
-    }
-  }
-}
-__name(notifyFarmCacheTask, "notifyFarmCacheTask");
-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");
 
-// src/api/endpoint.ts
-var import_better_call = require("better-call");
 
-// src/tracing.ts
-var import_api = require("@opentelemetry/api");
-var FARM_TRACER_NAME = "@farm.js/core";
-var ALL_SPAN_KINDS = [
-  "request",
-  "render",
-  "middleware",
-  "api",
-  "integration",
-  "storage",
-  "ppr",
-  "build",
-  "plugin"
-];
-var DEFAULT_IGNORED_PATHS = [
-  "/@vite/",
-  "/@fs/",
-  "/@id/",
-  "/@react-refresh",
-  "/node_modules/",
-  "/__vite",
-  "/.well-known/appspecific/"
-];
-var FARM_REQUEST_METHOD_CONTEXT_KEY = (0, import_api.createContextKey)("@farm.js/core/request-method");
-var TRACING_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/tracing-runtime/v1");
-var runtime = globalThis;
-var tracingState = runtime[TRACING_RUNTIME] ?? (runtime[TRACING_RUNTIME] = normalizeFarmTracingConfig(false));
-function normalizeFarmTracingConfig(config) {
-  if (!config) {
-    return {
-      enabled: false,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  if (config === true) {
-    return {
-      enabled: true,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  return {
-    enabled: config.enabled ?? true,
-    spans: new Set(config.spans ?? ALL_SPAN_KINDS),
-    recordEvents: config.recordEvents ?? true,
-    attributes: { ...config.attributes },
-    ignorePaths: [...DEFAULT_IGNORED_PATHS, ...config.ignorePaths ?? []]
-  };
-}
-__name(normalizeFarmTracingConfig, "normalizeFarmTracingConfig");
-function recordFarmEventTrace(event) {
-  if (!tracingState.enabled) return void 0;
-  const activeContext = import_api.context.active();
-  const activeSpan = import_api.trace.getSpan(activeContext);
-  const traceContext = getSpanTraceContext(activeSpan);
-  if (activeSpan && traceContext) {
-    if (event.type === "route.matched") {
-      const method = activeContext.getValue(FARM_REQUEST_METHOD_CONTEXT_KEY) ?? "HTTP";
-      activeSpan.updateName(`${method} ${event.route}`);
-      activeSpan.setAttribute("http.route", event.route);
-      activeSpan.setAttribute("farm.route", event.route);
-    }
-    if (tracingState.recordEvents) {
-      activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
-    }
-    const error = event.type === "request.error" ? void 0 : getEventError(event);
-    if (error !== void 0) {
-      if (event.type === "render.error") {
-        recordSpanException(activeSpan, error);
-      } else {
-        recordSpanError(activeSpan, error);
-      }
-    }
-  }
-  const completedTraceContext = recordCompletedEventSpan(event, activeContext);
-  return traceContext ?? completedTraceContext;
-}
-__name(recordFarmEventTrace, "recordFarmEventTrace");
-function recordCompletedEventSpan(event, parentContext) {
-  const descriptor = getCompletedSpanDescriptor(event);
-  if (!descriptor || !tracingState.spans.has(descriptor.kind)) return void 0;
-  const tracer = import_api.trace.getTracer(FARM_TRACER_NAME);
-  const span = tracer.startSpan(
-    descriptor.name,
-    {
-      kind: import_api.SpanKind.INTERNAL,
-      startTime: event.timestamp - descriptor.durationMs,
-      attributes: {
-        ...tracingState.attributes,
-        ...toEventAttributes(event),
-        "farm.event.type": event.type
-      }
-    },
-    parentContext
-  );
-  const status = "status" in event && typeof event.status === "number" ? event.status : void 0;
-  if (status !== void 0) setResponseStatus(span, status);
-  const error = getEventError(event);
-  if (error !== void 0) recordSpanError(span, error);
-  const traceContext = getSpanTraceContext(span);
-  span.end(event.timestamp);
-  return traceContext;
-}
-__name(recordCompletedEventSpan, "recordCompletedEventSpan");
-function getCompletedSpanDescriptor(event) {
-  if (!("durationMs" in event) || typeof event.durationMs !== "number") return void 0;
-  switch (event.type) {
-    case "render.complete":
-      return { kind: "render", name: `farm.render ${event.route}`, durationMs: event.durationMs };
-    case "render.stream.shellReady":
-      return {
-        kind: "render",
-        name: `farm.render.shell ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "render.stream.complete":
-      return {
-        kind: "render",
-        name: `farm.render.stream ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "middleware.complete":
-      return {
-        kind: "middleware",
-        name: `farm.middleware ${event.name ?? event.route ?? "anonymous"}`,
-        durationMs: event.durationMs
-      };
-    case "api.request.complete":
-    case "api.error":
-      return {
-        kind: "api",
-        name: `farm.api ${event.method} ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "integration.api.call.complete":
-      return {
-        kind: "integration",
-        name: `farm.integration ${event.integration}.${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "storage.query.complete":
-      return {
-        kind: "storage",
-        name: `farm.storage ${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "ppr.refresh.complete":
-      return {
-        kind: "ppr",
-        name: `farm.ppr.refresh ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "build.complete":
-      return {
-        kind: "build",
-        name: `farm.build${event.target ? ` ${event.target}` : ""}`,
-        durationMs: event.durationMs
-      };
-    case "plugin.hook.complete":
-      return {
-        kind: "plugin",
-        name: `farm.plugin ${event.plugin}.${event.hook}`,
-        durationMs: event.durationMs
-      };
-    default:
-      return void 0;
-  }
-}
-__name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
-function hashFarmCacheKey(value) {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index++) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-__name(hashFarmCacheKey, "hashFarmCacheKey");
-function toEventAttributes(event) {
-  const attributes = {};
-  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
-  for (const [key, value] of Object.entries(event)) {
-    if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
-      continue;
-    }
-    if (redactKey && key === "key" && typeof value === "string") {
-      attributes["farm.key_hash"] = hashFarmCacheKey(value);
-      continue;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      attributes[`farm.${key}`] = value;
-    } else if (Array.isArray(value)) {
-      if (value.every((entry) => typeof entry === "string")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "number")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "boolean")) {
-        attributes[`farm.${key}`] = value;
-      }
-    }
-  }
-  return attributes;
-}
-__name(toEventAttributes, "toEventAttributes");
-function getEventError(event) {
-  return "error" in event ? event.error : void 0;
-}
-__name(getEventError, "getEventError");
-function recordSpanException(span, error) {
-  const normalized = error instanceof Error ? error : new Error(String(error));
-  span.recordException(normalized);
-  return normalized;
-}
-__name(recordSpanException, "recordSpanException");
-function recordSpanError(span, error) {
-  const normalized = recordSpanException(span, error);
-  span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: normalized.message });
-}
-__name(recordSpanError, "recordSpanError");
-function setResponseStatus(span, status) {
-  span.setAttribute("http.response.status_code", status);
-  if (status >= 500) {
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR });
-  }
-}
-__name(setResponseStatus, "setResponseStatus");
-function getSpanTraceContext(span) {
-  if (!span) return void 0;
-  const spanContext = span.spanContext();
-  if (!(0, import_api.isSpanContextValid)(spanContext)) return void 0;
-  return {
-    traceId: spanContext.traceId,
-    spanId: spanContext.spanId,
-    traceSampled: (spanContext.traceFlags & 1) === 1
-  };
-}
-__name(getSpanTraceContext, "getSpanTraceContext");
 
-// src/observability.ts
-var OBSERVABILITY_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/observability-runtime/v1");
-var runtime2 = globalThis;
-var shared = runtime2[OBSERVABILITY_RUNTIME] ?? (runtime2[OBSERVABILITY_RUNTIME] = {
-  handlers: /* @__PURE__ */ new Set(),
-  unfilteredHandlers: /* @__PURE__ */ new Set(),
-  config: { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) }
-});
-var runtimeHandlers = shared.handlers;
-var unfilteredRuntimeHandlers = shared.unfilteredHandlers;
-var observabilityState = shared.config;
-function emitFarmEvent(input) {
-  const event = {
-    timestamp: Date.now(),
-    level: inferFarmEventLevel(input.type),
-    ...input
-  };
-  const traceContext = recordFarmEventTrace(event);
-  if (traceContext) {
-    event.traceId = traceContext.traceId;
-    event.spanId = traceContext.spanId;
-    event.traceSampled = traceContext.traceSampled;
-  }
-  notifyFarmEventHandlers(event, unfilteredRuntimeHandlers);
-  if (!shouldEmitFarmEvent(event)) return event;
-  if (observabilityState.logs) {
-    logFarmEvent(event);
-  }
-  notifyFarmEventHandlers(event, [...observabilityState.handlers, ...runtimeHandlers]);
-  return event;
-}
-__name(emitFarmEvent, "emitFarmEvent");
-function notifyFarmEventHandlers(event, handlers) {
-  for (const handler of handlers) {
-    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)}`);
-    }
-  }
-}
-__name(notifyFarmEventHandlers, "notifyFarmEventHandlers");
-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",
-    "server",
-    "tool",
-    "outcome",
-    "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-stream.ts
-var MAX_BUFFERED_BYTES = 64 * 1024;
-var textEncoder = new TextEncoder();
 
-// 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.activeGenerations = /* @__PURE__ */ new Set();
-    this.version = 0;
-    this.generation = 0;
-    this.namespace = "farm";
-    this.local = true;
-    this.maxEntries = 1024;
-    this.lease = {
-      enabled: true,
-      ttlMs: 1e4,
-      waitTimeoutMs: 1e4,
-      pollIntervalMs: 25
-    };
-    this.configure(config);
-  }
-  configure(config = {}) {
-    this.generation++;
-    this.entries.clear();
-    this.inflight.clear();
-    this.invalidatedTagVersions.clear();
-    this.activeGenerations.clear();
-    this.version = 0;
-    this.adapter = config.adapter;
-    this.namespace = normalizeCacheNamespace(config.namespace || "farm");
-    this.local = !config.adapter;
-    this.maxEntries = normalizePositiveInteger(config.maxEntries, 1024, "cache.maxEntries");
-    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"
-      )
-    };
-  }
-  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;
-    }
-    this.touchEntry(key, entry);
-    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 generation = this.generation;
-    const adapter = this.adapter;
-    const namespace = this.namespace;
-    const entry = await adapter.get(`${namespace}:entry:${key}`);
-    if (generation !== this.generation) return void 0;
-    if (!entry) {
-      emitFarmEvent({ type: "cache.miss", key });
-      return void 0;
-    }
-    assertFarmCacheEntry(entry, key);
-    const stale = await this.isAdapterEntryStale(entry, options.now, adapter, namespace);
-    if (generation !== this.generation) return void 0;
-    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 revalidate = normalizeRevalidate(options.revalidate);
-    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
-    };
-    this.storeLocalEntry(entry);
-    emitFarmEvent({
-      type: "cache.set",
-      key,
-      tags: Array.from(tags),
-      revalidate: entry.revalidate
-    });
-    return this.toPublicEntry(entry);
-  }
-  async setAsync(key, value, options = {}, tagVersions) {
-    return this.writeAsync(key, value, options, tagVersions);
-  }
-  async writeAsync(key, value, options, tagVersions, createdVersion) {
-    const revalidate = normalizeRevalidate(options.revalidate);
-    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: createdVersion ?? ++this.version,
-      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);
-    if (deleted) this.pruneInvalidatedTagVersions();
-    emitFarmEvent({ type: "cache.delete", key, deleted });
-    return deleted;
-  }
-  async deleteAsync(key) {
-    const deleted = this.entries.delete(key);
-    if (deleted) this.pruneInvalidatedTagVersions();
-    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.generation++;
-    this.entries.clear();
-    this.inflight.clear();
-    this.invalidatedTagVersions.clear();
-    this.activeGenerations.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 = {}) {
-    normalizeRevalidate(options.revalidate);
-    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 generation = this.generation;
-    const promise = this.fillCacheEntry(key, producer, options, tags, generation).catch((error) => {
-      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
-      throw error;
-    }).finally(() => {
-      if (this.inflight.get(key) === promise) {
-        this.inflight.delete(key);
-      }
-    });
-    this.inflight.set(key, promise);
-    return promise;
-  }
-  async fillCacheEntry(key, producer, options, tags, generation) {
-    const adapter = this.adapter;
-    const namespace = this.namespace;
-    const lease = { ...this.lease };
-    const leaseKey = `${namespace}:lease:${key}`;
-    let leaseToken;
-    if (adapter?.acquireLease && adapter.releaseLease && lease.enabled) {
-      leaseToken = await adapter.acquireLease(leaseKey, lease.ttlMs);
-      if (!leaseToken) {
-        const shared2 = await this.waitForAdapterEntry(
-          key,
-          adapter,
-          namespace,
-          lease,
-          generation
-        );
-        if (shared2) {
-          emitFarmEvent({ type: "cache.dedupe", key });
-          return shared2.value;
-        }
-        if (generation === this.generation) {
-          leaseToken = await adapter.acquireLease(leaseKey, lease.ttlMs);
-        }
-      }
-    }
-    const initialCreatedVersion = this.version;
-    const activeGeneration = {
-      tags: new Set(tags),
-      createdVersion: initialCreatedVersion
-    };
-    this.activeGenerations.add(activeGeneration);
-    try {
-      const initialTagVersions = await this.getAdapterTagVersions(tags, adapter, namespace);
-      const value = await producer();
-      if (generation === this.generation) {
-        await this.writeAsync(key, value, options, initialTagVersions, initialCreatedVersion);
-      }
-      return value;
-    } finally {
-      this.activeGenerations.delete(activeGeneration);
-      this.pruneInvalidatedTagVersions();
-      if (leaseToken && adapter?.releaseLease) {
-        try {
-          await adapter.releaseLease(leaseKey, leaseToken);
-        } catch (error) {
-          emitFarmEvent({ type: "cache.error", key, operation: "set", error });
-        }
-      }
-    }
-  }
-  async waitForAdapterEntry(key, adapter, namespace, lease, generation) {
-    const deadline = Date.now() + lease.waitTimeoutMs;
-    while (Date.now() < deadline) {
-      await delay(lease.pollIntervalMs);
-      if (generation !== this.generation) return void 0;
-      const entry = await adapter.get(`${namespace}:entry:${key}`);
-      if (generation !== this.generation) return void 0;
-      if (!entry) {
-        emitFarmEvent({ type: "cache.miss", key });
-        continue;
-      }
-      assertFarmCacheEntry(entry, key);
-      const stale = await this.isAdapterEntryStale(entry, Date.now(), adapter, namespace);
-      if (generation !== this.generation) return void 0;
-      if (stale) {
-        emitFarmEvent({
-          type: "cache.stale",
-          key,
-          tags: [...entry.tags],
-          revalidate: entry.revalidate
-        });
-        emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-      } else {
-        emitFarmEvent({
-          type: "cache.hit",
-          key,
-          tags: [...entry.tags],
-          revalidate: entry.revalidate,
-          stale: false
-        });
-        return { ...entry, key };
-      }
-    }
-    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) {
-    const count = this.countEntriesForTag(normalizedTag);
-    this.invalidatedTagVersions.delete(normalizedTag);
-    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
-    this.pruneInvalidatedTagVersions();
-    return count;
-  }
-  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.storeLocalEntry({
-      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)
-    });
-  }
-  touchEntry(key, entry) {
-    this.entries.delete(key);
-    this.entries.set(key, entry);
-  }
-  storeLocalEntry(entry) {
-    this.entries.delete(entry.key);
-    this.entries.set(entry.key, entry);
-    while (this.entries.size > this.maxEntries) {
-      const oldestKey = this.entries.keys().next().value;
-      if (oldestKey === void 0) break;
-      this.entries.delete(oldestKey);
-    }
-    this.pruneInvalidatedTagVersions();
-  }
-  pruneInvalidatedTagVersions() {
-    tags: for (const [tag, invalidatedVersion] of this.invalidatedTagVersions) {
-      for (const entry of this.entries.values()) {
-        if (entry.tags.has(tag) && entry.createdVersion < invalidatedVersion) continue tags;
-      }
-      for (const generation of this.activeGenerations) {
-        if (generation.tags.has(tag) && generation.createdVersion < invalidatedVersion)
-          continue tags;
-      }
-      this.invalidatedTagVersions.delete(tag);
-    }
-  }
-  createAdapterKey(key) {
-    return `${this.namespace}:entry:${key}`;
-  }
-  createAdapterTag(tag) {
-    return `${this.namespace}:tag:${tag}`;
-  }
-  async getAdapterTagVersions(tags, adapter = this.adapter, namespace = this.namespace) {
-    if (!adapter?.getTagVersions || tags.length === 0) return {};
-    const normalized = tags.map(normalizeCacheTag);
-    const physicalTags = normalized.map((tag) => `${namespace}:tag:${tag}`);
-    const versions = await adapter.getTagVersions(physicalTags);
-    return Object.fromEntries(
-      normalized.map((tag, index) => [
-        tag,
-        normalizeAdapterVersion(versions[physicalTags[index]])
-      ])
-    );
-  }
-  async isAdapterEntryStale(entry, now = Date.now(), adapter = this.adapter, namespace = this.namespace) {
-    if (typeof entry.revalidate === "number" && entry.revalidate >= 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
-      return true;
-    }
-    const currentVersions = await this.getAdapterTagVersions(entry.tags, adapter, namespace);
-    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());
-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?:\/\//i.test(normalized)) {
-      normalized = new URL(normalized).pathname;
-    }
-  } catch {
-  }
-  normalized = normalized.split(/[?#]/, 1)[0] ?? normalized;
-  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
-  normalized = normalized.replace(/\/{2,}/g, "/");
-  normalized = new URL(normalized, "http://farm.invalid").pathname;
-  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) {
-    throw new TypeError("Cache revalidate must be false or a finite, non-negative number.");
-  }
-  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 normalizePositiveInteger(value, fallback, name) {
-  if (value === void 0) return fallback;
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new TypeError(`${name} must be a positive integer.`);
-  }
-  return value;
-}
-__name(normalizePositiveInteger, "normalizePositiveInteger");
-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) {
-  const name = fn.name || "anonymous";
-  return `${name}:${hashFunctionSource(String(fn))}`;
-}
-__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
-function hashFunctionSource(source) {
-  let hash = 2166136261;
-  for (let index = 0; index < source.length; index++) {
-    hash ^= source.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36);
-}
-__name(hashFunctionSource, "hashFunctionSource");
-function compareCodepoint(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-__name(compareCodepoint, "compareCodepoint");
-function serializeBinaryBytes(bytes) {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-__name(serializeBinaryBytes, "serializeBinaryBytes");
-function serializeCanonicalStringEntries(entries, seen) {
-  const valuesByKey = /* @__PURE__ */ new Map();
-  for (const [key, item] of entries) {
-    const values = valuesByKey.get(key);
-    if (values) values.push(item);
-    else valuesByKey.set(key, [item]);
-  }
-  return Array.from(valuesByKey.keys()).sort(compareCodepoint).flatMap(
-    (key) => valuesByKey.get(key).map((item) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`)
-  ).join(",");
-}
-__name(serializeCanonicalStringEntries, "serializeCanonicalStringEntries");
-function isPlainCacheKeyObject(value) {
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype === null) return true;
-  const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
-  return Object.getPrototypeOf(prototype) === null && typeof constructor === "function" && constructor.name === "Object";
-}
-__name(isPlainCacheKeyObject, "isPlainCacheKeyObject");
-function getCacheKeyValueType(value) {
-  const prototype = Object.getPrototypeOf(value);
-  const constructor = prototype ? Object.getOwnPropertyDescriptor(prototype, "constructor")?.value : void 0;
-  if (typeof constructor === "function" && constructor.name) {
-    return constructor.name;
-  }
-  return Object.prototype.toString.call(value).slice(8, -1) || "object";
-}
-__name(getCacheKeyValueType, "getCacheKeyValueType");
-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 Number.isNaN(value.getTime()) ? "date:invalid" : `date:${value.toISOString()}`;
-  }
-  if (value instanceof URL) {
-    return `url:${value.toString()}`;
-  }
-  if (value instanceof RegExp) {
-    return `regexp:${value.toString()}`;
-  }
-  if (value instanceof ArrayBuffer) {
-    return `arraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
-  }
-  if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
-    return `sharedarraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
-  }
-  if (ArrayBuffer.isView(value)) {
-    const viewType = Object.prototype.toString.call(value).slice(8, -1);
-    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-    return `binary:${viewType}:${serializeBinaryBytes(bytes)}`;
-  }
-  if (value && typeof value === "object") {
-    if (seen.has(value)) {
-      return "[Circular]";
-    }
-    seen.add(value);
-    if (Array.isArray(value)) {
-      const items = [];
-      for (let index = 0; index < value.length; index++) {
-        items.push(
-          Object.prototype.hasOwnProperty.call(value, index) ? stableSerialize(value[index], seen) : "[Hole]"
-        );
-      }
-      seen.delete(value);
-      return `[${items.join(",")}]`;
-    }
-    if (value instanceof Set) {
-      const items = Array.from(value, (item) => stableSerialize(item, seen)).sort(compareCodepoint);
-      seen.delete(value);
-      return `set:[${items.join(",")}]`;
-    }
-    if (value instanceof Map) {
-      const items = Array.from(
-        value,
-        ([key, item]) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`
-      ).sort(compareCodepoint);
-      seen.delete(value);
-      return `map:[${items.join(",")}]`;
-    }
-    if (value instanceof URLSearchParams) {
-      const serialized2 = serializeCanonicalStringEntries(value, seen);
-      seen.delete(value);
-      return `urlsearchparams:[${serialized2}]`;
-    }
-    if (value instanceof Headers) {
-      const serialized2 = serializeCanonicalStringEntries(value, seen);
-      seen.delete(value);
-      return `headers:[${serialized2}]`;
-    }
-    if (!isPlainCacheKeyObject(value)) {
-      throw new TypeError(
-        `Cache keys do not support ${getCacheKeyValueType(value)} values. Convert the value to an explicit stable string or structured key before caching.`
-      );
-    }
-    const entries = Object.entries(value).sort(
-      ([a], [b]) => compareCodepoint(a, 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 isMultipartSchema(value) {
-  return typeof value === "object" && value !== null && value.__farmMultipartSchema === true && typeof value.parse === "function";
-}
-__name(isMultipartSchema, "isMultipartSchema");
 
-// 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 path;
-  let options;
-  let handler;
-  if (typeof pathOrOptions === "function") {
-    path = "";
-    options = {};
-    handler = pathOrOptions;
-  } else if (typeof pathOrOptions === "string") {
-    path = pathOrOptions;
-    options = optionsOrHandler;
-    handler = maybeHandler;
-  } else {
-    path = "";
-    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 error = createEndpointErrorHandler(errors);
-  const wrappedHandler = /* @__PURE__ */ __name((async (ctx) => {
-    const execution = await runEndpointMiddleware(
-      middleware,
-      ctx,
-      handler,
-      error,
-      options.invalidates
-    );
-    return execution.result;
-  }), "wrappedHandler");
-  const {
-    middleware: _middleware,
-    errors: _errors,
-    invalidates: _invalidates,
-    openapi: _openapi,
-    mcp: _mcp,
-    ...betterCallOptions
-  } = options;
-  const endpoint = (0, import_better_call.createEndpoint)(
-    path || "/__farm_auto_path__",
-    betterCallOptions,
-    wrappedHandler
-  );
-  endpoint.__path = path || void 0;
-  endpoint.__method = options.method || "GET";
-  endpoint.__autoPath = !path;
-  endpoint.__handler = wrappedHandler;
-  endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, error, options.invalidates);
-  endpoint.__middleware = middleware;
-  endpoint.__sourceHandler = handler;
-  endpoint.__invalidates = options.invalidates;
-  endpoint.__errors = errors;
-  endpoint.__openapi = options.openapi;
-  endpoint.__mcp = options.mcp;
-  endpoint.__types = {
-    body: options.body,
-    inputBody: isMultipartSchema(options.body) ? "form-data" : options.body,
-    query: options.query,
-    inputQuery: 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`);
-    }
-    const dataSchema = resolveEndpointErrorSchema(definition);
-    if (!dataSchema || typeof dataSchema.parse !== "function") {
-      throw new TypeError(`Endpoint error "${code}" requires a data 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 resolveEndpointErrorSchema(definition) {
-  if (definition.data && definition.schema) {
-    throw new TypeError("Endpoint errors cannot define both data and schema");
-  }
-  return definition.data ?? definition.schema;
-}
-__name(resolveEndpointErrorSchema, "resolveEndpointErrorSchema");
-function createEndpointErrorHandler(definitions) {
-  return ((code, data) => {
-    const definition = definitions[code];
-    if (!definition) {
-      throw new TypeError(`Endpoint error "${code}" is not declared`);
-    }
-    const parsed = resolveEndpointErrorSchema(definition).parse(data);
-    throw new EndpointFailure(code, parsed, {
-      status: definition.status,
-      message: definition.message ?? "Request failed"
-    });
-  });
-}
-__name(createEndpointErrorHandler, "createEndpointErrorHandler");
-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, error, invalidations) {
-  let context2 = createInitialEndpointContext(handlerContext.context);
-  for (let index = 0; index < middleware.length; index++) {
-    const result2 = await middleware[index]({ ...handlerContext, context: context2 });
-    if (isEndpointResponse(result2)) {
-      return {
-        result: result2,
-        context: context2,
-        handlerExecuted: false,
-        invalidations: []
-      };
-    }
-    if (result2 === false) {
-      return {
-        result: forbiddenEndpointResponse(),
-        context: context2,
-        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`
-      );
-    }
-    context2 = mergeEndpointContext(context2, result2, index);
-  }
-  const result = await handler({ ...handlerContext, context: context2, error, fail: error });
-  return {
-    result,
-    context: context2,
-    handlerExecuted: true,
-    invalidations: await applyEndpointInvalidations(
-      invalidations,
-      {
-        ...handlerContext,
-        context: context2,
-        result
-      },
-      result
-    )
-  };
-}
-__name(runEndpointMiddleware, "runEndpointMiddleware");
-async function applyEndpointInvalidations(declaration, context2, result) {
-  if (!declaration || isEndpointResponse(result) && result.status >= 400) {
-    return [];
-  }
-  const targets = typeof declaration === "function" ? await declaration(context2) : 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");
+var _chunk4PNUXIVUcjs = require('../chunk-4PNUXIVU.cjs');
+require('../chunk-WPYFSQKK.cjs');
 
-// src/routing/specificity.ts
-var _AmbiguousRouteError = class _AmbiguousRouteError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AmbiguousRouteError";
-  }
-};
-__name(_AmbiguousRouteError, "AmbiguousRouteError");
-var AmbiguousRouteError = _AmbiguousRouteError;
-var _NonTerminalCatchAllRouteError = class _NonTerminalCatchAllRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "NonTerminalCatchAllRouteError";
-  }
-};
-__name(_NonTerminalCatchAllRouteError, "NonTerminalCatchAllRouteError");
-var NonTerminalCatchAllRouteError = _NonTerminalCatchAllRouteError;
-var _DuplicateRouteParameterError = class _DuplicateRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "DuplicateRouteParameterError";
-  }
-};
-__name(_DuplicateRouteParameterError, "DuplicateRouteParameterError");
-var DuplicateRouteParameterError = _DuplicateRouteParameterError;
-var _ReservedRouteParameterError = class _ReservedRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "ReservedRouteParameterError";
-  }
-};
-__name(_ReservedRouteParameterError, "ReservedRouteParameterError");
-var ReservedRouteParameterError = _ReservedRouteParameterError;
-var _BrowserUnstableRouteError = class _BrowserUnstableRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserUnstableRouteError";
-  }
-};
-__name(_BrowserUnstableRouteError, "BrowserUnstableRouteError");
-var BrowserUnstableRouteError = _BrowserUnstableRouteError;
-var SEGMENT_RANK = {
-  static: 4,
-  dynamic: 3,
-  "catch-all": 1,
-  "optional-catch-all": 0
-};
-var ROUTE_END_RANK = 2;
-function compareRouteSpecificity(left, right) {
-  const length = Math.max(left.length, right.length);
-  for (let index = 0; index < length; index++) {
-    const leftRank = index < left.length ? SEGMENT_RANK[left[index]] : ROUTE_END_RANK;
-    const rightRank = index < right.length ? SEGMENT_RANK[right[index]] : ROUTE_END_RANK;
-    if (leftRank !== rightRank) return rightRank - leftRank;
-  }
-  return 0;
-}
-__name(compareRouteSpecificity, "compareRouteSpecificity");
-var ROUTER_PARAMETER_NAME = "[A-Za-z0-9_$-]+";
-var PAGE_PARAMETER_PATTERN = /^(?:\[\[\.\.\.(.+)\]\]|\[\.\.\.(.+)\]|\[(.+)\])$/;
-var ROUTER_PARAMETER_PATTERN = /^(?:\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]|\[\.\.\.([A-Za-z0-9_$-]+)\]|\[([A-Za-z0-9_$-]+)\]|:([A-Za-z0-9_$-]+)|\*([A-Za-z0-9_$-]+)\??)$/;
-var RESERVED_PARAMETER_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function assertBrowserStableRoutePath(pattern) {
-  if (pattern.includes("\\") || hasControlCharacter(pattern)) {
-    throw new BrowserUnstableRouteError(
-      `Route path "${pattern}" cannot contain backslashes or control characters.`
-    );
-  }
-  for (const segment of pattern.split("/").filter(Boolean)) {
-    if (segment.startsWith("(") && segment.endsWith(")") || segment.startsWith("[") && segment.endsWith("]")) {
-      continue;
-    }
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
-      throw new BrowserUnstableRouteError(
-        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
-      );
-    }
-  }
-}
-__name(assertBrowserStableRoutePath, "assertBrowserStableRoutePath");
-function hasControlCharacter(value) {
-  return Array.from(value).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  });
-}
-__name(hasControlCharacter, "hasControlCharacter");
-function assertUniqueRouteParameters(pattern, syntax = "page") {
-  const parameterPattern = syntax === "router" ? ROUTER_PARAMETER_PATTERN : PAGE_PARAMETER_PATTERN;
-  const names = /* @__PURE__ */ new Set();
-  for (const segment of splitRoutePattern(pattern, syntax)) {
-    const match = parameterPattern.exec(segment);
-    const name = match?.slice(1).find(Boolean);
-    if (!name) continue;
-    if (RESERVED_PARAMETER_NAMES.has(name)) {
-      throw new ReservedRouteParameterError(
-        `Route parameter "${name}" in route "${pattern}" is reserved. Use a different parameter name.`
-      );
-    }
-    if (names.has(name)) {
-      throw new DuplicateRouteParameterError(
-        `Duplicate route parameter "${name}" in route "${pattern}". Each dynamic segment must use a unique name.`
-      );
-    }
-    names.add(name);
-  }
-}
-__name(assertUniqueRouteParameters, "assertUniqueRouteParameters");
-function splitRoutePattern(pattern, syntax) {
-  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
-    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
-  );
-}
-__name(splitRoutePattern, "splitRoutePattern");
-function assertTerminalCatchAll(pattern, syntax = "page") {
-  const segments = splitRoutePattern(pattern, syntax);
-  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
-  const catchAllPattern = new RegExp(
-    syntax === "router" ? `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\]|\\*${parameterName}\\??)$` : `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\])$`
-  );
-  const catchAllIndex = segments.findIndex((segment) => catchAllPattern.test(segment));
-  if (catchAllIndex >= 0 && catchAllIndex !== segments.length - 1) {
-    throw new NonTerminalCatchAllRouteError(
-      `Catch-all segment "${segments[catchAllIndex]}" must be the final segment in route "${pattern}".`
-    );
-  }
-}
-__name(assertTerminalCatchAll, "assertTerminalCatchAll");
-function getRoutePatternShape(pattern, syntax = "page") {
-  assertTerminalCatchAll(pattern, syntax);
-  const segments = splitRoutePattern(pattern, syntax).map((segment) => {
-    const specificity = getPatternSegmentSpecificity(segment, syntax);
-    if (specificity !== "static") return specificity;
-    try {
-      return `static:${decodeURIComponent(segment)}`;
-    } catch {
-      return `static:${segment}`;
-    }
-  });
-  return segments.length === 0 ? "/" : JSON.stringify(segments);
-}
-__name(getRoutePatternShape, "getRoutePatternShape");
-function getPatternSegmentSpecificity(segment, syntax) {
-  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
-  const supportsColonAndStar = syntax === "router";
-  if (new RegExp(`^\\[\\[\\.\\.\\.${parameterName}\\]\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}\\?$`).test(segment)) {
-    return "optional-catch-all";
-  }
-  if (new RegExp(`^\\[\\.\\.\\.${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}$`).test(segment)) {
-    return "catch-all";
-  }
-  if (new RegExp(`^\\[${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^:${parameterName}$`).test(segment)) {
-    return "dynamic";
-  }
-  return "static";
-}
-__name(getPatternSegmentSpecificity, "getPatternSegmentSpecificity");
 
-// src/request-context.ts
-var REQUEST_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.requestContextStore");
-function getRequestContextStore() {
-  const globalState2 = globalThis;
-  if (!globalState2[REQUEST_CONTEXT_STORE_KEY]) {
-    globalState2[REQUEST_CONTEXT_STORE_KEY] = /* @__PURE__ */ new WeakMap();
-  }
-  return globalState2[REQUEST_CONTEXT_STORE_KEY];
-}
-__name(getRequestContextStore, "getRequestContextStore");
-function getBucket(target) {
-  const requestContextStore = getRequestContextStore();
-  let bucket = requestContextStore.get(target);
-  if (!bucket) {
-    bucket = {
-      privateData: /* @__PURE__ */ new Map(),
-      exposedData: /* @__PURE__ */ new Map()
-    };
-    requestContextStore.set(target, bucket);
-  }
-  return bucket;
-}
-__name(getBucket, "getBucket");
-function setRequestContext(target, key, value, options = {}) {
-  const bucket = getBucket(target);
-  bucket.privateData.set(key, value);
-  if (options.exposeToPage) {
-    bucket.exposedData.set(key, value);
-  }
-}
-__name(setRequestContext, "setRequestContext");
-function copyRequestContext(source, target) {
-  const bucket = getRequestContextStore().get(source);
-  if (!bucket || source === target) return;
-  for (const [key, value] of bucket.privateData) {
-    setRequestContext(target, key, value, { exposeToPage: bucket.exposedData.has(key) });
-  }
-}
-__name(copyRequestContext, "copyRequestContext");
+var _chunkI4J452B7cjs = require('../chunk-I4J452B7.cjs');
 
-// src/server-http.ts
-var DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = 1e7;
-var _FarmRequestBodyError = class _FarmRequestBodyError extends Error {
-  constructor(code, status, message) {
-    super(message);
-    this.name = "FarmRequestBodyError";
-    this.code = code;
-    this.status = status;
-  }
-};
-__name(_FarmRequestBodyError, "FarmRequestBodyError");
-var FarmRequestBodyError = _FarmRequestBodyError;
-async function bufferFarmRequestBody(request, limit) {
-  if (request.method === "GET" || request.method === "HEAD" || request.body === null) {
-    return request;
-  }
-  const bytes = await readFarmRequestBody(request, limit);
-  const body = new Uint8Array(bytes.byteLength);
-  body.set(bytes);
-  const buffered = new Request(request, {
-    // oxlint-disable-next-line unicorn/no-invalid-fetch-options -- GET and HEAD return above.
-    body: body.buffer
-  });
-  copyRequestContext(request, buffered);
-  return buffered;
-}
-__name(bufferFarmRequestBody, "bufferFarmRequestBody");
-async function readFarmRequestBody(request, limit) {
-  try {
-    validateContentLength(request.headers.get("content-length"), limit);
-  } catch (error) {
-    void request.body?.cancel(error).catch(() => {
-    });
-    throw error;
-  }
-  throwIfAborted(request.signal);
-  if (!request.body) return new Uint8Array();
-  const reader = request.body.getReader();
-  const chunks = [];
-  let total = 0;
-  const cancelBodyRead = /* @__PURE__ */ __name(() => {
-    void reader.cancel(request.signal.reason).catch(() => {
-    });
-  }, "cancelBodyRead");
-  request.signal.addEventListener("abort", cancelBodyRead, { once: true });
-  try {
-    while (true) {
-      throwIfAborted(request.signal);
-      const { done, value } = await reader.read();
-      throwIfAborted(request.signal);
-      if (done) break;
-      if (!value) continue;
-      total += value.byteLength;
-      if (total > limit) {
-        const error = new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
-        void reader.cancel(error).catch(() => {
-        });
-        throw error;
-      }
-      chunks.push(value);
-    }
-  } catch (error) {
-    if (request.signal.aborted) throwIfAborted(request.signal);
-    throw error;
-  } finally {
-    request.signal.removeEventListener("abort", cancelBodyRead);
-    reader.releaseLock();
-  }
-  const body = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return body;
-}
-__name(readFarmRequestBody, "readFarmRequestBody");
-function createFarmRequestBodyErrorResponse(error) {
-  if (!(error instanceof FarmRequestBodyError)) return null;
-  return new Response(error.status === 413 ? "Payload Too Large" : "Bad Request", {
-    status: error.status,
-    headers: {
-      "cache-control": "no-store",
-      "content-type": "text/plain; charset=utf-8",
-      "x-content-type-options": "nosniff"
-    }
-  });
-}
-__name(createFarmRequestBodyErrorResponse, "createFarmRequestBodyErrorResponse");
-function validateContentLength(value, limit) {
-  const contentLength = value?.trim();
-  if (!contentLength) return;
-  if (!/^\d+$/.test(contentLength)) {
-    throw new FarmRequestBodyError("INVALID_CONTENT_LENGTH", 400, "Invalid content-length header");
-  }
-  if (Number(contentLength) > limit) {
-    throw new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
-  }
-}
-__name(validateContentLength, "validateContentLength");
-function throwIfAborted(signal) {
-  if (!signal.aborted) return;
-  if (signal.reason !== void 0) throw signal.reason;
-  throw new DOMException("The operation was aborted", "AbortError");
-}
-__name(throwIfAborted, "throwIfAborted");
 
-// src/api/config.ts
-var DEFAULT_FARM_API_BASE_PATH = "/api";
-function normalizeFarmAPIBasePath(value) {
-  const hasUnstableCharacters = /* @__PURE__ */ __name((candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  }), "hasUnstableCharacters");
-  if (hasUnstableCharacters(value)) {
-    throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
-  }
-  const path = value.trim();
-  if (!path) {
-    throw new Error("Farm api.basePath cannot be empty.");
-  }
-  if (path.includes("?") || path.includes("#")) {
-    throw new Error("Farm api.basePath cannot contain a query string or hash.");
-  }
-  if (path.startsWith("//")) {
-    throw new Error('Farm api.basePath must be a pathname such as "/api", not a URL.');
-  }
-  for (const segment of path.split("/")) {
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (hasUnstableCharacters(decoded)) {
-      throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
-    }
-    if (decoded.includes("/")) {
-      throw new Error("Farm api.basePath cannot contain percent-encoded path separators.");
-    }
-    if (decoded === "." || decoded === "..") {
-      throw new Error('Farm api.basePath cannot contain "." or ".." path segments.');
-    }
-  }
-  const normalized = `/${path.replace(/^\/+|\/+$/g, "")}`;
-  return normalized === "/" ? "/" : normalized;
-}
-__name(normalizeFarmAPIBasePath, "normalizeFarmAPIBasePath");
+var _chunkWMAPPDMMcjs = require('../chunk-WMAPPDMM.cjs');
+require('../chunk-TKJZFIML.cjs');
+require('../chunk-EM6SBQKM.cjs');
 
-// src/api/server-path.ts
-function resolveFarmAPICanonicalPathname(pathname, serverBasePath = DEFAULT_FARM_API_BASE_PATH) {
-  const basePath = normalizeFarmAPIBasePath(serverBasePath);
-  if (basePath === DEFAULT_FARM_API_BASE_PATH) return pathname;
-  if (basePath === "/") {
-    return pathname === "/" ? DEFAULT_FARM_API_BASE_PATH : `${DEFAULT_FARM_API_BASE_PATH}${pathname.startsWith("/") ? pathname : `/${pathname}`}`;
-  }
-  if (pathname === basePath) return DEFAULT_FARM_API_BASE_PATH;
-  if (pathname.startsWith(`${basePath}/`)) {
-    return `${DEFAULT_FARM_API_BASE_PATH}${pathname.slice(basePath.length)}`;
-  }
-  return pathname;
-}
-__name(resolveFarmAPICanonicalPathname, "resolveFarmAPICanonicalPathname");
 
-// src/api/route-schema.ts
-async function parseRouteSchema(schema, value) {
-  if (schema.parseAsync) return schema.parseAsync(value);
-  if (schema["~standard"]) {
-    const result = await schema["~standard"].validate(value);
-    if (result.issues)
-      throw Object.assign(new Error("Validation failed"), { issues: result.issues });
-    return result.value;
-  }
-  if (schema.parse) return schema.parse(value);
-  throw new TypeError("Route validators must implement Standard Schema or parse().");
-}
-__name(parseRouteSchema, "parseRouteSchema");
+var _chunkG7HXGLECcjs = require('../chunk-G7HXGLEC.cjs');
+require('../chunk-ARJWXNQL.cjs');
+require('../chunk-S3A45T7F.cjs');
+require('../chunk-H6G5INWM.cjs');
+require('../chunk-ZEG3OPIB.cjs');
+require('../chunk-LIUGYUX3.cjs');
+require('../chunk-E3UK5IIB.cjs');
+require('../chunk-5ZSWG4UX.cjs');
+require('../chunk-U4KT7QP3.cjs');
+require('../chunk-NO3WWW3N.cjs');
+require('../chunk-S3JO3N4H.cjs');
 
-// src/response-body.ts
-function omitFarmResponseBody(response) {
-  if (response.body) {
-    void response.body.cancel().catch(() => void 0);
-  }
-  return new Response(null, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-}
-__name(omitFarmResponseBody, "omitFarmResponseBody");
 
-// src/api/route-shape.ts
-function registerAPIRouteShape(shapes, routePath, filePath, source) {
-  assertUniqueRouteParameters(routePath, "api");
-  const shape = getRoutePatternShape(routePath, "api");
-  const existing = shapes.get(shape);
-  const replacesPath = existing && existing.routePath !== routePath;
-  if (replacesPath && existing.source === source) {
-    throw new AmbiguousRouteError(
-      `Ambiguous API routes "${existing.routePath}" and "${routePath}" match the same URLs. Found ${existing.filePath} and ${filePath}. Keep only one route for this URL shape.`
-    );
-  }
-  shapes.set(shape, { routePath, source, filePath });
-  return replacesPath ? existing.routePath : void 0;
-}
-__name(registerAPIRouteShape, "registerAPIRouteShape");
 
-// src/api/route.ts
-var unavailablePluginLocalAPI = Object.freeze({
-  available: false,
-  get() {
-    return void 0;
-  },
-  list() {
-    return [];
-  }
-});
-function createRouteFactory() {
-  return createRouteFactoryAt("");
-}
-__name(createRouteFactory, "createRouteFactory");
-function createRouteFactoryAt(prefix) {
-  const factory = {
-    scope(child) {
-      return createRouteFactoryAt(joinRoutePath(prefix, child));
-    }
-  };
-  for (const method of [
-    "GET",
-    "HEAD",
-    "QUERY",
-    "POST",
-    "PUT",
-    "PATCH",
-    "DELETE",
-    "OPTIONS"
-  ]) {
-    factory[method.toLowerCase()] = (child, options) => {
-      const path = joinRoutePath(prefix, child);
-      const input = options.input ?? {};
-      const endpoint = createEndpoint(
-        path,
-        {
-          method,
-          body: input.body,
-          query: input.query,
-          headers: input.headers,
-          middleware: options.middleware,
-          mcp: options.mcp
-        },
-        (ctx) => options.handler(ctx.request, {
-          input: { body: ctx.body, query: ctx.query, headers: ctx.headers, params: ctx.params },
-          params: ctx.params,
-          context: ctx.context
-        })
-      );
-      endpoint.__types.params = input.params;
-      endpoint.__output = options.output;
-      return Object.freeze({ path, method, endpoint });
-    };
-  }
-  return Object.freeze(factory);
-}
-__name(createRouteFactoryAt, "createRouteFactoryAt");
-function joinRoutePath(prefix, child) {
-  if (typeof child !== "string") throw new TypeError("Route paths must be strings.");
-  const path = child === "" ? prefix : `${prefix}/${child.replace(/^\//, "")}`;
-  if (!(path === "/api" || path.startsWith("/api/")) || /[?#]|\/\/|\/$/.test(path)) {
-    throw new TypeError(
-      `Plugin route "${path}" must be a canonical /api path without a query, hash, or empty segment.`
-    );
-  }
-  assertBrowserStableRoutePath(path);
-  assertUniqueRouteParameters(path, "api");
-  getRoutePatternShape(path, "api");
-  for (const segment of path.split("/")) {
-    if (["__proto__", "constructor", "prototype", "$params"].includes(segment)) {
-      throw new TypeError(`Route segment "${segment}" is reserved.`);
-    }
-  }
-  return path;
-}
-__name(joinRoutePath, "joinRoutePath");
-function resolvePluginRoutes(plugins = [], context2 = {}) {
-  return plugins.flatMap((plugin) => {
-    if (!plugin.routes) return [];
-    const routes = plugin.routes({
-      route: createRouteFactory(),
-      api: context2.api ?? unavailablePluginLocalAPI
-    });
-    if (!Array.isArray(routes))
-      throw new TypeError(`Plugin "${plugin.name}" routes must return an array synchronously.`);
-    for (const route of routes) {
-      if (!route || joinRoutePath("", route.path) !== route.path || typeof route.endpoint !== "function" || !["GET", "HEAD", "QUERY", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"].includes(
-        route.method
-      )) {
-        throw new TypeError(`Plugin "${plugin.name}" returned an invalid API route.`);
-      }
-    }
-    return routes;
-  });
-}
-__name(resolvePluginRoutes, "resolvePluginRoutes");
 
-// src/api/plugin-route-runtime.ts
-function mergePluginAPIRoutes(existing, plugins, expected, options = {}) {
-  const routes = /* @__PURE__ */ new Map();
-  const shapes = /* @__PURE__ */ new Map();
-  for (const route of existing) {
-    registerAPIRouteShape(shapes, route.path, route.filePath || route.path, "app");
-    routes.set(route.path, {
-      ...route,
-      filePath: route.filePath || "",
-      methods: [...route.methods],
-      endpoints: { ...route.endpoints }
-    });
-  }
-  const api = createPluginLocalAPI(existing, options.bodySizeLimit);
-  for (const definition of resolvePluginRoutes(plugins, { api })) {
-    registerAPIRouteShape(shapes, definition.path, `plugin:${definition.path}`, "app");
-    let route = routes.get(definition.path);
-    if (route?.methods.includes(definition.method)) {
-      throw new Error(
-        `Duplicate API route for ${definition.method} ${definition.path}. Plugin routes cannot override app or other plugin endpoints.`
-      );
-    }
-    if (!route) {
-      route = { path: definition.path, filePath: "", methods: [], endpoints: {} };
-      routes.set(definition.path, route);
-    }
-    route.methods.push(definition.method);
-    route.pluginMethods = [...route.pluginMethods ?? [], definition.method];
-    route.endpoints[definition.method] = definition.endpoint;
-  }
-  const result = [...routes.values()];
-  if (expected) {
-    const signature = /* @__PURE__ */ __name((entries) => entries.map(({ path, methods }) => `${path}:${[...methods].sort().join(",")}`).sort().join("\n"), "signature");
-    const actualSignature = signature(result);
-    const expectedSignature = signature(expected);
-    if (actualSignature !== expectedSignature) {
-      throw new Error(
-        `Plugin API routes changed between build and runtime. Route paths and methods must be stable across environments; rebuild the app.
-Expected:
-${expectedSignature || "(none)"}
-Received:
-${actualSignature || "(none)"}`
-      );
-    }
-  }
-  return result;
-}
-__name(mergePluginAPIRoutes, "mergePluginAPIRoutes");
-function createPluginLocalAPI(routes, bodySizeLimit) {
-  const endpoints = /* @__PURE__ */ new Map();
-  for (const route of routes) {
-    for (const method of route.methods) {
-      const normalizedMethod = method.toUpperCase();
-      const endpoint = route.endpoints[normalizedMethod];
-      if (typeof endpoint !== "function") continue;
-      const descriptor = Object.freeze({
-        path: route.path,
-        method: normalizedMethod,
-        input: Object.freeze({
-          body: endpoint.__types?.body,
-          query: endpoint.__types?.query,
-          params: endpoint.__types?.params,
-          headers: endpoint.__types?.headers
-        }),
-        output: endpoint.__output,
-        mcp: endpoint.__mcp === true ? true : endpoint.__mcp ? Object.freeze({ ...endpoint.__mcp }) : void 0,
-        invoke(request, params = {}) {
-          return invokeAPIRouteEndpoint(endpoint, request, { ...params }, bodySizeLimit);
-        }
-      });
-      endpoints.set(`${normalizedMethod} ${route.path}`, descriptor);
-    }
-  }
-  const listedEndpoints = Object.freeze(Array.from(endpoints.values()));
-  return Object.freeze({
-    available: true,
-    get(method, path) {
-      return endpoints.get(`${method.toUpperCase()} ${path}`);
-    },
-    list() {
-      return listedEndpoints;
-    }
-  });
-}
-__name(createPluginLocalAPI, "createPluginLocalAPI");
 
-// src/api/route-pattern.ts
-var compiledEntries = /* @__PURE__ */ new WeakMap();
-function createStaticAPIRouteMatcher(routes) {
-  const table = new Map(routes.map((route) => [route.path, Object.freeze({ ...route })]));
-  const root = { children: /* @__PURE__ */ new Map(), candidates: [] };
-  let order = 0;
-  for (const route of table.values()) {
-    const compiled = compileRouteEntry(route.path);
-    let node = root;
-    for (const segment of compiled.segments) {
-      if (segment.dynamic) break;
-      let child = node.children.get(segment.value);
-      if (!child) {
-        child = { children: /* @__PURE__ */ new Map(), candidates: [] };
-        node.children.set(segment.value, child);
-      }
-      node = child;
-    }
-    node.candidates.push({ route, compiled, order: order++ });
-  }
-  return (pathname) => {
-    const exactRoute = table.get(pathname);
-    if (exactRoute) return { route: exactRoute, params: {} };
-    const normalizedPathname = normalizePathname(pathname);
-    if (normalizedPathname !== pathname) {
-      const normalizedRoute = table.get(normalizedPathname);
-      if (normalizedRoute) return { route: normalizedRoute, params: {} };
-    }
-    const segments = getPathSegments(normalizedPathname).map(decodePathSegment);
-    let best;
-    let bestMatch = null;
-    let node = root;
-    let depth = 0;
-    while (node) {
-      for (const candidate of node.candidates) {
-        const params = matchRouteEntry(candidate.compiled, segments);
-        if (!params) continue;
-        const comparison = best ? compareRouteSpecificity(candidate.compiled.specificity, best.compiled.specificity) : -1;
-        if (comparison < 0 || comparison === 0 && candidate.order < best.order) {
-          best = candidate;
-          bestMatch = { route: candidate.route, params };
-        }
-      }
-      node = depth < segments.length ? node.children.get(segments[depth++]) : void 0;
-    }
-    return bestMatch;
-  };
-}
-__name(createStaticAPIRouteMatcher, "createStaticAPIRouteMatcher");
-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: {} };
-  }
-  const pathnameSegments = getPathSegments(normalizedPathname).map(decodePathSegment);
-  let bestMatch = null;
-  let bestSpecificity = null;
-  for (const route of routes.values()) {
-    const routePath = route.path;
-    let entry = compiledEntries.get(route);
-    if (!entry || entry.path !== routePath) {
-      entry = compileRouteEntry(routePath);
-      compiledEntries.set(route, entry);
-    }
-    const params = matchRouteEntry(entry, pathnameSegments);
-    if (!params) continue;
-    if (bestSpecificity === null || compareRouteSpecificity(entry.specificity, bestSpecificity) < 0) {
-      bestMatch = { route, params };
-      bestSpecificity = entry.specificity;
-    }
-  }
-  return bestMatch;
-}
-__name(matchAPIRoute, "matchAPIRoute");
-function compileRouteEntry(path) {
-  const segments = getPathSegments(path).map((segment) => {
-    const dynamic = parseDynamicSegment(segment);
-    return dynamic ? { dynamic } : { value: decodePathSegment(segment) };
-  });
-  return {
-    path,
-    segments,
-    specificity: segments.map((segment) => {
-      const dynamic = segment.dynamic;
-      if (!dynamic) return "static";
-      if (!dynamic.catchAll) return "dynamic";
-      return dynamic.optional ? "optional-catch-all" : "catch-all";
-    })
-  };
-}
-__name(compileRouteEntry, "compileRouteEntry");
-function matchRouteEntry(entry, pathnameSegments) {
-  const params = {};
-  let pathIndex = 0;
-  for (const routeSegment of entry.segments) {
-    const dynamicSegment = routeSegment.dynamic;
-    if (dynamicSegment?.catchAll) {
-      const remainingSegments = pathnameSegments.slice(pathIndex);
-      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] = pathnameSegment;
-      pathIndex++;
-      continue;
-    }
-    if (routeSegment.value !== pathnameSegment) {
-      return null;
-    }
-    pathIndex++;
-  }
-  return pathIndex === pathnameSegments.length ? params : null;
-}
-__name(matchRouteEntry, "matchRouteEntry");
-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/runtime.ts
-var API_ROUTE_METHODS = [
-  "GET",
-  "HEAD",
-  "QUERY",
-  "POST",
-  "PUT",
-  "DELETE",
-  "PATCH",
-  "OPTIONS"
-];
-function resolveAPIRouteEndpoint(route, method) {
-  const normalizedMethod = method.toUpperCase();
-  return route.endpoints[normalizedMethod] ?? (normalizedMethod === "HEAD" ? route.endpoints.GET : void 0);
-}
-__name(resolveAPIRouteEndpoint, "resolveAPIRouteEndpoint");
-function getAllowedAPIRouteMethods(route) {
-  const methods = [...route.methods];
-  const getIndex = methods.indexOf("GET");
-  if (getIndex >= 0 && !methods.includes("HEAD")) {
-    methods.splice(getIndex + 1, 0, "HEAD");
-  }
-  return methods;
-}
-__name(getAllowedAPIRouteMethods, "getAllowedAPIRouteMethods");
-function matchAPIRouteAtBasePath(routes, pathname, serverBasePath = DEFAULT_FARM_API_BASE_PATH) {
-  const directMatch = matchAPIRoute(routes, pathname);
-  if (directMatch) return directMatch;
-  const canonicalPathname = resolveFarmAPICanonicalPathname(pathname, serverBasePath);
-  return canonicalPathname === pathname ? null : matchAPIRoute(routes, canonicalPathname);
-}
-__name(matchAPIRouteAtBasePath, "matchAPIRouteAtBasePath");
-function createStaticAPIRouteMatcherAtBasePath(routes, serverBasePath = DEFAULT_FARM_API_BASE_PATH) {
-  const match = createStaticAPIRouteMatcher(routes);
-  return (pathname) => {
-    const directMatch = match(pathname);
-    if (directMatch) return directMatch;
-    const canonicalPathname = resolveFarmAPICanonicalPathname(pathname, serverBasePath);
-    return canonicalPathname === pathname ? null : match(canonicalPathname);
-  };
-}
-__name(createStaticAPIRouteMatcherAtBasePath, "createStaticAPIRouteMatcherAtBasePath");
-function isFarmAPIPathname(pathname, serverBasePath = DEFAULT_FARM_API_BASE_PATH) {
-  const basePath = normalizeFarmAPIBasePath(serverBasePath);
-  return basePath !== "/" && (pathname === basePath || pathname.startsWith(`${basePath}/`));
-}
-__name(isFarmAPIPathname, "isFarmAPIPathname");
-async function invokeAPIRouteEndpoint(endpoint, request, params = {}, bodySizeLimit = DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT) {
-  try {
-    request = await bufferFarmRequestBody(request, bodySizeLimit);
-  } catch (error) {
-    const response2 = createFarmRequestBodyErrorResponse(error);
-    if (response2) return response2;
-    throw error;
-  }
-  const response = await _runWithCurrentRequest(
-    request,
-    () => invokeAPIRouteEndpointInContext(endpoint, request, params)
-  );
-  if (request.method.toUpperCase() !== "HEAD") {
-    return response;
-  }
-  return omitFarmResponseBody(response);
-}
-__name(invokeAPIRouteEndpoint, "invokeAPIRouteEndpoint");
-async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
-  const queryContentTypeError = validateQueryContentType(request);
-  if (queryContentTypeError) {
-    return queryContentTypeError;
-  }
-  const farmHandler = endpoint.__handler || null;
-  if (!farmHandler) {
-    const result = await endpoint(request, {
-      params: Promise.resolve(params)
-    });
-    return normalizeRouteResponse(result);
-  }
-  const url = new URL(request.url);
-  const query = {
-    ...searchParamsToObject(url.searchParams)
-  };
-  let body = void 0;
-  if (request.method.toUpperCase() !== "GET" && request.method.toUpperCase() !== "HEAD") {
-    const parsedBody = await readRequestBody(request);
-    if (parsedBody.error) return parsedBody.error;
-    body = parsedBody.body;
-  }
-  const headers = Object.fromEntries(request.headers.entries());
-  const types = endpoint.__types || {};
-  const queryValidation = await validateInput(types.query, query, "Invalid query parameters");
-  if (queryValidation instanceof Response) {
-    return queryValidation;
-  }
-  const bodyValidation = await validateInput(types.body, body, "Invalid request body");
-  if (bodyValidation instanceof Response) {
-    return bodyValidation;
-  }
-  const headersValidation = await validateInput(types.headers, headers, "Invalid request headers");
-  if (headersValidation instanceof Response) {
-    return headersValidation;
-  }
-  const paramsValidation = await validateInput(types.params, params, "Invalid route parameters");
-  if (paramsValidation instanceof Response) return paramsValidation;
-  const handlerContext = {
-    query: queryValidation,
-    body: bodyValidation,
-    headers: headersValidation,
-    request,
-    context: {},
-    params: paramsValidation
-  };
-  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;
-  }
-  if (execution.handlerExecuted && endpoint.__output && !isWebResponse(execution.result)) {
-    try {
-      execution.result = await parseRouteSchema(endpoint.__output, execution.result);
-    } catch {
-      throw new Error("API route returned a value that does not match its output schema.");
-    }
-  }
-  const response = normalizeRouteResponse(execution.result);
-  return attachEndpointInvalidations(response, execution.invalidations);
-}
-__name(invokeAPIRouteEndpointInContext, "invokeAPIRouteEndpointInContext");
-function validateQueryContentType(request) {
-  if (request.method.toUpperCase() !== "QUERY" || request.headers.has("content-type")) {
-    return null;
-  }
-  return new Response(
-    JSON.stringify({
-      error: "Invalid QUERY request",
-      message: "QUERY requests must include a Content-Type header."
-    }),
-    {
-      status: 400,
-      headers: { "Content-Type": "application/json" }
-    }
-  );
-}
-__name(validateQueryContentType, "validateQueryContentType");
-function normalizeRouteResponse(result) {
-  if (isWebResponse(result)) {
-    return result;
-  }
-  if (result === void 0) {
-    return new Response(null, { status: 204 });
-  }
-  let body;
-  try {
-    body = JSON.stringify(result);
-  } catch (error) {
-    const serializationError = new TypeError(
-      "API route result must be a JSON-serializable value or a Response."
-    );
-    serializationError.cause = error;
-    throw serializationError;
-  }
-  if (body === void 0) {
-    throw new TypeError("API route result must be a JSON-serializable value or a Response.");
-  }
-  return new Response(body, {
-    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");
-async function readRequestBody(request) {
-  const contentType = request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
-  if (contentType === "multipart/form-data") {
-    try {
-      return { body: formDataToObject(await request.clone().formData()) };
-    } catch {
-      return invalidRequestBody("The request body is not valid multipart form data.");
-    }
-  }
-  let text;
-  try {
-    text = await request.clone().text();
-  } catch {
-    if (contentType === "application/json" || contentType?.endsWith("+json")) {
-      return invalidRequestBody("The request body is not valid JSON.");
-    }
-    if (contentType === "application/x-www-form-urlencoded") {
-      return invalidRequestBody("The request body is not valid URL-encoded form data.");
-    }
-    return { body: void 0 };
-  }
-  if (contentType === "application/json" || contentType?.endsWith("+json")) {
-    if (!text && request.method.toUpperCase() === "QUERY") {
-      return { body: void 0 };
-    }
-    try {
-      return { body: JSON.parse(text) };
-    } catch {
-      return invalidRequestBody("The request body is not valid JSON.");
-    }
-  }
-  if (contentType === "application/x-www-form-urlencoded") {
-    return { body: searchParamsToObject(new URLSearchParams(text)) };
-  }
-  if (!text) return { body: void 0 };
-  if (contentType === void 0) {
-    try {
-      return { body: JSON.parse(text) };
-    } catch {
-      return { body: void 0 };
-    }
-  }
-  return { body: void 0 };
-}
-__name(readRequestBody, "readRequestBody");
-function invalidRequestBody(message) {
-  return {
-    error: new Response(
-      JSON.stringify({
-        error: "Invalid request body",
-        message
-      }),
-      {
-        status: 400,
-        headers: { "Content-Type": "application/json" }
-      }
-    )
-  };
-}
-__name(invalidRequestBody, "invalidRequestBody");
-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");
-async function validateInput(schema, value, error) {
-  if (!schema) return value;
-  try {
-    return await parseRouteSchema(schema, value);
-  } catch (validationError) {
-    return Response.json(
-      {
-        error,
-        details: (validationError.issues || validationError.errors || []).map((issue) => ({
-          path: issue.path,
-          message: issue.message,
-          code: issue.code
-        }))
-      },
-      { status: 400 }
-    );
-  }
-}
-__name(validateInput, "validateInput");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  API_ROUTE_METHODS,
-  createEndpointFailureResponse,
-  createStaticAPIRouteMatcherAtBasePath,
-  getAllowedAPIRouteMethods,
-  invokeAPIRouteEndpoint,
-  isFarmAPIPathname,
-  isWebResponse,
-  matchAPIRoute,
-  matchAPIRouteAtBasePath,
-  mergePluginAPIRoutes,
-  normalizeRouteResponse,
-  parseRouteSchema,
-  registerAPIRouteShape,
-  resolveAPIRouteEndpoint
-});
+
+
+
+
+
+
+
+
+
+
+exports.API_ROUTE_METHODS = _chunk4PNUXIVUcjs.API_ROUTE_METHODS; exports.createEndpointFailureResponse = _chunk4PNUXIVUcjs.createEndpointFailureResponse; exports.createStaticAPIRouteMatcherAtBasePath = _chunk4PNUXIVUcjs.createStaticAPIRouteMatcherAtBasePath; exports.getAllowedAPIRouteMethods = _chunk4PNUXIVUcjs.getAllowedAPIRouteMethods; exports.invokeAPIRouteEndpoint = _chunk4PNUXIVUcjs.invokeAPIRouteEndpoint; exports.isEndpointFailure = _chunkI4J452B7cjs.isEndpointFailure; exports.isFarmAPIPathname = _chunk4PNUXIVUcjs.isFarmAPIPathname; exports.isWebResponse = _chunk4PNUXIVUcjs.isWebResponse; exports.matchAPIRoute = _chunkG7HXGLECcjs.matchAPIRoute; exports.matchAPIRouteAtBasePath = _chunk4PNUXIVUcjs.matchAPIRouteAtBasePath; exports.mergePluginAPIRoutes = _chunk4PNUXIVUcjs.mergePluginAPIRoutes; exports.normalizeRouteResponse = _chunk4PNUXIVUcjs.normalizeRouteResponse; exports.parseRouteSchema = _chunk4PNUXIVUcjs.parseRouteSchema; exports.registerAPIRouteShape = _chunkWMAPPDMMcjs.registerAPIRouteShape; exports.resolveAPIRouteEndpoint = _chunk4PNUXIVUcjs.resolveAPIRouteEndpoint;