@veraxhq/verax 0.3.0 → 0.4.0

package/src/verax/core/ui-feedback-intelligence.js

@@ -37,8 +37,8 @@ export function detectUIFeedbackSignals(trace) {
   const sensors = trace.sensors || {};
   const uiSignals = sensors.uiSignals || {};
   const uiFeedback = sensors.uiFeedback || {};
-  const before = trace.before || {};
-  const after = trace.after || {};
+  const _before = trace.before || {};
+  const _after = trace.after || {};
   
   const beforeSignals = uiSignals.before || {};
   const afterSignals = uiSignals.after || {};
@@ -169,8 +169,8 @@ export function scoreUIFeedback(signals, expectation, trace) {
   const networkSensor = sensors.network || {};
   const uiFeedback = sensors.uiFeedback || {};
   
-  // Determine expected feedback type based on expectation
-  const expectedFeedbackTypes = inferExpectedFeedbackTypes(expectation);
+  // Evidence-only: no inferred feedback expectations
+  const expectedFeedbackTypes = [];
   
   // Check if any expected feedback types are present
   const matchingSignals = signals.filter(s => 
@@ -190,7 +190,9 @@ export function scoreUIFeedback(signals, expectation, trace) {
   if (matchingSignals.length > 0 || overallScore > 0.5) {
     return {
       score: FEEDBACK_SCORE.CONFIRMED,
-      confidence: Math.max(...matchingSignals.map(s => s.confidence), overallScore),
+      confidence: matchingSignals.length > 0
+        ? Math.max(...matchingSignals.map(s => s.confidence))
+        : overallScore,
       explanation: buildFeedbackExplanation(matchingSignals, overallScore, 'confirmed'),
       signals: matchingSignals,
       topSignals: matchingSignals.slice(0, 3).map(s => ({
@@ -240,42 +242,6 @@ export function scoreUIFeedback(signals, expectation, trace) {
   };
 }
 
-/**
- * Infer expected feedback types from expectation
- */
-function inferExpectedFeedbackTypes(expectation) {
-  const types = [];
-  
-  if (!expectation) return types;
-  
-  // Network expectations → loading + toast/error
-  if (expectation.type === 'network_action' || expectation.type === 'network') {
-    types.push(FEEDBACK_TYPE.LOADING);
-    types.push(FEEDBACK_TYPE.TOAST);
-    types.push(FEEDBACK_TYPE.INLINE_MESSAGE);
-  }
-  
-  // Navigation expectations → DOM change or modal
-  if (expectation.type === 'navigation' || expectation.type === 'spa_navigation') {
-    types.push(FEEDBACK_TYPE.DOM_CHANGE);
-    types.push(FEEDBACK_TYPE.MODAL);
-  }
-  
-  // State expectations → DOM change or disabled state
-  if (expectation.type === 'state_action' || expectation.type === 'state') {
-    types.push(FEEDBACK_TYPE.DOM_CHANGE);
-    types.push(FEEDBACK_TYPE.DISABLED);
-  }
-  
-  // Validation expectations → inline message
-  if (expectation.type === 'validation' || expectation.type === 'form_submission') {
-    types.push(FEEDBACK_TYPE.INLINE_MESSAGE);
-    types.push(FEEDBACK_TYPE.TOAST);
-  }
-  
-  return types;
-}
-
 /**
  * Build explanation for feedback score
  */
@@ -313,24 +279,24 @@ function buildFeedbackExplanation(signals, overallScore, outcome, context = {})
 /**
  * Helper functions to find selectors
  */
-function findLoadingSelector(signals) {
+function findLoadingSelector(_signals) {
   // Return a generic selector hint
   return '[aria-busy="true"], [data-loading], [role="status"]';
 }
 
-function findDisabledSelector(signals) {
+function findDisabledSelector(_signals) {
   return '[disabled], [aria-disabled="true"]';
 }
 
-function findToastSelector(signals) {
+function findToastSelector(_signals) {
   return '[role="alert"], [role="status"], [aria-live], .toast, .snackbar';
 }
 
-function findDialogSelector(signals) {
+function findDialogSelector(_signals) {
   return '[role="dialog"], [aria-modal="true"]';
 }
 
-function findInlineMessageSelector(signals) {
+function findInlineMessageSelector(_signals) {
   return '[role="alert"], .error, .success, [class*="message"]';
 }
 

package/src/verax/detect/conditional-ui-silent-failure.js

@@ -0,0 +1,84 @@
+/**
+ * Conditional UI Stale State Detection
+ * 
+ * Detects UI elements that should update/disappear when state changes but don't:
+ * - State mutation observed (via state sensor or console logs)
+ * - Dependent UI element remains unchanged
+ * - Expected element missing or still visible
+ * 
+ * CONFIDENCE: MEDIUM (heuristic-based)
+ * PARTIAL SUPPORT: Heuristic detection, not semantic analysis
+ * 
+ * Note: Does NOT detect async race conditions (UNSUPPORTED - too many false positives)
+ */
+
+import { hasDomChange } from './comparison.js';
+import { enrichFindingWithExplanations } from './finding-detector.js';
+
+export function detectConditionalUiSilentFailures(traces, manifest, findings) {
+  // Parameters:
+  // traces - array of interaction traces from observation
+  // manifest - project manifest (contains expectations)
+  // findings - array to append new findings to (mutated in-place)
+
+  for (const trace of traces) {
+    const sensors = trace.sensors || {};
+    const stateSignals = sensors.state || {};
+    const uiSignals = sensors.uiSignals || {};
+    const uiDiff = uiSignals.diff || {};
+    const domChanged = hasDomChange(trace);
+
+    // Heuristic: State changed but UI didn't
+    // This suggests a stale UI or conditional rendering bug
+    const stateChanged = stateSignals.changed === true || 
+                        (stateSignals.changed && stateSignals.changed.length > 0);
+    const uiChanged = uiDiff.changed === true;
+
+    // Detection logic:
+    // State changed but UI did not
+    // This is a common pattern for stale UI bugs in React/Vue
+    if (stateChanged && !uiChanged && !domChanged) {
+      const interaction = trace.interaction || {};
+      
+      // Skip if it's a form input (expected state-only change)
+      if (interaction.type === 'interaction' && interaction.category === 'button') {
+        const evidence = {
+          before: trace.before?.screenshot || trace.beforeScreenshot || '',
+          after: trace.after?.screenshot || trace.afterScreenshot || '',
+          beforeUrl: trace.before?.url || trace.beforeUrl || '',
+          afterUrl: trace.after?.url || trace.afterUrl || '',
+          stateChanged,
+          uiChanged,
+          domChanged,
+          reason: 'State updated but UI did not reflect the change (stale UI)'
+        };
+
+        const finding = {
+          type: 'conditional_ui_silent_failure',
+          description: `Conditional UI element did not update when state changed`,
+          summary: `Button/interaction caused state change but UI did not update (stale UI pattern)`,
+          explanation: `State mutation was detected but the UI elements dependent on that state did not update. This is a common pattern in React/Vue applications where conditional rendering or dynamic classes don't update properly.`,
+          evidence,
+          confidence: {
+            level: 0.60, // MEDIUM - heuristic-based
+            reasons: [
+              'State mutation observed',
+              'UI elements did not update to reflect new state',
+              'Likely stale UI or conditional rendering bug'
+            ]
+          },
+          promise: {
+            type: 'conditional_ui_update',
+            expected: 'State change triggers UI update (conditional render, class change, etc.)',
+            actual: 'State changed but UI remained unchanged'
+          },
+          capabilityNote: 'PARTIAL SUPPORT: Detection based on state sensor data and heuristics. Does not perform semantic analysis of UI logic. Async race conditions are UNSUPPORTED due to high false positive rate.'
+        };
+
+        // Enrich with explanations
+        enrichFindingWithExplanations(finding, trace);
+        findings.push(finding);
+      }
+    }
+  }
+}