@farm.js/core 0.1.0-beta.0

package/dist/testing.cjs

@@ -0,0 +1,1882 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/testing.ts
+var testing_exports = {};
+__export(testing_exports, {
+  createFarmTestHarness: () => createFarmTestHarness,
+  createTestRequest: () => createTestRequest
+});
+module.exports = __toCommonJS(testing_exports);
+var import_react2 = require("react");
+
+// src/routes.ts
+var import_react = require("react");
+
+// src/observability.ts
+var runtimeHandlers = /* @__PURE__ */ new Set();
+var observabilityState = {
+  logs: false,
+  handlers: []
+};
+function emitFarmEvent(input) {
+  const event = {
+    timestamp: Date.now(),
+    level: inferFarmEventLevel(input.type),
+    ...input
+  };
+  if (!shouldEmitFarmEvent(event)) {
+    return event;
+  }
+  if (observabilityState.logs) {
+    logFarmEvent(event);
+  }
+  for (const handler of [...observabilityState.handlers, ...runtimeHandlers]) {
+    try {
+      Promise.resolve(handler(event)).catch((error) => {
+        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+      });
+    } catch (error) {
+      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+    }
+  }
+  return event;
+}
+__name(emitFarmEvent, "emitFarmEvent");
+function shouldEmitFarmEvent(event) {
+  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
+    return false;
+  }
+  if (observabilityState.events && !observabilityState.events.has(event.type)) {
+    return false;
+  }
+  return true;
+}
+__name(shouldEmitFarmEvent, "shouldEmitFarmEvent");
+function inferFarmEventLevel(type) {
+  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
+    return "error";
+  }
+  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
+    return "warn";
+  }
+  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
+    return "debug";
+  }
+  return "info";
+}
+__name(inferFarmEventLevel, "inferFarmEventLevel");
+function logFarmEvent(event) {
+  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
+  switch (event.level) {
+    case "error":
+      console.error(message);
+      break;
+    case "warn":
+      console.warn(message);
+      break;
+    default:
+      console.log(message);
+      break;
+  }
+}
+__name(logFarmEvent, "logFarmEvent");
+function formatFarmEventDetails(event) {
+  const details = [];
+  const record = event;
+  for (const key of [
+    "route",
+    "pathname",
+    "method",
+    "status",
+    "key",
+    "tag",
+    "path",
+    "reason",
+    "durationMs",
+    "integration",
+    "operation",
+    "plugin",
+    "hook",
+    "target",
+    "count"
+  ]) {
+    const value = record[key];
+    if (value !== void 0) {
+      details.push(`${key}=${formatDetailValue(value)}`);
+    }
+  }
+  return details.length > 0 ? ` ${details.join(" ")}` : "";
+}
+__name(formatFarmEventDetails, "formatFarmEventDetails");
+function formatDetailValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+__name(formatDetailValue, "formatDetailValue");
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(formatError, "formatError");
+
+// src/cache-invalidation.ts
+var FARM_CACHE_INVALIDATION_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()
+  });
+}
+__name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
+function subscribeFarmCacheInvalidation(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.listeners.add(listener);
+  return () => state.listeners.delete(listener);
+}
+__name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
+
+// src/i18n/bridge.ts
+var FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
+function _setFarmI18nSnapshotResolver(resolver) {
+  globalThis[FARM_I18N_SNAPSHOT_RESOLVER] = resolver;
+}
+__name(_setFarmI18nSnapshotResolver, "_setFarmI18nSnapshotResolver");
+
+// src/cache.ts
+var _FarmDataCache = class _FarmDataCache {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
+    this.version = 0;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get(key, options = {}) {
+    return this.getEntry(key, options)?.value;
+  }
+  getEntry(key, options = {}) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      emitFarmEvent({ type: "cache.miss", key });
+      return void 0;
+    }
+    const stale = this.isStale(entry, options.now);
+    if (stale) {
+      emitFarmEvent({
+        type: "cache.stale",
+        key,
+        tags: Array.from(entry.tags),
+        revalidate: entry.revalidate
+      });
+    }
+    if (!options.allowStale && stale) {
+      emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
+      return void 0;
+    }
+    emitFarmEvent({
+      type: "cache.hit",
+      key,
+      tags: Array.from(entry.tags),
+      revalidate: entry.revalidate,
+      stale
+    });
+    return this.toPublicEntry(entry);
+  }
+  set(key, value, options = {}) {
+    const tags = /* @__PURE__ */ new Set();
+    for (const tag of options.tags ?? []) {
+      tags.add(normalizeCacheTag(tag));
+    }
+    for (const routePath of options.paths ?? []) {
+      tags.add(createPathCacheTag(routePath));
+    }
+    const entry = {
+      key,
+      value,
+      tags,
+      createdAt: options.createdAt ?? Date.now(),
+      createdVersion: ++this.version,
+      revalidate: normalizeRevalidate(options.revalidate)
+    };
+    this.entries.set(key, entry);
+    emitFarmEvent({
+      type: "cache.set",
+      key,
+      tags: Array.from(tags),
+      revalidate: entry.revalidate
+    });
+    return this.toPublicEntry(entry);
+  }
+  delete(key) {
+    const deleted = this.entries.delete(key);
+    emitFarmEvent({ type: "cache.delete", key, deleted });
+    return deleted;
+  }
+  clear() {
+    const count = this.entries.size;
+    this.entries.clear();
+    this.inflight.clear();
+    this.invalidatedTagVersions.clear();
+    this.version = 0;
+    emitFarmEvent({ type: "cache.clear", count });
+  }
+  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;
+  }
+  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;
+  }
+  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 getOrSet(key, producer, options = {}) {
+    const cached = this.getEntry(key);
+    if (cached) {
+      return cached.value;
+    }
+    const inflight = this.inflight.get(key);
+    if (inflight) {
+      emitFarmEvent({ type: "cache.dedupe", key });
+      return inflight;
+    }
+    const promise = Promise.resolve().then(producer).then((value) => {
+      this.set(key, value, options);
+      return value;
+    }).catch((error) => {
+      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
+      throw error;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  countEntriesForTag(tag) {
+    let count = 0;
+    for (const entry of this.entries.values()) {
+      if (entry.tags.has(tag)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  countEntriesForTags(tags) {
+    let count = 0;
+    for (const entry of this.entries.values()) {
+      if (tags.every((tag) => entry.tags.has(tag))) {
+        count++;
+      }
+    }
+    return count;
+  }
+  invalidateTag(normalizedTag) {
+    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
+    return this.countEntriesForTag(normalizedTag);
+  }
+  toPublicEntry(entry) {
+    return {
+      key: entry.key,
+      value: entry.value,
+      tags: Array.from(entry.tags),
+      createdAt: entry.createdAt,
+      createdVersion: entry.createdVersion,
+      revalidate: entry.revalidate
+    };
+  }
+};
+__name(_FarmDataCache, "FarmDataCache");
+var FarmDataCache = _FarmDataCache;
+var FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
+var farmDataCacheGlobal = globalThis;
+var sharedFarmDataCache = farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] ?? (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] = new FarmDataCache());
+var functionIds = /* @__PURE__ */ new WeakMap();
+var nextFunctionId = 0;
+function getFarmDataCache() {
+  return sharedFarmDataCache;
+}
+__name(getFarmDataCache, "getFarmDataCache");
+function createPathCacheTag(routePath) {
+  return `path:${normalizeRevalidatePath(routePath)}`;
+}
+__name(createPathCacheTag, "createPathCacheTag");
+function createRouteDataCacheTag(key) {
+  return `route-data:${createRouteDataCacheKey(key)}`;
+}
+__name(createRouteDataCacheTag, "createRouteDataCacheTag");
+function createRouteDataCacheKey(key) {
+  return createFarmCacheKey(Array.isArray(key) ? key : [key]);
+}
+__name(createRouteDataCacheKey, "createRouteDataCacheKey");
+function normalizeRevalidatePath(routePath) {
+  if (typeof routePath !== "string") {
+    throw new TypeError("revalidatePath expects a path string.");
+  }
+  let normalized = routePath.trim();
+  if (!normalized) {
+    throw new Error("revalidatePath expects a non-empty path.");
+  }
+  try {
+    if (/^https?:\/\//.test(normalized)) {
+      normalized = new URL(normalized).pathname;
+    }
+  } catch {
+  }
+  normalized = normalized.split("?")[0] ?? normalized;
+  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  normalized = normalized.replace(/\/{2,}/g, "/");
+  if (normalized.length > 1) {
+    normalized = normalized.replace(/\/+$/, "");
+  }
+  return normalized || "/";
+}
+__name(normalizeRevalidatePath, "normalizeRevalidatePath");
+function createFarmCacheKey(parts) {
+  return stableSerialize(parts);
+}
+__name(createFarmCacheKey, "createFarmCacheKey");
+function normalizeRevalidate(revalidate) {
+  if (revalidate === false || revalidate === void 0) {
+    return revalidate;
+  }
+  if (!Number.isFinite(revalidate) || revalidate <= 0) {
+    return void 0;
+  }
+  return revalidate;
+}
+__name(normalizeRevalidate, "normalizeRevalidate");
+function normalizeCacheTag(tag) {
+  if (typeof tag !== "string") {
+    throw new TypeError("Cache tags must be strings.");
+  }
+  const normalized = tag.trim();
+  if (!normalized) {
+    throw new Error("Cache tags cannot be empty.");
+  }
+  return normalized;
+}
+__name(normalizeCacheTag, "normalizeCacheTag");
+function getFunctionCacheIdentity(fn) {
+  if (fn.name) {
+    return `name:${fn.name}`;
+  }
+  let id = functionIds.get(fn);
+  if (!id) {
+    id = ++nextFunctionId;
+    functionIds.set(fn, id);
+  }
+  return `anonymous:${id}`;
+}
+__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
+function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const valueType = typeof value;
+  if (valueType === "string") return JSON.stringify(value);
+  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
+    return `${valueType}:${String(value)}`;
+  }
+  if (valueType === "symbol") {
+    return `symbol:${String(value)}`;
+  }
+  if (valueType === "function") {
+    return `function:${getFunctionCacheIdentity(value)}`;
+  }
+  if (value instanceof Date) {
+    return `date:${value.toISOString()}`;
+  }
+  if (value instanceof URL) {
+    return `url:${value.toString()}`;
+  }
+  if (value instanceof RegExp) {
+    return `regexp:${value.toString()}`;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableSerialize(item, seen)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
+    seen.delete(value);
+    return `{${serialized}}`;
+  }
+  return String(value);
+}
+__name(stableSerialize, "stableSerialize");
+
+// src/route-context.ts
+var FARM_ROUTE_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("farm.routeContext");
+async function resolveFarmRouteContext(config, input) {
+  if (typeof config.context !== "function") {
+    return void 0;
+  }
+  return config.context(input);
+}
+__name(resolveFarmRouteContext, "resolveFarmRouteContext");
+function withFarmRouteContext(props, context) {
+  if (context === void 0) {
+    return props;
+  }
+  Object.defineProperty(props, FARM_ROUTE_CONTEXT_SYMBOL, {
+    value: context,
+    enumerable: false,
+    configurable: true
+  });
+  return props;
+}
+__name(withFarmRouteContext, "withFarmRouteContext");
+function getFarmRouteContext(props) {
+  if (!props || typeof props !== "object") {
+    return void 0;
+  }
+  return props[FARM_ROUTE_CONTEXT_SYMBOL];
+}
+__name(getFarmRouteContext, "getFarmRouteContext");
+
+// src/route-runtime.ts
+function normalizeFarmRouteRuntimeConfig(value, source = "Route configuration") {
+  if (!value) return {};
+  const normalized = {};
+  if (value.runtime !== void 0) {
+    if (value.runtime !== "auto" && value.runtime !== "node" && value.runtime !== "edge") {
+      throw new TypeError(`${source} runtime must be "auto", "node", or "edge"`);
+    }
+    normalized.runtime = value.runtime;
+  }
+  if (value.regions !== void 0) {
+    if (value.regions === "auto") {
+      normalized.regions = "auto";
+    } else {
+      if (!Array.isArray(value.regions) || value.regions.length === 0) {
+        throw new TypeError(`${source} regions must be "auto" or a non-empty string array`);
+      }
+      const regions = Array.from(
+        new Set(
+          value.regions.map((region) => {
+            if (typeof region !== "string" || !region.trim() || /[\u0000-\u001f\u007f]/.test(region)) {
+              throw new TypeError(`${source} regions must contain non-empty region identifiers`);
+            }
+            return region.trim();
+          })
+        )
+      );
+      normalized.regions = regions;
+    }
+  }
+  if (value.maxDuration !== void 0) {
+    if (value.maxDuration === "auto") {
+      normalized.maxDuration = "auto";
+    } else if (typeof value.maxDuration !== "number" || !Number.isInteger(value.maxDuration) || value.maxDuration <= 0) {
+      throw new TypeError(`${source} maxDuration must be "auto" or a positive integer in seconds`);
+    } else {
+      normalized.maxDuration = value.maxDuration;
+    }
+  }
+  return normalized;
+}
+__name(normalizeFarmRouteRuntimeConfig, "normalizeFarmRouteRuntimeConfig");
+
+// src/routes.ts
+var routesBuilder = {
+  page(path2, options) {
+    return normalizeProgrammaticRoute({
+      kind: "page",
+      path: path2,
+      ...options
+    });
+  },
+  layout(path2, options) {
+    return normalizeProgrammaticRoute({
+      kind: "layout",
+      path: path2,
+      ...options
+    });
+  },
+  api(path2, options) {
+    const { render, runtime, regions, maxDuration, ...methods } = options;
+    return normalizeProgrammaticRoute({
+      kind: "api",
+      path: path2,
+      render,
+      runtime,
+      regions,
+      maxDuration,
+      methods: normalizeApiMethods(methods)
+    });
+  },
+  redirect(source, destination, options = {}) {
+    return normalizeProgrammaticRoute({
+      kind: "redirect",
+      source,
+      destination,
+      ...options
+    });
+  }
+};
+var page = routesBuilder.page;
+var layout = routesBuilder.layout;
+var api = routesBuilder.api;
+var redirect = routesBuilder.redirect;
+function getProgrammaticRouteSearchSchema(search) {
+  if (!search) return void 0;
+  if (isProgrammaticRouteSchema(search)) return search;
+  return search.schema;
+}
+__name(getProgrammaticRouteSearchSchema, "getProgrammaticRouteSearchSchema");
+function getProgrammaticRouteSearchClientOptions(search) {
+  if (!search || isProgrammaticRouteSchema(search)) return void 0;
+  const options = {};
+  if (typeof search.stripDefaults !== "undefined") options.stripDefaults = search.stripDefaults;
+  if (search.preserve?.length) options.preserve = [...search.preserve];
+  if (search.temporary?.length) options.temporary = [...search.temporary];
+  return Object.keys(options).length > 0 ? options : void 0;
+}
+__name(getProgrammaticRouteSearchClientOptions, "getProgrammaticRouteSearchClientOptions");
+function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path2, routePath) {
+  const schema = getProgrammaticRouteSearchSchema(searchConfig);
+  const search = parseProgrammaticSchema(schema, rawSearch, "search", routePath);
+  const options = getProgrammaticRouteSearchOptions(searchConfig);
+  const canonicalPath = resolveProgrammaticRouteCanonicalPath({
+    options,
+    schema,
+    rawSearch,
+    parsedSearch: search,
+    path: path2
+  });
+  return { search, canonicalPath };
+}
+__name(resolveProgrammaticRouteSearch, "resolveProgrammaticRouteSearch");
+function getProgrammaticRouteSearchOptions(search) {
+  if (!search || isProgrammaticRouteSchema(search)) return void 0;
+  return search;
+}
+__name(getProgrammaticRouteSearchOptions, "getProgrammaticRouteSearchOptions");
+function isProgrammaticRouteSchema(value) {
+  return !!value && typeof value === "object" && typeof value.parse === "function";
+}
+__name(isProgrammaticRouteSchema, "isProgrammaticRouteSchema");
+function resolveProgrammaticRouteCanonicalPath(input) {
+  const options = input.options;
+  if (!options?.temporary?.length && !options?.stripDefaults) {
+    return void 0;
+  }
+  const params = createSearchParams(input.rawSearch);
+  const original = params.toString();
+  for (const key of options.temporary || []) {
+    params.delete(key);
+  }
+  if (options.stripDefaults) {
+    const defaultSearch = parseDefaultSearch(input.schema);
+    if (defaultSearch !== void 0) {
+      const keys = options.stripDefaults === true ? Array.from(new Set(Array.from(params.keys()))) : [...options.stripDefaults];
+      for (const key of keys) {
+        if (params.has(key) && searchValuesEqual(
+          readSearchValue(input.parsedSearch, key),
+          readSearchValue(defaultSearch, key)
+        )) {
+          params.delete(key);
+        }
+      }
+    }
+  }
+  const next = params.toString();
+  if (next === original) {
+    return void 0;
+  }
+  return next ? `${input.path}?${next}` : input.path;
+}
+__name(resolveProgrammaticRouteCanonicalPath, "resolveProgrammaticRouteCanonicalPath");
+function createSearchParams(value) {
+  const params = new URLSearchParams();
+  for (const [key, item] of Object.entries(value)) {
+    if (item == null) continue;
+    const values = Array.isArray(item) ? item : [item];
+    for (const entry of values) {
+      if (entry != null) params.append(key, String(entry));
+    }
+  }
+  return params;
+}
+__name(createSearchParams, "createSearchParams");
+function parseDefaultSearch(schema) {
+  if (!schema) return void 0;
+  try {
+    const value = schema.parse({});
+    return value && typeof value === "object" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(parseDefaultSearch, "parseDefaultSearch");
+function readSearchValue(value, key) {
+  return value && typeof value === "object" ? value[key] : void 0;
+}
+__name(readSearchValue, "readSearchValue");
+function searchValuesEqual(left, right) {
+  return JSON.stringify(normalizeComparableValue(left)) === JSON.stringify(normalizeComparableValue(right));
+}
+__name(searchValuesEqual, "searchValuesEqual");
+function normalizeComparableValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeComparableValue);
+  }
+  if (value && typeof value === "object") {
+    return Object.keys(value).sort().reduce((output, key) => {
+      output[key] = normalizeComparableValue(value[key]);
+      return output;
+    }, {});
+  }
+  return value;
+}
+__name(normalizeComparableValue, "normalizeComparableValue");
+function parseProgrammaticRoutePath(routePath, type = "page") {
+  const fileName = type === "layout" ? "layout.tsx" : "page.tsx";
+  const normalized = normalizeRoutePath(routePath);
+  const filePath = normalized === "/" ? fileName : `${normalized.slice(1).replace(/\/+$/, "")}/${fileName}`;
+  return {
+    filePath,
+    type,
+    segments: normalized === "/" ? [] : normalized.slice(1).split("/").map(parseRouteSegment)
+  };
+}
+__name(parseProgrammaticRoutePath, "parseProgrammaticRoutePath");
+function createRouteModuleFromProgrammaticPage(route) {
+  const mod = {
+    default: createProgrammaticPageComponent(route),
+    ...normalizeFarmRouteRuntimeConfig(route, `Route "${route.path}"`)
+  };
+  if (route.params || route.search || route.guard || route.data) {
+    mod.__farmRouteSchemas = {
+      params: route.params,
+      search: getProgrammaticRouteSearchSchema(route.search)
+    };
+    mod.__farmRouteSearch = getProgrammaticRouteSearchClientOptions(route.search);
+    mod.__farmRouteGuard = route.guard;
+    mod.__farmRouteData = route.data;
+    mod.__farmRouteParsesProps = true;
+    mod.__farmResolveRouteProps = (props) => resolveProgrammaticRouteProps(route, props);
+    mod.__farmResolveRouteCanonicalPath = (rawSearch, path2) => resolveProgrammaticRouteSearch(route.search, rawSearch, path2, route.path).canonicalPath;
+  }
+  if (route.pending || route.error || route.notFound) {
+    mod.__farmRouteComponents = {
+      pending: route.pending,
+      error: route.error,
+      notFound: route.notFound
+    };
+  }
+  if (route.render === "static" || route.staticPaths) {
+    mod.ssg = true;
+    mod.dynamic = "force-static";
+  } else if (route.render === "dynamic") {
+    mod.ssg = false;
+    mod.dynamic = "force-dynamic";
+  }
+  if (typeof route.revalidate !== "undefined") {
+    mod.revalidate = route.revalidate;
+  }
+  if (route.ppr) {
+    mod.ppr = true;
+  }
+  if (route.metadata) {
+    mod.metadata = route.metadata;
+  }
+  if (route.generateMetadata) {
+    mod.generateMetadata = route.generateMetadata;
+  }
+  if (route.staticPaths) {
+    mod.getStaticPaths = async () => normalizeStaticPaths(route.path, await route.staticPaths());
+  }
+  return mod;
+}
+__name(createRouteModuleFromProgrammaticPage, "createRouteModuleFromProgrammaticPage");
+function createProgrammaticPageComponent(route) {
+  if (!route.params && !route.search && !route.guard && !route.data && !route.pending && !route.error && !route.notFound) {
+    return route.component;
+  }
+  const Component = route.component;
+  if (route.pending) {
+    const PendingComponent = route.pending;
+    const routePropsResources = /* @__PURE__ */ new WeakMap();
+    const FarmProgrammaticPageContent2 = /* @__PURE__ */ __name(function FarmProgrammaticPageContent3(props) {
+      try {
+        const resolvedProps = readProgrammaticRouteProps(route, props, routePropsResources);
+        return (0, import_react.createElement)(Component, stripProgrammaticRoutePropsMarker(resolvedProps));
+      } catch (error) {
+        if (isPromiseLike(error) || isProgrammaticRedirectSignal(error)) {
+          throw error;
+        }
+        if (isProgrammaticNotFoundSignal(error) && route.notFound) {
+          return (0, import_react.createElement)(route.notFound, createProgrammaticRouteErrorProps(error, props));
+        }
+        if (route.error) {
+          return (0, import_react.createElement)(route.error, createProgrammaticRouteErrorProps(error, props));
+        }
+        throw error;
+      }
+    }, "FarmProgrammaticPageContent");
+    const PageContent = FarmProgrammaticPageContent2;
+    const FarmProgrammaticPage = /* @__PURE__ */ __name(function FarmProgrammaticPage2(props) {
+      return (0, import_react.createElement)(
+        import_react.Suspense,
+        {
+          fallback: (0, import_react.createElement)(PendingComponent, createProgrammaticRoutePendingProps(props))
+        },
+        (0, import_react.createElement)(PageContent, props)
+      );
+    }, "FarmProgrammaticPage");
+    return FarmProgrammaticPage;
+  }
+  const FarmProgrammaticPageContent = /* @__PURE__ */ __name(async function FarmProgrammaticPageContent2(props) {
+    try {
+      const resolvedProps = isProgrammaticRoutePropsResolved(props) ? props : await resolveProgrammaticRouteProps(route, props);
+      return (0, import_react.createElement)(Component, stripProgrammaticRoutePropsMarker(resolvedProps));
+    } catch (error) {
+      if (isProgrammaticRedirectSignal(error)) {
+        throw error;
+      }
+      if (isProgrammaticNotFoundSignal(error) && route.notFound) {
+        return (0, import_react.createElement)(route.notFound, createProgrammaticRouteErrorProps(error, props));
+      }
+      if (route.error) {
+        return (0, import_react.createElement)(route.error, createProgrammaticRouteErrorProps(error, props));
+      }
+      throw error;
+    }
+  }, "FarmProgrammaticPageContent");
+  return FarmProgrammaticPageContent;
+}
+__name(createProgrammaticPageComponent, "createProgrammaticPageComponent");
+function readProgrammaticRouteProps(route, props, resources) {
+  if (isProgrammaticRoutePropsResolved(props)) {
+    return props;
+  }
+  let resource = resources.get(props);
+  if (!resource) {
+    const deferredRouteProps = props.__farmRoutePropsPromise;
+    const promise = Promise.resolve(
+      isPromiseLike(deferredRouteProps) ? deferredRouteProps : resolveProgrammaticRouteProps(route, props)
+    );
+    resource = { status: "pending", promise };
+    resources.set(props, resource);
+    promise.then(
+      (value) => resources.set(props, { status: "resolved", value }),
+      (error) => resources.set(props, { status: "rejected", error })
+    );
+  }
+  if (resource.status === "pending") throw resource.promise;
+  if (resource.status === "rejected") throw resource.error;
+  return resource.value;
+}
+__name(readProgrammaticRouteProps, "readProgrammaticRouteProps");
+function isPromiseLike(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function"
+  );
+}
+__name(isPromiseLike, "isPromiseLike");
+function createProgrammaticRoutePendingProps(props) {
+  return {
+    params: props.params,
+    searchParams: props.searchParams,
+    path: props.path
+  };
+}
+__name(createProgrammaticRoutePendingProps, "createProgrammaticRoutePendingProps");
+function createProgrammaticRouteErrorProps(error, props) {
+  return {
+    error,
+    params: props.params,
+    searchParams: props.searchParams,
+    path: props.path
+  };
+}
+__name(createProgrammaticRouteErrorProps, "createProgrammaticRouteErrorProps");
+function isProgrammaticRedirectSignal(error) {
+  if (!error || typeof error !== "object") return false;
+  const digest = error.digest;
+  return typeof digest === "string" && digest.startsWith("FARM_REDIRECT;");
+}
+__name(isProgrammaticRedirectSignal, "isProgrammaticRedirectSignal");
+function isProgrammaticNotFoundSignal(error) {
+  if (!error || typeof error !== "object") return false;
+  const digest = error.digest;
+  return digest === "FARM_NOT_FOUND";
+}
+__name(isProgrammaticNotFoundSignal, "isProgrammaticNotFoundSignal");
+async function resolveProgrammaticRouteProps(route, props) {
+  const rawSearch = await props.searchParams;
+  const params = parseProgrammaticSchema(route.params, props.params, "params", route.path);
+  const { search, canonicalPath } = resolveProgrammaticRouteSearch(
+    route.search,
+    rawSearch,
+    props.path,
+    route.path
+  );
+  const routeContextValue = getFarmRouteContext(props);
+  const pluginContext = props.context;
+  const baseProps = {
+    ...props,
+    params,
+    search,
+    searchParams: Promise.resolve(search)
+  };
+  const routeContextProps = {
+    ...baseProps,
+    context: routeContextValue,
+    pluginContext
+  };
+  if (route.guard) {
+    await route.guard(routeContextProps);
+  }
+  if (!route.data) {
+    return markProgrammaticRoutePropsResolved(addCanonicalPath(baseProps, canonicalPath));
+  }
+  const before = route.data.before ? await route.data.before(routeContextProps) : void 0;
+  const dataContext = {
+    ...routeContextProps,
+    before
+  };
+  const data = await resolveProgrammaticRouteData(route, route.data, dataContext);
+  if (route.data.after) {
+    await route.data.after({
+      ...routeContextProps,
+      before,
+      data
+    });
+  }
+  return markProgrammaticRoutePropsResolved({
+    ...baseProps,
+    data,
+    ...canonicalPath ? { __farmCanonicalPath: canonicalPath } : {}
+  });
+}
+__name(resolveProgrammaticRouteProps, "resolveProgrammaticRouteProps");
+async function resolveProgrammaticRouteData(route, dataHooks, context) {
+  if (!dataHooks?.key) {
+    return dataHooks.main(context);
+  }
+  const routeDataKey = await dataHooks.key(context);
+  if (routeDataKey == null) {
+    return dataHooks.main(context);
+  }
+  const cacheKey = createFarmCacheKey(["route-data", routeDataKey]);
+  const cacheOptions = {
+    tags: [
+      createRouteDataCacheTag(routeDataKey),
+      ...await resolveProgrammaticRouteDataKeys(dataHooks.tags, context)
+    ],
+    paths: [
+      ...typeof context.path === "string" ? [context.path] : [],
+      ...await resolveProgrammaticRouteDataKeys(dataHooks.paths, context)
+    ],
+    revalidate: normalizeProgrammaticRouteStaleTime(dataHooks.staleTime)
+  };
+  return getFarmDataCache().getOrSet(cacheKey, () => dataHooks.main(context), cacheOptions);
+}
+__name(resolveProgrammaticRouteData, "resolveProgrammaticRouteData");
+async function resolveProgrammaticRouteDataKeys(input, context) {
+  if (!input) return [];
+  const value = typeof input === "function" ? await input(context) : input;
+  return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+__name(resolveProgrammaticRouteDataKeys, "resolveProgrammaticRouteDataKeys");
+function normalizeProgrammaticRouteStaleTime(staleTime) {
+  if (staleTime === void 0) return void 0;
+  if (staleTime === false) return false;
+  if (typeof staleTime === "number") {
+    if (!Number.isFinite(staleTime) || staleTime <= 0) return void 0;
+    return Math.max(1, Math.ceil(staleTime / 1e3));
+  }
+  const match = staleTime.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/);
+  if (!match) return void 0;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return void 0;
+  const unit = match[2];
+  const milliseconds = unit === "ms" ? value : unit === "s" ? value * 1e3 : unit === "m" ? value * 6e4 : value * 36e5;
+  return Math.max(1, Math.ceil(milliseconds / 1e3));
+}
+__name(normalizeProgrammaticRouteStaleTime, "normalizeProgrammaticRouteStaleTime");
+function isProgrammaticRoutePropsResolved(value) {
+  return !!value && typeof value === "object" && value.__farmRoutePropsResolved === true;
+}
+__name(isProgrammaticRoutePropsResolved, "isProgrammaticRoutePropsResolved");
+function markProgrammaticRoutePropsResolved(props) {
+  return {
+    ...props,
+    __farmRoutePropsResolved: true
+  };
+}
+__name(markProgrammaticRoutePropsResolved, "markProgrammaticRoutePropsResolved");
+function addCanonicalPath(props, canonicalPath) {
+  return canonicalPath ? { ...props, __farmCanonicalPath: canonicalPath } : props;
+}
+__name(addCanonicalPath, "addCanonicalPath");
+function stripProgrammaticRoutePropsMarker(props) {
+  if (!isProgrammaticRoutePropsResolved(props)) {
+    return props;
+  }
+  const {
+    __farmRoutePropsResolved,
+    __farmCanonicalPath,
+    __farmRoutePropsPromise,
+    ...componentProps
+  } = props;
+  return componentProps;
+}
+__name(stripProgrammaticRoutePropsMarker, "stripProgrammaticRoutePropsMarker");
+function parseProgrammaticSchema(schema, value, label, routePath) {
+  if (!schema) {
+    return value;
+  }
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid ${label} for route "${routePath}": ${message}`);
+  }
+}
+__name(parseProgrammaticSchema, "parseProgrammaticSchema");
+function normalizeProgrammaticRoute(route) {
+  if (route.kind === "redirect") {
+    return {
+      ...route,
+      source: normalizeRoutePath(route.source)
+    };
+  }
+  if (route.kind === "api") {
+    return {
+      ...route,
+      ...normalizeFarmRouteRuntimeConfig(route, `API route "${route.path}"`),
+      path: normalizeRoutePath(route.path),
+      methods: normalizeApiMethods(route.methods)
+    };
+  }
+  return {
+    ...route,
+    ...normalizeFarmRouteRuntimeConfig(
+      route,
+      `${route.kind === "layout" ? "Layout" : "Route"} "${route.path}"`
+    ),
+    path: normalizeRoutePath(route.path)
+  };
+}
+__name(normalizeProgrammaticRoute, "normalizeProgrammaticRoute");
+function normalizeRoutePath(routePath) {
+  const withSlash = routePath.startsWith("/") ? routePath : `/${routePath}`;
+  const withoutTrailing = withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+  return withoutTrailing || "/";
+}
+__name(normalizeRoutePath, "normalizeRoutePath");
+function parseRouteSegment(segment) {
+  if (segment.startsWith("[") && segment.endsWith("]")) {
+    let name = segment.slice(1, -1);
+    let isOptional = false;
+    let isCatchAll = false;
+    if (name.startsWith("[") && name.endsWith("]")) {
+      isOptional = true;
+      name = name.slice(1, -1);
+    }
+    if (name.startsWith("...")) {
+      isCatchAll = true;
+      name = name.slice(3);
+    }
+    return {
+      segment: name,
+      isDynamic: true,
+      isOptional,
+      isCatchAll
+    };
+  }
+  return {
+    segment,
+    isDynamic: false,
+    isOptional: false,
+    isCatchAll: false
+  };
+}
+__name(parseRouteSegment, "parseRouteSegment");
+function normalizeApiMethods(methods) {
+  const normalized = {};
+  for (const [method, handler] of Object.entries(methods)) {
+    const normalizedMethod = method.toUpperCase();
+    if (handler && isProgrammaticRouteMethod(normalizedMethod)) {
+      normalized[normalizedMethod] = handler;
+    }
+  }
+  return normalized;
+}
+__name(normalizeApiMethods, "normalizeApiMethods");
+function isProgrammaticRouteMethod(method) {
+  return method === "GET" || method === "HEAD" || method === "POST" || method === "PUT" || method === "DELETE" || method === "PATCH" || method === "OPTIONS";
+}
+__name(isProgrammaticRouteMethod, "isProgrammaticRouteMethod");
+function normalizeStaticPaths(routePath, paths) {
+  const dynamicSegments = parseProgrammaticRoutePath(routePath).segments.filter(
+    (segment) => segment.isDynamic
+  );
+  return paths.map((entry) => {
+    if (typeof entry === "string" || Array.isArray(entry)) {
+      if (dynamicSegments.length !== 1) {
+        throw new Error(
+          `staticPaths for "${routePath}" must return objects when the route has ${dynamicSegments.length} dynamic params.`
+        );
+      }
+      const value = Array.isArray(entry) ? entry.join("/") : entry;
+      return { [dynamicSegments[0].segment]: String(value) };
+    }
+    return Object.fromEntries(
+      Object.entries(entry).map(([key, value]) => [
+        key,
+        Array.isArray(value) ? value.map(String).join("/") : String(value)
+      ])
+    );
+  });
+}
+__name(normalizeStaticPaths, "normalizeStaticPaths");
+
+// src/i18n/server.ts
+var import_node_async_hooks = require("async_hooks");
+
+// src/i18n/runtime.ts
+var import_intl_messageformat = __toESM(require("intl-messageformat"));
+
+// src/i18n/catalog.ts
+var import_promises = require("fs/promises");
+var import_icu_messageformat_parser = require("@formatjs/icu-messageformat-parser");
+
+// src/i18n/config.ts
+var import_node_path = __toESM(require("path"));
+var DEFAULT_FARM_I18N_COOKIE_MAX_AGE = 60 * 60 * 24 * 365;
+
+// src/i18n/server.ts
+var FARM_I18N_REQUEST_STORE = /* @__PURE__ */ Symbol.for("farm.i18n.requestStore");
+function getRequestStore() {
+  const state = globalThis;
+  return state[FARM_I18N_REQUEST_STORE] ?? (state[FARM_I18N_REQUEST_STORE] = new import_node_async_hooks.AsyncLocalStorage());
+}
+__name(getRequestStore, "getRequestStore");
+function getState() {
+  const state = getRequestStore().getStore();
+  if (!state) {
+    throw new Error(
+      "No Farm i18n request context is active. Use this API while rendering, inside an API route, or use createTranslator(locale)."
+    );
+  }
+  return state;
+}
+__name(getState, "getState");
+var t = createTranslatorFromState(() => getState());
+function getFarmI18nClientSnapshot() {
+  return getRequestStore().getStore()?.snapshot;
+}
+__name(getFarmI18nClientSnapshot, "getFarmI18nClientSnapshot");
+function createTranslatorFromState(resolveState) {
+  const translator = /* @__PURE__ */ __name(((key, values) => {
+    const state = resolveState();
+    return state.runtime.translate(state.resolution.locale, key, values);
+  }), "translator");
+  translator.rich = (key, values) => {
+    const state = resolveState();
+    return state.runtime.translateRich(state.resolution.locale, key, values);
+  };
+  translator.raw = (key) => {
+    const state = resolveState();
+    return state.runtime.getRawMessage(state.resolution.locale, key);
+  };
+  translator.has = (key) => {
+    const state = resolveState();
+    return state.runtime.hasMessage(state.resolution.locale, key);
+  };
+  return translator;
+}
+__name(createTranslatorFromState, "createTranslatorFromState");
+_setFarmI18nSnapshotResolver(() => getFarmI18nClientSnapshot());
+
+// src/server/request.ts
+var import_node_async_hooks2 = require("async_hooks");
+
+// src/server/request-bridge.ts
+var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
+function getGlobalState() {
+  return globalThis;
+}
+__name(getGlobalState, "getGlobalState");
+function _setCurrentRequestResolver(resolver) {
+  getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY] = resolver;
+}
+__name(_setCurrentRequestResolver, "_setCurrentRequestResolver");
+
+// src/server/request.ts
+var REQUEST_STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-storage");
+function getRequestStore2() {
+  const runtime = globalThis;
+  const existing = runtime[REQUEST_STORAGE_KEY];
+  if (existing instanceof import_node_async_hooks2.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new import_node_async_hooks2.AsyncLocalStorage();
+  runtime[REQUEST_STORAGE_KEY] = storage;
+  return storage;
+}
+__name(getRequestStore2, "getRequestStore");
+var requestStore = getRequestStore2();
+_setCurrentRequestResolver(() => requestStore.getStore());
+async function _runWithCurrentRequest(request, fn) {
+  return requestStore.run(request, fn);
+}
+__name(_runWithCurrentRequest, "_runWithCurrentRequest");
+
+// src/api/runtime.ts
+function matchAPIRoute(routes, pathname) {
+  const exactRoute = routes.get(pathname);
+  if (exactRoute) {
+    return { route: exactRoute, params: {} };
+  }
+  const normalizedPathname = normalizePathname(pathname);
+  if (normalizedPathname !== pathname) {
+    const normalizedRoute = routes.get(normalizedPathname);
+    if (normalizedRoute) {
+      return { route: normalizedRoute, params: {} };
+    }
+  }
+  for (const route of routes.values()) {
+    const params = matchRoutePath(route.path, pathname);
+    if (params) {
+      return { route, params };
+    }
+  }
+  return null;
+}
+__name(matchAPIRoute, "matchAPIRoute");
+async function invokeAPIRouteEndpoint(endpoint, request, params = {}) {
+  return _runWithCurrentRequest(
+    request,
+    () => invokeAPIRouteEndpointInContext(endpoint, request, params)
+  );
+}
+__name(invokeAPIRouteEndpoint, "invokeAPIRouteEndpoint");
+async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
+  const farmHandler = endpoint.__handler || (isFarmContextHandler(endpoint) ? endpoint : null);
+  if (!farmHandler) {
+    const result2 = await endpoint(request, {
+      params: Promise.resolve(params)
+    });
+    return normalizeRouteResponse(result2);
+  }
+  const url = new URL(request.url);
+  const query = {};
+  url.searchParams.forEach((value, key) => {
+    query[key] = value;
+  });
+  let body = void 0;
+  if (request.method.toUpperCase() !== "GET" && request.method.toUpperCase() !== "HEAD") {
+    body = await readJSONBody(request);
+  }
+  const headers = Object.fromEntries(request.headers.entries());
+  const types = endpoint.__types || {};
+  const queryValidation = validateInput(types.query, query, "Invalid query parameters");
+  if (queryValidation instanceof Response) {
+    return queryValidation;
+  }
+  const bodyValidation = validateInput(types.body, body, "Invalid request body");
+  if (bodyValidation instanceof Response) {
+    return bodyValidation;
+  }
+  const headersValidation = validateInput(types.headers, headers, "Invalid request headers");
+  if (headersValidation instanceof Response) {
+    return headersValidation;
+  }
+  const result = await farmHandler({
+    query: queryValidation,
+    body: bodyValidation,
+    headers: headersValidation,
+    request,
+    context: {},
+    params
+  });
+  return normalizeRouteResponse(result);
+}
+__name(invokeAPIRouteEndpointInContext, "invokeAPIRouteEndpointInContext");
+function normalizeRouteResponse(result) {
+  if (isWebResponse(result)) {
+    return result;
+  }
+  if (result === void 0) {
+    return new Response(null, { status: 204 });
+  }
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+__name(normalizeRouteResponse, "normalizeRouteResponse");
+function isWebResponse(value) {
+  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
+}
+__name(isWebResponse, "isWebResponse");
+function isFarmContextHandler(endpoint) {
+  if (typeof endpoint !== "function") {
+    return false;
+  }
+  const source = Function.prototype.toString.call(endpoint).trim();
+  const arrowMatch = source.match(/^(?:async\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*=>/);
+  const functionMatch = source.match(/^(?:async\s*)?function[^(]*\(([^)]*)\)/);
+  const firstParameter = (arrowMatch?.[1] || arrowMatch?.[2] || functionMatch?.[1] || "").split(",")[0].trim();
+  return firstParameter === "ctx" || firstParameter === "context" || firstParameter.startsWith("{");
+}
+__name(isFarmContextHandler, "isFarmContextHandler");
+async function readJSONBody(request) {
+  try {
+    const text = await request.clone().text();
+    if (text) {
+      return JSON.parse(text);
+    }
+  } catch {
+  }
+  return void 0;
+}
+__name(readJSONBody, "readJSONBody");
+function validateInput(schema, value, error) {
+  if (!schema || typeof schema.parse !== "function") {
+    return value;
+  }
+  try {
+    return schema.parse(value);
+  } catch (validationError) {
+    return new Response(
+      JSON.stringify({
+        error,
+        details: validationError.errors || validationError.issues || validationError.message
+      }),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+}
+__name(validateInput, "validateInput");
+function matchRoutePath(routePath, pathname) {
+  const routeSegments = getPathSegments(routePath);
+  const pathnameSegments = getPathSegments(pathname);
+  const params = {};
+  let pathIndex = 0;
+  for (const routeSegment of routeSegments) {
+    const dynamicSegment = parseDynamicSegment(routeSegment);
+    if (dynamicSegment?.catchAll) {
+      const remainingSegments = pathnameSegments.slice(pathIndex).map(decodePathSegment);
+      if (remainingSegments.length === 0 && !dynamicSegment.optional) {
+        return null;
+      }
+      if (remainingSegments.length > 0) {
+        params[dynamicSegment.name] = remainingSegments;
+      }
+      pathIndex = pathnameSegments.length;
+      continue;
+    }
+    const pathnameSegment = pathnameSegments[pathIndex];
+    if (pathnameSegment === void 0) {
+      return null;
+    }
+    if (dynamicSegment) {
+      params[dynamicSegment.name] = decodePathSegment(pathnameSegment);
+      pathIndex++;
+      continue;
+    }
+    if (routeSegment !== pathnameSegment) {
+      return null;
+    }
+    pathIndex++;
+  }
+  return pathIndex === pathnameSegments.length ? params : null;
+}
+__name(matchRoutePath, "matchRoutePath");
+function getPathSegments(pathname) {
+  return normalizePathname(pathname).split("/").filter((segment) => segment.length > 0);
+}
+__name(getPathSegments, "getPathSegments");
+function normalizePathname(pathname) {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.replace(/\/+$/, "");
+  }
+  return pathname;
+}
+__name(normalizePathname, "normalizePathname");
+function parseDynamicSegment(segment) {
+  const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
+  if (optionalCatchAll?.[1]) {
+    return { name: optionalCatchAll[1], catchAll: true, optional: true };
+  }
+  const catchAll = segment.match(/^\[\.\.\.(.+)\]$/);
+  if (catchAll?.[1]) {
+    return { name: catchAll[1], catchAll: true, optional: false };
+  }
+  const dynamic = segment.match(/^\[(.+)\]$/);
+  if (dynamic?.[1]) {
+    return { name: dynamic[1], catchAll: false, optional: false };
+  }
+  return null;
+}
+__name(parseDynamicSegment, "parseDynamicSegment");
+function decodePathSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+__name(decodePathSegment, "decodePathSegment");
+
+// src/router.ts
+function matchFarmRoute(pattern, pathname) {
+  return matchSegments(parseRoutePattern(pattern), normalizePathname2(pathname));
+}
+__name(matchFarmRoute, "matchFarmRoute");
+function buildFarmRoutePath(pattern, params = {}, options = {}) {
+  const parts = [];
+  for (const segment of parseRoutePattern(pattern)) {
+    if (segment.type === "static") {
+      parts.push(encodePathSegment(segment.value));
+      continue;
+    }
+    const value = params[segment.name];
+    const values = Array.isArray(value) ? value : value == null ? [] : [value];
+    if (values.length === 0) {
+      if (segment.optional) continue;
+      throw new Error(`Missing route param "${segment.name}" for ${pattern}.`);
+    }
+    if (!segment.catchAll && values.length > 1) {
+      throw new Error(`Route param "${segment.name}" for ${pattern} expects a single value.`);
+    }
+    parts.push(...values.map((item) => encodePathSegment(String(item))));
+  }
+  let pathname = parts.length ? `/${parts.join("/")}` : "/";
+  if (options.trailingSlash && pathname !== "/") {
+    pathname = `${pathname}/`;
+  }
+  return appendQueryAndHash(pathname, options);
+}
+__name(buildFarmRoutePath, "buildFarmRoutePath");
+function parseRoutePattern(pattern) {
+  return splitPathname(pattern).filter((part) => !isRouteGroup(part)).map((part) => {
+    const optionalCatchAll = part.match(/^\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]$/);
+    if (optionalCatchAll) {
+      return {
+        type: "dynamic",
+        name: optionalCatchAll[1],
+        catchAll: true,
+        optional: true
+      };
+    }
+    const catchAll = part.match(/^\[\.\.\.([A-Za-z0-9_$-]+)\]$/);
+    if (catchAll) {
+      return {
+        type: "dynamic",
+        name: catchAll[1],
+        catchAll: true,
+        optional: false
+      };
+    }
+    const dynamic = part.match(/^\[([A-Za-z0-9_$-]+)\]$/) || part.match(/^:([A-Za-z0-9_$-]+)$/);
+    if (dynamic) {
+      return {
+        type: "dynamic",
+        name: dynamic[1],
+        catchAll: false,
+        optional: false
+      };
+    }
+    const star = part.match(/^\*([A-Za-z0-9_$-]+)(\?)?$/);
+    if (star) {
+      return {
+        type: "dynamic",
+        name: star[1],
+        catchAll: true,
+        optional: !!star[2]
+      };
+    }
+    return {
+      type: "static",
+      value: decodePathSegment2(part)
+    };
+  });
+}
+__name(parseRoutePattern, "parseRoutePattern");
+function matchSegments(segments, pathname) {
+  const parts = splitPathname(pathname);
+  const params = {};
+  if (segments.length === 0) {
+    return parts.length === 0 ? params : null;
+  }
+  let pathIndex = 0;
+  for (const segment of segments) {
+    if (segment.type === "static") {
+      if (decodePathSegment2(parts[pathIndex] || "") !== segment.value) return null;
+      pathIndex++;
+      continue;
+    }
+    if (segment.catchAll) {
+      const remaining = parts.slice(pathIndex).map(decodePathSegment2);
+      if (remaining.length === 0 && !segment.optional) return null;
+      params[segment.name] = remaining.join("/");
+      pathIndex = parts.length;
+      continue;
+    }
+    const value = parts[pathIndex];
+    if (!value) return null;
+    params[segment.name] = decodePathSegment2(value);
+    pathIndex++;
+  }
+  return pathIndex === parts.length ? params : null;
+}
+__name(matchSegments, "matchSegments");
+function normalizePathname2(value) {
+  const raw = value || "/";
+  let pathname = raw;
+  try {
+    pathname = new URL(raw, "http://farm.local").pathname;
+  } catch {
+    pathname = raw.split(/[?#]/, 1)[0] || "/";
+  }
+  pathname = pathname.replace(/\\/g, "/").replace(/\/+/g, "/");
+  if (!pathname.startsWith("/")) pathname = `/${pathname}`;
+  if (pathname.length > 1) pathname = pathname.replace(/\/+$/, "");
+  return pathname || "/";
+}
+__name(normalizePathname2, "normalizePathname");
+function splitPathname(pathname) {
+  return normalizePathname2(pathname).split("/").filter(Boolean);
+}
+__name(splitPathname, "splitPathname");
+function isRouteGroup(part) {
+  return part.startsWith("(") && part.endsWith(")");
+}
+__name(isRouteGroup, "isRouteGroup");
+function decodePathSegment2(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+__name(decodePathSegment2, "decodePathSegment");
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+__name(encodePathSegment, "encodePathSegment");
+function appendQueryAndHash(pathname, options) {
+  const search = createSearchParams2(options.query);
+  const hash = options.hash ? `#${options.hash.replace(/^#/, "")}` : "";
+  const query = search.toString();
+  return `${pathname}${query ? `?${query}` : ""}${hash}`;
+}
+__name(appendQueryAndHash, "appendQueryAndHash");
+function createSearchParams2(query) {
+  if (query instanceof URLSearchParams) return query;
+  const search = new URLSearchParams();
+  if (!query) return search;
+  for (const [key, value] of Object.entries(query)) {
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      if (item == null) continue;
+      search.append(key, String(item));
+    }
+  }
+  return search;
+}
+__name(createSearchParams2, "createSearchParams");
+
+// src/server-action-security.ts
+var import_node_async_hooks3 = require("async_hooks");
+var SERVER_ACTION_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionStorage");
+function runWithServerActionRequest(request, callback) {
+  throwIfAborted(request.signal);
+  return getServerActionStorage().run(
+    {
+      request,
+      signal: request.signal,
+      invalidations: /* @__PURE__ */ new Set()
+    },
+    callback
+  );
+}
+__name(runWithServerActionRequest, "runWithServerActionRequest");
+function getServerActionExecutionContext() {
+  return getServerActionStorage().getStore();
+}
+__name(getServerActionExecutionContext, "getServerActionExecutionContext");
+subscribeFarmCacheInvalidation((key) => {
+  getServerActionExecutionContext()?.invalidations.add(key);
+});
+function getServerActionStorage() {
+  const globalState2 = globalThis;
+  if (!globalState2[SERVER_ACTION_STORAGE_KEY]) {
+    globalState2[SERVER_ACTION_STORAGE_KEY] = new import_node_async_hooks3.AsyncLocalStorage();
+  }
+  return globalState2[SERVER_ACTION_STORAGE_KEY];
+}
+__name(getServerActionStorage, "getServerActionStorage");
+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/testing.ts
+function createTestRequest(path2 = "/", options = {}) {
+  const url = resolveTestURL(path2, options.origin);
+  applyQuery(url.searchParams, options.query);
+  const headers = new Headers(options.headers);
+  applyCookies(headers, options.cookies);
+  const { body, hasBody } = resolveRequestBody(options, headers);
+  const method = (options.method ?? (hasBody ? "POST" : "GET")).toUpperCase();
+  if ((method === "GET" || method === "HEAD") && body != null) {
+    throw new TypeError(`Farm test requests cannot send a body with ${method}`);
+  }
+  const {
+    origin: _origin,
+    query: _query,
+    cookies: _cookies,
+    json: _json,
+    form: _form,
+    body: _body,
+    headers: _headers,
+    ...requestInit
+  } = options;
+  return new Request(url, {
+    ...requestInit,
+    method,
+    headers,
+    body
+  });
+}
+__name(createTestRequest, "createTestRequest");
+function createFarmTestHarness(options = {}) {
+  const origin = normalizeOrigin(options.origin);
+  const request = /* @__PURE__ */ __name((path2 = "/", requestOptions = {}) => createTestRequest(path2, mergeRequestDefaults(options, origin, requestOptions)), "request");
+  return {
+    request,
+    async route(route, routeOptions = {}) {
+      const requestPath = routeOptions.path ?? buildFarmRoutePath(route.path, routeOptions.params ?? {});
+      const routeRequest = request(requestPath, {
+        origin: routeOptions.origin,
+        headers: routeOptions.headers,
+        cookies: routeOptions.cookies,
+        signal: routeOptions.signal,
+        query: routeOptions.search
+      });
+      const url = new URL(routeRequest.url);
+      const params = resolvePageParams(route.path, url.pathname, routeOptions.params);
+      const search = readSearchParams(url.searchParams);
+      const routeContext = Object.prototype.hasOwnProperty.call(routeOptions, "context") ? routeOptions.context : await resolveFarmRouteContext(
+        { context: options.context },
+        {
+          request: routeRequest,
+          params,
+          search,
+          path: url.pathname
+        }
+      );
+      const rawProps = withFarmRouteContext(
+        {
+          params,
+          searchParams: Promise.resolve(search),
+          path: url.pathname,
+          middleware: routeOptions.middleware,
+          context: routeOptions.pluginContext
+        },
+        routeContext
+      );
+      const routeModule = createRouteModuleFromProgrammaticPage(route);
+      const resolveProps = routeModule.__farmResolveRouteProps;
+      const resolvedProps = resolveProps ? await resolveProps(rawProps) : { ...rawProps, search, searchParams: Promise.resolve(search) };
+      const canonicalPath = readCanonicalPath(resolvedProps);
+      const componentProps = stripInternalRouteProps(resolvedProps);
+      return {
+        route,
+        module: routeModule,
+        request: routeRequest,
+        props: componentProps,
+        element: (0, import_react2.createElement)(route.component, componentProps),
+        canonicalPath
+      };
+    },
+    async api(route, apiOptions = {}) {
+      const requestPath = apiOptions.path ?? buildFarmRoutePath(route.path, apiOptions.params ?? {});
+      const method = apiOptions.method ?? getDefaultApiMethod(route);
+      const apiRequest = request(requestPath, omitApiControlOptions({ ...apiOptions, method }));
+      const match = matchAPIRoute(/* @__PURE__ */ new Map([[route.path, route]]), new URL(apiRequest.url).pathname);
+      if (!match) {
+        return jsonErrorResponse("Not Found", 404);
+      }
+      const endpoint = match.route.methods[apiRequest.method];
+      if (!endpoint) {
+        return jsonErrorResponse("Method Not Allowed", 405);
+      }
+      return invokeTestEndpoint(endpoint, apiRequest, match.params, apiOptions.throwOnError);
+    },
+    async endpoint(endpoint, endpointOptions = {}) {
+      const endpointRecord = endpoint;
+      const endpointPath = endpointOptions.path ?? endpointRecord.__path ?? "/__farm/test/endpoint";
+      const endpointRequest = request(endpointPath, {
+        ...omitEndpointControlOptions(endpointOptions),
+        method: endpointOptions.method ?? endpointRecord.__method ?? "GET"
+      });
+      return invokeTestEndpoint(
+        endpoint,
+        endpointRequest,
+        endpointOptions.params,
+        endpointOptions.throwOnError
+      );
+    },
+    async serverFn(serverFn, ...args) {
+      const [input, serverFnOptions = {}] = args;
+      const actionRequest = serverFnOptions.request ?? request(serverFnOptions.path ?? "/__farm/test/server-fn", {
+        origin: serverFnOptions.origin,
+        headers: serverFnOptions.headers,
+        cookies: serverFnOptions.cookies,
+        signal: serverFnOptions.signal,
+        method: "POST"
+      });
+      return await runWithServerActionRequest(actionRequest, () => serverFn(input));
+    },
+    clearCache() {
+      getFarmDataCache().clear();
+    }
+  };
+}
+__name(createFarmTestHarness, "createFarmTestHarness");
+function resolveTestURL(path2, origin) {
+  const url = path2 instanceof URL ? new URL(path2) : new URL(path2, `${normalizeOrigin(origin)}/`);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new TypeError(`Farm test requests require an HTTP(S) URL, received ${url.protocol}`);
+  }
+  return url;
+}
+__name(resolveTestURL, "resolveTestURL");
+function normalizeOrigin(origin = "http://farm.test") {
+  let url;
+  try {
+    url = new URL(origin);
+  } catch {
+    throw new TypeError(`Invalid Farm test origin: ${JSON.stringify(origin)}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new TypeError(`Farm test origins must use HTTP(S), received ${url.protocol}`);
+  }
+  return url.origin;
+}
+__name(normalizeOrigin, "normalizeOrigin");
+function mergeRequestDefaults(harnessOptions, origin, requestOptions) {
+  const headers = new Headers(harnessOptions.headers);
+  new Headers(requestOptions.headers).forEach((value, key) => headers.set(key, value));
+  return {
+    ...requestOptions,
+    origin: requestOptions.origin ?? origin,
+    headers,
+    cookies: {
+      ...harnessOptions.cookies,
+      ...requestOptions.cookies
+    }
+  };
+}
+__name(mergeRequestDefaults, "mergeRequestDefaults");
+function applyQuery(searchParams, query) {
+  if (!query) return;
+  if (query instanceof URLSearchParams) {
+    for (const key of new Set(query.keys())) {
+      searchParams.delete(key);
+      for (const value of query.getAll(key)) searchParams.append(key, value);
+    }
+    return;
+  }
+  for (const [key, rawValue] of Object.entries(query)) {
+    searchParams.delete(key);
+    const values = Array.isArray(rawValue) ? rawValue : [rawValue];
+    for (const value of values) {
+      if (value == null) continue;
+      if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+        throw new TypeError(`Invalid query value for ${JSON.stringify(key)}`);
+      }
+      searchParams.append(key, String(value));
+    }
+  }
+}
+__name(applyQuery, "applyQuery");
+function applyCookies(headers, cookies) {
+  if (!cookies || Object.keys(cookies).length === 0) return;
+  const value = Object.entries(cookies).map(([name, cookieValue]) => `${encodeURIComponent(name)}=${encodeURIComponent(cookieValue)}`).join("; ");
+  const current = headers.get("cookie");
+  headers.set("cookie", current ? `${current}; ${value}` : value);
+}
+__name(applyCookies, "applyCookies");
+function resolveRequestBody(options, headers) {
+  const sources = [
+    options.json !== void 0,
+    options.form !== void 0,
+    options.body !== void 0
+  ];
+  if (sources.filter(Boolean).length > 1) {
+    throw new TypeError("Farm test requests accept only one of json, form, or body");
+  }
+  if (options.json !== void 0) {
+    if (!headers.has("content-type")) headers.set("content-type", "application/json");
+    return { body: JSON.stringify(options.json), hasBody: true };
+  }
+  if (options.form !== void 0) {
+    const formData = options.form instanceof FormData ? options.form : createFormData(options.form);
+    return { body: formData, hasBody: true };
+  }
+  return {
+    body: options.body ?? null,
+    hasBody: options.body !== void 0
+  };
+}
+__name(resolveRequestBody, "resolveRequestBody");
+function createFormData(values) {
+  const formData = new FormData();
+  for (const [key, rawValue] of Object.entries(values)) {
+    const entries = Array.isArray(rawValue) ? rawValue : [rawValue];
+    for (const value of entries) formData.append(key, value);
+  }
+  return formData;
+}
+__name(createFormData, "createFormData");
+function resolvePageParams(pattern, pathname, explicitParams) {
+  const matchedParams = matchFarmRoute(pattern, pathname);
+  if (!matchedParams) {
+    throw new Error(
+      `Path ${JSON.stringify(pathname)} does not match route ${JSON.stringify(pattern)}`
+    );
+  }
+  if (!explicitParams) return matchedParams;
+  return Object.fromEntries(
+    Object.entries(explicitParams).map(([key, value]) => [
+      key,
+      Array.isArray(value) ? value.map(String).join("/") : String(value)
+    ])
+  );
+}
+__name(resolvePageParams, "resolvePageParams");
+function readSearchParams(searchParams) {
+  const search = {};
+  searchParams.forEach((value, key) => {
+    search[key] = value;
+  });
+  return search;
+}
+__name(readSearchParams, "readSearchParams");
+function readCanonicalPath(props) {
+  return typeof props.__farmCanonicalPath === "string" ? props.__farmCanonicalPath : void 0;
+}
+__name(readCanonicalPath, "readCanonicalPath");
+function stripInternalRouteProps(props) {
+  const { __farmRoutePropsResolved, __farmCanonicalPath, ...componentProps } = props;
+  return componentProps;
+}
+__name(stripInternalRouteProps, "stripInternalRouteProps");
+function getDefaultApiMethod(route) {
+  if (route.methods.GET) return "GET";
+  return Object.keys(route.methods)[0] ?? "GET";
+}
+__name(getDefaultApiMethod, "getDefaultApiMethod");
+function omitApiControlOptions(options) {
+  const { path: _path, params: _params, throwOnError: _throwOnError, ...requestOptions } = options;
+  return requestOptions;
+}
+__name(omitApiControlOptions, "omitApiControlOptions");
+function omitEndpointControlOptions(options) {
+  const { path: _path, params: _params, throwOnError: _throwOnError, ...requestOptions } = options;
+  return requestOptions;
+}
+__name(omitEndpointControlOptions, "omitEndpointControlOptions");
+async function invokeTestEndpoint(endpoint, request, params = {}, throwOnError = false) {
+  try {
+    return await invokeAPIRouteEndpoint(endpoint, request, params);
+  } catch (error) {
+    if (throwOnError) throw error;
+    return jsonErrorResponse(error instanceof Error ? error.message : "Internal Server Error", 500);
+  }
+}
+__name(invokeTestEndpoint, "invokeTestEndpoint");
+function jsonErrorResponse(error, status) {
+  return Response.json({ error }, { status });
+}
+__name(jsonErrorResponse, "jsonErrorResponse");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFarmTestHarness,
+  createTestRequest
+});
+//# sourceMappingURL=testing.cjs.map