Performance & Efficiency rules

Exit loops as soon as the goal is achieved using break/return or use any/find/count short-circuiting operations.

Combine filters/maps to minimize passes; avoid creating intermediate collections unnecessarily.

Use appropriate column types/lengths (e.g., NVARCHAR(128) vs NVARCHAR(MAX)) for fields with known bounds.

Ensure that the `read(byte[], int, int)` method is overridden in `InputStream` subclasses to improve efficiency.

Detect string formatting using `.format()` or `%`. These methods are less readable and slower than f-strings. Recommend converting string formatting to f-strings for better readability and performance.

Use <Link> from 'next/link' for internal routes; reserve <a> only for external URLs or downloadable assets.

Ensure that event listeners are removed when no longer needed. Not doing so can lead to memory leaks and unnecessary resource consumption.

Avoid re-checking loop-invariant conditions inside iterations; lift them out.

Avoid unnecessary AsQueryable/ToList/Where/Select chains that do nothing; keep pipelines minimal.

Set sensible timeouts for queries/transactions and avoid excessively long timeouts that mask problems.

Serve assets with accurate Content-Type (e.g., text/css, application/javascript, image/avif, image/webp, font/woff2, image/svg+xml) and include charset for text types. Do not default to text/plain or application/octet-stream.

Configure UseStaticFiles with OnPrepareResponse to set "Cache-Control: public, max-age=31536000, immutable" for hashed assets and "no-cache" for HTML; ensure correct Content-Type (e.g., "font/woff2", "text/css").

In turbo.json, each task must set dependsOn (e.g., "^build") and outputs (e.g., "dist/"). Require cache:true for build/test/lint pipelines unless explicitly justified.

Replace `static final` with `const` where applicable to enable compile-time evaluation and optimize performance.

`string.Equals()` for checking empty strings is inefficient. Use `string.IsNullOrEmpty()` instead for clarity and performance.

Use the time package's types for handling time. For example, represent instants as `time.Time` and durations or time intervals as `time.Duration` instead of raw numeric types (int, int64).

Prefer set-based SQL (DELETE/UPDATE with WHERE IN/JOIN) or chunked batches over per-row statements.

Compute expensive derived values once per input set and reuse them rather than recalculating in multiple places.

For frequent key lookups, use Dictionary/ConcurrentDictionary instead of repeated linear scans.

When statically prebuilding dynamic segments, implement generateStaticParams and validate params; fall back to notFound() for invalid slugs.

Use HashSet<T> for repeated contains checks on large collections.

Stream results (cursor/generator) or paginate instead of loading entire result sets into memory.

Prefer comprehensions over map/filter chains and avoid double-sorting or sorting inside loops.

Prefer direct Map access over linear scans when looking up by key.