Every Mesrai rule, in one place

Detect `except:` blocks that catch all exceptions indiscriminately. Using a broad `except:` can hide real issues and prevent necessary errors like `KeyboardInterrupt`. Recommend catching specific exceptions instead.

Do not combine mechanical changes (formatting, renames) with behavioral changes. If unavoidable, separate commits and call out which commits are mechanical.

Identify function definitions where a mutable object (e.g., list, dictionary, set) is used as a default argument. This can cause shared state across function calls, leading to unintended behavior. Suggest using `None` as a default and initializing the object inside the function.

Classes with only private constructors cannot be instantiated outside their own scope, potentially making them dead code.

Do not silently catch and return null on errors; log context and either rethrow or return a typed failure/Result.

Detect the use of the 'any' type in TypeScript. Using 'any' disables type checking and can lead to runtime errors. Recommend using specific types or generics instead.

Remove unnecessary calls to `.toList()` when using the spread operator (`...`) as it is already designed to work with iterable collections.

Remove unnecessary `.toList()` calls when using the spread operator (`...`) to avoid redundant operations.

Detect cases of unsafe type assertions. These do not perform runtime checks and can lead to unexpected runtime errors. Recommend using proper type guards instead.

Detect the use of .bind() or inline arrow functions inside JSX props. These create new functions on every render, impacting performance. Suggest moving function definitions outside the render method.

Do not use `!` to check nullable type parameters, as this can lead to runtime exceptions if the type itself is nullable.

Ensure that `@Qualifier` is not used on `@Bean` methods, as explicit bean titles should be used instead.

Ensure that `File.deleteOnExit()` is not used, as it can cause memory and resource leaks.

Check if `goto` statements are avoided. Ensure that structured control flow statements (`if`, `for`, `while`) are used instead.

Ensure that the `finalize()` method is not used. Use try-with-resources or explicit cleanup methods instead.

Detect cases where <a> elements are used as buttons. Anchor tags should be used for navigation, while actions should be assigned to <button> elements to maintain accessibility and expected behavior.

Do not use constant patterns with type literals as it can lead to unexpected behavior. Prefer direct type checking instead.

Do not use the eval() function to run dynamically generated PHP code, especially if it can include user input. Look for safe alternatives like controlled function calls or explicit decision structures.

Check for global variable usage (e.g., variables prefixed with `$`). Suggest using instance variables, constants, or dependency injection instead.

Identify global variables that are mutable (e.g., lists, dictionaries). Global mutable state can cause unpredictable behavior. Recommend using local variables or encapsulating state in a class.

Detect occurrences of the comma operator in expressions. The comma operator can make code harder to read and debug, as it executes two expressions but only returns the last one. Suggest alternative structures for better readability.

Await Tasks instead of blocking (no .Result or .Wait()); prefer async/await end-to-end and configure awaits appropriately.

Create daily encrypted backups (KMS keys) with retention and geo-redundancy; run quarterly restore tests and record results in the audit log.

If files under src/ change behavior, the PR must include tests/ updates or a PR description line no-tests: <reason> explaining why tests are unaffected.