gsd-pi 2.28.0 → 2.29.0-dev.23d50d0

package/dist/resources/skills/code-optimizer/references/data-structures.md

@@ -0,0 +1,80 @@
+# Data Structures & Serialization
+
+## Grep/Glob Patterns to Detect
+
+### Wrong Data Structure for the Job
+```
+# Array used for frequent lookups (should be Map/Set/dict)
+\.find\(.*===                  (linear search - use Map)
+\.findIndex\(.*===             (linear search for index)
+\.includes\(.*inside.*loop     (O(n) lookup in loop)
+\.indexOf\(.*inside.*loop      (O(n) lookup in loop)
+if.*in\s+\[                    (Python: list membership test)
+list\.count\(                  (Python: counting in list)
+
+# Searching sorted data linearly (should use binary search)
+\.find\(.*sorted               (linear search on sorted array)
+for.*sorted                    (iterating sorted data to find)
+
+# Using objects where Map is better (non-string keys, frequent add/delete)
+\w+\[\w+\.id\]\s*=             (object with dynamic keys from IDs)
+delete\s+\w+\[                 (frequent deletion from object)
+Object\.keys\(.*\.length       (counting object keys - Map.size is O(1))
+
+# Using array for queue/deque operations
+\.shift\(\)                    (Array.shift is O(n) - use proper queue)
+\.unshift\(                    (Array.unshift is O(n))
+```
+
+### Unnecessary Deep Copies
+```
+JSON\.parse\(JSON\.stringify    (JSON round-trip for deep clone)
+\.map\(.*\.map\(.*spread       (nested spread for deep copy)
+\{\.\.\..*\{\.\.\.             (nested object spread)
+structuredClone\(.*inside.*loop (deep cloning in loop)
+copy\.deepcopy\(.*loop         (Python deepcopy in loop)
+import\s+copy                  (check if deepcopy is overused)
+```
+
+### Inefficient Serialization
+```
+# JSON for internal communication (use binary formats)
+JSON\.stringify.*JSON\.parse.*internal
+pickle\.dump.*pickle\.load     (Python: consider msgpack for cross-language)
+# Serializing more than needed
+JSON\.stringify\(.*entire      (serializing entire object when subset needed)
+\.toJSON\(\)                   (check what's being serialized)
+# Repeated serialization
+JSON\.stringify\(.*loop        (stringifying in loop)
+JSON\.parse\(.*loop            (parsing in loop)
+```
+
+### Unnecessary Object Creation
+```
+new Date\(.*inside.*loop       (creating Date objects in loop)
+new RegExp\(.*inside.*loop     (compiling regex in loop)
+new URL\(.*inside.*loop        (creating URL objects in loop)
+\.split\(.*\.join\(            (split then join - use replace)
+\.toString\(\).*\.split\(      (unnecessary string conversion)
+Array\.from\(.*Array\.from\(   (double Array.from)
+```
+
+### Immutability Overhead
+```
+# Excessive spread operators
+\{\.\.\.state,                 (spreading large state objects)
+\[\.\.\.array,                 (spreading large arrays)
+\.map\(.*=>.*\{\.\.\.         (creating new objects in map with spread)
+# Immer not used where it should be
+produce\(                      (check if immer is used consistently)
+```
+
+## Improvement Strategies
+
+1. **Array -> Map/Set**: Use Map for key-value lookups, Set for membership testing
+2. **Array.shift/unshift**: Use a proper deque/queue implementation
+3. **Deep copies**: Use structuredClone (modern), or targeted shallow copies
+4. **Serialization**: Use msgpack/protobuf for internal services, only JSON for external APIs
+5. **Object creation in loops**: Hoist object creation, reuse instances, use object pools
+6. **Large state spreads**: Use Immer's produce(), or targeted updates
+7. **Binary search**: Use on sorted data instead of linear search

package/dist/resources/skills/code-optimizer/references/database-queries.md

@@ -0,0 +1,76 @@
+# Database & Query Optimization
+
+## Grep/Glob Patterns to Detect
+
+### N+1 Query Problems
+```
+# ORM loops - querying inside iterations
+for.*in.*\.all\(\)
+for.*in.*\.filter\(
+for.*in.*\.objects\.
+\.prefetch_related  (absence of - check if loops exist WITHOUT prefetch)
+\.select_related    (absence of - check if FK access exists WITHOUT select_related)
+# SQLAlchemy
+session\.query.*for.*in
+\.lazy\s*=\s*True
+# ActiveRecord
+\.each.*\.where
+\.map.*\.find
+# Sequelize / TypeORM
+findOne.*inside.*map
+findOne.*inside.*for
+await.*find.*inside.*loop
+```
+
+### Unoptimized Queries
+```
+SELECT \*
+SELECT.*FROM.*WITHOUT.*WHERE  (full table scans)
+LIKE '%           (leading wildcard - can't use index)
+ORDER BY.*RAND()
+NOT IN.*SELECT     (subquery instead of JOIN)
+DISTINCT.*SELECT \*
+GROUP BY.*without.*index
+\.raw\(.*SELECT    (raw queries - potential SQL injection too)
+COUNT\(\*\).*WHERE  (count with filter vs indexed count)
+```
+
+### Missing Indexes (Heuristic)
+```
+WHERE.*=.*AND.*=    (composite queries without composite index)
+ORDER BY.*multiple columns
+JOIN.*ON.*without index hint
+\.filter\(.*__in=   (IN queries on large sets)
+```
+
+### ORM Anti-patterns
+```
+\.save\(\).*inside.*loop    (batch update instead)
+\.create\(\).*inside.*loop  (bulk_create instead)
+\.update\(\).*for.*in       (queryset.update instead)
+len\(.*\.all\(\)\)          (.count() instead)
+list\(.*\.all\(\)\)         (unnecessary materialization)
+if.*\.exists\(\).*\.first\(\)  (double query)
+\.values\(\).*\.values\(\)     (chained values)
+```
+
+### Connection Management
+```
+# Missing connection pooling
+create_engine\(.*pool_size  (check if pool is configured)
+new Pool\(                   (check pool settings)
+max_connections             (check if reasonable)
+# Unclosed connections
+connection\.open.*without.*close
+cursor.*without.*close
+```
+
+## Improvement Strategies
+
+1. **N+1 Queries**: Use eager loading (prefetch_related, select_related, JOIN FETCH, include/eager)
+2. **SELECT ***: Select only needed columns
+3. **Missing indexes**: Add indexes on frequently filtered/joined columns
+4. **Loop queries**: Use bulk operations (bulk_create, bulk_update, executemany)
+5. **Connection pooling**: Configure connection pools with appropriate size
+6. **Query caching**: Cache frequently-read, rarely-changing data
+7. **Pagination**: Never load unbounded result sets

package/dist/resources/skills/code-optimizer/references/dead-code-redundancy.md

@@ -0,0 +1,84 @@
+# Dead Code & Redundancy
+
+## Grep/Glob Patterns to Detect
+
+### Unused Exports/Functions
+```
+export\s+(function|const|class)\s+\w+    (cross-reference: is it imported anywhere?)
+def\s+\w+\(                              (cross-reference: is it called anywhere?)
+public\s+(static\s+)?\w+\s+\w+\(        (Java/C# methods - are they called?)
+func\s+\w+\(                             (Go functions - are they called?)
+```
+
+### Unused Imports
+```
+import.*from.*['"].*['"]    (cross-reference with usage in file)
+from\s+\w+\s+import\s+\w+  (Python: check if imported name is used)
+require\(['"].*['"]\)       (CJS: check if result is used)
+use\s+\w+;                  (Rust: check if used)
+```
+
+### Commented-Out Code
+```
+//\s*(function|const|let|var|class|import|return|if|for|while)
+#\s*(def|class|import|return|if|for|while)
+/\*[\s\S]*?(function|class|import)[\s\S]*?\*/
+```
+
+### Dead Branches
+```
+if\s*\(\s*false\s*\)        (always-false condition)
+if\s*\(\s*true\s*\)         (always-true condition - dead else)
+if\s*\(\s*0\s*\)            (falsy constant)
+if\s*\(\s*['"]['"]          (empty string - always falsy)
+TODO.*remove                 (TODOs indicating dead code)
+FIXME.*remove
+HACK.*temporary
+# Feature flags stuck off
+FEATURE_.*=\s*false
+ENABLE_.*=\s*false
+```
+
+### Duplicate Logic
+```
+# Similar function signatures in same file or nearby files
+function\s+\w*(get|fetch|load|process|handle)\w*\(   (many similar handlers)
+def\s+\w*(get|fetch|load|process|handle)\w*\(        (Python: similar functions)
+# Copy-paste indicators
+# Same code block appearing multiple times (use Grep to find identical blocks)
+```
+
+### Deprecated/Legacy Code
+```
+@deprecated
+@Deprecated
+# deprecated
+\.deprecated
+DEPRECATED
+legacy
+Legacy
+LEGACY
+__legacy__
+_old\b
+_backup\b
+_v[0-9]\b       (versioned functions like process_v1)
+```
+
+### Unreachable Code
+```
+return.*\n\s*(var|let|const|function)   (code after return)
+throw.*\n\s*(var|let|const|function)    (code after throw)
+exit\(\).*\n                            (code after exit)
+sys\.exit\(.*\n                         (Python: code after sys.exit)
+break\s*;\s*\n\s*\w                     (code after break)
+```
+
+## Improvement Strategies
+
+1. **Unused exports**: Remove and verify no external consumers (check all import statements)
+2. **Unused imports**: Remove with IDE or linting tooling
+3. **Commented code**: Delete it - version control preserves history
+4. **Dead branches**: Remove unreachable code, clean up feature flags
+5. **Duplicate logic**: Extract shared function, use strategy pattern if variants differ slightly
+6. **Deprecated code**: Plan migration, remove after all callers are updated
+7. **Unreachable code**: Remove statements after return/throw/exit

package/dist/resources/skills/code-optimizer/references/error-resilience.md

@@ -0,0 +1,80 @@
+# Error Handling & Resilience
+
+## Grep/Glob Patterns to Detect
+
+### Missing Timeouts
+```
+fetch\(.*(?!.*timeout)         (fetch without timeout)
+axios\.\w+\(.*(?!.*timeout)   (axios without timeout)
+requests\.\w+\(.*(?!.*timeout) (Python requests without timeout)
+http\.\w+\(.*(?!.*timeout)    (http call without timeout)
+new Promise\(.*(?!.*setTimeout) (promise without timeout)
+\.connect\(.*(?!.*timeout)     (DB/socket connect without timeout)
+```
+
+### Swallowed Errors
+```
+catch\s*\(\s*\w*\s*\)\s*\{\s*\}  (empty catch block)
+catch\s*\(\s*\)\s*\{\s*\}        (empty catch, no error param)
+except:\s*$                        (bare except)
+except\s+Exception.*pass          (catch-all with pass)
+except\s+Exception.*continue      (catch-all with continue)
+\.catch\(\s*\(\)\s*=>\s*\{\s*\}\) (empty .catch handler)
+\.catch\(\s*\(\)\s*=>\s*null\)    (swallowing with null)
+on_error.*pass                     (error handler that does nothing)
+```
+
+### Missing Retries for Transient Failures
+```
+# Network calls without retry logic
+fetch\(.*(?!.*retry)           (fetch without retry)
+axios\.\w+\(.*(?!.*retry)     (API call without retry)
+requests\.\w+\(.*(?!.*retry)  (Python request without retry)
+# Database operations without retry
+\.query\(.*(?!.*retry)         (DB query without retry)
+\.execute\(.*(?!.*retry)       (DB execute without retry)
+```
+
+### No Circuit Breaker
+```
+# Repeated calls to potentially failing services without circuit breaking
+while.*retry.*fetch            (retry loop without circuit break)
+MAX_RETRIES.*=.*[5-9]|[1-9]\d+ (high retry count without circuit breaker)
+```
+
+### Resource Cleanup on Error
+```
+# try without finally for resource cleanup
+try\s*\{.*open.*(?!.*finally)   (open resource without finally)
+try:.*open\(.*(?!.*finally)     (Python: open without finally or context manager)
+# Async cleanup missing
+async.*try.*(?!.*finally)       (async operation without cleanup)
+```
+
+### Cascading Failures
+```
+# No fallback/default values
+\?\?.*undefined                 (check fallback quality)
+\|\|.*null                      (check fallback quality)
+\.get\(.*,\s*None\)            (Python: check if None is appropriate default)
+# No graceful degradation
+catch.*throw                    (catching just to re-throw - no degradation)
+catch.*return\s+null            (returning null on error - caller may not handle)
+```
+
+### Logging Without Action
+```
+console\.error\(.*(?!.*throw|return|retry)  (logging error but not handling it)
+logger\.error\(.*(?!.*raise|return|retry)   (Python: logging without action)
+print\(.*error.*(?!.*raise|return)          (print error without handling)
+```
+
+## Improvement Strategies
+
+1. **Timeouts**: Add timeouts to ALL external calls (network, DB, file I/O). Use AbortController for fetch
+2. **Swallowed errors**: At minimum log errors, prefer explicit handling or re-throwing
+3. **Retries**: Implement exponential backoff with jitter for transient failures
+4. **Circuit breakers**: Use circuit breaker pattern for external service calls
+5. **Resource cleanup**: Use try-finally, context managers, or using statements
+6. **Graceful degradation**: Return cached/default data instead of failing completely
+7. **Error propagation**: Don't catch errors you can't handle - let them bubble up

package/dist/resources/skills/code-optimizer/references/io-network.md

@@ -0,0 +1,89 @@
+# I/O & Network Optimization
+
+## Grep/Glob Patterns to Detect
+
+### Sequential Requests (Should Be Batched/Parallel)
+```
+fetch\(.*\n.*fetch\(           (sequential fetch calls)
+axios\.\w+\(.*\n.*axios\.     (sequential axios calls)
+requests\.\w+\(.*\n.*requests (sequential Python requests)
+http\.\w+\(.*\n.*http\.       (sequential Node http calls)
+\.get\(.*\n.*\.get\(           (sequential GET requests)
+\.post\(.*\n.*\.post\(         (sequential POST requests)
+```
+
+### Missing Batching
+```
+# Individual API calls in loops
+for.*\n.*fetch\(               (fetch in loop)
+for.*\n.*axios\.               (axios in loop)
+for.*\n.*requests\.            (requests in loop)
+\.map\(.*fetch                 (map with individual fetches)
+\.forEach\(.*fetch             (forEach with individual fetches)
+# Individual DB writes in loops
+\.save\(\).*for                (save in loop - should batch)
+\.insert\(.*for                (insert in loop - should bulk insert)
+```
+
+### No Request Deduplication
+```
+# Same endpoint called multiple times
+fetch\(['"]([^'"]+)['"]\)      (check for duplicate URLs)
+axios\.\w+\(['"]([^'"]+)['"]  (check for duplicate URLs)
+useQuery\(.*['"]([^'"]+)['"]  (check for duplicate query keys)
+```
+
+### Missing Compression
+```
+# Large payload without compression
+Content-Type.*application/json  (check if gzip/br enabled)
+res\.json\(                     (response without compression middleware)
+# No compression middleware
+express\(\).*without.*compression
+```
+
+### Inefficient Serialization
+```
+JSON\.stringify\(.*large        (stringifying large objects)
+JSON\.parse\(.*JSON\.stringify  (deep clone via JSON - use structuredClone)
+pickle\.dumps\(                 (Python: consider msgpack/protobuf for performance)
+yaml\.dump\(.*yaml\.load\(     (YAML round-trip - slow for data exchange)
+```
+
+### Missing Streaming
+```
+\.readFile\(                   (read entire file vs createReadStream)
+\.readFileSync\(               (sync + entire file)
+body\.json\(\)                 (parse entire body vs streaming parser)
+\.text\(\)                     (entire response as text)
+\.json\(\).*large              (entire JSON response in memory)
+response\.data                 (entire response buffered)
+```
+
+### Missing Caching Headers
+```
+# API responses without caching
+res\.json\(.*without.*cache-control
+res\.send\(.*without.*etag
+# Static assets without cache headers
+express\.static\(.*without.*maxAge
+```
+
+### Retry Without Backoff
+```
+retry.*count                   (check if exponential backoff exists)
+while.*retry                   (retry loop without delay increase)
+catch.*retry                   (catch-retry without backoff)
+MAX_RETRIES                    (check backoff strategy)
+```
+
+## Improvement Strategies
+
+1. **Sequential requests**: Use Promise.all, asyncio.gather, or batch APIs
+2. **Loop requests**: Batch into single API call or use DataLoader pattern
+3. **Deduplication**: Use request deduplication (SWR, React Query, custom cache)
+4. **Compression**: Enable gzip/brotli at server and CDN level
+5. **Serialization**: Use efficient formats (protobuf, msgpack) for internal services
+6. **Streaming**: Use streams for large files/responses, NDJSON for large JSON
+7. **Caching**: Set appropriate Cache-Control, ETag, use stale-while-revalidate
+8. **Retries**: Implement exponential backoff with jitter

package/dist/resources/skills/code-optimizer/references/logging-observability.md

@@ -0,0 +1,64 @@
+# Logging & Observability Performance
+
+## Grep/Glob Patterns to Detect
+
+### Excessive Logging
+```
+console\.log\(                     (console.log in production code)
+console\.debug\(                   (console.debug in production)
+print\(.*debug                     (Python print debugging)
+logger\.debug\(.*inside.*loop      (debug logging in hot loop)
+log\.\w+\(.*inside.*for            (any logging in tight loop)
+console\.log\(JSON\.stringify\(    (serializing objects just to log)
+```
+
+### Expensive String Formatting in Logs
+```
+# String interpolation/formatting when log level is disabled
+logger\.debug\(f"                  (Python f-string even when debug disabled)
+logger\.debug\(.*\.format\(        (Python .format() even when debug disabled)
+logger\.debug\(`                   (JS template literal even when debug disabled)
+logger\.debug\(.*\+.*\+            (string concat for debug log)
+JSON\.stringify\(.*log             (JSON stringify for logging)
+```
+
+### Missing Structured Logging
+```
+console\.log\(["'].*:.*["']        (unstructured string logging)
+print\(.*["'].*:.*["']             (unstructured print logging)
+logger\.\w+\(["'].*["'] %         (format string logging vs structured)
+```
+
+### Synchronous Logging
+```
+fs\.writeFileSync.*log             (sync file write for logging)
+fs\.appendFileSync.*log            (sync file append for logging)
+open\(.*log.*\)\.write\(          (Python: sync log file write)
+```
+
+### Missing Request/Trace IDs
+```
+# API handlers without correlation IDs
+app\.(get|post)\(.*req.*res       (check if request ID is propagated)
+@app\.route\(                      (check if request ID middleware exists)
+```
+
+### Metrics Collection Overhead
+```
+# Metrics in hot paths
+\.observe\(.*inside.*loop         (Prometheus observe in loop)
+\.increment\(.*inside.*loop       (counter increment in loop)
+statsd\..*inside.*loop            (StatsD in loop)
+\.timing\(.*inside.*loop          (timing metric in loop)
+Date\.now\(\).*Date\.now\(\)      (manual timing - use proper instrumentation)
+performance\.now\(\).*performance (manual performance timing)
+```
+
+## Improvement Strategies
+
+1. **Console.log**: Remove from production, use proper logger with levels
+2. **Log formatting**: Use lazy evaluation - logger.debug("msg %s", expensive_value) vs f-strings
+3. **Structured logging**: Use JSON structured logs for machine parsing
+4. **Async logging**: Buffer and flush logs asynchronously, don't block request handling
+5. **Request IDs**: Add correlation ID middleware, propagate through all service calls
+6. **Metrics**: Pre-aggregate metrics, use histograms instead of per-request timers in hot loops

package/dist/resources/skills/code-optimizer/references/memory-resources.md

@@ -0,0 +1,66 @@
+# Memory & Resource Management
+
+## Grep/Glob Patterns to Detect
+
+### Memory Leaks
+```
+# Event listeners never removed
+addEventListener.*without.*removeEventListener
+\.on\(.*without.*\.off\(
+\.subscribe\(.*without.*unsubscribe
+# Timers never cleared
+setInterval\(.*without.*clearInterval
+setTimeout\(.*without.*clearTimeout
+# Global/module-level caches without eviction
+global.*\[\]        (unbounded global arrays)
+global.*\{\}        (unbounded global dicts/objects)
+module\.exports.*cache.*=.*\{\}
+_cache\s*=\s*\{\}   (module-level cache without LRU/TTL)
+# Closures retaining references
+closure.*large.*object
+# React-specific
+useEffect.*without.*cleanup
+useRef.*large.*object
+```
+
+### Unclosed Resources
+```
+open\(.*without.*close
+open\(.*without.*with\s   (Python: not using context manager)
+new FileReader\(.*without.*close
+createReadStream\(.*without.*destroy
+createWriteStream\(.*without.*end
+fs\.open\(.*without.*fs\.close
+new Socket\(.*without.*\.close
+new WebSocket\(.*without.*\.close
+acquire\(.*without.*release
+```
+
+### Large Allocations
+```
+new Array\(\d{5,}       (arrays > 10k elements)
+Buffer\.alloc\(\d{6,}   (buffers > 1MB)
+\.fill\(.*\d{6,}        (filling large arrays)
+\.repeat\(\d{4,}         (string repeat large count)
+JSON\.parse\(.*large     (parsing large JSON in memory)
+\.readFileSync\(          (synchronous large file reads)
+\.readFile\(.*without.*stream  (reading whole file vs streaming)
+```
+
+### String Concatenation in Loops
+```
+\+=.*string.*for
+\+=.*\".*loop
+str\s*\+=              (Python string concat in loop)
+\.join\(\[              (check if used correctly)
+```
+
+## Improvement Strategies
+
+1. **Event listeners**: Always pair add/remove, use AbortController for bulk cleanup
+2. **Timers**: Clear intervals in cleanup/unmount, use refs for timer IDs
+3. **Caches**: Use LRU cache with max size, add TTL, use WeakMap/WeakRef where possible
+4. **File handling**: Use context managers (Python with), try-finally, or using statements
+5. **Streams**: Use streaming for large data instead of loading everything in memory
+6. **String building**: Use StringBuilder/list join pattern instead of concatenation in loops
+7. **Buffers**: Pool and reuse buffers, use streaming transforms

package/dist/resources/skills/code-optimizer/references/rendering-ui.md

@@ -0,0 +1,90 @@
+# Rendering & UI Performance
+
+## Grep/Glob Patterns to Detect
+
+### React Re-render Issues
+```
+# Missing memoization
+const\s+\w+\s*=\s*\(\s*\)\s*=>.*return\s*\(    (inline component definitions)
+\w+\s*=\s*\{.*\}.*prop=                          (object literal as prop - new ref every render)
+\w+\s*=\s*\[.*\].*prop=                          (array literal as prop)
+\w+\s*=\s*\(\).*=>.*prop=                        (arrow function as prop - new ref every render)
+style=\{\{                                        (inline style object)
+# Context causing re-renders
+useContext\(                                       (check context value stability)
+<\w+Provider\s+value=\{\{                         (new object in Provider value)
+<\w+Provider\s+value=\{[^}]*\}                    (unstable provider value)
+# State management
+useState\(.*\{                                     (object state - check if needs splitting)
+setState\(.*\{\.\.\.state                          (spreading entire state on each update)
+```
+
+### Missing Virtualization
+```
+\.map\(.*<\w+                  (rendering list items - check list size)
+{items\.map\(                  (JSX list rendering - check if >50 items)
+\.map\(.*return.*<li           (list rendering without virtualization)
+\.map\(.*return.*<tr           (table row rendering without virtualization)
+\.map\(.*return.*<div          (div list - check count)
+v-for=                         (Vue list rendering)
+ngFor                          (Angular list rendering)
+```
+
+### Layout Thrashing
+```
+offsetWidth.*style\.           (read then write in sequence)
+offsetHeight.*style\.          (read then write)
+getBoundingClientRect.*style   (read then write)
+clientWidth.*className         (read then class change)
+scrollTop.*style               (read then write)
+\.style\..*\.style\.           (multiple style writes - batch with class)
+```
+
+### Large DOM
+```
+document\.createElement.*loop  (creating elements in loop)
+innerHTML\s*\+=                (innerHTML concatenation - causes reparse)
+\.appendChild\(.*loop          (appending in loop without fragment)
+document\.querySelector\(.*loop (DOM query in loop)
+\$\(.*\).*loop                 (jQuery selector in loop)
+```
+
+### Missing Lazy Loading
+```
+<img\s+(?!.*loading)           (images without loading="lazy")
+<iframe\s+(?!.*loading)        (iframes without lazy loading)
+import.*above.*fold            (heavy imports for below-fold content)
+```
+
+### Animation Performance
+```
+# Layout-triggering animations
+animate.*width                 (animating width triggers layout)
+animate.*height                (animating height triggers layout)
+animate.*top                   (animating top triggers layout)
+animate.*left                  (animating left triggers layout)
+animate.*margin                (animating margin triggers layout)
+transition.*width              (transitioning layout properties)
+transition.*height
+# Should use transform/opacity instead
+@keyframes.*\{.*(?:width|height|top|left|margin|padding)
+```
+
+### SSR/Hydration Issues
+```
+useEffect\(.*\[\].*setState   (client-side data fetch causing hydration mismatch)
+typeof window                  (window checks indicating SSR issues)
+document\.                     (direct document access in components)
+window\.                       (direct window access in components)
+```
+
+## Improvement Strategies
+
+1. **Re-renders**: Use React.memo, useMemo, useCallback for stable references
+2. **Context**: Split contexts by update frequency, memoize provider values
+3. **Virtualization**: Use react-window/react-virtuoso for lists > 50 items
+4. **Layout thrashing**: Batch reads, then batch writes; use requestAnimationFrame
+5. **DOM manipulation**: Use DocumentFragment, batch insertions, avoid innerHTML +=
+6. **Lazy loading**: Add loading="lazy" to images/iframes, use Intersection Observer
+7. **Animations**: Only animate transform and opacity (GPU-composited properties)
+8. **SSR**: Pre-fetch data server-side, avoid hydration mismatches