@mionjs/devtools 0.8.0-alpha.0

package/build/eslint/esm/src/eslint/rules/strong-typed-routes.js

@@ -0,0 +1,329 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+const ROUTER_FUNCTIONS = ["route", "middleFn", "headersFn"];
+const HANDLER_TYPES = ["Handler", "HeaderHandler"];
+function buildImportCache(program) {
+  const routerFunctions = /* @__PURE__ */ new Set();
+  const handlerTypes = /* @__PURE__ */ new Set();
+  for (const statement of program.body) {
+    if (statement.type === AST_NODE_TYPES.ImportDeclaration) {
+      const source = statement.source.value;
+      if (source === "@mionjs/router" || source === "@mionjs/router/") {
+        for (const specifier of statement.specifiers) {
+          if (specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES.Identifier) {
+            const name = specifier.imported.name;
+            if (ROUTER_FUNCTIONS.includes(name)) {
+              routerFunctions.add(name);
+            }
+            if (HANDLER_TYPES.includes(name)) {
+              handlerTypes.add(name);
+            }
+          }
+        }
+      }
+    }
+  }
+  return { routerFunctions, handlerTypes };
+}
+function getRouterFunctionName(node, importCache) {
+  if (node.callee.type !== AST_NODE_TYPES.Identifier) {
+    return null;
+  }
+  const functionName = node.callee.name;
+  if (importCache.routerFunctions.has(functionName)) {
+    return functionName;
+  }
+  return null;
+}
+function buildFunctionCache(program) {
+  const cache = /* @__PURE__ */ new Map();
+  for (const statement of program.body) {
+    if (statement.type === AST_NODE_TYPES.FunctionDeclaration && statement.id?.name) {
+      cache.set(statement.id.name, statement);
+    }
+    if (statement.type === AST_NODE_TYPES.VariableDeclaration) {
+      for (const declarator of statement.declarations) {
+        if (declarator.id.type === AST_NODE_TYPES.Identifier) {
+          if (declarator.init?.type === AST_NODE_TYPES.ArrowFunctionExpression || declarator.init?.type === AST_NODE_TYPES.FunctionExpression) {
+            cache.set(declarator.id.name, declarator.init);
+          }
+        }
+      }
+    }
+  }
+  return cache;
+}
+function getHandlerFunction(node, functionCache) {
+  const handlerIndex = 0;
+  if (node.arguments.length <= handlerIndex) {
+    return null;
+  }
+  const handlerArg = node.arguments[handlerIndex];
+  if (handlerArg.type === AST_NODE_TYPES.ArrowFunctionExpression || handlerArg.type === AST_NODE_TYPES.FunctionExpression) {
+    return handlerArg;
+  }
+  if (handlerArg.type === AST_NODE_TYPES.Identifier) {
+    return functionCache.get(handlerArg.name) ?? null;
+  }
+  return null;
+}
+function hasExplicitReturnType(func) {
+  return func.returnType !== void 0;
+}
+function isPrimitiveLiteral(node) {
+  if (node.type === AST_NODE_TYPES.Literal) {
+    const value = node.value;
+    if ("bigint" in node) {
+      return true;
+    }
+    return typeof value === "boolean" || typeof value === "string" || typeof value === "number" || value === null;
+  }
+  if (node.type === AST_NODE_TYPES.Identifier && node.name === "undefined") {
+    return true;
+  }
+  if (node.type === AST_NODE_TYPES.UnaryExpression && node.operator === "-" && node.argument.type === AST_NODE_TYPES.Literal) {
+    return typeof node.argument.value === "number";
+  }
+  return false;
+}
+function validateParameterTypes(func) {
+  const missingTypeParams = [];
+  const missingParamNodes = [];
+  for (let i = 1; i < func.params.length; i++) {
+    const param = func.params[i];
+    if (param.type === AST_NODE_TYPES.Identifier) {
+      if (!param.typeAnnotation) {
+        missingTypeParams.push(param.name);
+        missingParamNodes.push(param);
+      }
+    } else if (param.type === AST_NODE_TYPES.RestElement) {
+      if (param.argument.type === AST_NODE_TYPES.Identifier && !param.typeAnnotation) {
+        missingTypeParams.push(`...${param.argument.name}`);
+        missingParamNodes.push(param);
+      }
+    } else if (param.type === AST_NODE_TYPES.ArrayPattern || param.type === AST_NODE_TYPES.ObjectPattern) {
+      if (!param.typeAnnotation) {
+        missingTypeParams.push(`parameter ${i + 1}`);
+        missingParamNodes.push(param);
+      }
+    } else if (param.type === AST_NODE_TYPES.AssignmentPattern) {
+      const hasTypeAnnotationOnPattern = param.typeAnnotation !== void 0;
+      const hasTypeAnnotationOnLeft = param.left.type === AST_NODE_TYPES.Identifier && param.left.typeAnnotation !== void 0;
+      const hasTypeAnnotation = hasTypeAnnotationOnPattern || hasTypeAnnotationOnLeft;
+      const hasPrimitiveDefault = isPrimitiveLiteral(param.right);
+      if (!hasTypeAnnotation && !hasPrimitiveDefault) {
+        const paramName = param.left.type === AST_NODE_TYPES.Identifier ? param.left.name : `parameter ${i + 1}`;
+        missingTypeParams.push(paramName);
+        missingParamNodes.push(param);
+      }
+    } else if (!("typeAnnotation" in param) || !param.typeAnnotation) {
+      missingTypeParams.push(`parameter ${i + 1}`);
+      missingParamNodes.push(param);
+    }
+  }
+  return {
+    valid: missingTypeParams.length === 0,
+    missingTypeParams,
+    missingParamNodes
+  };
+}
+function getParameterName(param) {
+  if (param.type === AST_NODE_TYPES.Identifier) {
+    return param.name;
+  } else if (param.type === AST_NODE_TYPES.RestElement && param.argument.type === AST_NODE_TYPES.Identifier) {
+    return `...${param.argument.name}`;
+  } else if (param.type === AST_NODE_TYPES.ArrayPattern) {
+    return "[...]";
+  } else if (param.type === AST_NODE_TYPES.ObjectPattern) {
+    return "{...}";
+  } else if (param.type === AST_NODE_TYPES.AssignmentPattern) {
+    if (param.left.type === AST_NODE_TYPES.Identifier) {
+      return param.left.name;
+    }
+    return "param";
+  }
+  return "param";
+}
+function getReturnTypeReportNode(func) {
+  if ((func.type === AST_NODE_TYPES.FunctionDeclaration || func.type === AST_NODE_TYPES.FunctionExpression) && func.id) {
+    return func.id;
+  }
+  return func;
+}
+function getHandlerTypeFromAnnotation(typeAnnotation, importCache) {
+  if (typeAnnotation.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference) {
+    const typeName = typeAnnotation.typeAnnotation.typeName;
+    if (typeName.type === AST_NODE_TYPES.Identifier) {
+      const name = typeName.name;
+      if ((name === "Handler" || name === "HeaderHandler") && importCache.handlerTypes.has(name)) {
+        return name;
+      }
+    }
+  }
+  return null;
+}
+function getHandlerTypeFromSatisfies(satisfiesExpression, importCache) {
+  if (satisfiesExpression.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference) {
+    const typeName = satisfiesExpression.typeAnnotation.typeName;
+    if (typeName.type === AST_NODE_TYPES.Identifier) {
+      const name = typeName.name;
+      if ((name === "Handler" || name === "HeaderHandler") && importCache.handlerTypes.has(name)) {
+        return name;
+      }
+    }
+  }
+  return null;
+}
+function getHandlerTypeFromJSDoc(node, context) {
+  const sourceCode = context.sourceCode;
+  const comments = sourceCode.getCommentsBefore(node);
+  for (const comment of comments) {
+    if (comment.type === "Block") {
+      const commentText = comment.value;
+      if (commentText.includes("@mion:route")) {
+        return "Handler";
+      }
+      if (commentText.includes("@mion:middleFn")) {
+        return "MiddleFnHandler";
+      }
+      if (commentText.includes("@mion:headersFn")) {
+        return "HeaderHandler";
+      }
+    }
+  }
+  return null;
+}
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce explicit parameters and return type annotations for router handler functions"
+    },
+    messages: {
+      missingReturnType: "mion {{handlerType}}() handler must define a return type.",
+      missingParamTypes: 'mion parameter "{{paramName}}" must have an explicit type definition.',
+      missingReturnTypeRouter: "mion {{routerFunction}}() handler must define a return type.",
+      missingParamTypesRouter: 'mion parameter "{{paramName}}" must have an explicit type definition.'
+    },
+    schema: []
+    // No options
+  },
+  defaultOptions: [],
+  create(context) {
+    let importCache = null;
+    let functionCache = null;
+    return {
+      // Build caches once when we start processing the file
+      Program(node) {
+        importCache = buildImportCache(node);
+        functionCache = buildFunctionCache(node);
+      },
+      CallExpression(node) {
+        if (!importCache || !functionCache) return;
+        const functionName = getRouterFunctionName(node, importCache);
+        if (!functionName) {
+          return;
+        }
+        const handlerFunc = getHandlerFunction(node, functionCache);
+        if (!handlerFunc) {
+          return;
+        }
+        const hasReturnType = hasExplicitReturnType(handlerFunc);
+        const paramValidation = validateParameterTypes(handlerFunc);
+        if (!hasReturnType) {
+          context.report({
+            node: getReturnTypeReportNode(handlerFunc),
+            messageId: "missingReturnTypeRouter",
+            data: {
+              routerFunction: functionName
+            }
+          });
+        }
+        for (const paramNode of paramValidation.missingParamNodes) {
+          context.report({
+            node: paramNode,
+            messageId: "missingParamTypesRouter",
+            data: {
+              paramName: getParameterName(paramNode)
+            }
+          });
+        }
+      },
+      // Check variable declarations with type annotations or JSDoc tags
+      VariableDeclarator(node) {
+        if (!importCache) return;
+        if (node.id.type === AST_NODE_TYPES.Identifier) {
+          let handlerType = null;
+          if (node.id.typeAnnotation) {
+            handlerType = getHandlerTypeFromAnnotation(node.id.typeAnnotation, importCache);
+          }
+          if (!handlerType && node.parent?.type === AST_NODE_TYPES.VariableDeclaration) {
+            handlerType = getHandlerTypeFromJSDoc(node.parent, context);
+          }
+          if (handlerType && (node.init?.type === AST_NODE_TYPES.ArrowFunctionExpression || node.init?.type === AST_NODE_TYPES.FunctionExpression)) {
+            checkHandlerFunction(node.init, handlerType, context);
+          }
+        }
+      },
+      // Check satisfies expressions
+      TSSatisfiesExpression(node) {
+        if (!importCache) return;
+        const handlerType = getHandlerTypeFromSatisfies(node, importCache);
+        if (handlerType && (node.expression.type === AST_NODE_TYPES.ArrowFunctionExpression || node.expression.type === AST_NODE_TYPES.FunctionExpression)) {
+          checkHandlerFunction(node.expression, handlerType, context);
+        }
+      },
+      // Check function declarations with JSDoc tags
+      FunctionDeclaration(node) {
+        const handlerType = getHandlerTypeFromJSDoc(node, context);
+        if (handlerType) {
+          checkHandlerFunction(node, handlerType, context);
+        }
+      },
+      // Check arrow functions and function expressions with JSDoc tags
+      ArrowFunctionExpression(node) {
+        const handlerType = getHandlerTypeFromJSDoc(node, context);
+        if (handlerType) {
+          checkHandlerFunction(node, handlerType, context);
+        }
+      },
+      FunctionExpression(node) {
+        const handlerType = getHandlerTypeFromJSDoc(node, context);
+        if (handlerType) {
+          checkHandlerFunction(node, handlerType, context);
+        }
+      }
+    };
+  }
+};
+function handlerTypeToFunctionName(handlerType) {
+  if (handlerType === "HeaderHandler") return "headersFn";
+  if (handlerType === "MiddleFnHandler") return "middleFn";
+  return "route";
+}
+function checkHandlerFunction(func, handlerType, context) {
+  const hasReturnType = hasExplicitReturnType(func);
+  const paramValidation = validateParameterTypes(func);
+  const functionName = handlerTypeToFunctionName(handlerType);
+  if (!hasReturnType) {
+    context.report({
+      node: getReturnTypeReportNode(func),
+      messageId: "missingReturnType",
+      data: {
+        handlerType: functionName
+      }
+    });
+  }
+  for (const paramNode of paramValidation.missingParamNodes) {
+    context.report({
+      node: paramNode,
+      messageId: "missingParamTypes",
+      data: {
+        paramName: getParameterName(paramNode)
+      }
+    });
+  }
+}
+export {
+  rule as default
+};
+//# sourceMappingURL=strong-typed-routes.js.map

package/build/eslint/esm/src/eslint/rules/strong-typed-routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strong-typed-routes.js","sources":["../../../../../../src/eslint/rules/strong-typed-routes.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {TSESTree, TSESLint, AST_NODE_TYPES} from '@typescript-eslint/utils';\n\n// List of router functions that should have strongly typed handlers\nconst ROUTER_FUNCTIONS = ['route', 'middleFn', 'headersFn'] as const;\n// List of handler types that can be used with type annotations\nconst HANDLER_TYPES = ['Handler', 'HeaderHandler'] as const;\n\n/**\n * Cache for imports from @mionjs/router - computed once per file\n */\ninterface MionRouterImports {\n    /** Set of function names imported from @mionjs/router (route, middleFn, headersFn) */\n    routerFunctions: Set<string>;\n    /** Set of type names imported from @mionjs/router (Handler, HeaderHandler) */\n    handlerTypes: Set<string>;\n}\n\n/**\n * Builds a cache of all imports from @mionjs/router\n * This is called once per file in the Program visitor\n */\nfunction buildImportCache(program: TSESTree.Program): MionRouterImports {\n    const routerFunctions = new Set<string>();\n    const handlerTypes = new Set<string>();\n\n    for (const statement of program.body) {\n        if (statement.type === AST_NODE_TYPES.ImportDeclaration) {\n            const source = statement.source.value;\n            // Check for @mionjs/router package\n            if (source === '@mionjs/router' || source === '@mionjs/router/') {\n                for (const specifier of statement.specifiers) {\n                    if (\n                        specifier.type === AST_NODE_TYPES.ImportSpecifier &&\n                        specifier.imported.type === AST_NODE_TYPES.Identifier\n                    ) {\n                        const name = specifier.imported.name;\n                        if (ROUTER_FUNCTIONS.includes(name as (typeof ROUTER_FUNCTIONS)[number])) {\n                            routerFunctions.add(name);\n                        }\n                        if (HANDLER_TYPES.includes(name as (typeof HANDLER_TYPES)[number])) {\n                            handlerTypes.add(name);\n                        }\n                    }\n                }\n            }\n        }\n    }\n\n    return {routerFunctions, handlerTypes};\n}\n\n/**\n * Checks if a call expression is calling router functions from @mionjs/router\n * Uses the cached import information for performance\n */\nfunction getRouterFunctionName(node: TSESTree.CallExpression, importCache: MionRouterImports): string | null {\n    // Check if the callee is an identifier with one of the router function names\n    if (node.callee.type !== AST_NODE_TYPES.Identifier) {\n        return null;\n    }\n\n    const functionName = node.callee.name;\n\n    // Check if this function is imported from @mionjs/router\n    if (importCache.routerFunctions.has(functionName)) {\n        return functionName;\n    }\n\n    return null;\n}\n\n/**\n * Cache for top-level function declarations and variable function expressions\n * This avoids iterating through the program body for each function reference\n */\ntype FunctionCache = Map<string, TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration>;\n\n/**\n * Builds a cache of all top-level function declarations and function variable assignments\n * This is called once per file in the Program visitor\n */\nfunction buildFunctionCache(program: TSESTree.Program): FunctionCache {\n    const cache: FunctionCache = new Map();\n\n    for (const statement of program.body) {\n        // Check function declarations\n        if (statement.type === AST_NODE_TYPES.FunctionDeclaration && statement.id?.name) {\n            cache.set(statement.id.name, statement);\n        }\n\n        // Check variable declarations\n        if (statement.type === AST_NODE_TYPES.VariableDeclaration) {\n            for (const declarator of statement.declarations) {\n                if (declarator.id.type === AST_NODE_TYPES.Identifier) {\n                    if (\n                        declarator.init?.type === AST_NODE_TYPES.ArrowFunctionExpression ||\n                        declarator.init?.type === AST_NODE_TYPES.FunctionExpression\n                    ) {\n                        cache.set(declarator.id.name, declarator.init);\n                    }\n                }\n            }\n        }\n    }\n\n    return cache;\n}\n\n/**\n * Gets the handler function from a router function call\n * Uses the cached function information for performance\n */\nfunction getHandlerFunction(\n    node: TSESTree.CallExpression,\n    functionCache: FunctionCache\n): TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration | null {\n    // Handler is always the first parameter for route, middleFn, and headersFn\n    const handlerIndex = 0;\n\n    if (node.arguments.length <= handlerIndex) {\n        return null;\n    }\n\n    const handlerArg = node.arguments[handlerIndex];\n\n    // Handle inline function expressions/arrow functions\n    if (handlerArg.type === AST_NODE_TYPES.ArrowFunctionExpression || handlerArg.type === AST_NODE_TYPES.FunctionExpression) {\n        return handlerArg;\n    }\n\n    // Handle function references (identifiers) - use cached function lookup\n    if (handlerArg.type === AST_NODE_TYPES.Identifier) {\n        return functionCache.get(handlerArg.name) ?? null;\n    }\n\n    return null;\n}\n\n/**\n * Checks if a function has an explicit return type annotation\n * @param func The function node\n * @returns True if it has explicit return type, false otherwise\n */\nfunction hasExplicitReturnType(\n    func: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration\n): boolean {\n    return func.returnType !== undefined;\n}\n\n/**\n * Checks if a node represents a primitive literal value\n * @param node The node to check\n * @returns True if the node is a primitive literal (boolean, string, number, null, undefined, bigint)\n */\nfunction isPrimitiveLiteral(node: TSESTree.Node): boolean {\n    // Check for boolean, string, number, null, or bigint literals\n    if (node.type === AST_NODE_TYPES.Literal) {\n        const value = node.value;\n        // BigInt literals have a 'bigint' property and value is null\n        if ('bigint' in node) {\n            return true;\n        }\n        return typeof value === 'boolean' || typeof value === 'string' || typeof value === 'number' || value === null;\n    }\n    // Check for undefined identifier\n    if (node.type === AST_NODE_TYPES.Identifier && node.name === 'undefined') {\n        return true;\n    }\n    // Check for negative numbers (UnaryExpression with -)\n    if (node.type === AST_NODE_TYPES.UnaryExpression && node.operator === '-' && node.argument.type === AST_NODE_TYPES.Literal) {\n        return typeof node.argument.value === 'number';\n    }\n    return false;\n}\n\n/**\n * Checks if all parameters (except the first) have explicit type annotations\n * @param func The function node\n * @returns Object with validation results including the actual parameter nodes\n */\nfunction validateParameterTypes(\n    func: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration\n): {\n    valid: boolean;\n    missingTypeParams: string[];\n    missingParamNodes: TSESTree.Parameter[];\n} {\n    const missingTypeParams: string[] = [];\n    const missingParamNodes: TSESTree.Parameter[] = [];\n\n    // Skip the first parameter (context), check all others\n    for (let i = 1; i < func.params.length; i++) {\n        const param = func.params[i];\n\n        if (param.type === AST_NODE_TYPES.Identifier) {\n            if (!param.typeAnnotation) {\n                missingTypeParams.push(param.name);\n                missingParamNodes.push(param);\n            }\n        } else if (param.type === AST_NODE_TYPES.RestElement) {\n            if (param.argument.type === AST_NODE_TYPES.Identifier && !param.typeAnnotation) {\n                missingTypeParams.push(`...${param.argument.name}`);\n                missingParamNodes.push(param);\n            }\n        } else if (param.type === AST_NODE_TYPES.ArrayPattern || param.type === AST_NODE_TYPES.ObjectPattern) {\n            // For destructuring patterns, check if they have type annotations\n            if (!param.typeAnnotation) {\n                missingTypeParams.push(`parameter ${i + 1}`);\n                missingParamNodes.push(param);\n            }\n        } else if (param.type === AST_NODE_TYPES.AssignmentPattern) {\n            // For default parameters (e.g., `name = 'default'` or `name: string = 'default'`), check if:\n            // 1. There's an explicit type annotation on the AssignmentPattern itself, OR\n            // 2. There's an explicit type annotation on the left side (for `name: Type = value` pattern), OR\n            // 3. The default value is a primitive literal (type can be inferred)\n            const hasTypeAnnotationOnPattern = param.typeAnnotation !== undefined;\n            const hasTypeAnnotationOnLeft =\n                param.left.type === AST_NODE_TYPES.Identifier && param.left.typeAnnotation !== undefined;\n            const hasTypeAnnotation = hasTypeAnnotationOnPattern || hasTypeAnnotationOnLeft;\n            const hasPrimitiveDefault = isPrimitiveLiteral(param.right);\n\n            if (!hasTypeAnnotation && !hasPrimitiveDefault) {\n                // Need explicit type annotation since type cannot be inferred from default value\n                const paramName = param.left.type === AST_NODE_TYPES.Identifier ? param.left.name : `parameter ${i + 1}`;\n                missingTypeParams.push(paramName);\n                missingParamNodes.push(param);\n            }\n        }\n        // For other parameter types, we assume they need type annotations too\n        else if (!('typeAnnotation' in param) || !param.typeAnnotation) {\n            missingTypeParams.push(`parameter ${i + 1}`);\n            missingParamNodes.push(param);\n        }\n    }\n\n    return {\n        valid: missingTypeParams.length === 0,\n        missingTypeParams,\n        missingParamNodes,\n    };\n}\n\n/**\n * Extracts a readable parameter name from a parameter node\n */\nfunction getParameterName(param: TSESTree.Parameter): string {\n    if (param.type === AST_NODE_TYPES.Identifier) {\n        return param.name;\n    } else if (param.type === AST_NODE_TYPES.RestElement && param.argument.type === AST_NODE_TYPES.Identifier) {\n        return `...${param.argument.name}`;\n    } else if (param.type === AST_NODE_TYPES.ArrayPattern) {\n        return '[...]';\n    } else if (param.type === AST_NODE_TYPES.ObjectPattern) {\n        return '{...}';\n    } else if (param.type === AST_NODE_TYPES.AssignmentPattern) {\n        if (param.left.type === AST_NODE_TYPES.Identifier) {\n            return param.left.name;\n        }\n        return 'param';\n    }\n    return 'param';\n}\n\n/**\n * Gets the node to report for missing return type\n * For arrow functions, this is the arrow token area; for regular functions, the function keyword\n */\nfunction getReturnTypeReportNode(\n    func: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration\n): TSESTree.Node {\n    // For function declarations/expressions with an id, report on the id\n    if ((func.type === AST_NODE_TYPES.FunctionDeclaration || func.type === AST_NODE_TYPES.FunctionExpression) && func.id) {\n        return func.id;\n    }\n    // Otherwise report on the function itself (will highlight just the signature area)\n    return func;\n}\n\n/**\n * Checks if a type annotation references Handler or HeaderHandler from @mionjs/router\n * Uses the cached import information for performance\n */\nfunction getHandlerTypeFromAnnotation(\n    typeAnnotation: TSESTree.TSTypeAnnotation,\n    importCache: MionRouterImports\n): 'Handler' | 'HeaderHandler' | null {\n    if (typeAnnotation.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference) {\n        const typeName = typeAnnotation.typeAnnotation.typeName;\n        if (typeName.type === AST_NODE_TYPES.Identifier) {\n            const name = typeName.name;\n            if ((name === 'Handler' || name === 'HeaderHandler') && importCache.handlerTypes.has(name)) {\n                return name as 'Handler' | 'HeaderHandler';\n            }\n        }\n    }\n    return null;\n}\n\n/**\n * Checks if a satisfies expression references Handler or HeaderHandler from @mionjs/router\n * Uses the cached import information for performance\n */\nfunction getHandlerTypeFromSatisfies(\n    satisfiesExpression: TSESTree.TSSatisfiesExpression,\n    importCache: MionRouterImports\n): 'Handler' | 'HeaderHandler' | null {\n    if (satisfiesExpression.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference) {\n        const typeName = satisfiesExpression.typeAnnotation.typeName;\n        if (typeName.type === AST_NODE_TYPES.Identifier) {\n            const name = typeName.name;\n            if ((name === 'Handler' || name === 'HeaderHandler') && importCache.handlerTypes.has(name)) {\n                return name as 'Handler' | 'HeaderHandler';\n            }\n        }\n    }\n    return null;\n}\n\n/**\n * Checks if a function has JSDoc tags indicating it should be type-checked\n * @param node The node to check for JSDoc comments\n * @param context The ESLint context\n * @returns The handler type if JSDoc tag is found, null otherwise\n */\nfunction getHandlerTypeFromJSDoc(\n    node:\n        | TSESTree.ArrowFunctionExpression\n        | TSESTree.FunctionExpression\n        | TSESTree.FunctionDeclaration\n        | TSESTree.VariableDeclaration,\n    context: TSESLint.RuleContext<any, any>\n): 'Handler' | 'HeaderHandler' | 'MiddleFnHandler' | null {\n    const sourceCode = context.sourceCode;\n    const comments = sourceCode.getCommentsBefore(node);\n\n    for (const comment of comments) {\n        if (comment.type === 'Block') {\n            const commentText = comment.value;\n            if (commentText.includes('@mion:route')) {\n                return 'Handler';\n            }\n            if (commentText.includes('@mion:middleFn')) {\n                return 'MiddleFnHandler';\n            }\n            if (commentText.includes('@mion:headersFn')) {\n                return 'HeaderHandler';\n            }\n        }\n    }\n    return null;\n}\n\nconst rule: TSESLint.RuleModule<\n    'missingReturnType' | 'missingParamTypes' | 'missingReturnTypeRouter' | 'missingParamTypesRouter',\n    []\n> = {\n    meta: {\n        type: 'problem',\n        docs: {\n            description: 'Enforce explicit parameters and return type annotations for router handler functions',\n        },\n        messages: {\n            missingReturnType: 'mion {{handlerType}}() handler must define a return type.',\n            missingParamTypes: 'mion parameter \"{{paramName}}\" must have an explicit type definition.',\n            missingReturnTypeRouter: 'mion {{routerFunction}}() handler must define a return type.',\n            missingParamTypesRouter: 'mion parameter \"{{paramName}}\" must have an explicit type definition.',\n        },\n        schema: [], // No options\n    },\n    defaultOptions: [],\n    create(context) {\n        // Caches built once per file for performance\n        let importCache: MionRouterImports | null = null;\n        let functionCache: FunctionCache | null = null;\n\n        return {\n            // Build caches once when we start processing the file\n            Program(node: TSESTree.Program) {\n                importCache = buildImportCache(node);\n                functionCache = buildFunctionCache(node);\n            },\n            CallExpression(node: TSESTree.CallExpression) {\n                if (!importCache || !functionCache) return;\n\n                const functionName = getRouterFunctionName(node, importCache);\n                if (!functionName) {\n                    return;\n                }\n\n                const handlerFunc = getHandlerFunction(node, functionCache);\n                if (!handlerFunc) {\n                    return;\n                }\n\n                const hasReturnType = hasExplicitReturnType(handlerFunc);\n                const paramValidation = validateParameterTypes(handlerFunc);\n\n                // Report errors on specific nodes for better highlighting\n                if (!hasReturnType) {\n                    context.report({\n                        node: getReturnTypeReportNode(handlerFunc),\n                        messageId: 'missingReturnTypeRouter',\n                        data: {\n                            routerFunction: functionName,\n                        },\n                    });\n                }\n\n                // Report each missing parameter type separately\n                for (const paramNode of paramValidation.missingParamNodes) {\n                    context.report({\n                        node: paramNode,\n                        messageId: 'missingParamTypesRouter',\n                        data: {\n                            paramName: getParameterName(paramNode),\n                        },\n                    });\n                }\n            },\n            // Check variable declarations with type annotations or JSDoc tags\n            VariableDeclarator(node: TSESTree.VariableDeclarator) {\n                if (!importCache) return;\n\n                if (node.id.type === AST_NODE_TYPES.Identifier) {\n                    let handlerType: 'Handler' | 'HeaderHandler' | 'MiddleFnHandler' | null = null;\n\n                    // Check for type annotation\n                    if (node.id.typeAnnotation) {\n                        handlerType = getHandlerTypeFromAnnotation(node.id.typeAnnotation, importCache);\n                    }\n\n                    // Check for JSDoc tags on the variable declaration\n                    if (!handlerType && node.parent?.type === AST_NODE_TYPES.VariableDeclaration) {\n                        handlerType = getHandlerTypeFromJSDoc(node.parent, context);\n                    }\n\n                    if (\n                        handlerType &&\n                        (node.init?.type === AST_NODE_TYPES.ArrowFunctionExpression ||\n                            node.init?.type === AST_NODE_TYPES.FunctionExpression)\n                    ) {\n                        checkHandlerFunction(node.init, handlerType, context);\n                    }\n                }\n            },\n            // Check satisfies expressions\n            TSSatisfiesExpression(node: TSESTree.TSSatisfiesExpression) {\n                if (!importCache) return;\n\n                const handlerType = getHandlerTypeFromSatisfies(node, importCache);\n                if (\n                    handlerType &&\n                    (node.expression.type === AST_NODE_TYPES.ArrowFunctionExpression ||\n                        node.expression.type === AST_NODE_TYPES.FunctionExpression)\n                ) {\n                    checkHandlerFunction(node.expression, handlerType, context);\n                }\n            },\n            // Check function declarations with JSDoc tags\n            FunctionDeclaration(node: TSESTree.FunctionDeclaration) {\n                const handlerType = getHandlerTypeFromJSDoc(node, context);\n                if (handlerType) {\n                    checkHandlerFunction(node, handlerType, context);\n                }\n            },\n            // Check arrow functions and function expressions with JSDoc tags\n            ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression) {\n                const handlerType = getHandlerTypeFromJSDoc(node, context);\n                if (handlerType) {\n                    checkHandlerFunction(node, handlerType, context);\n                }\n            },\n            FunctionExpression(node: TSESTree.FunctionExpression) {\n                const handlerType = getHandlerTypeFromJSDoc(node, context);\n                if (handlerType) {\n                    checkHandlerFunction(node, handlerType, context);\n                }\n            },\n        };\n    },\n};\n\n/**\n * Maps Handler/HeaderHandler/MiddleFnHandler type names to their corresponding router function names\n */\nfunction handlerTypeToFunctionName(handlerType: 'Handler' | 'HeaderHandler' | 'MiddleFnHandler'): string {\n    if (handlerType === 'HeaderHandler') return 'headersFn';\n    if (handlerType === 'MiddleFnHandler') return 'middleFn';\n    return 'route';\n}\n\n/**\n * Helper function to check a handler function for type annotations\n * @param func The function node to check\n * @param handlerType The expected handler type\n * @param context The ESLint context\n */\nfunction checkHandlerFunction(\n    func: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration,\n    handlerType: 'Handler' | 'HeaderHandler' | 'MiddleFnHandler',\n    context: TSESLint.RuleContext<any, any>\n) {\n    const hasReturnType = hasExplicitReturnType(func);\n    const paramValidation = validateParameterTypes(func);\n    const functionName = handlerTypeToFunctionName(handlerType);\n\n    // Report errors on specific nodes for better highlighting\n    if (!hasReturnType) {\n        context.report({\n            node: getReturnTypeReportNode(func),\n            messageId: 'missingReturnType',\n            data: {\n                handlerType: functionName,\n            },\n        });\n    }\n\n    // Report each missing parameter type separately\n    for (const paramNode of paramValidation.missingParamNodes) {\n        context.report({\n            node: paramNode,\n            messageId: 'missingParamTypes',\n            data: {\n                paramName: getParameterName(paramNode),\n            },\n        });\n    }\n}\n\nexport default rule;\n"],"names":[],"mappings":"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"}

package/build/eslint/esm/src/eslint/rules/type-formats-imports.d.ts

@@ -0,0 +1,3 @@
+import { TSESLint } from '@typescript-eslint/utils';
+declare const rule: TSESLint.RuleModule<'typeFormatsImports', []>;
+export default rule;

package/build/eslint/esm/src/eslint/rules/type-formats-imports.js

@@ -0,0 +1,53 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { FORMAT_TYPES_BY_PACKAGE } from "./formatTypeNames.js";
+function getFormatTypePackage(source) {
+  for (const [pkg] of FORMAT_TYPES_BY_PACKAGE) {
+    if (source === pkg || source.startsWith(pkg + "/")) return pkg;
+  }
+  return null;
+}
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow type-only imports for TypeFormat types. Type-only imports strip type metadata needed by Deepkit for runtime type reflection, causing silent validation/serialization failures."
+    },
+    messages: {
+      typeFormatsImports: 'Type "{{typeName}}" is imported as type-only from "{{source}}". Remove the "type" keyword from the import to preserve runtime type metadata for Deepkit reflection.'
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        const matchedPkg = getFormatTypePackage(source);
+        if (!matchedPkg) return;
+        const formatTypes = FORMAT_TYPES_BY_PACKAGE.get(matchedPkg);
+        if (!formatTypes) return;
+        const isTypeOnlyImport = node.importKind === "type";
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) continue;
+          const importedName = specifier.imported.type === AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+          if (!formatTypes.has(importedName)) continue;
+          const isTypeOnlySpecifier = specifier.importKind === "type";
+          if (isTypeOnlyImport || isTypeOnlySpecifier) {
+            context.report({
+              node: specifier,
+              messageId: "typeFormatsImports",
+              data: {
+                typeName: importedName,
+                source
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+export {
+  rule as default
+};
+//# sourceMappingURL=type-formats-imports.js.map

package/build/eslint/esm/src/eslint/rules/type-formats-imports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-formats-imports.js","sources":["../../../../../../src/eslint/rules/type-formats-imports.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 {TSESTree, TSESLint, AST_NODE_TYPES} from '@typescript-eslint/utils';\nimport {FORMAT_TYPES_BY_PACKAGE} from './formatTypeNames.ts';\n\n/** Checks if source matches one of the format type packages (exact or subpath) */\nfunction getFormatTypePackage(source: string): string | null {\n    for (const [pkg] of FORMAT_TYPES_BY_PACKAGE) {\n        if (source === pkg || source.startsWith(pkg + '/')) return pkg;\n    }\n    return null;\n}\n\nconst rule: TSESLint.RuleModule<'typeFormatsImports', []> = {\n    meta: {\n        type: 'problem',\n        docs: {\n            description:\n                'Disallow type-only imports for TypeFormat types. Type-only imports strip type metadata needed by Deepkit for runtime type reflection, causing silent validation/serialization failures.',\n        },\n        messages: {\n            typeFormatsImports:\n                'Type \"{{typeName}}\" is imported as type-only from \"{{source}}\". Remove the \"type\" keyword from the import to preserve runtime type metadata for Deepkit reflection.',\n        },\n        schema: [],\n    },\n    defaultOptions: [],\n    create(context) {\n        return {\n            ImportDeclaration(node: TSESTree.ImportDeclaration) {\n                const source = node.source.value;\n                const matchedPkg = getFormatTypePackage(source);\n                if (!matchedPkg) return;\n\n                const formatTypes = FORMAT_TYPES_BY_PACKAGE.get(matchedPkg);\n                if (!formatTypes) return;\n\n                const isTypeOnlyImport = node.importKind === 'type';\n\n                for (const specifier of node.specifiers) {\n                    if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) continue;\n\n                    const importedName =\n                        specifier.imported.type === AST_NODE_TYPES.Identifier\n                            ? specifier.imported.name\n                            : specifier.imported.value;\n\n                    if (!formatTypes.has(importedName)) continue;\n\n                    const isTypeOnlySpecifier = specifier.importKind === 'type';\n\n                    if (isTypeOnlyImport || isTypeOnlySpecifier) {\n                        context.report({\n                            node: specifier,\n                            messageId: 'typeFormatsImports',\n                            data: {\n                                typeName: importedName,\n                                source,\n                            },\n                        });\n                    }\n                }\n            },\n        };\n    },\n};\n\nexport default rule;\n"],"names":[],"mappings":";;AAWA,SAAS,qBAAqB,QAA+B;AACzD,aAAW,CAAC,GAAG,KAAK,yBAAyB;AACzC,QAAI,WAAW,OAAO,OAAO,WAAW,MAAM,GAAG,EAAG,QAAO;AAAA,EAC/D;AACA,SAAO;AACX;AAEA,MAAM,OAAsD;AAAA,EACxD,MAAM;AAAA,IACF,MAAM;AAAA,IACN,MAAM;AAAA,MACF,aACI;AAAA,IAAA;AAAA,IAER,UAAU;AAAA,MACN,oBACI;AAAA,IAAA;AAAA,IAER,QAAQ,CAAA;AAAA,EAAC;AAAA,EAEb,gBAAgB,CAAA;AAAA,EAChB,OAAO,SAAS;AACZ,WAAO;AAAA,MACH,kBAAkB,MAAkC;AAChD,cAAM,SAAS,KAAK,OAAO;AAC3B,cAAM,aAAa,qBAAqB,MAAM;AAC9C,YAAI,CAAC,WAAY;AAEjB,cAAM,cAAc,wBAAwB,IAAI,UAAU;AAC1D,YAAI,CAAC,YAAa;AAElB,cAAM,mBAAmB,KAAK,eAAe;AAE7C,mBAAW,aAAa,KAAK,YAAY;AACrC,cAAI,UAAU,SAAS,eAAe,gBAAiB;AAEvD,gBAAM,eACF,UAAU,SAAS,SAAS,eAAe,aACrC,UAAU,SAAS,OACnB,UAAU,SAAS;AAE7B,cAAI,CAAC,YAAY,IAAI,YAAY,EAAG;AAEpC,gBAAM,sBAAsB,UAAU,eAAe;AAErD,cAAI,oBAAoB,qBAAqB;AACzC,oBAAQ,OAAO;AAAA,cACX,MAAM;AAAA,cACN,WAAW;AAAA,cACX,MAAM;AAAA,gBACF,UAAU;AAAA,gBACV;AAAA,cAAA;AAAA,YACJ,CACH;AAAA,UACL;AAAA,QACJ;AAAA,MACJ;AAAA,IAAA;AAAA,EAER;AACJ;"}

package/build/eslint/esm/src/pureFns/purityRules.d.ts

@@ -0,0 +1,4 @@
+export declare const ALLOWED_GLOBALS: Set<string>;
+export declare const FORBIDDEN_IDENTIFIERS: Set<string>;
+export declare const PURE_FN_CALL_NAMES: readonly ["pureServerFn", "registerPureFnFactory", "mapFrom"];
+export declare const PURE_FN_SOURCE_PACKAGES: readonly ["@mionjs/core", "@mionjs/client"];

package/build/eslint/esm/src/pureFns/purityRules.js

@@ -0,0 +1,67 @@
+const ALLOWED_GLOBALS = /* @__PURE__ */ new Set([
+  // Value types
+  "undefined",
+  "null",
+  "NaN",
+  "Infinity",
+  "true",
+  "false",
+  // Built-in constructors/objects
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Math",
+  "JSON",
+  "Date",
+  "RegExp",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Symbol",
+  "BigInt",
+  "Promise",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI",
+  // Common safe globals
+  "console",
+  "globalThis",
+  "Bun"
+]);
+const FORBIDDEN_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "eval",
+  "Function",
+  "fetch",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval",
+  "process",
+  "window",
+  "document",
+  "global",
+  "require",
+  "XMLHttpRequest",
+  "WebSocket",
+  "localStorage",
+  "sessionStorage",
+  "indexedDB"
+]);
+const PURE_FN_SOURCE_PACKAGES = ["@mionjs/core", "@mionjs/client"];
+export {
+  ALLOWED_GLOBALS,
+  FORBIDDEN_IDENTIFIERS,
+  PURE_FN_SOURCE_PACKAGES
+};
+//# sourceMappingURL=purityRules.js.map

package/build/eslint/esm/src/pureFns/purityRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"purityRules.js","sources":["../../../../../src/pureFns/purityRules.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/** Globals and built-ins that are allowed inside pure functions */\nexport const ALLOWED_GLOBALS = new Set([\n    // Value types\n    'undefined',\n    'null',\n    'NaN',\n    'Infinity',\n    'true',\n    'false',\n    // Built-in constructors/objects\n    'Object',\n    'Array',\n    'String',\n    'Number',\n    'Boolean',\n    'Math',\n    'JSON',\n    'Date',\n    'RegExp',\n    'Map',\n    'Set',\n    'WeakMap',\n    'WeakSet',\n    'Symbol',\n    'BigInt',\n    'Promise',\n    'Error',\n    'TypeError',\n    'RangeError',\n    'parseInt',\n    'parseFloat',\n    'isNaN',\n    'isFinite',\n    'encodeURIComponent',\n    'decodeURIComponent',\n    'encodeURI',\n    'decodeURI',\n    // Common safe globals\n    'console',\n    'globalThis',\n    'Bun',\n]);\n\n/** Forbidden identifiers that indicate impure operations in pure functions */\nexport const FORBIDDEN_IDENTIFIERS = new Set([\n    'eval',\n    'Function',\n    'fetch',\n    'setTimeout',\n    'setInterval',\n    'clearTimeout',\n    'clearInterval',\n    'process',\n    'window',\n    'document',\n    'global',\n    'require',\n    'XMLHttpRequest',\n    'WebSocket',\n    'localStorage',\n    'sessionStorage',\n    'indexedDB',\n]);\n\n/** The target function names that purity validation applies to */\nexport const PURE_FN_CALL_NAMES = ['pureServerFn', 'registerPureFnFactory', 'mapFrom'] as const;\n\n/** The packages that export the target pure function APIs */\nexport const PURE_FN_SOURCE_PACKAGES = ['@mionjs/core', '@mionjs/client'] as const;\n"],"names":[],"mappings":"AAQO,MAAM,sCAAsB,IAAI;AAAA;AAAA,EAEnC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AACJ,CAAC;AAGM,MAAM,4CAA4B,IAAI;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,CAAC;AAMM,MAAM,0BAA0B,CAAC,gBAAgB,gBAAgB;"}

package/build/vite-plugin/cjs/index.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_vitePlugin_mionVitePlugin = require("./src/vite-plugin/mionVitePlugin.cjs");
+const src_vitePlugin_cjsPackageJsonPlugin = require("./src/vite-plugin/cjsPackageJsonPlugin.cjs");
+const src_vitePlugin_constants = require("./src/vite-plugin/constants.cjs");
+exports.mionPlugin = src_vitePlugin_mionVitePlugin.mionVitePlugin;
+exports.mionVitePlugin = src_vitePlugin_mionVitePlugin.mionVitePlugin;
+exports.serverReady = src_vitePlugin_mionVitePlugin.serverReady;
+exports.cjsPackageJsonPlugin = src_vitePlugin_cjsPackageJsonPlugin.cjsPackageJsonPlugin;
+exports.VIRTUAL_AOT_JIT_FNS = src_vitePlugin_constants.VIRTUAL_AOT_JIT_FNS;
+exports.VIRTUAL_AOT_PURE_FNS = src_vitePlugin_constants.VIRTUAL_AOT_PURE_FNS;
+exports.VIRTUAL_AOT_ROUTER_CACHE = src_vitePlugin_constants.VIRTUAL_AOT_ROUTER_CACHE;
+exports.VIRTUAL_PURE_FUNCTIONS = src_vitePlugin_constants.VIRTUAL_SERVER_PURE_FNS;
+//# sourceMappingURL=index.cjs.map

package/build/vite-plugin/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/build/vite-plugin/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/build/vite-plugin/cjs/src/pureFns/purityRules.cjs

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ALLOWED_GLOBALS = /* @__PURE__ */ new Set([
+  // Value types
+  "undefined",
+  "null",
+  "NaN",
+  "Infinity",
+  "true",
+  "false",
+  // Built-in constructors/objects
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Math",
+  "JSON",
+  "Date",
+  "RegExp",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Symbol",
+  "BigInt",
+  "Promise",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI",
+  // Common safe globals
+  "console",
+  "globalThis",
+  "Bun"
+]);
+const FORBIDDEN_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "eval",
+  "Function",
+  "fetch",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval",
+  "process",
+  "window",
+  "document",
+  "global",
+  "require",
+  "XMLHttpRequest",
+  "WebSocket",
+  "localStorage",
+  "sessionStorage",
+  "indexedDB"
+]);
+exports.ALLOWED_GLOBALS = ALLOWED_GLOBALS;
+exports.FORBIDDEN_IDENTIFIERS = FORBIDDEN_IDENTIFIERS;
+//# sourceMappingURL=purityRules.cjs.map

package/build/vite-plugin/cjs/src/pureFns/purityRules.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"purityRules.cjs","sources":["../../../../../src/pureFns/purityRules.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/** Globals and built-ins that are allowed inside pure functions */\nexport const ALLOWED_GLOBALS = new Set([\n    // Value types\n    'undefined',\n    'null',\n    'NaN',\n    'Infinity',\n    'true',\n    'false',\n    // Built-in constructors/objects\n    'Object',\n    'Array',\n    'String',\n    'Number',\n    'Boolean',\n    'Math',\n    'JSON',\n    'Date',\n    'RegExp',\n    'Map',\n    'Set',\n    'WeakMap',\n    'WeakSet',\n    'Symbol',\n    'BigInt',\n    'Promise',\n    'Error',\n    'TypeError',\n    'RangeError',\n    'parseInt',\n    'parseFloat',\n    'isNaN',\n    'isFinite',\n    'encodeURIComponent',\n    'decodeURIComponent',\n    'encodeURI',\n    'decodeURI',\n    // Common safe globals\n    'console',\n    'globalThis',\n    'Bun',\n]);\n\n/** Forbidden identifiers that indicate impure operations in pure functions */\nexport const FORBIDDEN_IDENTIFIERS = new Set([\n    'eval',\n    'Function',\n    'fetch',\n    'setTimeout',\n    'setInterval',\n    'clearTimeout',\n    'clearInterval',\n    'process',\n    'window',\n    'document',\n    'global',\n    'require',\n    'XMLHttpRequest',\n    'WebSocket',\n    'localStorage',\n    'sessionStorage',\n    'indexedDB',\n]);\n\n/** The target function names that purity validation applies to */\nexport const PURE_FN_CALL_NAMES = ['pureServerFn', 'registerPureFnFactory', 'mapFrom'] as const;\n\n/** The packages that export the target pure function APIs */\nexport const PURE_FN_SOURCE_PACKAGES = ['@mionjs/core', '@mionjs/client'] as const;\n"],"names":[],"mappings":";;AAQO,MAAM,sCAAsB,IAAI;AAAA;AAAA,EAEnC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AACJ,CAAC;AAGM,MAAM,4CAA4B,IAAI;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,CAAC;;;"}

package/build/vite-plugin/cjs/src/pureFns/purityRules.d.ts

@@ -0,0 +1,4 @@
+export declare const ALLOWED_GLOBALS: Set<string>;
+export declare const FORBIDDEN_IDENTIFIERS: Set<string>;
+export declare const PURE_FN_CALL_NAMES: readonly ["pureServerFn", "registerPureFnFactory", "mapFrom"];
+export declare const PURE_FN_SOURCE_PACKAGES: readonly ["@mionjs/core", "@mionjs/client"];