@farm.js/core 0.1.16 → 0.1.18

package/dist/testing.cjs

@@ -1,3130 +1,71 @@
-"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 __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-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/tracing.ts
-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 ?? []]
-  };
-}
-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;
-}
-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;
-}
-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;
-  }
-}
-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");
-}
-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;
-}
-function getEventError(event) {
-  return "error" in event ? event.error : void 0;
-}
-function recordSpanException(span, error) {
-  const normalized = error instanceof Error ? error : new Error(String(error));
-  span.recordException(normalized);
-  return normalized;
-}
-function recordSpanError(span, error) {
-  const normalized = recordSpanException(span, error);
-  span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: normalized.message });
-}
-function setResponseStatus(span, status) {
-  span.setAttribute("http.response.status_code", status);
-  if (status >= 500) {
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR });
-  }
-}
-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
-  };
-}
-var import_api, FARM_TRACER_NAME, ALL_SPAN_KINDS, DEFAULT_IGNORED_PATHS, FARM_REQUEST_METHOD_CONTEXT_KEY, TRACING_RUNTIME, runtime, tracingState;
-var init_tracing = __esm({
-  "src/tracing.ts"() {
-    "use strict";
-    import_api = require("@opentelemetry/api");
-    FARM_TRACER_NAME = "@farm.js/core";
-    ALL_SPAN_KINDS = [
-      "request",
-      "render",
-      "middleware",
-      "api",
-      "integration",
-      "storage",
-      "ppr",
-      "build",
-      "plugin"
-    ];
-    DEFAULT_IGNORED_PATHS = [
-      "/@vite/",
-      "/@fs/",
-      "/@id/",
-      "/@react-refresh",
-      "/node_modules/",
-      "/__vite",
-      "/.well-known/appspecific/"
-    ];
-    FARM_REQUEST_METHOD_CONTEXT_KEY = (0, import_api.createContextKey)("@farm.js/core/request-method");
-    TRACING_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/tracing-runtime/v1");
-    runtime = globalThis;
-    tracingState = runtime[TRACING_RUNTIME] ?? (runtime[TRACING_RUNTIME] = normalizeFarmTracingConfig(false));
-    __name(normalizeFarmTracingConfig, "normalizeFarmTracingConfig");
-    __name(recordFarmEventTrace, "recordFarmEventTrace");
-    __name(recordCompletedEventSpan, "recordCompletedEventSpan");
-    __name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
-    __name(hashFarmCacheKey, "hashFarmCacheKey");
-    __name(toEventAttributes, "toEventAttributes");
-    __name(getEventError, "getEventError");
-    __name(recordSpanException, "recordSpanException");
-    __name(recordSpanError, "recordSpanError");
-    __name(setResponseStatus, "setResponseStatus");
-    __name(getSpanTraceContext, "getSpanTraceContext");
-  }
-});
-
-// src/observability.ts
-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;
-}
-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)}`);
-    }
-  }
-}
-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;
-}
-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";
-}
-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;
-  }
-}
-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(" ")}` : "";
-}
-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);
-  }
-}
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-var OBSERVABILITY_RUNTIME, runtime2, shared, runtimeHandlers, unfilteredRuntimeHandlers, observabilityState;
-var init_observability = __esm({
-  "src/observability.ts"() {
-    "use strict";
-    init_tracing();
-    OBSERVABILITY_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/observability-runtime/v1");
-    runtime2 = globalThis;
-    shared = runtime2[OBSERVABILITY_RUNTIME] ?? (runtime2[OBSERVABILITY_RUNTIME] = {
-      handlers: /* @__PURE__ */ new Set(),
-      unfilteredHandlers: /* @__PURE__ */ new Set(),
-      config: { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) }
-    });
-    runtimeHandlers = shared.handlers;
-    unfilteredRuntimeHandlers = shared.unfilteredHandlers;
-    observabilityState = shared.config;
-    __name(emitFarmEvent, "emitFarmEvent");
-    __name(notifyFarmEventHandlers, "notifyFarmEventHandlers");
-    __name(shouldEmitFarmEvent, "shouldEmitFarmEvent");
-    __name(inferFarmEventLevel, "inferFarmEventLevel");
-    __name(logFarmEvent, "logFarmEvent");
-    __name(formatFarmEventDetails, "formatFarmEventDetails");
-    __name(formatDetailValue, "formatDetailValue");
-    __name(formatError, "formatError");
-  }
-});
-
-// src/cache-invalidation.ts
-function getFarmCacheInvalidationState() {
-  return globalState[FARM_CACHE_INVALIDATION_STATE] ?? (globalState[FARM_CACHE_INVALIDATION_STATE] = {
-    listeners: /* @__PURE__ */ new Set(),
-    taskListeners: /* @__PURE__ */ new Set()
-  });
-}
-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));
-}
-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 [];
-  }
-}
-function subscribeFarmCacheInvalidation(listener) {
-  const state = getFarmCacheInvalidationState();
-  state.listeners.add(listener);
-  return () => state.listeners.delete(listener);
-}
-function subscribeFarmCacheTask(listener) {
-  const state = getFarmCacheInvalidationState();
-  state.taskListeners.add(listener);
-  return () => state.taskListeners.delete(listener);
-}
-var FARM_CACHE_INVALIDATION_HEADER, FARM_CACHE_INVALIDATION_STATE, globalState;
-var init_cache_invalidation = __esm({
-  "src/cache-invalidation.ts"() {
-    "use strict";
-    FARM_CACHE_INVALIDATION_HEADER = "x-farm-cache-invalidations";
-    FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationState");
-    globalState = globalThis;
-    __name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
-    __name(encodeFarmCacheInvalidations, "encodeFarmCacheInvalidations");
-    __name(decodeFarmCacheInvalidations, "decodeFarmCacheInvalidations");
-    __name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
-    __name(subscribeFarmCacheTask, "subscribeFarmCacheTask");
-  }
-});
-
-// src/i18n/bridge.ts
-function _setFarmI18nSnapshotResolver(resolver) {
-  globalThis[FARM_I18N_SNAPSHOT_RESOLVER] = resolver;
-}
-var FARM_I18N_SNAPSHOT_RESOLVER;
-var init_bridge = __esm({
-  "src/i18n/bridge.ts"() {
-    "use strict";
-    FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
-    __name(_setFarmI18nSnapshotResolver, "_setFarmI18nSnapshotResolver");
-  }
-});
-
-// src/cache-invalidation-stream.ts
-var MAX_BUFFERED_BYTES, textEncoder;
-var init_cache_invalidation_stream = __esm({
-  "src/cache-invalidation-stream.ts"() {
-    "use strict";
-    init_cache_invalidation();
-    MAX_BUFFERED_BYTES = 64 * 1024;
-    textEncoder = new TextEncoder();
-  }
-});
-
-// src/cache.ts
-function getFarmDataCache() {
-  return sharedFarmDataCache;
-}
-function createPathCacheTag(routePath) {
-  return `path:${normalizeRevalidatePath(routePath)}`;
-}
-function createRouteDataCacheTag(key) {
-  return `route-data:${createRouteDataCacheKey(key)}`;
-}
-function createRouteDataCacheKey(key) {
-  return createFarmCacheKey(Array.isArray(key) ? key : [key]);
-}
-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 || "/";
-}
-function createFarmCacheKey(parts) {
-  return stableSerialize(parts);
-}
-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;
-}
-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;
-}
-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;
-}
-function normalizeAdapterVersion(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
-}
-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);
-}
-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;
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-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;
-}
-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)}.`
-    );
-  }
-}
-function getFunctionCacheIdentity(fn) {
-  const name = fn.name || "anonymous";
-  return `${name}:${hashFunctionSource(String(fn))}`;
-}
-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);
-}
-function compareCodepoint(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-function serializeBinaryBytes(bytes) {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-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(",");
-}
-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";
-}
-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";
-}
-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);
-}
-var _FarmDataCache, FarmDataCache, FARM_DATA_CACHE_SYMBOL, farmDataCacheGlobal, sharedFarmDataCache;
-var init_cache = __esm({
-  "src/cache.ts"() {
-    "use strict";
-    init_observability();
-    init_cache_invalidation();
-    init_bridge();
-    init_cache_invalidation();
-    init_cache_invalidation_stream();
-    _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");
-    FarmDataCache = _FarmDataCache;
-    FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
-    farmDataCacheGlobal = globalThis;
-    sharedFarmDataCache = farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] ?? (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] = new FarmDataCache());
-    __name(getFarmDataCache, "getFarmDataCache");
-    __name(createPathCacheTag, "createPathCacheTag");
-    __name(createRouteDataCacheTag, "createRouteDataCacheTag");
-    __name(createRouteDataCacheKey, "createRouteDataCacheKey");
-    __name(normalizeRevalidatePath, "normalizeRevalidatePath");
-    __name(createFarmCacheKey, "createFarmCacheKey");
-    __name(normalizeRevalidate, "normalizeRevalidate");
-    __name(normalizeCacheTag, "normalizeCacheTag");
-    __name(normalizeCacheNamespace, "normalizeCacheNamespace");
-    __name(normalizeAdapterVersion, "normalizeAdapterVersion");
-    __name(normalizePositiveDuration, "normalizePositiveDuration");
-    __name(normalizePositiveInteger, "normalizePositiveInteger");
-    __name(delay, "delay");
-    __name(normalizeCacheOptionsTags, "normalizeCacheOptionsTags");
-    __name(assertFarmCacheEntry, "assertFarmCacheEntry");
-    __name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
-    __name(hashFunctionSource, "hashFunctionSource");
-    __name(compareCodepoint, "compareCodepoint");
-    __name(serializeBinaryBytes, "serializeBinaryBytes");
-    __name(serializeCanonicalStringEntries, "serializeCanonicalStringEntries");
-    __name(isPlainCacheKeyObject, "isPlainCacheKeyObject");
-    __name(getCacheKeyValueType, "getCacheKeyValueType");
-    __name(stableSerialize, "stableSerialize");
-  }
-});
-
-// src/routing/specificity.ts
-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;
-}
-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}".`
-      );
-    }
-  }
-}
-function hasControlCharacter(value) {
-  return Array.from(value).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  });
-}
-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);
-  }
-}
-function splitRoutePattern(pattern, syntax) {
-  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
-    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
-  );
-}
-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}".`
-    );
-  }
-}
-var _AmbiguousRouteError, AmbiguousRouteError, _NonTerminalCatchAllRouteError, NonTerminalCatchAllRouteError, _DuplicateRouteParameterError, DuplicateRouteParameterError, _ReservedRouteParameterError, ReservedRouteParameterError, _BrowserUnstableRouteError, BrowserUnstableRouteError, SEGMENT_RANK, ROUTE_END_RANK, ROUTER_PARAMETER_NAME, PAGE_PARAMETER_PATTERN, ROUTER_PARAMETER_PATTERN, RESERVED_PARAMETER_NAMES;
-var init_specificity = __esm({
-  "src/routing/specificity.ts"() {
-    "use strict";
-    _AmbiguousRouteError = class _AmbiguousRouteError extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "AmbiguousRouteError";
-      }
-    };
-    __name(_AmbiguousRouteError, "AmbiguousRouteError");
-    AmbiguousRouteError = _AmbiguousRouteError;
-    _NonTerminalCatchAllRouteError = class _NonTerminalCatchAllRouteError extends TypeError {
-      constructor(message) {
-        super(message);
-        this.name = "NonTerminalCatchAllRouteError";
-      }
-    };
-    __name(_NonTerminalCatchAllRouteError, "NonTerminalCatchAllRouteError");
-    NonTerminalCatchAllRouteError = _NonTerminalCatchAllRouteError;
-    _DuplicateRouteParameterError = class _DuplicateRouteParameterError extends AmbiguousRouteError {
-      constructor(message) {
-        super(message);
-        this.name = "DuplicateRouteParameterError";
-      }
-    };
-    __name(_DuplicateRouteParameterError, "DuplicateRouteParameterError");
-    DuplicateRouteParameterError = _DuplicateRouteParameterError;
-    _ReservedRouteParameterError = class _ReservedRouteParameterError extends AmbiguousRouteError {
-      constructor(message) {
-        super(message);
-        this.name = "ReservedRouteParameterError";
-      }
-    };
-    __name(_ReservedRouteParameterError, "ReservedRouteParameterError");
-    ReservedRouteParameterError = _ReservedRouteParameterError;
-    _BrowserUnstableRouteError = class _BrowserUnstableRouteError extends TypeError {
-      constructor(message) {
-        super(message);
-        this.name = "BrowserUnstableRouteError";
-      }
-    };
-    __name(_BrowserUnstableRouteError, "BrowserUnstableRouteError");
-    BrowserUnstableRouteError = _BrowserUnstableRouteError;
-    SEGMENT_RANK = {
-      static: 4,
-      dynamic: 3,
-      "catch-all": 1,
-      "optional-catch-all": 0
-    };
-    ROUTE_END_RANK = 2;
-    __name(compareRouteSpecificity, "compareRouteSpecificity");
-    ROUTER_PARAMETER_NAME = "[A-Za-z0-9_$-]+";
-    PAGE_PARAMETER_PATTERN = /^(?:\[\[\.\.\.(.+)\]\]|\[\.\.\.(.+)\]|\[(.+)\])$/;
-    ROUTER_PARAMETER_PATTERN = /^(?:\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]|\[\.\.\.([A-Za-z0-9_$-]+)\]|\[([A-Za-z0-9_$-]+)\]|:([A-Za-z0-9_$-]+)|\*([A-Za-z0-9_$-]+)\??)$/;
-    RESERVED_PARAMETER_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-    __name(assertBrowserStableRoutePath, "assertBrowserStableRoutePath");
-    __name(hasControlCharacter, "hasControlCharacter");
-    __name(assertUniqueRouteParameters, "assertUniqueRouteParameters");
-    __name(splitRoutePattern, "splitRoutePattern");
-    __name(assertTerminalCatchAll, "assertTerminalCatchAll");
-  }
-});
-
-// src/route-call-scanner.ts
-var init_route_call_scanner = __esm({
-  "src/route-call-scanner.ts"() {
-    "use strict";
-  }
-});
-
-// src/routes-shared.ts
-function parseProgrammaticRoutePath(routePath, type = "page") {
-  const fileName = type === "layout" ? "layout.tsx" : "page.tsx";
-  const normalized = normalizeProgrammaticRoutePath(routePath);
-  assertTerminalCatchAll(normalized);
-  assertUniqueRouteParameters(normalized);
-  const filePath = normalized === "/" ? fileName : `${normalized.slice(1).replace(/\/+$/, "")}/${fileName}`;
-  return {
-    filePath,
-    segments: normalized.split("/").filter(Boolean).filter((segment) => !(segment.startsWith("(") && segment.endsWith(")"))).map(parseRouteSegment),
-    type
-  };
-}
-function normalizeProgrammaticRoutePath(routePath) {
-  if (routePath.includes("?") || routePath.includes("#")) {
-    throw new TypeError(
-      `Programmatic route path "${routePath}" must be a pathname without a query string or hash.`
-    );
-  }
-  const withSlash = routePath.startsWith("/") ? routePath : `/${routePath}`;
-  const withoutTrailing = withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
-  assertBrowserStableRoutePath(withoutTrailing);
-  return withoutTrailing || "/";
-}
-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 };
-}
-var init_routes_shared = __esm({
-  "src/routes-shared.ts"() {
-    "use strict";
-    init_specificity();
-    init_route_call_scanner();
-    __name(parseProgrammaticRoutePath, "parseProgrammaticRoutePath");
-    __name(normalizeProgrammaticRoutePath, "normalizeProgrammaticRoutePath");
-    __name(parseRouteSegment, "parseRouteSegment");
-  }
-});
-
-// 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;
-}
-var init_route_runtime = __esm({
-  "src/route-runtime.ts"() {
-    "use strict";
-    __name(normalizeFarmRouteRuntimeConfig, "normalizeFarmRouteRuntimeConfig");
-  }
-});
-
-// src/route-context.ts
-async function resolveFarmRouteContext(config, input) {
-  if (typeof config.context !== "function") {
-    return void 0;
-  }
-  return config.context(input);
-}
-function withFarmRouteContext(props, context2) {
-  if (context2 === void 0) {
-    return props;
-  }
-  Object.defineProperty(props, FARM_ROUTE_CONTEXT_SYMBOL, {
-    value: context2,
-    enumerable: false,
-    configurable: true
-  });
-  return props;
-}
-function getFarmRouteContext(props) {
-  if (!props || typeof props !== "object") {
-    return void 0;
-  }
-  return props[FARM_ROUTE_CONTEXT_SYMBOL];
-}
-var FARM_ROUTE_CONTEXT_SYMBOL;
-var init_route_context = __esm({
-  "src/route-context.ts"() {
-    "use strict";
-    FARM_ROUTE_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("farm.routeContext");
-    __name(resolveFarmRouteContext, "resolveFarmRouteContext");
-    __name(withFarmRouteContext, "withFarmRouteContext");
-    __name(getFarmRouteContext, "getFarmRouteContext");
-  }
-});
-
-// src/routes.ts
-function getProgrammaticRouteSearchSchema(search) {
-  if (!search) return void 0;
-  if (isProgrammaticRouteSchema(search)) return search;
-  return search.schema;
-}
-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;
-}
-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 };
-}
-function getProgrammaticRouteSearchOptions(search) {
-  if (!search || isProgrammaticRouteSchema(search)) return void 0;
-  return search;
-}
-function isProgrammaticRouteSchema(value) {
-  return !!value && typeof value === "object" && typeof value.parse === "function";
-}
-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;
-}
-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;
-}
-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;
-  }
-}
-function readSearchValue(value, key) {
-  return value && typeof value === "object" ? value[key] : void 0;
-}
-function searchValuesEqual(left, right) {
-  return JSON.stringify(normalizeComparableValue(left)) === JSON.stringify(normalizeComparableValue(right));
-}
-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;
-}
-function parseProgrammaticRoutePath2(routePath, type = "page") {
-  return parseProgrammaticRoutePath(routePath, type);
-}
-function createRouteModuleFromProgrammaticPage(route, rendererRuntime) {
-  const mod = {
-    default: createProgrammaticPageComponent(route, rendererRuntime),
-    ...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;
-}
-function createProgrammaticPageComponent(route, rendererRuntime) {
-  if (!route.params && !route.search && !route.guard && !route.data && !route.pending && !route.error && !route.notFound) {
-    return route.component;
-  }
-  const createElement2 = /* @__PURE__ */ __name((...args) => {
-    if (!rendererRuntime) {
-      throw new Error(
-        `Programmatic route "${route.path}" requires a FARMJS renderer runtime before it can render.`
-      );
-    }
-    return rendererRuntime.createElement(...args);
-  }, "createElement");
-  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 createElement2(Component, stripProgrammaticRoutePropsMarker(resolvedProps));
-      } catch (error) {
-        if (isPromiseLike(error) || isProgrammaticRedirectSignal(error)) {
-          throw error;
-        }
-        if (isProgrammaticNotFoundSignal(error) && route.notFound) {
-          return createElement2(route.notFound, createProgrammaticRouteErrorProps(error, props));
-        }
-        if (route.error) {
-          return createElement2(route.error, createProgrammaticRouteErrorProps(error, props));
-        }
-        throw error;
-      }
-    }, "FarmProgrammaticPageContent");
-    const PageContent = FarmProgrammaticPageContent2;
-    const FarmProgrammaticPage = /* @__PURE__ */ __name(function FarmProgrammaticPage2(props) {
-      return createElement2(
-        rendererRuntime.Suspense,
-        {
-          fallback: createElement2(PendingComponent, createProgrammaticRoutePendingProps(props))
-        },
-        createElement2(PageContent, props)
-      );
-    }, "FarmProgrammaticPage");
-    return FarmProgrammaticPage;
-  }
-  const FarmProgrammaticPageContent = /* @__PURE__ */ __name(async function FarmProgrammaticPageContent2(props) {
-    try {
-      const resolvedProps = isProgrammaticRoutePropsResolved(props) ? props : await resolveProgrammaticRouteProps(route, props);
-      return createElement2(Component, stripProgrammaticRoutePropsMarker(resolvedProps));
-    } catch (error) {
-      if (isProgrammaticRedirectSignal(error)) {
-        throw error;
-      }
-      if (isProgrammaticNotFoundSignal(error) && route.notFound) {
-        return createElement2(route.notFound, createProgrammaticRouteErrorProps(error, props));
-      }
-      if (route.error) {
-        return createElement2(route.error, createProgrammaticRouteErrorProps(error, props));
-      }
-      throw error;
-    }
-  }, "FarmProgrammaticPageContent");
-  return FarmProgrammaticPageContent;
-}
-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;
-}
-function isPromiseLike(value) {
-  return Boolean(
-    value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function"
-  );
-}
-function createProgrammaticRoutePendingProps(props) {
-  return {
-    params: props.params,
-    searchParams: props.searchParams,
-    path: props.path
-  };
-}
-function createProgrammaticRouteErrorProps(error, props) {
-  return {
-    error,
-    params: props.params,
-    searchParams: props.searchParams,
-    path: props.path
-  };
-}
-function isProgrammaticRedirectSignal(error) {
-  if (!error || typeof error !== "object") return false;
-  const digest = error.digest;
-  return typeof digest === "string" && digest.startsWith("FARM_REDIRECT;");
-}
-function isProgrammaticNotFoundSignal(error) {
-  if (!error || typeof error !== "object") return false;
-  const digest = error.digest;
-  return digest === "FARM_NOT_FOUND";
-}
-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 } : {}
-  });
-}
-async function resolveProgrammaticRouteData(route, dataHooks, context2) {
-  if (!dataHooks?.key) {
-    return dataHooks.main(context2);
-  }
-  const routeDataKey = await dataHooks.key(context2);
-  if (routeDataKey == null) {
-    return dataHooks.main(context2);
-  }
-  const cacheKey = createFarmCacheKey(["route-data", routeDataKey]);
-  const cacheOptions = {
-    tags: [
-      createRouteDataCacheTag(routeDataKey),
-      ...await resolveProgrammaticRouteDataKeys(dataHooks.tags, context2)
-    ],
-    paths: [
-      ...typeof context2.path === "string" ? [context2.path] : [],
-      ...await resolveProgrammaticRouteDataKeys(dataHooks.paths, context2)
-    ],
-    revalidate: normalizeProgrammaticRouteStaleTime(dataHooks.staleTime)
-  };
-  return getFarmDataCache().getOrSet(cacheKey, () => dataHooks.main(context2), cacheOptions);
-}
-async function resolveProgrammaticRouteDataKeys(input, context2) {
-  if (!input) return [];
-  const value = typeof input === "function" ? await input(context2) : input;
-  return value.filter((item) => typeof item === "string" && item.trim().length > 0);
-}
-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));
-}
-function isProgrammaticRoutePropsResolved(value) {
-  return !!value && typeof value === "object" && value.__farmRoutePropsResolved === true;
-}
-function markProgrammaticRoutePropsResolved(props) {
-  return {
-    ...props,
-    __farmRoutePropsResolved: true
-  };
-}
-function addCanonicalPath(props, canonicalPath) {
-  return canonicalPath ? { ...props, __farmCanonicalPath: canonicalPath } : props;
-}
-function stripProgrammaticRoutePropsMarker(props) {
-  if (!isProgrammaticRoutePropsResolved(props)) {
-    return props;
-  }
-  const {
-    __farmRoutePropsResolved,
-    __farmCanonicalPath,
-    __farmRoutePropsPromise,
-    ...componentProps
-  } = props;
-  return componentProps;
-}
-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}`);
-  }
-}
-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)
-    };
-  }
-  const routeActions = route.kind === "page" ? normalizeProgrammaticRouteActions(route) : void 0;
-  return {
-    ...route,
-    ...routeActions,
-    ...normalizeFarmRouteRuntimeConfig(
-      route,
-      `${route.kind === "layout" ? "Layout" : "Route"} "${route.path}"`
-    ),
-    path: normalizeRoutePath(route.path)
-  };
-}
-function normalizeProgrammaticRouteActions(route) {
-  const entries = Object.entries(route.actions ?? {});
-  if (entries.length === 0) {
-    if (route.defaultAction !== void 0) {
-      throw new TypeError(
-        `Route "${route.path}" declares defaultAction without declaring any actions.`
-      );
-    }
-    return {};
-  }
-  for (const [name, action2] of entries) {
-    if (typeof action2 !== "function") {
-      throw new TypeError(`Route "${route.path}" action "${name}" must be a server function.`);
-    }
-  }
-  const defaultAction = route.defaultAction ?? entries[0][0];
-  const actions = Object.freeze({ ...route.actions });
-  const action = actions[defaultAction];
-  if (!action) {
-    throw new TypeError(
-      `Route "${route.path}" defaultAction "${defaultAction}" does not match a declared action.`
-    );
-  }
-  return {
-    actions,
-    defaultAction,
-    action
-  };
-}
-function normalizeRoutePath(routePath) {
-  const withSlash = routePath.startsWith("/") ? routePath : `/${routePath}`;
-  const withoutTrailing = withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
-  return withoutTrailing || "/";
-}
-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;
-}
-function isProgrammaticRouteMethod(method) {
-  return method === "GET" || method === "HEAD" || method === "QUERY" || method === "POST" || method === "PUT" || method === "DELETE" || method === "PATCH" || method === "OPTIONS";
-}
-function normalizeStaticPaths(routePath, paths) {
-  const dynamicSegments = parseProgrammaticRoutePath2(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)
-      ])
-    );
-  });
-}
-var routesBuilder, page, layout, api, redirect;
-var init_routes = __esm({
-  "src/routes.ts"() {
-    "use strict";
-    init_cache();
-    init_route_context();
-    init_route_runtime();
-    init_routes_shared();
-    init_route_call_scanner();
-    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: runtime3, regions, maxDuration, ...methods } = options;
-        return normalizeProgrammaticRoute({
-          kind: "api",
-          path: path2,
-          render,
-          runtime: runtime3,
-          regions,
-          maxDuration,
-          methods: normalizeApiMethods(methods)
-        });
-      },
-      redirect(source, destination, options = {}) {
-        return normalizeProgrammaticRoute({
-          kind: "redirect",
-          source,
-          destination,
-          ...options
-        });
-      }
-    };
-    page = routesBuilder.page;
-    layout = routesBuilder.layout;
-    api = routesBuilder.api;
-    redirect = routesBuilder.redirect;
-    __name(getProgrammaticRouteSearchSchema, "getProgrammaticRouteSearchSchema");
-    __name(getProgrammaticRouteSearchClientOptions, "getProgrammaticRouteSearchClientOptions");
-    __name(resolveProgrammaticRouteSearch, "resolveProgrammaticRouteSearch");
-    __name(getProgrammaticRouteSearchOptions, "getProgrammaticRouteSearchOptions");
-    __name(isProgrammaticRouteSchema, "isProgrammaticRouteSchema");
-    __name(resolveProgrammaticRouteCanonicalPath, "resolveProgrammaticRouteCanonicalPath");
-    __name(createSearchParams, "createSearchParams");
-    __name(parseDefaultSearch, "parseDefaultSearch");
-    __name(readSearchValue, "readSearchValue");
-    __name(searchValuesEqual, "searchValuesEqual");
-    __name(normalizeComparableValue, "normalizeComparableValue");
-    __name(parseProgrammaticRoutePath2, "parseProgrammaticRoutePath");
-    __name(createRouteModuleFromProgrammaticPage, "createRouteModuleFromProgrammaticPage");
-    __name(createProgrammaticPageComponent, "createProgrammaticPageComponent");
-    __name(readProgrammaticRouteProps, "readProgrammaticRouteProps");
-    __name(isPromiseLike, "isPromiseLike");
-    __name(createProgrammaticRoutePendingProps, "createProgrammaticRoutePendingProps");
-    __name(createProgrammaticRouteErrorProps, "createProgrammaticRouteErrorProps");
-    __name(isProgrammaticRedirectSignal, "isProgrammaticRedirectSignal");
-    __name(isProgrammaticNotFoundSignal, "isProgrammaticNotFoundSignal");
-    __name(resolveProgrammaticRouteProps, "resolveProgrammaticRouteProps");
-    __name(resolveProgrammaticRouteData, "resolveProgrammaticRouteData");
-    __name(resolveProgrammaticRouteDataKeys, "resolveProgrammaticRouteDataKeys");
-    __name(normalizeProgrammaticRouteStaleTime, "normalizeProgrammaticRouteStaleTime");
-    __name(isProgrammaticRoutePropsResolved, "isProgrammaticRoutePropsResolved");
-    __name(markProgrammaticRoutePropsResolved, "markProgrammaticRoutePropsResolved");
-    __name(addCanonicalPath, "addCanonicalPath");
-    __name(stripProgrammaticRoutePropsMarker, "stripProgrammaticRoutePropsMarker");
-    __name(parseProgrammaticSchema, "parseProgrammaticSchema");
-    __name(normalizeProgrammaticRoute, "normalizeProgrammaticRoute");
-    __name(normalizeProgrammaticRouteActions, "normalizeProgrammaticRouteActions");
-    __name(normalizeRoutePath, "normalizeRoutePath");
-    __name(normalizeApiMethods, "normalizeApiMethods");
-    __name(isProgrammaticRouteMethod, "isProgrammaticRouteMethod");
-    __name(normalizeStaticPaths, "normalizeStaticPaths");
-  }
-});
-
-// src/testing.ts
-var testing_exports = {};
-__export(testing_exports, {
-  createFarmTestHarness: () => createFarmTestHarness,
-  createTestRequest: () => createTestRequest
-});
-module.exports = __toCommonJS(testing_exports);
-var import_react = require("react");
-
-// src/api/endpoint.ts
-var import_better_call = require("better-call");
-init_cache();
-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");
-var EMPTY_ENDPOINT_MIDDLEWARE = Object.freeze([]);
-var EMPTY_ENDPOINT_CONTEXT = Object.freeze(/* @__PURE__ */ Object.create(null));
-
-// src/api/route.ts
-init_specificity();
-var unavailablePluginLocalAPI = Object.freeze({
-  available: false,
-  get() {
-    return void 0;
-  },
-  list() {
-    return [];
-  }
-});
-
-// 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/api/runtime.ts
-init_cache_invalidation();
-
-// src/server-http.ts
-init_specificity();
-
-// 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");
-
-// 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/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");
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
-// 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
-init_specificity();
-
-// src/api/route-pattern.ts
-init_specificity();
-var compiledEntries = /* @__PURE__ */ new WeakMap();
-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(path2) {
-  const segments = getPathSegments(path2).map((segment) => {
-    const dynamic = parseDynamicSegment(segment);
-    return dynamic ? { dynamic } : { value: decodePathSegment(segment) };
-  });
-  return {
-    path: path2,
-    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");
+var _chunkXSKZORAScjs = require('./chunk-XSKZORAS.cjs');
 
-// src/api/runtime.ts
-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");
 
-// src/utils.ts
-init_specificity();
 
-// src/search-params.ts
-function searchParamsToObject2(searchParams) {
-  const output = {};
-  searchParams.forEach((value, key) => {
-    if (key === "__proto__" || key === "constructor" || key === "prototype") return;
-    const existing = Object.prototype.hasOwnProperty.call(output, key) ? output[key] : void 0;
-    if (existing !== void 0) {
-      if (Array.isArray(existing)) {
-        existing.push(value);
-      } else {
-        output[key] = [existing, value];
-      }
-    } else {
-      output[key] = value;
-    }
-  });
-  return output;
-}
-__name(searchParamsToObject2, "searchParamsToObject");
+var _chunkSU7MH53Pcjs = require('./chunk-SU7MH53P.cjs');
+require('./chunk-PCOTGFSM.cjs');
 
-// src/utils/file-module.ts
-var import_node_url = require("url");
 
-// src/api/route-manager.ts
-init_routes_shared();
+var _chunkT5CERMEHcjs = require('./chunk-T5CERMEH.cjs');
 
-// src/routes.server.ts
-init_routes_shared();
 
-// src/api/route-manager.ts
-init_route_runtime();
 
-// src/i18n/server.ts
-var import_node_async_hooks2 = require("async_hooks");
-init_bridge();
+var _chunk6QQDAAAZcjs = require('./chunk-6QQDAAAZ.cjs');
+require('./chunk-SVRTJOUF.cjs');
+require('./chunk-AFOD3LYZ.cjs');
+require('./chunk-IAMRBF3Z.cjs');
+require('./chunk-2CQ74SP6.cjs');
+require('./chunk-UJ2C4ICS.cjs');
+require('./chunk-IQXFRNY2.cjs');
 
-// 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");
+var _chunk4PNUXIVUcjs = require('./chunk-4PNUXIVU.cjs');
+require('./chunk-WPYFSQKK.cjs');
+require('./chunk-I4J452B7.cjs');
+require('./chunk-WMAPPDMM.cjs');
+require('./chunk-TKJZFIML.cjs');
+require('./chunk-6V4TDWEC.cjs');
+require('./chunk-MKB2EGIR.cjs');
+require('./chunk-EM6SBQKM.cjs');
+require('./chunk-VQDBNVOO.cjs');
+require('./chunk-HBTUGXHS.cjs');
+require('./chunk-5QIKR7RR.cjs');
 
-// 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 getRequestStore2() {
-  const state = globalThis;
-  return state[FARM_I18N_REQUEST_STORE] ?? (state[FARM_I18N_REQUEST_STORE] = new import_node_async_hooks2.AsyncLocalStorage());
-}
-__name(getRequestStore2, "getRequestStore");
-function getState() {
-  const state = getRequestStore2().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 getRequestStore2().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());
+var _chunkQNPEUFHQcjs = require('./chunk-QNPEUFHQ.cjs');
 
-// src/api/route-manager.ts
-init_specificity();
 
-// src/testing.ts
-init_cache();
-init_route_context();
-init_routes();
+var _chunkG7HXGLECcjs = require('./chunk-G7HXGLEC.cjs');
+require('./chunk-ARJWXNQL.cjs');
+require('./chunk-S3A45T7F.cjs');
+require('./chunk-75BRBIFP.cjs');
 
-// src/router.ts
-init_specificity();
 
-// src/routing/matcher.ts
-init_specificity();
-function parseRoutePattern(pattern) {
-  assertBrowserStableRoutePath(pattern);
-  assertTerminalCatchAll(pattern, "router");
-  assertUniqueRouteParameters(pattern, "router");
-  return splitRoutePattern2(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 matchSegmentParts(segments, parts, allowTrailingSegments = false) {
-  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 allowTrailingSegments || pathIndex === parts.length ? params : null;
-}
-__name(matchSegmentParts, "matchSegmentParts");
-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 splitNormalizedPathname(normalizePathname2(pathname));
-}
-__name(splitPathname, "splitPathname");
-function splitNormalizedPathname(pathname) {
-  return pathname.split("/").filter(Boolean);
-}
-__name(splitNormalizedPathname, "splitNormalizedPathname");
-function normalizeRoutePattern(value) {
-  let pathname = (value || "/").replace(/\\/g, "/").replace(/\/+/g, "/");
-  if (!pathname.startsWith("/")) pathname = `/${pathname}`;
-  if (pathname.length > 1) pathname = pathname.replace(/\/+$/, "");
-  return pathname || "/";
-}
-__name(normalizeRoutePattern, "normalizeRoutePattern");
-function splitRoutePattern2(pattern) {
-  return normalizeRoutePattern(pattern).split("/").filter(Boolean);
-}
-__name(splitRoutePattern2, "splitRoutePattern");
-function isRouteGroup(part) {
-  return part.startsWith("(") && part.endsWith(")");
-}
-__name(isRouteGroup, "isRouteGroup");
-function decodePathSegment2(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-__name(decodePathSegment2, "decodePathSegment");
+var _chunkH6G5INWMcjs = require('./chunk-H6G5INWM.cjs');
+require('./chunk-ZEG3OPIB.cjs');
+require('./chunk-LIUGYUX3.cjs');
+require('./chunk-E3UK5IIB.cjs');
+require('./chunk-5ZSWG4UX.cjs');
+require('./chunk-US2QVW3E.cjs');
+require('./chunk-U4KT7QP3.cjs');
+require('./chunk-BIDYX3SL.cjs');
+require('./chunk-I57LW5VZ.cjs');
+require('./chunk-NO3WWW3N.cjs');
 
-// 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.`);
-    }
-    const encodedValues = values.map((item) => {
-      const value2 = String(item);
-      if (!value2) {
-        throw new Error(
-          `Route param "${segment.name}" for ${pattern} cannot contain an empty path segment.`
-        );
-      }
-      return encodePathSegment(value2);
-    });
-    parts.push(...encodedValues);
-  }
-  let pathname = parts.length ? `/${parts.join("/")}` : "/";
-  if (options.trailingSlash && pathname !== "/") {
-    pathname = `${pathname}/`;
-  }
-  return appendQueryAndHash(pathname, options);
-}
-__name(buildFarmRoutePath, "buildFarmRoutePath");
-function matchSegments(segments, pathname, allowTrailingSegments = false) {
-  return matchSegmentParts(segments, splitPathname(pathname), allowTrailingSegments);
-}
-__name(matchSegments, "matchSegments");
-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");
-init_cache_invalidation();
-var SERVER_ACTION_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionStorage");
-async function runWithServerActionRequest(request, callback) {
-  throwIfAborted2(request.signal);
-  const context2 = {
-    request,
-    signal: request.signal,
-    invalidations: /* @__PURE__ */ new Set(),
-    cacheTasks: /* @__PURE__ */ new Set()
-  };
-  return getServerActionStorage().run(context2, async () => {
-    try {
-      const result = await callback();
-      await Promise.all(context2.cacheTasks);
-      return result;
-    } catch (error) {
-      await Promise.allSettled(context2.cacheTasks);
-      throw error;
-    }
-  });
-}
-__name(runWithServerActionRequest, "runWithServerActionRequest");
-function getServerActionExecutionContext() {
-  return getServerActionStorage().getStore();
-}
-__name(getServerActionExecutionContext, "getServerActionExecutionContext");
-subscribeFarmCacheInvalidation((key) => {
-  getServerActionExecutionContext()?.invalidations.add(key);
-});
-subscribeFarmCacheTask((task) => {
-  getServerActionExecutionContext()?.cacheTasks.add(task);
-});
-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 throwIfAborted2(signal) {
-  if (!signal.aborted) return;
-  if (signal.reason !== void 0) throw signal.reason;
-  throw new DOMException("The operation was aborted", "AbortError");
-}
-__name(throwIfAborted2, "throwIfAborted");
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
 
 // src/testing.ts
-function createTestRequest(path2 = "/", options = {}) {
-  const url = resolveTestURL(path2, options.origin);
+var _react = require('react');
+function createTestRequest(path = "/", options = {}) {
+  const url = resolveTestURL(path, 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();
+  const method = (_nullishCoalesce(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}`);
   }
@@ -3145,14 +86,14 @@ function createTestRequest(path2 = "/", options = {}) {
     body
   });
 }
-__name(createTestRequest, "createTestRequest");
+_chunkS3JO3N4Hcjs.__name.call(void 0, createTestRequest, "createTestRequest");
 function createFarmTestHarness(options = {}) {
   const origin = normalizeOrigin(options.origin);
-  const request = /* @__PURE__ */ __name((path2 = "/", requestOptions = {}) => createTestRequest(path2, mergeRequestDefaults(options, origin, requestOptions)), "request");
+  const request = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (path = "/", requestOptions = {}) => createTestRequest(path, mergeRequestDefaults(options, origin, requestOptions)), "request");
   return {
     request,
     async route(route, routeOptions = {}) {
-      const requestPath = routeOptions.path ?? buildFarmRoutePath(route.path, routeOptions.params ?? {});
+      const requestPath = _nullishCoalesce(routeOptions.path, () => ( _chunkSU7MH53Pcjs.buildFarmRoutePath.call(void 0, route.path, _nullishCoalesce(routeOptions.params, () => ( {})))));
       const routeRequest = request(requestPath, {
         origin: routeOptions.origin,
         headers: routeOptions.headers,
@@ -3162,8 +103,8 @@ function createFarmTestHarness(options = {}) {
       });
       const url = new URL(routeRequest.url);
       const params = resolvePageParams(route.path, url.pathname, routeOptions.params);
-      const search = searchParamsToObject2(url.searchParams);
-      const routeContext = Object.prototype.hasOwnProperty.call(routeOptions, "context") ? routeOptions.context : await resolveFarmRouteContext(
+      const search = _chunkQNPEUFHQcjs.searchParamsToObject.call(void 0, url.searchParams);
+      const routeContext = Object.prototype.hasOwnProperty.call(routeOptions, "context") ? routeOptions.context : await _chunk6QQDAAAZcjs.resolveFarmRouteContext.call(void 0, 
         { context: options.context },
         {
           request: routeRequest,
@@ -3172,7 +113,7 @@ function createFarmTestHarness(options = {}) {
           path: url.pathname
         }
       );
-      const rawProps = withFarmRouteContext(
+      const rawProps = _chunk6QQDAAAZcjs.withFarmRouteContext.call(void 0, 
         {
           params,
           searchParams: Promise.resolve(search),
@@ -3182,7 +123,7 @@ function createFarmTestHarness(options = {}) {
         },
         routeContext
       );
-      const routeModule = createRouteModuleFromProgrammaticPage(route);
+      const routeModule = _chunkXSKZORAScjs.createRouteModuleFromProgrammaticPage.call(void 0, route);
       const resolveProps = routeModule.__farmResolveRouteProps;
       const resolvedProps = resolveProps ? await resolveProps(rawProps) : { ...rawProps, search, searchParams: Promise.resolve(search) };
       const canonicalPath = readCanonicalPath(resolvedProps);
@@ -3192,15 +133,15 @@ function createFarmTestHarness(options = {}) {
         module: routeModule,
         request: routeRequest,
         props: componentProps,
-        element: (0, import_react.createElement)(route.component, componentProps),
+        element: _react.createElement.call(void 0, route.component, componentProps),
         canonicalPath
       };
     },
     async api(route, apiOptions = {}) {
-      const requestPath = apiOptions.path ?? buildFarmRoutePath(route.path, apiOptions.params ?? {});
-      const method = apiOptions.method ?? getDefaultApiMethod(route);
+      const requestPath = _nullishCoalesce(apiOptions.path, () => ( _chunkSU7MH53Pcjs.buildFarmRoutePath.call(void 0, route.path, _nullishCoalesce(apiOptions.params, () => ( {})))));
+      const method = _nullishCoalesce(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);
+      const match = _chunkG7HXGLECcjs.matchAPIRoute.call(void 0, /* @__PURE__ */ new Map([[route.path, route]]), new URL(apiRequest.url).pathname);
       if (!match) {
         return jsonErrorResponse("Not Found", 404);
       }
@@ -3212,10 +153,10 @@ function createFarmTestHarness(options = {}) {
     },
     async endpoint(endpoint, endpointOptions = {}) {
       const endpointRecord = endpoint;
-      const endpointPath = endpointOptions.path ?? endpointRecord.__path ?? "/__farm/test/endpoint";
+      const endpointPath = _nullishCoalesce(_nullishCoalesce(endpointOptions.path, () => ( endpointRecord.__path)), () => ( "/__farm/test/endpoint"));
       const endpointRequest = request(endpointPath, {
         ...omitEndpointControlOptions(endpointOptions),
-        method: endpointOptions.method ?? endpointRecord.__method ?? "GET"
+        method: _nullishCoalesce(_nullishCoalesce(endpointOptions.method, () => ( endpointRecord.__method)), () => ( (hasRequestBody(endpointOptions) ? "POST" : "GET")))
       });
       return invokeTestEndpoint(
         endpoint,
@@ -3226,34 +167,34 @@ function createFarmTestHarness(options = {}) {
     },
     async serverFn(serverFn, ...args) {
       const [input, serverFnOptions = {}] = args;
-      const actionRequest = serverFnOptions.request ?? request(serverFnOptions.path ?? "/__farm/test/server-fn", {
+      const actionRequest = _nullishCoalesce(serverFnOptions.request, () => ( request(_nullishCoalesce(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));
+      })));
+      return await _chunkT5CERMEHcjs.runWithServerActionRequest.call(void 0, actionRequest, () => serverFn(input));
     },
     clearCache() {
-      getFarmDataCache().clear();
+      _chunkH6G5INWMcjs.getFarmDataCache.call(void 0, ).clear();
     }
   };
 }
-__name(createFarmTestHarness, "createFarmTestHarness");
-function resolveTestURL(path2, origin) {
-  const url = path2 instanceof URL ? new URL(path2) : new URL(path2, `${normalizeOrigin(origin)}/`);
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmTestHarness, "createFarmTestHarness");
+function resolveTestURL(path, origin) {
+  const url = path instanceof URL ? new URL(path) : new URL(path, `${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");
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveTestURL, "resolveTestURL");
 function normalizeOrigin(origin = "http://farm.test") {
   let url;
   try {
     url = new URL(origin);
-  } catch {
+  } catch (e) {
     throw new TypeError(`Invalid Farm test origin: ${JSON.stringify(origin)}`);
   }
   if (url.protocol !== "http:" && url.protocol !== "https:") {
@@ -3261,13 +202,13 @@ function normalizeOrigin(origin = "http://farm.test") {
   }
   return url.origin;
 }
-__name(normalizeOrigin, "normalizeOrigin");
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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,
+    origin: _nullishCoalesce(requestOptions.origin, () => ( origin)),
     headers,
     cookies: {
       ...harnessOptions.cookies,
@@ -3275,7 +216,7 @@ function mergeRequestDefaults(harnessOptions, origin, requestOptions) {
     }
   };
 }
-__name(mergeRequestDefaults, "mergeRequestDefaults");
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergeRequestDefaults, "mergeRequestDefaults");
 function applyQuery(searchParams, query) {
   if (!query) return;
   if (query instanceof URLSearchParams) {
@@ -3297,14 +238,14 @@ function applyQuery(searchParams, query) {
     }
   }
 }
-__name(applyQuery, "applyQuery");
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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");
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyCookies, "applyCookies");
 function resolveRequestBody(options, headers) {
   const sources = [
     options.json !== void 0,
@@ -3323,11 +264,11 @@ function resolveRequestBody(options, headers) {
     return { body: formData, hasBody: true };
   }
   return {
-    body: options.body ?? null,
+    body: _nullishCoalesce(options.body, () => ( null)),
     hasBody: options.body !== void 0
   };
 }
-__name(resolveRequestBody, "resolveRequestBody");
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveRequestBody, "resolveRequestBody");
 function createFormData(values) {
   const formData = new FormData();
   for (const [key, rawValue] of Object.entries(values)) {
@@ -3336,9 +277,9 @@ function createFormData(values) {
   }
   return formData;
 }
-__name(createFormData, "createFormData");
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFormData, "createFormData");
 function resolvePageParams(pattern, pathname, explicitParams) {
-  const matchedParams = matchFarmRoute(pattern, pathname);
+  const matchedParams = _chunkSU7MH53Pcjs.matchFarmRoute.call(void 0, pattern, pathname);
   if (!matchedParams) {
     throw new Error(
       `Path ${JSON.stringify(pathname)} does not match route ${JSON.stringify(pattern)}`
@@ -3352,46 +293,49 @@ function resolvePageParams(pattern, pathname, explicitParams) {
     ])
   );
 }
-__name(resolvePageParams, "resolvePageParams");
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolvePageParams, "resolvePageParams");
 function readCanonicalPath(props) {
   return typeof props.__farmCanonicalPath === "string" ? props.__farmCanonicalPath : void 0;
 }
-__name(readCanonicalPath, "readCanonicalPath");
+_chunkS3JO3N4Hcjs.__name.call(void 0, readCanonicalPath, "readCanonicalPath");
 function stripInternalRouteProps(props) {
   const { __farmRoutePropsResolved, __farmCanonicalPath, ...componentProps } = props;
   return componentProps;
 }
-__name(stripInternalRouteProps, "stripInternalRouteProps");
+_chunkS3JO3N4Hcjs.__name.call(void 0, stripInternalRouteProps, "stripInternalRouteProps");
+function hasRequestBody(options) {
+  return options.json !== void 0 || options.form !== void 0 || options.body != null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, hasRequestBody, "hasRequestBody");
 function getDefaultApiMethod(route) {
   if (route.methods.GET) return "GET";
-  return Object.keys(route.methods)[0] ?? "GET";
+  return _nullishCoalesce(Object.keys(route.methods)[0], () => ( "GET"));
 }
-__name(getDefaultApiMethod, "getDefaultApiMethod");
+_chunkS3JO3N4Hcjs.__name.call(void 0, getDefaultApiMethod, "getDefaultApiMethod");
 function omitApiControlOptions(options) {
   const { path: _path, params: _params, throwOnError: _throwOnError, ...requestOptions } = options;
   return requestOptions;
 }
-__name(omitApiControlOptions, "omitApiControlOptions");
+_chunkS3JO3N4Hcjs.__name.call(void 0, omitApiControlOptions, "omitApiControlOptions");
 function omitEndpointControlOptions(options) {
   const { path: _path, params: _params, throwOnError: _throwOnError, ...requestOptions } = options;
   return requestOptions;
 }
-__name(omitEndpointControlOptions, "omitEndpointControlOptions");
+_chunkS3JO3N4Hcjs.__name.call(void 0, omitEndpointControlOptions, "omitEndpointControlOptions");
 async function invokeTestEndpoint(endpoint, request, params = {}, throwOnError = false) {
   try {
-    return await invokeAPIRouteEndpoint(endpoint, request, params);
+    return await _chunk4PNUXIVUcjs.invokeAPIRouteEndpoint.call(void 0, endpoint, request, params);
   } catch (error) {
     if (throwOnError) throw error;
     return jsonErrorResponse(error instanceof Error ? error.message : "Internal Server Error", 500);
   }
 }
-__name(invokeTestEndpoint, "invokeTestEndpoint");
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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
-});
+_chunkS3JO3N4Hcjs.__name.call(void 0, jsonErrorResponse, "jsonErrorResponse");
+
+
+
+exports.createFarmTestHarness = createFarmTestHarness; exports.createTestRequest = createTestRequest;