@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/middleware.cjs

@@ -0,0 +1,2148 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/middleware/index.ts
+var middleware_exports = {};
+__export(middleware_exports, {
+  MiddlewareManager: () => MiddlewareManager,
+  _runWithMiddlewareContext: () => _runWithMiddlewareContext,
+  _runWithMiddlewareData: () => _runWithMiddlewareData,
+  applyProductionMiddlewareHeaders: () => applyProductionMiddlewareHeaders,
+  createContext: () => createContext,
+  createProductionMiddlewareRunner: () => createProductionMiddlewareRunner,
+  farmMiddlewarePlugin: () => farmMiddlewarePlugin,
+  getFromMiddleware: () => getFromMiddleware,
+  getMiddlewareContext: () => getMiddlewareContext,
+  getMiddlewareData: () => getMiddlewareData,
+  getMiddlewareValue: () => getMiddlewareValue,
+  getRateLimitStatus: () => getRateLimitStatus,
+  hasMiddlewareData: () => hasMiddlewareData,
+  middleware: () => middleware,
+  unwrapMiddleware: () => unwrapMiddleware
+});
+module.exports = __toCommonJS(middleware_exports);
+
+// src/storage/index.ts
+var import_unstorage = require("unstorage");
+var import_memory = __toESM(require("unstorage/drivers/memory"));
+function createMemoryStorage() {
+  return (0, import_unstorage.createStorage)({
+    driver: (0, import_memory.default)()
+  });
+}
+__name(createMemoryStorage, "createMemoryStorage");
+var GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farmjs.storage.global");
+function readGlobalStorage() {
+  return globalThis[GLOBAL_STORAGE_KEY];
+}
+__name(readGlobalStorage, "readGlobalStorage");
+function writeGlobalStorage(storage) {
+  globalThis[GLOBAL_STORAGE_KEY] = storage;
+  return storage;
+}
+__name(writeGlobalStorage, "writeGlobalStorage");
+function getActiveGlobalStorage() {
+  const existing = readGlobalStorage();
+  if (existing) {
+    return existing;
+  }
+  return writeGlobalStorage(createMemoryStorage());
+}
+__name(getActiveGlobalStorage, "getActiveGlobalStorage");
+var globalStorage = getActiveGlobalStorage();
+function normalizeMountKey(base) {
+  return (base || "").trim().replace(/^[:/\\]+|[:/\\]+$/g, "").replace(/[\\/]+/g, ":");
+}
+__name(normalizeMountKey, "normalizeMountKey");
+function getStorage(namespace) {
+  globalStorage = getActiveGlobalStorage();
+  const base = normalizeMountKey(namespace);
+  if (!base) {
+    return globalStorage;
+  }
+  const namespaced = (0, import_unstorage.prefixStorage)(globalStorage, base);
+  return {
+    ...namespaced,
+    async clear() {
+      const keys = await namespaced.getKeys();
+      await Promise.all(keys.map((key) => namespaced.removeItem(key)));
+    }
+  };
+}
+__name(getStorage, "getStorage");
+
+// src/middleware/chain.ts
+function getRateLimitStorage() {
+  return getStorage("ratelimit");
+}
+__name(getRateLimitStorage, "getRateLimitStorage");
+var defaultRateLimitStorage = {
+  async get(key) {
+    const storage = getRateLimitStorage();
+    const value = await storage.getItem(key);
+    return value ?? null;
+  },
+  async set(key, value, ttl) {
+    const storage = getRateLimitStorage();
+    await storage.setItem(key, value, ttl ? { ttl } : void 0);
+  },
+  async delete(key) {
+    const storage = getRateLimitStorage();
+    await storage.removeItem(key);
+  },
+  async ttl(key) {
+    const storage = getRateLimitStorage();
+    const record = await storage.getItem(key);
+    if (!record || !record.resetAt) {
+      return null;
+    }
+    const remainingMs = record.resetAt - Date.now();
+    return remainingMs > 0 ? Math.ceil(remainingMs / 1e3) : null;
+  }
+};
+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
+  };
+  return value * multipliers[unit];
+}
+__name(parseTimeWindow, "parseTimeWindow");
+function createRateLimitMiddleware(config) {
+  const windowMs = parseTimeWindow(config.window);
+  const storage = config.storage || defaultRateLimitStorage;
+  return async (ctx, next) => {
+    const key = config.keyGenerator ? config.keyGenerator(ctx) : `${ctx.request.socket.remoteAddress}:${ctx.pathname}`;
+    const now = Date.now();
+    const ttlSeconds = Math.ceil(windowMs / 1e3);
+    const record = await storage.get(key);
+    if (record && now > record.resetAt) {
+      await storage.delete(key);
+    }
+    const current = await storage.get(key);
+    if (!current) {
+      await storage.set(
+        key,
+        {
+          count: 1,
+          resetAt: now + windowMs
+        },
+        ttlSeconds
+      );
+      return next();
+    }
+    if (current.count >= config.requests) {
+      if (config.onLimit) {
+        const result = await config.onLimit(ctx);
+        if (result) return;
+      }
+      ctx.json(
+        {
+          error: "Rate limit exceeded",
+          retryAfter: Math.ceil((current.resetAt - now) / 1e3)
+        },
+        429
+      );
+      return;
+    }
+    current.count++;
+    await storage.set(key, current, ttlSeconds);
+    return next();
+  };
+}
+__name(createRateLimitMiddleware, "createRateLimitMiddleware");
+function matchPattern(pattern, pathname) {
+  if (pattern instanceof RegExp) {
+    return pattern.test(pathname);
+  }
+  const regexPattern = pattern.replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/]+").replace(/__DOUBLE_STAR__/g, ".*").replace(/\//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(path3) {
+    this.basePath = path3 === "/" ? "/" : path3.endsWith("/") ? path3.slice(0, -1) : path3;
+  }
+  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) {
+  const record = await storage.get(key);
+  if (!record) {
+    return {
+      requests: 0,
+      limit,
+      remaining: limit,
+      resetIn: null,
+      resetAt: null,
+      isLimited: false
+    };
+  }
+  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);
+  } else if (storage.ttl) {
+    resetIn = await storage.ttl(key);
+    resetAt = resetIn ? new Date(now + resetIn * 1e3) : null;
+  }
+  return {
+    requests,
+    limit,
+    remaining,
+    resetIn,
+    resetAt,
+    isLimited
+  };
+}
+__name(getRateLimitStatus, "getRateLimitStatus");
+function middleware(basePath = "/") {
+  return new MiddlewareChainImpl(basePath);
+}
+__name(middleware, "middleware");
+
+// src/middleware/context.ts
+function parseCookies(cookieHeader) {
+  if (!cookieHeader) return {};
+  return cookieHeader.split(";").reduce(
+    (cookies, cookie) => {
+      const [name, ...rest] = cookie.split("=");
+      const value = rest.join("=").trim();
+      if (name && value) {
+        cookies[name.trim()] = decodeURIComponent(value);
+      }
+      return cookies;
+    },
+    {}
+  );
+}
+__name(parseCookies, "parseCookies");
+function serializeCookie(name, value, options = {}) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (options.maxAge) {
+    cookie += `; Max-Age=${options.maxAge}`;
+  }
+  if (options.expires) {
+    cookie += `; Expires=${options.expires.toUTCString()}`;
+  }
+  if (options.path) {
+    cookie += `; Path=${options.path}`;
+  } else {
+    cookie += "; Path=/";
+  }
+  if (options.domain) {
+    cookie += `; Domain=${options.domain}`;
+  }
+  if (options.secure) {
+    cookie += "; Secure";
+  }
+  if (options.httpOnly) {
+    cookie += "; HttpOnly";
+  }
+  if (options.sameSite) {
+    cookie += `; SameSite=${options.sameSite.charAt(0).toUpperCase() + options.sameSite.slice(1)}`;
+  }
+  return cookie;
+}
+__name(serializeCookie, "serializeCookie");
+var _CookieJarImpl = class _CookieJarImpl {
+  constructor(req, res) {
+    this.req = req;
+    this.res = res;
+    this.setCookies = [];
+    this.cookies = parseCookies(req.headers.cookie);
+  }
+  get(name) {
+    return this.cookies[name];
+  }
+  set(name, value, options = {}) {
+    this.cookies[name] = value;
+    const cookieString = serializeCookie(name, value, options);
+    this.setCookies.push(cookieString);
+    this.res.setHeader("Set-Cookie", this.setCookies);
+  }
+  delete(name) {
+    delete this.cookies[name];
+    const cookieString = serializeCookie(name, "", {
+      maxAge: 0,
+      expires: /* @__PURE__ */ new Date(0)
+    });
+    this.setCookies.push(cookieString);
+    this.res.setHeader("Set-Cookie", this.setCookies);
+  }
+  getAll() {
+    return { ...this.cookies };
+  }
+};
+__name(_CookieJarImpl, "CookieJarImpl");
+var CookieJarImpl = _CookieJarImpl;
+function createContext(req, res, viteServer, parent) {
+  const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+  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);
+  Object.entries(req.headers).forEach(([key, value]) => {
+    if (typeof value === "string") {
+      headers.set(key, value);
+    } else if (Array.isArray(value)) {
+      headers.set(key, value.join(", "));
+    }
+  });
+  if (parent?.headers) {
+    for (const [key, value] of Object.entries(parent.headers)) {
+      headers.set(key, value);
+    }
+  }
+  let handled = false;
+  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;
+      res.writeHead(status, {
+        Location: redirectUrl,
+        "Content-Type": "text/plain"
+      });
+      res.end(`Redirecting to ${redirectUrl}`);
+    },
+    rewrite(rewriteUrl) {
+      ctx._rewriteUrl = rewriteUrl;
+      const newUrl = new URL(rewriteUrl, `http://${req.headers.host || "localhost"}`);
+      ctx.url = newUrl;
+      ctx.pathname = newUrl.pathname;
+      ctx.searchParams = newUrl.searchParams;
+      req.url = rewriteUrl;
+    },
+    json(jsonData, status = 200) {
+      if (handled) {
+        console.warn("Response already sent, cannot send JSON");
+        return;
+      }
+      ctx._handled = true;
+      handled = true;
+      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;
+      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;
+      res.writeHead(status, {
+        "Content-Type": "text/html"
+      });
+      res.end(content);
+    }
+  };
+  return ctx;
+}
+__name(createContext, "createContext");
+
+// src/middleware/manager.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+
+// src/server/request.ts
+var import_node_async_hooks = require("async_hooks");
+
+// src/server/request-bridge.ts
+var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
+function getGlobalState() {
+  return globalThis;
+}
+__name(getGlobalState, "getGlobalState");
+function _setCurrentRequestResolver(resolver) {
+  getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY] = resolver;
+}
+__name(_setCurrentRequestResolver, "_setCurrentRequestResolver");
+
+// src/server/request.ts
+var REQUEST_STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-storage");
+function getRequestStore() {
+  const runtime = globalThis;
+  const existing = runtime[REQUEST_STORAGE_KEY];
+  if (existing instanceof import_node_async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new import_node_async_hooks.AsyncLocalStorage();
+  runtime[REQUEST_STORAGE_KEY] = storage;
+  return storage;
+}
+__name(getRequestStore, "getRequestStore");
+var requestStore = getRequestStore();
+_setCurrentRequestResolver(() => requestStore.getStore());
+function createWebRequestFromFarmRequest(req) {
+  const forwardedHost = req.headers["x-forwarded-host"];
+  const host = Array.isArray(forwardedHost) ? forwardedHost[0] : forwardedHost || req.headers.host || "localhost";
+  const forwardedProto = req.headers["x-forwarded-proto"];
+  const proto = Array.isArray(forwardedProto) ? forwardedProto[0] : forwardedProto || "http";
+  const fullUrl = new URL(req.url || "/", `${proto}://${host}`).toString();
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+      continue;
+    }
+    headers.set(key, value);
+  }
+  return new Request(fullUrl, {
+    method: req.method,
+    headers
+  });
+}
+__name(createWebRequestFromFarmRequest, "createWebRequestFromFarmRequest");
+
+// src/middleware/module.ts
+function isWebRequest(request) {
+  return typeof Request !== "undefined" && request instanceof Request;
+}
+__name(isWebRequest, "isWebRequest");
+function toWebRequest(ctx) {
+  if (isWebRequest(ctx.request)) {
+    return ctx.request;
+  }
+  return createWebRequestFromFarmRequest(ctx.request);
+}
+__name(toWebRequest, "toWebRequest");
+function createRequestMiddlewareContext(ctx) {
+  const context = {
+    get url() {
+      return ctx.url;
+    },
+    get pathname() {
+      return ctx.pathname;
+    },
+    get searchParams() {
+      return ctx.searchParams;
+    },
+    get method() {
+      return ctx.method;
+    },
+    get params() {
+      return ctx.params;
+    },
+    get route() {
+      return ctx.route;
+    },
+    get locals() {
+      return ctx.locals;
+    },
+    get data() {
+      return ctx.data;
+    },
+    get headers() {
+      return ctx.headers;
+    },
+    get cookies() {
+      return ctx.cookies;
+    },
+    get(key) {
+      return ctx.locals.get(key);
+    },
+    has(key) {
+      return ctx.locals.has(key);
+    },
+    set(key, value) {
+      ctx.locals.set(key, value);
+    },
+    delete(key) {
+      return ctx.locals.delete(key);
+    },
+    redirect(url, status) {
+      ctx.redirect(url, status);
+    },
+    rewrite(url) {
+      ctx.rewrite(url);
+    },
+    json(data, status) {
+      ctx.json(data, status);
+    },
+    text(content, status) {
+      ctx.text(content, status);
+    },
+    html(content, status) {
+      ctx.html(content, status);
+    }
+  };
+  return context;
+}
+__name(createRequestMiddlewareContext, "createRequestMiddlewareContext");
+function normalizeMiddlewareModule(middlewareModule, routePath) {
+  const module2 = middlewareModule;
+  const defaultExport = module2.default;
+  const namedExport = module2.middleware;
+  const hasNamedExport = typeof namedExport === "function";
+  if (namedExport !== void 0 && !hasNamedExport) {
+    throw new TypeError("The named middleware export must be a function");
+  }
+  if (defaultExport && hasNamedExport) {
+    throw new Error(
+      "A middleware file cannot export both a default handler and a named middleware handler"
+    );
+  }
+  if (hasNamedExport) {
+    return {
+      handlers: [
+        async (ctx) => {
+          return namedExport(toWebRequest(ctx), createRequestMiddlewareContext(ctx));
+        }
+      ],
+      config: module2.config
+    };
+  }
+  if (defaultExport && typeof defaultExport === "object" && "build" in defaultExport) {
+    if (typeof defaultExport.setBasePath === "function") {
+      defaultExport.setBasePath(routePath);
+    }
+    const built = defaultExport.build();
+    const handlers = Array.isArray(built?.handlers) ? built.handlers.filter((handler) => typeof handler === "function") : [];
+    return handlers.length > 0 ? {
+      handlers,
+      config: module2.config || built?.config
+    } : null;
+  }
+  if (typeof defaultExport === "function") {
+    return {
+      handlers: [defaultExport],
+      config: module2.config
+    };
+  }
+  return null;
+}
+__name(normalizeMiddlewareModule, "normalizeMiddlewareModule");
+
+// src/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
+var import_node_events = require("events");
+async function sendWebResponse(res, response) {
+  res.statusCode = response.status;
+  const responseHeaders = response.headers;
+  const setCookies = responseHeaders.getSetCookie?.() || [];
+  if (setCookies.length > 0) {
+    res.setHeader("Set-Cookie", setCookies);
+  }
+  response.headers.forEach((value, key) => {
+    if (key.toLowerCase() === "set-cookie" && setCookies.length > 0) {
+      return;
+    }
+    res.setHeader(key, value);
+  });
+  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();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (!value || value.byteLength === 0) {
+        continue;
+      }
+      if (!res.write(value)) {
+        await (0, import_node_events.once)(res, "drain");
+      }
+    }
+    res.end();
+  } catch (error) {
+    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 {
+    reader.releaseLock();
+  }
+}
+__name(sendWebResponse, "sendWebResponse");
+
+// src/observability.ts
+var runtimeHandlers = /* @__PURE__ */ new Set();
+var observabilityState = {
+  logs: false,
+  handlers: []
+};
+function emitFarmEvent(input) {
+  const event = {
+    timestamp: Date.now(),
+    level: inferFarmEventLevel(input.type),
+    ...input
+  };
+  if (!shouldEmitFarmEvent(event)) {
+    return event;
+  }
+  if (observabilityState.logs) {
+    logFarmEvent(event);
+  }
+  for (const handler of [...observabilityState.handlers, ...runtimeHandlers]) {
+    try {
+      Promise.resolve(handler(event)).catch((error) => {
+        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+      });
+    } catch (error) {
+      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+    }
+  }
+  return event;
+}
+__name(emitFarmEvent, "emitFarmEvent");
+function shouldEmitFarmEvent(event) {
+  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
+    return false;
+  }
+  if (observabilityState.events && !observabilityState.events.has(event.type)) {
+    return false;
+  }
+  return true;
+}
+__name(shouldEmitFarmEvent, "shouldEmitFarmEvent");
+function inferFarmEventLevel(type) {
+  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
+    return "error";
+  }
+  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
+    return "warn";
+  }
+  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
+    return "debug";
+  }
+  return "info";
+}
+__name(inferFarmEventLevel, "inferFarmEventLevel");
+function logFarmEvent(event) {
+  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
+  switch (event.level) {
+    case "error":
+      console.error(message);
+      break;
+    case "warn":
+      console.warn(message);
+      break;
+    default:
+      console.log(message);
+      break;
+  }
+}
+__name(logFarmEvent, "logFarmEvent");
+function formatFarmEventDetails(event) {
+  const details = [];
+  const record = event;
+  for (const key of [
+    "route",
+    "pathname",
+    "method",
+    "status",
+    "key",
+    "tag",
+    "path",
+    "reason",
+    "durationMs",
+    "integration",
+    "operation",
+    "plugin",
+    "hook",
+    "target",
+    "count"
+  ]) {
+    const value = record[key];
+    if (value !== void 0) {
+      details.push(`${key}=${formatDetailValue(value)}`);
+    }
+  }
+  return details.length > 0 ? ` ${details.join(" ")}` : "";
+}
+__name(formatFarmEventDetails, "formatFarmEventDetails");
+function formatDetailValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+__name(formatDetailValue, "formatDetailValue");
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(formatError, "formatError");
+
+// src/i18n/routing.ts
+function resolveFarmLocalePath(pathname, config) {
+  const normalized = normalizePathname(pathname);
+  if (config.routing === "none") {
+    return { pathname: normalized, explicit: false };
+  }
+  const segments = normalized.split("/").filter(Boolean);
+  const firstSegment = segments[0];
+  const locale = config.locales.find(
+    (candidate) => candidate.toLowerCase() === firstSegment?.toLowerCase()
+  );
+  if (!locale) {
+    return { pathname: normalized, explicit: false };
+  }
+  const remaining = segments.slice(1);
+  return {
+    locale,
+    pathname: remaining.length > 0 ? `/${remaining.join("/")}` : "/",
+    explicit: true
+  };
+}
+__name(resolveFarmLocalePath, "resolveFarmLocalePath");
+function stripFarmLocaleFromPathname(pathname, config) {
+  return resolveFarmLocalePath(pathname, config).pathname;
+}
+__name(stripFarmLocaleFromPathname, "stripFarmLocaleFromPathname");
+function normalizePathname(pathname) {
+  const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (withLeadingSlash === "/") return "/";
+  return withLeadingSlash.replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
+}
+__name(normalizePathname, "normalizePathname");
+
+// src/middleware/manager.ts
+function isMiddlewareResponse(value) {
+  return value instanceof Response;
+}
+__name(isMiddlewareResponse, "isMiddlewareResponse");
+var _MiddlewareManager = class _MiddlewareManager {
+  constructor(appDir, viteServer, config, i18n) {
+    this.middleware = [];
+    this.configMiddleware = [];
+    this.appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
+    this.viteServer = viteServer;
+    this.i18n = i18n;
+    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);
+      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) {
+        middlewareByPath.set(middleware2.path, middleware2);
+      }
+    }
+    this.middleware = Array.from(middlewareByPath.values());
+    this.middleware.sort((a, b) => {
+      const depthA = a.path.split("/").length;
+      const depthB = b.path.split("/").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 = path.posix.join(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 {
+        const fileUrl = `file://${filePath}`;
+        module2 = await import(
+          /* @vite-ignore */
+          fileUrl
+        );
+      }
+      const normalized = normalizeMiddlewareModule(module2, routePath);
+      if (!normalized) {
+        logger.warn(
+          `Middleware file ${filePath} must export a default handler or a named middleware handler`
+        );
+        return null;
+      }
+      return {
+        path: routePath,
+        filePath,
+        handlers: normalized.handlers,
+        config: normalized.config,
+        source: "file"
+      };
+    } catch (error) {
+      logger.error(`Failed to load middleware ${filePath}: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Execute middleware for a request
+   */
+  async execute(req, res) {
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    const pathname = url.pathname;
+    const routePathname = this.i18n?.enabled ? stripFarmLocaleFromPathname(pathname, this.i18n) : pathname;
+    const method = req.method || "GET";
+    const startTime = Date.now();
+    let parentData;
+    let ctx = createContext(req, res, this.viteServer);
+    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: this.matchRoutePath(routePathname, mw.path) })).filter((entry) => entry.routeMatch.matched)
+    ];
+    if (applicable.length === 0) {
+      return false;
+    }
+    try {
+      const pc = require("picocolors");
+      const middlewarePaths = applicable.map(({ mw }) => mw.path).join(", ");
+      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);
+    } catch {
+      console.log(
+        `[FARM] [MIDDLEWARE] [${method}] Executing ${pathname} (${applicable.length} middleware)`
+      );
+    }
+    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);
+        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({
+          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) {
+    if (config.exclude) {
+      for (const pattern of config.exclude) {
+        if (this.matchPattern(pattern, pathname).matched) {
+          return { matched: false };
+        }
+      }
+    }
+    if (config.matcher) {
+      for (const matcher of this.toMatcherList(config.matcher)) {
+        if (typeof matcher === "string" || matcher instanceof RegExp) {
+          const result = this.matchPattern(matcher, pathname);
+          if (result.matched) {
+            return result;
+          }
+        } else if (typeof matcher === "function") {
+          return { matched: matcher(ctx) };
+        }
+      }
+      return { matched: false };
+    }
+    return { matched: true };
+  }
+  /**
+   * Match a pattern against pathname
+   */
+  matchPattern(pattern, pathname) {
+    if (pattern instanceof RegExp) {
+      pattern.lastIndex = 0;
+      const match2 = pattern.exec(pathname);
+      return {
+        matched: !!match2,
+        params: match2?.groups ? { ...match2.groups } : void 0
+      };
+    }
+    if (pattern === "*" || pattern === "/(.*)") {
+      return { matched: true };
+    }
+    if (pattern.endsWith("(.*)")) {
+      const prefix = pattern.slice(0, -4);
+      return { matched: pathname === prefix || pathname.startsWith(`${prefix}/`) };
+    }
+    const { regex, params } = this.compilePathPattern(pattern);
+    const match = regex.exec(pathname);
+    if (!match) {
+      return { matched: false };
+    }
+    const values = {};
+    params.forEach((param, index) => {
+      values[param] = decodeURIComponent(match[index + 1] || "");
+    });
+    return {
+      matched: true,
+      params: Object.keys(values).length > 0 ? values : void 0
+    };
+  }
+  /**
+   * 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;
+  }
+  matchRoutePath(pathname, middlewarePath) {
+    if (middlewarePath === "/") return { matched: true };
+    const exactMatch = this.matchPattern(middlewarePath, pathname);
+    if (exactMatch.matched) {
+      return exactMatch;
+    }
+    const nestedMatch = this.matchPattern(`${middlewarePath}/:__farmRest*`, pathname);
+    if (!nestedMatch.matched) {
+      return { matched: false };
+    }
+    const params = { ...nestedMatch.params };
+    delete params.__farmRest;
+    return {
+      matched: true,
+      params: Object.keys(params).length > 0 ? params : void 0
+    };
+  }
+  toMatcherList(matcher) {
+    if (!matcher) return [];
+    return Array.isArray(matcher) ? matcher : [matcher];
+  }
+  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 } = entry;
+    return { matcher, exclude, runtime };
+  }
+  compilePathPattern(pattern) {
+    const params = [];
+    const segments = pattern.split("/").filter(Boolean);
+    if (segments.length === 0) {
+      return { regex: /^\/$/, params };
+    }
+    const parts = segments.map((segment) => {
+      if (segment === "**") {
+        return "(?:/.*)?";
+      }
+      if (segment === "*") {
+        return "/[^/]+";
+      }
+      if (segment.startsWith(":")) {
+        const { name, modifier } = this.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 `/${this.escapeRegex(segment).replace(/\\\*/g, "[^/]*")}`;
+    });
+    return {
+      regex: new RegExp(`^${parts.join("")}$`),
+      params
+    };
+  }
+  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
+    };
+  }
+  escapeRegex(value) {
+    return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+  }
+};
+__name(_MiddlewareManager, "MiddlewareManager");
+var MiddlewareManager = _MiddlewareManager;
+
+// src/middleware/server.ts
+var import_async_hooks = require("async_hooks");
+var MIDDLEWARE_DATA_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.middlewareDataStore");
+var MIDDLEWARE_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.middlewareContextStore");
+function getGlobalMiddlewareStore(key) {
+  const state = globalThis;
+  const existing = state[key];
+  if (existing instanceof import_async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const store = new import_async_hooks.AsyncLocalStorage();
+  state[key] = store;
+  return store;
+}
+__name(getGlobalMiddlewareStore, "getGlobalMiddlewareStore");
+var middlewareStore = getGlobalMiddlewareStore(MIDDLEWARE_DATA_STORE_KEY);
+var middlewareContextStore = getGlobalMiddlewareStore(MIDDLEWARE_CONTEXT_STORE_KEY);
+function toMiddlewareMap(data) {
+  if (data instanceof Map) {
+    return new Map(data);
+  }
+  return new Map(Object.entries(data));
+}
+__name(toMiddlewareMap, "toMiddlewareMap");
+async function _runWithMiddlewareData(data, fn) {
+  return middlewareStore.run(toMiddlewareMap(data), fn);
+}
+__name(_runWithMiddlewareData, "_runWithMiddlewareData");
+async function _runWithMiddlewareContext(context, fn) {
+  return middlewareContextStore.run(toMiddlewareMap(context), fn);
+}
+__name(_runWithMiddlewareContext, "_runWithMiddlewareContext");
+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
+function parseCookies2(cookieHeader) {
+  if (!cookieHeader) return {};
+  return cookieHeader.split(";").reduce(
+    (cookies, cookie) => {
+      const [name, ...rest] = cookie.split("=");
+      const value = rest.join("=").trim();
+      if (name && value) {
+        cookies[name.trim()] = decodeURIComponent(value);
+      }
+      return cookies;
+    },
+    {}
+  );
+}
+__name(parseCookies2, "parseCookies");
+function serializeCookie2(name, value, options = {}) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (options.maxAge) cookie += `; Max-Age=${options.maxAge}`;
+  if (options.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
+  cookie += `; Path=${options.path || "/"}`;
+  if (options.domain) cookie += `; Domain=${options.domain}`;
+  if (options.secure) cookie += "; Secure";
+  if (options.httpOnly) cookie += "; HttpOnly";
+  if (options.sameSite) {
+    cookie += `; SameSite=${options.sameSite.charAt(0).toUpperCase()}${options.sameSite.slice(1)}`;
+  }
+  return cookie;
+}
+__name(serializeCookie2, "serializeCookie");
+var _WebCookieJar = class _WebCookieJar {
+  constructor(request, headers) {
+    this.headers = headers;
+    this.setCookies = [];
+    this.cookies = parseCookies2(request.headers.get("cookie"));
+  }
+  get(name) {
+    return this.cookies[name];
+  }
+  set(name, value, options = {}) {
+    this.cookies[name] = value;
+    const cookieString = serializeCookie2(name, value, options);
+    this.setCookies.push(cookieString);
+    this.headers.set("Set-Cookie", this.setCookies.join(", "));
+  }
+  delete(name) {
+    delete this.cookies[name];
+    const cookieString = serializeCookie2(name, "", {
+      maxAge: 0,
+      expires: /* @__PURE__ */ new Date(0)
+    });
+    this.setCookies.push(cookieString);
+    this.headers.set("Set-Cookie", this.setCookies.join(", "));
+  }
+  getAll() {
+    return { ...this.cookies };
+  }
+};
+__name(_WebCookieJar, "WebCookieJar");
+var WebCookieJar = _WebCookieJar;
+function mapToHeaders(map) {
+  const headers = new Headers();
+  for (const [key, value] of map) {
+    if (key.toLowerCase() === "set-cookie") {
+      headers.append(key, value);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  return headers;
+}
+__name(mapToHeaders, "mapToHeaders");
+function headersToRecord(headers) {
+  return Object.fromEntries(headers);
+}
+__name(headersToRecord, "headersToRecord");
+function isMiddlewareResponse2(value) {
+  return value instanceof Response;
+}
+__name(isMiddlewareResponse2, "isMiddlewareResponse");
+function createResponseShim(headers) {
+  return {
+    headersSent: false,
+    writableEnded: false,
+    setHeader(name, value) {
+      headers.set(name, Array.isArray(value) ? value.join(", ") : String(value));
+    },
+    getHeader(name) {
+      return headers.get(name);
+    },
+    writeHead(status, responseHeaders) {
+      this.statusCode = status;
+      if (responseHeaders) {
+        for (const [key, value] of Object.entries(responseHeaders)) {
+          headers.set(key, value);
+        }
+      }
+      this.headersSent = true;
+    },
+    end() {
+      this.writableEnded = true;
+    }
+  };
+}
+__name(createResponseShim, "createResponseShim");
+function withNodeRequestShape(request) {
+  const requestWithShape = request;
+  if (!requestWithShape.socket) {
+    const forwardedFor = request.headers.get("x-forwarded-for")?.split(",")[0]?.trim();
+    try {
+      requestWithShape.socket = {
+        remoteAddress: forwardedFor || "127.0.0.1"
+      };
+    } catch {
+    }
+  }
+  return requestWithShape;
+}
+__name(withNodeRequestShape, "withNodeRequestShape");
+function createHandledResponse(body, init, headers) {
+  const responseHeaders = new Headers(init.headers);
+  for (const [key, value] of headers) {
+    if (key.toLowerCase() === "set-cookie") {
+      responseHeaders.append(key, value);
+    } else {
+      responseHeaders.set(key, value);
+    }
+  }
+  return new Response(body, { ...init, headers: responseHeaders });
+}
+__name(createHandledResponse, "createHandledResponse");
+function createWebMiddlewareContext(request, parent) {
+  let currentRequest = withNodeRequestShape(request);
+  let handledResponse = null;
+  const url = new URL(currentRequest.url);
+  const data = parent?.data ? new Map(parent.data) : /* @__PURE__ */ new Map();
+  const locals = parent?.locals ? new Map(parent.locals) : /* @__PURE__ */ new Map();
+  const headers = /* @__PURE__ */ new Map();
+  if (parent?.headers) {
+    for (const [key, value] of Object.entries(parent.headers)) {
+      headers.set(key, value);
+    }
+  }
+  const ctx = {
+    request: currentRequest,
+    response: createResponseShim(headers),
+    url,
+    pathname: url.pathname,
+    searchParams: url.searchParams,
+    method: currentRequest.method || "GET",
+    params: {},
+    route: url.pathname,
+    parent,
+    vite: {
+      isDev: false,
+      hmr: false
+    },
+    data,
+    locals,
+    headers,
+    cookies: new WebCookieJar(currentRequest, headers),
+    _handled: false,
+    _redirectUrl: void 0,
+    _rewriteUrl: void 0,
+    redirect(redirectUrl, status = 307) {
+      ctx._redirectUrl = redirectUrl;
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        `Redirecting to ${redirectUrl}`,
+        {
+          status,
+          headers: {
+            Location: redirectUrl,
+            "Content-Type": "text/plain"
+          }
+        },
+        headers
+      );
+    },
+    rewrite(rewriteUrl) {
+      ctx._rewriteUrl = rewriteUrl;
+      const nextUrl = new URL(rewriteUrl, currentRequest.url);
+      currentRequest = withNodeRequestShape(new Request(nextUrl, currentRequest));
+      ctx.request = currentRequest;
+      ctx.url = nextUrl;
+      ctx.pathname = nextUrl.pathname;
+      ctx.searchParams = nextUrl.searchParams;
+      ctx.route = nextUrl.pathname;
+    },
+    json(jsonData, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        JSON.stringify(jsonData),
+        {
+          status,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        },
+        headers
+      );
+    },
+    text(content, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        content,
+        {
+          status,
+          headers: {
+            "Content-Type": "text/plain"
+          }
+        },
+        headers
+      );
+    },
+    html(content, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        content,
+        {
+          status,
+          headers: {
+            "Content-Type": "text/html"
+          }
+        },
+        headers
+      );
+    }
+  };
+  return {
+    ctx,
+    getRequest: /* @__PURE__ */ __name(() => currentRequest, "getRequest"),
+    getResponse: /* @__PURE__ */ __name(() => handledResponse, "getResponse")
+  };
+}
+__name(createWebMiddlewareContext, "createWebMiddlewareContext");
+function toMatcherList(matcher) {
+  if (!matcher) return [];
+  return Array.isArray(matcher) ? matcher : [matcher];
+}
+__name(toMatcherList, "toMatcherList");
+function escapeRegex(value) {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+__name(escapeRegex, "escapeRegex");
+function parseColonParam(segment) {
+  const raw = segment.slice(1);
+  const last = raw[raw.length - 1];
+  const modifier = last === "*" || last === "+" || last === "?" ? last : void 0;
+  return {
+    name: modifier ? raw.slice(0, -1) : raw,
+    modifier
+  };
+}
+__name(parseColonParam, "parseColonParam");
+function compilePathPattern(pattern) {
+  const params = [];
+  const segments = pattern.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return { regex: /^\/$/, params };
+  }
+  const parts = segments.map((segment) => {
+    if (segment === "**") {
+      return "(?:/.*)?";
+    }
+    if (segment === "*") {
+      return "/[^/]+";
+    }
+    if (segment.startsWith(":")) {
+      const { name, modifier } = parseColonParam(segment);
+      params.push(name);
+      if (modifier === "*") {
+        return "(?:/(.*))?";
+      }
+      if (modifier === "+") {
+        return "/(.+)";
+      }
+      return "/([^/]+)";
+    }
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      params.push(segment.slice(4, -1));
+      return "(?:/(.*))?";
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      params.push(segment.slice(1, -1));
+      return "/([^/]+)";
+    }
+    return `/${escapeRegex(segment).replace(/\\\*/g, "[^/]*")}`;
+  });
+  return {
+    regex: new RegExp(`^${parts.join("")}$`),
+    params
+  };
+}
+__name(compilePathPattern, "compilePathPattern");
+function matchPattern2(pattern, pathname) {
+  if (pattern instanceof RegExp) {
+    pattern.lastIndex = 0;
+    const match2 = pattern.exec(pathname);
+    return {
+      matched: !!match2,
+      params: match2?.groups ? { ...match2.groups } : void 0
+    };
+  }
+  if (pattern === "*" || pattern === "/(.*)") {
+    return { matched: true };
+  }
+  if (pattern.endsWith("(.*)")) {
+    const prefix = pattern.slice(0, -4);
+    return { matched: pathname === prefix || pathname.startsWith(`${prefix}/`) };
+  }
+  const { regex, params } = compilePathPattern(pattern);
+  const match = regex.exec(pathname);
+  if (!match) {
+    return { matched: false };
+  }
+  const values = {};
+  params.forEach((param, index) => {
+    values[param] = decodeURIComponent(match[index + 1] || "");
+  });
+  return {
+    matched: true,
+    params: Object.keys(values).length > 0 ? values : void 0
+  };
+}
+__name(matchPattern2, "matchPattern");
+function matchesConfig(pathname, config, ctx) {
+  if (config.exclude) {
+    for (const pattern of config.exclude) {
+      if (matchPattern2(pattern, pathname).matched) {
+        return { matched: false };
+      }
+    }
+  }
+  if (config.matcher) {
+    for (const matcher of toMatcherList(config.matcher)) {
+      if (typeof matcher === "string" || matcher instanceof RegExp) {
+        const result = matchPattern2(matcher, pathname);
+        if (result.matched) {
+          return result;
+        }
+      } else if (typeof matcher === "function") {
+        return { matched: matcher(ctx) };
+      }
+    }
+    return { matched: false };
+  }
+  return { matched: true };
+}
+__name(matchesConfig, "matchesConfig");
+function matchRoutePath(pathname, middlewarePath) {
+  if (middlewarePath === "/") return { matched: true };
+  const exactMatch = matchPattern2(middlewarePath, pathname);
+  if (exactMatch.matched) {
+    return exactMatch;
+  }
+  const nestedMatch = matchPattern2(`${middlewarePath}/:__farmRest*`, pathname);
+  if (!nestedMatch.matched) {
+    return { matched: false };
+  }
+  const params = { ...nestedMatch.params };
+  delete params.__farmRest;
+  return {
+    matched: true,
+    params: Object.keys(params).length > 0 ? params : void 0
+  };
+}
+__name(matchRoutePath, "matchRoutePath");
+function getConfigHandlers(entry) {
+  const handlers = [];
+  if ("handler" in entry && typeof entry.handler === "function") {
+    handlers.push(entry.handler);
+  }
+  if ("handlers" in entry && Array.isArray(entry.handlers)) {
+    handlers.push(...entry.handlers.filter((handler) => typeof handler === "function"));
+  }
+  return handlers;
+}
+__name(getConfigHandlers, "getConfigHandlers");
+function toMiddlewareConfig(entry) {
+  const { matcher, exclude, runtime } = entry;
+  return { matcher, exclude, runtime };
+}
+__name(toMiddlewareConfig, "toMiddlewareConfig");
+function normalizeConfigMiddleware(config) {
+  const entries = [];
+  let globalConfig;
+  if (!config) {
+    return { entries, globalConfig };
+  }
+  const configEntries = Array.isArray(config) ? config : [config];
+  for (const [index, entry] of configEntries.entries()) {
+    const handlers = getConfigHandlers(entry);
+    const middlewareConfig = toMiddlewareConfig(entry);
+    if (handlers.length === 0) {
+      globalConfig = middlewareConfig;
+      continue;
+    }
+    entries.push({
+      path: "/",
+      filePath: `farm.config.ts#middleware-${index}`,
+      handlers,
+      config: middlewareConfig,
+      source: "config"
+    });
+  }
+  return { entries, globalConfig };
+}
+__name(normalizeConfigMiddleware, "normalizeConfigMiddleware");
+function normalizeFileMiddleware(modules = []) {
+  const entries = [];
+  for (const moduleEntry of modules) {
+    const normalized = normalizeMiddlewareModule(moduleEntry.module, moduleEntry.path);
+    if (!normalized) {
+      continue;
+    }
+    entries.push({
+      path: moduleEntry.path,
+      filePath: moduleEntry.filePath || moduleEntry.path,
+      handlers: normalized.handlers,
+      config: normalized.config,
+      source: "file"
+    });
+  }
+  return entries;
+}
+__name(normalizeFileMiddleware, "normalizeFileMiddleware");
+async function executeHandlers(handlers, ctx) {
+  let handlerIndex = 0;
+  let returnedResponse;
+  const executeNext = /* @__PURE__ */ __name(async () => {
+    if (handlerIndex < handlers.length) {
+      const handler = handlers[handlerIndex++];
+      const result2 = await handler(ctx, executeNext);
+      if (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);
+  const entries = [...configMiddleware.entries, ...fileMiddleware];
+  const globalConfig = configMiddleware.globalConfig;
+  return /* @__PURE__ */ __name(async function runProductionMiddleware(request) {
+    if (!globalConfig && entries.length === 0) {
+      return emptyResult(request);
+    }
+    let contextState = createWebMiddlewareContext(request);
+    let ctx = contextState.ctx;
+    let currentRequest = contextState.getRequest();
+    const initialPathname = options.i18n?.enabled ? stripFarmLocaleFromPathname(ctx.pathname, options.i18n) : ctx.pathname;
+    let parentData;
+    if (globalConfig) {
+      const globalMatch = matchesConfig(initialPathname, globalConfig, ctx);
+      if (!globalMatch.matched) {
+        return emptyResult(request);
+      }
+      if (globalMatch.params) {
+        ctx.params = { ...ctx.params, ...globalMatch.params };
+      }
+    }
+    const applicable = entries.map((entry) => ({
+      entry,
+      routeMatch: entry.source === "config" ? { matched: true } : matchRoutePath(initialPathname, entry.path)
+    })).filter((candidate) => candidate.routeMatch.matched);
+    if (applicable.length === 0) {
+      return {
+        request: currentRequest,
+        response: null,
+        data: new Map(ctx.data),
+        context: new Map(ctx.locals),
+        headers: mapToHeaders(ctx.headers),
+        handled: false
+      };
+    }
+    for (const candidate of applicable) {
+      const { entry, routeMatch } = candidate;
+      const configMatch = entry.config ? matchesConfig(initialPathname, entry.config, ctx) : { matched: true };
+      if (!configMatch.matched) {
+        continue;
+      }
+      if (parentData) {
+        contextState = createWebMiddlewareContext(currentRequest, parentData);
+        ctx = contextState.ctx;
+      }
+      if (routeMatch.params) {
+        ctx.params = { ...ctx.params, ...routeMatch.params };
+      }
+      if (configMatch.params) {
+        ctx.params = { ...ctx.params, ...configMatch.params };
+      }
+      const middlewareStartTime = Date.now();
+      const middlewareEvent = {
+        route: entry.path,
+        pathname: initialPathname,
+        name: entry.filePath
+      };
+      emitFarmEvent({ type: "middleware.start", ...middlewareEvent });
+      try {
+        const returnedResponse = await executeHandlers(entry.handlers, ctx);
+        currentRequest = contextState.getRequest();
+        if (returnedResponse) {
+          const response = applyProductionMiddlewareHeaders(
+            returnedResponse,
+            mapToHeaders(ctx.headers)
+          );
+          emitFarmEvent({
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: response.status
+          });
+          return {
+            request: currentRequest,
+            response,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(ctx.headers),
+            handled: true
+          };
+        }
+        if (ctx._handled) {
+          const response = contextState.getResponse() || new Response(null);
+          emitFarmEvent({
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: response.status
+          });
+          return {
+            request: currentRequest,
+            response,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(ctx.headers),
+            handled: true
+          };
+        }
+        emitFarmEvent({
+          type: "middleware.complete",
+          ...middlewareEvent,
+          durationMs: Date.now() - middlewareStartTime
+        });
+      } catch (error) {
+        emitFarmEvent({
+          type: "middleware.error",
+          ...middlewareEvent,
+          error
+        });
+        throw error;
+      }
+      parentData = {
+        data: new Map(ctx.data),
+        locals: new Map(ctx.locals),
+        headers: headersToRecord(ctx.headers)
+      };
+    }
+    return {
+      request: currentRequest,
+      response: null,
+      data: new Map(ctx.data),
+      context: new Map(ctx.locals),
+      headers: mapToHeaders(ctx.headers),
+      handled: false
+    };
+  }, "runProductionMiddleware");
+}
+__name(createProductionMiddlewareRunner, "createProductionMiddlewareRunner");
+function applyProductionMiddlewareHeaders(response, middlewareHeaders) {
+  if (!middlewareHeaders || Array.from(middlewareHeaders.keys()).length === 0) {
+    return response;
+  }
+  const headers = new Headers(response.headers);
+  for (const [key, value] of middlewareHeaders) {
+    if (key.toLowerCase() === "set-cookie") {
+      headers.append(key, value);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+__name(applyProductionMiddlewareHeaders, "applyProductionMiddlewareHeaders");
+
+// src/middleware/vite-plugin.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+function getMiddlewareAppDirectory(root, srcDir) {
+  const sourceDirectory = import_node_path.default.join(root, srcDir);
+  const appDirectory = import_node_path.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) => {
+    manager = new MiddlewareManager(getMiddlewareAppDirectory(server.config.root, srcDir), server);
+    await manager.discover();
+    discoveryComplete = true;
+  }, "discover");
+  return {
+    name: "@farm.js/core:middleware",
+    enforce: "pre",
+    configureServer(server) {
+      discoveryPromise = discover(server).catch((error) => {
+        discoveryComplete = true;
+        console.error("[FARM] Middleware discovery error:", error);
+      });
+      const execute = /* @__PURE__ */ __name(async (req, res, _pathname, sharedData) => {
+        if (discoveryPromise && !discoveryComplete) {
+          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_path.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,
+  _runWithMiddlewareContext,
+  _runWithMiddlewareData,
+  applyProductionMiddlewareHeaders,
+  createContext,
+  createProductionMiddlewareRunner,
+  farmMiddlewarePlugin,
+  getFromMiddleware,
+  getMiddlewareContext,
+  getMiddlewareData,
+  getMiddlewareValue,
+  getRateLimitStatus,
+  hasMiddlewareData,
+  middleware,
+  unwrapMiddleware
+});
+//# sourceMappingURL=middleware.cjs.map