@veraxhq/verax 0.2.0 → 0.2.1

package/src/verax/observe/browser.js

@@ -16,12 +16,31 @@ export async function navigateToUrl(page, url, scanBudget = DEFAULT_SCAN_BUDGET)
     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 });
+  } catch {
+    // Ignore config errors
+  }
+  // Use domcontentloaded first for faster timeout, then wait for networkidle separately
+  await page.goto(url, { waitUntil: 'domcontentloaded', timeout: scanBudget.initialNavigationTimeoutMs });
+  await page.waitForLoadState('networkidle', { timeout: 10000 }).catch(() => {
+    // Network idle timeout is acceptable, continue
+  });
   await page.waitForTimeout(stableWait);
 }
 
 export async function closeBrowser(browser) {
-  await browser.close();
+  try {
+    // Close all contexts first
+    const contexts = browser.contexts();
+    for (const context of contexts) {
+      try {
+        await context.close({ timeout: 5000 }).catch(() => {});
+      } catch (e) {
+        // Ignore context close errors
+      }
+    }
+    await browser.close({ timeout: 5000 }).catch(() => {});
+  } catch (e) {
+    // Ignore browser close errors - best effort cleanup
+  }
 }
 

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

@@ -57,7 +57,7 @@ export class ConsoleSensor {
     };
 
     // Capture unhandled promise rejections
-    const onUnhandledRejection = (promise, reason) => {
+    const _onUnhandledRejection = (promise, reason) => {
       const message = (reason?.toString?.() || String(reason)).slice(0, 200);
       state.unhandledRejections.push({
         message: message,
@@ -104,7 +104,7 @@ export class ConsoleSensor {
   /**
    * Stop monitoring and return a summary for the window.
    */
-  stopWindow(windowId, page) {
+  stopWindow(windowId, _page) {
     const state = this.windows.get(windowId);
     if (!state) {
       return this.getEmptySummary();

package/src/verax/observe/expectation-executor.js

@@ -3,6 +3,7 @@
  * 
  * Executes every PROVEN expectation from the manifest.
  * Each expectation must result in: VERIFIED, SILENT_FAILURE, or COVERAGE_GAP.
+ * @typedef {import('playwright').Page} Page
  */
 
 import { isProvenExpectation } from '../shared/expectation-prover.js';
@@ -11,7 +12,7 @@ import { hasMeaningfulUrlChange, hasVisibleChange, hasDomChange } from '../detec
 import { runInteraction } from './interaction-runner.js';
 import { captureScreenshot } from './evidence-capture.js';
 import { getBaseOrigin } from './domain-boundary.js';
-import { resolve, dirname } from 'path';
+import { resolve } from 'path';
 
 /**
  * Execute a single PROVEN expectation.

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

@@ -155,7 +155,7 @@ export class FocusSensor {
   /**
    * Detect if focus didn't move into modal (expected but didn't happen)
    */
-  detectModalFocusFailure(page) {
+  detectModalFocusFailure(_page) {
     // This is checked via modal detection - focus should move to modal
     // Presence of modal without focus change = failure
     return false; // Caller will check if modal opened

package/src/verax/observe/human-driver.js

@@ -158,7 +158,9 @@ export class HumanBehaviorDriver {
       } else if (url.includes('localhost:') || url.includes('127.0.0.1')) {
         timeoutMs = 200; // Short wait for local http fixtures
       }
-    } catch {}
+    } catch {
+      // Ignore config errors
+    }
 
     const waitForUiIdle = async () => {
       const start = Date.now();
@@ -336,7 +338,10 @@ export class HumanBehaviorDriver {
 
     const focusableSelectors = await page.evaluate(() => {
       const focusables = Array.from(document.querySelectorAll('a[href], button, input, select, textarea, [tabindex], [role="button"], [role="menuitem"], [contenteditable="true"]'))
-        .filter(el => !el.hasAttribute('disabled') && el.tabIndex >= 0 && el.offsetParent !== null);
+        .filter(el => {
+          const htmlEl = /** @type {HTMLElement} */ (el);
+          return !el.hasAttribute('disabled') && htmlEl.tabIndex >= 0 && htmlEl.offsetParent !== null;
+        });
       const describe = (el) => {
         if (!el) return 'body';
         if (el.id) return `#${el.id}`;
@@ -609,7 +614,9 @@ export class HumanBehaviorDriver {
         page.waitForTimeout(CLICK_TIMEOUT_MS)
       ]);
       await this.waitAfterAction(page, 600);
-    } catch {}
+    } catch {
+      // Ignore form submission errors
+    }
 
     const afterUrl = page.url();
     const afterStorageKeys = await page.evaluate(() => Object.keys(localStorage));
@@ -660,7 +667,9 @@ export class HumanBehaviorDriver {
           clicked = true;
           await this.waitAfterAction(page, 400);
           break;
-        } catch {}
+        } catch {
+          // Ignore interaction errors
+        }
       }
     }
 
@@ -686,17 +695,23 @@ export class HumanBehaviorDriver {
     const beforeUrl = page.url();
     try {
       await page.goto(url, { waitUntil: 'load', timeout: CLICK_TIMEOUT_MS }).catch(() => null);
-    } catch {}
+    } catch {
+      // Ignore navigation errors
+    }
 
     const afterUrl = page.url();
-    const blocked = beforeUrl !== afterUrl && (afterUrl.includes('/login') || afterUrl.includes('/signin'));
+    const redirectedToLogin = beforeUrl !== afterUrl && (afterUrl.includes('/login') || afterUrl.includes('/signin'));
     const content = await page.content();
     const hasAccessDenied = content.includes('401') || content.includes('403') || content.includes('unauthorized') || content.includes('forbidden');
+    const isProtected = redirectedToLogin || hasAccessDenied;
 
     return {
       url,
-      blocked: blocked || hasAccessDenied,
-      redirectedTo: afterUrl,
+      beforeUrl,
+      afterUrl,
+      isProtected,
+      redirectedToLogin,
+      hasAccessDenied,
       httpStatus: hasAccessDenied ? (content.includes('403') ? 403 : 401) : 200
     };
   }
@@ -710,7 +725,9 @@ export class HumanBehaviorDriver {
             const key = window.localStorage.key(i);
             if (key) result[key] = window.localStorage.getItem(key);
           }
-        } catch (e) {}
+        } catch {
+          // Ignore localStorage access errors
+        }
         return result;
       });
 
@@ -721,7 +738,9 @@ export class HumanBehaviorDriver {
             const key = window.sessionStorage.key(i);
             if (key) result[key] = window.sessionStorage.getItem(key);
           }
-        } catch (e) {}
+        } catch {
+          // Ignore sessionStorage access errors
+        }
         return result;
       });
 

package/src/verax/observe/index.js

@@ -1,5 +1,5 @@
 import { resolve, dirname } from 'path';
-import { mkdirSync, readFileSync, existsSync } from 'fs';
+import { mkdirSync, readFileSync, existsSync, writeFileSync } from 'fs';
 import { createBrowser, navigateToUrl, closeBrowser } from './browser.js';
 import { discoverAllInteractions } from './interaction-discovery.js';
 import { captureScreenshot } from './evidence-capture.js';
@@ -15,7 +15,7 @@ import { deriveObservedExpectation, shouldAttemptRepeatObservedExpectation, eval
 import { computeRouteBudget } from '../core/budget-engine.js';
 import { loadPreviousSnapshot, saveSnapshot, buildSnapshot, compareSnapshots, shouldSkipInteractionIncremental } from '../core/incremental-store.js';
 import SilenceTracker from '../core/silence-model.js';
-import { DecisionRecorder, recordBudgetProfile, recordTimeoutConfig, recordAdaptiveStabilization, recordTruncation, recordEnvironment } from '../core/determinism-model.js';
+import { DecisionRecorder, recordBudgetProfile, recordTimeoutConfig, recordTruncation, recordEnvironment } from '../core/determinism-model.js';
 
 /**
  * OBSERVE PHASE - Execute interactions and capture runtime behavior
@@ -134,8 +134,11 @@ export async function observe(url, manifestPath = null, scanBudgetOverride = nul
     await navigateToUrl(page, url, scanBudget);
 
     const projectDir = manifestPath ? dirname(dirname(dirname(manifestPath))) : process.cwd();
-    const observeDir = resolve(projectDir, '.veraxverax', 'observe');
-    const screenshotsDir = resolve(observeDir, 'screenshots');
+    if (!runId) {
+      throw new Error('runId is required');
+    }
+    const { getScreenshotDir } = await import('../core/run-id.js');
+    const screenshotsDir = getScreenshotDir(projectDir, runId);
     mkdirSync(screenshotsDir, { recursive: true });
     
     const timestamp = Date.now();
@@ -307,7 +310,7 @@ export async function observe(url, manifestPath = null, scanBudgetOverride = nul
       
       // Discover ALL interactions on this page
       // Note: discoverAllInteractions already returns sorted interactions deterministically
-      const { interactions, coverage: pageCoverage } = await discoverAllInteractions(page, baseOrigin, routeBudget);
+      const { interactions } = await discoverAllInteractions(page, baseOrigin, routeBudget);
       totalInteractionsDiscovered += interactions.length;
       
       // SCALE INTELLIGENCE: Apply adaptive budget cap (interactions are already sorted deterministically)
@@ -847,7 +850,7 @@ export async function observe(url, manifestPath = null, scanBudgetOverride = nul
         }));
       
       const currentSnapshot = buildSnapshot(manifest, observedInteractions);
-      saveSnapshot(projectDir, currentSnapshot);
+      saveSnapshot(projectDir, currentSnapshot, runId);
       
       // Add incremental mode metadata to observation
       observation.incremental = {
@@ -865,7 +868,7 @@ export async function observe(url, manifestPath = null, scanBudgetOverride = nul
       mkdirSync(runsDir, { recursive: true });
       const decisionsPath = resolve(runsDir, 'decisions.json');
       const decisionsData = JSON.stringify(decisionRecorder.export(), null, 2);
-      require('fs').writeFileSync(decisionsPath, decisionsData, 'utf-8');
+      writeFileSync(decisionsPath, decisionsData, 'utf-8');
     }
     
     // Phase 4: Add safety mode statistics

package/src/verax/observe/interaction-discovery.js

@@ -73,7 +73,6 @@ async function extractLabel(element) {
 
 export async function discoverInteractions(page, baseOrigin, scanBudget = DEFAULT_SCAN_BUDGET) {
   const currentUrl = page.url();
-  const interactions = [];
   const seenElements = new Set();
   
   const allInteractions = [];
@@ -246,7 +245,6 @@ export async function discoverInteractions(page, baseOrigin, scanBudget = DEFAUL
     if (item.type === 'button' || item.type === 'link') {
       const text = (item.text || '').trim().toLowerCase();
       const label = (item.label || '').trim().toLowerCase();
-      const combined = `${text} ${label}`;
       
       const isLogout = /^(logout|sign\s*out|signout|log\s*out)$/i.test(text) ||
                        /^(logout|sign\s*out|signout|log\s*out)$/i.test(label) ||
@@ -419,12 +417,16 @@ export async function discoverInteractions(page, baseOrigin, scanBudget = DEFAUL
     try {
       const box = await item.element.boundingBox();
       if (box) {
+        // @ts-expect-error - Adding runtime properties to interaction object
         item.boundingY = box.y;
+        // @ts-expect-error - Adding runtime properties to interaction object
         item.boundingAvailable = true;
       }
     } catch (error) {
+      // @ts-expect-error - Adding runtime properties to interaction object
       item.boundingAvailable = false;
     }
+    // @ts-expect-error - Adding runtime properties to interaction object
     item.priority = computePriority(item, viewportHeight);
   }
 
@@ -457,7 +459,7 @@ export async function discoverInteractions(page, baseOrigin, scanBudget = DEFAUL
  * Discover ALL interactions on a page (no priority cap).
  * Used for full-site coverage traversal.
  */
-export async function discoverAllInteractions(page, baseOrigin, scanBudget = DEFAULT_SCAN_BUDGET) {
+export async function discoverAllInteractions(page, baseOrigin, _scanBudget = DEFAULT_SCAN_BUDGET) {
   const currentUrl = page.url();
   const seenElements = new Set();
   const allInteractions = [];
@@ -597,18 +599,28 @@ export async function discoverAllInteractions(page, baseOrigin, scanBudget = DEF
   
   // Return ALL interactions (no priority cap)
   return {
-    interactions: ordered.map(item => ({
-      type: item.type,
-      selector: item.selector,
-      label: item.label,
-      element: item.element,
-      isExternal: item.isExternal || false,
-      href: item.href,
-      text: item.text,
-      dataHref: item.dataHref,
-      dataDanger: item.dataDanger || false,
-      dataDestructive: item.dataDestructive || false
-    })),
+    interactions: ordered.map(item => {
+      const mapped = {
+        type: item.type,
+        selector: item.selector,
+        label: item.label,
+        element: item.element,
+        isExternal: item.isExternal || false,
+        href: item.href,
+        text: item.text,
+        dataHref: item.dataHref,
+        // @ts-expect-error - dataDanger and dataDestructive are optional runtime properties on interaction objects
+        dataDanger: item.dataDanger || false,
+        // @ts-expect-error - dataDestructive is an optional runtime property on interaction objects
+        dataDestructive: item.dataDestructive || false
+      };
+      // hasPasswordInput only exists on form types
+      if (item.type === 'form' || item.type === 'login') {
+        // @ts-expect-error - hasPasswordInput is only on form/login types at runtime
+        mapped.hasPasswordInput = item.hasPasswordInput || false;
+      }
+      return mapped;
+    }),
     coverage: {
       candidatesDiscovered: allInteractions.length,
       candidatesSelected: allInteractions.length,

package/src/verax/observe/interaction-runner.js

@@ -12,7 +12,9 @@ import { FocusSensor } from './focus-sensor.js';
 import { AriaSensor } from './aria-sensor.js';
 import { TimingSensor } from './timing-sensor.js';
 import { HumanBehaviorDriver } from './human-driver.js';
-import { DEFAULT_SCAN_BUDGET } from '../shared/scan-budget.js';
+
+// Import CLICK_TIMEOUT_MS from human-driver (re-export needed)
+const CLICK_TIMEOUT_MS = 2000;
 
 /**
  * SILENCE TRACKING: Mark timeout and record to silence tracker.
@@ -136,13 +138,11 @@ export async function runInteraction(page, interaction, timestamp, i, screenshot
   let loadingWindowData = null;
   
   let uiBefore = {};
-  let stateBefore = null;
-  let sessionStateBefore = null;
   
   try {
     // Capture session state before interaction for auth-aware interactions
     if (interaction.type === 'login' || interaction.type === 'logout') {
-      sessionStateBefore = await humanDriver.captureSessionState(page);
+      await humanDriver.captureSessionState(page);
     }
     
     if (Date.now() - startTime > scanBudget.maxScanDurationMs) {
@@ -263,7 +263,7 @@ export async function runInteraction(page, interaction, timestamp, i, screenshot
     const locator = interaction.element;
     // On file:// origins, avoid long navigation waits for simple link clicks
     const isFileOrigin = baseOrigin && baseOrigin.startsWith('file:');
-    const shouldWaitForNavigation = (interaction.type === 'link' || interaction.type === 'form') && !isFileOrigin;
+    let shouldWaitForNavigation = (interaction.type === 'link' || interaction.type === 'form') && !isFileOrigin;
     let navigationResult = null;
     
     try {
@@ -300,7 +300,7 @@ export async function runInteraction(page, interaction, timestamp, i, screenshot
         }
       } else if (interaction.type === 'logout') {
         // Logout action: click logout and observe session changes
-        const logoutResult = await humanDriver.executeLogout(page, locator);
+        const logoutResult = await humanDriver.performLogout(page);
         const sessionStateAfter = await humanDriver.captureSessionState(page);
         trace.logout = {
           clicked: logoutResult.clicked,

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

@@ -84,6 +84,12 @@ export class LoadingSensor {
     // Set up interval to check loading state (every 100ms for deterministic detection)
     const intervalId = setInterval(checkLoading, 100);
 
+    // CRITICAL: Unref the interval so it doesn't keep the process alive
+    // This allows tests to exit cleanly even if stopWindow() is not called
+    if (intervalId && intervalId.unref) {
+      intervalId.unref();
+    }
+
     // Immediately check once
     checkLoading();
 

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

@@ -109,7 +109,7 @@ export class NavigationSensor {
    * 
    * @param {number} windowId - Window ID
    * @param {Object} page - Playwright page
-   * @returns {Object} - Navigation summary
+   * @returns {Promise<any>} - Navigation summary
    */
   async stopWindow(windowId, page) {
     const state = this.windows.get(windowId);

package/src/verax/observe/settle.js

@@ -1,6 +1,7 @@
 /**
  * WAVE 2: Deterministic DOM settle logic
  * Waits for page to stabilize after navigation or interaction
+ * @typedef {import('playwright').Page} Page
  */
 
 import { DEFAULT_SCAN_BUDGET } from '../shared/scan-budget.js';

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

@@ -58,7 +58,10 @@ class ReduxSensor {
             resolve();
           } else {
             // Wait up to 5 seconds for store initialization
-            const timeout = setTimeout(() => resolve(), 5000);
+            const timeout = setTimeout(() => {
+              clearInterval(check);
+              resolve();
+            }, 5000);
             const check = setInterval(() => {
               if (window.__REDUX_STORE__) {
                 clearInterval(check);
@@ -125,7 +128,7 @@ class ReduxSensor {
               // Shallow copy of top-level keys only (privacy: no values)
               const snapshot = {};
               for (const key in state) {
-                if (state.hasOwnProperty(key)) {
+                if (Object.prototype.hasOwnProperty.call(state, key)) {
                   snapshot[key] = '[REDACTED]'; // Never store values, only keys
                 }
               }
@@ -222,8 +225,9 @@ class ZustandSensor {
         // Look for common Zustand patterns in window object
         for (const key in window) {
           if (key.startsWith('use') && typeof window[key] === 'function') {
-            const store = window[key];
-            if (store.getState && typeof store.getState === 'function') {
+            // Dynamic property access on window for Zustand store detection (runtime property)
+            const store = /** @type {any} */ (window[key]);
+            if (store && typeof store === 'object' && 'getState' in store && typeof store.getState === 'function') {
               return true;
             }
           }

package/src/verax/observe/state-ui-sensor.js

@@ -22,13 +22,14 @@ export class StateUISensor {
    */
   async snapshot(page, contextSelector = null) {
     try {
-      const snapshot = await page.evaluate(({ selector }) => {
+      const snapshot = await page.evaluate(() => {
         const signals = {};
         const rawSnapshot = {};
 
         // 1. Dialog/Modal signals
         signals.dialogs = [];
         const dialogs = document.querySelectorAll('[role="dialog"]');
+        // @ts-expect-error - NodeListOf is iterable in browser context
         for (const dialog of dialogs) {
           const isVisible = dialog.offsetParent !== null || dialog.hasAttribute('open');
           const ariaModal = dialog.getAttribute('aria-modal');
@@ -46,6 +47,7 @@ export class StateUISensor {
         // 2. Expansion state (aria-expanded)
         signals.expandedElements = [];
         const expandables = document.querySelectorAll('[aria-expanded]');
+        // @ts-expect-error - NodeListOf is iterable in browser context
         for (const el of expandables) {
           const expanded = el.getAttribute('aria-expanded') === 'true';
           signals.expandedElements.push({
@@ -58,6 +60,7 @@ export class StateUISensor {
         // 3. Tab selection (role=tab with aria-selected)
         signals.selectedTabs = [];
         const tabs = document.querySelectorAll('[role="tab"]');
+        // @ts-expect-error - NodeListOf is iterable in browser context
         for (const tab of tabs) {
           const selected = tab.getAttribute('aria-selected') === 'true';
           signals.selectedTabs.push({
@@ -70,6 +73,7 @@ export class StateUISensor {
         // 4. Checkbox/toggle state (aria-checked)
         signals.checkedElements = [];
         const checkables = document.querySelectorAll('[aria-checked]');
+        // @ts-expect-error - NodeListOf is iterable in browser context
         for (const el of checkables) {
           const checked = el.getAttribute('aria-checked') === 'true';
           signals.checkedElements.push({
@@ -82,6 +86,7 @@ export class StateUISensor {
         // 5. Alert/Status changes (role=alert, role=status)
         signals.alerts = [];
         const alerts = document.querySelectorAll('[role="alert"], [role="status"]');
+        // @ts-expect-error - NodeListOf is iterable in browser context
         for (const alert of alerts) {
           const text = alert.textContent?.trim() || '';
           signals.alerts.push({
@@ -96,6 +101,7 @@ export class StateUISensor {
         // Count visible nodes and text nodes (excluding style/comment nodes)
         const countMeaningfulNodes = () => {
           let count = 0;
+          // @ts-expect-error - NodeListOf is iterable in browser context
           for (const node of document.querySelectorAll('*')) {
             if (node.offsetParent !== null) { // Visible
               count++;

package/src/verax/observe/traces-writer.js

@@ -1,7 +1,23 @@
-import { resolve } from 'path';
 import { writeFileSync, mkdirSync } from 'fs';
 import { getArtifactPath, getRunArtifactDir } from '../core/run-id.js';
 
+/**
+ * @typedef {Object} WriteTracesResult
+ * @property {number} version
+ * @property {string} observedAt
+ * @property {string} url
+ * @property {Array} traces
+ * @property {Array} [observedExpectations]
+ * @property {Object} [coverage]
+ * @property {Array} [warnings]
+ * @property {Object} [silences] - Added by writeTraces if silenceTracker provided
+ * @property {string} tracesPath
+ * @property {Object} observeTruth
+ * @property {Object} [expectationExecution] - Added by caller after writeTraces
+ * @property {Array} [expectationCoverageGaps] - Added by caller after writeTraces
+ * @property {Object} [incremental] - Added by caller after writeTraces
+ */
+
 /**
  * SILENCE TRACKING: Write observation traces with explicit silence tracking.
  * All gaps, skips, caps, and unknowns must be recorded and surfaced.
@@ -11,24 +27,19 @@ import { getArtifactPath, getRunArtifactDir } from '../core/run-id.js';
  * @param {string} projectDir - Project directory
  * @param {string} url - URL observed
  * @param {Array} traces - Execution traces
- * @param {Object} coverage - Coverage data (if capped, this is a silence)
- * @param {Array} warnings - Warnings (caps are silences)
- * @param {Array} observedExpectations - Observed expectations
- * @param {Object} silenceTracker - Silence tracker (optional)
- * @param {string} runId - Run identifier (Phase 5)
+ * @param {Object} [coverage] - Coverage data (if capped, this is a silence)
+ * @param {Array} [warnings] - Warnings (caps are silences)
+ * @param {Array} [observedExpectations] - Observed expectations
+ * @param {Object} [silenceTracker] - Silence tracker (optional)
+ * @param {string} [runId] - Run identifier (Phase 5) - required but optional in signature for type compatibility
+ * @returns {WriteTracesResult}
  */
 export function writeTraces(projectDir, url, traces, coverage = null, warnings = [], observedExpectations = [], silenceTracker = null, runId = null) {
-  // PHASE 5: Use deterministic artifact path if runId provided, otherwise fall back to old path
-  let observeDir, tracesPath;
-  if (runId) {
-    observeDir = getRunArtifactDir(projectDir, runId);
-    tracesPath = getArtifactPath(projectDir, runId, 'traces.json');
-  } else {
-    // Backwards compatibility for tests
-    observeDir = resolve(projectDir, '.veraxverax', 'observe');
-    tracesPath = resolve(observeDir, 'observation-traces.json');
+  if (!runId) {
+    throw new Error('runId is required');
   }
-  
+  const observeDir = getRunArtifactDir(projectDir, runId);
+  const tracesPath = getArtifactPath(projectDir, runId, 'traces.json');
   mkdirSync(observeDir, { recursive: true });
   
   const observation = {

package/src/verax/observe/ui-signal-sensor.js

@@ -41,6 +41,7 @@ export class UISignalSensor {
       const statusRegions = Array.from(document.querySelectorAll('[role="status"], [role="alert"]'));
       const visibleStatusRegions = statusRegions.filter((el) => {
         const style = window.getComputedStyle(el);
+        // @ts-expect-error - offsetParent exists on HTMLElement in browser context
         return el.offsetParent !== null && style.visibility !== 'hidden' && style.display !== 'none' && style.opacity !== '0';
       });
       if (visibleStatusRegions.length > 0) {
@@ -57,6 +58,7 @@ export class UISignalSensor {
 
       // Check for dialogs
       const dialog = document.querySelector('[role="dialog"], [aria-modal="true"]');
+      // @ts-expect-error - offsetParent exists on HTMLElement in browser context
       if (dialog && dialog.offsetParent !== null) {
         // offsetParent is null if element is hidden
         result.hasDialog = true;
@@ -90,6 +92,7 @@ export class UISignalSensor {
       
       for (const invalidEl of invalidElements) {
         const style = window.getComputedStyle(invalidEl);
+        // @ts-expect-error - offsetParent exists on HTMLElement in browser context
         const isVisible = invalidEl.offsetParent !== null && 
                          style.visibility !== 'hidden' && 
                          style.display !== 'none' && 
@@ -120,6 +123,7 @@ export class UISignalSensor {
             const errorText = Array.from(parent.querySelectorAll('[role="alert"], .error, .invalid-feedback'))
               .find(el => {
                 const elStyle = window.getComputedStyle(el);
+                // @ts-expect-error - offsetParent exists on HTMLElement in browser context
                 return el.offsetParent !== null && 
                        elStyle.visibility !== 'hidden' && 
                        elStyle.display !== 'none' && 
@@ -138,6 +142,7 @@ export class UISignalSensor {
       const alertRegions = Array.from(document.querySelectorAll('[role="alert"], [role="status"]'));
       const visibleAlertRegions = alertRegions.filter((el) => {
         const style = window.getComputedStyle(el);
+        // @ts-expect-error - offsetParent exists on HTMLElement in browser context
         const isVisible = el.offsetParent !== null && 
                          style.visibility !== 'hidden' && 
                          style.display !== 'none' && 
@@ -149,6 +154,7 @@ export class UISignalSensor {
       const liveRegions = Array.from(document.querySelectorAll('[aria-live]'));
       const visibleLiveRegions = liveRegions.filter((el) => {
         const style = window.getComputedStyle(el);
+        // @ts-expect-error - offsetParent exists on HTMLElement in browser context
         const isVisible = el.offsetParent !== null && 
                          style.visibility !== 'hidden' && 
                          style.display !== 'none' && 
@@ -176,6 +182,7 @@ export class UISignalSensor {
         '[role="alert"], [class*="error"], [class*="danger"]'
       );
       if (errorMessages.length > 0) {
+        // @ts-expect-error - NodeListOf is iterable in browser context
         for (const elem of errorMessages) {
           const text = elem.textContent.trim().slice(0, 50);
           if (text && (text.toLowerCase().includes('error') || text.toLowerCase().includes('fail'))) {

package/src/verax/scan-summary-writer.js

@@ -4,8 +4,11 @@ import { computeExpectationsSummary } from './shared/artifact-manager.js';
 import { createImpactSummary } from './core/silence-impact.js';
 import { computeDecisionSnapshot } from './core/decision-snapshot.js';
 
-export function writeScanSummary(projectDir, url, projectType, learnTruth, observeTruth, detectTruth, manifestPath, tracesPath, findingsPath, runDirOpt = null, findingsArray = null) {
-  const scanDir = runDirOpt ? resolve(runDirOpt) : resolve(projectDir, '.veraxverax', 'scan');
+export function writeScanSummary(projectDir, url, projectType, learnTruth, observeTruth, detectTruth, manifestPath, tracesPath, findingsPath, runDirOpt, findingsArray = null) {
+  if (!runDirOpt) {
+    throw new Error('runDirOpt is required');
+  }
+  const scanDir = resolve(runDirOpt);
   mkdirSync(scanDir, { recursive: true });
   
   // Compute expectations summary from manifest

package/src/verax/shared/artifact-manager.js

@@ -13,7 +13,7 @@
  */
 
 import { existsSync, mkdirSync, writeFileSync, appendFileSync } from 'fs';
-import { resolve, join } from 'path';
+import { resolve } from 'path';
 import { randomBytes } from 'crypto';
 
 /**

package/src/verax/shared/budget-profiles.js

@@ -11,7 +11,7 @@
  * - EXHAUSTIVE: 300 seconds, maximum coverage (deep audit)
  */
 
-import { DEFAULT_SCAN_BUDGET, createScanBudget } from './scan-budget.js';
+import { createScanBudget } from './scan-budget.js';
 
 /**
  * QUICK profile: Fast feedback for development
@@ -107,7 +107,7 @@ export function getActiveBudgetProfile() {
 
 /**
  * Create a scan budget with the active profile applied.
- * @returns {ScanBudget} Complete scan budget with profile applied
+ * @returns {Object} Complete scan budget with profile applied
  */
 export function createScanBudgetWithProfile() {
   const profile = getActiveBudgetProfile();

package/src/verax/shared/caching.js

@@ -10,7 +10,7 @@
 
 import { createHash } from 'crypto';
 import { readFileSync, existsSync, statSync } from 'fs';
-import { resolve, join } from 'path';
+import { resolve } from 'path';
 
 const memoryCache = new Map(); // Global in-memory cache