@farm.js/core 0.1.0-beta.0

package/dist/internal/production-runtime.cjs

@@ -0,0 +1,1896 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/nitro/production-runtime.ts
+var production_runtime_exports = {};
+__export(production_runtime_exports, {
+  _runWithAfterRequest: () => _runWithAfterRequest,
+  _runWithCurrentRequest: () => _runWithCurrentRequest,
+  _runWithMiddlewareContext: () => _runWithMiddlewareContext,
+  _runWithMiddlewareData: () => _runWithMiddlewareData,
+  addMetadataImageReference: () => addMetadataImageReference,
+  applyProductionMiddlewareHeaders: () => applyProductionMiddlewareHeaders,
+  configureFarmObservability: () => configureFarmObservability,
+  createFarmCacheKey: () => createFarmCacheKey,
+  createFarmLocaleCookie: () => createFarmLocaleCookie,
+  createProductionMiddlewareRunner: () => createProductionMiddlewareRunner,
+  emitFarmEvent: () => emitFarmEvent,
+  getCurrentRequest: () => getCurrentRequest,
+  getFarmDataCache: () => getFarmDataCache,
+  getFarmLocaleVaryHeaders: () => getFarmLocaleVaryHeaders,
+  getFarmRedirectError: () => getFarmRedirectError,
+  isFarmNotFoundError: () => isFarmNotFoundError,
+  isFarmRedirectError: () => isFarmRedirectError,
+  localizeFarmHref: () => localizeFarmHref,
+  localizeFarmPathname: () => localizeFarmPathname,
+  mergeMetadata: () => mergeMetadata,
+  normalizeRevalidatePath: () => normalizeRevalidatePath,
+  renderMetadataHead: () => renderMetadataHead,
+  resolveFarmRouteContext: () => resolveFarmRouteContext,
+  stripFarmLocaleFromPathname: () => stripFarmLocaleFromPathname,
+  withFarmRouteContext: () => withFarmRouteContext
+});
+module.exports = __toCommonJS(production_runtime_exports);
+
+// src/after.ts
+var import_node_async_hooks = require("async_hooks");
+var AFTER_STORAGE = /* @__PURE__ */ Symbol.for("@farm.js/core/after-storage");
+function getAfterStorage() {
+  const runtime = globalThis;
+  const existing = runtime[AFTER_STORAGE];
+  if (existing instanceof import_node_async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new import_node_async_hooks.AsyncLocalStorage();
+  runtime[AFTER_STORAGE] = storage;
+  return storage;
+}
+__name(getAfterStorage, "getAfterStorage");
+var afterStorage = getAfterStorage();
+function defaultAfterErrorReporter(error) {
+  console.error("[Farm.js] after() callback failed:", error);
+}
+__name(defaultAfterErrorReporter, "defaultAfterErrorReporter");
+function reportAfterError(state, error) {
+  try {
+    state.reportError(error);
+  } catch {
+  }
+}
+__name(reportAfterError, "reportAfterError");
+function createAfterRequestState(reportError = defaultAfterErrorReporter) {
+  let resolveResponseFinished;
+  let responseFinished = false;
+  const responseFinishedPromise = new Promise((resolve) => {
+    resolveResponseFinished = resolve;
+  });
+  const state = {
+    completion: Promise.resolve(),
+    finishResponse: /* @__PURE__ */ __name(() => {
+      if (responseFinished) return;
+      responseFinished = true;
+      resolveResponseFinished();
+    }, "finishResponse"),
+    phase: "open",
+    reportError,
+    tasks: []
+  };
+  state.completion = responseFinishedPromise.then(
+    () => afterStorage.run(state, async () => {
+      state.phase = "running";
+      for (let index = 0; index < state.tasks.length; index++) {
+        const task = state.tasks[index];
+        task.start();
+        try {
+          await task.result;
+        } catch (error) {
+          reportAfterError(state, error);
+        }
+      }
+      state.phase = "closed";
+    })
+  );
+  return state;
+}
+__name(createAfterRequestState, "createAfterRequestState");
+function registerPlatformLifetime(state, context) {
+  if (!context?.waitUntil) return;
+  try {
+    context.waitUntil(state.completion);
+  } catch (error) {
+    reportAfterError(state, error);
+  }
+}
+__name(registerPlatformLifetime, "registerPlatformLifetime");
+function registerResponseFinishedHook(state, context) {
+  if (!context?.onResponseFinished) return false;
+  try {
+    context.onResponseFinished(state.finishResponse);
+    return true;
+  } catch (error) {
+    reportAfterError(state, error);
+    return false;
+  }
+}
+__name(registerResponseFinishedHook, "registerResponseFinishedHook");
+function finishSoon(state) {
+  setTimeout(state.finishResponse, 0);
+}
+__name(finishSoon, "finishSoon");
+function wrapResponseBody(response, request, state) {
+  if (request.method === "HEAD" || response.status < 200 || response.status > 599 || !response.body || response.bodyUsed || response.body.locked) {
+    finishSoon(state);
+    return response;
+  }
+  const reader = response.body.getReader();
+  let released = false;
+  const releaseReader = /* @__PURE__ */ __name(() => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  }, "releaseReader");
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          releaseReader();
+          controller.close();
+          finishSoon(state);
+          return;
+        }
+        controller.enqueue(chunk.value);
+      } catch (error) {
+        releaseReader();
+        controller.error(error);
+        finishSoon(state);
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        releaseReader();
+        finishSoon(state);
+      }
+    }
+  });
+  return new Response(body, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+__name(wrapResponseBody, "wrapResponseBody");
+async function _runWithAfterRequest(request, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  registerPlatformLifetime(state, context);
+  const hasResponseHook = registerResponseFinishedHook(state, context);
+  try {
+    const response = await afterStorage.run(state, handler);
+    return hasResponseHook ? response : wrapResponseBody(response, request, state);
+  } catch (error) {
+    if (!hasResponseHook) finishSoon(state);
+    throw error;
+  }
+}
+__name(_runWithAfterRequest, "_runWithAfterRequest");
+
+// src/server/request.ts
+var import_node_async_hooks2 = require("async_hooks");
+
+// src/server/request-bridge.ts
+var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
+function getGlobalState() {
+  return globalThis;
+}
+__name(getGlobalState, "getGlobalState");
+function _setCurrentRequestResolver(resolver) {
+  getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY] = resolver;
+}
+__name(_setCurrentRequestResolver, "_setCurrentRequestResolver");
+
+// src/server/request.ts
+var REQUEST_STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-storage");
+function getRequestStore() {
+  const runtime = globalThis;
+  const existing = runtime[REQUEST_STORAGE_KEY];
+  if (existing instanceof import_node_async_hooks2.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new import_node_async_hooks2.AsyncLocalStorage();
+  runtime[REQUEST_STORAGE_KEY] = storage;
+  return storage;
+}
+__name(getRequestStore, "getRequestStore");
+var requestStore = getRequestStore();
+_setCurrentRequestResolver(() => requestStore.getStore());
+function createWebRequestFromFarmRequest(req) {
+  const forwardedHost = req.headers["x-forwarded-host"];
+  const host = Array.isArray(forwardedHost) ? forwardedHost[0] : forwardedHost || req.headers.host || "localhost";
+  const forwardedProto = req.headers["x-forwarded-proto"];
+  const proto = Array.isArray(forwardedProto) ? forwardedProto[0] : forwardedProto || "http";
+  const fullUrl = new URL(req.url || "/", `${proto}://${host}`).toString();
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+      continue;
+    }
+    headers.set(key, value);
+  }
+  return new Request(fullUrl, {
+    method: req.method,
+    headers
+  });
+}
+__name(createWebRequestFromFarmRequest, "createWebRequestFromFarmRequest");
+async function _runWithCurrentRequest(request, fn) {
+  return requestStore.run(request, fn);
+}
+__name(_runWithCurrentRequest, "_runWithCurrentRequest");
+function getCurrentRequest() {
+  const request = requestStore.getStore();
+  if (!request) {
+    throw new Error(
+      "No current request is available. getCurrentRequest() can only be used during server rendering."
+    );
+  }
+  return request;
+}
+__name(getCurrentRequest, "getCurrentRequest");
+
+// src/observability.ts
+var runtimeHandlers = /* @__PURE__ */ new Set();
+var observabilityState = {
+  logs: false,
+  handlers: []
+};
+function configureFarmObservability(config) {
+  observabilityState = normalizeFarmObservabilityConfig(config);
+}
+__name(configureFarmObservability, "configureFarmObservability");
+function normalizeFarmObservabilityConfig(config) {
+  if (config === void 0 || config === false) {
+    return { logs: false, handlers: [] };
+  }
+  if (config === true) {
+    return { logs: true, handlers: [] };
+  }
+  const handlers = config.onEvent ? Array.isArray(config.onEvent) ? [...config.onEvent] : [config.onEvent] : [];
+  return {
+    logs: config.logs ?? false,
+    handlers,
+    events: config.events ? new Set(config.events) : void 0
+  };
+}
+__name(normalizeFarmObservabilityConfig, "normalizeFarmObservabilityConfig");
+function emitFarmEvent(input) {
+  const event = {
+    timestamp: Date.now(),
+    level: inferFarmEventLevel(input.type),
+    ...input
+  };
+  if (!shouldEmitFarmEvent(event)) {
+    return event;
+  }
+  if (observabilityState.logs) {
+    logFarmEvent(event);
+  }
+  for (const handler of [...observabilityState.handlers, ...runtimeHandlers]) {
+    try {
+      Promise.resolve(handler(event)).catch((error) => {
+        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+      });
+    } catch (error) {
+      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+    }
+  }
+  return event;
+}
+__name(emitFarmEvent, "emitFarmEvent");
+function shouldEmitFarmEvent(event) {
+  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
+    return false;
+  }
+  if (observabilityState.events && !observabilityState.events.has(event.type)) {
+    return false;
+  }
+  return true;
+}
+__name(shouldEmitFarmEvent, "shouldEmitFarmEvent");
+function inferFarmEventLevel(type) {
+  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
+    return "error";
+  }
+  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
+    return "warn";
+  }
+  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
+    return "debug";
+  }
+  return "info";
+}
+__name(inferFarmEventLevel, "inferFarmEventLevel");
+function logFarmEvent(event) {
+  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
+  switch (event.level) {
+    case "error":
+      console.error(message);
+      break;
+    case "warn":
+      console.warn(message);
+      break;
+    default:
+      console.log(message);
+      break;
+  }
+}
+__name(logFarmEvent, "logFarmEvent");
+function formatFarmEventDetails(event) {
+  const details = [];
+  const record = event;
+  for (const key of [
+    "route",
+    "pathname",
+    "method",
+    "status",
+    "key",
+    "tag",
+    "path",
+    "reason",
+    "durationMs",
+    "integration",
+    "operation",
+    "plugin",
+    "hook",
+    "target",
+    "count"
+  ]) {
+    const value = record[key];
+    if (value !== void 0) {
+      details.push(`${key}=${formatDetailValue(value)}`);
+    }
+  }
+  return details.length > 0 ? ` ${details.join(" ")}` : "";
+}
+__name(formatFarmEventDetails, "formatFarmEventDetails");
+function formatDetailValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+__name(formatDetailValue, "formatDetailValue");
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(formatError, "formatError");
+
+// src/cache.ts
+var _FarmDataCache = class _FarmDataCache {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
+    this.version = 0;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get(key, options = {}) {
+    return this.getEntry(key, options)?.value;
+  }
+  getEntry(key, options = {}) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      emitFarmEvent({ type: "cache.miss", key });
+      return void 0;
+    }
+    const stale = this.isStale(entry, options.now);
+    if (stale) {
+      emitFarmEvent({
+        type: "cache.stale",
+        key,
+        tags: Array.from(entry.tags),
+        revalidate: entry.revalidate
+      });
+    }
+    if (!options.allowStale && stale) {
+      emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
+      return void 0;
+    }
+    emitFarmEvent({
+      type: "cache.hit",
+      key,
+      tags: Array.from(entry.tags),
+      revalidate: entry.revalidate,
+      stale
+    });
+    return this.toPublicEntry(entry);
+  }
+  set(key, value, options = {}) {
+    const tags = /* @__PURE__ */ new Set();
+    for (const tag of options.tags ?? []) {
+      tags.add(normalizeCacheTag(tag));
+    }
+    for (const routePath of options.paths ?? []) {
+      tags.add(createPathCacheTag(routePath));
+    }
+    const entry = {
+      key,
+      value,
+      tags,
+      createdAt: options.createdAt ?? Date.now(),
+      createdVersion: ++this.version,
+      revalidate: normalizeRevalidate(options.revalidate)
+    };
+    this.entries.set(key, entry);
+    emitFarmEvent({
+      type: "cache.set",
+      key,
+      tags: Array.from(tags),
+      revalidate: entry.revalidate
+    });
+    return this.toPublicEntry(entry);
+  }
+  delete(key) {
+    const deleted = this.entries.delete(key);
+    emitFarmEvent({ type: "cache.delete", key, deleted });
+    return deleted;
+  }
+  clear() {
+    const count = this.entries.size;
+    this.entries.clear();
+    this.inflight.clear();
+    this.invalidatedTagVersions.clear();
+    this.version = 0;
+    emitFarmEvent({ type: "cache.clear", count });
+  }
+  isStale(entry, now = Date.now()) {
+    if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
+      return true;
+    }
+    for (const tag of entry.tags) {
+      const invalidatedVersion = this.invalidatedTagVersions.get(normalizeCacheTag(tag));
+      if (typeof invalidatedVersion === "number" && typeof entry.createdVersion === "number" && invalidatedVersion > entry.createdVersion) {
+        return true;
+      }
+    }
+    return false;
+  }
+  revalidateTag(tag, options = {}) {
+    const normalized = normalizeCacheTag(tag);
+    const count = this.invalidateTag(normalized);
+    emitFarmEvent(
+      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
+    );
+    return count;
+  }
+  revalidatePath(routePath) {
+    const normalizedPath = normalizeRevalidatePath(routePath);
+    const pathTag = createPathCacheTag(normalizedPath);
+    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
+    const count = this.invalidateTag(pathTag);
+    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
+    if (pprCount > 0) {
+      emitFarmEvent({
+        type: "ppr.shell.invalidated",
+        route: normalizedPath,
+        reason: "revalidatePath",
+        count: pprCount
+      });
+    }
+    return count;
+  }
+  async getOrSet(key, producer, options = {}) {
+    const cached = this.getEntry(key);
+    if (cached) {
+      return cached.value;
+    }
+    const inflight = this.inflight.get(key);
+    if (inflight) {
+      emitFarmEvent({ type: "cache.dedupe", key });
+      return inflight;
+    }
+    const promise = Promise.resolve().then(producer).then((value) => {
+      this.set(key, value, options);
+      return value;
+    }).catch((error) => {
+      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
+      throw error;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  countEntriesForTag(tag) {
+    let count = 0;
+    for (const entry of this.entries.values()) {
+      if (entry.tags.has(tag)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  countEntriesForTags(tags) {
+    let count = 0;
+    for (const entry of this.entries.values()) {
+      if (tags.every((tag) => entry.tags.has(tag))) {
+        count++;
+      }
+    }
+    return count;
+  }
+  invalidateTag(normalizedTag) {
+    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
+    return this.countEntriesForTag(normalizedTag);
+  }
+  toPublicEntry(entry) {
+    return {
+      key: entry.key,
+      value: entry.value,
+      tags: Array.from(entry.tags),
+      createdAt: entry.createdAt,
+      createdVersion: entry.createdVersion,
+      revalidate: entry.revalidate
+    };
+  }
+};
+__name(_FarmDataCache, "FarmDataCache");
+var FarmDataCache = _FarmDataCache;
+var FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
+var farmDataCacheGlobal = globalThis;
+var sharedFarmDataCache = farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] ?? (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] = new FarmDataCache());
+var functionIds = /* @__PURE__ */ new WeakMap();
+var nextFunctionId = 0;
+function getFarmDataCache() {
+  return sharedFarmDataCache;
+}
+__name(getFarmDataCache, "getFarmDataCache");
+function createPathCacheTag(routePath) {
+  return `path:${normalizeRevalidatePath(routePath)}`;
+}
+__name(createPathCacheTag, "createPathCacheTag");
+function normalizeRevalidatePath(routePath) {
+  if (typeof routePath !== "string") {
+    throw new TypeError("revalidatePath expects a path string.");
+  }
+  let normalized = routePath.trim();
+  if (!normalized) {
+    throw new Error("revalidatePath expects a non-empty path.");
+  }
+  try {
+    if (/^https?:\/\//.test(normalized)) {
+      normalized = new URL(normalized).pathname;
+    }
+  } catch {
+  }
+  normalized = normalized.split("?")[0] ?? normalized;
+  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  normalized = normalized.replace(/\/{2,}/g, "/");
+  if (normalized.length > 1) {
+    normalized = normalized.replace(/\/+$/, "");
+  }
+  return normalized || "/";
+}
+__name(normalizeRevalidatePath, "normalizeRevalidatePath");
+function createFarmCacheKey(parts) {
+  return stableSerialize(parts);
+}
+__name(createFarmCacheKey, "createFarmCacheKey");
+function normalizeRevalidate(revalidate) {
+  if (revalidate === false || revalidate === void 0) {
+    return revalidate;
+  }
+  if (!Number.isFinite(revalidate) || revalidate <= 0) {
+    return void 0;
+  }
+  return revalidate;
+}
+__name(normalizeRevalidate, "normalizeRevalidate");
+function normalizeCacheTag(tag) {
+  if (typeof tag !== "string") {
+    throw new TypeError("Cache tags must be strings.");
+  }
+  const normalized = tag.trim();
+  if (!normalized) {
+    throw new Error("Cache tags cannot be empty.");
+  }
+  return normalized;
+}
+__name(normalizeCacheTag, "normalizeCacheTag");
+function getFunctionCacheIdentity(fn) {
+  if (fn.name) {
+    return `name:${fn.name}`;
+  }
+  let id = functionIds.get(fn);
+  if (!id) {
+    id = ++nextFunctionId;
+    functionIds.set(fn, id);
+  }
+  return `anonymous:${id}`;
+}
+__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
+function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const valueType = typeof value;
+  if (valueType === "string") return JSON.stringify(value);
+  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
+    return `${valueType}:${String(value)}`;
+  }
+  if (valueType === "symbol") {
+    return `symbol:${String(value)}`;
+  }
+  if (valueType === "function") {
+    return `function:${getFunctionCacheIdentity(value)}`;
+  }
+  if (value instanceof Date) {
+    return `date:${value.toISOString()}`;
+  }
+  if (value instanceof URL) {
+    return `url:${value.toString()}`;
+  }
+  if (value instanceof RegExp) {
+    return `regexp:${value.toString()}`;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableSerialize(item, seen)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
+    seen.delete(value);
+    return `{${serialized}}`;
+  }
+  return String(value);
+}
+__name(stableSerialize, "stableSerialize");
+
+// src/i18n/routing.ts
+function resolveFarmLocalePath(pathname, config) {
+  const normalized = normalizePathname(pathname);
+  if (config.routing === "none") {
+    return { pathname: normalized, explicit: false };
+  }
+  const segments = normalized.split("/").filter(Boolean);
+  const firstSegment = segments[0];
+  const locale = config.locales.find(
+    (candidate) => candidate.toLowerCase() === firstSegment?.toLowerCase()
+  );
+  if (!locale) {
+    return { pathname: normalized, explicit: false };
+  }
+  const remaining = segments.slice(1);
+  return {
+    locale,
+    pathname: remaining.length > 0 ? `/${remaining.join("/")}` : "/",
+    explicit: true
+  };
+}
+__name(resolveFarmLocalePath, "resolveFarmLocalePath");
+function stripFarmLocaleFromPathname(pathname, config) {
+  return resolveFarmLocalePath(pathname, config).pathname;
+}
+__name(stripFarmLocaleFromPathname, "stripFarmLocaleFromPathname");
+function localizeFarmPathname(pathname, locale, config) {
+  const internalPathname = resolveFarmLocalePath(pathname, config).pathname;
+  if (config.routing === "none") return internalPathname;
+  if (config.routing === "prefix-except-default" && locale === config.defaultLocale) {
+    return internalPathname;
+  }
+  return internalPathname === "/" ? `/${locale}` : `/${locale}${internalPathname}`;
+}
+__name(localizeFarmPathname, "localizeFarmPathname");
+function localizeFarmHref(href, locale, config) {
+  if (!href.startsWith("/") || href.startsWith("//")) return href;
+  const url = new URL(href, "http://farm.local");
+  url.pathname = localizeFarmPathname(url.pathname, locale, config);
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+__name(localizeFarmHref, "localizeFarmHref");
+function normalizePathname(pathname) {
+  const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (withLeadingSlash === "/") return "/";
+  return withLeadingSlash.replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
+}
+__name(normalizePathname, "normalizePathname");
+
+// src/i18n/resolver.ts
+function getFarmLocaleVaryHeaders(config, resolution) {
+  if (!config.enabled || resolution.source === "url") return [];
+  const headers = [];
+  if (config.detection.includes("cookie")) headers.push("Cookie");
+  if (config.detection.includes("accept-language")) headers.push("Accept-Language");
+  return headers;
+}
+__name(getFarmLocaleVaryHeaders, "getFarmLocaleVaryHeaders");
+function createFarmLocaleCookie(locale, config) {
+  const cookie = config.cookie;
+  let value = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(locale)}`;
+  value += `; Max-Age=${cookie.maxAge}`;
+  value += `; Path=${cookie.path}`;
+  value += `; SameSite=${capitalize(cookie.sameSite)}`;
+  if (cookie.secure) value += "; Secure";
+  return value;
+}
+__name(createFarmLocaleCookie, "createFarmLocaleCookie");
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+__name(capitalize, "capitalize");
+
+// src/metadata.ts
+function mergeMetadata(base, next) {
+  if (!base) return next ? { ...next } : {};
+  if (!next) return { ...base };
+  return {
+    ...base,
+    ...next,
+    openGraph: mergeNestedMetadata(base.openGraph, next.openGraph),
+    twitter: mergeNestedMetadata(base.twitter, next.twitter),
+    alternates: mergeNestedMetadata(base.alternates, next.alternates),
+    icons: mergeNestedMetadata(base.icons, next.icons)
+  };
+}
+__name(mergeMetadata, "mergeMetadata");
+function addMetadataImageReference(metadata, reference) {
+  if (reference.kind === "opengraph") {
+    const openGraph = { ...metadata.openGraph || {} };
+    if (!hasMetadataImages(openGraph.images) && !hasMetadataImages(openGraph.image)) {
+      openGraph.images = [
+        {
+          url: reference.href,
+          width: reference.width,
+          height: reference.height,
+          alt: reference.alt,
+          type: reference.contentType
+        }
+      ];
+    }
+    return {
+      ...metadata,
+      openGraph
+    };
+  }
+  const twitter = { ...metadata.twitter || {} };
+  if (!hasMetadataImages(twitter.images)) {
+    twitter.images = [reference.href];
+    twitter.card = twitter.card || "summary_large_image";
+  }
+  return {
+    ...metadata,
+    twitter
+  };
+}
+__name(addMetadataImageReference, "addMetadataImageReference");
+function renderMetadataHead(metadata) {
+  const resolvedMetadata = metadata || {};
+  const metadataBase = resolveMetadataBase(resolvedMetadata);
+  const title = resolveMetadataTitle(resolvedMetadata.title) || "Farm.js App";
+  const tags = [];
+  appendMetaName(tags, "description", resolvedMetadata.description);
+  appendMetaName(tags, "keywords", normalizeKeywords(resolvedMetadata.keywords));
+  appendMetaName(tags, "author", resolvedMetadata.author);
+  if (Array.isArray(resolvedMetadata.authors)) {
+    for (const author of resolvedMetadata.authors) {
+      appendMetaName(tags, "author", author?.name);
+      if (author?.url) {
+        appendLink(tags, "author", resolveMetadataUrl(author.url, metadataBase));
+      }
+    }
+  }
+  appendMetaName(tags, "creator", resolvedMetadata.creator);
+  appendMetaName(tags, "publisher", resolvedMetadata.publisher);
+  appendMetaName(tags, "robots", normalizeRobots(resolvedMetadata.robots));
+  const alternates = resolvedMetadata.alternates;
+  if (isRecord(alternates)) {
+    appendLink(tags, "canonical", resolveMetadataUrl(alternates.canonical, metadataBase));
+    if (isRecord(alternates.languages)) {
+      for (const [language, href] of Object.entries(alternates.languages)) {
+        appendLink(tags, "alternate", resolveMetadataUrl(href, metadataBase), {
+          hreflang: language
+        });
+      }
+    }
+  }
+  const hasFavicon = appendIcons(tags, resolvedMetadata.icons, metadataBase);
+  if (resolvedMetadata.manifest) {
+    appendLink(
+      tags,
+      "manifest",
+      resolveMetadataUrl(resolvedMetadata.manifest, metadataBase)
+    );
+  }
+  appendOpenGraph(tags, resolvedMetadata.openGraph, metadataBase);
+  appendTwitter(tags, resolvedMetadata.twitter, metadataBase);
+  return {
+    title: escapeText(title),
+    tags: tags.length > 0 ? `
+  ${tags.join("\n  ")}` : "",
+    hasFavicon
+  };
+}
+__name(renderMetadataHead, "renderMetadataHead");
+function mergeNestedMetadata(base, next) {
+  if (isRecord(base) && isRecord(next)) {
+    return {
+      ...base,
+      ...next
+    };
+  }
+  return next ?? base;
+}
+__name(mergeNestedMetadata, "mergeNestedMetadata");
+function appendOpenGraph(tags, openGraph, metadataBase) {
+  if (!isRecord(openGraph)) return;
+  appendMetaProperty(tags, "og:title", openGraph.title);
+  appendMetaProperty(tags, "og:description", openGraph.description);
+  appendMetaProperty(tags, "og:url", resolveMetadataUrl(openGraph.url, metadataBase));
+  appendMetaProperty(tags, "og:site_name", openGraph.siteName);
+  appendMetaProperty(tags, "og:type", openGraph.type);
+  appendMetaProperty(tags, "og:locale", openGraph.locale);
+  const images = normalizeMetadataImages(
+    openGraph.images ?? openGraph.image,
+    metadataBase
+  );
+  for (const image of images) {
+    appendMetaProperty(tags, "og:image", image.url);
+    appendMetaProperty(tags, "og:image:width", image.width);
+    appendMetaProperty(tags, "og:image:height", image.height);
+    appendMetaProperty(tags, "og:image:alt", image.alt);
+    appendMetaProperty(tags, "og:image:type", image.type);
+  }
+}
+__name(appendOpenGraph, "appendOpenGraph");
+function appendTwitter(tags, twitter, metadataBase) {
+  if (!isRecord(twitter)) return;
+  appendMetaName(tags, "twitter:card", twitter.card);
+  appendMetaName(tags, "twitter:site", twitter.site);
+  appendMetaName(tags, "twitter:creator", twitter.creator);
+  appendMetaName(tags, "twitter:title", twitter.title);
+  appendMetaName(tags, "twitter:description", twitter.description);
+  for (const image of normalizeMetadataImages(twitter.images, metadataBase)) {
+    appendMetaName(tags, "twitter:image", image.url);
+    appendMetaName(tags, "twitter:image:alt", image.alt);
+  }
+}
+__name(appendTwitter, "appendTwitter");
+function appendIcons(tags, icons, metadataBase) {
+  if (!icons) return false;
+  if (typeof icons === "string") {
+    const initialTagCount2 = tags.length;
+    appendLink(tags, "icon", resolveMetadataUrl(icons, metadataBase));
+    return tags.length > initialTagCount2;
+  }
+  if (!isRecord(icons)) return false;
+  const initialTagCount = tags.length;
+  appendIconList(tags, "icon", icons.icon, metadataBase);
+  appendIconList(tags, "shortcut icon", icons.shortcut, metadataBase);
+  const hasFavicon = tags.length > initialTagCount;
+  appendIconList(tags, "apple-touch-icon", icons.apple, metadataBase);
+  return hasFavicon;
+}
+__name(appendIcons, "appendIcons");
+function appendIconList(tags, rel, value, metadataBase) {
+  for (const icon of normalizeArray(value)) {
+    if (typeof icon === "string") {
+      appendLink(tags, rel, resolveMetadataUrl(icon, metadataBase));
+      continue;
+    }
+    if (!isRecord(icon)) continue;
+    appendLink(tags, rel, resolveMetadataUrl(icon.url, metadataBase), {
+      sizes: icon.sizes,
+      type: icon.type
+    });
+  }
+}
+__name(appendIconList, "appendIconList");
+function appendMetaName(tags, name, content) {
+  const normalized = normalizeContent(content);
+  if (!normalized) return;
+  tags.push(`<meta name="${escapeAttribute(name)}" content="${escapeAttribute(normalized)}">`);
+}
+__name(appendMetaName, "appendMetaName");
+function appendMetaProperty(tags, property, content) {
+  const normalized = normalizeContent(content);
+  if (!normalized) return;
+  tags.push(
+    `<meta property="${escapeAttribute(property)}" content="${escapeAttribute(normalized)}">`
+  );
+}
+__name(appendMetaProperty, "appendMetaProperty");
+function appendLink(tags, rel, href, attrs = {}) {
+  const normalizedHref = normalizeContent(href);
+  if (!normalizedHref) return;
+  const attrText = Object.entries(attrs).map(([key, value]) => {
+    const normalized = normalizeContent(value);
+    return normalized ? ` ${key}="${escapeAttribute(normalized)}"` : "";
+  }).join("");
+  tags.push(
+    `<link rel="${escapeAttribute(rel)}" href="${escapeAttribute(normalizedHref)}"${attrText}>`
+  );
+}
+__name(appendLink, "appendLink");
+function normalizeMetadataImages(value, metadataBase) {
+  return normalizeArray(value).map((item) => {
+    if (typeof item === "string") {
+      return { url: resolveMetadataUrl(item, metadataBase) || item };
+    }
+    if (!isRecord(item)) return null;
+    const rawUrl = item.url || item.src;
+    const url = resolveMetadataUrl(rawUrl, metadataBase);
+    if (!url) return null;
+    return {
+      url,
+      width: normalizeNumber(item.width),
+      height: normalizeNumber(item.height),
+      alt: typeof item.alt === "string" ? item.alt : void 0,
+      type: typeof item.type === "string" ? item.type : void 0
+    };
+  }).filter((item) => item !== null);
+}
+__name(normalizeMetadataImages, "normalizeMetadataImages");
+function normalizeArray(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+__name(normalizeArray, "normalizeArray");
+function hasMetadataImages(value) {
+  return normalizeMetadataImages(value).length > 0;
+}
+__name(hasMetadataImages, "hasMetadataImages");
+function resolveMetadataTitle(title) {
+  if (typeof title === "string") return title;
+  if (isRecord(title)) {
+    return normalizeContent(title.default);
+  }
+  return void 0;
+}
+__name(resolveMetadataTitle, "resolveMetadataTitle");
+function normalizeKeywords(keywords) {
+  if (Array.isArray(keywords)) return keywords.filter(Boolean).join(", ");
+  return keywords;
+}
+__name(normalizeKeywords, "normalizeKeywords");
+function normalizeRobots(robots) {
+  if (typeof robots === "string") return robots;
+  if (!isRecord(robots)) return void 0;
+  const values = [];
+  if (typeof robots.index === "boolean") values.push(robots.index ? "index" : "noindex");
+  if (typeof robots.follow === "boolean") values.push(robots.follow ? "follow" : "nofollow");
+  return values.join(", ") || void 0;
+}
+__name(normalizeRobots, "normalizeRobots");
+function resolveMetadataBase(metadata) {
+  const base = metadata.metadataBase;
+  if (!base) return void 0;
+  return String(base);
+}
+__name(resolveMetadataBase, "resolveMetadataBase");
+function resolveMetadataUrl(value, metadataBase) {
+  const normalized = normalizeContent(value);
+  if (!normalized) return void 0;
+  if (!metadataBase) return normalized;
+  try {
+    return new URL(normalized, metadataBase).toString();
+  } catch {
+    return normalized;
+  }
+}
+__name(resolveMetadataUrl, "resolveMetadataUrl");
+function normalizeNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+__name(normalizeNumber, "normalizeNumber");
+function normalizeContent(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value instanceof URL) return value.toString();
+  return void 0;
+}
+__name(normalizeContent, "normalizeContent");
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+__name(escapeText, "escapeText");
+function escapeAttribute(value) {
+  return escapeText(value).replace(/"/g, "&quot;");
+}
+__name(escapeAttribute, "escapeAttribute");
+
+// src/middleware/module.ts
+function isWebRequest(request) {
+  return typeof Request !== "undefined" && request instanceof Request;
+}
+__name(isWebRequest, "isWebRequest");
+function toWebRequest(ctx) {
+  if (isWebRequest(ctx.request)) {
+    return ctx.request;
+  }
+  return createWebRequestFromFarmRequest(ctx.request);
+}
+__name(toWebRequest, "toWebRequest");
+function createRequestMiddlewareContext(ctx) {
+  const context = {
+    get url() {
+      return ctx.url;
+    },
+    get pathname() {
+      return ctx.pathname;
+    },
+    get searchParams() {
+      return ctx.searchParams;
+    },
+    get method() {
+      return ctx.method;
+    },
+    get params() {
+      return ctx.params;
+    },
+    get route() {
+      return ctx.route;
+    },
+    get locals() {
+      return ctx.locals;
+    },
+    get data() {
+      return ctx.data;
+    },
+    get headers() {
+      return ctx.headers;
+    },
+    get cookies() {
+      return ctx.cookies;
+    },
+    get(key) {
+      return ctx.locals.get(key);
+    },
+    has(key) {
+      return ctx.locals.has(key);
+    },
+    set(key, value) {
+      ctx.locals.set(key, value);
+    },
+    delete(key) {
+      return ctx.locals.delete(key);
+    },
+    redirect(url, status) {
+      ctx.redirect(url, status);
+    },
+    rewrite(url) {
+      ctx.rewrite(url);
+    },
+    json(data, status) {
+      ctx.json(data, status);
+    },
+    text(content, status) {
+      ctx.text(content, status);
+    },
+    html(content, status) {
+      ctx.html(content, status);
+    }
+  };
+  return context;
+}
+__name(createRequestMiddlewareContext, "createRequestMiddlewareContext");
+function normalizeMiddlewareModule(middlewareModule, routePath) {
+  const module2 = middlewareModule;
+  const defaultExport = module2.default;
+  const namedExport = module2.middleware;
+  const hasNamedExport = typeof namedExport === "function";
+  if (namedExport !== void 0 && !hasNamedExport) {
+    throw new TypeError("The named middleware export must be a function");
+  }
+  if (defaultExport && hasNamedExport) {
+    throw new Error(
+      "A middleware file cannot export both a default handler and a named middleware handler"
+    );
+  }
+  if (hasNamedExport) {
+    return {
+      handlers: [
+        async (ctx) => {
+          return namedExport(toWebRequest(ctx), createRequestMiddlewareContext(ctx));
+        }
+      ],
+      config: module2.config
+    };
+  }
+  if (defaultExport && typeof defaultExport === "object" && "build" in defaultExport) {
+    if (typeof defaultExport.setBasePath === "function") {
+      defaultExport.setBasePath(routePath);
+    }
+    const built = defaultExport.build();
+    const handlers = Array.isArray(built?.handlers) ? built.handlers.filter((handler) => typeof handler === "function") : [];
+    return handlers.length > 0 ? {
+      handlers,
+      config: module2.config || built?.config
+    } : null;
+  }
+  if (typeof defaultExport === "function") {
+    return {
+      handlers: [defaultExport],
+      config: module2.config
+    };
+  }
+  return null;
+}
+__name(normalizeMiddlewareModule, "normalizeMiddlewareModule");
+
+// src/middleware/production-runtime.ts
+function parseCookies(cookieHeader) {
+  if (!cookieHeader) return {};
+  return cookieHeader.split(";").reduce(
+    (cookies, cookie) => {
+      const [name, ...rest] = cookie.split("=");
+      const value = rest.join("=").trim();
+      if (name && value) {
+        cookies[name.trim()] = decodeURIComponent(value);
+      }
+      return cookies;
+    },
+    {}
+  );
+}
+__name(parseCookies, "parseCookies");
+function serializeCookie(name, value, options = {}) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (options.maxAge) cookie += `; Max-Age=${options.maxAge}`;
+  if (options.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
+  cookie += `; Path=${options.path || "/"}`;
+  if (options.domain) cookie += `; Domain=${options.domain}`;
+  if (options.secure) cookie += "; Secure";
+  if (options.httpOnly) cookie += "; HttpOnly";
+  if (options.sameSite) {
+    cookie += `; SameSite=${options.sameSite.charAt(0).toUpperCase()}${options.sameSite.slice(1)}`;
+  }
+  return cookie;
+}
+__name(serializeCookie, "serializeCookie");
+var _WebCookieJar = class _WebCookieJar {
+  constructor(request, headers) {
+    this.headers = headers;
+    this.setCookies = [];
+    this.cookies = parseCookies(request.headers.get("cookie"));
+  }
+  get(name) {
+    return this.cookies[name];
+  }
+  set(name, value, options = {}) {
+    this.cookies[name] = value;
+    const cookieString = serializeCookie(name, value, options);
+    this.setCookies.push(cookieString);
+    this.headers.set("Set-Cookie", this.setCookies.join(", "));
+  }
+  delete(name) {
+    delete this.cookies[name];
+    const cookieString = serializeCookie(name, "", {
+      maxAge: 0,
+      expires: /* @__PURE__ */ new Date(0)
+    });
+    this.setCookies.push(cookieString);
+    this.headers.set("Set-Cookie", this.setCookies.join(", "));
+  }
+  getAll() {
+    return { ...this.cookies };
+  }
+};
+__name(_WebCookieJar, "WebCookieJar");
+var WebCookieJar = _WebCookieJar;
+function mapToHeaders(map) {
+  const headers = new Headers();
+  for (const [key, value] of map) {
+    if (key.toLowerCase() === "set-cookie") {
+      headers.append(key, value);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  return headers;
+}
+__name(mapToHeaders, "mapToHeaders");
+function headersToRecord(headers) {
+  return Object.fromEntries(headers);
+}
+__name(headersToRecord, "headersToRecord");
+function isMiddlewareResponse(value) {
+  return value instanceof Response;
+}
+__name(isMiddlewareResponse, "isMiddlewareResponse");
+function createResponseShim(headers) {
+  return {
+    headersSent: false,
+    writableEnded: false,
+    setHeader(name, value) {
+      headers.set(name, Array.isArray(value) ? value.join(", ") : String(value));
+    },
+    getHeader(name) {
+      return headers.get(name);
+    },
+    writeHead(status, responseHeaders) {
+      this.statusCode = status;
+      if (responseHeaders) {
+        for (const [key, value] of Object.entries(responseHeaders)) {
+          headers.set(key, value);
+        }
+      }
+      this.headersSent = true;
+    },
+    end() {
+      this.writableEnded = true;
+    }
+  };
+}
+__name(createResponseShim, "createResponseShim");
+function withNodeRequestShape(request) {
+  const requestWithShape = request;
+  if (!requestWithShape.socket) {
+    const forwardedFor = request.headers.get("x-forwarded-for")?.split(",")[0]?.trim();
+    try {
+      requestWithShape.socket = {
+        remoteAddress: forwardedFor || "127.0.0.1"
+      };
+    } catch {
+    }
+  }
+  return requestWithShape;
+}
+__name(withNodeRequestShape, "withNodeRequestShape");
+function createHandledResponse(body, init, headers) {
+  const responseHeaders = new Headers(init.headers);
+  for (const [key, value] of headers) {
+    if (key.toLowerCase() === "set-cookie") {
+      responseHeaders.append(key, value);
+    } else {
+      responseHeaders.set(key, value);
+    }
+  }
+  return new Response(body, { ...init, headers: responseHeaders });
+}
+__name(createHandledResponse, "createHandledResponse");
+function createWebMiddlewareContext(request, parent) {
+  let currentRequest = withNodeRequestShape(request);
+  let handledResponse = null;
+  const url = new URL(currentRequest.url);
+  const data = parent?.data ? new Map(parent.data) : /* @__PURE__ */ new Map();
+  const locals = parent?.locals ? new Map(parent.locals) : /* @__PURE__ */ new Map();
+  const headers = /* @__PURE__ */ new Map();
+  if (parent?.headers) {
+    for (const [key, value] of Object.entries(parent.headers)) {
+      headers.set(key, value);
+    }
+  }
+  const ctx = {
+    request: currentRequest,
+    response: createResponseShim(headers),
+    url,
+    pathname: url.pathname,
+    searchParams: url.searchParams,
+    method: currentRequest.method || "GET",
+    params: {},
+    route: url.pathname,
+    parent,
+    vite: {
+      isDev: false,
+      hmr: false
+    },
+    data,
+    locals,
+    headers,
+    cookies: new WebCookieJar(currentRequest, headers),
+    _handled: false,
+    _redirectUrl: void 0,
+    _rewriteUrl: void 0,
+    redirect(redirectUrl, status = 307) {
+      ctx._redirectUrl = redirectUrl;
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        `Redirecting to ${redirectUrl}`,
+        {
+          status,
+          headers: {
+            Location: redirectUrl,
+            "Content-Type": "text/plain"
+          }
+        },
+        headers
+      );
+    },
+    rewrite(rewriteUrl) {
+      ctx._rewriteUrl = rewriteUrl;
+      const nextUrl = new URL(rewriteUrl, currentRequest.url);
+      currentRequest = withNodeRequestShape(new Request(nextUrl, currentRequest));
+      ctx.request = currentRequest;
+      ctx.url = nextUrl;
+      ctx.pathname = nextUrl.pathname;
+      ctx.searchParams = nextUrl.searchParams;
+      ctx.route = nextUrl.pathname;
+    },
+    json(jsonData, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        JSON.stringify(jsonData),
+        {
+          status,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        },
+        headers
+      );
+    },
+    text(content, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        content,
+        {
+          status,
+          headers: {
+            "Content-Type": "text/plain"
+          }
+        },
+        headers
+      );
+    },
+    html(content, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        content,
+        {
+          status,
+          headers: {
+            "Content-Type": "text/html"
+          }
+        },
+        headers
+      );
+    }
+  };
+  return {
+    ctx,
+    getRequest: /* @__PURE__ */ __name(() => currentRequest, "getRequest"),
+    getResponse: /* @__PURE__ */ __name(() => handledResponse, "getResponse")
+  };
+}
+__name(createWebMiddlewareContext, "createWebMiddlewareContext");
+function toMatcherList(matcher) {
+  if (!matcher) return [];
+  return Array.isArray(matcher) ? matcher : [matcher];
+}
+__name(toMatcherList, "toMatcherList");
+function escapeRegex(value) {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+__name(escapeRegex, "escapeRegex");
+function parseColonParam(segment) {
+  const raw = segment.slice(1);
+  const last = raw[raw.length - 1];
+  const modifier = last === "*" || last === "+" || last === "?" ? last : void 0;
+  return {
+    name: modifier ? raw.slice(0, -1) : raw,
+    modifier
+  };
+}
+__name(parseColonParam, "parseColonParam");
+function compilePathPattern(pattern) {
+  const params = [];
+  const segments = pattern.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return { regex: /^\/$/, params };
+  }
+  const parts = segments.map((segment) => {
+    if (segment === "**") {
+      return "(?:/.*)?";
+    }
+    if (segment === "*") {
+      return "/[^/]+";
+    }
+    if (segment.startsWith(":")) {
+      const { name, modifier } = parseColonParam(segment);
+      params.push(name);
+      if (modifier === "*") {
+        return "(?:/(.*))?";
+      }
+      if (modifier === "+") {
+        return "/(.+)";
+      }
+      return "/([^/]+)";
+    }
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      params.push(segment.slice(4, -1));
+      return "(?:/(.*))?";
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      params.push(segment.slice(1, -1));
+      return "/([^/]+)";
+    }
+    return `/${escapeRegex(segment).replace(/\\\*/g, "[^/]*")}`;
+  });
+  return {
+    regex: new RegExp(`^${parts.join("")}$`),
+    params
+  };
+}
+__name(compilePathPattern, "compilePathPattern");
+function matchPattern(pattern, pathname) {
+  if (pattern instanceof RegExp) {
+    pattern.lastIndex = 0;
+    const match2 = pattern.exec(pathname);
+    return {
+      matched: !!match2,
+      params: match2?.groups ? { ...match2.groups } : void 0
+    };
+  }
+  if (pattern === "*" || pattern === "/(.*)") {
+    return { matched: true };
+  }
+  if (pattern.endsWith("(.*)")) {
+    const prefix = pattern.slice(0, -4);
+    return { matched: pathname === prefix || pathname.startsWith(`${prefix}/`) };
+  }
+  const { regex, params } = compilePathPattern(pattern);
+  const match = regex.exec(pathname);
+  if (!match) {
+    return { matched: false };
+  }
+  const values = {};
+  params.forEach((param, index) => {
+    values[param] = decodeURIComponent(match[index + 1] || "");
+  });
+  return {
+    matched: true,
+    params: Object.keys(values).length > 0 ? values : void 0
+  };
+}
+__name(matchPattern, "matchPattern");
+function matchesConfig(pathname, config, ctx) {
+  if (config.exclude) {
+    for (const pattern of config.exclude) {
+      if (matchPattern(pattern, pathname).matched) {
+        return { matched: false };
+      }
+    }
+  }
+  if (config.matcher) {
+    for (const matcher of toMatcherList(config.matcher)) {
+      if (typeof matcher === "string" || matcher instanceof RegExp) {
+        const result = matchPattern(matcher, pathname);
+        if (result.matched) {
+          return result;
+        }
+      } else if (typeof matcher === "function") {
+        return { matched: matcher(ctx) };
+      }
+    }
+    return { matched: false };
+  }
+  return { matched: true };
+}
+__name(matchesConfig, "matchesConfig");
+function matchRoutePath(pathname, middlewarePath) {
+  if (middlewarePath === "/") return { matched: true };
+  const exactMatch = matchPattern(middlewarePath, pathname);
+  if (exactMatch.matched) {
+    return exactMatch;
+  }
+  const nestedMatch = matchPattern(`${middlewarePath}/:__farmRest*`, pathname);
+  if (!nestedMatch.matched) {
+    return { matched: false };
+  }
+  const params = { ...nestedMatch.params || {} };
+  delete params.__farmRest;
+  return {
+    matched: true,
+    params: Object.keys(params).length > 0 ? params : void 0
+  };
+}
+__name(matchRoutePath, "matchRoutePath");
+function getConfigHandlers(entry) {
+  const handlers = [];
+  if ("handler" in entry && typeof entry.handler === "function") {
+    handlers.push(entry.handler);
+  }
+  if ("handlers" in entry && Array.isArray(entry.handlers)) {
+    handlers.push(...entry.handlers.filter((handler) => typeof handler === "function"));
+  }
+  return handlers;
+}
+__name(getConfigHandlers, "getConfigHandlers");
+function toMiddlewareConfig(entry) {
+  const { matcher, exclude, runtime } = entry;
+  return { matcher, exclude, runtime };
+}
+__name(toMiddlewareConfig, "toMiddlewareConfig");
+function normalizeConfigMiddleware(config) {
+  const entries = [];
+  let globalConfig;
+  if (!config) {
+    return { entries, globalConfig };
+  }
+  const configEntries = Array.isArray(config) ? config : [config];
+  for (const [index, entry] of configEntries.entries()) {
+    const handlers = getConfigHandlers(entry);
+    const middlewareConfig = toMiddlewareConfig(entry);
+    if (handlers.length === 0) {
+      globalConfig = middlewareConfig;
+      continue;
+    }
+    entries.push({
+      path: "/",
+      filePath: `farm.config.ts#middleware-${index}`,
+      handlers,
+      config: middlewareConfig,
+      source: "config"
+    });
+  }
+  return { entries, globalConfig };
+}
+__name(normalizeConfigMiddleware, "normalizeConfigMiddleware");
+function normalizeFileMiddleware(modules = []) {
+  const entries = [];
+  for (const moduleEntry of modules) {
+    const normalized = normalizeMiddlewareModule(moduleEntry.module, moduleEntry.path);
+    if (!normalized) {
+      continue;
+    }
+    entries.push({
+      path: moduleEntry.path,
+      filePath: moduleEntry.filePath || moduleEntry.path,
+      handlers: normalized.handlers,
+      config: normalized.config,
+      source: "file"
+    });
+  }
+  return entries;
+}
+__name(normalizeFileMiddleware, "normalizeFileMiddleware");
+async function executeHandlers(handlers, ctx) {
+  let handlerIndex = 0;
+  let returnedResponse;
+  const executeNext = /* @__PURE__ */ __name(async () => {
+    if (handlerIndex < handlers.length) {
+      const handler = handlers[handlerIndex++];
+      const result2 = await handler(ctx, executeNext);
+      if (isMiddlewareResponse(result2)) {
+        returnedResponse = result2;
+        return result2;
+      }
+    }
+    return returnedResponse;
+  }, "executeNext");
+  const result = await executeNext();
+  return isMiddlewareResponse(result) ? result : returnedResponse;
+}
+__name(executeHandlers, "executeHandlers");
+function emptyResult(request) {
+  return {
+    request,
+    response: null,
+    data: /* @__PURE__ */ new Map(),
+    context: /* @__PURE__ */ new Map(),
+    headers: new Headers(),
+    handled: false
+  };
+}
+__name(emptyResult, "emptyResult");
+function createProductionMiddlewareRunner(options = {}) {
+  const configMiddleware = normalizeConfigMiddleware(options.config);
+  const fileMiddleware = normalizeFileMiddleware(options.modules);
+  const entries = [...configMiddleware.entries, ...fileMiddleware];
+  const globalConfig = configMiddleware.globalConfig;
+  return /* @__PURE__ */ __name(async function runProductionMiddleware(request) {
+    if (!globalConfig && entries.length === 0) {
+      return emptyResult(request);
+    }
+    let contextState = createWebMiddlewareContext(request);
+    let ctx = contextState.ctx;
+    let currentRequest = contextState.getRequest();
+    const initialPathname = options.i18n?.enabled ? stripFarmLocaleFromPathname(ctx.pathname, options.i18n) : ctx.pathname;
+    let parentData;
+    if (globalConfig) {
+      const globalMatch = matchesConfig(initialPathname, globalConfig, ctx);
+      if (!globalMatch.matched) {
+        return emptyResult(request);
+      }
+      if (globalMatch.params) {
+        ctx.params = { ...ctx.params, ...globalMatch.params };
+      }
+    }
+    const applicable = entries.map((entry) => ({
+      entry,
+      routeMatch: entry.source === "config" ? { matched: true } : matchRoutePath(initialPathname, entry.path)
+    })).filter((candidate) => candidate.routeMatch.matched);
+    if (applicable.length === 0) {
+      return {
+        request: currentRequest,
+        response: null,
+        data: new Map(ctx.data),
+        context: new Map(ctx.locals),
+        headers: mapToHeaders(ctx.headers),
+        handled: false
+      };
+    }
+    for (const candidate of applicable) {
+      const { entry, routeMatch } = candidate;
+      const configMatch = entry.config ? matchesConfig(initialPathname, entry.config, ctx) : { matched: true };
+      if (!configMatch.matched) {
+        continue;
+      }
+      if (parentData) {
+        contextState = createWebMiddlewareContext(currentRequest, parentData);
+        ctx = contextState.ctx;
+      }
+      if (routeMatch.params) {
+        ctx.params = { ...ctx.params, ...routeMatch.params };
+      }
+      if (configMatch.params) {
+        ctx.params = { ...ctx.params, ...configMatch.params };
+      }
+      const middlewareStartTime = Date.now();
+      const middlewareEvent = {
+        route: entry.path,
+        pathname: initialPathname,
+        name: entry.filePath
+      };
+      emitFarmEvent({ type: "middleware.start", ...middlewareEvent });
+      try {
+        const returnedResponse = await executeHandlers(entry.handlers, ctx);
+        currentRequest = contextState.getRequest();
+        if (returnedResponse) {
+          const response = applyProductionMiddlewareHeaders(
+            returnedResponse,
+            mapToHeaders(ctx.headers)
+          );
+          emitFarmEvent({
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: response.status
+          });
+          return {
+            request: currentRequest,
+            response,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(ctx.headers),
+            handled: true
+          };
+        }
+        if (ctx._handled) {
+          const response = contextState.getResponse() || new Response(null);
+          emitFarmEvent({
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: response.status
+          });
+          return {
+            request: currentRequest,
+            response,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(ctx.headers),
+            handled: true
+          };
+        }
+        emitFarmEvent({
+          type: "middleware.complete",
+          ...middlewareEvent,
+          durationMs: Date.now() - middlewareStartTime
+        });
+      } catch (error) {
+        emitFarmEvent({
+          type: "middleware.error",
+          ...middlewareEvent,
+          error
+        });
+        throw error;
+      }
+      parentData = {
+        data: new Map(ctx.data),
+        locals: new Map(ctx.locals),
+        headers: headersToRecord(ctx.headers)
+      };
+    }
+    return {
+      request: currentRequest,
+      response: null,
+      data: new Map(ctx.data),
+      context: new Map(ctx.locals),
+      headers: mapToHeaders(ctx.headers),
+      handled: false
+    };
+  }, "runProductionMiddleware");
+}
+__name(createProductionMiddlewareRunner, "createProductionMiddlewareRunner");
+function applyProductionMiddlewareHeaders(response, middlewareHeaders) {
+  if (!middlewareHeaders || Array.from(middlewareHeaders.keys()).length === 0) {
+    return response;
+  }
+  const headers = new Headers(response.headers);
+  for (const [key, value] of middlewareHeaders) {
+    if (key.toLowerCase() === "set-cookie") {
+      headers.append(key, value);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+__name(applyProductionMiddlewareHeaders, "applyProductionMiddlewareHeaders");
+
+// src/middleware/server.ts
+var import_async_hooks = require("async_hooks");
+var MIDDLEWARE_DATA_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.middlewareDataStore");
+var MIDDLEWARE_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.middlewareContextStore");
+function getGlobalMiddlewareStore(key) {
+  const state = globalThis;
+  const existing = state[key];
+  if (existing instanceof import_async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const store = new import_async_hooks.AsyncLocalStorage();
+  state[key] = store;
+  return store;
+}
+__name(getGlobalMiddlewareStore, "getGlobalMiddlewareStore");
+var middlewareStore = getGlobalMiddlewareStore(MIDDLEWARE_DATA_STORE_KEY);
+var middlewareContextStore = getGlobalMiddlewareStore(MIDDLEWARE_CONTEXT_STORE_KEY);
+function toMiddlewareMap(data) {
+  if (data instanceof Map) {
+    return new Map(data);
+  }
+  return new Map(Object.entries(data));
+}
+__name(toMiddlewareMap, "toMiddlewareMap");
+async function _runWithMiddlewareData(data, fn) {
+  return middlewareStore.run(toMiddlewareMap(data), fn);
+}
+__name(_runWithMiddlewareData, "_runWithMiddlewareData");
+async function _runWithMiddlewareContext(context, fn) {
+  return middlewareContextStore.run(toMiddlewareMap(context), fn);
+}
+__name(_runWithMiddlewareContext, "_runWithMiddlewareContext");
+
+// src/navigation-errors.ts
+var REDIRECT_ERROR_CODE = "FARM_REDIRECT";
+var NOT_FOUND_ERROR_CODE = "FARM_NOT_FOUND";
+var REDIRECT_ERROR_SYMBOL = /* @__PURE__ */ Symbol.for("farm.navigation.redirect");
+var NOT_FOUND_ERROR_SYMBOL = /* @__PURE__ */ Symbol.for("farm.navigation.notFound");
+function isFarmRedirectError(error) {
+  return Boolean(getFarmRedirectError(error));
+}
+__name(isFarmRedirectError, "isFarmRedirectError");
+function getFarmRedirectError(error) {
+  if (!error || typeof error !== "object") return null;
+  const candidate = error;
+  if (candidate[REDIRECT_ERROR_SYMBOL]) {
+    return candidate[REDIRECT_ERROR_SYMBOL];
+  }
+  if (typeof candidate.digest === "string" && candidate.digest.startsWith(`${REDIRECT_ERROR_CODE};`)) {
+    const [, status, ...urlParts] = candidate.digest.split(";");
+    const parsedStatus = Number(status);
+    if (isRedirectStatus(parsedStatus)) {
+      return {
+        status: parsedStatus,
+        url: urlParts.join(";")
+      };
+    }
+  }
+  return null;
+}
+__name(getFarmRedirectError, "getFarmRedirectError");
+function isFarmNotFoundError(error) {
+  if (!error || typeof error !== "object") return false;
+  const candidate = error;
+  return Boolean(candidate[NOT_FOUND_ERROR_SYMBOL] || candidate.digest === NOT_FOUND_ERROR_CODE);
+}
+__name(isFarmNotFoundError, "isFarmNotFoundError");
+function isRedirectStatus(status) {
+  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+__name(isRedirectStatus, "isRedirectStatus");
+
+// src/route-context.ts
+var FARM_ROUTE_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("farm.routeContext");
+async function resolveFarmRouteContext(config, input) {
+  if (typeof config.context !== "function") {
+    return void 0;
+  }
+  return config.context(input);
+}
+__name(resolveFarmRouteContext, "resolveFarmRouteContext");
+function withFarmRouteContext(props, context) {
+  if (context === void 0) {
+    return props;
+  }
+  Object.defineProperty(props, FARM_ROUTE_CONTEXT_SYMBOL, {
+    value: context,
+    enumerable: false,
+    configurable: true
+  });
+  return props;
+}
+__name(withFarmRouteContext, "withFarmRouteContext");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _runWithAfterRequest,
+  _runWithCurrentRequest,
+  _runWithMiddlewareContext,
+  _runWithMiddlewareData,
+  addMetadataImageReference,
+  applyProductionMiddlewareHeaders,
+  configureFarmObservability,
+  createFarmCacheKey,
+  createFarmLocaleCookie,
+  createProductionMiddlewareRunner,
+  emitFarmEvent,
+  getCurrentRequest,
+  getFarmDataCache,
+  getFarmLocaleVaryHeaders,
+  getFarmRedirectError,
+  isFarmNotFoundError,
+  isFarmRedirectError,
+  localizeFarmHref,
+  localizeFarmPathname,
+  mergeMetadata,
+  normalizeRevalidatePath,
+  renderMetadataHead,
+  resolveFarmRouteContext,
+  stripFarmLocaleFromPathname,
+  withFarmRouteContext
+});
+//# sourceMappingURL=production-runtime.cjs.map