Every Mesrai rule, in one place

Do not put complex logic or long-running tasks in package `init()` functions. Keep `init()` minimal (if you use it at all), such as simple registration of types or default variable initialization. Perform real setup in explicit functions (like in `main` or a setup function called by main).

Ensure that console statements are removed in production code. Console logs can expose sensitive data and impact performance.

Detect the use of default exports. Named exports provide better clarity, maintainability, and prevent issues when refactoring.

Ensure that classes with only static members are converted to top-level functions or extensions. Avoid unnecessary class instantiation.

Flag usages marked as @deprecated (via JSDoc or types) and propose the documented alternative when available.

Detect floating-point numbers with excessive precision. Overly precise numeric literals can cause rounding errors and unexpected behavior in calculations.

Ensure that titlespace structures are not overly deep. Favor a flat, organized structure to enhance readability and navigation.

Animate transform/opacity; avoid top/left/width/box-shadow on large elements.

Do not include internal identifiers (DB IDs, service IDs, tokens) in client-facing errors. Log them internally; return generic messages externally.

Be c sem areful when slicing out a small portion of a large slice or array. The resulting slice still references the entire original array. If you only need the small portion long-term, copy that data into a new slice to avoid keeping the large array in memory.

Treat function inputs as immutable; copy before mutation (e.g., dict.copy(), list(x)).

Ensure that large classes with multiple responsibilities are refactored into smaller, more manageable classes.

Do not use global (package-level) variables for mutable state whenever possible. Instead, encapsulate state in structs or pass it as parameters. If you must use a global variable (for configuration or caching), protect it with mutexes if concurrent access is possible and document its usage.

Do not perform multiple DB queries inside a loop for data you could fetch in one query. Instead, consolidate using IN clauses or JOINs to retrieve all needed data at once.

Ensure that arrays do not contain non-numeric properties. This practice can lead to unexpected behavior. Use Maps or Objects instead.

Identify lambda functions that are too complex. Lambdas should be simple and concise. If a lambda contains multiple expressions, recommend converting it to a titled function for better readability.

Never use a pointer to an interface type. Pass interfaces as values, since an interface already provides reference semantics to the underlying data.

Do not use pointers to slice or map types. Slices and maps are already reference types that point to underlying data, so they can be passed by value and still allow modifications to the contents.

Check if the method, variable, or class title contains redundant context (e.g., using 'carDrive()' when 'drive()' would suffice). Ensure the title is concise and avoids repetition of surrounding context.

Ensure that explicit null checks are not used with `instanceof`, as `null` is never an instance of any class.

Do not use global variables to share data across your program. Prefer passing values as function parameters or using configuration objects. Limiting variable scope makes code more predictable and less prone to side effects.

Identify `rescue Exception` statements and suggest replacing them with `rescue StandardError` to avoid catching critical system exceptions.

Methods returning values that are never used introduce unnecessary complexity. Remove such return values to improve clarity.

Check if semicolons are used at the end of statements in Python code. Semicolons are unnecessary and may cause readability issues or errors when multiple statements are placed on one line. Recommend using new lines instead.