Every Mesrai rule, in one place

Use distinct variable names across scopes; never reuse the outer loop variable in inner loops or comprehensions.

Verify that method and variable titles follow `snake_case` conventions, avoiding camelCase or PascalCase.

Freeze constant objects (arrays/hashes/strings) to avoid accidental mutation at runtime.

Component names should prefer full words over abbreviations.

All production deployments must reference a change ticket ID, peer approval, and linked rollout plan; write the change_id to the audit log on deploy.

List all included builds/modules in settings.gradle and manage versions via gradle/libs.versions.toml (version catalogs). Forbid hardcoded versions and repo declarations in module build.gradle files.

Replace long parameter lists with request objects or records; validate them as a unit.

When using Optional/CompletableFuture/Publisher-like types, map empty values to a clear outcome (e.g., 404) rather than returning null.

Use ?? and the nullsafe operator (?->) to provide defaults and avoid notices when values may be null.

Always provide `orElse` to firstWhere (or use a safe helper) when the match may not exist.

Parse dates/times in begin/rescue blocks and validate expected format/timezone.

Use template helpers to set metadata.name and labels (app.kubernetes.io/) consistently across templates; prohibit hardcoded mismatches.

Hoist constant work (e.g., RegExp, static JSON, config loads) out of loops and cache results by input when feasible.

Changes that create new ePHI stores must also include retention configuration and a scheduled purge job aligned to policy (e.g., 6 years). Document tables/collections covered and add tests for TTL behavior.

Avoid implicit communication between parent and child components, such as using `this.$parent`, `this.$root`, or directly mutating props received from the parent. Prefer explicit communication via props down and events up.

Use private fields with accessors; expose the narrowest visibility that satisfies usage.

Set sensible defaults for properties/fields or enforce via constructors.

Always initialize variables before use and avoid conditionally-defined locals.

Validate CPF/CNPJ format and checksum server-side; reject storage of invalid identifiers and never auto-correct them. Store normalized (digits-only) representation.

Do not hardcode user-visible strings in pages/layouts. Use an i18n library integrated with App Router and load dictionaries on the server.

Use assertThrows for exception cases and annotate long-running tests with @Timeout to bound execution; use @TempDir for file I/O.

Detect `try` blocks that contain excessive code. Large `try` blocks make it harder to debug errors. Recommend narrowing the scope of the `try` block to only the necessary code.

By default, use unbuffered channels or a buffer size of one. Only use larger buffers when necessary and carefully considered. Unbuffered channels (size 0) or a size of 1 are the most common; a large buffer can hide synchronization issues or lead to memory bloat if misused.

Write functions and methods so each does one well-defined task. If a function handles distinct steps (validation, processing, saving, notifying), refactor into smaller focused functions.