@farm.js/core 0.1.16 → 0.1.18

package/dist/middleware.cjs

@@ -1,3017 +1,65 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/middleware/index.ts
-var middleware_exports = {};
-__export(middleware_exports, {
-  MiddlewareManager: () => MiddlewareManager,
-  UnsupportedRateLimitStorageError: () => UnsupportedRateLimitStorageError,
-  _runWithMiddlewareContext: () => _runWithMiddlewareContext,
-  _runWithMiddlewareData: () => _runWithMiddlewareData,
-  applyProductionMiddlewareHeaders: () => applyProductionMiddlewareHeaders,
-  canonicalizeRequestPathSegments: () => canonicalizeRequestPathSegments,
-  createContext: () => createContext,
-  createProductionMiddlewareRunner: () => createProductionMiddlewareRunner,
-  farmMiddlewarePlugin: () => farmMiddlewarePlugin,
-  getFromMiddleware: () => getFromMiddleware,
-  getMiddlewareContext: () => getMiddlewareContext,
-  getMiddlewareData: () => getMiddlewareData,
-  getMiddlewareValue: () => getMiddlewareValue,
-  getRateLimitStatus: () => getRateLimitStatus,
-  hasMiddlewareData: () => hasMiddlewareData,
-  matchesMiddlewareConfig: () => matchesMiddlewareConfig2,
-  memoryRateLimitStorage: () => memoryRateLimitStorage,
-  middleware: () => middleware,
-  unwrapMiddleware: () => unwrapMiddleware
-});
-module.exports = __toCommonJS(middleware_exports);
 
-// src/middleware/chain.ts
-var DEFAULT_MEMORY_RATE_LIMIT_ENTRIES = 1e5;
-var _UnsupportedRateLimitStorageError = class _UnsupportedRateLimitStorageError extends TypeError {
-  constructor() {
-    super(
-      "RateLimitStorage must implement atomic increment(key, windowMs). Legacy get/set adapters can lose increments under concurrency. Use memoryRateLimitStorage() for one process or redisRateLimitStorage() from @farm.js/cache-redis for production."
-    );
-    this.name = "UnsupportedRateLimitStorageError";
-  }
-};
-__name(_UnsupportedRateLimitStorageError, "UnsupportedRateLimitStorageError");
-var UnsupportedRateLimitStorageError = _UnsupportedRateLimitStorageError;
-function memoryRateLimitStorage(options = {}) {
-  const maxEntries = options.maxEntries ?? DEFAULT_MEMORY_RATE_LIMIT_ENTRIES;
-  if (!Number.isSafeInteger(maxEntries) || maxEntries <= 0) {
-    throw new TypeError("memoryRateLimitStorage maxEntries must be a positive safe integer.");
-  }
-  const records = /* @__PURE__ */ new Map();
-  let earliestExpiry = Infinity;
-  function read(key, now) {
-    const record = records.get(key);
-    if (!record) return null;
-    if (record.resetAt <= now) {
-      records.delete(key);
-      return null;
-    }
-    return record;
-  }
-  __name(read, "read");
-  function pruneExpired(now) {
-    if (now < earliestExpiry) return;
-    earliestExpiry = Infinity;
-    for (const [key, record] of records) {
-      if (record.resetAt <= now) records.delete(key);
-      else earliestExpiry = Math.min(earliestExpiry, record.resetAt);
-    }
-  }
-  __name(pruneExpired, "pruneExpired");
-  return {
-    increment(key, windowMs) {
-      if (!Number.isSafeInteger(windowMs) || windowMs <= 0) {
-        throw new TypeError("Rate-limit windowMs must be a positive safe integer.");
-      }
-      const now = Date.now();
-      const current = read(key, now);
-      if (current) {
-        current.count++;
-        return { ...current };
-      }
-      if (records.size >= maxEntries) pruneExpired(now);
-      if (records.size >= maxEntries) {
-        throw new Error(
-          `Process-local rate-limit storage reached its ${maxEntries} active-key capacity. Configure a shared production adapter or increase maxEntries.`
-        );
-      }
-      const next = { count: 1, resetAt: now + windowMs };
-      records.set(key, next);
-      earliestExpiry = Math.min(earliestExpiry, next.resetAt);
-      return { ...next };
-    },
-    get(key) {
-      const record = read(key, Date.now());
-      return record ? { ...record } : null;
-    }
-  };
-}
-__name(memoryRateLimitStorage, "memoryRateLimitStorage");
-var defaultRateLimitStorage = memoryRateLimitStorage();
-function parseTimeWindow(window) {
-  const match = window.match(/^(\d+)(ms|s|m|h|d)$/);
-  if (!match) throw new Error(`Invalid time window: ${window}`);
-  const [, amount, unit] = match;
-  const value = Number.parseInt(amount, 10);
-  const multipliers = {
-    ms: 1,
-    s: 1e3,
-    m: 60 * 1e3,
-    h: 60 * 60 * 1e3,
-    d: 24 * 60 * 60 * 1e3
-  };
-  const windowMs = value * multipliers[unit];
-  if (!Number.isSafeInteger(windowMs) || windowMs <= 0) {
-    throw new Error(`Invalid time window: ${window}`);
-  }
-  return windowMs;
-}
-__name(parseTimeWindow, "parseTimeWindow");
-function createRateLimitMiddleware(config) {
-  if (!Number.isSafeInteger(config.requests) || config.requests <= 0) {
-    throw new TypeError("Rate limit requests must be a positive safe integer.");
-  }
-  const windowMs = parseTimeWindow(config.window);
-  const storage = config.storage || defaultRateLimitStorage;
-  assertAtomicRateLimitStorage(storage);
-  return async (ctx, next) => {
-    const key = config.keyGenerator ? config.keyGenerator(ctx) : `${requireRateLimitClientAddress(ctx)}:${ctx.pathname}`;
-    const current = await storage.increment(key, windowMs);
-    assertRateLimitIncrementResult(current);
-    const now = Date.now();
-    const resetIn = Math.max(1, Math.ceil((current.resetAt - now) / 1e3));
-    const remaining = Math.max(0, config.requests - current.count);
-    setRateLimitHeaders(ctx, config.requests, remaining, resetIn, Math.ceil(windowMs / 1e3));
-    if (current.count > config.requests) {
-      setMiddlewareResponseHeader(ctx, "Retry-After", String(resetIn));
-      if (config.onLimit) {
-        const result = await config.onLimit(ctx);
-        if (result) return result;
-      }
-      ctx.json(
-        {
-          error: "Rate limit exceeded",
-          retryAfter: resetIn
-        },
-        429
-      );
-      return;
-    }
-    return next();
-  };
-}
-__name(createRateLimitMiddleware, "createRateLimitMiddleware");
-function requireRateLimitClientAddress(ctx) {
-  const address = ctx.request.socket?.remoteAddress;
-  if (address) return address;
-  throw new Error(
-    "Rate limiting could not identify the caller: this runtime reports no client address. Set `server.trustProxy` so a proxy's x-forwarded-for is trusted, or pass a `keyGenerator` that derives the bucket from something you do have, such as a session or an API key."
-  );
-}
-__name(requireRateLimitClientAddress, "requireRateLimitClientAddress");
-function assertAtomicRateLimitStorage(storage) {
-  if (!storage || typeof storage.increment !== "function") {
-    throw new UnsupportedRateLimitStorageError();
-  }
-}
-__name(assertAtomicRateLimitStorage, "assertAtomicRateLimitStorage");
-function assertRateLimitIncrementResult(result) {
-  if (!result || !Number.isSafeInteger(result.count) || result.count <= 0 || !Number.isFinite(result.resetAt) || result.resetAt <= 0) {
-    throw new TypeError(
-      "RateLimitStorage.increment() must return a positive integer count and a resetAt timestamp."
-    );
-  }
-}
-__name(assertRateLimitIncrementResult, "assertRateLimitIncrementResult");
-function setRateLimitHeaders(ctx, limit, remaining, resetIn, windowSeconds) {
-  setMiddlewareResponseHeader(ctx, "RateLimit-Policy", `"farm";q=${limit};w=${windowSeconds}`);
-  setMiddlewareResponseHeader(ctx, "RateLimit", `"farm";r=${remaining};t=${resetIn}`);
-}
-__name(setRateLimitHeaders, "setRateLimitHeaders");
-function setMiddlewareResponseHeader(ctx, name, value) {
-  ctx.headers.set(name, value);
-  if (!ctx.response.headersSent && !ctx.response.writableEnded) {
-    ctx.response.setHeader(name, value);
-  }
-}
-__name(setMiddlewareResponseHeader, "setMiddlewareResponseHeader");
-function matchPattern(pattern, pathname) {
-  if (pattern instanceof RegExp) {
-    return pattern.test(pathname);
-  }
-  const regexPattern = pattern.replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "__SINGLE_STAR__").replace(/[.+?^${}()|[\]\\/]/g, "\\$&").replace(/__DOUBLE_STAR__/g, ".*").replace(/__SINGLE_STAR__/g, "[^/]+");
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(pathname);
-}
-__name(matchPattern, "matchPattern");
-var _MiddlewareChainImpl = class _MiddlewareChainImpl {
-  constructor(basePath = "/") {
-    this.handlers = [];
-    this.basePath = basePath === "/" ? "/" : basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
-  }
-  /**
-   * Set the base path for this middleware chain (called by manager when loading)
-   */
-  setBasePath(path4) {
-    this.basePath = path4 === "/" ? "/" : path4.endsWith("/") ? path4.slice(0, -1) : path4;
-  }
-  use(fn) {
-    this.handlers.push(fn);
-    return this;
-  }
-  /**
-   * Normalize a path pattern - auto-scope to middleware route
-   * If middleware is in /contact, then "/api" becomes "/contact/api"
-   */
-  normalizePattern(pattern) {
-    if (this.basePath === "/") {
-      return pattern.startsWith("/") ? pattern : `/${pattern}`;
-    }
-    const cleanPattern = pattern.startsWith("/") ? pattern.slice(1) : pattern;
-    return `${this.basePath}/${cleanPattern}`;
-  }
-  /**
-   * Conditionally run middleware based on a condition.
-   * Only supports boolean values or functions that evaluate to boolean.
-   * Route-based string matching has been removed - use function conditions instead.
-   *
-   * @example
-   * .when(true, (ctx, next) => { ... })  // Always run
-   * .when((ctx) => ctx.data.get('flag'), (ctx, next) => { ... })  // Conditional
-   * .when((ctx) => ctx.pathname === '/contact', (ctx, next) => { ... })  // Path-based condition
-   */
-  when(condition, fn) {
-    const conditionalMiddleware = /* @__PURE__ */ __name(async (ctx, next) => {
-      const shouldRun = typeof condition === "function" ? condition(ctx) : condition;
-      if (!shouldRun) {
-        return next();
-      }
-      if (typeof fn === "function" && fn.length === 2) {
-        return fn(ctx, next);
-      } else {
-        const subChain = middleware(this.basePath);
-        fn(subChain);
-        const { handlers } = subChain.build();
-        let index = 0;
-        let returnedResponse;
-        const executeNext = /* @__PURE__ */ __name(async () => {
-          if (index < handlers.length) {
-            const handler = handlers[index++];
-            const result = await handler(ctx, executeNext);
-            if (result instanceof Response) {
-              returnedResponse = result;
-              return result;
-            }
-          } else {
-            const result = await next();
-            if (result instanceof Response) {
-              returnedResponse = result;
-              return result;
-            }
-          }
-          return returnedResponse;
-        }, "executeNext");
-        return executeNext();
-      }
-    }, "conditionalMiddleware");
-    this.handlers.push(conditionalMiddleware);
-    return this;
-  }
-  rateLimit(config) {
-    this.handlers.push(createRateLimitMiddleware(config));
-    return this;
-  }
-  redirect(source, destination, permanent = false) {
-    const redirectMiddleware = /* @__PURE__ */ __name(async (ctx, next) => {
-      const normalizedSource = this.normalizePattern(source);
-      if (matchPattern(normalizedSource, ctx.pathname)) {
-        ctx.redirect(destination, permanent ? 308 : 307);
-        return;
-      }
-      return next();
-    }, "redirectMiddleware");
-    this.handlers.push(redirectMiddleware);
-    return this;
-  }
-  /**
-   * Rewrite the current middleware route to a new destination.
-   * Since each middleware file is route-specific, the source is automatically
-   * the middleware's route, so you only need to specify the destination.
-   *
-   * @param destination - The destination path to rewrite to
-   * @param condition - Optional boolean or function that evaluates to boolean.
-   *                    If provided and evaluates to false, rewrite is skipped.
-   *                    If not provided, rewrite always happens.
-   *
-   * @example
-   * // In /contact/middleware.ts
-   * .rewrite('/about')  // Always rewrites /contact to /about
-   * .rewrite('/about', true)  // Always rewrites
-   * .rewrite('/about', false)  // Never rewrites
-   * .rewrite('/about', (ctx) => ctx.data.get('shouldRewrite'))  // Conditional rewrite
-   */
-  rewrite(destination, condition) {
-    const rewriteMiddleware = /* @__PURE__ */ __name(async (ctx, next) => {
-      if (condition !== void 0) {
-        const shouldRewrite = typeof condition === "function" ? condition(ctx) : condition;
-        if (!shouldRewrite) {
-          return next();
-        }
-      }
-      if (this.basePath !== "/") {
-        if (ctx.pathname === this.basePath) {
-          ctx.rewrite(destination);
-        } else if (ctx.pathname.startsWith(this.basePath + "/")) {
-          const subPath = ctx.pathname.slice(this.basePath.length);
-          const newPath = destination + subPath;
-          ctx.rewrite(newPath);
-        }
-      } else {
-        ctx.rewrite(destination);
-      }
-      return next();
-    }, "rewriteMiddleware");
-    this.handlers.push(rewriteMiddleware);
-    return this;
-  }
-  build() {
-    return {
-      handlers: this.handlers,
-      config: this.config
-    };
-  }
-};
-__name(_MiddlewareChainImpl, "MiddlewareChainImpl");
-var MiddlewareChainImpl = _MiddlewareChainImpl;
-async function getRateLimitStatus(key, limit, storage = defaultRateLimitStorage) {
-  if (!Number.isSafeInteger(limit) || limit <= 0) {
-    throw new TypeError("Rate limit must be a positive safe integer.");
-  }
-  assertAtomicRateLimitStorage(storage);
-  if (typeof storage.get !== "function") {
-    throw new TypeError(
-      "getRateLimitStatus() requires a RateLimitStorage adapter that implements get(key)."
-    );
-  }
-  const record = await storage.get(key);
-  if (!record) {
-    return {
-      requests: 0,
-      limit,
-      remaining: limit,
-      resetIn: null,
-      resetAt: null,
-      isLimited: false
-    };
-  }
-  assertRateLimitIncrementResult(record);
-  const now = Date.now();
-  if (record.resetAt && now > record.resetAt) {
-    return {
-      requests: 0,
-      limit,
-      remaining: limit,
-      resetIn: null,
-      resetAt: null,
-      isLimited: false
-    };
-  }
-  const requests = record.count || 0;
-  const remaining = Math.max(0, limit - requests);
-  const isLimited = requests >= limit;
-  let resetIn = null;
-  let resetAt = null;
-  if (record.resetAt) {
-    const remainingMs = record.resetAt - now;
-    resetIn = remainingMs > 0 ? Math.ceil(remainingMs / 1e3) : null;
-    resetAt = new Date(record.resetAt);
-  }
-  return {
-    requests,
-    limit,
-    remaining,
-    resetIn,
-    resetAt,
-    isLimited
-  };
-}
-__name(getRateLimitStatus, "getRateLimitStatus");
-function middleware(basePath = "/") {
-  return new MiddlewareChainImpl(basePath);
-}
-__name(middleware, "middleware");
 
-// 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());
-function resolveFarmRequestURL(req, options = {}) {
-  if (options.origin) {
-    return new URL(req.url || "/", options.origin);
-  }
-  const forwardedHost = options.trustProxy ? firstForwardedHeaderValue(req.headers["x-forwarded-host"]) : void 0;
-  const fallbackHost = firstForwardedHeaderValue(req.headers.host) || "localhost";
-  const forwardedProto = options.trustProxy ? firstForwardedHeaderValue(req.headers["x-forwarded-proto"]) : void 0;
-  const normalizedProto = forwardedProto?.toLowerCase();
-  const proto = normalizedProto === "https" || normalizedProto === "http" ? normalizedProto : isEncryptedFarmRequest(req) ? "https" : "http";
-  return new URL(req.url || "/", resolveRequestOrigin(proto, forwardedHost, fallbackHost));
-}
-__name(resolveFarmRequestURL, "resolveFarmRequestURL");
-function createWebRequestFromFarmRequest(req, options = {}) {
-  const fullUrl = resolveFarmRequestURL(req, options).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);
-  }
-  const method = (req.method || "GET").toUpperCase();
-  const init = {
-    method: req.method,
-    headers
-  };
-  if (method !== "GET" && method !== "HEAD") {
-    init.body = import_node_stream.Readable.toWeb(req);
-    init.duplex = "half";
-  }
-  return new Request(fullUrl, init);
-}
-__name(createWebRequestFromFarmRequest, "createWebRequestFromFarmRequest");
-function isEncryptedFarmRequest(req) {
-  return Boolean(req.socket?.encrypted);
-}
-__name(isEncryptedFarmRequest, "isEncryptedFarmRequest");
-function firstForwardedHeaderValue(value) {
-  const first = Array.isArray(value) ? value[0] : value;
-  const token = first?.split(",", 1)[0]?.trim();
-  return token || void 0;
-}
-__name(firstForwardedHeaderValue, "firstForwardedHeaderValue");
-function resolveRequestOrigin(proto, host, fallback) {
-  for (const candidate of [host, fallback, "localhost"]) {
-    if (!candidate) continue;
-    if (/[\s/?#@\\]/u.test(candidate)) continue;
-    try {
-      const url = new URL(`${proto}://${candidate}`);
-      if (url.username || url.password || url.pathname !== "/" || url.search || url.hash) continue;
-      return url.origin;
-    } catch {
-    }
-  }
-  return `${proto}://localhost`;
-}
-__name(resolveRequestOrigin, "resolveRequestOrigin");
 
-// src/request-cookies.ts
-function parseRequestCookieHeader(header) {
-  if (!header?.trim()) return [];
-  return header.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
-    const separatorIndex = part.indexOf("=");
-    if (separatorIndex === -1) {
-      return {
-        name: decodeCookiePart(part),
-        value: ""
-      };
-    }
-    return {
-      name: decodeCookiePart(part.slice(0, separatorIndex).trim()),
-      value: decodeCookiePart(part.slice(separatorIndex + 1).trim())
-    };
-  }).filter((cookie) => cookie.name.length > 0);
-}
-__name(parseRequestCookieHeader, "parseRequestCookieHeader");
-function decodeCookiePart(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-__name(decodeCookiePart, "decodeCookiePart");
 
-// src/middleware/cookie-header.ts
-function parseMiddlewareCookieHeader(cookieHeader) {
-  const cookies = /* @__PURE__ */ Object.create(null);
-  for (const cookie of parseRequestCookieHeader(cookieHeader)) {
-    if (!Object.prototype.hasOwnProperty.call(cookies, cookie.name)) {
-      cookies[cookie.name] = cookie.value;
-    }
-  }
-  return cookies;
-}
-__name(parseMiddlewareCookieHeader, "parseMiddlewareCookieHeader");
-function applyCookieNamePrefixRequirements(name, options) {
-  if (name.startsWith("__Host-")) {
-    return { ...options, secure: true, path: "/", domain: void 0 };
-  }
-  if (name.startsWith("__Secure-")) {
-    return { ...options, secure: true };
-  }
-  return options;
-}
-__name(applyCookieNamePrefixRequirements, "applyCookieNamePrefixRequirements");
-function serializeMiddlewareCookie(name, value, options = {}) {
-  const resolved = applyCookieNamePrefixRequirements(name, options);
-  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-  if (resolved.maxAge != null) cookie += `; Max-Age=${resolved.maxAge}`;
-  if (resolved.expires) cookie += `; Expires=${resolved.expires.toUTCString()}`;
-  cookie += `; Path=${resolved.path || "/"}`;
-  if (resolved.domain) cookie += `; Domain=${resolved.domain}`;
-  if (resolved.secure) cookie += "; Secure";
-  if (resolved.httpOnly) cookie += "; HttpOnly";
-  if (resolved.sameSite) {
-    cookie += `; SameSite=${resolved.sameSite.charAt(0).toUpperCase()}${resolved.sameSite.slice(1)}`;
-  }
-  return cookie;
-}
-__name(serializeMiddlewareCookie, "serializeMiddlewareCookie");
-function serializeMiddlewareCookieDeletion(name, options = {}) {
-  return serializeMiddlewareCookie(name, "", { ...options, maxAge: 0, expires: /* @__PURE__ */ new Date(0) });
-}
-__name(serializeMiddlewareCookieDeletion, "serializeMiddlewareCookieDeletion");
 
-// src/middleware/context.ts
-var _CookieJarImpl = class _CookieJarImpl {
-  constructor(req, res) {
-    this.req = req;
-    this.res = res;
-    this.cookies = parseMiddlewareCookieHeader(req.headers.cookie);
-    const existing = res.getHeader("Set-Cookie");
-    this.setCookies = Array.isArray(existing) ? existing.map(String) : existing === void 0 ? [] : [String(existing)];
-  }
-  get(name) {
-    return this.cookies[name];
-  }
-  set(name, value, options = {}) {
-    this.cookies[name] = value;
-    const cookieString = serializeMiddlewareCookie(name, value, options);
-    this.setCookies.push(cookieString);
-    this.res.setHeader("Set-Cookie", this.setCookies);
-  }
-  delete(name, options = {}) {
-    delete this.cookies[name];
-    this.setCookies.push(serializeMiddlewareCookieDeletion(name, options));
-    this.res.setHeader("Set-Cookie", this.setCookies);
-  }
-  getAll() {
-    return { ...this.cookies };
-  }
-};
-__name(_CookieJarImpl, "CookieJarImpl");
-var CookieJarImpl = _CookieJarImpl;
-function createContext(req, res, viteServer, parent, server) {
-  const url = resolveFarmRequestURL(req, { trustProxy: server?.trustProxy });
-  const headers = /* @__PURE__ */ new Map();
-  const data = parent?.data ? new Map(parent.data) : /* @__PURE__ */ new Map();
-  const locals = parent?.locals ? new Map(parent.locals) : /* @__PURE__ */ new Map();
-  const cookies = new CookieJarImpl(req, res);
-  if (parent?.headers) {
-    for (const [key, value] of Object.entries(parent.headers)) {
-      headers.set(key, value);
-    }
-  }
-  let handled = false;
-  const applyResponseHeaders = /* @__PURE__ */ __name(() => {
-    for (const [key, value] of headers) {
-      try {
-        res.setHeader(key, value);
-      } catch {
-      }
-    }
-  }, "applyResponseHeaders");
-  const ctx = {
-    request: req,
-    response: res,
-    url,
-    pathname: url.pathname,
-    searchParams: url.searchParams,
-    method: req.method || "GET",
-    params: {},
-    route: url.pathname,
-    parent,
-    vite: {
-      isDev: process.env.NODE_ENV !== "production",
-      hmr: !!viteServer?.hot,
-      server: viteServer
-    },
-    data,
-    locals,
-    headers,
-    cookies,
-    _handled: false,
-    redirect(redirectUrl, status = 307) {
-      if (handled) {
-        console.warn("Response already sent, cannot redirect");
-        return;
-      }
-      ctx._redirectUrl = redirectUrl;
-      ctx._handled = true;
-      handled = true;
-      applyResponseHeaders();
-      res.writeHead(status, {
-        Location: redirectUrl,
-        "Content-Type": "text/plain"
-      });
-      res.end(`Redirecting to ${redirectUrl}`);
-    },
-    rewrite(rewriteUrl) {
-      ctx._rewriteUrl = rewriteUrl;
-      const newUrl = new URL(rewriteUrl, ctx.url);
-      ctx.url = newUrl;
-      ctx.pathname = newUrl.pathname;
-      ctx.searchParams = newUrl.searchParams;
-      ctx.route = newUrl.pathname;
-      req.url = rewriteUrl;
-    },
-    json(jsonData, status = 200) {
-      if (handled) {
-        console.warn("Response already sent, cannot send JSON");
-        return;
-      }
-      ctx._handled = true;
-      handled = true;
-      applyResponseHeaders();
-      res.writeHead(status, {
-        "Content-Type": "application/json"
-      });
-      res.end(JSON.stringify(jsonData));
-    },
-    text(content, status = 200) {
-      if (handled) {
-        console.warn("Response already sent, cannot send text");
-        return;
-      }
-      ctx._handled = true;
-      handled = true;
-      applyResponseHeaders();
-      res.writeHead(status, {
-        "Content-Type": "text/plain"
-      });
-      res.end(content);
-    },
-    html(content, status = 200) {
-      if (handled) {
-        console.warn("Response already sent, cannot send HTML");
-        return;
-      }
-      ctx._handled = true;
-      handled = true;
-      applyResponseHeaders();
-      res.writeHead(status, {
-        "Content-Type": "text/html"
-      });
-      res.end(content);
-    }
-  };
-  return ctx;
-}
-__name(createContext, "createContext");
+var _chunkFJSWYIR7cjs = require('./chunk-FJSWYIR7.cjs');
 
-// src/middleware/manager.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
 
-// src/utils/file-module.ts
-var import_node_url = require("url");
-function toFileModuleUrl(filePath) {
-  return (0, import_node_url.pathToFileURL)(filePath).href;
-}
-__name(toFileModuleUrl, "toFileModuleUrl");
 
-// 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, { origin: ctx.url.origin });
-}
-__name(toWebRequest, "toWebRequest");
-function createRequestMiddlewareContext(ctx) {
-  const context2 = {
-    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 context2;
-}
-__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/utils/decode.ts
-function decodeRouteSegment(segment) {
-  try {
-    return decodeURIComponent(segment);
-  } catch {
-    return segment;
-  }
-}
-__name(decodeRouteSegment, "decodeRouteSegment");
-function canonicalizeRequestPathSegments(pathname) {
-  const segments = pathname.split("/").filter(Boolean);
-  if (!pathname.includes("%")) return segments;
-  return segments.map(decodeRouteSegment);
-}
-__name(canonicalizeRequestPathSegments, "canonicalizeRequestPathSegments");
-function canonicalizeRequestPathname(pathname) {
-  const encoded = pathname.includes("%");
-  if (!encoded && !pathname.includes("//")) return pathname;
-  const collapsed = pathname.replace(/\/{2,}/g, "/");
-  if (!encoded) return collapsed;
-  return collapsed.split("/").map((segment) => {
-    const decoded = decodeRouteSegment(segment);
-    return decoded === segment ? segment : decoded.replace(/\//g, "%2F");
-  }).join("/");
-}
-__name(canonicalizeRequestPathname, "canonicalizeRequestPathname");
+var _chunkBYODCJD6cjs = require('./chunk-BYODCJD6.cjs');
 
-// src/utils.ts
-var logger = {
-  info: /* @__PURE__ */ __name((message) => console.log(`[info] ${message}`), "info"),
-  success: /* @__PURE__ */ __name((message) => console.log(`[success] ${message}`), "success"),
-  warn: /* @__PURE__ */ __name((message) => console.warn(`\u26A0\uFE0F  ${message}`), "warn"),
-  error: /* @__PURE__ */ __name((message) => console.error(`\u274C ${message}`), "error"),
-  ready: /* @__PURE__ */ __name((message) => console.log(`${message}`), "ready"),
-  event: /* @__PURE__ */ __name((message) => console.log(`  ${message}`), "event")
-};
 
-// src/server/response.ts
-function watchResponseEvent(res, events) {
-  if (typeof res.once !== "function" || typeof res.removeListener !== "function") {
-    return null;
-  }
-  let settled = false;
-  const listeners = events.map(([event, value]) => {
-    const listener = /* @__PURE__ */ __name(() => {
-      if (settled) return;
-      settled = true;
-      dispose();
-      resolvePromise(value);
-    }, "listener");
-    return { event, listener };
-  });
-  let resolvePromise;
-  const promise = new Promise((resolve) => {
-    resolvePromise = resolve;
-    for (const { event, listener } of listeners) {
-      res.once(event, listener);
-    }
-  });
-  const dispose = /* @__PURE__ */ __name(() => {
-    for (const { event, listener } of listeners) {
-      res.removeListener(event, listener);
-    }
-  }, "dispose");
-  return { promise, dispose };
-}
-__name(watchResponseEvent, "watchResponseEvent");
-async function waitForWritable(res) {
-  if (res.writableEnded || res.destroyed) {
-    return false;
-  }
-  const watcher = watchResponseEvent(res, [
-    ["drain", true],
-    ["close", false],
-    ["error", false]
-  ]);
-  if (!watcher) {
-    return false;
-  }
-  try {
-    return await watcher.promise;
-  } finally {
-    watcher.dispose();
-  }
-}
-__name(waitForWritable, "waitForWritable");
-function splitSetCookieHeader(value) {
-  const cookies = [];
-  let start = 0;
-  for (let index = 0; index < value.length; index += 1) {
-    if (value[index] !== ",") continue;
-    let next = index + 1;
-    while (value[next] === " " || value[next] === "	") next += 1;
-    const equals = value.indexOf("=", next);
-    if (equals === -1) continue;
-    const separator = value.slice(next, equals);
-    if (separator.length === 0 || /[;,\s]/.test(separator)) continue;
-    cookies.push(value.slice(start, index).trim());
-    start = next;
-    index = next - 1;
-  }
-  cookies.push(value.slice(start).trim());
-  return cookies.filter(Boolean);
-}
-__name(splitSetCookieHeader, "splitSetCookieHeader");
-function applyWebResponseHeaders(res, headers, options = {}) {
-  const responseHeaders = headers;
-  const rawSetCookies = responseHeaders.raw?.()["set-cookie"];
-  const setCookies = responseHeaders.getSetCookie?.() || rawSetCookies || [];
-  const existing = options.appendSetCookie && typeof res.getHeader === "function" ? res.getHeader("Set-Cookie") : void 0;
-  const existingCookies = Array.isArray(existing) ? existing.map(String) : existing === void 0 ? [] : [String(existing)];
-  let fallbackSetCookie = "";
-  headers.forEach((value, key) => {
-    if (key.toLowerCase() === "set-cookie") {
-      fallbackSetCookie = value;
-      return;
-    }
-    res.setHeader(key, value);
-  });
-  const cookies = setCookies.length > 0 ? setCookies : fallbackSetCookie ? splitSetCookieHeader(fallbackSetCookie) : [];
-  if (cookies.length > 0) {
-    res.setHeader("Set-Cookie", [...existingCookies, ...cookies]);
-  }
-}
-__name(applyWebResponseHeaders, "applyWebResponseHeaders");
-async function sendWebResponse(res, response) {
-  res.statusCode = response.status;
-  applyWebResponseHeaders(res, response.headers, { appendSetCookie: true });
-  if (!response.body) {
-    res.end();
-    return;
-  }
-  if (typeof res.write !== "function") {
-    const body = await response.arrayBuffer();
-    res.end(Buffer.from(body));
-    return;
-  }
-  const reader = response.body.getReader();
-  const disconnectWatcher = watchResponseEvent(res, [
-    ["close", true],
-    ["error", true]
-  ]);
-  try {
-    while (true) {
-      if (res.destroyed) {
-        void reader.cancel().catch(() => {
-        });
-        return;
-      }
-      const read = reader.read().then((result) => ({ type: "read", result }));
-      const next = disconnectWatcher ? await Promise.race([
-        read,
-        disconnectWatcher.promise.then(() => ({ type: "disconnect" }))
-      ]) : await read;
-      if (next.type === "disconnect") {
-        void reader.cancel().catch(() => {
-        });
-        return;
-      }
-      const { done, value } = next.result;
-      if (done) {
-        break;
-      }
-      if (!value || value.byteLength === 0) {
-        continue;
-      }
-      if (!res.write(value)) {
-        if (!await waitForWritable(res)) {
-          void reader.cancel().catch(() => {
-          });
-          return;
-        }
-      }
-    }
-    res.end();
-  } catch (error) {
-    void reader.cancel(error).catch(() => {
-    });
-    if (!res.writableEnded) {
-      const responseError = error instanceof Error ? error : new Error(String(error));
-      if (typeof res.destroy === "function") {
-        res.destroy(responseError);
-      } else {
-        res.end();
-      }
-    }
-    throw error;
-  } finally {
-    disconnectWatcher?.dispose();
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
-}
-__name(sendWebResponse, "sendWebResponse");
 
-// src/tracing.ts
-var import_api = require("@opentelemetry/api");
-var FARM_TRACER_NAME = "@farm.js/core";
-var ALL_SPAN_KINDS = [
-  "request",
-  "render",
-  "middleware",
-  "api",
-  "integration",
-  "storage",
-  "ppr",
-  "build",
-  "plugin"
-];
-var DEFAULT_IGNORED_PATHS = [
-  "/@vite/",
-  "/@fs/",
-  "/@id/",
-  "/@react-refresh",
-  "/node_modules/",
-  "/__vite",
-  "/.well-known/appspecific/"
-];
-var FARM_REQUEST_METHOD_CONTEXT_KEY = (0, import_api.createContextKey)("@farm.js/core/request-method");
-var TRACING_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/tracing-runtime/v1");
-var runtime = globalThis;
-var tracingState = runtime[TRACING_RUNTIME] ?? (runtime[TRACING_RUNTIME] = normalizeFarmTracingConfig(false));
-function normalizeFarmTracingConfig(config) {
-  if (!config) {
-    return {
-      enabled: false,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  if (config === true) {
-    return {
-      enabled: true,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  return {
-    enabled: config.enabled ?? true,
-    spans: new Set(config.spans ?? ALL_SPAN_KINDS),
-    recordEvents: config.recordEvents ?? true,
-    attributes: { ...config.attributes },
-    ignorePaths: [...DEFAULT_IGNORED_PATHS, ...config.ignorePaths ?? []]
-  };
-}
-__name(normalizeFarmTracingConfig, "normalizeFarmTracingConfig");
-function recordFarmEventTrace(event) {
-  if (!tracingState.enabled) return void 0;
-  const activeContext = import_api.context.active();
-  const activeSpan = import_api.trace.getSpan(activeContext);
-  const traceContext = getSpanTraceContext(activeSpan);
-  if (activeSpan && traceContext) {
-    if (event.type === "route.matched") {
-      const method = activeContext.getValue(FARM_REQUEST_METHOD_CONTEXT_KEY) ?? "HTTP";
-      activeSpan.updateName(`${method} ${event.route}`);
-      activeSpan.setAttribute("http.route", event.route);
-      activeSpan.setAttribute("farm.route", event.route);
-    }
-    if (tracingState.recordEvents) {
-      activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
-    }
-    const error = event.type === "request.error" ? void 0 : getEventError(event);
-    if (error !== void 0) {
-      if (event.type === "render.error") {
-        recordSpanException(activeSpan, error);
-      } else {
-        recordSpanError(activeSpan, error);
-      }
-    }
-  }
-  const completedTraceContext = recordCompletedEventSpan(event, activeContext);
-  return traceContext ?? completedTraceContext;
-}
-__name(recordFarmEventTrace, "recordFarmEventTrace");
-function recordCompletedEventSpan(event, parentContext) {
-  const descriptor = getCompletedSpanDescriptor(event);
-  if (!descriptor || !tracingState.spans.has(descriptor.kind)) return void 0;
-  const tracer = import_api.trace.getTracer(FARM_TRACER_NAME);
-  const span = tracer.startSpan(
-    descriptor.name,
-    {
-      kind: import_api.SpanKind.INTERNAL,
-      startTime: event.timestamp - descriptor.durationMs,
-      attributes: {
-        ...tracingState.attributes,
-        ...toEventAttributes(event),
-        "farm.event.type": event.type
-      }
-    },
-    parentContext
-  );
-  const status = "status" in event && typeof event.status === "number" ? event.status : void 0;
-  if (status !== void 0) setResponseStatus(span, status);
-  const error = getEventError(event);
-  if (error !== void 0) recordSpanError(span, error);
-  const traceContext = getSpanTraceContext(span);
-  span.end(event.timestamp);
-  return traceContext;
-}
-__name(recordCompletedEventSpan, "recordCompletedEventSpan");
-function getCompletedSpanDescriptor(event) {
-  if (!("durationMs" in event) || typeof event.durationMs !== "number") return void 0;
-  switch (event.type) {
-    case "render.complete":
-      return { kind: "render", name: `farm.render ${event.route}`, durationMs: event.durationMs };
-    case "render.stream.shellReady":
-      return {
-        kind: "render",
-        name: `farm.render.shell ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "render.stream.complete":
-      return {
-        kind: "render",
-        name: `farm.render.stream ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "middleware.complete":
-      return {
-        kind: "middleware",
-        name: `farm.middleware ${event.name ?? event.route ?? "anonymous"}`,
-        durationMs: event.durationMs
-      };
-    case "api.request.complete":
-    case "api.error":
-      return {
-        kind: "api",
-        name: `farm.api ${event.method} ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "integration.api.call.complete":
-      return {
-        kind: "integration",
-        name: `farm.integration ${event.integration}.${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "storage.query.complete":
-      return {
-        kind: "storage",
-        name: `farm.storage ${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "ppr.refresh.complete":
-      return {
-        kind: "ppr",
-        name: `farm.ppr.refresh ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "build.complete":
-      return {
-        kind: "build",
-        name: `farm.build${event.target ? ` ${event.target}` : ""}`,
-        durationMs: event.durationMs
-      };
-    case "plugin.hook.complete":
-      return {
-        kind: "plugin",
-        name: `farm.plugin ${event.plugin}.${event.hook}`,
-        durationMs: event.durationMs
-      };
-    default:
-      return void 0;
-  }
-}
-__name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
-function hashFarmCacheKey(value) {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index++) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-__name(hashFarmCacheKey, "hashFarmCacheKey");
-function toEventAttributes(event) {
-  const attributes = {};
-  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
-  for (const [key, value] of Object.entries(event)) {
-    if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
-      continue;
-    }
-    if (redactKey && key === "key" && typeof value === "string") {
-      attributes["farm.key_hash"] = hashFarmCacheKey(value);
-      continue;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      attributes[`farm.${key}`] = value;
-    } else if (Array.isArray(value)) {
-      if (value.every((entry) => typeof entry === "string")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "number")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "boolean")) {
-        attributes[`farm.${key}`] = value;
-      }
-    }
-  }
-  return attributes;
-}
-__name(toEventAttributes, "toEventAttributes");
-function getEventError(event) {
-  return "error" in event ? event.error : void 0;
-}
-__name(getEventError, "getEventError");
-function recordSpanException(span, error) {
-  const normalized = error instanceof Error ? error : new Error(String(error));
-  span.recordException(normalized);
-  return normalized;
-}
-__name(recordSpanException, "recordSpanException");
-function recordSpanError(span, error) {
-  const normalized = recordSpanException(span, error);
-  span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: normalized.message });
-}
-__name(recordSpanError, "recordSpanError");
-function setResponseStatus(span, status) {
-  span.setAttribute("http.response.status_code", status);
-  if (status >= 500) {
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR });
-  }
-}
-__name(setResponseStatus, "setResponseStatus");
-function getSpanTraceContext(span) {
-  if (!span) return void 0;
-  const spanContext = span.spanContext();
-  if (!(0, import_api.isSpanContextValid)(spanContext)) return void 0;
-  return {
-    traceId: spanContext.traceId,
-    spanId: spanContext.spanId,
-    traceSampled: (spanContext.traceFlags & 1) === 1
-  };
-}
-__name(getSpanTraceContext, "getSpanTraceContext");
+var _chunkY53ZSFN6cjs = require('./chunk-Y53ZSFN6.cjs');
 
-// src/observability.ts
-var OBSERVABILITY_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/observability-runtime/v1");
-var runtime2 = globalThis;
-var shared = runtime2[OBSERVABILITY_RUNTIME] ?? (runtime2[OBSERVABILITY_RUNTIME] = {
-  handlers: /* @__PURE__ */ new Set(),
-  unfilteredHandlers: /* @__PURE__ */ new Set(),
-  config: { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) }
-});
-var runtimeHandlers = shared.handlers;
-var unfilteredRuntimeHandlers = shared.unfilteredHandlers;
-var observabilityState = shared.config;
-function emitFarmEvent(input) {
-  const event = {
-    timestamp: Date.now(),
-    level: inferFarmEventLevel(input.type),
-    ...input
-  };
-  const traceContext = recordFarmEventTrace(event);
-  if (traceContext) {
-    event.traceId = traceContext.traceId;
-    event.spanId = traceContext.spanId;
-    event.traceSampled = traceContext.traceSampled;
-  }
-  notifyFarmEventHandlers(event, unfilteredRuntimeHandlers);
-  if (!shouldEmitFarmEvent(event)) return event;
-  if (observabilityState.logs) {
-    logFarmEvent(event);
-  }
-  notifyFarmEventHandlers(event, [...observabilityState.handlers, ...runtimeHandlers]);
-  return event;
-}
-__name(emitFarmEvent, "emitFarmEvent");
-function notifyFarmEventHandlers(event, handlers) {
-  for (const handler of handlers) {
-    try {
-      Promise.resolve(handler(event)).catch((error) => {
-        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-      });
-    } catch (error) {
-      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-    }
-  }
-}
-__name(notifyFarmEventHandlers, "notifyFarmEventHandlers");
-function shouldEmitFarmEvent(event) {
-  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
-    return false;
-  }
-  if (observabilityState.events && !observabilityState.events.has(event.type)) {
-    return false;
-  }
-  return true;
-}
-__name(shouldEmitFarmEvent, "shouldEmitFarmEvent");
-function inferFarmEventLevel(type) {
-  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
-    return "error";
-  }
-  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
-    return "warn";
-  }
-  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
-    return "debug";
-  }
-  return "info";
-}
-__name(inferFarmEventLevel, "inferFarmEventLevel");
-function logFarmEvent(event) {
-  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
-  switch (event.level) {
-    case "error":
-      console.error(message);
-      break;
-    case "warn":
-      console.warn(message);
-      break;
-    default:
-      console.log(message);
-      break;
-  }
-}
-__name(logFarmEvent, "logFarmEvent");
-function formatFarmEventDetails(event) {
-  const details = [];
-  const record = event;
-  for (const key of [
-    "route",
-    "pathname",
-    "method",
-    "status",
-    "key",
-    "tag",
-    "path",
-    "reason",
-    "durationMs",
-    "integration",
-    "server",
-    "tool",
-    "outcome",
-    "operation",
-    "plugin",
-    "hook",
-    "target",
-    "count"
-  ]) {
-    const value = record[key];
-    if (value !== void 0) {
-      details.push(`${key}=${formatDetailValue(value)}`);
-    }
-  }
-  return details.length > 0 ? ` ${details.join(" ")}` : "";
-}
-__name(formatFarmEventDetails, "formatFarmEventDetails");
-function formatDetailValue(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-__name(formatDetailValue, "formatDetailValue");
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-__name(formatError, "formatError");
 
-// src/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 (isFarmRedirectStatus(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 isFarmRedirectStatus(status) {
-  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
-}
-__name(isFarmRedirectStatus, "isFarmRedirectStatus");
 
-// src/base-path.ts
-var FARM_BASE_PATH = /* @__PURE__ */ Symbol.for("farm.basePath");
-function getFarmGlobalState() {
-  return globalThis;
-}
-__name(getFarmGlobalState, "getFarmGlobalState");
-function getFarmBasePath() {
-  return getFarmGlobalState()[FARM_BASE_PATH] ?? "";
-}
-__name(getFarmBasePath, "getFarmBasePath");
-function stripFarmBasePath(pathname, basePath = getFarmBasePath()) {
-  const normalizedBasePath = normalizeFarmBasePath(basePath);
-  if (!normalizedBasePath) return pathname || "/";
-  if (pathname === normalizedBasePath) return "/";
-  if (!pathname.startsWith(`${normalizedBasePath}/`)) return pathname || "/";
-  return pathname.slice(normalizedBasePath.length) || "/";
-}
-__name(stripFarmBasePath, "stripFarmBasePath");
-function normalizeFarmBasePath(basePath) {
-  if (!basePath || basePath === "/") return "";
-  const hasUnstableCharacters = /* @__PURE__ */ __name((candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  }), "hasUnstableCharacters");
-  if (hasUnstableCharacters(basePath)) {
-    throw new Error("Farm basePath cannot contain backslashes or control characters.");
-  }
-  const pathname = basePath.trim();
-  if (!pathname || pathname === "/") return "";
-  if (pathname.includes("?") || pathname.includes("#")) {
-    throw new Error("Farm basePath cannot contain a query string or hash.");
-  }
-  if (pathname.startsWith("//") || /^[a-z][a-z\d+.-]*:\/\//i.test(pathname)) {
-    throw new Error('Farm basePath must be a pathname such as "/docs", not a URL.');
-  }
-  for (const segment of pathname.split("/")) {
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (hasUnstableCharacters(decoded)) {
-      throw new Error("Farm basePath cannot contain backslashes or control characters.");
-    }
-    if (decoded.includes("/")) {
-      throw new Error("Farm basePath cannot contain percent-encoded path separators.");
-    }
-    if (decoded === "." || decoded === "..") {
-      throw new Error('Farm basePath cannot contain "." or ".." path segments.');
-    }
-  }
-  return `/${pathname}`.replace(/\/{2,}/g, "/").replace(/\/+$/, "");
-}
-__name(normalizeFarmBasePath, "normalizeFarmBasePath");
 
-// src/i18n/routing.ts
-function resolveFarmLocalePath(pathname, config) {
-  const normalized = normalizePathname(stripFarmBasePath(pathname, config.basePath));
-  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 normalizePathname(pathname) {
-  const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
-  if (withLeadingSlash === "/") return "/";
-  return withLeadingSlash.replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
-}
-__name(normalizePathname, "normalizePathname");
 
-// src/cli-colors.ts
-var import_picocolors = __toESM(require("picocolors"));
-function createCliColors(interactive = process.stdout.isTTY === true) {
-  return import_picocolors.default.createColors(interactive);
-}
-__name(createCliColors, "createCliColors");
 
-// src/middleware/path.ts
-function appendMiddlewareRoutePath(routePath, directoryName) {
-  if (directoryName.startsWith("(") && directoryName.endsWith(")")) {
-    return routePath;
-  }
-  return routePath === "/" ? `/${directoryName}` : `${routePath}/${directoryName}`;
-}
-__name(appendMiddlewareRoutePath, "appendMiddlewareRoutePath");
+var _chunkXGC343EYcjs = require('./chunk-XGC343EY.cjs');
+require('./chunk-RG3ZOTG5.cjs');
+require('./chunk-M2L4MYDQ.cjs');
+require('./chunk-VQDBNVOO.cjs');
+require('./chunk-HBTUGXHS.cjs');
+require('./chunk-5QIKR7RR.cjs');
+require('./chunk-QNPEUFHQ.cjs');
+require('./chunk-UQZ4AYTH.cjs');
+require('./chunk-E3UK5IIB.cjs');
+require('./chunk-OX6O6WVA.cjs');
+require('./chunk-5ZSWG4UX.cjs');
 
-// src/middleware/matcher.ts
-var compiledConfigCache = /* @__PURE__ */ new WeakMap();
-var compiledRouteCache = /* @__PURE__ */ new WeakMap();
-function compileMiddlewareRoute(entry) {
-  const path4 = entry.path;
-  if (path4 === "/") return void 0;
-  const cached = compiledRouteCache.get(entry);
-  if (cached?.path === path4) return cached;
-  const compiled = {
-    path: path4,
-    exact: compilePattern(path4),
-    nested: compilePattern(`${path4}/:__farmRest*`)
-  };
-  compiledRouteCache.set(entry, compiled);
-  return compiled;
-}
-__name(compileMiddlewareRoute, "compileMiddlewareRoute");
-function matchesMiddlewareRoute(pathname, entry) {
-  const compiled = compileMiddlewareRoute(entry);
-  if (!compiled) return { matched: true };
-  const canonicalPathname = canonicalizeRequestPathname(pathname);
-  const exactMatch = matchPattern2(compiled.exact, canonicalPathname);
-  if (exactMatch.matched) return exactMatch;
-  const nestedMatch = matchPattern2(compiled.nested, canonicalPathname);
-  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(matchesMiddlewareRoute, "matchesMiddlewareRoute");
-function sameEntries(current, previous) {
-  return current === void 0 || previous === void 0 ? current === previous : current.length === previous.length && current.every((entry, index) => entry === previous[index]);
-}
-__name(sameEntries, "sameEntries");
-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 { kind: "path", 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 {
-    kind: "path",
-    regex: new RegExp(`^${parts.join("")}$`),
-    params
-  };
-}
-__name(compilePathPattern, "compilePathPattern");
-function compilePattern(pattern) {
-  if (pattern instanceof RegExp) {
-    return { kind: "regexp", regex: pattern };
-  }
-  if (pattern === "*" || pattern === "/(.*)") {
-    return { kind: "all" };
-  }
-  if (pattern.endsWith("(.*)")) {
-    return {
-      kind: "subtree",
-      prefix: pattern.slice(0, -4).replace(/\/$/, "")
-    };
-  }
-  return compilePathPattern(pattern);
-}
-__name(compilePattern, "compilePattern");
-function compileMiddlewareConfig(config) {
-  const compiled = {
-    matcher: config.matcher ? toMatcherList(config.matcher).map(
-      (matcher) => typeof matcher === "function" ? matcher : compilePattern(matcher)
-    ) : void 0,
-    exclude: config.exclude?.map(compilePattern)
-  };
-  compiledConfigCache.set(config, {
-    compiled,
-    matcher: config.matcher,
-    matcherEntries: Array.isArray(config.matcher) ? config.matcher.slice() : void 0,
-    excludeEntries: config.exclude?.slice()
-  });
-  return compiled;
-}
-__name(compileMiddlewareConfig, "compileMiddlewareConfig");
-function matchPattern2(pattern, pathname) {
-  if (pattern.kind === "all") {
-    return { matched: true };
-  }
-  if (pattern.kind === "subtree") {
-    return {
-      matched: pathname === pattern.prefix || pathname.startsWith(`${pattern.prefix}/`)
-    };
-  }
-  pattern.regex.lastIndex = 0;
-  const match = pattern.regex.exec(pathname);
-  if (!match) {
-    return { matched: false };
-  }
-  if (pattern.kind === "regexp") {
-    return {
-      matched: true,
-      params: match.groups ? { ...match.groups } : void 0
-    };
-  }
-  const values = {};
-  pattern.params.forEach((param, index) => {
-    values[param] = match[index + 1] || "";
-  });
-  return {
-    matched: true,
-    params: Object.keys(values).length > 0 ? values : void 0
-  };
-}
-__name(matchPattern2, "matchPattern");
-function matchesCompiledMiddlewareConfig(pathname, config, ctx) {
-  let canonicalPathname;
-  const getCanonicalPathname = /* @__PURE__ */ __name(() => canonicalPathname ?? (canonicalPathname = canonicalizeRequestPathname(pathname)), "getCanonicalPathname");
-  if (config.exclude) {
-    for (const pattern of config.exclude) {
-      if (matchPattern2(pattern, getCanonicalPathname()).matched) {
-        return { matched: false };
-      }
-    }
-  }
-  if (config.matcher) {
-    for (const matcher of config.matcher) {
-      if (typeof matcher === "function") {
-        if (matcher(ctx)) {
-          return { matched: true };
-        }
-        continue;
-      }
-      const result = matchPattern2(matcher, getCanonicalPathname());
-      if (result.matched) {
-        return result;
-      }
-    }
-    return { matched: false };
-  }
-  return { matched: true };
-}
-__name(matchesCompiledMiddlewareConfig, "matchesCompiledMiddlewareConfig");
-function matchesMiddlewareConfig(pathname, config, ctx) {
-  const cached = compiledConfigCache.get(config);
-  const unchanged = cached && (Array.isArray(config.matcher) ? sameEntries(config.matcher, cached.matcherEntries) : config.matcher === cached.matcher) && sameEntries(config.exclude, cached.excludeEntries);
-  const compiled = unchanged ? cached.compiled : compileMiddlewareConfig(config);
-  return matchesCompiledMiddlewareConfig(pathname, compiled, ctx);
-}
-__name(matchesMiddlewareConfig, "matchesMiddlewareConfig");
 
-// src/middleware/manager.ts
-function isMiddlewareResponse(value) {
-  return value instanceof Response;
-}
-__name(isMiddlewareResponse, "isMiddlewareResponse");
-var _MiddlewareManager = class _MiddlewareManager {
-  constructor(appDir, viteServer, config, i18n, server) {
-    this.middleware = [];
-    this.configMiddleware = [];
-    this.appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
-    this.viteServer = viteServer;
-    this.i18n = i18n;
-    this.server = server;
-    this.configure(config);
-  }
-  configure(config) {
-    this.configMiddleware = [];
-    this.globalConfig = void 0;
-    if (!config) return;
-    const entries = Array.isArray(config) ? config : [config];
-    for (const [index, entry] of entries.entries()) {
-      const handlers = this.getConfigHandlers(entry);
-      const middlewareConfig = this.toMiddlewareConfig(entry);
-      compileMiddlewareConfig(middlewareConfig);
-      if (handlers.length === 0) {
-        this.globalConfig = middlewareConfig;
-        continue;
-      }
-      this.configMiddleware.push({
-        path: "/",
-        filePath: `farm.config.ts#middleware-${index}`,
-        handlers,
-        config: middlewareConfig,
-        source: "config"
-      });
-    }
-  }
-  /**
-   * Discover all middleware.ts files
-   */
-  async discover() {
-    const middlewareByPath = /* @__PURE__ */ new Map();
-    for (const appDir of this.appDirs) {
-      const discovered = [];
-      await this.discoverInDirectory(appDir, "/", discovered);
-      for (const middleware2 of discovered) {
-        compileMiddlewareRoute(middleware2);
-        middlewareByPath.set(middleware2.path, middleware2);
-      }
-    }
-    this.middleware = Array.from(middlewareByPath.values());
-    this.middleware.sort((a, b) => {
-      const depthA = a.path.split("/").filter(Boolean).length;
-      const depthB = b.path.split("/").filter(Boolean).length;
-      return depthA - depthB;
-    });
-    if (process.env.FARM_VERBOSE && this.middleware.length > 0) {
-      logger.success(`Discovered ${this.middleware.length} middleware files`);
-      for (const mw of this.middleware) {
-        logger.info(`  ${mw.path} (${mw.handlers.length} handlers)`);
-      }
-    }
-  }
-  /**
-   * Recursively discover middleware files
-   */
-  async discoverInDirectory(dir, routePath, discovered) {
-    if (!fs.existsSync(dir)) {
-      return;
-    }
-    const middlewareFile = this.findMiddlewareFile(dir);
-    if (middlewareFile) {
-      const middleware2 = await this.loadMiddleware(middlewareFile, routePath);
-      if (middleware2) {
-        discovered.push(middleware2);
-      }
-    }
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
-        const subPath = path.join(dir, entry.name);
-        const subRoutePath = appendMiddlewareRoutePath(routePath, entry.name);
-        await this.discoverInDirectory(subPath, subRoutePath, discovered);
-      }
-    }
-  }
-  /**
-   * Find middleware file in directory
-   */
-  findMiddlewareFile(dir) {
-    const extensions = [".ts", ".tsx", ".js", ".jsx"];
-    for (const ext of extensions) {
-      const filePath = path.join(dir, `middleware${ext}`);
-      if (fs.existsSync(filePath)) {
-        return filePath;
-      }
-    }
-    return null;
-  }
-  /**
-   * Load a middleware file
-   */
-  async loadMiddleware(filePath, routePath) {
-    try {
-      let module2;
-      if (this.viteServer) {
-        module2 = await this.viteServer.ssrLoadModule(filePath);
-      } else {
-        module2 = await import(
-          /* @vite-ignore */
-          toFileModuleUrl(filePath)
-        );
-      }
-      const normalized = normalizeMiddlewareModule(module2, routePath);
-      if (!normalized) {
-        throw new Error("must export a default handler or a named middleware handler");
-      }
-      if (normalized.config) {
-        compileMiddlewareConfig(normalized.config);
-      }
-      return {
-        path: routePath,
-        filePath,
-        handlers: normalized.handlers,
-        config: normalized.config,
-        source: "file"
-      };
-    } catch (error) {
-      throw new Error(`Failed to load middleware ${filePath}: ${error}`);
-    }
-  }
-  /**
-   * Execute middleware for a request
-   */
-  async execute(req, res) {
-    const url = resolveFarmRequestURL(req, { trustProxy: this.server?.trustProxy });
-    const pathname = url.pathname;
-    const routePathname = this.i18n?.enabled ? stripFarmLocaleFromPathname(pathname, this.i18n) : stripFarmBasePath(pathname, this.i18n?.basePath ?? "/");
-    const method = req.method || "GET";
-    const startTime = Date.now();
-    let parentData;
-    let ctx = createContext(req, res, this.viteServer, void 0, this.server);
-    if (this.globalConfig) {
-      const globalMatch = this.matchesConfig(routePathname, this.globalConfig, ctx);
-      if (!globalMatch.matched) {
-        return false;
-      }
-      if (globalMatch.params) {
-        ctx.params = { ...ctx.params, ...globalMatch.params };
-      }
-    }
-    const applicable = [
-      ...this.configMiddleware.map((mw) => ({ mw, routeMatch: { matched: true } })),
-      ...this.middleware.map((mw) => ({ mw, routeMatch: matchesMiddlewareRoute(routePathname, mw) })).filter((entry) => entry.routeMatch.matched)
-    ];
-    if (applicable.length === 0) {
-      return false;
-    }
-    const pc = createCliColors();
-    const log = [
-      pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
-      pc.dim("[") + pc.bold(pc.magenta("MIDDLEWARE")) + pc.dim("]"),
-      pc.dim("[") + pc.bold(pc.white(method.padEnd(3))) + pc.dim("]"),
-      pc.gray("Executing middleware: "),
-      pc.gray(pathname),
-      pc.dim(` (${(Date.now() - startTime).toFixed(2)}ms)`)
-    ].join(" ");
-    console.log(log);
-    for (const entry of applicable) {
-      const { mw, routeMatch } = entry;
-      const configMatch = mw.config ? this.matchesConfig(routePathname, mw.config, ctx) : { matched: true };
-      if (!configMatch.matched) {
-        continue;
-      }
-      if (routeMatch.params) {
-        ctx.params = { ...ctx.params, ...routeMatch.params };
-      }
-      if (configMatch.params) {
-        ctx.params = { ...ctx.params, ...configMatch.params };
-      }
-      if (parentData) {
-        ctx = createContext(req, res, this.viteServer, parentData, this.server);
-        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: mw.path,
-        pathname,
-        name: mw.filePath
-      };
-      emitFarmEvent({ type: "middleware.start", ...middlewareEvent });
-      try {
-        let handlerIndex = 0;
-        let returnedResponse;
-        const executeNext = /* @__PURE__ */ __name(async () => {
-          if (handlerIndex < mw.handlers.length) {
-            const handler = mw.handlers[handlerIndex++];
-            const result2 = await handler(ctx, executeNext);
-            if (isMiddlewareResponse(result2)) {
-              returnedResponse = result2;
-              return result2;
-            }
-          }
-          return returnedResponse;
-        }, "executeNext");
-        const result = await executeNext();
-        const response = isMiddlewareResponse(result) ? result : returnedResponse;
-        if (response) {
-          if (!res.headersSent && !res.writableEnded) {
-            for (const [key, value] of ctx.headers) {
-              try {
-                res.setHeader(key, value);
-              } catch (error) {
-              }
-            }
-          }
-          emitFarmEvent({
-            type: "middleware.shortCircuit",
-            ...middlewareEvent,
-            status: response.status
-          });
-          await sendWebResponse(res, response);
-          return true;
-        }
-        if (ctx._handled || res.headersSent || res.writableEnded) {
-          emitFarmEvent({
-            type: "middleware.shortCircuit",
-            ...middlewareEvent,
-            status: res.statusCode
-          });
-          return true;
-        }
-        emitFarmEvent({
-          type: "middleware.complete",
-          ...middlewareEvent,
-          durationMs: Date.now() - middlewareStartTime
-        });
-      } catch (error) {
-        emitFarmEvent(
-          isFarmRedirectError(error) || isFarmNotFoundError(error) ? {
-            type: "middleware.shortCircuit",
-            ...middlewareEvent,
-            status: isFarmRedirectError(error) ? getFarmRedirectError(error).status : 404
-          } : { type: "middleware.error", ...middlewareEvent, error }
-        );
-        throw error;
-      }
-      parentData = {
-        data: new Map(ctx.data),
-        locals: new Map(ctx.locals),
-        headers: Object.fromEntries(ctx.headers)
-      };
-    }
-    if (!res.headersSent && !res.writableEnded) {
-      for (const [key, value] of ctx.headers) {
-        try {
-          res.setHeader(key, value);
-        } catch (error) {
-        }
-      }
-    }
-    req.__FARM_MIDDLEWARE_DATA__ = new Map(ctx.data);
-    req.__FARM_MIDDLEWARE_CONTEXT__ = new Map(ctx.locals);
-    return false;
-  }
-  /**
-   * Check if pathname matches middleware config
-   */
-  matchesConfig(pathname, config, ctx) {
-    return matchesMiddlewareConfig(pathname, config, ctx);
-  }
-  /**
-   * Reload middleware (for HMR)
-   */
-  async reload() {
-    await this.discover();
-  }
-  getMiddlewares() {
-    return [...this.configMiddleware, ...this.middleware];
-  }
-  hasMiddleware() {
-    return this.configMiddleware.length > 0 || this.middleware.length > 0;
-  }
-  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;
-  }
-  toMiddlewareConfig(entry) {
-    const { matcher, exclude, runtime: runtime3 } = entry;
-    return { matcher, exclude, runtime: runtime3 };
-  }
-};
-__name(_MiddlewareManager, "MiddlewareManager");
-var MiddlewareManager = _MiddlewareManager;
+var _chunkUS2QVW3Ecjs = require('./chunk-US2QVW3E.cjs');
+require('./chunk-U4KT7QP3.cjs');
+require('./chunk-BIDYX3SL.cjs');
+require('./chunk-I57LW5VZ.cjs');
+require('./chunk-NO3WWW3N.cjs');
+require('./chunk-S3JO3N4H.cjs');
 
-// 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(context2, fn) {
-  return middlewareContextStore.run(toMiddlewareMap(context2), fn);
-}
-__name(_runWithMiddlewareContext, "_runWithMiddlewareContext");
-function getMiddlewareData() {
-  return middlewareStore.getStore() || /* @__PURE__ */ new Map();
-}
-__name(getMiddlewareData, "getMiddlewareData");
-function getMiddlewareValue(key) {
-  const data = getMiddlewareData();
-  return data.get(key);
-}
-__name(getMiddlewareValue, "getMiddlewareValue");
-function getMiddlewareContext() {
-  return middlewareContextStore.getStore() || /* @__PURE__ */ new Map();
-}
-__name(getMiddlewareContext, "getMiddlewareContext");
 
-// src/middleware/helpers.ts
-function unwrapMiddleware(middleware2, defaults) {
-  if (!middleware2) {
-    return defaults || {};
-  }
-  const result = { ...defaults };
-  for (const [key, value] of middleware2.data) {
-    result[key] = value;
-  }
-  return result;
-}
-__name(unwrapMiddleware, "unwrapMiddleware");
-function getFromMiddleware(middleware2, key, defaultValue) {
-  if (!middleware2) {
-    return defaultValue;
-  }
-  const value = middleware2.data.get(key);
-  return value !== void 0 ? value : defaultValue;
-}
-__name(getFromMiddleware, "getFromMiddleware");
-function hasMiddlewareData(middleware2) {
-  if (!middleware2) return false;
-  return middleware2.data.size > 0;
-}
-__name(hasMiddlewareData, "hasMiddlewareData");
 
-// src/middleware/production-runtime.ts
-var FARM_SET_COOKIE_HEADERS = /* @__PURE__ */ Symbol("farm.setCookieHeaders");
-var _WebResponseHeaderMap = class _WebResponseHeaderMap extends Map {
-  constructor() {
-    super(...arguments);
-    this.setCookies = [];
-  }
-  set(key, value) {
-    if (key.toLowerCase() === "set-cookie") {
-      this.setCookies = [value];
-      super.set("Set-Cookie", value);
-      return this;
-    }
-    return super.set(key, value);
-  }
-  delete(key) {
-    if (key.toLowerCase() === "set-cookie") {
-      this.setCookies = [];
-      return super.delete("Set-Cookie") || super.delete("set-cookie");
-    }
-    return super.delete(key);
-  }
-  clear() {
-    this.setCookies = [];
-    super.clear();
-  }
-  appendSetCookie(value) {
-    this.setCookies.push(value);
-    super.set("Set-Cookie", value);
-  }
-  replaceSetCookies(values) {
-    this.setCookies = [...values];
-    super.delete("Set-Cookie");
-    super.delete("set-cookie");
-    if (this.setCookies.length > 0) {
-      super.set("Set-Cookie", this.setCookies[this.setCookies.length - 1]);
-    }
-  }
-  getSetCookies() {
-    return this.setCookies;
-  }
-};
-__name(_WebResponseHeaderMap, "WebResponseHeaderMap");
-var WebResponseHeaderMap = _WebResponseHeaderMap;
-var _WebCookieJar = class _WebCookieJar {
-  constructor(request, headers) {
-    this.headers = headers;
-    this.cookies = parseMiddlewareCookieHeader(request.headers.get("cookie"));
-  }
-  get(name) {
-    return this.cookies[name];
-  }
-  set(name, value, options = {}) {
-    this.cookies[name] = value;
-    const cookieString = serializeMiddlewareCookie(name, value, options);
-    this.headers.appendSetCookie(cookieString);
-  }
-  delete(name, options = {}) {
-    delete this.cookies[name];
-    this.headers.appendSetCookie(serializeMiddlewareCookieDeletion(name, options));
-  }
-  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") continue;
-    headers.set(key, value);
-  }
-  for (const cookie of map.getSetCookies()) {
-    headers.append("Set-Cookie", cookie);
-  }
-  return headers;
-}
-__name(mapToHeaders, "mapToHeaders");
-function headersToRecord(headers) {
-  return Object.fromEntries(headers);
-}
-__name(headersToRecord, "headersToRecord");
-function isMiddlewareResponse2(value) {
-  return value instanceof Response;
-}
-__name(isMiddlewareResponse2, "isMiddlewareResponse");
-function findHeaderName(headers, name) {
-  const normalizedName = name.toLowerCase();
-  return [...headers.keys()].find((key) => key.toLowerCase() === normalizedName);
-}
-__name(findHeaderName, "findHeaderName");
-function createResponseShim(headers) {
-  const bodyChunks = [];
-  const encoder = new TextEncoder();
-  const response = {
-    headersSent: false,
-    writableEnded: false,
-    statusCode: 200,
-    statusMessage: "",
-    setHeader(name, value) {
-      const existingName = findHeaderName(headers, name);
-      if (existingName) headers.delete(existingName);
-      if (name.toLowerCase() === "set-cookie") {
-        headers.replaceSetCookies(Array.isArray(value) ? value.map(String) : [String(value)]);
-      } else {
-        headers.set(name, Array.isArray(value) ? value.join(", ") : String(value));
-      }
-      return this;
-    },
-    getHeader(name) {
-      if (name.toLowerCase() === "set-cookie") {
-        const cookies = headers.getSetCookies();
-        return cookies.length > 0 ? [...cookies] : void 0;
-      }
-      const existingName = findHeaderName(headers, name);
-      return existingName ? headers.get(existingName) : void 0;
-    },
-    hasHeader(name) {
-      return name.toLowerCase() === "set-cookie" ? headers.getSetCookies().length > 0 : findHeaderName(headers, name) !== void 0;
-    },
-    getHeaderNames() {
-      return [...headers.keys()].map((name) => name.toLowerCase());
-    },
-    getHeaders() {
-      return Object.fromEntries(
-        [...headers.keys()].map((name) => [name.toLowerCase(), this.getHeader(name)])
-      );
-    },
-    removeHeader(name) {
-      const existingName = findHeaderName(headers, name);
-      if (existingName) headers.delete(existingName);
-    },
-    appendHeader(name, value) {
-      const values = Array.isArray(value) ? value.map(String) : [String(value)];
-      if (name.toLowerCase() === "set-cookie") {
-        for (const item of values) headers.appendSetCookie(item);
-        return this;
-      }
-      const existing = this.getHeader(name);
-      return this.setHeader(name, existing ? `${String(existing)}, ${values.join(", ")}` : values);
-    },
-    writeHead(status, statusMessageOrHeaders, responseHeaders) {
-      this.statusCode = status;
-      const nextHeaders = typeof statusMessageOrHeaders === "string" ? responseHeaders : statusMessageOrHeaders;
-      if (typeof statusMessageOrHeaders === "string") {
-        this.statusMessage = statusMessageOrHeaders;
-      }
-      if (nextHeaders) {
-        for (const [key, value] of Object.entries(nextHeaders)) {
-          this.setHeader(key, value);
-        }
-      }
-      this.headersSent = true;
-      return this;
-    },
-    flushHeaders() {
-      this.headersSent = true;
-    },
-    write(chunk, encodingOrCallback, callback) {
-      bodyChunks.push(typeof chunk === "string" ? encoder.encode(chunk) : new Uint8Array(chunk));
-      this.headersSent = true;
-      const done = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
-      done?.();
-      return true;
-    },
-    end(chunk, encodingOrCallback, callback) {
-      if (typeof chunk === "string" || chunk instanceof Uint8Array) {
-        bodyChunks.push(typeof chunk === "string" ? encoder.encode(chunk) : new Uint8Array(chunk));
-      }
-      this.headersSent = true;
-      this.writableEnded = true;
-      const done = typeof chunk === "function" ? chunk : typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
-      done?.();
-      return this;
-    }
-  };
-  return {
-    response,
-    getResponse(method) {
-      if (!response.headersSent && !response.writableEnded) return null;
-      const bodyLength = bodyChunks.reduce((total, chunk) => total + chunk.byteLength, 0);
-      const body = new Uint8Array(bodyLength);
-      let offset = 0;
-      for (const chunk of bodyChunks) {
-        body.set(chunk, offset);
-        offset += chunk.byteLength;
-      }
-      const bodyAllowed = method.toUpperCase() !== "HEAD" && response.statusCode !== 204 && response.statusCode !== 205 && response.statusCode !== 304;
-      return new Response(bodyAllowed && bodyLength > 0 ? body : null, {
-        status: response.statusCode,
-        statusText: response.statusMessage || void 0,
-        headers: mapToHeaders(headers)
-      });
-    }
-  };
-}
-__name(createResponseShim, "createResponseShim");
-function withNodeRequestShape(request, trustProxy, clientAddress) {
-  const requestWithShape = request;
-  if (!requestWithShape.socket) {
-    const forwardedFor = trustProxy ? request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() : void 0;
-    try {
-      requestWithShape.socket = { remoteAddress: forwardedFor || clientAddress || void 0 };
-    } catch {
-    }
-  }
-  return requestWithShape;
-}
-__name(withNodeRequestShape, "withNodeRequestShape");
-function createHandledResponse(body, init, headers) {
-  const responseHeaders = new Headers();
-  for (const [key, value] of headers) {
-    if (key.toLowerCase() === "set-cookie") continue;
-    responseHeaders.set(key, value);
-  }
-  for (const [key, value] of new Headers(init.headers)) {
-    responseHeaders.set(key, value);
-  }
-  for (const cookie of headers.getSetCookies()) {
-    responseHeaders.append("Set-Cookie", cookie);
-  }
-  return new Response(body, { ...init, headers: responseHeaders });
-}
-__name(createHandledResponse, "createHandledResponse");
-function createWebMiddlewareContext(request, parent, trustProxy = false, clientAddress) {
-  let currentRequest = withNodeRequestShape(request, trustProxy, clientAddress);
-  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 = new WebResponseHeaderMap();
-  if (parent?.headers) {
-    for (const [key, value] of Object.entries(parent.headers)) {
-      if (key.toLowerCase() === "set-cookie") continue;
-      headers.set(key, value);
-    }
-  }
-  const parentCookies = parent?.[FARM_SET_COOKIE_HEADERS];
-  if (parentCookies) headers.replaceSetCookies(parentCookies);
-  const responseShim = createResponseShim(headers);
-  const ctx = {
-    request: currentRequest,
-    response: responseShim.response,
-    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),
-        trustProxy,
-        clientAddress
-      );
-      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,
-    headers,
-    getRequest: /* @__PURE__ */ __name(() => currentRequest, "getRequest"),
-    getResponse: /* @__PURE__ */ __name(() => handledResponse || responseShim.getResponse(currentRequest.method), "getResponse")
-  };
-}
-__name(createWebMiddlewareContext, "createWebMiddlewareContext");
-function matchesMiddlewareConfig2(pathname, config, ctx) {
-  return matchesMiddlewareConfig(pathname, config, ctx);
-}
-__name(matchesMiddlewareConfig2, "matchesMiddlewareConfig");
-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: runtime3 } = entry;
-  return { matcher, exclude, runtime: runtime3 };
-}
-__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;
-    }
-    compileMiddlewareConfig(middlewareConfig);
-    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;
-    }
-    if (normalized.config) compileMiddlewareConfig(normalized.config);
-    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 (isMiddlewareResponse2(result2)) {
-        returnedResponse = result2;
-        return result2;
-      }
-    }
-    return returnedResponse;
-  }, "executeNext");
-  const result = await executeNext();
-  return isMiddlewareResponse2(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);
-  for (const entry of fileMiddleware) compileMiddlewareRoute(entry);
-  const entries = [...configMiddleware.entries, ...fileMiddleware];
-  const globalConfig = configMiddleware.globalConfig;
-  if (globalConfig) compileMiddlewareConfig(globalConfig);
-  return /* @__PURE__ */ __name(async function runProductionMiddleware(request, requestOptions = {}) {
-    if (!globalConfig && entries.length === 0) {
-      return emptyResult(request);
-    }
-    let contextState = createWebMiddlewareContext(
-      request,
-      void 0,
-      options.server?.trustProxy === true,
-      requestOptions.clientAddress
-    );
-    let ctx = contextState.ctx;
-    let currentRequest = contextState.getRequest();
-    const initialPathname = options.i18n?.enabled ? stripFarmLocaleFromPathname(ctx.pathname, options.i18n) : stripFarmBasePath(ctx.pathname, options.i18n?.basePath ?? "/");
-    let parentData;
-    if (globalConfig) {
-      const globalMatch = matchesMiddlewareConfig(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 } : matchesMiddlewareRoute(initialPathname, entry)
-    })).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(contextState.headers),
-        handled: false
-      };
-    }
-    for (const candidate of applicable) {
-      const { entry, routeMatch } = candidate;
-      const configMatch = entry.config ? matchesMiddlewareConfig(initialPathname, entry.config, ctx) : { matched: true };
-      if (!configMatch.matched) {
-        continue;
-      }
-      if (parentData) {
-        contextState = createWebMiddlewareContext(
-          currentRequest,
-          parentData,
-          options.server?.trustProxy === true,
-          requestOptions.clientAddress
-        );
-        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(contextState.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(contextState.headers),
-            handled: true
-          };
-        }
-        if (ctx._handled || ctx.response.headersSent || ctx.response.writableEnded) {
-          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(contextState.headers),
-            handled: true
-          };
-        }
-        emitFarmEvent({
-          type: "middleware.complete",
-          ...middlewareEvent,
-          durationMs: Date.now() - middlewareStartTime
-        });
-      } catch (error) {
-        currentRequest = contextState.getRequest();
-        if (isFarmRedirectError(error)) {
-          const redirect = getFarmRedirectError(error);
-          const response = applyProductionMiddlewareHeaders(
-            new Response(null, { status: redirect.status, headers: { Location: redirect.url } }),
-            mapToHeaders(contextState.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(contextState.headers),
-            handled: true
-          };
-        }
-        if (isFarmNotFoundError(error)) {
-          emitFarmEvent({ type: "middleware.shortCircuit", ...middlewareEvent, status: 404 });
-          return {
-            request: currentRequest,
-            response: null,
-            data: new Map(ctx.data),
-            context: new Map(ctx.locals),
-            headers: mapToHeaders(contextState.headers),
-            handled: true,
-            notFound: true
-          };
-        }
-        emitFarmEvent({
-          type: "middleware.error",
-          ...middlewareEvent,
-          error
-        });
-        throw error;
-      }
-      parentData = {
-        data: new Map(ctx.data),
-        locals: new Map(ctx.locals),
-        headers: headersToRecord(contextState.headers),
-        [FARM_SET_COOKIE_HEADERS]: [...contextState.headers.getSetCookies()]
-      };
-    }
-    return {
-      request: currentRequest,
-      response: null,
-      data: new Map(ctx.data),
-      context: new Map(ctx.locals),
-      headers: mapToHeaders(contextState.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);
-  const getSetCookie = middlewareHeaders.getSetCookie;
-  const setCookies = getSetCookie ? getSetCookie.call(middlewareHeaders) : middlewareHeaders.get("set-cookie") ? [middlewareHeaders.get("set-cookie")] : [];
-  for (const [key, value] of middlewareHeaders) {
-    if (key.toLowerCase() === "set-cookie") continue;
-    if (headers.has(key)) continue;
-    headers.set(key, value);
-  }
-  for (const cookie of setCookies) {
-    headers.append("Set-Cookie", cookie);
-  }
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
-__name(applyProductionMiddlewareHeaders, "applyProductionMiddlewareHeaders");
 
-// src/middleware/vite-plugin.ts
-var import_node_fs = __toESM(require("fs"));
-var import_node_path2 = __toESM(require("path"));
 
-// src/i18n/config.ts
-var import_node_path = __toESM(require("path"));
-var DEFAULT_FARM_I18N_COOKIE = "farm_locale";
-var DEFAULT_FARM_I18N_COOKIE_MAX_AGE = 60 * 60 * 24 * 365;
-var DEFAULT_DETECTION = ["url", "cookie", "accept-language"];
-function resolveFarmI18nConfig(input, options = {}) {
-  const root = options.root || process.cwd();
-  const basePath = options.basePath || "/";
-  const strictByDefault = options.mode === "production";
-  if (!input) {
-    return {
-      enabled: false,
-      basePath,
-      locales: ["en"],
-      defaultLocale: "en",
-      messages: import_node_path.default.join(root, "src/messages"),
-      routing: "none",
-      detection: [],
-      fallbackLocale: "en",
-      strict: strictByDefault,
-      cookie: {
-        name: DEFAULT_FARM_I18N_COOKIE,
-        maxAge: DEFAULT_FARM_I18N_COOKIE_MAX_AGE,
-        path: "/",
-        sameSite: "lax",
-        secure: options.mode === "production"
-      },
-      direction: {}
-    };
-  }
-  if (!Array.isArray(input.locales) || input.locales.length === 0) {
-    throw new Error("i18n.locales must contain at least one locale.");
-  }
-  const locales = input.locales.map(canonicalizeLocale);
-  if (new Set(locales).size !== locales.length) {
-    throw new Error("i18n.locales must not contain duplicate locales.");
-  }
-  const defaultLocale = canonicalizeLocale(input.defaultLocale);
-  if (!locales.includes(defaultLocale)) {
-    throw new Error(`i18n.defaultLocale "${defaultLocale}" must be included in i18n.locales.`);
-  }
-  const fallbackLocale = canonicalizeLocale(input.fallbackLocale || defaultLocale);
-  if (!locales.includes(fallbackLocale)) {
-    throw new Error(`i18n.fallbackLocale "${fallbackLocale}" must be included in i18n.locales.`);
-  }
-  const detection = resolveDetection(input);
-  const sameSite = input.cookie?.sameSite ?? "lax";
-  if (sameSite !== "lax" && sameSite !== "strict" && sameSite !== "none") {
-    throw new Error('i18n.cookie.sameSite must be "lax", "strict", or "none".');
-  }
-  const direction = {};
-  for (const [rawLocale, value] of Object.entries(input.direction || {})) {
-    const locale = canonicalizeLocale(rawLocale);
-    if (!locales.includes(locale)) {
-      throw new Error(`i18n.direction contains unknown locale "${rawLocale}".`);
-    }
-    if (value !== "ltr" && value !== "rtl") {
-      throw new Error(`i18n.direction.${rawLocale} must be "ltr" or "rtl".`);
-    }
-    direction[locale] = value;
-  }
-  return {
-    enabled: true,
-    basePath,
-    locales,
-    defaultLocale,
-    messages: import_node_path.default.resolve(root, input.messages || "src/messages"),
-    routing: input.routing || "prefix-except-default",
-    detection,
-    fallbackLocale,
-    strict: input.strict ?? strictByDefault,
-    cookie: {
-      name: input.cookie?.name?.trim() || DEFAULT_FARM_I18N_COOKIE,
-      maxAge: normalizePositiveInteger(
-        input.cookie?.maxAge,
-        DEFAULT_FARM_I18N_COOKIE_MAX_AGE,
-        "i18n.cookie.maxAge"
-      ),
-      path: normalizeCookiePath(input.cookie?.path),
-      sameSite,
-      secure: input.cookie?.secure ?? options.mode === "production"
-    },
-    direction
-  };
-}
-__name(resolveFarmI18nConfig, "resolveFarmI18nConfig");
-function canonicalizeLocale(locale) {
-  if (!locale || typeof locale !== "string") {
-    throw new Error("Farm i18n locales must be non-empty strings.");
-  }
-  try {
-    return Intl.getCanonicalLocales(locale)[0];
-  } catch {
-    throw new Error(`Invalid i18n locale "${locale}".`);
-  }
-}
-__name(canonicalizeLocale, "canonicalizeLocale");
-function resolveDetection(input) {
-  if (input.detection === false || input.localeDetection === false) {
-    return ["url"];
-  }
-  const detection = input.detection || DEFAULT_DETECTION;
-  const allowed = /* @__PURE__ */ new Set(["url", "cookie", "accept-language"]);
-  const unique = [];
-  for (const signal of detection) {
-    if (!allowed.has(signal)) {
-      throw new Error(`Unsupported i18n detection signal "${signal}".`);
-    }
-    if (!unique.includes(signal)) unique.push(signal);
-  }
-  return unique;
-}
-__name(resolveDetection, "resolveDetection");
-function normalizePositiveInteger(value, fallback, name) {
-  if (value === void 0) return fallback;
-  if (!Number.isInteger(value) || value < 0) {
-    throw new Error(`${name} must be a positive integer.`);
-  }
-  return value;
-}
-__name(normalizePositiveInteger, "normalizePositiveInteger");
-function normalizeCookiePath(value) {
-  if (value === void 0) return "/";
-  if (typeof value !== "string") {
-    throw new Error("i18n.cookie.path must be a root-relative pathname.");
-  }
-  const hasUnstableCharacters = /* @__PURE__ */ __name((candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  }), "hasUnstableCharacters");
-  if (hasUnstableCharacters(value)) {
-    throw new Error("i18n.cookie.path cannot contain backslashes or control characters.");
-  }
-  const pathname = value.trim();
-  if (!pathname || !pathname.startsWith("/") || pathname.startsWith("//") || pathname.includes(";") || pathname.includes("?") || pathname.includes("#")) {
-    throw new Error(
-      "i18n.cookie.path must be a root-relative pathname without attributes, a query, or a hash."
-    );
-  }
-  for (const segment of pathname.split("/")) {
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (hasUnstableCharacters(decoded)) {
-      throw new Error("i18n.cookie.path cannot contain backslashes or control characters.");
-    }
-    if (decoded.includes("/")) {
-      throw new Error("i18n.cookie.path cannot contain percent-encoded path separators.");
-    }
-    if (decoded === "." || decoded === "..") {
-      throw new Error('i18n.cookie.path cannot contain "." or ".." path segments.');
-    }
-  }
-  return pathname;
-}
-__name(normalizeCookiePath, "normalizeCookiePath");
 
-// src/middleware/vite-plugin.ts
-function getMiddlewareAppDirectory(root, srcDir) {
-  const sourceDirectory = import_node_path2.default.join(root, srcDir);
-  const appDirectory = import_node_path2.default.join(sourceDirectory, "app");
-  return import_node_fs.default.existsSync(appDirectory) ? appDirectory : sourceDirectory;
-}
-__name(getMiddlewareAppDirectory, "getMiddlewareAppDirectory");
-function farmMiddlewarePlugin(options = {}) {
-  const srcDir = options.srcDir ?? "src";
-  let manager = null;
-  let discoveryComplete = false;
-  let discoveryPromise = null;
-  const discover = /* @__PURE__ */ __name(async (server) => {
-    const i18n = resolveFarmI18nConfig(false, {
-      root: server.config.root,
-      mode: server.config.mode === "production" ? "production" : "development",
-      basePath: options.basePath ?? "/"
-    });
-    manager = new MiddlewareManager(
-      getMiddlewareAppDirectory(server.config.root, srcDir),
-      server,
-      void 0,
-      i18n
-    );
-    await manager.discover();
-    discoveryComplete = true;
-  }, "discover");
-  return {
-    name: "@farm.js/core:middleware",
-    enforce: "pre",
-    configureServer(server) {
-      discoveryPromise = discover(server);
-      void discoveryPromise.catch((error) => {
-        console.error("[FARM] Middleware discovery error:", error);
-      });
-      const execute = /* @__PURE__ */ __name(async (req, res, _pathname, sharedData) => {
-        if (discoveryPromise) {
-          await discoveryPromise;
-        }
-        if (!manager) {
-          return false;
-        }
-        const handled = await manager.execute(req, res);
-        const middlewareData = req.__FARM_MIDDLEWARE_DATA__;
-        if (sharedData && middlewareData instanceof Map) {
-          for (const [key, value] of middlewareData) {
-            sharedData.set(key, value);
-          }
-        }
-        return handled;
-      }, "execute");
-      server.__farmMiddleware__ = {
-        execute,
-        getMiddlewares: /* @__PURE__ */ __name(() => manager?.getMiddlewares() ?? [], "getMiddlewares"),
-        isReady: /* @__PURE__ */ __name(() => discoveryComplete, "isReady"),
-        waitForDiscovery: /* @__PURE__ */ __name(() => discoveryPromise, "waitForDiscovery")
-      };
-    },
-    async handleHotUpdate({ file, server, modules }) {
-      if (!/^middleware\.[tj]sx?$/.test(import_node_path2.default.basename(file))) {
-        return;
-      }
-      for (const module2 of modules) {
-        server.moduleGraph.invalidateModule(module2);
-      }
-      await manager?.reload();
-      server.ws.send({ type: "full-reload", path: "*" });
-      return [];
-    }
-  };
-}
-__name(farmMiddlewarePlugin, "farmMiddlewarePlugin");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MiddlewareManager,
-  UnsupportedRateLimitStorageError,
-  _runWithMiddlewareContext,
-  _runWithMiddlewareData,
-  applyProductionMiddlewareHeaders,
-  canonicalizeRequestPathSegments,
-  createContext,
-  createProductionMiddlewareRunner,
-  farmMiddlewarePlugin,
-  getFromMiddleware,
-  getMiddlewareContext,
-  getMiddlewareData,
-  getMiddlewareValue,
-  getRateLimitStatus,
-  hasMiddlewareData,
-  matchesMiddlewareConfig,
-  memoryRateLimitStorage,
-  middleware,
-  unwrapMiddleware
-});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.MiddlewareManager = _chunkY53ZSFN6cjs.MiddlewareManager; exports.UnsupportedRateLimitStorageError = _chunkFJSWYIR7cjs.UnsupportedRateLimitStorageError; exports._runWithMiddlewareContext = _chunkXGC343EYcjs._runWithMiddlewareContext; exports._runWithMiddlewareData = _chunkXGC343EYcjs._runWithMiddlewareData; exports.applyProductionMiddlewareHeaders = _chunkBYODCJD6cjs.applyProductionMiddlewareHeaders; exports.canonicalizeRequestPathSegments = _chunkUS2QVW3Ecjs.canonicalizeRequestPathSegments; exports.createContext = _chunkY53ZSFN6cjs.createContext; exports.createProductionMiddlewareRunner = _chunkBYODCJD6cjs.createProductionMiddlewareRunner; exports.farmMiddlewarePlugin = _chunkFJSWYIR7cjs.farmMiddlewarePlugin; exports.getFromMiddleware = _chunkFJSWYIR7cjs.getFromMiddleware; exports.getMiddlewareContext = _chunkXGC343EYcjs.getMiddlewareContext; exports.getMiddlewareData = _chunkXGC343EYcjs.getMiddlewareData; exports.getMiddlewareValue = _chunkXGC343EYcjs.getMiddlewareValue; exports.getRateLimitStatus = _chunkFJSWYIR7cjs.getRateLimitStatus; exports.hasMiddlewareData = _chunkFJSWYIR7cjs.hasMiddlewareData; exports.matchesMiddlewareConfig = _chunkBYODCJD6cjs.matchesMiddlewareConfig; exports.memoryRateLimitStorage = _chunkFJSWYIR7cjs.memoryRateLimitStorage; exports.middleware = _chunkFJSWYIR7cjs.middleware; exports.unwrapMiddleware = _chunkFJSWYIR7cjs.unwrapMiddleware;