@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-YOZYCI6Z.mjs

@@ -1,73 +0,0 @@
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/optional-peer.ts
-import { createRequire } from "module";
-import path from "path";
-function isMissingPackageError(error, packageName) {
-  let current = error;
-  for (let depth = 0; depth < 4; depth++) {
-    if (!current || typeof current !== "object") return false;
-    const { code, message, cause } = current;
-    if ((code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") && typeof message === "string") {
-      return message.includes(`'${packageName}'`) || message.includes(`"${packageName}"`);
-    }
-    current = cause;
-  }
-  return false;
-}
-__name(isMissingPackageError, "isMissingPackageError");
-function isOptionalPeerInstalled(root, packageName) {
-  const appRequire = createRequire(path.join(root, "package.json"));
-  const requires = [appRequire];
-  try {
-    requires.push(createRequire(appRequire.resolve("@farm.js/core")));
-  } catch {
-  }
-  return requires.some((parentRequire) => {
-    try {
-      parentRequire.resolve(`${packageName}/package.json`);
-      return true;
-    } catch (error) {
-      return error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED";
-    }
-  });
-}
-__name(isOptionalPeerInstalled, "isOptionalPeerInstalled");
-function formatOptionalPeerInstallHint(packageName, purpose, options = {}) {
-  return `Install "${packageName}" to ${purpose}: pnpm add ${options.dev ? "-D " : ""}${packageName}`;
-}
-__name(formatOptionalPeerInstallHint, "formatOptionalPeerInstallHint");
-var VERCEL_OG_INSTALL_HINT = formatOptionalPeerInstallHint(
-  "@vercel/og",
-  "render OG and metadata images"
-);
-var APP_IMPORTED_OPTIONAL_PEERS = [
-  ["@vercel/og", VERCEL_OG_INSTALL_HINT]
-];
-function explainMissingOptionalPeer(error, context) {
-  for (const [packageName, hint] of APP_IMPORTED_OPTIONAL_PEERS) {
-    if (isMissingPackageError(error, packageName)) {
-      return withOptionalPeerCause(
-        new Error(`${context} needs ${packageName}, which is not installed. ${hint}`),
-        error
-      );
-    }
-  }
-  return error;
-}
-__name(explainMissingOptionalPeer, "explainMissingOptionalPeer");
-function withOptionalPeerCause(error, cause) {
-  return Object.assign(error, { cause });
-}
-__name(withOptionalPeerCause, "withOptionalPeerCause");
-
-export {
-  isMissingPackageError,
-  isOptionalPeerInstalled,
-  formatOptionalPeerInstallHint,
-  VERCEL_OG_INSTALL_HINT,
-  explainMissingOptionalPeer,
-  withOptionalPeerCause
-};

package/dist/chunk-YWCYV7QC.cjs

@@ -1,54 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkAI7QMY7Ocjs = require('./chunk-AI7QMY7O.cjs');
-
-
-
-var _chunkZTP3BJG6cjs = require('./chunk-ZTP3BJG6.cjs');
-
-
-var _chunk6IZWX6EScjs = require('./chunk-6IZWX6ES.cjs');
-
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/headers.ts
-function headers() {
-  _chunkZTP3BJG6cjs._assertRequestReadAllowed.call(void 0, "headers()");
-  return new Headers(_chunkZTP3BJG6cjs.getCurrentRequest.call(void 0, ).headers);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, headers, "headers");
-function cookies() {
-  _chunkZTP3BJG6cjs._assertRequestReadAllowed.call(void 0, "cookies()");
-  const cookieHeader = _chunkZTP3BJG6cjs.getCurrentRequest.call(void 0, ).headers.get("cookie") || "";
-  const parsed = _chunkAI7QMY7Ocjs.parseRequestCookieHeader.call(void 0, cookieHeader);
-  return {
-    get(name) {
-      return parsed.find((cookie) => cookie.name === name);
-    },
-    getAll(name) {
-      return name ? parsed.filter((cookie) => cookie.name === name) : [...parsed];
-    },
-    has(name) {
-      return parsed.some((cookie) => cookie.name === name);
-    },
-    toString() {
-      return cookieHeader;
-    },
-    [Symbol.iterator]() {
-      return parsed[Symbol.iterator]();
-    }
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, cookies, "cookies");
-function getCspNonce() {
-  _chunkZTP3BJG6cjs._assertRequestReadAllowed.call(void 0, "getCspNonce()");
-  return _chunk6IZWX6EScjs._resolveCurrentCspNonce.call(void 0, );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getCspNonce, "getCspNonce");
-
-
-
-
-
-exports.headers = headers; exports.cookies = cookies; exports.getCspNonce = getCspNonce;

package/dist/chunk-YX3DBN4M.cjs

@@ -1,18 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/redirect-query.ts
-function appendFarmRedirectQuery(destination, search) {
-  if (!search || search === "?") return destination;
-  const hashIndex = destination.indexOf("#");
-  const pathAndQuery = hashIndex === -1 ? destination : destination.slice(0, hashIndex);
-  if (pathAndQuery.includes("?")) return destination;
-  if (hashIndex === -1) return `${destination}${search}`;
-  return `${pathAndQuery}${search}${destination.slice(hashIndex)}`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, appendFarmRedirectQuery, "appendFarmRedirectQuery");
-
-
-
-exports.appendFarmRedirectQuery = appendFarmRedirectQuery;

package/dist/chunk-YYQVGKO5.mjs

@@ -1,394 +0,0 @@
-import {
-  findProgrammaticRouteFilesInDir
-} from "./chunk-FWCGUVVL.mjs";
-import {
-  isFarmAPIRouteFileName
-} from "./chunk-CU625VAY.mjs";
-import {
-  _runWithFarmI18nRequest
-} from "./chunk-NPC7VWJE.mjs";
-import {
-  explainMissingOptionalPeer
-} from "./chunk-YOZYCI6Z.mjs";
-import {
-  API_ROUTE_METHODS,
-  getAllowedAPIRouteMethods,
-  invokeAPIRouteEndpoint,
-  matchAPIRouteAtBasePath,
-  mergePluginAPIRoutes,
-  resolveAPIRouteEndpoint
-} from "./chunk-VTBXE6QG.mjs";
-import {
-  registerAPIRouteShape
-} from "./chunk-W3B4PKAW.mjs";
-import {
-  createProgrammaticRouteModuleId
-} from "./chunk-KNHBTJP6.mjs";
-import {
-  getFarmRouteRuntimeConfig,
-  normalizeFarmRouteRuntimeConfig
-} from "./chunk-2J7W2WND.mjs";
-import {
-  toFileModuleUrl
-} from "./chunk-7GNWGLWB.mjs";
-import {
-  loadFarmDevModule
-} from "./chunk-QCVIRVHE.mjs";
-import {
-  logger
-} from "./chunk-KI3MESHB.mjs";
-import {
-  AmbiguousRouteError,
-  NonTerminalCatchAllRouteError
-} from "./chunk-55YI3RRB.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/api/route-manager.ts
-import * as fs from "fs";
-import * as path from "path";
-var _APIRouteConflictError = class _APIRouteConflictError extends Error {
-  constructor(routePath, method, existingFile, conflictingFile) {
-    super(
-      `Duplicate API route for ${method.toUpperCase()} ${routePath}: ${existingFile} conflicts with ${conflictingFile}`
-    );
-    this.name = "APIRouteConflictError";
-  }
-};
-__name(_APIRouteConflictError, "APIRouteConflictError");
-var APIRouteConflictError = _APIRouteConflictError;
-var _APIRouteManager = class _APIRouteManager {
-  constructor(appDir, viteServer, options = {}) {
-    this.routes = /* @__PURE__ */ new Map();
-    this.endpointSources = /* @__PURE__ */ new Map();
-    this.routeShapes = /* @__PURE__ */ new Map();
-    this.appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
-    this.viteServer = viteServer;
-    this.plugins = options.plugins ?? [];
-    this.throwOnLoadError = options.throwOnLoadError === true;
-    this.i18n = options.i18n;
-    this.bodySizeLimit = options.bodySizeLimit;
-    this.basePath = options.basePath;
-    this.dispatch = options.dispatch;
-  }
-  /** Every file the current handlers were loaded from: route files and root routes files. */
-  getSourceFiles() {
-    const files = /* @__PURE__ */ new Set();
-    for (const sources of this.endpointSources.values()) {
-      for (const { filePath } of sources.values()) files.add(filePath);
-    }
-    return files;
-  }
-  /**
-   * Discover route.ts files in /app/api and explicit endpoints in root routes.ts
-   */
-  async discoverRoutes() {
-    const previousRoutes = this.routes;
-    const previousEndpointSources = this.endpointSources;
-    const previousRouteShapes = this.routeShapes;
-    this.routes = /* @__PURE__ */ new Map();
-    this.endpointSources = /* @__PURE__ */ new Map();
-    this.routeShapes = /* @__PURE__ */ new Map();
-    try {
-      for (const appDir of this.appDirs) {
-        const apiDir = path.join(appDir, "api");
-        let routeFiles = [];
-        if (fs.existsSync(apiDir)) {
-          routeFiles = this.findRouteFiles(apiDir);
-        }
-        for (const filePath of routeFiles) {
-          await this.loadRoute(filePath, appDir);
-        }
-        await this.loadRootRoutes(appDir);
-        await this.loadProgrammaticApiRoutes(appDir);
-      }
-      this.routes = new Map(
-        mergePluginAPIRoutes([...this.routes.values()], this.plugins, void 0, {
-          bodySizeLimit: this.bodySizeLimit,
-          dispatch: this.dispatch
-        }).map((route) => [route.path, route])
-      );
-    } catch (error) {
-      this.routes = previousRoutes;
-      this.endpointSources = previousEndpointSources;
-      this.routeShapes = previousRouteShapes;
-      throw error;
-    }
-    if (process.env.FARM_VERBOSE) {
-      logger.success(`Discovered ${this.routes.size} API routes`);
-      for (const [routePath, route] of this.routes) {
-        logger.info(`  ${route.methods.join(", ")} ${routePath}`);
-      }
-    }
-  }
-  /**
-   * Recursively find all route.ts files
-   */
-  findRouteFiles(dir) {
-    const files = [];
-    if (!fs.existsSync(dir)) {
-      return files;
-    }
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        files.push(...this.findRouteFiles(fullPath));
-      } else if (isFarmAPIRouteFileName(entry.name)) {
-        files.push(fullPath);
-      }
-    }
-    return files;
-  }
-  /**
-   * Load a route.ts file and extract HTTP method exports
-   */
-  async loadRoute(filePath, appDir) {
-    try {
-      const apiDir = path.join(appDir, "api");
-      const relativePath = path.relative(apiDir, path.dirname(filePath));
-      const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
-      const routeModule = await this.loadModule(filePath);
-      const endpoints = {};
-      const availableMethods = [];
-      for (const method of API_ROUTE_METHODS) {
-        if (routeModule[method]) {
-          endpoints[method] = routeModule[method];
-          availableMethods.push(method);
-        }
-      }
-      if (availableMethods.length > 0) {
-        const existingSources = this.endpointSources.get(routePath);
-        if (existingSources) {
-          for (const method of availableMethods) {
-            const existingSource = existingSources.get(method);
-            if (existingSource?.appDir === appDir) {
-              throw new APIRouteConflictError(routePath, method, existingSource.filePath, filePath);
-            }
-          }
-        }
-        const runtimeConfig = normalizeFarmRouteRuntimeConfig(
-          getFarmRouteRuntimeConfig(routeModule),
-          `API route "${routePath}"`
-        );
-        this.registerRouteShape(routePath, filePath, appDir);
-        const existingRoute = this.routes.get(routePath);
-        const mergedMethods = existingRoute ? [...existingRoute.methods] : [];
-        for (const method of availableMethods) {
-          if (!mergedMethods.includes(method)) mergedMethods.push(method);
-        }
-        this.routes.set(routePath, {
-          ...existingRoute,
-          path: routePath,
-          filePath,
-          methods: mergedMethods,
-          endpoints: { ...existingRoute?.endpoints, ...endpoints },
-          ...runtimeConfig
-        });
-        const nextSources = new Map(existingSources);
-        for (const method of availableMethods) {
-          nextSources.set(method, { appDir, filePath });
-        }
-        this.endpointSources.set(routePath, nextSources);
-      }
-    } catch (error) {
-      this.handleLoadError(`Error loading route ${filePath}`, error);
-    }
-  }
-  /**
-   * Load explicit-path endpoints from src/routes.ts-style files.
-   */
-  async loadRootRoutes(appDir) {
-    const routesFile = this.findRootRoutesFile(appDir);
-    if (!routesFile) {
-      return;
-    }
-    try {
-      const routesModule = await this.loadModule(routesFile);
-      for (const exportValue of Object.values(routesModule)) {
-        const endpoint = exportValue;
-        if (!endpoint?.__path) {
-          continue;
-        }
-        const method = String(endpoint.__method || "GET").toUpperCase();
-        this.registerRouteShape(endpoint.__path, routesFile, appDir);
-        this.addEndpoint(endpoint.__path, routesFile, method, endpoint, appDir);
-      }
-    } catch (error) {
-      this.handleLoadError(`Error loading root API routes ${routesFile}`, error);
-    }
-  }
-  async loadProgrammaticApiRoutes(appDir) {
-    const candidateRoots = [path.dirname(appDir), appDir];
-    const routeFiles = Array.from(
-      new Set(candidateRoots.flatMap((srcRoot) => findProgrammaticRouteFilesInDir(srcRoot)))
-    );
-    if (routeFiles.length === 0) return;
-    const { getProgrammaticRouteManifest } = await import("./routes.mjs");
-    for (const routeFile of routeFiles) {
-      try {
-        const routesModule = await this.loadModule(routeFile);
-        const manifest = getProgrammaticRouteManifest(routesModule);
-        if (!manifest) continue;
-        for (const definition of manifest.routes) {
-          if (definition.kind !== "api") continue;
-          if (!Object.values(definition.methods).some(Boolean)) continue;
-          this.addProgrammaticApiRoute(routeFile, definition, appDir);
-        }
-      } catch (error) {
-        this.handleLoadError(`Error loading programmatic API routes ${routeFile}`, error);
-      }
-    }
-  }
-  handleLoadError(message, loadError) {
-    const error = explainMissingOptionalPeer(loadError, message.replace(/^Error loading /, ""));
-    logger.error(`${message}: ${error}`);
-    if (this.throwOnLoadError || error instanceof APIRouteConflictError || error instanceof AmbiguousRouteError || error instanceof NonTerminalCatchAllRouteError) {
-      throw error;
-    }
-  }
-  findRootRoutesFile(appDir) {
-    const routeNames = ["routes.ts", "routes.tsx", "routes.js"];
-    const candidateDirs = [path.dirname(appDir), appDir];
-    const seen = /* @__PURE__ */ new Set();
-    for (const dir of candidateDirs) {
-      for (const routeName of routeNames) {
-        const routesFile = path.join(dir, routeName);
-        if (seen.has(routesFile)) {
-          continue;
-        }
-        seen.add(routesFile);
-        if (fs.existsSync(routesFile)) {
-          return routesFile;
-        }
-      }
-    }
-    return null;
-  }
-  async loadModule(filePath) {
-    if (this.viteServer) {
-      return await loadFarmDevModule(this.viteServer, filePath);
-    }
-    return await import(
-      /* @vite-ignore */
-      toFileModuleUrl(filePath)
-    );
-  }
-  addEndpoint(routePath, filePath, method, endpoint, appDir, runtimeConfig = {}) {
-    const normalizedMethod = method.toUpperCase();
-    const existingRoute = this.routes.get(routePath);
-    const existingSource = this.endpointSources.get(routePath)?.get(normalizedMethod);
-    if (existingSource?.appDir === appDir) {
-      throw new APIRouteConflictError(
-        routePath,
-        normalizedMethod,
-        existingSource.filePath,
-        filePath
-      );
-    }
-    if (existingRoute) {
-      if (!existingRoute.methods.includes(normalizedMethod)) {
-        existingRoute.methods.push(normalizedMethod);
-      }
-      existingRoute.endpoints[normalizedMethod] = endpoint;
-      Object.assign(existingRoute, runtimeConfig);
-      const sources = this.endpointSources.get(routePath) ?? /* @__PURE__ */ new Map();
-      sources.set(normalizedMethod, { appDir, filePath });
-      this.endpointSources.set(routePath, sources);
-      return;
-    }
-    this.routes.set(routePath, {
-      path: routePath,
-      filePath,
-      methods: [normalizedMethod],
-      endpoints: { [normalizedMethod]: endpoint },
-      ...runtimeConfig
-    });
-    this.endpointSources.set(routePath, /* @__PURE__ */ new Map([[normalizedMethod, { appDir, filePath }]]));
-  }
-  addProgrammaticApiRoute(filePath, route, appDir) {
-    const modulePath = createProgrammaticRouteModuleId(filePath, "api", route.path);
-    const runtimeConfig = normalizeFarmRouteRuntimeConfig(route, `API route "${route.path}"`);
-    for (const [method, endpoint] of Object.entries(route.methods)) {
-      if (endpoint) {
-        this.addEndpoint(route.path, modulePath, method, endpoint, appDir, runtimeConfig);
-      }
-    }
-  }
-  registerRouteShape(routePath, filePath, appDir) {
-    const replacedPath = registerAPIRouteShape(this.routeShapes, routePath, filePath, appDir);
-    if (replacedPath) {
-      this.routes.delete(replacedPath);
-      this.endpointSources.delete(replacedPath);
-    }
-  }
-  /**
-   * Get the handler that directly invokes endpoint handlers
-   */
-  getHandler(options = {}) {
-    if (this.routes.size === 0) {
-      return null;
-    }
-    return async (request) => {
-      const url = new URL(request.url);
-      const pathname = url.pathname;
-      const method = request.method.toUpperCase();
-      const match = matchAPIRouteAtBasePath(this.routes, pathname, this.basePath);
-      if (!match) {
-        return new Response(JSON.stringify({ error: "Not Found" }), {
-          status: 404,
-          headers: { "Content-Type": "application/json" }
-        });
-      }
-      const { route, params } = match;
-      const endpoint = resolveAPIRouteEndpoint(route, method);
-      if (!endpoint) {
-        return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
-          status: 405,
-          headers: {
-            Allow: getAllowedAPIRouteMethods(route).join(", "),
-            "Content-Type": "application/json"
-          }
-        });
-      }
-      const invoke = /* @__PURE__ */ __name(async () => {
-        try {
-          return await invokeAPIRouteEndpoint(endpoint, request, params, this.bodySizeLimit);
-        } catch (error) {
-          if (options.throwOnError) throw error;
-          console.error(`[API Error] ${pathname}:`, error);
-          return new Response(JSON.stringify({ error: "Internal Server Error" }), {
-            status: 500,
-            headers: { "Content-Type": "application/json" }
-          });
-        }
-      }, "invoke");
-      return this.i18n?.config.enabled ? _runWithFarmI18nRequest(this.i18n, request, invoke, {
-        redirect: false
-      }) : invoke();
-    };
-  }
-  /**
-   * Check if a path is an API route
-   */
-  isAPIRoute(pathname) {
-    return Boolean(this.matchRoute(pathname));
-  }
-  matchRoute(pathname) {
-    return matchAPIRouteAtBasePath(this.routes, pathname, this.basePath);
-  }
-  /**
-   * Get all routes for client type generation
-   */
-  getRoutes() {
-    return this.routes;
-  }
-};
-__name(_APIRouteManager, "APIRouteManager");
-var APIRouteManager = _APIRouteManager;
-
-export {
-  APIRouteConflictError,
-  APIRouteManager
-};

package/dist/chunk-YZAKIXRL.cjs

@@ -1,67 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/middleware/server.ts
-var _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 _async_hooks.AsyncLocalStorage) {
-    return existing;
-  }
-  const store = new (0, _async_hooks.AsyncLocalStorage)();
-  state[key] = store;
-  return store;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, toMiddlewareMap, "toMiddlewareMap");
-function _clearCurrentMiddlewareData() {
-  middlewareStore.enterWith(/* @__PURE__ */ new Map());
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, _clearCurrentMiddlewareData, "_clearCurrentMiddlewareData");
-function _clearCurrentMiddlewareContext() {
-  middlewareContextStore.enterWith(/* @__PURE__ */ new Map());
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, _clearCurrentMiddlewareContext, "_clearCurrentMiddlewareContext");
-async function _runWithMiddlewareData(data, fn) {
-  return middlewareStore.run(toMiddlewareMap(data), fn);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithMiddlewareData, "_runWithMiddlewareData");
-async function _runWithMiddlewareContext(context, fn) {
-  return middlewareContextStore.run(toMiddlewareMap(context), fn);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithMiddlewareContext, "_runWithMiddlewareContext");
-function getMiddlewareData() {
-  return middlewareStore.getStore() || /* @__PURE__ */ new Map();
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareData, "getMiddlewareData");
-function getMiddlewareValue(key) {
-  const data = getMiddlewareData();
-  return data.get(key);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareValue, "getMiddlewareValue");
-function getMiddlewareContext() {
-  return middlewareContextStore.getStore() || /* @__PURE__ */ new Map();
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareContext, "getMiddlewareContext");
-
-
-
-
-
-
-
-
-
-exports._clearCurrentMiddlewareData = _clearCurrentMiddlewareData; exports._clearCurrentMiddlewareContext = _clearCurrentMiddlewareContext; exports._runWithMiddlewareData = _runWithMiddlewareData; exports._runWithMiddlewareContext = _runWithMiddlewareContext; exports.getMiddlewareData = getMiddlewareData; exports.getMiddlewareValue = getMiddlewareValue; exports.getMiddlewareContext = getMiddlewareContext;