@mocoto/mahoraga 0.14.5 → 0.14.7

package/dist/analysts/css/analysts/analyst-css.js

@@ -179,7 +179,16 @@ const CONHECIDAS_CSS_PROPRIEDADES = new Set([
     // CSS3 e modernas
     'transform-origin', 'inset', 'background-clip', 'max-width', 'max-height', 'min-height', 'animation-delay', 'pointer-events', 'scroll-behavior', 'background-attachment', 'text-shadow', 'inset-inline', 'inset-block', 'inset-inline-start', 'inset-inline-end', 'inset-block-start', 'inset-block-end',
     // Outros comuns
-    'cursor', 'opacity', 'transform', 'transition', 'animation', 'list-style', 'vertical-align', 'text-overflow', 'box-shadow', 'border-radius', 'outline', 'content', 'counter-reset', 'counter-increment'
+    'cursor', 'opacity', 'transform', 'transition', 'animation', 'list-style', 'vertical-align', 'text-overflow', 'box-shadow', 'border-radius', 'outline', 'content', 'counter-reset', 'counter-increment',
+    // CSS modernas (propriedades válidas e amplamente suportadas — ver feedback.md 1.4)
+    'clip-path', 'backdrop-filter', 'aspect-ratio', 'accent-color', 'appearance', 'user-select',
+    'object-fit', 'object-position', 'mix-blend-mode', 'filter', 'backdrop', 'will-change',
+    'place-items', 'place-content', 'place-self', 'grid-auto-flow', 'grid-auto-columns', 'grid-auto-rows',
+    'scroll-snap-type', 'scroll-snap-align', 'scroll-snap-stop', 'scroll-behavior', 'scroll-padding',
+    'text-wrap', 'overflow-wrap', 'word-break', 'hyphens', 'line-break', 'paint-order',
+    'touch-action', 'user-zoom', 'zoom', 'field-sizing', 'd', 'fill', 'stroke', 'stroke-width',
+    'mask-image', 'mask-size', 'mask-position', 'mask-repeat', 'clip-rule', 'fill-rule',
+    'isolation', 'contain', 'contain-intrinsic-size', 'content-visibility', 'rotate', 'scale', 'translate'
 ]);
 function isValidCssProperty(prop) {
     const normalized = prop.toLowerCase();

package/dist/analysts/detectors/detector-bugs-ml.js

@@ -1,6 +1,6 @@
-// SPDX-License-Identifier: MIT
-// @mahoraga-disable ml-deep-nesting
-// Justificativa: O detector de aninhamento excessivo analisa o próprio código gerando falso positivo em auto-análise. O padrão deep-nesting é necessário para detecção de bugs.
+import { parse as babelParse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
 import { getMessages } from '../../core/messages/index.js';
 const MAX_MESSAGE_PREVIEW_LENGTH = 60;
 // Statistical bug patterns with ML-like scoring
@@ -180,27 +180,42 @@ const BUG_PATTERNS = [
         severity: 'aviso',
         category: 'logic',
         weight: 0.7,
-        detect(content, _relPath) {
+        detect(content, relPath) {
+            // Contagem ingênua de todos os `()[]{}` globais gera falso positivo em
+            // bases modernas: aninhamento de JSX (divs aninhadas) e parênteses/colchetes
+            // de expressões inflam a profundidade sem aumentar a complexidade de
+            // decisão. Seguindo feedback.md seção 1.5, contamos apenas o aninhamento
+            // de BLOCOS DE LÓGICA (BlockStatement) via AST — JSX, literais de objeto/
+            // array e parênteses de expressão são ignorados. Arquivos não analisáveis
+            // mantêm o fallback conservador por contagem de colchetes.
+            const logic = computeLogicNestingDepth(content, relPath);
             let maxDepth = 0;
-            let currentDepth = 0;
             let depthLine = 0;
-            let lineCount = 1;
-            for (const char of content) {
-                if (char === '\n') {
-                    lineCount++;
-                }
-                if (char === '{' || char === '(' || char === '[') {
-                    currentDepth++;
-                    if (currentDepth > maxDepth) {
-                        maxDepth = currentDepth;
-                        depthLine = lineCount;
+            if (logic !== null) {
+                maxDepth = logic.depth;
+                depthLine = logic.line;
+            }
+            else {
+                let currentDepth = 0;
+                let lineCount = 1;
+                for (const char of content) {
+                    if (char === '\n') {
+                        lineCount++;
+                    }
+                    if (char === '{' || char === '(' || char === '[') {
+                        currentDepth++;
+                        if (currentDepth > maxDepth) {
+                            maxDepth = currentDepth;
+                            depthLine = lineCount;
+                        }
+                    }
+                    else if (char === '}' || char === ')' || char === ']') {
+                        currentDepth = Math.max(0, currentDepth - 1);
                     }
-                }
-                else if (char === '}' || char === ')' || char === ']') {
-                    currentDepth = Math.max(0, currentDepth - 1);
                 }
             }
-            if (maxDepth > 6) {
+            // Limiar maior: só sinaliza aninhamento de lógica genuinamente profundo.
+            if (maxDepth > 7) {
                 return {
                     confidence: Math.min(0.95, 0.5 + maxDepth * 0.06),
                     line: depthLine,
@@ -447,6 +462,53 @@ function hasValidation(content, _line) {
 function contarLinhasAtePos(content, pos) {
     return content.slice(0, pos).split('\n').length;
 }
+const traverseFn = traverse;
+/**
+ * Calcula a profundidade de aninhamento de BLOCOS DE LÓGICA (BlockStatement)
+ * via AST, ignorando JSX, literais de objeto/array e parênteses de expressões
+ * — que a contagem ingênua de colchetes contava indevidamente (feedback.md 1.5).
+ * Retorna `null` quando o arquivo não é JS/TS ou não pôde ser parseado.
+ */
+function computeLogicNestingDepth(content, relPath) {
+    if (!/\.(tsx?|jsx?|mjs|cjs)$/i.test(relPath)) {
+        return null;
+    }
+    try {
+        const lower = relPath.toLowerCase();
+        const isTs = lower.endsWith('.ts') || lower.endsWith('.tsx');
+        const isJsxLike = lower.endsWith('.tsx') || lower.endsWith('.jsx');
+        const plugins = ['decorators-legacy', 'classProperties', 'classPrivateProperties', 'classPrivateMethods', 'optionalChaining', 'nullishCoalescingOperator', 'topLevelAwait', 'importAttributes'];
+        if (isTs) {
+            plugins.unshift('typescript');
+        }
+        if (isJsxLike) {
+            plugins.unshift('jsx');
+        }
+        const ast = babelParse(content, { sourceType: 'unambiguous', errorRecovery: true, plugins: plugins });
+        let depth = 0;
+        let max = 0;
+        let maxLine = 0;
+        const visitor = {
+            BlockStatement: {
+                enter(path) {
+                    depth++;
+                    if (depth > max) {
+                        max = depth;
+                        maxLine = path.node.loc?.start.line ?? 0;
+                    }
+                },
+                exit() {
+                    depth--;
+                }
+            }
+        };
+        traverseFn(ast, visitor);
+        return { depth: max, line: maxLine };
+    }
+    catch {
+        return null;
+    }
+}
 function detectarPadroesBug(src, relPath, ocorrencias) {
     for (const pattern of BUG_PATTERNS) {
         try {

package/dist/analysts/detectors/detector-structure.js

@@ -51,7 +51,7 @@ export const detectorEstrutura = {
         const setCaminhos = new Set(caminhos);
         // Detecta contexto geral do projeto para análise inteligente
         const arquivoPrincipal = caminhos?.find(caminho => /package\.json$/.test(caminho)) ?? caminhos[0];
-        const conteudoPrincipal = contexto.arquivos.find(arquivo => arquivo.relPath === arquivoPrincipal)?.content ?? '';
+        const conteudoPrincipal = contexto.arquivos?.find(arquivo => arquivo.relPath === arquivoPrincipal)?.content ?? '';
         const contextoProjeto = detectarContextoProjeto({
             arquivo: arquivoPrincipal,
             conteudo: conteudoPrincipal,

package/dist/analysts/react/analysts/analyst-react-hooks.js

@@ -33,8 +33,63 @@ function extractHookCallContent(src, startIndex) {
     let depth = 0;
     let started = false;
     let content = '';
+    let inSingle = false;
+    let inDouble = false;
+    let inBacktick = false;
+    let escaped = false;
     for (let i = startIndex; i < src.length; i++) {
         const char = src[i];
+        if (escaped) {
+            escaped = false;
+            if (started)
+                content += char;
+            continue;
+        }
+        if (char === '\\' && (inSingle || inDouble || inBacktick)) {
+            escaped = true;
+            if (started)
+                content += char;
+            continue;
+        }
+        if (inSingle) {
+            if (char === "'")
+                inSingle = false;
+            if (started)
+                content += char;
+            continue;
+        }
+        if (inDouble) {
+            if (char === '"')
+                inDouble = false;
+            if (started)
+                content += char;
+            continue;
+        }
+        if (inBacktick) {
+            if (char === '`')
+                inBacktick = false;
+            if (started)
+                content += char;
+            continue;
+        }
+        if (char === "'") {
+            inSingle = true;
+            if (started)
+                content += char;
+            continue;
+        }
+        if (char === '"') {
+            inDouble = true;
+            if (started)
+                content += char;
+            continue;
+        }
+        if (char === '`') {
+            inBacktick = true;
+            if (started)
+                content += char;
+            continue;
+        }
         if (char === '(') {
             depth++;
             started = true;
@@ -51,50 +106,80 @@ function extractHookCallContent(src, startIndex) {
     }
     return content;
 }
-function collectHookIssues(src, relPath) {
+function collectHookIssues(src, relPath, opts = {}) {
     const ocorrencias = [];
     const lineOf = createLineLookup(src).lineAt;
-    // Check useEffect/useLayoutEffect for deps
-    const effectMatches = [...src.matchAll(/use(Layout)?Effect\s*\(/g)];
-    effectMatches.forEach(m => {
-        const hookInicio = m.index;
-        const fullCall = extractHookCallContent(src, hookInicio + m[0].length - 1);
-        const hasDepsArg = /,\s*(\[[\s\S]*?\]|\w+)\s*\)$/.test(fullCall);
-        const skip = /no-deps-ok|eslint-disable-next-line\s+react-hooks\/exhaustive-deps/i.test(fullCall);
-        if (!hasDepsArg && !skip) {
-            const line = lineOf(hookInicio);
-            ocorrencias.push(warn(messages.ReactHooksMensagens.useEffectNoDeps, relPath, line));
-        }
-        if (hasDepsArg && /\[\s*\]/.test(fullCall)) {
-            const bodyWithRefs = fullCall.match(/^[\s\S]*?(?=,\s*\[)/);
-            if (bodyWithRefs) {
-                const varRefs = bodyWithRefs[0].match(/\b([a-z]\w+)\b/g) ?? [];
-                const nonTrivialRefs = varRefs.filter(v => !/^(set|use)/.test(v) && v.length > 1 && !['undefined', 'null', 'true', 'false'].includes(v));
-                if (nonTrivialRefs.length > 0) {
-                    const line = lineOf(hookInicio);
-                    ocorrencias.push(warn('Empty deps array but effect references component variables', relPath, line));
+    // As verificações estruturais (useEffect/useMemo/useCallback sem deps e hook
+    // em condicional) são imprecisas quando feitas por regex/linha e geram falsos
+    // positivos. Quando a análise por AST (`parseHooksWithBabel`) está disponível,
+    // ela é a fonte autoritativa e estas verificações devem ser ignoradas.
+    const skipStructural = opts.skipStructural === true;
+    if (!skipStructural) {
+        // Check useEffect/useLayoutEffect for deps
+        const effectMatches = [...src.matchAll(/use(Layout)?Effect\s*\(/g)];
+        effectMatches.forEach(m => {
+            const hookInicio = m.index;
+            const fullCall = extractHookCallContent(src, hookInicio + m[0].length - 1);
+            // More robust deps detection: find the last comma followed by an array or identifier before the closing paren
+            const hasDepsArg = (() => {
+                // Find the last ')' (closing paren of the full call)
+                const lastClosing = fullCall.lastIndexOf(')');
+                if (lastClosing === -1)
+                    return false;
+                const beforeClosing = fullCall.slice(0, lastClosing);
+                // Find the last '[' or identifier before the closing paren
+                const arrayMatch = beforeClosing.match(/,\s*(\[[\s\S]*?\])\s*$/);
+                if (arrayMatch)
+                    return true;
+                const identMatch = beforeClosing.match(/,\s*(\w+)\s*$/);
+                if (identMatch)
+                    return true;
+                return false;
+            })();
+            const skip = /no-deps-ok|eslint-disable-next-line\s+react-hooks\/exhaustive-deps/i.test(fullCall);
+            if (!hasDepsArg && !skip) {
+                const line = lineOf(hookInicio);
+                ocorrencias.push(warn(messages.ReactHooksMensagens.useEffectNoDeps, relPath, line));
+            }
+            if (hasDepsArg && /\[\s*\]/.test(fullCall)) {
+                const bodyWithRefs = fullCall.match(/^[\s\S]*?(?=,\s*\[)/);
+                if (bodyWithRefs) {
+                    const varRefs = bodyWithRefs[0].match(/\b([a-z]\w+)\b/g) ?? [];
+                    const nonTrivialRefs = varRefs.filter(v => !/^(set|use)/.test(v) && v.length > 1 && !['undefined', 'null', 'true', 'false'].includes(v));
+                    if (nonTrivialRefs.length > 0) {
+                        const line = lineOf(hookInicio);
+                        ocorrencias.push(warn('Empty deps array but effect references component variables', relPath, line));
+                    }
                 }
             }
-        }
-    });
-    // useMemo/useCallback deps check
-    const memoMatches = [...src.matchAll(/use(Memo|Callback)\s*\(/g)];
-    memoMatches.forEach(m => {
-        const hookInicio = m.index;
-        const fullCall = extractHookCallContent(src, hookInicio + m[0].length - 1);
-        const hasDepsArg = /,\s*(\[[\s\S]*?\]|\w+)\s*\)$/.test(fullCall);
-        const skip = /no-deps-ok|eslint-disable-next-line\s+react-hooks\/exhaustive-deps/i.test(fullCall);
-        if (!hasDepsArg && !skip) {
-            const line = lineOf(hookInicio);
-            ocorrencias.push(warn(messages.ReactHooksMensagens.memoCallbackNoDeps, relPath, line));
-        }
-    });
-    // Conditional hooks
-    const conditionalHooks = [...src.matchAll(/(if|for|while)\s*\([^)]*\)\s*\{[\s\S]{0,160}?use[A-Z][A-Za-z0-9_]*/g)];
-    conditionalHooks.forEach(m => {
-        const line = lineOf(m.index || 0);
-        ocorrencias.push(warn(messages.ReactHooksMensagens.hookInConditional, relPath, line));
-    });
+        });
+        // useMemo/useCallback deps check
+        const memoMatches = [...src.matchAll(/use(Memo|Callback)\s*\(/g)];
+        memoMatches.forEach(m => {
+            const hookInicio = m.index;
+            const fullCall = extractHookCallContent(src, hookInicio + m[0].length - 1);
+            const hasDepsArg = /,\s*(\[[\s\S]*?\]|\w+)\s*\)$/.test(fullCall);
+            const skip = /no-deps-ok|eslint-disable-next-line\s+react-hooks\/exhaustive-deps/i.test(fullCall);
+            if (!hasDepsArg && !skip) {
+                const line = lineOf(hookInicio);
+                ocorrencias.push(warn(messages.ReactHooksMensagens.memoCallbackNoDeps, relPath, line));
+            }
+        });
+        // Conditional hooks — only flag when a hook call is directly inside a conditional block,
+        // not when the conditional is inside a hook callback (e.g. cleanup inside useEffect).
+        // The regex matches: if/for/while (...) { ... useXxx ... } but limits the match scope
+        // to avoid matching conditionals that appear inside hook callbacks.
+        const conditionalHooks = [...src.matchAll(/(?:^|(?<=[\n;]))\s*(if|for|while)\s*\([^)]*\)\s*\{[\s\S]{0,160}?use[A-Z][A-Za-z0-9_]*/g)];
+        conditionalHooks.forEach(m => {
+            const line = lineOf(m.index || 0);
+            // Heuristic: skip if the 'if' keyword is preceded by a closing paren or brace at the same indentation,
+            // which suggests it's inside a callback body rather than at the component top level.
+            const pre = src.slice(Math.max(0, (m.index ?? 0) - 80), m.index ?? 0);
+            if (/=>\s*$|\)\s*=>\s*$|\)\s*\{[\s\S]{0,40}$/.test(pre))
+                return;
+            ocorrencias.push(warn(messages.ReactHooksMensagens.hookInConditional, relPath, line));
+        });
+    } // fim de if (!skipStructural)
     // React 19: useOptimistic detected
     for (const match of src.matchAll(/\buseOptimistic\s*\(/g)) {
         const line = lineOf(match.index);
@@ -110,16 +195,12 @@ function collectHookIssues(src, relPath) {
         const line = lineOf(match.index);
         ocorrencias.push(warn('useFormStatus (React 19) detected - access pending form state', relPath, line, messages.SeverityNiveis.info));
     }
-    // React 19: use() hook - suspends, must be in Suspense boundary
-    for (const match of src.matchAll(/\buse\s*\(/g)) {
-        const line = lineOf(match.index);
-        // Avoid matching "useState", "useEffect", etc.
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime safety for match.index === 0
-        if (src[match.index - 1]?.match(/[a-zA-Z]/)) {
-            continue;
-        }
-        ocorrencias.push(warn('React 19 use() hook detected - must be wrapped in <Suspense> boundary', relPath, line, messages.SeverityNiveis.error));
-    }
+    // React 19: use() hook - suspends, must be in Suspense boundary.
+    // OBS: esta detecção por regex é intencionalmente OMITIDA aqui porque
+    // casaria falsamente com comentários/strings (ex.: "terms-of-use (...)") e
+    // com identificadores como "reuse(" / "abuse(". O hook use() é detectado de
+    // forma precisa via AST em parseHooksWithBabel (que ignora comentários),
+    // tornando este regex redundante e gerador de falsos positivos.
     // Custom hooks naming convention
     const customHooks = [...src.matchAll(/\buse[A-Z][A-Za-z0-9_]*\s*=\s*\(/g)];
     customHooks.forEach(m => {
@@ -127,7 +208,7 @@ function collectHookIssues(src, relPath) {
         if (!ALL_BUILTIN_HOOKS.includes(hookName)) {
             if (/^use[A-Z]/.test(hookName)) {
                 const line = lineOf(m.index || 0);
-                ocorrencias.push(warn(`Custom hook '${hookName}' - verify naming follows useXxx convention`, relPath, line));
+                ocorrencias.push(warn(`Custom hook '${hookName}' - verify naming follows useXxx convention`, relPath, line, messages.SeverityNiveis.info));
             }
         }
     });
@@ -182,7 +263,35 @@ function parseHooksWithBabel(src, relPath) {
         const isMemoLike = (name) => name === 'useMemo' || name === 'useCallback';
         const isAnyHook = (name) => /^use[A-Z0-9_]/.test(name) || name === 'use';
         const inConditionalOrLoop = (path) => {
-            return Boolean(path.findParent(p => p.isIfStatement() || p.isForStatement() || p.isWhileStatement() || p.isDoWhileStatement() || p.isSwitchStatement() || p.isConditionalExpression()));
+            // Só viola as Rules of Hooks se o hook estiver DENTRO de um
+            // if/for/while/do-while/switch/conditional no MESMO escopo de função que o
+            // contém. Condicionais em funções pais (ex.: um `if` no componente que define
+            // um hook customizado como useMusicPlayer) são válidas e NÃO devem gerar falso
+            // positivo (feedback.md seção 1.2). Callbacks aninhados (outra função) também
+            // delimitam o escopo — um condicional dentro de um callback não conta para o
+            // hook de fora.
+            let current = path;
+            while (current) {
+                const parent = current.parentPath;
+                if (!parent) {
+                    break;
+                }
+                // Função que contém o hook: condicionais acima dela estão em escopo diferente.
+                if (parent.isFunction()) {
+                    break;
+                }
+                if (parent.isIfStatement()
+                    || parent.isForStatement()
+                    || parent.isWhileStatement()
+                    || parent.isDoWhileStatement()
+                    || parent.isSwitchStatement()
+                    || parent.isSwitchCase()
+                    || parent.isConditionalExpression()) {
+                    return true;
+                }
+                current = parent;
+            }
+            return false;
         };
         const getIdentifiersInNode = (node) => {
             const ids = new Set();
@@ -291,12 +400,14 @@ function parseHooksWithBabel(src, relPath) {
                                 return !depsSet.has(r);
                             });
                             if (maybeMissing.length > 1) {
+                                // Apenas useMemo/useCallback com deps faltando são "sem array de
+                                // dependências". useEffect/useLayoutEffect QUE JÁ POSSUEM um array
+                                // de deps (mesmo que incompleto) NÃO devem ser reportados como
+                                // "sem array" — ver feedback.md seção 1.1. O aviso de stale closure
+                                // para esses casos já é emitido por outro analisador.
                                 if (isMemoLike(name)) {
                                     pushOnce(warn(messages.ReactHooksMensagens.memoCallbackNoDeps, relPath, locLine));
                                 }
-                                else {
-                                    pushOnce(warn(messages.ReactHooksMensagens.useEffectNoDeps, relPath, locLine));
-                                }
                             }
                             if (deps.elements.length === 0 && refsInCb.size > 0) {
                                 const nonTrivialRefs = [...refsInCb].filter(r => {
@@ -329,7 +440,7 @@ function parseHooksWithBabel(src, relPath) {
                         }
                     }
                     if (isAnyHook(name) && !isEffectLike(name) && !isMemoLike(name) && name !== 'useState' && name !== 'useRef' && name !== 'useContext' && name !== 'useReducer' && name !== 'useDebugValue' && name !== 'useId' && name !== 'useOptimistic' && name !== 'useActionState' && name !== 'useFormStatus' && name !== 'use') {
-                        pushOnce(warn(`Custom hook '${name}' usage detected`, relPath, locLine));
+                        pushOnce(warn(`Custom hook '${name}' usage detected`, relPath, locLine, messages.SeverityNiveis.info));
                     }
                 }
                 catch {
@@ -362,7 +473,12 @@ export const analistaReactHooks = criarAnalista({
         }
         const astMsgs = parseHooksWithBabel(src, relPath);
         if (astMsgs !== null) {
-            const regexMsgs = collectHookIssues(src, relPath);
+            // O AST é a fonte autoritativa para verificações estruturais (deps de
+            // useEffect/useMemo e hooks em condicional). Quando disponível, o regex
+            // estrutural é ignorado para evitar os falsos positivos de análise por
+            // texto (ver feedback.md seção 1.1 e 1.2). As verificações informativas
+            // do regex permanecem como rede de segurança.
+            const regexMsgs = collectHookIssues(src, relPath, { skipStructural: true });
             const all = [...astMsgs, ...regexMsgs];
             const seen = new Set();
             const deduped = all.filter(m => {

package/dist/analysts/react/analysts/analyst-react.js

@@ -38,6 +38,11 @@ function collectReactIssues(src, relPath) {
     // dangerouslySetInnerHTML
     for (const match of src.matchAll(/dangerouslySetInnerHTML/gi)) {
         const line = lineOf(match.index);
+        // Skip if this is a <script type="speculationrules"> element — dangerouslySetInnerHTML
+        // is required for Speculation Rules API (no children allowed, only innerHTML).
+        const lineContent = src.split('\n')[line - 1] ?? '';
+        if (/speculationrules/.test(lineContent))
+            continue;
         ocorrencias.push(warn(messages.ReactMensagens.dangerouslySetInnerHTML, relPath, line));
     }
     // <img> sem alt
@@ -233,6 +238,13 @@ function parseReactWithBabel(scan, relPath) {
                         }
                     }
                     if (findAttr(attrs, 'dangerouslySetInnerHTML')) {
+                        // Skip if this is a <script type="speculationrules"> — dangerouslySetInnerHTML
+                        // is required for Speculation Rules API (no children, only innerHTML).
+                        if (tag.toLowerCase() === 'script') {
+                            const typeAttr = findAttr(attrs, 'type');
+                            if (typeAttr && /speculationrules/i.test(normalizeStringValue(typeAttr.value)))
+                                return;
+                        }
                         pushOnce(warn(messages.ReactMensagens.dangerouslySetInnerHTML, relPath, locLine));
                     }
                     // Inline Styles

package/dist/analysts/react/detectors/detector-react-best-practices.js

@@ -9,6 +9,68 @@ const D = messages.DetectorReactMensagens;
 function warn(tipo, mensagem, relPath, linha, sugestao, nivel = 'aviso') {
     return criarOcorrencia({ tipo, nivel, mensagem, relPath, linha, sugestao });
 }
+/**
+ * Decide se o valor passado a `dangerouslySetInnerHTML` é estático/controlado
+ * e, portanto, seguro o suficiente para NÃO gerar falso positivo.
+ * (ver feedback.md seção 1.3 — JSON-LD, string interna, conteúdo sanitizado).
+ *
+ * Consideramos controlado quando o valor é:
+ *  - uma string literal (estática);
+ *  - resultado de `JSON.stringify(...)` (ex.: JSON-LD / structured data);
+ *  - resultado de uma chamada de sanitização/escape (`sanitize`, `escape`,
+ *    `encode`, `secure`, etc.);
+ *  - um template literal (conteúdo estático na prática).
+ */
+function isJsonStringifyCall(node) {
+    if (!t.isCallExpression(node)) {
+        return false;
+    }
+    const callee = node.callee;
+    return t.isMemberExpression(callee)
+        && t.isIdentifier(callee.object)
+        && callee.object.name === 'JSON'
+        && t.isIdentifier(callee.property)
+        && callee.property.name === 'stringify';
+}
+function calleeName(callee) {
+    if (t.isIdentifier(callee)) {
+        return callee.name;
+    }
+    if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
+        return callee.property.name;
+    }
+    return '';
+}
+function isControlledDangerousHtml(expr) {
+    if (!expr || t.isJSXEmptyExpression(expr)) {
+        return true;
+    }
+    if (t.isStringLiteral(expr)) {
+        return true;
+    }
+    if (t.isTemplateLiteral(expr)) {
+        return true;
+    }
+    if (t.isCallExpression(expr)) {
+        if (isJsonStringifyCall(expr)) {
+            return true;
+        }
+        // JSON.stringify(data).replace(...) / .trim() — o objeto da chamada é JSON.stringify
+        if (t.isMemberExpression(expr.callee) && isJsonStringifyCall(expr.callee.object)) {
+            return true;
+        }
+        const name = calleeName(expr.callee);
+        if (/sanit|escape|encod|secure|trust/i.test(name)) {
+            return true;
+        }
+    }
+    // JSON.stringify(...).replace(...) — o objeto da MemberExpression é a chamada
+    // JSON.stringify, então o conteúdo é estruturado/controlado (ex.: JSON-LD).
+    if (t.isMemberExpression(expr) && isJsonStringifyCall(expr.object)) {
+        return true;
+    }
+    return false;
+}
 export const detectorReactBestPractices = {
     nome: 'detector-react-best-practices',
     categoria: 'framework',
@@ -22,9 +84,6 @@ export const detectorReactBestPractices = {
         const linhas = splitLines(src);
         linhas.forEach((linha, index) => {
             const numeroLinha = index + 1;
-            if (/dangerouslySetInnerHTML/.test(linha)) {
-                ocorrencias.push(warn('react-dangerous-html', D.dangerousHtml, relPath, numeroLinha, D.dangerousHtmlSugestao, 'erro'));
-            }
             if (/onClick=|onSubmit=|onChange=|onMouseOver=/.test(linha) && /{[^}]*=>/.test(linha)) {
                 ocorrencias.push(warn('react-inline-handler', D.inlineHandler, relPath, numeroLinha, D.inlineHandlerSugestao, 'info'));
             }
@@ -59,6 +118,21 @@ export const detectorReactBestPractices = {
                 }
             }
         }
+        // Fallback conservador: quando o parse por AST falha, ainda detectamos
+        // dangerouslySetInnerHTML de forma limitada, alertando apenas quando o
+        // valor claramente vem de fonte externa/não controlada (props, params,
+        // localStorage, fetch, location, etc). Conteúdo estático/controlado é
+        // ignorado (ver feedback.md seção 1.3 - ex.: JSON-LD).
+        if (!deeper) {
+            linhas.forEach((linha, index) => {
+                if (/dangerouslySetInnerHTML/.test(linha) && !/speculationrules/i.test(linha)) {
+                    const numeroLinha = index + 1;
+                    if (/\b(props|params|query|searchParams|localStorage|sessionStorage|fetch\(|\blocation\b|window\.|document\.cookie|req\.|res\.)/.test(linha)) {
+                        ocorrencias.push(warn('react-dangerous-html', D.dangerousHtml, relPath, numeroLinha, D.dangerousHtmlSugestao, 'aviso'));
+                    }
+                }
+            });
+        }
         return ocorrencias;
     }
 };
@@ -101,7 +175,27 @@ function detectWithBabel(src, relPath) {
                 }
                 const locLine = path.node.loc?.start.line;
                 if (isHookName(name)) {
-                    const parent = path.findParent(p => p.isIfStatement() || p.isConditionalExpression() || p.isLogicalExpression() || p.isSwitchStatement() || p.isSwitchCase() || p.isForStatement() || p.isWhileStatement() || p.isDoWhileStatement() || p.isLoop());
+                    // Only flag hooks inside conditionals in the SAME function scope.
+                    // Stop climbing at function boundaries (callbacks, event handlers, etc.)
+                    // to avoid false positives when a conditional is inside a hook callback.
+                    const parent = (() => {
+                        let currentPath = path;
+                        while (currentPath) {
+                            const found = currentPath.findParent(p => p.isIfStatement() || p.isConditionalExpression() || p.isLogicalExpression() || p.isSwitchStatement() || p.isSwitchCase() || p.isForStatement() || p.isWhileStatement() || p.isDoWhileStatement() || p.isLoop());
+                            if (found)
+                                return found;
+                            // Stop at function boundaries
+                            const fnBoundary = currentPath.findParent(p => p.isFunction());
+                            if (!fnBoundary)
+                                return null;
+                            // Check above the function boundary
+                            const aboveFn = fnBoundary.findParent(p => p.isIfStatement() || p.isConditionalExpression() || p.isLogicalExpression() || p.isSwitchStatement() || p.isSwitchCase() || p.isForStatement() || p.isWhileStatement() || p.isDoWhileStatement() || p.isLoop());
+                            if (aboveFn)
+                                return aboveFn;
+                            return null;
+                        }
+                        return null;
+                    })();
                     if (parent) {
                         pushOnce(warn('react-hook-conditional', D.hookConditionalCall, relPath, locLine, D.hookConditionalCallSugestao, 'erro'));
                     }
@@ -303,6 +397,29 @@ function detectWithBabel(src, relPath) {
                         pushOnce(warn('react-key-index', D.keyIndexUsage, relPath, locLine, D.keyIndexUsageSugestao, 'aviso'));
                     }
                 }
+                // dangerouslySetInnerHTML: só alerta quando o valor NÃO é estático/
+                // controlado (ex.: vem de props, params, fetch, localStorage). Conteúdo
+                // como JSON-LD (JSON.stringify) ou string interna é seguro e não deve
+                // gerar ruído (ver feedback.md seção 1.3).
+                if (name === 'dangerouslySetInnerHTML') {
+                    const value = path.node.value;
+                    let htmlExpr;
+                    if (t.isJSXExpressionContainer(value)) {
+                        const inner = value.expression;
+                        if (t.isObjectExpression(inner)) {
+                            const htmlProp = inner.properties?.find(p => t.isObjectProperty(p) && t.isIdentifier(p.key) && p.key.name === '__html');
+                            if (htmlProp && t.isObjectProperty(htmlProp) && !t.isPrivateName(htmlProp.value) && !t.isJSXEmptyExpression(htmlProp.value)) {
+                                htmlExpr = htmlProp.value;
+                            }
+                        }
+                        else if (t.isExpression(inner)) {
+                            htmlExpr = inner;
+                        }
+                    }
+                    if (!isControlledDangerousHtml(htmlExpr)) {
+                        pushOnce(warn('react-dangerous-html', D.dangerousHtml, relPath, locLine, D.dangerousHtmlSugestao, 'aviso'));
+                    }
+                }
             },
             MemberExpression(path) {
                 const locLine = path.node.loc?.start.line;

package/dist/analysts/tailwind/analysts/analyst-tailwind.js

@@ -311,8 +311,11 @@ function propertyKey(token) {
             re: /^max-h(?:-|\[)/,
             key: 'max-h'
         }, {
-            re: /^(top|left|right|bottom)(?:-|\[)/,
-            key: 'position'
+            re: /^(top|bottom)(?:-|\[)/,
+            key: 'position-y'
+        }, {
+            re: /^(left|right)(?:-|\[)/,
+            key: 'position-x'
         }, {
             re: /^field-sizing(?:-|\[)/,
             key: 'field-sizing'