@mionjs/router 0.8.8 → 0.13.0

package/.dist/cjs/src/router.cjs

@@ -1,482 +1,556 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const src_constants = require("./constants.cjs");
-const src_types_guards = require("./types/guards.cjs");
-const core = require("@mionjs/core");
-const src_lib_reflection = require("./lib/reflection.cjs");
-const src_routes_serializer_routes = require("./routes/serializer.routes.cjs");
-const src_lib_remoteMethods = require("./lib/remoteMethods.cjs");
-const src_lib_methodsCache = require("./lib/methodsCache.cjs");
-const src_routes_client_routes = require("./routes/client.routes.cjs");
-const src_routes_errors_routes = require("./routes/errors.routes.cjs");
-const src_routesFlow = require("./routesFlow.cjs");
-const src_callContext = require("./callContext.cjs");
-const mionInternalRoutes = Object.values(core.MION_ROUTES);
-const flatRouter = /* @__PURE__ */ new Map();
-const middleFnsById = /* @__PURE__ */ new Map();
-const routesById = /* @__PURE__ */ new Map();
-const rawMiddleFnsById = /* @__PURE__ */ new Map();
-const middleFnNames = /* @__PURE__ */ new Set();
-const routeNames = /* @__PURE__ */ new Set();
-let complexity = 0;
-let routerOptions = { ...src_constants.DEFAULT_ROUTE_OPTIONS };
-let isRouterInitialized = false;
-let allExecutablesIds;
-let platformConfig;
-const defaultStartMiddleFns = {
-  mionDeserializeRequest: src_routes_serializer_routes.serializerMiddleFns.mionDeserializeRequest
-};
-const defaultEndMiddleFns = {
-  ...src_routes_client_routes.mionClientMiddleFns,
-  mionSerializeResponse: src_routes_serializer_routes.serializerMiddleFns.mionSerializeResponse
-};
-let startMiddleFnsDef = { ...defaultStartMiddleFns };
-let endMiddleFnsDef = { ...defaultEndMiddleFns };
-exports.startMiddleFns = [];
-exports.endMiddleFns = [];
-const getRouteExecutionChain = (path) => flatRouter.get(path);
-const getRouteEntries = () => flatRouter.entries();
-const geRoutesSize = () => flatRouter.size;
-const getRouteExecutable = (id) => routesById.get(id);
-const getMiddleFnExecutable = (id) => middleFnsById.get(id);
-const geMiddleFnsSize = () => middleFnsById.size;
-const getComplexity = () => complexity;
-const getRouterOptions = () => routerOptions;
-const getAnyExecutable = (id) => routesById.get(id) || middleFnsById.get(id) || rawMiddleFnsById.get(id);
+const require_src_types_guards = require("./types/guards.cjs");
+const require_src_constants = require("./constants.cjs");
+const require_src_lib_reflection = require("./lib/reflection.cjs");
+const require_src_lib_bodyLimit = require("./lib/bodyLimit.cjs");
+const require_src_batches = require("./batches.cjs");
+const require_src_dispatch = require("./dispatch.cjs");
+const require_src_lib_handlers = require("./lib/handlers.cjs");
+const require_src_routes_serializer_routes = require("./routes/serializer.routes.cjs");
+const require_src_lib_remoteMethods = require("./lib/remoteMethods.cjs");
+const require_src_routes_errors_routes = require("./routes/errors.routes.cjs");
+let _mionjs_core = require("@mionjs/core");
+//#region src/router.ts
+var flatRouter = (0, _mionjs_core.getOrCreateGlobal)("mion.router.flatRouter", () => /* @__PURE__ */ new Map());
+/** mion's two not-found chains (an unknown path, an unknown batch id) are NOT routes and not in the
+*  router above: each is the global middleware behind a first member that throws, and is rebuilt on
+*  every registration because that middleware is. */
+var notFoundChains = (0, _mionjs_core.getOrCreateGlobal)("mion.router.notFoundChains", () => /* @__PURE__ */ new Map());
+var middlewaresById = (0, _mionjs_core.getOrCreateGlobal)("mion.router.middlewaresById", () => /* @__PURE__ */ new Map());
+var routesById = (0, _mionjs_core.getOrCreateGlobal)("mion.router.routesById", () => /* @__PURE__ */ new Map());
+var rawMiddlewaresById = (0, _mionjs_core.getOrCreateGlobal)("mion.router.rawMiddlewaresById", () => /* @__PURE__ */ new Map());
+var middlewareNames = (0, _mionjs_core.getOrCreateGlobal)("mion.router.middlewareNames", () => /* @__PURE__ */ new Set());
+var routeNames = (0, _mionjs_core.getOrCreateGlobal)("mion.router.routeNames", () => /* @__PURE__ */ new Set());
+var complexity = 0;
+var routerOptions = { ...require_src_constants.DEFAULT_ROUTE_OPTIONS };
+var isRouterInitialized = false;
+var isRouterCreated = false;
+var allExecutablesIds;
+var platformConfig;
+/** Merged by initRouter, read per request. */
+var responseDefaults = mergeResponseDefaults({});
+/** Sent by mionFetchMetadata; unset with `apiVersionCheck` off, a pinned header or no build version. */
+var buildVersion;
+/** The adapter's `maxBodySize` under its `maxBodySizeCap`, settled by setPlatformConfig (the default with no adapter). */
+var platformMaxBodySize = _mionjs_core.DEFAULT_MAX_BODY_SIZE;
+/** Run before and after every middleware or route set through `mion.initRoutes` */
+var defaultStartMiddlewares = { mionDeserializeRequest: require_src_routes_serializer_routes.serializerMiddlewares.mionDeserializeRequest };
+var defaultEndMiddlewares = { mionSerializeResponse: require_src_routes_serializer_routes.serializerMiddlewares.mionSerializeResponse };
+var startMiddlewaresDef = { ...defaultStartMiddlewares };
+var endMiddlewaresDef = { ...defaultEndMiddlewares };
+var startMiddlewares = [];
+var endMiddlewares = [];
+var getRouteExecutionChain = (path) => flatRouter.get(path);
+/** The chain that answers an unknown path or an unknown batch id, by its `MION_ROUTES` id. */
+var getNotFoundExecutionChain = (id) => notFoundChains.get(id);
+var getRouteEntries = () => flatRouter.entries();
+var geRoutesSize = () => flatRouter.size;
+var getRouteExecutable = (id) => routesById.get(id);
+var getMiddlewareExecutable = (id) => middlewaresById.get(id);
+var getMiddlewaresSize = () => middlewaresById.size;
+var getComplexity = () => complexity;
+var getRouterOptions = () => routerOptions;
+/** The version mionFetchMetadata sends in `x-build-version`. */
+var getBuildVersion = () => buildVersion;
+/** The headers every response starts with: every adapter reads it per request. */
+var getResponseDefaults = () => responseDefaults;
+var getAnyExecutable = (id) => routesById.get(id) || middlewaresById.get(id) || rawMiddlewaresById.get(id);
+/** Called automatically by platform adapters: the adapter's `maxBodySize` and `maxBodySizeCap` are
+*  settled here, once, so no request reads the config. */
 function setPlatformConfig(config) {
-  platformConfig = config;
-  if (core.isMionAOTEmitMode() && typeof process.send === "function") {
-    const routerConfig = Object.fromEntries(Object.entries(routerOptions).filter(([, v]) => typeof v !== "function"));
-    try {
-      process.send({ type: "mion-platform-ready", routerConfig, platformConfig: config });
-    } catch (err) {
-      console.error("[mion] Failed to send platform-ready IPC:", err);
-    }
-  }
+	platformConfig = config;
+	const published = config.maxBodySize;
+	platformMaxBodySize = Math.min(typeof published === "number" ? published : _mionjs_core.DEFAULT_MAX_BODY_SIZE, readMaxBodySizeCap(config) ?? Infinity);
+	if (isRouterInitialized) applyMaxBodySizeCap();
+	refreshChainBodyLimits();
+}
+var getPlatformConfig = () => platformConfig;
+var devHost = (0, _mionjs_core.getOrCreateGlobal)("mion.router.devHost", () => ({
+	ownsSocket: false,
+	handler: void 0
+}));
+/** Set by a dev host that owns the socket (the mion vite plugin) BEFORE it loads the server entry, so whatever
+*  platform adapter the entry starts registers its routes and hands over its handler instead of listening. */
+function setHostOwnsSocket(ownsSocket) {
+	devHost.ownsSocket = ownsSocket;
+	if (!ownsSocket) devHost.handler = void 0;
+}
+var hostOwnsSocket = () => devHost.ownsSocket;
+/** Every platform adapter calls it on start; true means a dev host owns the socket and the adapter must not listen. */
+function handOverToHost(handler) {
+	if (devHost.ownsSocket) devHost.handler = handler;
+	return devHost.ownsSocket;
 }
-const getPlatformConfig = () => platformConfig;
-const resetRouter = () => {
-  flatRouter.clear();
-  middleFnsById.clear();
-  routesById.clear();
-  rawMiddleFnsById.clear();
-  middleFnNames.clear();
-  routeNames.clear();
-  complexity = 0;
-  routerOptions = { ...src_constants.DEFAULT_ROUTE_OPTIONS };
-  startMiddleFnsDef = { ...defaultStartMiddleFns };
-  endMiddleFnsDef = { ...defaultEndMiddleFns };
-  exports.startMiddleFns = [];
-  exports.endMiddleFns = [];
-  isRouterInitialized = false;
-  allExecutablesIds = void 0;
-  platformConfig = void 0;
-  src_lib_remoteMethods.resetRemoteMethodsMetadata();
-  src_lib_methodsCache.resetPersistedMethods();
-  core.resetRoutesCache();
-  src_callContext.clearContextPool();
-  src_routesFlow.clearRoutesFlowCache();
+var getHostRequestHandler = () => devHost.handler;
+var resetRouter = () => {
+	flatRouter.clear();
+	notFoundChains.clear();
+	middlewaresById.clear();
+	routesById.clear();
+	rawMiddlewaresById.clear();
+	middlewareNames.clear();
+	routeNames.clear();
+	complexity = 0;
+	routerOptions = { ...require_src_constants.DEFAULT_ROUTE_OPTIONS };
+	startMiddlewaresDef = { ...defaultStartMiddlewares };
+	endMiddlewaresDef = { ...defaultEndMiddlewares };
+	startMiddlewares = [];
+	endMiddlewares = [];
+	isRouterInitialized = false;
+	isRouterCreated = false;
+	allExecutablesIds = void 0;
+	platformConfig = void 0;
+	responseDefaults = mergeResponseDefaults({});
+	buildVersion = void 0;
+	platformMaxBodySize = _mionjs_core.DEFAULT_MAX_BODY_SIZE;
+	require_src_lib_remoteMethods.resetRemoteMethodsMetadata();
+	(0, _mionjs_core.resetRoutesCache)();
+	require_src_batches.clearBatches();
 };
-async function initMionRouter(routes, opts) {
-  await initRouter(opts);
-  const publicApi = await registerRoutes(routes);
-  await emitAOTCaches();
-  return publicApi;
+/** The ONE way to initialize the router and to declare routes and middlewares: the options are written once
+*  and carried BY TYPE into every helper the factory returns, so a handler's `ctx.shared` is typed from
+*  `contextDataFactory` and router-wide defaults can be read at build time. The helpers are plain closures
+*  (no `this`), so destructuring them is fine. Create the router once per app: a second call throws until
+*  `resetRouter()` (tests) clears it. */
+function createMionRouter(opts) {
+	if (isRouterCreated) throw new Error("createMionRouter has already been called: create the router once per app (resetRouter() clears it in tests)");
+	isRouterCreated = true;
+	const options = Object.freeze({ ...opts });
+	return {
+		options,
+		route: require_src_lib_handlers.route,
+		query: require_src_lib_handlers.query,
+		mutation: require_src_lib_handlers.mutation,
+		middleware: require_src_lib_handlers.middleware,
+		headersMiddleware: require_src_lib_handlers.headersMiddleware,
+		rawMiddleware: require_src_lib_handlers.rawMiddleware,
+		initRoutes(routes, buildVersion) {
+			initRouter(options, buildVersion);
+			const api = registerRoutes(routes);
+			if (platformConfig) applyMaxBodySizeCap();
+			refreshChainBodyLimits();
+			return api;
+		}
+	};
 }
-async function initRouter(opts) {
-  if (isRouterInitialized) throw new Error("Router has already been initialized");
-  routerOptions = { ...routerOptions, ...opts };
-  validateSharedDataFactory(routerOptions);
-  Object.freeze(routerOptions);
-  core.setErrorOptions(routerOptions);
-  if (routerOptions.aot) await loadAOTCaches();
-  isRouterInitialized = true;
-  await registerRoutes({ ...src_routes_errors_routes.mionErrorsRoutes });
-  if (!routerOptions.skipClientRoutes) await registerRoutes({ ...src_routes_client_routes.mionClientRoutes });
-  if (!core.isTestEnv()) console.log("mion router initialized", { routerOptions });
-  return routerOptions;
+/** Once per app; `resetRouter()` clears it. */
+function initRouter(opts, version) {
+	if (isRouterInitialized) throw new Error("Router has already been initialized");
+	routerOptions = {
+		...routerOptions,
+		...opts
+	};
+	responseDefaults = mergeResponseDefaults(routerOptions.responseHeaders);
+	const isPinned = responseDefaults[_mionjs_core.BUILD_VERSION_HEADER] !== void 0;
+	buildVersion = routerOptions.apiVersionCheck && !isPinned && version || void 0;
+	validateSharedDataFactory(routerOptions);
+	Object.freeze(routerOptions);
+	(0, _mionjs_core.setErrorOptions)(routerOptions);
+	isRouterInitialized = true;
+	registerRoutes({ ...require_src_routes_errors_routes.mionErrorsRoutes });
+	if (!(0, _mionjs_core.isTestEnv)()) console.log("mion router initialized", { routerOptions });
 }
-async function registerRoutes(routes) {
-  if (!isRouterInitialized) throw new Error("initRouter should be called first");
-  exports.startMiddleFns = await getExecutablesFromMiddleFnsCollection(startMiddleFnsDef);
-  exports.endMiddleFns = await getExecutablesFromMiddleFnsCollection(endMiddleFnsDef);
-  const binaryMiddlewares = /* @__PURE__ */ new Set();
-  await recursiveFlatRoutes(routes, [], [], [], binaryMiddlewares, 0);
-  if (binaryMiddlewares.size > 0) await compileBinaryForMiddleware(binaryMiddlewares);
-  if (shouldFullGenerateSpec()) {
-    return src_lib_remoteMethods.getPublicApi(routes);
-  }
-  return {};
+function registerRoutes(routes) {
+	if (!isRouterInitialized) throw new Error("the router must be initialized first");
+	startMiddlewares = getExecutablesFromMiddlewaresCollection(startMiddlewaresDef);
+	endMiddlewares = getExecutablesFromMiddlewaresCollection(endMiddlewaresDef);
+	recursiveFlatRoutes(routes, [], [], [], 0);
+	buildNotFoundChains();
+	allExecutablesIds = void 0;
+	if (shouldFullGenerateSpec()) return require_src_lib_remoteMethods.getPublicApi(routes);
+	return {};
 }
-function addStartMiddleFns(middleFnsDef, appendBeforeExisting = true) {
-  if (isRouterInitialized) throw new Error("Can not add start middleFns after the router has been initialized");
-  if (appendBeforeExisting) {
-    startMiddleFnsDef = { ...middleFnsDef, ...startMiddleFnsDef };
-    return;
-  }
-  startMiddleFnsDef = { ...startMiddleFnsDef, ...middleFnsDef };
+/** Adds middlewares at the start of the ExecutionChain, before the existing start middlewares by default */
+function addStartMiddlewares(middlewaresDef, appendBeforeExisting = true) {
+	if (isRouterInitialized) throw new Error("Can not add start middlewares after the router has been initialized");
+	if (appendBeforeExisting) {
+		startMiddlewaresDef = {
+			...middlewaresDef,
+			...startMiddlewaresDef
+		};
+		return;
+	}
+	startMiddlewaresDef = {
+		...startMiddlewaresDef,
+		...middlewaresDef
+	};
 }
-function addEndMiddleFns(middleFnsDef, prependAfterExisting = true) {
-  if (isRouterInitialized) throw new Error("Can not add end middleFns after the router has been initialized");
-  if (prependAfterExisting) {
-    endMiddleFnsDef = { ...endMiddleFnsDef, ...middleFnsDef };
-    return;
-  }
-  endMiddleFnsDef = { ...middleFnsDef, ...endMiddleFnsDef };
+/** Adds middlewares at the end of the ExecutionChain, after the existing end middlewares by default */
+function addEndMiddlewares(middlewaresDef, prependAfterExisting = true) {
+	if (isRouterInitialized) throw new Error("Can not add end middlewares after the router has been initialized");
+	if (prependAfterExisting) {
+		endMiddlewaresDef = {
+			...endMiddlewaresDef,
+			...middlewaresDef
+		};
+		return;
+	}
+	endMiddlewaresDef = {
+		...middlewaresDef,
+		...endMiddlewaresDef
+	};
 }
 function isPrivateDefinition(entry, id) {
-  if (src_types_guards.isRoute(entry)) return false;
-  if (src_types_guards.isRawMiddleFnDef(entry)) return true;
-  try {
-    const executable = getMiddleFnExecutable(id) || getRouteExecutable(id);
-    if (!executable)
-      throw new Error(`Route or MiddleFn ${id} not found. Please check you have called router.registerRoutes first.`);
-    return isPrivateExecutable(executable);
-  } catch {
-    return false;
-  }
-}
-function isPrivateExecutable(executable) {
-  if (executable.type === core.HandlerType.rawMiddleFn) return true;
-  if (executable.type === core.HandlerType.route) return false;
-  const hasPublicParams = !!executable.paramNames?.length;
-  const hasHeaderParams = !!executable.headersParam?.headerNames?.length;
-  return !hasPublicParams && !hasHeaderParams && !executable.hasReturnData;
+	if (require_src_types_guards.isRoute(entry)) return false;
+	if (require_src_types_guards.isRawMiddlewareDef(entry)) return true;
+	try {
+		const executable = getMiddlewareExecutable(id) || getRouteExecutable(id);
+		if (!executable) throw new Error(`Route or Middleware ${id} not found. Please check you have called mion.initRoutes first.`);
+		return !require_src_types_guards.isPublicExecutable(executable);
+	} catch {
+		return false;
+	}
 }
 function getTotalExecutables() {
-  return routesById.size + middleFnsById.size + rawMiddleFnsById.size;
+	return routesById.size + middlewaresById.size + rawMiddlewaresById.size;
 }
 function getAllExecutablesIds() {
-  if (allExecutablesIds) return allExecutablesIds;
-  allExecutablesIds = [...routesById.keys(), ...middleFnsById.keys(), ...rawMiddleFnsById.keys()];
-  return allExecutablesIds;
+	if (allExecutablesIds) return allExecutablesIds;
+	allExecutablesIds = [
+		...routesById.keys(),
+		...middlewaresById.keys(),
+		...rawMiddlewaresById.keys()
+	];
+	return allExecutablesIds;
 }
 function shouldFullGenerateSpec() {
-  return routerOptions.getPublicRoutesData || core.getENV("GENERATE_ROUTER_SPEC") === "true" || core.isMionCompileMode();
-}
-function getRouteExecutableFromPath(path) {
-  const executionChain = flatRouter.get(path);
-  if (!executionChain) {
-    return getAnyExecutable(core.MION_ROUTES.notFound);
-  }
-  return executionChain.methods[executionChain.routeIndex];
-}
-async function loadAOTCaches() {
-  const loader = await Promise.resolve().then(() => require("./aot/aotCacheLoader.cjs"));
-  return loader.loadRouterAOTCaches();
+	return routerOptions.getPublicRoutesData || (0, _mionjs_core.getENV)("GENERATE_ROUTER_SPEC") === "true";
 }
-async function emitAOTCaches() {
-  if (!core.isMionAOTEmitMode()) return;
-  const aotEmitter = await Promise.resolve().then(() => require("./lib/aotEmitter.cjs"));
-  return aotEmitter.emitAOTCaches();
+/** Flattens the routes object into a list of Executable objects. `currentPointer` is the position in that
+*  object (i.e. ['users', 'get']); `preMiddlewares` / `postMiddlewares` are the middlewares one level up, before
+*  and after that position. */
+function recursiveFlatRoutes(routes, currentPointer = [], preMiddlewares = [], postMiddlewares = [], nestLevel = 0) {
+	if (nestLevel > 10) throw new Error("Too many nested routes, you can only nest routes ${MAX_ROUTE_NESTING} levels");
+	const entries = Object.entries(routes);
+	if (entries.length === 0) throw new Error(`Invalid route: ${currentPointer.length ? joinPath(...currentPointer) : "*"}. Can Not define empty routes`);
+	let minus1Props = null;
+	for (let index = 0; index < entries.length; index++) {
+		const [key, item] = entries[index];
+		const newPointer = [...currentPointer, key];
+		let routeEntry;
+		if (typeof key !== "string" || !isNaN(key)) throw new Error(`Invalid route: ${joinPath(...newPointer)}. Numeric route names are not allowed`);
+		if (key.includes(",")) throw new Error(`Invalid route: ${joinPath(...newPointer)}. Route names cannot contain commas.`);
+		if ((0, _mionjs_core.isUnsafePropertyName)(key)) throw new Error(`Invalid route: ${joinPath(...newPointer)}. '${key}' is not a valid route name.`);
+		if (key === _mionjs_core.MION_BATCH_KEY) throw new Error(`Invalid route: ${joinPath(...newPointer)}. '${_mionjs_core.MION_BATCH_KEY}' is a reserved mion route name.`);
+		if (require_src_types_guards.isAnyMiddlewareDef(item)) {
+			if (nestLevel === 0 && (Object.hasOwn(startMiddlewaresDef, key) || Object.hasOwn(endMiddlewaresDef, key))) throw new Error(`Invalid middleware: ${joinPath(...newPointer)}. '${key}' is a reserved mion middleware name.`);
+			if (require_src_lib_handlers.isOnDemandMiddleware(item) && (nestLevel !== 0 || entries.slice(0, index).some(([, entry]) => !require_src_types_guards.isAnyMiddlewareDef(entry)))) throw new Error(`Invalid middleware: ${joinPath(...newPointer)}. Place '${key}' at the root of your routes, before any route or group.`);
+			routeEntry = getExecutableFromAnyMiddleware(item, newPointer, nestLevel);
+			if (middlewareNames.has(routeEntry.id)) throw new Error(`Invalid middleware: ${joinPath(...newPointer)}. Naming collision, duplicated middleware.`);
+			middlewareNames.add(routeEntry.id);
+		} else if (require_src_types_guards.isRoute(item)) {
+			routeEntry = getExecutableFromRoute(item, newPointer, nestLevel);
+			if (routeNames.has(routeEntry.id)) throw new Error(`Invalid route: ${joinPath(...newPointer)}. Naming collision, duplicated route`);
+			routeNames.add(routeEntry.id);
+		} else if (require_src_types_guards.isRoutes(item)) routeEntry = {
+			pathPointer: newPointer,
+			routes: item
+		};
+		else {
+			const itemType = typeof item;
+			throw new Error(`Invalid route: ${joinPath(...newPointer)}. Type <${itemType}> is not a valid route.`);
+		}
+		minus1Props = recursiveCreateExecutionChain(routeEntry, newPointer, preMiddlewares, postMiddlewares, nestLevel, index, entries, minus1Props);
+		complexity++;
+	}
 }
-async function recursiveFlatRoutes(routes, currentPointer = [], preMiddleFns = [], postMiddleFns = [], binaryMiddlewares = /* @__PURE__ */ new Set(), nestLevel = 0) {
-  if (nestLevel > src_constants.MAX_ROUTE_NESTING)
-    throw new Error("Too many nested routes, you can only nest routes ${MAX_ROUTE_NESTING} levels");
-  const entries = Object.entries(routes);
-  if (entries.length === 0)
-    throw new Error(
-      `Invalid route: ${currentPointer.length ? joinPath(...currentPointer) : "*"}. Can Not define empty routes`
-    );
-  let minus1Props = null;
-  for (let index = 0; index < entries.length; index++) {
-    const [key, item] = entries[index];
-    const newPointer = [...currentPointer, key];
-    let routeEntry;
-    if (typeof key !== "string" || !isNaN(key))
-      throw new Error(`Invalid route: ${joinPath(...newPointer)}. Numeric route names are not allowed`);
-    if (key.includes(",")) throw new Error(`Invalid route: ${joinPath(...newPointer)}. Route names cannot contain commas.`);
-    if (key === src_constants.WORKFLOW_KEY)
-      throw new Error(`Invalid route: ${joinPath(...newPointer)}. '${src_constants.WORKFLOW_KEY}' is a reserved mion route name.`);
-    if (src_types_guards.isAnyMiddleFnDef(item)) {
-      routeEntry = await getExecutableFromAnyMiddleFn(item, newPointer, nestLevel);
-      if (middleFnNames.has(routeEntry.id))
-        throw new Error(
-          `Invalid middleFn: ${joinPath(...newPointer)}. Naming collision, Naming collision, duplicated middleFn.`
-        );
-      middleFnNames.add(routeEntry.id);
-    } else if (src_types_guards.isRoute(item)) {
-      routeEntry = await getExecutableFromRoute(item, newPointer, nestLevel);
-      if (routeNames.has(routeEntry.id))
-        throw new Error(`Invalid route: ${joinPath(...newPointer)}. Naming collision, duplicated route`);
-      routeNames.add(routeEntry.id);
-    } else if (src_types_guards.isRoutes(item)) {
-      routeEntry = {
-        pathPointer: newPointer,
-        routes: item
-      };
-    } else {
-      const itemType = typeof item;
-      throw new Error(`Invalid route: ${joinPath(...newPointer)}. Type <${itemType}> is not a valid route.`);
-    }
-    minus1Props = await recursiveCreateExecutionChain(
-      routeEntry,
-      newPointer,
-      preMiddleFns,
-      postMiddleFns,
-      binaryMiddlewares,
-      nestLevel,
-      index,
-      entries,
-      minus1Props
-    );
-    complexity++;
-  }
+function recursiveCreateExecutionChain(routeEntry, currentPointer, preMiddlewares, postMiddlewares, nestLevel, index, routeKeyedEntries, minus1Props) {
+	const props = getRouteEntryProperties(getEntry(index - 1, routeKeyedEntries), routeEntry, getEntry(index + 1, routeKeyedEntries));
+	if (props.isBetweenRoutes && minus1Props) {
+		props.preLevelMiddlewares = minus1Props.preLevelMiddlewares;
+		props.postLevelMiddlewares = minus1Props.postLevelMiddlewares;
+	} else for (let i = 0; i < routeKeyedEntries.length; i++) {
+		const [k, entry] = routeKeyedEntries[i];
+		complexity++;
+		if (!require_src_types_guards.isAnyMiddlewareDef(entry)) continue;
+		const executable = getExecutableFromAnyMiddleware(entry, [...currentPointer.slice(0, -1), k], nestLevel);
+		if (i < index) props.preLevelMiddlewares.push(executable);
+		if (i > index) props.postLevelMiddlewares.push(executable);
+	}
+	const isExec = require_src_types_guards.isExecutable(routeEntry);
+	if (isExec && props.isRoute) {
+		const path = (0, _mionjs_core.getRoutePath)(routeEntry.pointer, routerOptions);
+		const routeMethod = routeEntry;
+		const levelMethods = [
+			...preMiddlewares,
+			...props.preLevelMiddlewares,
+			routeEntry,
+			...props.postLevelMiddlewares,
+			...postMiddlewares
+		];
+		const methods = [
+			...startMiddlewares,
+			...levelMethods,
+			...endMiddlewares
+		];
+		const maxBodySize = require_src_lib_handlers.mionInternalRouteIds.has(routeMethod.id) ? routeMethod.options.maxBodySize : require_src_lib_bodyLimit.resolveChainMaxBodySize(methods, routeMethod, routerOptions);
+		if (maxBodySize !== void 0) routeMethod.options.maxBodySize = maxBodySize;
+		const executionChain = {
+			routeIndex: startMiddlewares.length + preMiddlewares.length + props.preLevelMiddlewares.length,
+			methods,
+			path,
+			declaredBodySize: maxBodySize,
+			maxBodySize: maxBodySize ?? platformMaxBodySize,
+			readsBody: true
+		};
+		const middlewareIds = getPublicMiddlewareIds(levelMethods);
+		if (middlewareIds.length) routeMethod.middlewareIds = middlewareIds;
+		flatRouter.set(path, executionChain);
+	} else if (!isExec) recursiveFlatRoutes(routeEntry.routes, routeEntry.pathPointer, [...preMiddlewares, ...props.preLevelMiddlewares], [...props.postLevelMiddlewares, ...postMiddlewares], nestLevel + 1);
+	return props;
 }
-async function recursiveCreateExecutionChain(routeEntry, currentPointer, preMiddleFns, postMiddleFns, binaryMiddlewares, nestLevel, index, routeKeyedEntries, minus1Props) {
-  const minus1 = getEntry(index - 1, routeKeyedEntries);
-  const plus1 = getEntry(index + 1, routeKeyedEntries);
-  const props = getRouteEntryProperties(minus1, routeEntry, plus1);
-  if (props.isBetweenRoutes && minus1Props) {
-    props.preLevelMiddleFns = minus1Props.preLevelMiddleFns;
-    props.postLevelMiddleFns = minus1Props.postLevelMiddleFns;
-  } else {
-    for (let i = 0; i < routeKeyedEntries.length; i++) {
-      const [k, entry] = routeKeyedEntries[i];
-      complexity++;
-      if (!src_types_guards.isAnyMiddleFnDef(entry)) continue;
-      const newPointer = [...currentPointer.slice(0, -1), k];
-      const executable = await getExecutableFromAnyMiddleFn(entry, newPointer, nestLevel);
-      if (i < index) props.preLevelMiddleFns.push(executable);
-      if (i > index) props.postLevelMiddleFns.push(executable);
-    }
-  }
-  const isExec = src_types_guards.isExecutable(routeEntry);
-  if (isExec && props.isRoute) {
-    const path = core.getRoutePath(routeEntry.pointer, routerOptions);
-    const routeMethod = routeEntry;
-    const levelMethods = [
-      ...preMiddleFns,
-      ...props.preLevelMiddleFns,
-      routeEntry,
-      ...props.postLevelMiddleFns,
-      ...postMiddleFns
-    ];
-    const methods = [...exports.startMiddleFns, ...levelMethods, ...exports.endMiddleFns];
-    const executionChain = {
-      routeIndex: exports.startMiddleFns.length + preMiddleFns.length + props.preLevelMiddleFns.length,
-      methods,
-      serializer: getSerializerCodeFromMode(routeMethod.options.serializer)
-    };
-    const middleFnIds = getPublicMiddleFnIds(methods);
-    if (middleFnIds.length) routeMethod.middleFnIds = middleFnIds;
-    flatRouter.set(path, executionChain);
-    if (routeMethod.options.serializer === "binary") {
-      for (const method of methods) {
-        if (method.type === core.HandlerType.middleFn || method.type === core.HandlerType.headersMiddleFn) {
-          binaryMiddlewares.add(method.id);
-        }
-      }
-    }
-  } else if (!isExec) {
-    await recursiveFlatRoutes(
-      routeEntry.routes,
-      routeEntry.pathPointer,
-      [...preMiddleFns, ...props.preLevelMiddleFns],
-      [...props.postLevelMiddleFns, ...postMiddleFns],
-      binaryMiddlewares,
-      nestLevel + 1
-    );
-  }
-  return props;
+/** The thrower goes first so the dispatcher skips every later non-`alwaysRun` member; body size is the platform's. */
+function buildNotFoundChains() {
+	notFoundChains.clear();
+	const throwers = [[_mionjs_core.MION_ROUTES.notFound, require_src_routes_errors_routes.notFoundMiddleware], [_mionjs_core.MION_ROUTES.batchNotFound, require_src_routes_errors_routes.batchNotFoundMiddleware]];
+	for (const [id, middlewareDef] of throwers) {
+		const methods = [
+			getExecutableFromRawMiddleware(middlewareDef, [id], 0),
+			...startMiddlewares,
+			...endMiddlewares
+		];
+		notFoundChains.set(id, {
+			routeIndex: -1,
+			methods,
+			path: void 0,
+			declaredBodySize: void 0,
+			maxBodySize: platformMaxBodySize,
+			readsBody: false
+		});
+	}
 }
-async function getExecutableFromAnyMiddleFn(middleFn, middleFnPointer, nestLevel) {
-  if (src_types_guards.isRawMiddleFnDef(middleFn)) return getExecutableFromRawMiddleFn(middleFn, middleFnPointer, nestLevel);
-  return getExecutableFromMiddleFn(middleFn, middleFnPointer, nestLevel);
+function getExecutableFromAnyMiddleware(middleware, middlewarePointer, nestLevel) {
+	if (require_src_types_guards.isRawMiddlewareDef(middleware)) return getExecutableFromRawMiddleware(middleware, middlewarePointer, nestLevel);
+	return getExecutableFromMiddleware(middleware, middlewarePointer, nestLevel);
 }
-async function getExecutableFromMiddleFn(middleFn, middleFnPointer, nestLevel) {
-  const isHeader = src_types_guards.isHeadersMiddleFnDef(middleFn);
-  const middleFnId = core.getRouterItemId(middleFnPointer);
-  const existing = middleFnsById.get(middleFnId);
-  if (existing) return existing;
-  const compiledMethod = src_lib_methodsCache.getPersistedMethod(middleFnId, middleFn.handler);
-  let executable;
-  if (compiledMethod) {
-    executable = compiledMethod;
-  } else {
-    const reflectionData = await src_lib_reflection.getHandlerReflection(
-      middleFn.handler,
-      middleFnId,
-      routerOptions,
-      middleFn.options ?? {},
-      isHeader,
-      middleFn.options?.strictTypes
-    );
-    executable = {
-      id: middleFnId,
-      type: isHeader ? core.HandlerType.headersMiddleFn : core.HandlerType.middleFn,
-      nestLevel,
-      handler: middleFn.handler,
-      pointer: middleFnPointer,
-      ...reflectionData,
-      options: {
-        runOnError: !!middleFn.options?.runOnError,
-        validateParams: middleFn.options?.validateParams ?? true,
-        validateReturn: middleFn.options?.validateReturn ?? false,
-        description: middleFn.options?.description,
-        strictTypes: middleFn.options?.strictTypes ?? routerOptions.strictTypes
-      }
-    };
-    src_lib_methodsCache.addToPersistedMethods(middleFnId, executable);
-  }
-  middleFnsById.set(middleFnId, executable);
-  core.routesCache.setMethodJitFns(middleFnId, executable);
-  return executable;
+function getExecutableFromMiddleware(middleware, middlewarePointer, nestLevel) {
+	const isHeader = require_src_types_guards.isHeadersMiddlewareDef(middleware);
+	const middlewareId = (0, _mionjs_core.getRouterItemId)(middlewarePointer);
+	const existing = middlewaresById.get(middlewareId);
+	if (existing) return existing;
+	let executable;
+	{
+		const parser = (0, _mionjs_core.resolveParser)(middleware.options?.parser, routerOptions.parser, middlewareId);
+		const reflectionData = require_src_lib_reflection.getHandlerReflection(middleware, middlewareId, routerOptions, middleware.options ?? {}, isHeader);
+		require_src_lib_reflection.assertCompiledParser(middlewareId, parser, reflectionData);
+		const middlewareType = isHeader ? _mionjs_core.HandlerType.headersMiddleware : _mionjs_core.HandlerType.middleware;
+		executable = {
+			id: middlewareId,
+			type: middlewareType,
+			nestLevel,
+			handler: middleware.handler,
+			pointer: middlewarePointer,
+			methodCaller: require_src_lib_handlers.isOnDemandMiddleware(middleware) ? onDemandCaller(require_src_dispatch.callerForType(middlewareType), require_src_lib_handlers.getOnEveryCall(middleware)) : require_src_dispatch.callerForType(middlewareType),
+			alwaysRun: !!middleware.options?.alwaysRun,
+			quotedId: JSON.stringify(middlewareId),
+			...reflectionData,
+			options: {
+				alwaysRun: !!middleware.options?.alwaysRun,
+				description: middleware.options?.description,
+				parser,
+				sanitizeParams: middleware.options?.sanitizeParams ?? routerOptions.sanitizeParams
+			}
+		};
+		if (middleware.options?.maxBodySize !== void 0) executable.options.maxBodySize = middleware.options.maxBodySize;
+	}
+	middlewaresById.set(middlewareId, executable);
+	_mionjs_core.routesCache.setMethodJitFns(middlewareId, executable);
+	return executable;
 }
-async function getExecutableFromRawMiddleFn(middleFn, middleFnPointer, nestLevel) {
-  const middleFnId = core.getRouterItemId(middleFnPointer);
-  const existing = rawMiddleFnsById.get(middleFnId);
-  if (existing) return existing;
-  const reflectionData = await src_lib_reflection.getRawMethodReflection(middleFn.handler, middleFnId, routerOptions);
-  const executable = {
-    id: middleFnId,
-    type: core.HandlerType.rawMiddleFn,
-    nestLevel,
-    handler: middleFn.handler,
-    pointer: middleFnPointer,
-    ...reflectionData,
-    options: {
-      runOnError: !!middleFn.options?.runOnError,
-      validateParams: false,
-      validateReturn: false,
-      description: middleFn.options?.description
-    }
-  };
-  rawMiddleFnsById.set(middleFnId, executable);
-  core.routesCache.setMethodJitFns(middleFnId, executable);
-  return executable;
+/** An absent slot skips the params pipeline; the answer is the same only because such a middleware's params are optional. */
+function onDemandCaller(caller, onEveryCall) {
+	return (context, executable, request, ...rest) => {
+		onEveryCall?.(context);
+		return request.body[executable.id] === void 0 ? void 0 : caller(context, executable, request, ...rest);
+	};
 }
-async function compileBinaryForMiddleware(binaryMiddlewareIds) {
-  for (const id of binaryMiddlewareIds) {
-    const method = middleFnsById.get(id);
-    if (method) await src_lib_reflection.ensureBinaryJitFns(method);
-  }
+function getExecutableFromRawMiddleware(middleware, middlewarePointer, nestLevel) {
+	const middlewareId = (0, _mionjs_core.getRouterItemId)(middlewarePointer);
+	const existing = rawMiddlewaresById.get(middlewareId);
+	if (existing) return existing;
+	const reflectionData = require_src_lib_reflection.getRawMethodReflection(middleware.handler, middlewareId, routerOptions);
+	const executable = {
+		id: middlewareId,
+		type: _mionjs_core.HandlerType.rawMiddleware,
+		nestLevel,
+		handler: middleware.handler,
+		pointer: middlewarePointer,
+		methodCaller: require_src_dispatch.callerForType(_mionjs_core.HandlerType.rawMiddleware),
+		alwaysRun: !!middleware.options?.alwaysRun,
+		quotedId: JSON.stringify(middlewareId),
+		...reflectionData,
+		options: {
+			alwaysRun: !!middleware.options?.alwaysRun,
+			description: middleware.options?.description
+		}
+	};
+	rawMiddlewaresById.set(middlewareId, executable);
+	_mionjs_core.routesCache.setMethodJitFns(middlewareId, executable);
+	return executable;
 }
-async function getExecutableFromRoute(route, routePointer, nestLevel) {
-  const routeId = core.getRouterItemId(routePointer);
-  const existing = routesById.get(routeId);
-  if (existing) return existing;
-  const compiledMethod = src_lib_methodsCache.getPersistedMethod(routeId, route.handler);
-  let executable;
-  if (compiledMethod) {
-    executable = compiledMethod;
-  } else {
-    const resolvedRouteOptions = { ...route.options, serializer: route.options?.serializer ?? routerOptions.serializer };
-    const reflectionData = await src_lib_reflection.getHandlerReflection(
-      route.handler,
-      routeId,
-      routerOptions,
-      resolvedRouteOptions,
-      false,
-      route.options?.strictTypes
-    );
-    executable = {
-      id: routeId,
-      type: core.HandlerType.route,
-      nestLevel,
-      handler: route.handler,
-      pointer: routePointer,
-      ...reflectionData,
-      options: {
-        runOnError: false,
-        validateParams: route.options?.validateParams ?? true,
-        validateReturn: route.options?.validateReturn ?? false,
-        description: route.options?.description,
-        serializer: route.options?.serializer ?? routerOptions.serializer,
-        isMutation: route.options?.isMutation,
-        strictTypes: route.options?.strictTypes ?? routerOptions.strictTypes
-      }
-    };
-    src_lib_methodsCache.addToPersistedMethods(routeId, executable);
-  }
-  routesById.set(routeId, executable);
-  core.routesCache.setMethodJitFns(routeId, executable);
-  return executable;
+function getExecutableFromRoute(route, routePointer, nestLevel) {
+	const routeId = (0, _mionjs_core.getRouterItemId)(routePointer);
+	const existing = routesById.get(routeId);
+	if (existing) return existing;
+	let executable;
+	{
+		const parser = (0, _mionjs_core.resolveParser)(route.options?.parser, routerOptions.parser, routeId);
+		const reflectionData = require_src_lib_reflection.getHandlerReflection(route, routeId, routerOptions, route.options ?? {}, false);
+		require_src_lib_reflection.assertCompiledParser(routeId, parser, reflectionData);
+		executable = {
+			id: routeId,
+			type: _mionjs_core.HandlerType.route,
+			nestLevel,
+			handler: route.handler,
+			pointer: routePointer,
+			methodCaller: require_src_dispatch.callerForType(_mionjs_core.HandlerType.route),
+			alwaysRun: false,
+			quotedId: JSON.stringify(routeId),
+			...reflectionData,
+			options: {
+				alwaysRun: false,
+				description: route.options?.description,
+				parser,
+				isMutation: route.options?.isMutation,
+				sanitizeParams: route.options?.sanitizeParams ?? routerOptions.sanitizeParams
+			}
+		};
+		if (route.options?.maxBodySize !== void 0) executable.options.maxBodySize = route.options.maxBodySize;
+	}
+	routesById.set(routeId, executable);
+	_mionjs_core.routesCache.setMethodJitFns(routeId, executable);
+	return executable;
 }
-function getPublicMiddleFnIds(methods) {
-  const ids = methods.filter((exec) => src_types_guards.isPublicExecutable(exec)).map((exec) => core.getRouterItemId(exec.pointer)).filter((mfId) => {
-    if (mionInternalRoutes.includes(mfId)) return false;
-    const exec = getMiddleFnExecutable(mfId);
-    return exec && src_types_guards.isPublicExecutable(exec);
-  });
-  return ids;
+function getPublicMiddlewareIds(methods) {
+	return methods.filter((exec) => require_src_types_guards.isPublicExecutable(exec)).map((exec) => (0, _mionjs_core.getRouterItemId)(exec.pointer)).filter((mfId) => {
+		if (require_src_lib_handlers.mionInternalRouteIds.has(mfId)) return false;
+		const exec = getMiddlewareExecutable(mfId);
+		return exec && require_src_types_guards.isPublicExecutable(exec);
+	});
 }
 function getEntry(index, keyEntryList) {
-  return keyEntryList[index]?.[1];
+	return keyEntryList[index]?.[1];
 }
 function getRouteEntryProperties(minus1, zero, plus1) {
-  const minus1IsRoute = minus1 && src_types_guards.isRoute(minus1);
-  const zeroIsRoute = zero.type === core.HandlerType.route;
-  const plus1IsRoute = plus1 && src_types_guards.isRoute(plus1);
-  const isExec = !!zero.handler;
-  return {
-    isBetweenRoutes: minus1IsRoute && zeroIsRoute && plus1IsRoute,
-    isExecutable: isExec,
-    isRoute: zeroIsRoute,
-    preLevelMiddleFns: [],
-    postLevelMiddleFns: []
-  };
+	const minus1IsRoute = minus1 && require_src_types_guards.isRoute(minus1);
+	const zeroIsRoute = zero.type === _mionjs_core.HandlerType.route;
+	const plus1IsRoute = plus1 && require_src_types_guards.isRoute(plus1);
+	const isExec = !!zero.handler;
+	return {
+		isBetweenRoutes: minus1IsRoute && zeroIsRoute && plus1IsRoute,
+		isExecutable: isExec,
+		isRoute: zeroIsRoute,
+		preLevelMiddlewares: [],
+		postLevelMiddlewares: []
+	};
 }
-async function getExecutablesFromMiddleFnsCollection(middleFnsDef) {
-  const results = [];
-  for (const [key, middleFn] of Object.entries(middleFnsDef)) {
-    if (src_types_guards.isRawMiddleFnDef(middleFn)) {
-      results.push(await getExecutableFromRawMiddleFn(middleFn, [key], 0));
-    } else if (src_types_guards.isHeadersMiddleFnDef(middleFn) || src_types_guards.isMiddleFnDef(middleFn)) {
-      results.push(await getExecutableFromMiddleFn(middleFn, [key], 0));
-    } else {
-      throw new Error(`Invalid middleFn: ${key}. Invalid middleFn definition`);
-    }
-  }
-  return results;
+function getExecutablesFromMiddlewaresCollection(middlewaresDef) {
+	const results = [];
+	for (const [key, middleware] of Object.entries(middlewaresDef)) if (require_src_types_guards.isRawMiddlewareDef(middleware)) results.push(getExecutableFromRawMiddleware(middleware, [key], 0));
+	else if (require_src_types_guards.isHeadersMiddlewareDef(middleware) || require_src_types_guards.isMiddlewareDef(middleware)) results.push(getExecutableFromMiddleware(middleware, [key], 0));
+	else throw new Error(`Invalid middleware: ${key}. Invalid middleware definition`);
+	return results;
 }
 function validateSharedDataFactory(opts) {
-  if (!opts?.contextDataFactory) return;
-  const testSharedData = opts.contextDataFactory();
-  if (typeof testSharedData !== "object" || Array.isArray(testSharedData) || testSharedData === null || Object.keys(testSharedData).length === 0) {
-    throw new Error("contextDataFactory must return a plain object with at least one property");
-  }
-}
-function getSerializerCodeFromMode(mode) {
-  switch (mode) {
-    case "binary":
-      return core.SerializerModes.binary;
-    case "stringifyJson":
-      return core.SerializerModes.stringifyJson;
-    case "optimistic":
-      return core.SerializerModes.stringifyJson;
-    case "json":
-    default:
-      return core.SerializerModes.json;
-  }
+	if (!opts?.contextDataFactory) return;
+	const testSharedData = opts.contextDataFactory();
+	if (typeof testSharedData !== "object" || Array.isArray(testSharedData) || testSharedData === null || Object.keys(testSharedData).length === 0) throw new Error("contextDataFactory must return a plain object with at least one property");
 }
+/** Hand-rolled: Node's 'path' module is not available in edge runtimes. */
 function joinPath(...parts) {
-  return parts.filter(Boolean).join("/");
+	return parts.filter(Boolean).join("/");
+}
+/** What a route takes when its own option is unset and its types cannot say: the adapter's `maxBodySize`,
+*  published with its config at start, else the shared default (a router driven with no adapter, as in tests). */
+var getPlatformMaxBodySize = () => platformMaxBodySize;
+/** The platform's own request ceiling, when the adapter published one. */
+var getPlatformRequestCap = () => readMaxBodySizeCap(platformConfig);
+/** The largest limit any registered route or batch resolves to: what a platform with ONE native,
+*  server-wide read limit (bun) starts with, so it never refuses a body a route allows. */
+function getMaxRouteBodySize() {
+	let largest = getPlatformMaxBodySize();
+	for (const chain of flatRouter.values()) largest = Math.max(largest, chain.maxBodySize);
+	return Math.max(largest, require_src_batches.getMaxBatchBodySize());
+}
+/** The platform's own request ceiling the adapter published, in bytes; undefined means none. */
+function readMaxBodySizeCap(config) {
+	const cap = config?.maxBodySizeCap;
+	return typeof cap === "number" ? cap : void 0;
+}
+/** A limit above the platform's ceiling would promise a size the platform refuses before mion ever runs,
+*  so it is brought down. Applied once, when the adapter has published its config AND the routes are
+*  registered, whichever comes last. */
+function applyMaxBodySizeCap() {
+	const cap = readMaxBodySizeCap(platformConfig);
+	if (cap === void 0) return;
+	for (const chain of flatRouter.values()) {
+		if (chain.declaredBodySize === void 0 || chain.declaredBodySize <= cap) continue;
+		chain.declaredBodySize = cap;
+		const route = chain.methods[chain.routeIndex];
+		if (route.options.maxBodySize !== void 0) route.options.maxBodySize = cap;
+	}
+	require_src_batches.capBatchBodySizes(cap);
+}
+/** `maxBodySize` caches two inputs that both move after a chain is built: the cap above lowers what a
+*  chain declared, and `setPlatformConfig` replaces the fallback the chains that declared nothing read.
+*  Missing a refresh refuses bodies a route allows, or allows bodies past the platform's ceiling. */
+function refreshChainBodyLimits() {
+	for (const chain of flatRouter.values()) chain.maxBodySize = chain.declaredBodySize ?? platformMaxBodySize;
+	for (const chain of notFoundChains.values()) chain.maxBodySize = chain.declaredBodySize ?? platformMaxBodySize;
+	require_src_batches.refreshBatchChainBodyLimits(platformMaxBodySize);
+}
+/** `server` first so the option can replace it, `content-type` last so it cannot; lowercased, or `Headers` would
+*  append a name repeated in another case. */
+function mergeResponseDefaults(responseHeaders) {
+	const merged = { server: "mionjs" };
+	for (const name in responseHeaders) merged[name.toLowerCase()] = responseHeaders[name];
+	merged["content-type"] = require_src_constants.JSON_CONTENT_TYPE;
+	return merged;
 }
-exports.addEndMiddleFns = addEndMiddleFns;
-exports.addStartMiddleFns = addStartMiddleFns;
-exports.geMiddleFnsSize = geMiddleFnsSize;
+//#endregion
+exports.addEndMiddlewares = addEndMiddlewares;
+exports.addStartMiddlewares = addStartMiddlewares;
+exports.createMionRouter = createMionRouter;
+Object.defineProperty(exports, "endMiddlewares", {
+	enumerable: true,
+	get: function() {
+		return endMiddlewares;
+	}
+});
 exports.geRoutesSize = geRoutesSize;
 exports.getAllExecutablesIds = getAllExecutablesIds;
 exports.getAnyExecutable = getAnyExecutable;
+exports.getBuildVersion = getBuildVersion;
 exports.getComplexity = getComplexity;
-exports.getExecutableFromMiddleFn = getExecutableFromMiddleFn;
-exports.getExecutableFromRawMiddleFn = getExecutableFromRawMiddleFn;
+exports.getExecutableFromMiddleware = getExecutableFromMiddleware;
+exports.getExecutableFromRawMiddleware = getExecutableFromRawMiddleware;
 exports.getExecutableFromRoute = getExecutableFromRoute;
-exports.getMiddleFnExecutable = getMiddleFnExecutable;
+exports.getHostRequestHandler = getHostRequestHandler;
+exports.getMaxRouteBodySize = getMaxRouteBodySize;
+exports.getMiddlewareExecutable = getMiddlewareExecutable;
+exports.getMiddlewaresSize = getMiddlewaresSize;
+exports.getNotFoundExecutionChain = getNotFoundExecutionChain;
 exports.getPlatformConfig = getPlatformConfig;
+exports.getPlatformMaxBodySize = getPlatformMaxBodySize;
+exports.getPlatformRequestCap = getPlatformRequestCap;
+exports.getResponseDefaults = getResponseDefaults;
 exports.getRouteEntries = getRouteEntries;
 exports.getRouteExecutable = getRouteExecutable;
-exports.getRouteExecutableFromPath = getRouteExecutableFromPath;
 exports.getRouteExecutionChain = getRouteExecutionChain;
 exports.getRouterOptions = getRouterOptions;
 exports.getTotalExecutables = getTotalExecutables;
-exports.initMionRouter = initMionRouter;
-exports.initRouter = initRouter;
+exports.handOverToHost = handOverToHost;
+exports.hostOwnsSocket = hostOwnsSocket;
 exports.isPrivateDefinition = isPrivateDefinition;
-exports.isPrivateExecutable = isPrivateExecutable;
-exports.registerRoutes = registerRoutes;
 exports.resetRouter = resetRouter;
+exports.setHostOwnsSocket = setHostOwnsSocket;
 exports.setPlatformConfig = setPlatformConfig;
 exports.shouldFullGenerateSpec = shouldFullGenerateSpec;
-//# sourceMappingURL=router.cjs.map
+Object.defineProperty(exports, "startMiddlewares", {
+	enumerable: true,
+	get: function() {
+		return startMiddlewares;
+	}
+});
+
+//# sourceMappingURL=router.cjs.map