Performance & Efficiency rules

Blocking async methods with `.Result` or `.Wait()` can cause deadlocks and prevent efficient asynchronous execution. Use `await` instead for proper async behavior.

All static JS/CSS/font/image files MUST use content-hashed filenames (e.g., app.9c1a7b.js) and be served with "Cache-Control: public, max-age=31536000, immutable". HTML and other non-fingerprinted documents MUST be served with "Cache-Control: no-cache" (or equivalent) to enable conditional revalidation.

Unit tests must stub or fake external HTTP/DB calls; allow real I/O only in integration/e2e tests tagged accordingly.

Detect uses of `re.sub()` where regular expressions are not needed. For simple string replacements, `str.replace()` is more efficient and should be used instead.

Ensure that offset-based string methods are used instead of creating unnecessary substring instances.

Ensure that `String.replace()` is used when a simple string replacement is needed instead of `String.replaceAll()`.

Verify that when extracting substrings, a start index is specified to avoid unnecessary memory allocations.

Define constructors for `@immutable` classes as `const` to ensure that instances are created efficiently and cannot be modified.

Index frequently filtered or joined columns and verify with query plans.

`DateTime.Now` is affected by daylight savings and system clock adjustments. Use `Stopwatch` for more accurate timing.

Never use `v-if` on the same element as `v-for`.

Ensure that React list items do not use array indexes as keys. This practice can cause reordering issues and unexpected behavior. Recommend using unique identifiers instead.

Ensure that objects are not created solely for calling `getClass()`. Use `ClassName.class` instead.

Ensure that logging arguments and preconditions do not require costly evaluations before method calls.

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 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.

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

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

Serve text-based assets (JS, CSS, JSON, SVG) with Brotli (br) when the client sends "Accept-Encoding: br" and fallback to gzip. Always set "Vary: Accept-Encoding" and do NOT compress already-compressed formats (e.g., .png, .jpg, .woff2).

Apply debounce/throttle to handlers that trigger network calls or heavy computation on rapid input.

Flag patterns that issue network/database calls inside loops; recommend batching (Promise.all), joins, or aggregate endpoints.

Check if React components are defined inside other components. Nested components are recreated on every render, causing unnecessary re-renders. Suggest moving them outside the parent component.

Ensure that `StringBuilder` instances are converted to strings using `ToString()` before use to prevent memory wastage.