@mionjs/router 0.8.8 → 0.13.0

package/.dist/cjs/src/lib/remoteMethods.cjs

@@ -1,125 +1,125 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const src_types_guards = require("../types/guards.cjs");
-const src_router = require("../router.cjs");
-const core = require("@mionjs/core");
-const publicMethods = /* @__PURE__ */ new Map();
+const require_src_types_guards = require("../types/guards.cjs");
+const require_src_router = require("../router.cjs");
+let _mionjs_core = require("@mionjs/core");
+let _mionjs_run_types_runtime = require("@mionjs/run-types/runtime");
+//#region src/lib/remoteMethods.ts
+var publicMethods = (0, _mionjs_core.getOrCreateGlobal)("mion.remoteMethods.publicMethods", () => /* @__PURE__ */ new Map());
 function resetRemoteMethodsMetadata() {
-  publicMethods.clear();
+	publicMethods.clear();
 }
+/** All the public information and types of the routes, what a router client is generated from. */
 function getPublicApi(routes) {
-  return recursiveGetSerializableRoutes(routes);
+	return recursiveGetSerializableRoutes(routes);
 }
 function recursiveGetSerializableRoutes(routes, currentPointer = [], publicData = {}) {
-  const entries = Object.entries(routes);
-  entries.forEach(([key, item]) => {
-    const itemPointer = [...currentPointer, key];
-    const id = core.getRouterItemId(itemPointer);
-    if (src_router.isPrivateDefinition(item, id)) {
-      publicData[key] = null;
-    } else if (src_types_guards.isMiddleFnDef(item) || src_types_guards.isHeadersMiddleFnDef(item) || src_types_guards.isRoute(item)) {
-      const executable = src_router.getMiddleFnExecutable(id) || src_router.getRouteExecutable(id);
-      if (!executable)
-        throw new Error(`Route or MiddleFn ${id} not found. Please check you have called router.registerRoutes first.`);
-      publicData[key] = getSerializableMethod(executable);
-    } else {
-      const subRoutes = routes[key];
-      publicData[key] = recursiveGetSerializableRoutes(subRoutes, itemPointer);
-    }
-  });
-  return publicData;
+	Object.entries(routes).forEach(([key, item]) => {
+		const itemPointer = [...currentPointer, key];
+		const id = (0, _mionjs_core.getRouterItemId)(itemPointer);
+		if (require_src_router.isPrivateDefinition(item, id)) publicData[key] = null;
+		else if (require_src_types_guards.isMiddlewareDef(item) || require_src_types_guards.isHeadersMiddlewareDef(item) || require_src_types_guards.isRoute(item)) {
+			const executable = require_src_router.getMiddlewareExecutable(id) || require_src_router.getRouteExecutable(id);
+			if (!executable) throw new Error(`Route or Middleware ${id} not found. Please check you have called mion.initRoutes first.`);
+			publicData[key] = getSerializableMethod(executable);
+		} else {
+			const subRoutes = routes[key];
+			publicData[key] = recursiveGetSerializableRoutes(subRoutes, itemPointer);
+		}
+	});
+	return publicData;
 }
 function getSerializableMethod(executable) {
-  const existing = publicMethods.get(executable.id);
-  if (existing) return existing;
-  const newRemoteMethod = {
-    type: executable.type,
-    id: executable.id,
-    nestLevel: executable.nestLevel,
-    isAsync: executable.isAsync,
-    hasReturnData: executable.hasReturnData,
-    paramsJitHash: executable.paramsJitHash,
-    returnJitHash: executable.returnJitHash,
-    pointer: executable.pointer,
-    ...executable.paramNames ? { paramNames: executable.paramNames } : {},
-    options: executable.options
-  };
-  if (executable.headersParam) newRemoteMethod.headersParam = executable.headersParam;
-  if (executable.middleFnIds) newRemoteMethod.middleFnIds = executable.middleFnIds;
-  publicMethods.set(executable.id, newRemoteMethod);
-  return newRemoteMethod;
+	const existing = publicMethods.get(executable.id);
+	if (existing) return existing;
+	const newRemoteMethod = {
+		type: executable.type,
+		id: executable.id,
+		nestLevel: executable.nestLevel,
+		isAsync: executable.isAsync,
+		hasReturnData: executable.hasReturnData,
+		paramsJitHash: executable.paramsJitHash,
+		returnJitHash: executable.returnJitHash,
+		pointer: executable.pointer,
+		paramsCount: executable.paramsCount ?? 0,
+		paramNames: executable.paramNames,
+		options: executable.type === _mionjs_core.HandlerType.route && executable.options.maxBodySize === void 0 ? {
+			...executable.options,
+			maxBodySize: require_src_router.getPlatformMaxBodySize()
+		} : executable.options
+	};
+	if (executable.syncId) newRemoteMethod.syncId = executable.syncId;
+	if (executable.headersParam) newRemoteMethod.headersParam = executable.headersParam;
+	if (executable.headersReturn) newRemoteMethod.headersReturn = {
+		headerNames: executable.headersReturn.headerNames,
+		jitHash: executable.headersReturn.jitHash
+	};
+	if (executable.middlewareIds) newRemoteMethod.middlewareIds = executable.middlewareIds;
+	publicMethods.set(executable.id, newRemoteMethod);
+	return newRemoteMethod;
 }
-function serializePureDeps(namespacedDepHash, purFnDeps, depth = 0) {
-  if (depth >= core.MAX_STACK_DEPTH)
-    throw new Error(`Max depth reached serializing pure function dependencies, for: ${namespacedDepHash}`);
-  const parts = namespacedDepHash.split("::");
-  if (parts.length !== 2)
-    throw new Error(`Invalid pure function dependency format: ${namespacedDepHash}, expected "namespace::fnHash"`);
-  const [namespace, fnHash] = parts;
-  if (!purFnDeps[namespace]) purFnDeps[namespace] = {};
-  if (purFnDeps[namespace][fnHash]) return;
-  const pureDep = core.getJitUtils().getCompiledPureFn(namespace, fnHash);
-  if (!pureDep) throw new Error(`Pure function ${fnHash} not found in namespace ${namespace}`);
-  const serializedPureDep = {
-    ...pureDep,
-    pureFnDependencies: pureDep.pureFnDependencies ? [...pureDep.pureFnDependencies] : void 0
-  };
-  purFnDeps[namespace][fnHash] = serializedPureDep;
-  pureDep.pureFnDependencies?.forEach((depFnHash) => serializePureDeps(`${namespace}::${depFnHash}`, purFnDeps, depth + 1));
+/** Serializes a pure function and everything it reaches into the wire cache, keyed by id. */
+function serializePureDeps(id, purFnDeps, depth = 0) {
+	if (depth >= _mionjs_core.MAX_STACK_DEPTH) throw new Error(`Max depth reached serializing pure function dependencies, for: ${id}`);
+	if (id.startsWith(_mionjs_run_types_runtime.RUN_TYPES_PURE_FN_ID_PREFIX)) return;
+	if (purFnDeps[id]) return;
+	const pureDep = (0, _mionjs_core.resolveCompiledPureFn)(id);
+	if (!pureDep) throw new Error(`Pure function ${id} not found`);
+	if (!pureDep.code) throw new Error(`Pure function ${id} has no code payload and cannot be serialized to the client. Runtime-registered pure fns are server-only; the client can rebuild only build-extracted ones.`);
+	purFnDeps[id] = {
+		...pureDep,
+		code: pureDep.code,
+		pureFnDependencies: pureDep.pureFnDependencies ? [...pureDep.pureFnDependencies] : void 0
+	};
+	pureDep.pureFnDependencies?.forEach((depId) => serializePureDeps(depId, purFnDeps, depth + 1));
 }
-function serializeJitFn(jitFnHash, deps, purFnDeps, depth = 0) {
-  if (depth >= core.MAX_STACK_DEPTH)
-    throw new Error(`Max depth reached serializing jit function dependencies for jitHash: ${jitFnHash}`);
-  const jitFn = core.getJitUtils().getJIT(jitFnHash);
-  if (!jitFn) throw new Error(`Jit function ${jitFnHash} not found`);
-  if (deps[jitFnHash]) return;
-  const serializedJitFn = getSerializableJitCompiler(jitFn);
-  deps[jitFnHash] = serializedJitFn;
-  jitFn.jitDependencies?.forEach((h) => serializeJitFn(h, deps, purFnDeps, depth + 1));
-  jitFn.pureFnDependencies?.forEach((h) => serializePureDeps(h, purFnDeps));
+function serializeJitFn(rtFnHash, deps, purFnDeps, depth = 0) {
+	if (depth >= _mionjs_core.MAX_STACK_DEPTH) throw new Error(`Max depth reached serializing jit function dependencies for jitHash: ${rtFnHash}`);
+	const jitFn = (0, _mionjs_run_types_runtime.getRTUtils)().getRT(rtFnHash);
+	if (!jitFn) throw new Error(`Jit function ${rtFnHash} not found`);
+	if (deps[rtFnHash]) return;
+	deps[rtFnHash] = getSerializableJitCompiler(jitFn);
+	jitFn.rtDependencies?.forEach((h) => serializeJitFn(h, deps, purFnDeps, depth + 1));
+	jitFn.pureFnDependencies?.forEach((h) => serializePureDeps(h, purFnDeps));
 }
 function serializeMethodDeps(method, deps, purFnDeps) {
-  const { paramsJitHash, returnJitHash } = method;
-  if (paramsJitHash !== core.EMPTY_HASH) {
-    const paramsJitHashes = core.getJitFnHashes(paramsJitHash, true);
-    for (const k in paramsJitHashes) {
-      if (core.getJitUtils().getJIT(paramsJitHashes[k])) serializeJitFn(paramsJitHashes[k], deps, purFnDeps);
-    }
-  }
-  if (returnJitHash !== core.EMPTY_HASH) {
-    const returnJitHashes = core.getJitFnHashes(returnJitHash, true);
-    let foundAny = false;
-    for (const k in returnJitHashes) {
-      if (core.getJitUtils().getJIT(returnJitHashes[k])) {
-        serializeJitFn(returnJitHashes[k], deps, purFnDeps);
-        foundAny = true;
-      }
-    }
-    if (!foundAny) {
-      throw new Error(
-        `Method "${method.id}" declares returnJitHash="${returnJitHash}" but no JIT functions are registered under that hash. This usually means a Promise/Function return type was not unwrapped before computing the hash.`
-      );
-    }
-  }
+	const { paramsJitHash, returnJitHash } = method;
+	const utl = (0, _mionjs_run_types_runtime.getRTUtils)();
+	const parser = method.options.parser ?? _mionjs_core.DEFAULT_PARSER;
+	if (paramsJitHash !== _mionjs_core.EMPTY_HASH) {
+		const paramsJitHashes = (0, _mionjs_core.getJitFnHashes)(paramsJitHash, parser.params);
+		for (const k in paramsJitHashes) if (utl.getRT(paramsJitHashes[k])) serializeJitFn(paramsJitHashes[k], deps, purFnDeps);
+	}
+	if (returnJitHash !== _mionjs_core.EMPTY_HASH) {
+		const returnJitHashes = (0, _mionjs_core.getJitFnHashes)(returnJitHash, parser.return);
+		let foundAny = false;
+		for (const k in returnJitHashes) if (utl.getRT(returnJitHashes[k])) {
+			serializeJitFn(returnJitHashes[k], deps, purFnDeps);
+			foundAny = true;
+		}
+		if (!foundAny) throw new Error(`Method "${method.id}" declares returnJitHash="${returnJitHash}" but no JIT functions are registered under that hash. This usually means a Promise/Function return type was not unwrapped before computing the hash.`);
+	}
 }
 function getSerializableJitCompiler(comp) {
-  return {
-    typeName: comp.typeName,
-    fnID: comp.fnID,
-    jitFnHash: comp.jitFnHash,
-    args: structuredClone(comp.args),
-    isNoop: comp.isNoop,
-    defaultParamValues: structuredClone(comp.defaultParamValues),
-    code: comp.code,
-    jitDependencies: comp.jitDependencies ? [...comp.jitDependencies] : void 0,
-    pureFnDependencies: comp.pureFnDependencies ? [...comp.pureFnDependencies] : void 0,
-    ...comp.paramNames ? { paramNames: [...comp.paramNames] } : {}
-  };
+	return {
+		typeName: comp.typeName,
+		fnID: comp.fnID,
+		familyTag: comp.familyTag,
+		rtFnHash: comp.rtFnHash,
+		args: { ...comp.args },
+		isNoop: comp.isNoop,
+		defaultParamValues: { ...comp.defaultParamValues },
+		code: comp.code,
+		rtDependencies: comp.rtDependencies ? [...comp.rtDependencies] : void 0,
+		pureFnDependencies: comp.pureFnDependencies ? [...comp.pureFnDependencies] : void 0,
+		alwaysThrowMessage: comp.alwaysThrowMessage
+	};
 }
+//#endregion
 exports.getPublicApi = getPublicApi;
 exports.getSerializableMethod = getSerializableMethod;
 exports.resetRemoteMethodsMetadata = resetRemoteMethodsMetadata;
 exports.serializeJitFn = serializeJitFn;
 exports.serializeMethodDeps = serializeMethodDeps;
 exports.serializePureDeps = serializePureDeps;
-//# sourceMappingURL=remoteMethods.cjs.map
+
+//# sourceMappingURL=remoteMethods.cjs.map

package/.dist/cjs/src/lib/remoteMethods.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"remoteMethods.cjs","sources":["../../../../src/lib/remoteMethods.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {type RouterEntry, type Routes} from '../types/general.ts';\nimport {type RemoteMethod} from '../types/remoteMethods.ts';\nimport type {PublicApi} from '../types/publicMethods.ts';\nimport type {\n    AnyObject,\n    JitCompiledFn,\n    JitCompiledFnData,\n    PureFunctionData,\n    MethodWithOptions,\n    PureFnsDataCache,\n} from '@mionjs/core';\nimport {isRoute, isHeadersMiddleFnDef, isMiddleFnDef} from '../types/guards.ts';\nimport {getMiddleFnExecutable, getRouteExecutable, isPrivateDefinition} from '../router.ts';\nimport {getRouterItemId, MAX_STACK_DEPTH, getJitFnHashes, getJitUtils, EMPTY_HASH} from '@mionjs/core';\n\n// ############# PRIVATE STATE #############\nconst publicMethods: Map<string, MethodWithOptions> = new Map();\n\n// ############# PUBLIC METHODS #############\nexport function resetRemoteMethodsMetadata() {\n    publicMethods.clear();\n}\n\n/**\n * Returns a data structure containing all public information and types of the routes.\n * This data and types can be used to generate router clients, etc...\n */\nexport function getPublicApi<R extends Routes>(routes: R): PublicApi<R> {\n    return recursiveGetSerializableRoutes(routes) as PublicApi<R>;\n}\n\n// ############# PRIVATE METHODS #############\n\nfunction recursiveGetSerializableRoutes<R extends Routes>(\n    routes: R,\n    currentPointer: string[] = [],\n    publicData: AnyObject = {}\n): AnyObject {\n    const entries = Object.entries(routes);\n    entries.forEach(([key, item]: [string, RouterEntry]) => {\n        const itemPointer = [...currentPointer, key];\n        const id = getRouterItemId(itemPointer);\n\n        if (isPrivateDefinition(item, id)) {\n            publicData[key] = null; // middleFns that don't receive or return data are not public\n        } else if (isMiddleFnDef(item) || isHeadersMiddleFnDef(item) || isRoute(item)) {\n            const executable = getMiddleFnExecutable(id) || getRouteExecutable(id);\n            if (!executable)\n                throw new Error(`Route or MiddleFn ${id} not found. Please check you have called router.registerRoutes first.`);\n            publicData[key] = getSerializableMethod(executable as RemoteMethod);\n        } else {\n            const subRoutes: Routes = routes[key] as Routes;\n            publicData[key] = recursiveGetSerializableRoutes(subRoutes, itemPointer);\n        }\n    });\n\n    return publicData;\n}\n\nexport function getSerializableMethod(executable: RemoteMethod): MethodWithOptions {\n    const existing = publicMethods.get(executable.id);\n    if (existing) return existing as MethodWithOptions;\n\n    const newRemoteMethod: MethodWithOptions = {\n        type: executable.type,\n        id: executable.id,\n        nestLevel: executable.nestLevel,\n        isAsync: executable.isAsync,\n        hasReturnData: executable.hasReturnData,\n        paramsJitHash: executable.paramsJitHash,\n        returnJitHash: executable.returnJitHash,\n        pointer: executable.pointer,\n        ...(executable.paramNames ? {paramNames: executable.paramNames} : {}),\n        options: executable.options,\n    };\n    if (executable.headersParam) newRemoteMethod.headersParam = executable.headersParam;\n    if (executable.middleFnIds) newRemoteMethod.middleFnIds = executable.middleFnIds;\n    publicMethods.set(executable.id, newRemoteMethod);\n    return newRemoteMethod as MethodWithOptions;\n}\n\n/** Serializes pure function dependencies into a namespaced cache structure.\n * @param namespacedDepHash - Pure function dependency in format \"namespace::fnHash\"\n * @param purFnDeps - Namespaced cache to store serialized pure functions\n * @param depth - Current recursion depth for stack overflow protection\n */\nexport function serializePureDeps(namespacedDepHash: string, purFnDeps: PureFnsDataCache, depth = 0) {\n    if (depth >= MAX_STACK_DEPTH)\n        throw new Error(`Max depth reached serializing pure function dependencies, for: ${namespacedDepHash}`);\n    // Parse \"namespace::fnHash\" format\n    const parts = namespacedDepHash.split('::');\n    if (parts.length !== 2)\n        throw new Error(`Invalid pure function dependency format: ${namespacedDepHash}, expected \"namespace::fnHash\"`);\n    const [namespace, fnHash] = parts;\n    // Ensure namespace exists in the cache\n    if (!purFnDeps[namespace]) purFnDeps[namespace] = {};\n    // Check if already serialized (prevent infinite recursion on circular dependencies)\n    if (purFnDeps[namespace][fnHash]) return;\n    const pureDep = getJitUtils().getCompiledPureFn(namespace, fnHash);\n    if (!pureDep) throw new Error(`Pure function ${fnHash} not found in namespace ${namespace}`);\n    const serializedPureDep: PureFunctionData = {\n        ...pureDep,\n        pureFnDependencies: pureDep.pureFnDependencies ? [...pureDep.pureFnDependencies] : undefined,\n    };\n    purFnDeps[namespace][fnHash] = serializedPureDep;\n    // Dependencies within the same namespace are stored as just fnHash, not namespaced\n    pureDep.pureFnDependencies?.forEach((depFnHash) => serializePureDeps(`${namespace}::${depFnHash}`, purFnDeps, depth + 1));\n}\n\nexport function serializeJitFn(\n    jitFnHash: string,\n    deps: Record<string, JitCompiledFnData>,\n    purFnDeps: PureFnsDataCache,\n    depth = 0\n) {\n    if (depth >= MAX_STACK_DEPTH)\n        throw new Error(`Max depth reached serializing jit function dependencies for jitHash: ${jitFnHash}`);\n    const jitFn = getJitUtils().getJIT(jitFnHash);\n    if (!jitFn) throw new Error(`Jit function ${jitFnHash} not found`);\n    if (deps[jitFnHash]) return; // already serialized and prevent infinite recursion on circular dependencies\n    const serializedJitFn = getSerializableJitCompiler(jitFn);\n    deps[jitFnHash] = serializedJitFn;\n    jitFn.jitDependencies?.forEach((h) => serializeJitFn(h, deps, purFnDeps, depth + 1));\n    jitFn.pureFnDependencies?.forEach((h) => serializePureDeps(h, purFnDeps));\n}\n\nexport function serializeMethodDeps(\n    method: MethodWithOptions,\n    deps: Record<string, JitCompiledFnData>,\n    purFnDeps: PureFnsDataCache\n) {\n    const {paramsJitHash, returnJitHash} = method;\n    // Skip serialization for empty hashes (no params or void return)\n    // Always request binary hashes so they are included when available (e.g. middleware in binary routes).\n    // serializeJitFn is only called when the JIT function exists in the store, so non-binary methods are unaffected.\n    if (paramsJitHash !== EMPTY_HASH) {\n        const paramsJitHashes = getJitFnHashes(paramsJitHash, true);\n        for (const k in paramsJitHashes) {\n            if (getJitUtils().getJIT(paramsJitHashes[k])) serializeJitFn(paramsJitHashes[k], deps, purFnDeps);\n        }\n    }\n    if (returnJitHash !== EMPTY_HASH) {\n        const returnJitHashes = getJitFnHashes(returnJitHash, true);\n        let foundAny = false;\n        for (const k in returnJitHashes) {\n            if (getJitUtils().getJIT(returnJitHashes[k])) {\n                serializeJitFn(returnJitHashes[k], deps, purFnDeps);\n                foundAny = true;\n            }\n        }\n        if (!foundAny) {\n            throw new Error(\n                `Method \"${method.id}\" declares returnJitHash=\"${returnJitHash}\" but no JIT functions are registered under that hash. ` +\n                    `This usually means a Promise/Function return type was not unwrapped before computing the hash.`\n            );\n        }\n    }\n}\n\nfunction getSerializableJitCompiler(comp: JitCompiledFn): JitCompiledFnData {\n    return {\n        typeName: comp.typeName,\n        fnID: comp.fnID,\n        jitFnHash: comp.jitFnHash,\n        args: structuredClone(comp.args),\n        isNoop: comp.isNoop,\n        defaultParamValues: structuredClone(comp.defaultParamValues),\n        code: comp.code,\n        jitDependencies: comp.jitDependencies ? [...comp.jitDependencies] : undefined,\n        pureFnDependencies: comp.pureFnDependencies ? [...comp.pureFnDependencies] : undefined,\n        ...(comp.paramNames ? {paramNames: [...comp.paramNames]} : {}),\n    };\n}\n"],"names":["getRouterItemId","isPrivateDefinition","isMiddleFnDef","isHeadersMiddleFnDef","isRoute","getMiddleFnExecutable","getRouteExecutable","MAX_STACK_DEPTH","getJitUtils","EMPTY_HASH","getJitFnHashes"],"mappings":"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"}
+{"version":3,"file":"remoteMethods.cjs","names":[],"sources":["../../../../src/lib/remoteMethods.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {type RouterEntry, type Routes} from '../types/general.ts';\nimport {type RemoteMethod} from '../types/remoteMethods.ts';\nimport type {PublicApi} from '../types/publicMethods.ts';\nimport type {AnyObject, CompiledTypeFn, CompiledFnData, MethodWithOptions, PureFnsDataCache} from '@mionjs/core';\nimport {isRoute, isHeadersMiddlewareDef, isMiddlewareDef} from '../types/guards.ts';\nimport {getMiddlewareExecutable, getRouteExecutable, isPrivateDefinition, getPlatformMaxBodySize} from '../router.ts';\nimport {\n  getRouterItemId,\n  MAX_STACK_DEPTH,\n  getJitFnHashes,\n  DEFAULT_PARSER,\n  resolveCompiledPureFn,\n  EMPTY_HASH,\n  getOrCreateGlobal,\n  HandlerType,\n} from '@mionjs/core';\nimport {getRTUtils, RUN_TYPES_PURE_FN_ID_PREFIX} from '@mionjs/run-types/runtime';\n\n// ############# PRIVATE STATE #############\nconst publicMethods = getOrCreateGlobal('mion.remoteMethods.publicMethods', () => new Map<string, MethodWithOptions>());\n\n// ############# PUBLIC METHODS #############\nexport function resetRemoteMethodsMetadata() {\n  publicMethods.clear();\n}\n\n/** All the public information and types of the routes, what a router client is generated from. */\nexport function getPublicApi<R extends Routes>(routes: R): PublicApi<R> {\n  return recursiveGetSerializableRoutes(routes) as PublicApi<R>;\n}\n\n// ############# PRIVATE METHODS #############\n\nfunction recursiveGetSerializableRoutes<R extends Routes>(\n  routes: R,\n  currentPointer: string[] = [],\n  publicData: AnyObject = {}\n): AnyObject {\n  const entries = Object.entries(routes);\n  entries.forEach(([key, item]: [string, RouterEntry]) => {\n    const itemPointer = [...currentPointer, key];\n    const id = getRouterItemId(itemPointer);\n\n    if (isPrivateDefinition(item, id)) {\n      publicData[key] = null; // middlewares that don't receive or return data are not public\n    } else if (isMiddlewareDef(item) || isHeadersMiddlewareDef(item) || isRoute(item)) {\n      const executable = getMiddlewareExecutable(id) || getRouteExecutable(id);\n      if (!executable)\n        throw new Error(`Route or Middleware ${id} not found. Please check you have called mion.initRoutes first.`);\n      publicData[key] = getSerializableMethod(executable as RemoteMethod);\n    } else {\n      const subRoutes: Routes = routes[key] as Routes;\n      publicData[key] = recursiveGetSerializableRoutes(subRoutes, itemPointer);\n    }\n  });\n\n  return publicData;\n}\n\nexport function getSerializableMethod(executable: RemoteMethod): MethodWithOptions {\n  const existing = publicMethods.get(executable.id);\n  if (existing) return existing as MethodWithOptions;\n\n  const newRemoteMethod: MethodWithOptions = {\n    type: executable.type,\n    id: executable.id,\n    nestLevel: executable.nestLevel,\n    isAsync: executable.isAsync,\n    hasReturnData: executable.hasReturnData,\n    paramsJitHash: executable.paramsJitHash,\n    returnJitHash: executable.returnJitHash,\n    pointer: executable.pointer,\n    paramsCount: executable.paramsCount ?? 0,\n    paramNames: executable.paramNames,\n    // a route whose types could not say takes the platform's number: filled in here, once, so the\n    // client sees the limit the server really applies (the adapter has published it by now)\n    options:\n      executable.type === HandlerType.route && executable.options.maxBodySize === undefined\n        ? {...executable.options, maxBodySize: getPlatformMaxBodySize()}\n        : executable.options,\n  };\n  if (executable.syncId) newRemoteMethod.syncId = executable.syncId;\n  if (executable.headersParam) newRemoteMethod.headersParam = executable.headersParam;\n  // the client rebuilds a returned HeadersSubset from these names, so they must ride the wire\n  if (executable.headersReturn) {\n    newRemoteMethod.headersReturn = {\n      headerNames: executable.headersReturn.headerNames,\n      jitHash: executable.headersReturn.jitHash,\n    };\n  }\n  if (executable.middlewareIds) newRemoteMethod.middlewareIds = executable.middlewareIds;\n  publicMethods.set(executable.id, newRemoteMethod);\n  return newRemoteMethod as MethodWithOptions;\n}\n\n/** Serializes a pure function and everything it reaches into the wire cache, keyed by id. */\nexport function serializePureDeps(id: string, purFnDeps: PureFnsDataCache, depth = 0) {\n  if (depth >= MAX_STACK_DEPTH) throw new Error(`Max depth reached serializing pure function dependencies, for: ${id}`);\n  // Run-types' own pure fns never ride the wire: their bodies are hollowed in the dist build and served by\n  // the compiler, so each is already registered wherever `@mionjs/run-types` is loaded, guaranteed on the\n  // client since @mionjs/core value-imports it. addSerializedJitCaches skipped them on restore anyway.\n  if (id.startsWith(RUN_TYPES_PURE_FN_ID_PREFIX)) return;\n  // prevents infinite recursion on circular dependencies\n  if (purFnDeps[id]) return;\n  const pureDep = resolveCompiledPureFn(id);\n  if (!pureDep) throw new Error(`Pure function ${id} not found`);\n  // The client rebuilds a pure fn as `new Function(...paramNames, code)` and nothing else, so an entry with\n  // no code is unrecoverable there: fail here instead of shipping a payload that breaks on first use. With\n  // built-ins filtered out above, only a fn registered at runtime with no body reaches this: server-only.\n  if (!pureDep.code)\n    throw new Error(\n      `Pure function ${id} has no code payload and cannot be serialized to the client. ` +\n        `Runtime-registered pure fns are server-only; the client can rebuild only build-extracted ones.`\n    );\n  purFnDeps[id] = {\n    ...pureDep,\n    code: pureDep.code,\n    pureFnDependencies: pureDep.pureFnDependencies ? [...pureDep.pureFnDependencies] : undefined,\n  };\n  pureDep.pureFnDependencies?.forEach((depId) => serializePureDeps(depId, purFnDeps, depth + 1));\n}\n\nexport function serializeJitFn(rtFnHash: string, deps: Record<string, CompiledFnData>, purFnDeps: PureFnsDataCache, depth = 0) {\n  if (depth >= MAX_STACK_DEPTH)\n    throw new Error(`Max depth reached serializing jit function dependencies for jitHash: ${rtFnHash}`);\n  const jitFn = getRTUtils().getRT(rtFnHash);\n  if (!jitFn) throw new Error(`Jit function ${rtFnHash} not found`);\n  if (deps[rtFnHash]) return; // already serialized and prevent infinite recursion on circular dependencies\n  const serializedJitFn = getSerializableJitCompiler(jitFn);\n  deps[rtFnHash] = serializedJitFn;\n  jitFn.rtDependencies?.forEach((h) => serializeJitFn(h, deps, purFnDeps, depth + 1));\n  jitFn.pureFnDependencies?.forEach((h) => serializePureDeps(h, purFnDeps));\n}\n\nexport function serializeMethodDeps(\n  method: MethodWithOptions,\n  deps: Record<string, CompiledFnData>,\n  purFnDeps: PureFnsDataCache\n) {\n  const {paramsJitHash, returnJitHash} = method;\n  // an empty hash means no params, or a void return\n  const utl = getRTUtils();\n  const parser = method.options.parser ?? DEFAULT_PARSER;\n  if (paramsJitHash !== EMPTY_HASH) {\n    const paramsJitHashes = getJitFnHashes(paramsJitHash, parser.params);\n    for (const k in paramsJitHashes) {\n      if (utl.getRT(paramsJitHashes[k])) serializeJitFn(paramsJitHashes[k], deps, purFnDeps);\n    }\n  }\n  if (returnJitHash !== EMPTY_HASH) {\n    const returnJitHashes = getJitFnHashes(returnJitHash, parser.return);\n    let foundAny = false;\n    for (const k in returnJitHashes) {\n      if (utl.getRT(returnJitHashes[k])) {\n        serializeJitFn(returnJitHashes[k], deps, purFnDeps);\n        foundAny = true;\n      }\n    }\n    if (!foundAny) {\n      throw new Error(\n        `Method \"${method.id}\" declares returnJitHash=\"${returnJitHash}\" but no JIT functions are registered under that hash. ` +\n          `This usually means a Promise/Function return type was not unwrapped before computing the hash.`\n      );\n    }\n  }\n}\n\nfunction getSerializableJitCompiler(comp: CompiledTypeFn): CompiledFnData {\n  return {\n    typeName: comp.typeName,\n    fnID: comp.fnID,\n    // the exact emitting family — upstream's findRTForType gates on it, and unlike fnID it is\n    // not composited, so the client cannot recover it from anything else on the wire\n    familyTag: comp.familyTag,\n    rtFnHash: comp.rtFnHash,\n    args: {...comp.args},\n    isNoop: comp.isNoop,\n    defaultParamValues: {...comp.defaultParamValues},\n    code: comp.code,\n    rtDependencies: comp.rtDependencies ? [...comp.rtDependencies] : undefined,\n    pureFnDependencies: comp.pureFnDependencies ? [...comp.pureFnDependencies] : undefined,\n    // an alwaysThrow entry has no code, only this message; without it the client cannot rebuild\n    // the throwing factory and surfaces a bare TypeError instead of the build-time diagnostic\n    alwaysThrowMessage: comp.alwaysThrowMessage,\n  };\n}\n"],"mappings":"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"}

package/.dist/cjs/src/lib/remoteMethods.d.ts

@@ -1,11 +1,11 @@
 import { Routes } from '../types/general.ts';
 import { RemoteMethod } from '../types/remoteMethods.ts';
 import { PublicApi } from '../types/publicMethods.ts';
-import { JitCompiledFnData, MethodWithOptions, PureFnsDataCache } from '@mionjs/core';
+import { CompiledFnData, MethodWithOptions, PureFnsDataCache } from '@mionjs/core';
 export declare function resetRemoteMethodsMetadata(): void;
 export declare function getPublicApi<R extends Routes>(routes: R): PublicApi<R>;
 export declare function getSerializableMethod(executable: RemoteMethod): MethodWithOptions;
-export declare function serializePureDeps(namespacedDepHash: string, purFnDeps: PureFnsDataCache, depth?: number): void;
-export declare function serializeJitFn(jitFnHash: string, deps: Record<string, JitCompiledFnData>, purFnDeps: PureFnsDataCache, depth?: number): void;
-export declare function serializeMethodDeps(method: MethodWithOptions, deps: Record<string, JitCompiledFnData>, purFnDeps: PureFnsDataCache): void;
+export declare function serializePureDeps(id: string, purFnDeps: PureFnsDataCache, depth?: number): void;
+export declare function serializeJitFn(rtFnHash: string, deps: Record<string, CompiledFnData>, purFnDeps: PureFnsDataCache, depth?: number): void;
+export declare function serializeMethodDeps(method: MethodWithOptions, deps: Record<string, CompiledFnData>, purFnDeps: PureFnsDataCache): void;
 //# sourceMappingURL=remoteMethods.d.ts.map

package/.dist/cjs/src/lib/urlQuery.cjs

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/lib/urlQuery.ts
+/** The ONE reader of the url query string, `id=` for a batch and `data=` for a query body, so there is
+*  one set of rules for how a query splits. Router-internal: nothing outside this package reads it.
+*  Values come back RAW, no percent-decoding and no `+` turned into a space; a caller needing a decoded
+*  value calls `decodeURIComponent` itself, which lets the batch id decode while a query body must not. */
+function findMionQueryParam(urlQuery, name) {
+	if (!urlQuery || !name) return void 0;
+	const queryLength = urlQuery.length;
+	const nameLength = name.length;
+	let start = 0;
+	while (start < queryLength) {
+		let end = urlQuery.indexOf("&", start);
+		if (end === -1) end = queryLength;
+		let nameEnd = urlQuery.indexOf("=", start);
+		if (nameEnd === -1 || nameEnd > end) nameEnd = end;
+		if (nameEnd - start === nameLength && urlQuery.startsWith(name, start)) return nameEnd === end ? "" : urlQuery.slice(nameEnd + 1, end);
+		start = end + 1;
+	}
+}
+//#endregion
+exports.findMionQueryParam = findMionQueryParam;
+
+//# sourceMappingURL=urlQuery.cjs.map

package/.dist/cjs/src/lib/urlQuery.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlQuery.cjs","names":[],"sources":["../../../../src/lib/urlQuery.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\n/** The ONE reader of the url query string, `id=` for a batch and `data=` for a query body, so there is\n *  one set of rules for how a query splits. Router-internal: nothing outside this package reads it.\n *  Values come back RAW, no percent-decoding and no `+` turned into a space; a caller needing a decoded\n *  value calls `decodeURIComponent` itself, which lets the batch id decode while a query body must not. */\nexport function findMionQueryParam(urlQuery: string | undefined, name: string): string | undefined {\n  // an empty name is not a parameter: without this, a hostile `?=x` would answer a lookup for ''\n  if (!urlQuery || !name) return undefined;\n  const queryLength = urlQuery.length;\n  const nameLength = name.length;\n  let start = 0;\n  while (start < queryLength) {\n    let end = urlQuery.indexOf('&', start);\n    if (end === -1) end = queryLength;\n    // the name runs to the first `=` of this parameter, or to its end when it carries no value\n    let nameEnd = urlQuery.indexOf('=', start);\n    if (nameEnd === -1 || nameEnd > end) nameEnd = end;\n    // compare the length first, so a name that merely starts with the wanted one is not a match\n    if (nameEnd - start === nameLength && urlQuery.startsWith(name, start)) {\n      // `?flag` and `?flag=` both read as present with an empty value\n      return nameEnd === end ? '' : urlQuery.slice(nameEnd + 1, end);\n    }\n    start = end + 1;\n  }\n  return undefined;\n}\n"],"mappings":";;;;;;AAWA,SAAgB,mBAAmB,UAA8B,MAAkC;CAEjG,IAAI,CAAC,YAAY,CAAC,MAAM,OAAO,KAAA;CAC/B,MAAM,cAAc,SAAS;CAC7B,MAAM,aAAa,KAAK;CACxB,IAAI,QAAQ;CACZ,OAAO,QAAQ,aAAa;EAC1B,IAAI,MAAM,SAAS,QAAQ,KAAK,KAAK;EACrC,IAAI,QAAQ,IAAI,MAAM;EAEtB,IAAI,UAAU,SAAS,QAAQ,KAAK,KAAK;EACzC,IAAI,YAAY,MAAM,UAAU,KAAK,UAAU;EAE/C,IAAI,UAAU,UAAU,cAAc,SAAS,WAAW,MAAM,KAAK,GAEnE,OAAO,YAAY,MAAM,KAAK,SAAS,MAAM,UAAU,GAAG,GAAG;EAE/D,QAAQ,MAAM;CAChB;AAEF"}

package/.dist/cjs/src/lib/urlQuery.d.ts

@@ -0,0 +1,2 @@
+export declare function findMionQueryParam(urlQuery: string | undefined, name: string): string | undefined;
+//# sourceMappingURL=urlQuery.d.ts.map

package/.dist/cjs/src/middlewares/fetchMetadata.cjs

@@ -0,0 +1,99 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_src_types_guards = require("../types/guards.cjs");
+const require_src_batches = require("../batches.cjs");
+const require_src_lib_handlers = require("../lib/handlers.cjs");
+const require_src_lib_remoteMethods = require("../lib/remoteMethods.cjs");
+const require_src_router = require("../router.cjs");
+const require_A0Qb_E1CjDEA = require("../../.mion/types/A0Qb_E1CjDEA.cjs");
+const require_A0Qb_fMIJ1JT = require("../../.mion/types/A0Qb_fMIJ1JT.cjs");
+const require_Ky89_E1CjDEA = require("../../.mion/types/Ky89_E1CjDEA.cjs");
+const require_Ky89_fMIJ1JT = require("../../.mion/types/Ky89_fMIJ1JT.cjs");
+const require_Xhuv_E1CjDEA = require("../../.mion/types/Xhuv_E1CjDEA.cjs");
+const require_OBOg_E1CjDEA = require("../../.mion/types/OBOg_E1CjDEA.cjs");
+const require_OBOg_fMIJ1JT = require("../../.mion/types/OBOg_fMIJ1JT.cjs");
+const require_Xhuv_fMIJ1JT = require("../../.mion/types/Xhuv_fMIJ1JT.cjs");
+const require_mzca_fMIJ1JT = require("../../.mion/types/mzca_fMIJ1JT.cjs");
+const require_eF4wQzU6Fd = require("../../.mion/types/rt/eF4wQzU6Fd.cjs");
+let _mionjs_core = require("@mionjs/core");
+//#region src/middlewares/fetchMetadata.ts
+/** Rows alongside the call; with a mode, rows alone and the call stopped before its route runs. */
+function fetchMetadata(ctx, methodsIds, mode) {
+	if (mode) return new _mionjs_core.FatalError({
+		type: "metadata-only",
+		publicMessage: "Route metadata only: the call was stopped before its route.",
+		errorData: rowsFor(methodsIds ?? [], mode === "all"),
+		statusCode: _mionjs_core.StatusCodes.OK
+	});
+	if (!methodsIds || methodsIds.length === 0) return;
+	const { metadata, notFound } = rowsFor(methodsIds, false);
+	if (notFound) return new _mionjs_core.RpcError({
+		type: "rpc-metadata-not-found",
+		publicMessage: "Errors getting Remote Methods Metadata",
+		errorData: notFound
+	});
+	return metadata;
+}
+/** With `all`, every public method instead of the given ids, plus the batch ids. */
+function rowsFor(methodsIds, all) {
+	const metadata = {
+		methods: {},
+		deps: {},
+		purFnDeps: {}
+	};
+	const notFound = {};
+	const shouldReturnAll = all && require_src_router.getTotalExecutables() <= require_src_router.getRouterOptions().getAllRemoteMethodsMaxNumber;
+	(shouldReturnAll ? require_src_router.getAllExecutablesIds().filter((id) => !require_src_lib_handlers.mionInternalRouteIds.has(id) && require_src_types_guards.isPublicExecutable(require_src_router.getAnyExecutable(id))) : methodsIds).forEach((id) => addRequiredRemoteMethodsToResponse(id, metadata, notFound));
+	if (shouldReturnAll) metadata.batches = require_src_batches.getBatchIds();
+	const answer = { metadata };
+	if (Object.keys(notFound).length) answer.notFound = notFound;
+	if (all && !shouldReturnAll) answer.truncated = true;
+	return answer;
+}
+/** The rows of the given methods and of their chains; an unknown id is left out. */
+function getMethodsDataFor(ids) {
+	return rowsFor(ids, false).metadata;
+}
+function addRequiredRemoteMethodsToResponse(id, resp, errorData) {
+	const { methods, deps, purFnDeps } = resp;
+	if (methods[id]) return;
+	if (require_src_lib_handlers.mionInternalRouteIds.has(id)) return;
+	const executable = require_src_router.getMiddlewareExecutable(id) || require_src_router.getRouteExecutable(id);
+	if (!executable) {
+		errorData[id] = `Remote Method ${id} not found`;
+		return;
+	}
+	if (!require_src_types_guards.isPublicExecutable(executable)) return;
+	const method = require_src_lib_remoteMethods.getSerializableMethod(executable);
+	methods[id] = method;
+	method.middlewareIds?.forEach((middlewareId) => addRequiredRemoteMethodsToResponse(middlewareId, resp, errorData));
+	require_src_lib_remoteMethods.serializeMethodDeps(method, deps, purFnDeps);
+}
+/** Sent on every call so a stale client can recover; set, not returned, so the middleware's answer stays the rows. */
+function setBuildVersionHeader(ctx) {
+	const version = require_src_router.getBuildVersion();
+	if (version) ctx.response.headers.set(_mionjs_core.BUILD_VERSION_HEADER, version);
+}
+var mionFetchMetadata = require_src_lib_handlers.markOnDemand(require_src_lib_handlers.middleware(fetchMetadata, {
+	alwaysRun: true,
+	parser: {
+		params: "clone",
+		return: "clone"
+	},
+	maxBodySize: 4096
+}, [
+	require_Xhuv_fMIJ1JT.__rt_Xhuv_fMIJ1JT,
+	require_OBOg_fMIJ1JT.__rt_OBOg_fMIJ1JT,
+	require_mzca_fMIJ1JT.__rt_mzca_fMIJ1JT,
+	require_A0Qb_fMIJ1JT.__rt_A0Qb_fMIJ1JT,
+	require_Ky89_fMIJ1JT.__rt_Ky89_fMIJ1JT
+], [
+	require_Xhuv_E1CjDEA.__rt_Xhuv_E1CjDEA,
+	require_OBOg_E1CjDEA.__rt_OBOg_E1CjDEA,
+	require_A0Qb_E1CjDEA.__rt_A0Qb_E1CjDEA,
+	require_Ky89_E1CjDEA.__rt_Ky89_E1CjDEA
+], require_eF4wQzU6Fd.__rt_fMIJ1JT, require_eF4wQzU6Fd.__rt_E1CjDEA, require_eF4wQzU6Fd.__rt_w6KmCD1, require_eF4wQzU6Fd.__rt_HmqctzF), setBuildVersionHeader);
+//#endregion
+exports.getMethodsDataFor = getMethodsDataFor;
+exports.mionFetchMetadata = mionFetchMetadata;
+
+//# sourceMappingURL=fetchMetadata.cjs.map

package/.dist/cjs/src/middlewares/fetchMetadata.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchMetadata.cjs","names":[],"sources":["../../../../src/middlewares/fetchMetadata.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {BUILD_VERSION_HEADER, FatalError, RpcError, SerializableMethodsData, StatusCodes} from '@mionjs/core';\nimport type {FetchMetadataHandler, FetchMetadataMode, FetchMetadataOnlyData} from '@mionjs/core/middlewares';\nimport {\n  getMiddlewareExecutable,\n  getRouteExecutable,\n  getRouterOptions,\n  getTotalExecutables,\n  getAllExecutablesIds,\n  getAnyExecutable,\n  getBuildVersion,\n} from '../router.ts';\nimport {markOnDemand, middleware, mionInternalRouteIds} from '../lib/handlers.ts';\nimport {isPublicExecutable} from '../types/guards.ts';\nimport {getBatchIds} from '../batches.ts';\nimport {getSerializableMethod, serializeMethodDeps} from '../lib/remoteMethods.ts';\nimport {RemoteMethod} from '../types/remoteMethods.ts';\nimport {CallContext} from '../types/context.ts';\n\n/** Rows alongside the call; with a mode, rows alone and the call stopped before its route runs. */\nfunction fetchMetadata(ctx: CallContext, methodsIds?: string[], mode?: FetchMetadataMode): ReturnType<FetchMetadataHandler> {\n  if (mode) {\n    return new FatalError<'metadata-only', FetchMetadataOnlyData>({\n      type: 'metadata-only',\n      publicMessage: 'Route metadata only: the call was stopped before its route.',\n      errorData: rowsFor(methodsIds ?? [], mode === 'all'),\n      // an answer, not a failure: access logs and monitoring count it as a success\n      statusCode: StatusCodes.OK,\n    });\n  }\n  if (!methodsIds || methodsIds.length === 0) return;\n  const {metadata, notFound} = rowsFor(methodsIds, false);\n  if (notFound)\n    return new RpcError({\n      type: 'rpc-metadata-not-found',\n      publicMessage: 'Errors getting Remote Methods Metadata',\n      errorData: notFound,\n    });\n  return metadata;\n}\n\n/** With `all`, every public method instead of the given ids, plus the batch ids. */\nfunction rowsFor(methodsIds: string[], all: boolean): FetchMetadataOnlyData {\n  const metadata: SerializableMethodsData = {methods: {}, deps: {}, purFnDeps: {}};\n  const notFound: Record<string, string> = {};\n  const shouldReturnAll = all && getTotalExecutables() <= getRouterOptions().getAllRemoteMethodsMaxNumber;\n  const idsToReturn = shouldReturnAll\n    ? getAllExecutablesIds().filter(\n        (id) => !mionInternalRouteIds.has(id) && isPublicExecutable(getAnyExecutable(id) as RemoteMethod)\n      )\n    : methodsIds;\n  idsToReturn.forEach((id) => addRequiredRemoteMethodsToResponse(id, metadata, notFound));\n  // A hand-written client can only send ids the build compiled in, so list them alongside the methods\n  if (shouldReturnAll) metadata.batches = getBatchIds();\n  const answer: FetchMetadataOnlyData = {metadata};\n  if (Object.keys(notFound).length) answer.notFound = notFound;\n  if (all && !shouldReturnAll) answer.truncated = true;\n  return answer;\n}\n\n/** The rows of the given methods and of their chains; an unknown id is left out. */\nexport function getMethodsDataFor(ids: string[]): SerializableMethodsData {\n  return rowsFor(ids, false).metadata;\n}\n\nfunction addRequiredRemoteMethodsToResponse(id: string, resp: SerializableMethodsData, errorData: Record<string, string>): void {\n  const {methods, deps, purFnDeps} = resp;\n  if (methods[id]) return;\n  if (mionInternalRouteIds.has(id)) return;\n  const executable = getMiddlewareExecutable(id) || getRouteExecutable(id);\n  if (!executable) {\n    errorData[id] = `Remote Method ${id} not found`;\n    return;\n  }\n  if (!isPublicExecutable(executable)) return;\n  const method = getSerializableMethod(executable as RemoteMethod);\n  methods[id] = method;\n  method.middlewareIds?.forEach((middlewareId) => addRequiredRemoteMethodsToResponse(middlewareId, resp, errorData));\n  serializeMethodDeps(method, deps, purFnDeps);\n}\n\n/** Sent on every call so a stale client can recover; set, not returned, so the middleware's answer stays the rows. */\nfunction setBuildVersionHeader(ctx: CallContext): void {\n  const version = getBuildVersion();\n  if (version) ctx.response.headers.set(BUILD_VERSION_HEADER, version);\n}\n\n// Place it at the root, before any route: its `only` and `all` modes must stop the chain before the route.\n// Pins the built-in parser: a client asks before it knows any strategy.\n// In every chain with an unbounded `string[]`, so maxBodySize is a fixed share of each limit: room for a first call's ids.\nexport const mionFetchMetadata = markOnDemand(\n  middleware(fetchMetadata satisfies FetchMetadataHandler, {\n    alwaysRun: true,\n    parser: {params: 'clone', return: 'clone'},\n    maxBodySize: 4096,\n  }),\n  setBuildVersionHeader\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA0BA,SAAS,cAAc,KAAkB,YAAuB,MAA4D;CAC1H,IAAI,MACF,OAAO,IAAI,aAAA,WAAmD;EAC5D,MAAM;EACN,eAAe;EACf,WAAW,QAAQ,cAAc,CAAC,GAAG,SAAS,KAAK;EAEnD,YAAY,aAAA,YAAY;CAC1B,CAAC;CAEH,IAAI,CAAC,cAAc,WAAW,WAAW,GAAG;CAC5C,MAAM,EAAC,UAAU,aAAY,QAAQ,YAAY,KAAK;CACtD,IAAI,UACF,OAAO,IAAI,aAAA,SAAS;EAClB,MAAM;EACN,eAAe;EACf,WAAW;CACb,CAAC;CACH,OAAO;AACT;;AAGA,SAAS,QAAQ,YAAsB,KAAqC;CAC1E,MAAM,WAAoC;EAAC,SAAS,CAAC;EAAG,MAAM,CAAC;EAAG,WAAW,CAAC;CAAC;CAC/E,MAAM,WAAmC,CAAC;CAC1C,MAAM,kBAAkB,OAAO,mBAAA,oBAAoB,KAAK,mBAAA,iBAAiB,EAAE;CAM3E,CALoB,kBAChB,mBAAA,qBAAqB,EAAE,QACpB,OAAO,CAAC,yBAAA,qBAAqB,IAAI,EAAE,KAAK,yBAAA,mBAAmB,mBAAA,iBAAiB,EAAE,CAAiB,CAClG,IACA,YACQ,SAAS,OAAO,mCAAmC,IAAI,UAAU,QAAQ,CAAC;CAEtF,IAAI,iBAAiB,SAAS,UAAU,oBAAA,YAAY;CACpD,MAAM,SAAgC,EAAC,SAAQ;CAC/C,IAAI,OAAO,KAAK,QAAQ,EAAE,QAAQ,OAAO,WAAW;CACpD,IAAI,OAAO,CAAC,iBAAiB,OAAO,YAAY;CAChD,OAAO;AACT;;AAGA,SAAgB,kBAAkB,KAAwC;CACxE,OAAO,QAAQ,KAAK,KAAK,EAAE;AAC7B;AAEA,SAAS,mCAAmC,IAAY,MAA+B,WAAyC;CAC9H,MAAM,EAAC,SAAS,MAAM,cAAa;CACnC,IAAI,QAAQ,KAAK;CACjB,IAAI,yBAAA,qBAAqB,IAAI,EAAE,GAAG;CAClC,MAAM,aAAa,mBAAA,wBAAwB,EAAE,KAAK,mBAAA,mBAAmB,EAAE;CACvE,IAAI,CAAC,YAAY;EACf,UAAU,MAAM,iBAAiB,GAAG;EACpC;CACF;CACA,IAAI,CAAC,yBAAA,mBAAmB,UAAU,GAAG;CACrC,MAAM,SAAS,8BAAA,sBAAsB,UAA0B;CAC/D,QAAQ,MAAM;CACd,OAAO,eAAe,SAAS,iBAAiB,mCAAmC,cAAc,MAAM,SAAS,CAAC;CACjH,8BAAA,oBAAoB,QAAQ,MAAM,SAAS;AAC7C;;AAGA,SAAS,sBAAsB,KAAwB;CACrD,MAAM,UAAU,mBAAA,gBAAgB;CAChC,IAAI,SAAS,IAAI,SAAS,QAAQ,IAAI,aAAA,sBAAsB,OAAO;AACrE;AAKA,IAAa,oBAAoB,yBAAA,aAC/B,yBAAA,WAAW,eAA8C;CACvD,WAAW;CACX,QAAQ;EAAC,QAAQ;EAAS,QAAQ;CAAO;CACzC,aAAa;AACf,GAAA;CAAA,qBAAA;CAAA,qBAAA;CAAA,qBAAA;CAAA,qBAAA;CAAA,qBAAA;AAAA,GAAA;CAAA,qBAAA;CAAA,qBAAA;CAAA,qBAAA;CAAA,qBAAA;AAAA,GAAA,mBAAA,cAAA,mBAAA,cAAA,mBAAA,cAAA,mBAAA,YAAC,GACD,qBACF"}

package/.dist/cjs/src/middlewares/fetchMetadata.d.ts

@@ -0,0 +1,15 @@
+import { SerializableMethodsData } from '@mionjs/core';
+import { FetchMetadataHandler, FetchMetadataMode } from '@mionjs/core/middlewares';
+import { CallContext } from '../types/context.ts';
+declare function fetchMetadata(ctx: CallContext, methodsIds?: string[], mode?: FetchMetadataMode): ReturnType<FetchMetadataHandler>;
+export declare function getMethodsDataFor(ids: string[]): SerializableMethodsData;
+export declare const mionFetchMetadata: import('../types/definitions.ts').MiddlewareDef<typeof fetchMetadata, {
+    readonly alwaysRun: true;
+    readonly parser: {
+        readonly params: "clone";
+        readonly return: "clone";
+    };
+    readonly maxBodySize: 4096;
+}, Partial<import('../types/general.ts').RouterOptions<any, any>>>;
+export {};
+//# sourceMappingURL=fetchMetadata.d.ts.map

package/.dist/cjs/src/middlewares/syncRoutes.cjs

@@ -0,0 +1,67 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_src_lib_handlers = require("../lib/handlers.cjs");
+const require_src_router = require("../router.cjs");
+const require_src_middlewares_fetchMetadata = require("./fetchMetadata.cjs");
+const require_A0Qb_D5PMNNO = require("../../.mion/types/A0Qb_D5PMNNO.cjs");
+const require_A0Qb_kibOHkN = require("../../.mion/types/A0Qb_kibOHkN.cjs");
+const require_Ky89_D5PMNNO = require("../../.mion/types/Ky89_D5PMNNO.cjs");
+const require_Ky89_kibOHkN = require("../../.mion/types/Ky89_kibOHkN.cjs");
+const require_Xhuv_D5PMNNO = require("../../.mion/types/Xhuv_D5PMNNO.cjs");
+const require_OBOg_D5PMNNO = require("../../.mion/types/OBOg_D5PMNNO.cjs");
+const require_OBOg_kibOHkN = require("../../.mion/types/OBOg_kibOHkN.cjs");
+const require_Xhuv_kibOHkN = require("../../.mion/types/Xhuv_kibOHkN.cjs");
+const require_mzca_kibOHkN = require("../../.mion/types/mzca_kibOHkN.cjs");
+const require_C7ezVBCtGn = require("../../.mion/types/rt/C7ezVBCtGn.cjs");
+let _mionjs_core = require("@mionjs/core");
+//#region src/middlewares/syncRoutes.ts
+/** Refuses a call whose route sync ids are missing or differ, before any route runs. */
+function syncRoutes(ctx, routeSyncIds) {
+	const routes = getCalledRoutes(ctx);
+	const mismatched = [];
+	let missing = false;
+	for (let i = 0; i < routes.length; i++) {
+		const sent = routeSyncIds?.[i];
+		if (!sent) missing = true;
+		else if (sent !== routes[i].syncId) mismatched.push(routes[i].id);
+	}
+	if (mismatched.length) return new _mionjs_core.FatalError({
+		type: "route-types-mismatch",
+		publicMessage: `The types of ${mismatched.map((id) => `"${id}"`).join(", ")} changed on the server since this client was built. Reload the app or rebuild the client against the current API.`,
+		errorData: { routeIds: mismatched }
+	});
+	if (missing) return new _mionjs_core.FatalError({
+		type: "route-sync-required",
+		publicMessage: "This server checks each route before running it: send the route sync ids along with the call.",
+		errorData: { metadata: require_src_middlewares_fetchMetadata.getMethodsDataFor(routes.map((route) => route.id)) }
+	});
+}
+/** The routes a call runs, in call order; mion's own routes are never checked. */
+function getCalledRoutes(ctx) {
+	if (ctx.batchRouteIds) return ctx.batchRouteIds.map((id) => require_src_router.getRouteExecutable(id));
+	const { executionChain } = ctx;
+	const route = executionChain.methods[executionChain.routeIndex];
+	if (!route || require_src_lib_handlers.mionInternalRouteIds.has(route.id)) return [];
+	return [route];
+}
+var mionSyncRoutes = require_src_lib_handlers.middleware(syncRoutes, {
+	parser: {
+		params: "clone",
+		return: "clone"
+	},
+	maxBodySize: 1024
+}, [
+	require_Xhuv_kibOHkN.__rt_Xhuv_kibOHkN,
+	require_OBOg_kibOHkN.__rt_OBOg_kibOHkN,
+	require_mzca_kibOHkN.__rt_mzca_kibOHkN,
+	require_A0Qb_kibOHkN.__rt_A0Qb_kibOHkN,
+	require_Ky89_kibOHkN.__rt_Ky89_kibOHkN
+], [
+	require_Xhuv_D5PMNNO.__rt_Xhuv_D5PMNNO,
+	require_OBOg_D5PMNNO.__rt_OBOg_D5PMNNO,
+	require_A0Qb_D5PMNNO.__rt_A0Qb_D5PMNNO,
+	require_Ky89_D5PMNNO.__rt_Ky89_D5PMNNO
+], require_C7ezVBCtGn.__rt_kibOHkN, require_C7ezVBCtGn.__rt_D5PMNNO, require_C7ezVBCtGn.__rt_w6KmCD1, require_C7ezVBCtGn.__rt_RzooVQg);
+//#endregion
+exports.mionSyncRoutes = mionSyncRoutes;
+
+//# sourceMappingURL=syncRoutes.cjs.map

package/.dist/cjs/src/middlewares/syncRoutes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncRoutes.cjs","names":[],"sources":["../../../../src/middlewares/syncRoutes.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {FatalError} from '@mionjs/core';\nimport type {RouteSyncError, RouteSyncErrorData, SyncRoutesHandler} from '@mionjs/core/middlewares';\nimport {middleware, mionInternalRouteIds} from '../lib/handlers.ts';\nimport {getRouteExecutable} from '../router.ts';\nimport {getMethodsDataFor} from './fetchMetadata.ts';\nimport type {RemoteMethod} from '../types/remoteMethods.ts';\nimport type {CallContext} from '../types/context.ts';\n\n/** Refuses a call whose route sync ids are missing or differ, before any route runs. */\nfunction syncRoutes(ctx: CallContext, routeSyncIds?: string[]): RouteSyncError | void {\n  const routes = getCalledRoutes(ctx);\n  const mismatched: string[] = [];\n  let missing = false;\n  for (let i = 0; i < routes.length; i++) {\n    const sent = routeSyncIds?.[i];\n    if (!sent) missing = true;\n    else if (sent !== routes[i].syncId) mismatched.push(routes[i].id);\n  }\n  if (mismatched.length) {\n    return new FatalError<'route-types-mismatch', RouteSyncErrorData>({\n      type: 'route-types-mismatch',\n      publicMessage:\n        `The types of ${mismatched.map((id) => `\"${id}\"`).join(', ')} changed on the server since this client was built. ` +\n        `Reload the app or rebuild the client against the current API.`,\n      errorData: {routeIds: mismatched},\n    });\n  }\n  if (missing) {\n    return new FatalError<'route-sync-required', RouteSyncErrorData>({\n      type: 'route-sync-required',\n      publicMessage: 'This server checks each route before running it: send the route sync ids along with the call.',\n      errorData: {metadata: getMethodsDataFor(routes.map((route) => route.id))},\n    });\n  }\n}\n\n/** The routes a call runs, in call order; mion's own routes are never checked. */\nfunction getCalledRoutes(ctx: CallContext): RemoteMethod[] {\n  if (ctx.batchRouteIds) return ctx.batchRouteIds.map((id) => getRouteExecutable(id) as RemoteMethod);\n  const {executionChain} = ctx;\n  const route = executionChain.methods[executionChain.routeIndex];\n  if (!route || mionInternalRouteIds.has(route.id)) return [];\n  return [route];\n}\n\n// Place it first in the routes so a refused call runs nothing else.\n// The router-wide parser never reaches this helper at build time; a fixed body share keeps chain limits type-derived.\nexport const mionSyncRoutes = middleware(syncRoutes satisfies SyncRoutesHandler, {\n  parser: {params: 'clone', return: 'clone'},\n  maxBodySize: 1024,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,SAAS,WAAW,KAAkB,cAAgD;CACpF,MAAM,SAAS,gBAAgB,GAAG;CAClC,MAAM,aAAuB,CAAC;CAC9B,IAAI,UAAU;CACd,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;EACtC,MAAM,OAAO,eAAe;EAC5B,IAAI,CAAC,MAAM,UAAU;OAChB,IAAI,SAAS,OAAO,GAAG,QAAQ,WAAW,KAAK,OAAO,GAAG,EAAE;CAClE;CACA,IAAI,WAAW,QACb,OAAO,IAAI,aAAA,WAAuD;EAChE,MAAM;EACN,eACE,gBAAgB,WAAW,KAAK,OAAO,IAAI,GAAG,EAAE,EAAE,KAAK,IAAI,EAAE;EAE/D,WAAW,EAAC,UAAU,WAAU;CAClC,CAAC;CAEH,IAAI,SACF,OAAO,IAAI,aAAA,WAAsD;EAC/D,MAAM;EACN,eAAe;EACf,WAAW,EAAC,UAAU,sCAAA,kBAAkB,OAAO,KAAK,UAAU,MAAM,EAAE,CAAC,EAAC;CAC1E,CAAC;AAEL;;AAGA,SAAS,gBAAgB,KAAkC;CACzD,IAAI,IAAI,eAAe,OAAO,IAAI,cAAc,KAAK,OAAO,mBAAA,mBAAmB,EAAE,CAAiB;CAClG,MAAM,EAAC,mBAAkB;CACzB,MAAM,QAAQ,eAAe,QAAQ,eAAe;CACpD,IAAI,CAAC,SAAS,yBAAA,qBAAqB,IAAI,MAAM,EAAE,GAAG,OAAO,CAAC;CAC1D,OAAO,CAAC,KAAK;AACf;AAIA,IAAa,iBAAiB,yBAAA,WAAW,YAAwC;CAC/E,QAAQ;EAAC,QAAQ;EAAS,QAAQ;CAAO;CACzC,aAAa;AACf,GAAA;CAAA,qBAAA;CAAA,qBAAA;CAAA,qBAAA;CAAA,qBAAA;CAAA,qBAAA;AAAA,GAAA;CAAA,qBAAA;CAAA,qBAAA;CAAA,qBAAA;CAAA,qBAAA;AAAA,GAAA,mBAAA,cAAA,mBAAA,cAAA,mBAAA,cAAA,mBAAA,YAAC"}

package/.dist/cjs/src/middlewares/syncRoutes.d.ts

@@ -0,0 +1,12 @@
+import { RouteSyncError } from '@mionjs/core/middlewares';
+import { CallContext } from '../types/context.ts';
+declare function syncRoutes(ctx: CallContext, routeSyncIds?: string[]): RouteSyncError | void;
+export declare const mionSyncRoutes: import('../types/definitions.ts').MiddlewareDef<typeof syncRoutes, {
+    readonly parser: {
+        readonly params: "clone";
+        readonly return: "clone";
+    };
+    readonly maxBodySize: 1024;
+}, Partial<import('../types/general.ts').RouterOptions<any, any>>>;
+export {};
+//# sourceMappingURL=syncRoutes.d.ts.map