@veraxhq/verax 0.1.0 → 0.2.0

package/src/verax/observe/aria-sensor.js

@@ -0,0 +1,211 @@
+/**
+ * ARIA Announcement Sensor
+ * Tracks ARIA live regions, status/alert roles, and announcements
+ */
+
+export class AriaSensor {
+  constructor() {
+    this.ariaStateBefore = null;
+    this.ariaStateAfter = null;
+  }
+
+  /**
+   * Capture ARIA state before interaction
+   */
+  async captureBefore(page) {
+    const ariaData = await page.evaluate(() => {
+      const result = {
+        liveRegions: [],
+        statusRoles: [],
+        alerts: [],
+        ariaBusyElements: [],
+        ariaLive: [],
+        announcements: []
+      };
+
+      // Find all live regions
+      const liveRegions = document.querySelectorAll('[aria-live]');
+      liveRegions.forEach(el => {
+        result.liveRegions.push({
+          selector: generateSelector(el),
+          ariaLive: el.getAttribute('aria-live'),
+          text: el.textContent?.slice(0, 100) || '',
+          ariaAtomic: el.getAttribute('aria-atomic'),
+          ariaRelevant: el.getAttribute('aria-relevant')
+        });
+      });
+
+      // Find status and alert roles
+      const statusAlerts = document.querySelectorAll('[role="status"], [role="alert"]');
+      statusAlerts.forEach(el => {
+        result.statusRoles.push({
+          selector: generateSelector(el),
+          role: el.getAttribute('role'),
+          text: el.textContent?.slice(0, 100) || '',
+          ariaLive: el.getAttribute('aria-live')
+        });
+      });
+
+      // Find aria-busy elements
+      const busyElements = document.querySelectorAll('[aria-busy="true"]');
+      busyElements.forEach(el => {
+        result.ariaBusyElements.push({
+          selector: generateSelector(el),
+          ariaBusy: el.getAttribute('aria-busy')
+        });
+      });
+
+      return result;
+
+      function generateSelector(el) {
+        if (el.id) return `#${el.id}`;
+        if (el.className) {
+          const classes = Array.from(el.classList || []).slice(0, 2).join('.');
+          return el.tagName.toLowerCase() + (classes ? `.${classes}` : '');
+        }
+        return el.tagName.toLowerCase();
+      }
+    });
+
+    this.ariaStateBefore = ariaData;
+    return ariaData;
+  }
+
+  /**
+   * Capture ARIA state after interaction
+   */
+  async captureAfter(page) {
+    const ariaData = await page.evaluate(() => {
+      const result = {
+        liveRegions: [],
+        statusRoles: [],
+        alerts: [],
+        ariaBusyElements: [],
+        ariaLive: [],
+        announcements: []
+      };
+
+      // Find all live regions
+      const liveRegions = document.querySelectorAll('[aria-live]');
+      liveRegions.forEach(el => {
+        result.liveRegions.push({
+          selector: generateSelector(el),
+          ariaLive: el.getAttribute('aria-live'),
+          text: el.textContent?.slice(0, 100) || '',
+          ariaAtomic: el.getAttribute('aria-atomic'),
+          ariaRelevant: el.getAttribute('aria-relevant')
+        });
+      });
+
+      // Find status and alert roles
+      const statusAlerts = document.querySelectorAll('[role="status"], [role="alert"]');
+      statusAlerts.forEach(el => {
+        result.statusRoles.push({
+          selector: generateSelector(el),
+          role: el.getAttribute('role'),
+          text: el.textContent?.slice(0, 100) || '',
+          ariaLive: el.getAttribute('aria-live')
+        });
+      });
+
+      // Find aria-busy elements
+      const busyElements = document.querySelectorAll('[aria-busy="true"]');
+      busyElements.forEach(el => {
+        result.ariaBusyElements.push({
+          selector: generateSelector(el),
+          ariaBusy: el.getAttribute('aria-busy')
+        });
+      });
+
+      return result;
+
+      function generateSelector(el) {
+        if (el.id) return `#${el.id}`;
+        if (el.className) {
+          const classes = Array.from(el.classList || []).slice(0, 2).join('.');
+          return el.tagName.toLowerCase() + (classes ? `.${classes}` : '');
+        }
+        return el.tagName.toLowerCase();
+      }
+    });
+
+    this.ariaStateAfter = ariaData;
+    return ariaData;
+  }
+
+  /**
+   * Detect if ARIA state changed (live region updates, role changes, etc)
+   */
+  detectAriaChange() {
+    if (!this.ariaStateBefore || !this.ariaStateAfter) {
+      return false;
+    }
+
+    // Check if live region text changed
+    const beforeLiveText = this.ariaStateBefore.liveRegions.map(r => r.text).join('|');
+    const afterLiveText = this.ariaStateAfter.liveRegions.map(r => r.text).join('|');
+
+    if (beforeLiveText !== afterLiveText) {
+      return true;
+    }
+
+    // Check if status/alert role text changed
+    const beforeStatusText = this.ariaStateBefore.statusRoles.map(r => r.text).join('|');
+    const afterStatusText = this.ariaStateAfter.statusRoles.map(r => r.text).join('|');
+
+    if (beforeStatusText !== afterStatusText) {
+      return true;
+    }
+
+    // Check if aria-busy state changed
+    const beforeBusy = this.ariaStateBefore.ariaBusyElements.length;
+    const afterBusy = this.ariaStateAfter.ariaBusyElements.length;
+
+    if (beforeBusy !== afterBusy) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if ARIA announcement should have occurred but didn't
+   */
+  detectMissingAnnouncement(eventType) {
+    // eventType: 'submit', 'network_success', 'network_error', 'validation_error', etc
+    // These meaningful events should typically trigger ARIA announcements
+
+    if (!this.ariaStateBefore || !this.ariaStateAfter) {
+      return false;
+    }
+
+    // Check if any live region exists (at least one should for accessibility)
+    const hasLiveRegion = this.ariaStateAfter.liveRegions.length > 0;
+    const hasStatus = this.ariaStateAfter.statusRoles.length > 0;
+
+    if (!hasLiveRegion && !hasStatus) {
+      return true; // No ARIA announcement mechanism present
+    }
+
+    // Check if announcement actually changed
+    const ariaChanged = this.detectAriaChange();
+
+    // For meaningful events, ARIA should have changed
+    if (!ariaChanged && (eventType === 'submit' || eventType === 'network_success' || eventType === 'network_error')) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get ARIA diff for evidence
+   */
+  getAriaDiff() {
+    return {
+      before: this.ariaStateBefore,
+      after: this.ariaStateAfter,
+      changed: this.detectAriaChange()
+    };
+  }
+}

package/src/verax/observe/browser.js

@@ -1,6 +1,5 @@
 import { chromium } from 'playwright';
-
-const STABLE_WAIT_MS = 2000;
+import { DEFAULT_SCAN_BUDGET } from '../shared/scan-budget.js';
 
 export async function createBrowser() {
   const browser = await chromium.launch({ headless: true });
@@ -11,9 +10,15 @@ export async function createBrowser() {
   return { browser, page };
 }
 
-export async function navigateToUrl(page, url) {
-  await page.goto(url, { waitUntil: 'networkidle', timeout: 30000 });
-  await page.waitForTimeout(STABLE_WAIT_MS);
+export async function navigateToUrl(page, url, scanBudget = DEFAULT_SCAN_BUDGET) {
+  let stableWait = scanBudget.navigationStableWaitMs;
+  try {
+    if (url.startsWith('file:') || url.includes('localhost:') || url.includes('127.0.0.1')) {
+      stableWait = 200; // Short wait for local fixtures
+    }
+  } catch {}
+  await page.goto(url, { waitUntil: 'networkidle', timeout: scanBudget.initialNavigationTimeoutMs });
+  await page.waitForTimeout(stableWait);
 }
 
 export async function closeBrowser(browser) {

package/src/verax/observe/console-sensor.js

@@ -104,7 +104,7 @@ export class ConsoleSensor {
   /**
    * Stop monitoring and return a summary for the window.
    */
-  async stopWindow(windowId, page) {
+  stopWindow(windowId, page) {
     const state = this.windows.get(windowId);
     if (!state) {
       return this.getEmptySummary();
@@ -112,22 +112,6 @@ export class ConsoleSensor {
 
     state.cleanup();
 
-    // Collect any unhandled rejections that were captured
-    let capturedRejections = [];
-    try {
-      capturedRejections = await page.evaluate(() => {
-        return window.__unhandledRejections || [];
-      });
-    } catch {
-      // Page may not have this
-    }
-
-    // Merge captured rejections with ones we heard about
-    state.unhandledRejections = [
-      ...state.unhandledRejections,
-      ...capturedRejections
-    ].slice(0, this.maxErrorsToKeep);
-
     const summary = {
       windowId,
       errorCount: state.consoleErrors.length + state.pageErrors.length,

package/src/verax/observe/domain-boundary.js

@@ -1,7 +1,10 @@
 export function getBaseOrigin(url) {
   try {
     const urlObj = new URL(url);
-    return `${urlObj.protocol}//${urlObj.host}${urlObj.port ? `:${urlObj.port}` : ''}`;
+    if (urlObj.protocol === 'file:') {
+      return 'file://';
+    }
+    return urlObj.origin;
   } catch (error) {
     return null;
   }
@@ -12,6 +15,12 @@ export function isExternalUrl(url, baseOrigin) {
   
   try {
     const urlObj = new URL(url);
+    // Special-case file protocol: treat all file:// URLs as same-origin
+    const isFileProtocol = urlObj.protocol === 'file:';
+    const baseIsFile = baseOrigin.startsWith('file:');
+    if (isFileProtocol && baseIsFile) {
+      return false;
+    }
     const urlOrigin = urlObj.origin;
     return urlOrigin !== baseOrigin;
   } catch (error) {