@mionjs/router 0.8.10 → 0.13.0

package/.dist/esm/src/router.js

@@ -1,484 +1,512 @@
-import { DEFAULT_ROUTE_OPTIONS, MAX_ROUTE_NESTING, WORKFLOW_KEY } from "./constants.js";
-import { isHeadersMiddleFnDef, isRoute, isRawMiddleFnDef, isMiddleFnDef, isAnyMiddleFnDef, isRoutes, isExecutable, isPublicExecutable } from "./types/guards.js";
-import { MION_ROUTES, getRouterItemId, HandlerType, routesCache, setErrorOptions, isTestEnv, resetRoutesCache, isMionAOTEmitMode, getENV, isMionCompileMode, getRoutePath, SerializerModes } from "@mionjs/core";
-import { getHandlerReflection, getRawMethodReflection, ensureBinaryJitFns } from "./lib/reflection.js";
-import { serializerMiddleFns } from "./routes/serializer.routes.js";
+import { isAnyMiddlewareDef, isExecutable, isHeadersMiddlewareDef, isMiddlewareDef, isPublicExecutable, isRawMiddlewareDef, isRoute, isRoutes } from "./types/guards.js";
+import { DEFAULT_ROUTE_OPTIONS, JSON_CONTENT_TYPE } from "./constants.js";
+import { assertCompiledParser, getHandlerReflection, getRawMethodReflection } from "./lib/reflection.js";
+import { resolveChainMaxBodySize } from "./lib/bodyLimit.js";
+import { capBatchBodySizes, clearBatches, getMaxBatchBodySize, refreshBatchChainBodyLimits } from "./batches.js";
+import { callerForType } from "./dispatch.js";
+import { getOnEveryCall, headersMiddleware, isOnDemandMiddleware, middleware, mionInternalRouteIds, mutation, query, rawMiddleware, route } from "./lib/handlers.js";
+import { serializerMiddlewares } from "./routes/serializer.routes.js";
 import { getPublicApi, resetRemoteMethodsMetadata } from "./lib/remoteMethods.js";
-import { getPersistedMethod, addToPersistedMethods, resetPersistedMethods } from "./lib/methodsCache.js";
-import { mionClientMiddleFns, mionClientRoutes } from "./routes/client.routes.js";
-import { mionErrorsRoutes } from "./routes/errors.routes.js";
-import { clearRoutesFlowCache } from "./routesFlow.js";
-import { clearContextPool } from "./callContext.js";
-const mionInternalRoutes = Object.values(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 = { ...DEFAULT_ROUTE_OPTIONS };
-let isRouterInitialized = false;
-let allExecutablesIds;
-let platformConfig;
-const defaultStartMiddleFns = {
-  mionDeserializeRequest: serializerMiddleFns.mionDeserializeRequest
-};
-const defaultEndMiddleFns = {
-  ...mionClientMiddleFns,
-  mionSerializeResponse: serializerMiddleFns.mionSerializeResponse
-};
-let startMiddleFnsDef = { ...defaultStartMiddleFns };
-let endMiddleFnsDef = { ...defaultEndMiddleFns };
-let startMiddleFns = [];
-let 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);
+import { batchNotFoundMiddleware, mionErrorsRoutes, notFoundMiddleware } from "./routes/errors.routes.js";
+import { BUILD_VERSION_HEADER, DEFAULT_MAX_BODY_SIZE, HandlerType, MION_BATCH_KEY, MION_ROUTES, getENV, getOrCreateGlobal, getRoutePath, getRouterItemId, isTestEnv, isUnsafePropertyName, resetRoutesCache, resolveParser, routesCache, setErrorOptions } from "@mionjs/core";
+//#region src/router.ts
+var flatRouter = 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 = getOrCreateGlobal("mion.router.notFoundChains", () => /* @__PURE__ */ new Map());
+var middlewaresById = getOrCreateGlobal("mion.router.middlewaresById", () => /* @__PURE__ */ new Map());
+var routesById = getOrCreateGlobal("mion.router.routesById", () => /* @__PURE__ */ new Map());
+var rawMiddlewaresById = getOrCreateGlobal("mion.router.rawMiddlewaresById", () => /* @__PURE__ */ new Map());
+var middlewareNames = getOrCreateGlobal("mion.router.middlewareNames", () => /* @__PURE__ */ new Set());
+var routeNames = getOrCreateGlobal("mion.router.routeNames", () => /* @__PURE__ */ new Set());
+var complexity = 0;
+var routerOptions = { ...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 = DEFAULT_MAX_BODY_SIZE;
+/** Run before and after every middleware or route set through `mion.initRoutes` */
+var defaultStartMiddlewares = { mionDeserializeRequest: serializerMiddlewares.mionDeserializeRequest };
+var defaultEndMiddlewares = { mionSerializeResponse: 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 (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 : DEFAULT_MAX_BODY_SIZE, readMaxBodySizeCap(config) ?? Infinity);
+	if (isRouterInitialized) applyMaxBodySizeCap();
+	refreshChainBodyLimits();
+}
+var getPlatformConfig = () => platformConfig;
+var devHost = 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 = { ...DEFAULT_ROUTE_OPTIONS };
-  startMiddleFnsDef = { ...defaultStartMiddleFns };
-  endMiddleFnsDef = { ...defaultEndMiddleFns };
-  startMiddleFns = [];
-  endMiddleFns = [];
-  isRouterInitialized = false;
-  allExecutablesIds = void 0;
-  platformConfig = void 0;
-  resetRemoteMethodsMetadata();
-  resetPersistedMethods();
-  resetRoutesCache();
-  clearContextPool();
-  clearRoutesFlowCache();
+var getHostRequestHandler = () => devHost.handler;
+var resetRouter = () => {
+	flatRouter.clear();
+	notFoundChains.clear();
+	middlewaresById.clear();
+	routesById.clear();
+	rawMiddlewaresById.clear();
+	middlewareNames.clear();
+	routeNames.clear();
+	complexity = 0;
+	routerOptions = { ...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 = DEFAULT_MAX_BODY_SIZE;
+	resetRemoteMethodsMetadata();
+	resetRoutesCache();
+	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,
+		query,
+		mutation,
+		middleware,
+		headersMiddleware,
+		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);
-  setErrorOptions(routerOptions);
-  if (routerOptions.aot) await loadAOTCaches();
-  isRouterInitialized = true;
-  await registerRoutes({ ...mionErrorsRoutes });
-  if (!routerOptions.skipClientRoutes) await registerRoutes({ ...mionClientRoutes });
-  if (!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[BUILD_VERSION_HEADER] !== void 0;
+	buildVersion = routerOptions.apiVersionCheck && !isPinned && version || void 0;
+	validateSharedDataFactory(routerOptions);
+	Object.freeze(routerOptions);
+	setErrorOptions(routerOptions);
+	isRouterInitialized = true;
+	registerRoutes({ ...mionErrorsRoutes });
+	if (!isTestEnv()) console.log("mion router initialized", { routerOptions });
 }
-async function registerRoutes(routes) {
-  if (!isRouterInitialized) throw new Error("initRouter should be called first");
-  startMiddleFns = await getExecutablesFromMiddleFnsCollection(startMiddleFnsDef);
-  endMiddleFns = await getExecutablesFromMiddleFnsCollection(endMiddleFnsDef);
-  const binaryMiddlewares = /* @__PURE__ */ new Set();
-  await recursiveFlatRoutes(routes, [], [], [], binaryMiddlewares, 0);
-  if (binaryMiddlewares.size > 0) await compileBinaryForMiddleware(binaryMiddlewares);
-  if (shouldFullGenerateSpec()) {
-    return 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 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 (isRoute(entry)) return false;
-  if (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 === HandlerType.rawMiddleFn) return true;
-  if (executable.type === HandlerType.route) return false;
-  const hasPublicParams = !!executable.paramNames?.length;
-  const hasHeaderParams = !!executable.headersParam?.headerNames?.length;
-  return !hasPublicParams && !hasHeaderParams && !executable.hasReturnData;
+	if (isRoute(entry)) return false;
+	if (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 !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 || getENV("GENERATE_ROUTER_SPEC") === "true" || isMionCompileMode();
-}
-function getRouteExecutableFromPath(path) {
-  const executionChain = flatRouter.get(path);
-  if (!executionChain) {
-    return getAnyExecutable(MION_ROUTES.notFound);
-  }
-  return executionChain.methods[executionChain.routeIndex];
-}
-async function loadAOTCaches() {
-  const loader = await import("./aot/aotCacheLoader.js");
-  return loader.loadRouterAOTCaches();
+	return routerOptions.getPublicRoutesData || getENV("GENERATE_ROUTER_SPEC") === "true";
 }
-async function emitAOTCaches() {
-  if (!isMionAOTEmitMode()) return;
-  const aotEmitter = await import("./lib/aotEmitter.js");
-  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 (isUnsafePropertyName(key)) throw new Error(`Invalid route: ${joinPath(...newPointer)}. '${key}' is not a valid route name.`);
+		if (key === MION_BATCH_KEY) throw new Error(`Invalid route: ${joinPath(...newPointer)}. '${MION_BATCH_KEY}' is a reserved mion route name.`);
+		if (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 (isOnDemandMiddleware(item) && (nestLevel !== 0 || entries.slice(0, index).some(([, entry]) => !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 (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 (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 > 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 === WORKFLOW_KEY)
-      throw new Error(`Invalid route: ${joinPath(...newPointer)}. '${WORKFLOW_KEY}' is a reserved mion route name.`);
-    if (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 (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 (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 (!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 = isExecutable(routeEntry);
+	if (isExec && props.isRoute) {
+		const path = getRoutePath(routeEntry.pointer, routerOptions);
+		const routeMethod = routeEntry;
+		const levelMethods = [
+			...preMiddlewares,
+			...props.preLevelMiddlewares,
+			routeEntry,
+			...props.postLevelMiddlewares,
+			...postMiddlewares
+		];
+		const methods = [
+			...startMiddlewares,
+			...levelMethods,
+			...endMiddlewares
+		];
+		const maxBodySize = mionInternalRouteIds.has(routeMethod.id) ? routeMethod.options.maxBodySize : 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 (!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 = isExecutable(routeEntry);
-  if (isExec && props.isRoute) {
-    const path = getRoutePath(routeEntry.pointer, routerOptions);
-    const routeMethod = routeEntry;
-    const levelMethods = [
-      ...preMiddleFns,
-      ...props.preLevelMiddleFns,
-      routeEntry,
-      ...props.postLevelMiddleFns,
-      ...postMiddleFns
-    ];
-    const methods = [...startMiddleFns, ...levelMethods, ...endMiddleFns];
-    const executionChain = {
-      routeIndex: 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 === HandlerType.middleFn || method.type === 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 = [[MION_ROUTES.notFound, notFoundMiddleware], [MION_ROUTES.batchNotFound, 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 (isRawMiddleFnDef(middleFn)) return getExecutableFromRawMiddleFn(middleFn, middleFnPointer, nestLevel);
-  return getExecutableFromMiddleFn(middleFn, middleFnPointer, nestLevel);
+function getExecutableFromAnyMiddleware(middleware, middlewarePointer, nestLevel) {
+	if (isRawMiddlewareDef(middleware)) return getExecutableFromRawMiddleware(middleware, middlewarePointer, nestLevel);
+	return getExecutableFromMiddleware(middleware, middlewarePointer, nestLevel);
 }
-async function getExecutableFromMiddleFn(middleFn, middleFnPointer, nestLevel) {
-  const isHeader = isHeadersMiddleFnDef(middleFn);
-  const middleFnId = getRouterItemId(middleFnPointer);
-  const existing = middleFnsById.get(middleFnId);
-  if (existing) return existing;
-  const compiledMethod = getPersistedMethod(middleFnId, middleFn.handler);
-  let executable;
-  if (compiledMethod) {
-    executable = compiledMethod;
-  } else {
-    const reflectionData = await getHandlerReflection(
-      middleFn.handler,
-      middleFnId,
-      routerOptions,
-      middleFn.options ?? {},
-      isHeader,
-      middleFn.options?.strictTypes
-    );
-    executable = {
-      id: middleFnId,
-      type: isHeader ? HandlerType.headersMiddleFn : 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
-      }
-    };
-    addToPersistedMethods(middleFnId, executable);
-  }
-  middleFnsById.set(middleFnId, executable);
-  routesCache.setMethodJitFns(middleFnId, executable);
-  return executable;
+function getExecutableFromMiddleware(middleware, middlewarePointer, nestLevel) {
+	const isHeader = isHeadersMiddlewareDef(middleware);
+	const middlewareId = getRouterItemId(middlewarePointer);
+	const existing = middlewaresById.get(middlewareId);
+	if (existing) return existing;
+	let executable;
+	{
+		const parser = resolveParser(middleware.options?.parser, routerOptions.parser, middlewareId);
+		const reflectionData = getHandlerReflection(middleware, middlewareId, routerOptions, middleware.options ?? {}, isHeader);
+		assertCompiledParser(middlewareId, parser, reflectionData);
+		const middlewareType = isHeader ? HandlerType.headersMiddleware : HandlerType.middleware;
+		executable = {
+			id: middlewareId,
+			type: middlewareType,
+			nestLevel,
+			handler: middleware.handler,
+			pointer: middlewarePointer,
+			methodCaller: isOnDemandMiddleware(middleware) ? onDemandCaller(callerForType(middlewareType), getOnEveryCall(middleware)) : 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);
+	routesCache.setMethodJitFns(middlewareId, executable);
+	return executable;
 }
-async function getExecutableFromRawMiddleFn(middleFn, middleFnPointer, nestLevel) {
-  const middleFnId = getRouterItemId(middleFnPointer);
-  const existing = rawMiddleFnsById.get(middleFnId);
-  if (existing) return existing;
-  const reflectionData = await getRawMethodReflection(middleFn.handler, middleFnId, routerOptions);
-  const executable = {
-    id: middleFnId,
-    type: 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);
-  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 ensureBinaryJitFns(method);
-  }
+function getExecutableFromRawMiddleware(middleware, middlewarePointer, nestLevel) {
+	const middlewareId = getRouterItemId(middlewarePointer);
+	const existing = rawMiddlewaresById.get(middlewareId);
+	if (existing) return existing;
+	const reflectionData = getRawMethodReflection(middleware.handler, middlewareId, routerOptions);
+	const executable = {
+		id: middlewareId,
+		type: HandlerType.rawMiddleware,
+		nestLevel,
+		handler: middleware.handler,
+		pointer: middlewarePointer,
+		methodCaller: callerForType(HandlerType.rawMiddleware),
+		alwaysRun: !!middleware.options?.alwaysRun,
+		quotedId: JSON.stringify(middlewareId),
+		...reflectionData,
+		options: {
+			alwaysRun: !!middleware.options?.alwaysRun,
+			description: middleware.options?.description
+		}
+	};
+	rawMiddlewaresById.set(middlewareId, executable);
+	routesCache.setMethodJitFns(middlewareId, executable);
+	return executable;
 }
-async function getExecutableFromRoute(route, routePointer, nestLevel) {
-  const routeId = getRouterItemId(routePointer);
-  const existing = routesById.get(routeId);
-  if (existing) return existing;
-  const compiledMethod = getPersistedMethod(routeId, route.handler);
-  let executable;
-  if (compiledMethod) {
-    executable = compiledMethod;
-  } else {
-    const resolvedRouteOptions = { ...route.options, serializer: route.options?.serializer ?? routerOptions.serializer };
-    const reflectionData = await getHandlerReflection(
-      route.handler,
-      routeId,
-      routerOptions,
-      resolvedRouteOptions,
-      false,
-      route.options?.strictTypes
-    );
-    executable = {
-      id: routeId,
-      type: 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
-      }
-    };
-    addToPersistedMethods(routeId, executable);
-  }
-  routesById.set(routeId, executable);
-  routesCache.setMethodJitFns(routeId, executable);
-  return executable;
+function getExecutableFromRoute(route, routePointer, nestLevel) {
+	const routeId = getRouterItemId(routePointer);
+	const existing = routesById.get(routeId);
+	if (existing) return existing;
+	let executable;
+	{
+		const parser = resolveParser(route.options?.parser, routerOptions.parser, routeId);
+		const reflectionData = getHandlerReflection(route, routeId, routerOptions, route.options ?? {}, false);
+		assertCompiledParser(routeId, parser, reflectionData);
+		executable = {
+			id: routeId,
+			type: HandlerType.route,
+			nestLevel,
+			handler: route.handler,
+			pointer: routePointer,
+			methodCaller: callerForType(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);
+	routesCache.setMethodJitFns(routeId, executable);
+	return executable;
 }
-function getPublicMiddleFnIds(methods) {
-  const ids = methods.filter((exec) => isPublicExecutable(exec)).map((exec) => getRouterItemId(exec.pointer)).filter((mfId) => {
-    if (mionInternalRoutes.includes(mfId)) return false;
-    const exec = getMiddleFnExecutable(mfId);
-    return exec && isPublicExecutable(exec);
-  });
-  return ids;
+function getPublicMiddlewareIds(methods) {
+	return methods.filter((exec) => isPublicExecutable(exec)).map((exec) => getRouterItemId(exec.pointer)).filter((mfId) => {
+		if (mionInternalRouteIds.has(mfId)) return false;
+		const exec = getMiddlewareExecutable(mfId);
+		return exec && isPublicExecutable(exec);
+	});
 }
 function getEntry(index, keyEntryList) {
-  return keyEntryList[index]?.[1];
+	return keyEntryList[index]?.[1];
 }
 function getRouteEntryProperties(minus1, zero, plus1) {
-  const minus1IsRoute = minus1 && isRoute(minus1);
-  const zeroIsRoute = zero.type === HandlerType.route;
-  const plus1IsRoute = plus1 && isRoute(plus1);
-  const isExec = !!zero.handler;
-  return {
-    isBetweenRoutes: minus1IsRoute && zeroIsRoute && plus1IsRoute,
-    isExecutable: isExec,
-    isRoute: zeroIsRoute,
-    preLevelMiddleFns: [],
-    postLevelMiddleFns: []
-  };
+	const minus1IsRoute = minus1 && isRoute(minus1);
+	const zeroIsRoute = zero.type === HandlerType.route;
+	const plus1IsRoute = plus1 && 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 (isRawMiddleFnDef(middleFn)) {
-      results.push(await getExecutableFromRawMiddleFn(middleFn, [key], 0));
-    } else if (isHeadersMiddleFnDef(middleFn) || 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 (isRawMiddlewareDef(middleware)) results.push(getExecutableFromRawMiddleware(middleware, [key], 0));
+	else if (isHeadersMiddlewareDef(middleware) || 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 SerializerModes.binary;
-    case "stringifyJson":
-      return SerializerModes.stringifyJson;
-    case "optimistic":
-      return SerializerModes.stringifyJson;
-    case "json":
-    default:
-      return 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("/");
 }
-export {
-  addEndMiddleFns,
-  addStartMiddleFns,
-  endMiddleFns,
-  geMiddleFnsSize,
-  geRoutesSize,
-  getAllExecutablesIds,
-  getAnyExecutable,
-  getComplexity,
-  getExecutableFromMiddleFn,
-  getExecutableFromRawMiddleFn,
-  getExecutableFromRoute,
-  getMiddleFnExecutable,
-  getPlatformConfig,
-  getRouteEntries,
-  getRouteExecutable,
-  getRouteExecutableFromPath,
-  getRouteExecutionChain,
-  getRouterOptions,
-  getTotalExecutables,
-  initMionRouter,
-  initRouter,
-  isPrivateDefinition,
-  isPrivateExecutable,
-  registerRoutes,
-  resetRouter,
-  setPlatformConfig,
-  shouldFullGenerateSpec,
-  startMiddleFns
-};
-//# sourceMappingURL=router.js.map
+/** 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, 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;
+	}
+	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;
+	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"] = JSON_CONTENT_TYPE;
+	return merged;
+}
+//#endregion
+export { addEndMiddlewares, addStartMiddlewares, createMionRouter, endMiddlewares, geRoutesSize, getAllExecutablesIds, getAnyExecutable, getBuildVersion, getComplexity, getExecutableFromMiddleware, getExecutableFromRawMiddleware, getExecutableFromRoute, getHostRequestHandler, getMaxRouteBodySize, getMiddlewareExecutable, getMiddlewaresSize, getNotFoundExecutionChain, getPlatformConfig, getPlatformMaxBodySize, getPlatformRequestCap, getResponseDefaults, getRouteEntries, getRouteExecutable, getRouteExecutionChain, getRouterOptions, getTotalExecutables, handOverToHost, hostOwnsSocket, isPrivateDefinition, resetRouter, setHostOwnsSocket, setPlatformConfig, shouldFullGenerateSpec, startMiddlewares };
+
+//# sourceMappingURL=router.js.map