@veraxhq/verax 0.2.0 → 0.2.1

package/src/verax/intel/vue-navigation-extractor.js

@@ -11,24 +11,29 @@
 import ts from 'typescript';
 import { parseFile, findNodes, getStringLiteral, getNodeLocation } from './ts-program.js';
 import { readFileSync, existsSync } from 'fs';
-import { resolve, extname } from 'path';
+import { resolve, extname, relative } from 'path';
+import { globSync } from 'glob';
 import { normalizeDynamicRoute, normalizeTemplateLiteral } from '../shared/dynamic-route-utils.js';
 
 /**
  * Extract navigation promises from Vue components.
  * 
- * @param {Object} program - TypeScript program
- * @param {string} projectRoot - Project root
- * @returns {Promise<Array>} - Array of navigation expectation objects
+ * @param {Object|string} programOrProjectRoot - TypeScript program object or project root path
+ * @param {string|Object} [maybeProjectRoot] - Project root string or program object (supports both call signatures)
+ * @returns {Array} - Array of navigation expectation objects
  */
-export async function extractVueNavigationPromises(program, projectRoot) {
-  const expectations = [];
+export function extractVueNavigationPromises(programOrProjectRoot, maybeProjectRoot) {
+  // Accept both (program, projectRoot) and (projectRoot, program) call signatures
+  const program = programOrProjectRoot && programOrProjectRoot.program ? programOrProjectRoot : maybeProjectRoot;
+  const projectRoot = programOrProjectRoot && programOrProjectRoot.program ? (maybeProjectRoot || process.cwd()) : programOrProjectRoot;
   
-  if (!program || !program.program) return expectations;
+  if (!program || !program.program || !projectRoot) return [];
+  const expectations = [];
   
   // Find Vue component files (.vue, .ts, .js, .tsx, .jsx)
   const vueFiles = [];
-  const sourceFiles = program.getSourceFiles ? program.getSourceFiles() : (program.sourceFiles || []);
+  const tsProgram = program.program || program;
+  const sourceFiles = tsProgram.getSourceFiles ? tsProgram.getSourceFiles() : (program.sourceFiles || []);
   
   for (const sourceFile of sourceFiles) {
     // sourceFiles can be either file paths (strings) or SourceFile objects
@@ -42,11 +47,9 @@ export async function extractVueNavigationPromises(program, projectRoot) {
   
   // Also explicitly glob for .vue files since TypeScript might not include them
   try {
-    const { glob } = await import('glob');
-    const vueGlobPattern = resolve(projectRoot, '**/*.vue');
-    const vueFilesFromGlob = await glob(vueGlobPattern, { cwd: projectRoot });
+    const vueFilesFromGlob = globSync('**/*.vue', { cwd: projectRoot, absolute: true, nodir: true });
     for (const filePath of vueFilesFromGlob) {
-      const absPath = resolve(projectRoot, filePath);
+      const absPath = resolve(filePath);
       if (!vueFiles.includes(absPath) && !vueFiles.find(f => f.endsWith(filePath))) {
         vueFiles.push(absPath);
       }
@@ -68,16 +71,54 @@ export async function extractVueNavigationPromises(program, projectRoot) {
  * 
  * @param {string} filePath - File path
  * @param {string} projectRoot - Project root
- * @param {Object} program - TypeScript program
  * @returns {Array} - Navigation expectations
  */
-function extractFromFile(filePath, projectRoot, program) {
+function extractFromFile(filePath, projectRoot, _program) {
   const expectations = [];
   
   // Check if it's a .vue file (SFC)
   if (extname(filePath) === '.vue') {
     const sfcExpectations = extractFromVueSFC(filePath, projectRoot);
     expectations.push(...sfcExpectations);
+    
+    // For .vue files, also parse the script section as AST
+    // to handle template literals and complex navigation calls
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+      if (scriptMatch) {
+        const scriptContent = scriptMatch[1];
+        // Parse script content as TypeScript/JavaScript
+        const ast = ts.createSourceFile(
+          filePath,
+          scriptContent,
+          ts.ScriptTarget.Latest,
+          true,
+          ts.ScriptKind.TS
+        );
+        
+        // Extract router.push/replace calls
+        const routerCalls = findRouterCalls(ast);
+        for (const call of routerCalls) {
+          const expectation = extractFromRouterCall(call, ast, projectRoot, filePath);
+          if (expectation) {
+            // Check for duplicates (might already be extracted by regex)
+            const isDupe = expectations.some(e => 
+              e.targetPath === expectation.targetPath && 
+              e.navigationMethod === expectation.navigationMethod &&
+              e.sourceRef === expectation.sourceRef
+            );
+            if (!isDupe) {
+              expectations.push(expectation);
+            }
+          }
+        }
+      }
+    } catch (err) {
+      // If script parsing fails, fall back to regex-based extraction (already done)
+    }
+    
+    return expectations;
   }
   
   // Extract from script section (TypeScript/JavaScript)
@@ -114,7 +155,6 @@ function extractFromFile(filePath, projectRoot, program) {
  */
 function extractFromVueSFC(filePath, projectRoot) {
   const expectations = [];
-  const { relative } = require('path');
   
   if (!existsSync(filePath)) return expectations;
   
@@ -141,8 +181,10 @@ function extractFromVueSFC(filePath, projectRoot) {
               type: 'spa_navigation',
               targetPath: normalized.examplePath,
               originalPattern: normalized.originalPattern,
+              originalTarget: normalized.originalPattern,
               isDynamic: true,
               exampleExecution: true,
+              parameters: normalized.parameters || [],
               matchAttribute: 'to',
               proof: 'PROVEN_EXPECTATION',
               sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
@@ -186,8 +228,10 @@ function extractFromVueSFC(filePath, projectRoot) {
               type: 'spa_navigation',
               targetPath: normalized.examplePath,
               originalPattern: normalized.originalPattern,
+              originalTarget: normalized.originalPattern,
               isDynamic: true,
               exampleExecution: true,
+              parameters: normalized.parameters || [],
               matchAttribute: 'to',
               proof: 'PROVEN_EXPECTATION',
               sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
@@ -223,6 +267,7 @@ function extractFromVueSFC(filePath, projectRoot) {
     if (scriptMatch) {
       const scriptContent = scriptMatch[1];
       const routerPushRegex = /router\.(push|replace)\s*\(\s*["']([^"']+)["']\s*\)/g;
+      let match;
       while ((match = routerPushRegex.exec(scriptContent)) !== null) {
         const method = match[1];
         const path = match[2];
@@ -236,8 +281,10 @@ function extractFromVueSFC(filePath, projectRoot) {
               type: 'spa_navigation',
               targetPath: normalized.examplePath,
               originalPattern: normalized.originalPattern,
+              originalTarget: normalized.originalPattern,
               isDynamic: true,
               exampleExecution: true,
+              parameters: normalized.parameters || [],
               navigationMethod: method,
               proof: 'PROVEN_EXPECTATION',
               sourceRef: `${relative(projectRoot, filePath).replace(/\\/g, '/')}:${line}`,
@@ -283,7 +330,7 @@ function extractFromVueSFC(filePath, projectRoot) {
  * @returns {Array} - Call expression nodes
  */
 function findRouterCalls(ast) {
-  const calls = [];
+  const _calls = [];
   
   const callExpressions = findNodes(ast, node => {
     if (!ts.isCallExpression(node)) return false;
@@ -307,9 +354,10 @@ function findRouterCalls(ast) {
  * @param {ts.CallExpression} call - Call expression
  * @param {ts.SourceFile} ast - Source file
  * @param {string} projectRoot - Project root
+ * @param {string} [filePathOverride] - Optional file path override for .vue files
  * @returns {Object|null} - Expectation or null
  */
-function extractFromRouterCall(call, ast, projectRoot) {
+function extractFromRouterCall(call, ast, projectRoot, filePathOverride = null) {
   const expr = call.expression;
   if (!ts.isPropertyAccessExpression(expr)) return null;
   
@@ -321,6 +369,13 @@ function extractFromRouterCall(call, ast, projectRoot) {
   const arg = call.arguments[0];
   const location = getNodeLocation(ast, call, projectRoot);
   
+  // Override file path if provided (for .vue files)
+  if (filePathOverride) {
+    const relativePath = relative(projectRoot, filePathOverride);
+    location.file = relativePath.replace(/\\/g, '/');
+    location.sourceRef = `${relativePath.replace(/\\/g, '/')}:${location.line}`;
+  }
+  
   // String literal: router.push('/path')
   const path = getStringLiteral(arg);
   if (path && path.startsWith('/')) {
@@ -331,8 +386,10 @@ function extractFromRouterCall(call, ast, projectRoot) {
         type: 'spa_navigation',
         targetPath: normalized.examplePath,
         originalPattern: normalized.originalPattern,
+        originalTarget: normalized.originalPattern,
         isDynamic: true,
         exampleExecution: true,
+        parameters: normalized.parameters || [],
         navigationMethod: method,
         proof: 'PROVEN_EXPECTATION',
         sourceRef: location.sourceRef,
@@ -391,8 +448,10 @@ function extractFromRouterCall(call, ast, projectRoot) {
           type: 'spa_navigation',
           targetPath: normalized.examplePath,
           originalPattern: normalized.originalPattern,
+          originalTarget: normalized.originalPattern,
           isDynamic: true,
           exampleExecution: true,
+          parameters: normalized.parameters || [],
           navigationMethod: method,
           proof: 'PROVEN_EXPECTATION',
           sourceRef: location.sourceRef,
@@ -425,8 +484,10 @@ function extractFromRouterCall(call, ast, projectRoot) {
             type: 'spa_navigation',
             targetPath: normalized.examplePath,
             originalPattern: normalized.originalPattern,
+            originalTarget: normalized.originalPattern,
             isDynamic: true,
             exampleExecution: true,
+            parameters: normalized.parameters || [],
             navigationMethod: method,
             proof: 'PROVEN_EXPECTATION',
             sourceRef: location.sourceRef,
@@ -468,7 +529,7 @@ function extractFromRouterCall(call, ast, projectRoot) {
  * @returns {Array} - JSX element nodes
  */
 function findRouterLinkElements(ast) {
-  const elements = [];
+  const _elements = [];
   
   const jsxElements = findNodes(ast, node => {
     if (!ts.isJsxOpeningElement(node) && !ts.isJsxSelfClosingElement(node)) return false;
@@ -545,8 +606,10 @@ function extractFromRouterLink(element, ast, projectRoot) {
         type: 'spa_navigation',
         targetPath: normalized.examplePath,
         originalPattern: normalized.originalPattern,
+        originalTarget: normalized.originalPattern,
         isDynamic: true,
         exampleExecution: true,
+        parameters: normalized.parameters || [],
         matchAttribute: 'to',
         proof: 'PROVEN_EXPECTATION',
         sourceRef: location.sourceRef,

package/src/verax/intel/vue-router-extractor.js

@@ -298,7 +298,8 @@ function extractRouteFromObject(objNode, ast, projectRoot, parentPath) {
       file: location.file,
       line: location.line,
       framework: 'vue-router',
-      public: !isInternalRoute(normalized.examplePath)
+      public: !isInternalRoute(normalized.examplePath),
+      children: null // Will be set below if children exist
     };
   } else {
     // Static route
@@ -308,7 +309,8 @@ function extractRouteFromObject(objNode, ast, projectRoot, parentPath) {
       file: location.file,
       line: location.line,
       framework: 'vue-router',
-      public: !isInternalRoute(fullPath)
+      public: !isInternalRoute(fullPath),
+      children: null // Will be set below if children exist
     };
   }
   

package/src/verax/learn/action-contract-extractor.js

@@ -11,7 +11,7 @@
 import { normalizeTemplateLiteral } from '../shared/dynamic-route-utils.js';import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
 import { readFileSync } from 'fs';
-import { resolve, relative, sep } from 'path';
+import { relative, sep } from 'path';
 
 /**
  * Extract action contracts from a source file.
@@ -394,7 +394,7 @@ function findNetworkCallsInNode(node) {
    
    // Recursively scan all properties
    for (const key in n) {
-     if (n.hasOwnProperty(key)) {
+     if (Object.prototype.hasOwnProperty.call(n, key)) {
        const value = n[key];
        if (Array.isArray(value)) {
          value.forEach(item => scan(item));
@@ -445,7 +445,7 @@ function formatSourceRef(filePath, workspaceRoot, loc, lineOffset = 0) {
  * 
  * @param {string} rootPath - Root directory to scan
  * @param {string} workspaceRoot - Workspace root
- * @returns {Array<Object>} - All contracts found
+ * @returns {Promise<Array<Object>>} - All contracts found
  */
 export async function scanForContracts(rootPath, workspaceRoot) {
   const contracts = [];

package/src/verax/learn/ast-contract-extractor.js

@@ -21,6 +21,11 @@ function extractStaticStringValue(node) {
   if (node.type === 'StringLiteral') {
     return node.value;
   }
+
+  // Template literal without interpolation
+  if (node.type === 'TemplateLiteral' && node.expressions.length === 0 && node.quasis.length === 1) {
+    return node.quasis[0].value.cooked;
+  }
   
   // JSX expression: href={'/about'} or href={`/about`}
   if (node.type === 'JSXExpressionContainer') {
@@ -46,6 +51,22 @@ function extractStaticStringValue(node) {
   return null;
 }
 
+function extractStaticPropValue(propsNode, propNames) {
+  if (!propsNode || propsNode.type !== 'ObjectExpression') return { attributeName: null, targetPath: null };
+  const names = new Set(propNames);
+  for (const prop of propsNode.properties || []) {
+    if (prop.type !== 'ObjectProperty') continue;
+    const key = prop.key;
+    const name = key.type === 'Identifier' ? key.name : (key.type === 'StringLiteral' ? key.value : null);
+    if (!name || !names.has(name)) continue;
+    const targetPath = extractStaticStringValue(prop.value);
+    if (targetPath) {
+      return { attributeName: name, targetPath };
+    }
+  }
+  return { attributeName: null, targetPath: null };
+}
+
 /**
  * Extracts template literal pattern from Babel TemplateLiteral node.
  * Returns null if template has complex expressions that cannot be normalized.
@@ -176,6 +197,37 @@ function extractContractsFromFile(filePath, fileContent) {
       // since we cannot reliably tie them to clicked elements
       CallExpression(path) {
         const callee = path.node.callee;
+
+        // React.createElement(Link, { to: '/about' }) or createElement('a', { href: '/about' })
+        const isCreateElement = (
+          (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'React' && callee.property.type === 'Identifier' && callee.property.name === 'createElement') ||
+          (callee.type === 'Identifier' && callee.name === 'createElement')
+        );
+
+        if (isCreateElement) {
+          const [componentArg, propsArg] = path.node.arguments;
+          let elementName = null;
+          if (componentArg?.type === 'Identifier') {
+            elementName = componentArg.name;
+          } else if (componentArg?.type === 'StringLiteral') {
+            elementName = componentArg.value;
+          }
+          if (elementName) {
+            const { attributeName, targetPath } = extractStaticPropValue(propsArg, ['to', 'href']);
+            if (targetPath && !targetPath.startsWith('http://') && !targetPath.startsWith('https://') && !targetPath.startsWith('mailto:') && !targetPath.startsWith('tel:')) {
+              const normalized = targetPath.startsWith('/') ? targetPath : '/' + targetPath;
+              contracts.push({
+                kind: 'NAVIGATION',
+                targetPath: normalized,
+                sourceFile: filePath,
+                element: elementName,
+                attribute: attributeName,
+                proof: ExpectationProof.PROVEN_EXPECTATION,
+                line: path.node.loc?.start.line || null
+              });
+            }
+          }
+        }
         
         // navigate("/about") - useNavigate hook
         if (callee.type === 'Identifier' && callee.name === 'navigate') {
@@ -308,7 +360,7 @@ export async function extractASTContracts(projectDir) {
  * Converts AST contracts to manifest expectations format.
  * Only includes contracts that can be matched at runtime (excludes imperativeOnly).
  */
-export function contractsToExpectations(contracts, projectType) {
+export function contractsToExpectations(contracts, _projectType) {
   const expectations = [];
   const seenPaths = new Set();
   

package/src/verax/learn/index.js

@@ -1,9 +1,31 @@
 import { resolve } from 'path';
-import { existsSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { detectProjectType } from './project-detector.js';
 import { extractRoutes } from './route-extractor.js';
 import { writeManifest } from './manifest-writer.js';
 
+/**
+ * @typedef {Object} LearnResult
+ * @property {number} version
+ * @property {string} learnedAt
+ * @property {string} projectDir
+ * @property {string} projectType
+ * @property {Array} routes
+ * @property {Array<string>} publicRoutes
+ * @property {Array<string>} internalRoutes
+ * @property {Array} [staticExpectations]
+ * @property {Array} [flows]
+ * @property {string} [expectationsStatus]
+ * @property {Array} [coverageGaps]
+ * @property {Array} notes
+ * @property {Object} [learnTruth]
+ * @property {string} [manifestPath] - Optional manifest path (added when loaded from file)
+ */
+
+/**
+ * @param {string} projectDir
+ * @returns {Promise<LearnResult>}
+ */
 export async function learn(projectDir) {
   const absoluteProjectDir = resolve(projectDir);
   
@@ -14,5 +36,17 @@ export async function learn(projectDir) {
   const projectType = await detectProjectType(absoluteProjectDir);
   const routes = await extractRoutes(absoluteProjectDir, projectType);
   
-  return await writeManifest(absoluteProjectDir, projectType, routes);
+    const manifest = await writeManifest(absoluteProjectDir, projectType, routes);
+  
+    // Write manifest to disk and return path
+    const veraxDir = resolve(absoluteProjectDir, '.verax');
+    mkdirSync(veraxDir, { recursive: true });
+  
+    const manifestPath = resolve(veraxDir, 'project.json');
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+  
+    return {
+      ...manifest,
+      manifestPath
+    };
 }

package/src/verax/learn/manifest-writer.js

@@ -1,5 +1,4 @@
-import { resolve } from 'path';
-import { writeFileSync, mkdirSync } from 'fs';
+// resolve, writeFileSync, mkdirSync imports removed - currently unused
 import { extractStaticExpectations } from './static-extractor.js';
 import { assessLearnTruth } from './truth-assessor.js';
 import { runCodeIntelligence } from '../intel/index.js';
@@ -8,6 +7,29 @@ import { extractFlows } from './flow-extractor.js';
 import { createTSProgram } from '../intel/ts-program.js';
 import { extractVueNavigationPromises } from '../intel/vue-navigation-extractor.js';
 
+/**
+ * @typedef {Object} Manifest
+ * @property {number} version
+ * @property {string} learnedAt
+ * @property {string} projectDir
+ * @property {string} projectType
+ * @property {Array} routes
+ * @property {Array<string>} publicRoutes
+ * @property {Array<string>} internalRoutes
+ * @property {Array} [staticExpectations]
+ * @property {Array} [flows]
+ * @property {string} [expectationsStatus]
+ * @property {Array} [coverageGaps]
+ * @property {Array} notes
+ * @property {Object} [learnTruth]
+ */
+
+/**
+ * @param {string} projectDir
+ * @param {string} projectType
+ * @param {Array} routes
+ * @returns {Promise<Manifest>}
+ */
 export async function writeManifest(projectDir, projectType, routes) {
   const publicRoutes = routes.filter(r => r.public).map(r => r.path);
   const internalRoutes = routes.filter(r => !r.public).map(r => r.path);
@@ -44,7 +66,7 @@ export async function writeManifest(projectDir, projectType, routes) {
     const program = createTSProgram(projectDir, { includeJs: true });
     
     if (!program.error) {
-      const vueNavPromises = extractVueNavigationPromises(program, projectDir);
+      const vueNavPromises = await extractVueNavigationPromises(program, projectDir);
       
       if (vueNavPromises && vueNavPromises.length > 0) {
         intelExpectations = vueNavPromises.filter(exp => isProvenExpectation(exp));
@@ -132,16 +154,8 @@ export async function writeManifest(projectDir, projectType, routes) {
     learn: learnTruth
   });
   
-  const manifestDir = resolve(projectDir, '.veraxverax', 'learn');
-  mkdirSync(manifestDir, { recursive: true });
-  
-  const manifestPath = resolve(manifestDir, 'site-manifest.json');
-  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
-  
-  return {
-    ...manifest,
-    manifestPath: manifestPath,
-    learnTruth: learnTruth
-  };
+  // Note: This function is still used by learn() function
+  // Direct usage is deprecated in favor of CLI learn.json writer
+  return manifest;
 }
 

package/src/verax/learn/route-extractor.js

@@ -1,4 +1,4 @@
-import { resolve } from 'path';
+// resolve import removed - currently unused
 import { extractStaticRoutes } from './static-extractor.js';
 import { createTSProgram } from '../intel/ts-program.js';
 import { extractRoutes as extractRoutesAST } from '../intel/route-extractor.js';

package/src/verax/learn/route-validator.js

@@ -99,14 +99,15 @@ export async function validateRoutes(manifest, baseUrl) {
           
           const request = response.request();
           
-          // Use redirectChain() if available (preferred), otherwise use redirectedFrom()
+          // Use redirectChain property if available (Playwright API)
           let redirectChain = [];
-          if (typeof request.redirectChain === 'function') {
-            try {
-              redirectChain = request.redirectChain();
-            } catch (e) {
-              // redirectChain may not be available, fall back to redirectedFrom
-            }
+          // @ts-expect-error - redirectChain exists in Playwright runtime but not in TypeScript types
+          if (request.redirectChain && Array.isArray(request.redirectChain)) {
+            // @ts-expect-error - redirectChain exists in Playwright runtime but not in TypeScript types
+            redirectChain = request.redirectChain;
+          } else if (request.redirectedFrom) {
+            // Fall back to redirectedFrom if redirectChain not available
+            redirectChain = [request.redirectedFrom];
           }
           
           // If redirectChain is empty or not available, build chain from redirectedFrom

package/src/verax/learn/state-extractor.js

@@ -11,7 +11,7 @@ const MAX_FILES_TO_SCAN = 200;
  * Extracts static string value from call expression arguments.
  * Returns null if value is dynamic.
  */
-function extractStaticActionName(node) {
+function _extractStaticActionName(node) {
   if (!node) return null;
   
   // String literal: dispatch('increment')

package/src/verax/learn/static-extractor-navigation.js

@@ -3,7 +3,7 @@
  * Detects router.push/replace/navigate calls in inline scripts.
  */
 
-function extractNavigationExpectations(root, fromPath, file, projectDir) {
+function extractNavigationExpectations(root, fromPath, file, _projectDir) {
   const expectations = [];
   
   // Extract from inline scripts

package/src/verax/learn/static-extractor-validation.js

@@ -3,7 +3,7 @@
  * Detects preventDefault() calls in onSubmit handlers.
  */
 
-function extractValidationExpectations(root, fromPath, file, projectDir) {
+function extractValidationExpectations(root, fromPath, file, _projectDir) {
   const expectations = [];
   
   // Extract from inline scripts
@@ -19,7 +19,7 @@ function extractValidationExpectations(root, fromPath, file, projectDir) {
       // Check if this is in an onSubmit context
       // Look for function definitions that might be onSubmit handlers
       const beforeMatch = scriptContent.substring(0, match.index);
-      const afterMatch = scriptContent.substring(match.index);
+      const _afterMatch = scriptContent.substring(match.index);
       
       // Check if there's a function definition before this preventDefault
       const functionMatch = beforeMatch.match(/function\s+(\w+)\s*\([^)]*event[^)]*\)/);

package/src/verax/learn/static-extractor.js

@@ -1,13 +1,13 @@
 import { glob } from 'glob';
-import { resolve, dirname, join, relative } from 'path';
+import { resolve, dirname, relative } from 'path';
 import { readFileSync, existsSync } from 'fs';
 import { parse } from 'node-html-parser';
 
 const MAX_HTML_FILES = 200;
 
 function htmlFileToRoute(file) {
-  let path = file.replace(/[\\\/]/g, '/');
-  path = path.replace(/\/index\.html$/, '');
+  let path = file.replace(/[\\/]/g, '/');
+  path = path.replace(/\/index.html$/, '');
   path = path.replace(/\.html$/, '');
   path = path.replace(/^index$/, '');
   
@@ -159,7 +159,7 @@ function extractFormSubmissionExpectations(root, fromPath, file, routeMap, proje
   return expectations;
 }
 
-function extractNetworkExpectations(root, fromPath, file, projectDir) {
+function extractNetworkExpectations(root, fromPath, file, _projectDir) {
   const expectations = [];
   
   // Extract from inline scripts
@@ -286,9 +286,10 @@ export async function extractStaticExpectations(projectDir, routes) {
         const targetPath = resolveLinkPath(href, file, projectDir);
         if (!targetPath) continue;
         
-        if (!routeMap.has(targetPath)) continue;
-        
-        const linkText = link.textContent?.trim() || '';
+        // Extract expectation even if target route doesn't exist yet
+        // This allows detection of broken links or prevented navigation
+        // (The route may not exist, but the link promises navigation)
+        const _linkText = link.textContent?.trim() || '';
         const selectorHint = link.id ? `#${link.id}` : `a[href="${href}"]`;
         
         expectations.push({

package/src/verax/learn/ts-contract-resolver.js

@@ -9,7 +9,7 @@
 
 import ts from 'typescript';
 import { resolve, relative, dirname, sep, join } from 'path';
-import { readFileSync, existsSync, statSync } from 'fs';
+import { existsSync, statSync } from 'fs';
 import { glob } from 'glob';
 
 const MAX_DEPTH = 3;
@@ -45,14 +45,8 @@ export async function resolveActionContracts(rootDir, workspaceRoot) {
   const checker = program.getTypeChecker();
   const contracts = [];
 
-  for (const sourceFile of program.getSourceFiles()) {
-    const sourcePath = resolve(sourceFile.fileName);
-    if (!sourcePath.toLowerCase().startsWith(normalizedRoot.toLowerCase())) continue;
-    if (sourceFile.isDeclarationFile) continue;
-
-    const importMap = buildImportMap(sourceFile, rootDir, workspaceRoot);
-
-    function visit(node) {
+  function createVisitFunction(importMap, sourceFile) {
+    return function visit(node) {
       if (ts.isJsxAttribute(node)) {
         const name = node.name.getText();
         if (name !== 'onClick' && name !== 'onSubmit') return;
@@ -64,7 +58,7 @@ export async function resolveActionContracts(rootDir, workspaceRoot) {
         // We only handle identifier handlers (cross-file capable)
         if (!ts.isIdentifier(expr)) return;
 
-        const handlerName = expr.text;
+        const _handlerName = expr.text;
         const handlerRef = deriveHandlerRef(expr, importMap, sourceFile, workspaceRoot);
         if (!handlerRef) return;
 
@@ -112,8 +106,16 @@ export async function resolveActionContracts(rootDir, workspaceRoot) {
         }
       }
       ts.forEachChild(node, visit);
-    }
+    };
+  }
 
+  for (const sourceFile of program.getSourceFiles()) {
+    const sourcePath = resolve(sourceFile.fileName);
+    if (!sourcePath.toLowerCase().startsWith(normalizedRoot.toLowerCase())) continue;
+    if (sourceFile.isDeclarationFile) continue;
+
+    const importMap = buildImportMap(sourceFile, rootDir, workspaceRoot);
+    const visit = createVisitFunction(importMap, sourceFile);
     visit(sourceFile);
   }
 
@@ -313,7 +315,7 @@ function analyzeStateCall(node) {
 
   // Zustand: store.set(...) or setState(...)
   if (ts.isPropertyAccessExpression(callee)) {
-    const obj = callee.expression;
+    const _obj = callee.expression;
     const prop = callee.name;
     // Common pattern: storeObj.set(...)
     if (prop.text === 'set') {