@veraxhq/verax 0.2.1 → 0.4.0

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

@@ -0,0 +1,126 @@
+/**
+ * EXPECTATION HANDLER
+ * 
+ * Manages manifest loading, snapshot comparison, and proven expectation execution.
+ */
+
+import { readFileSync as readFileSyncWithEncoding, existsSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Load and execute proven expectations from manifest
+ * 
+ * @param {Object} page - Playwright page
+ * @param {string} manifestPath - Path to manifest file
+ * @param {string} projectDir - Project directory
+ * @param {Object} silenceTracker - Silence tracker
+ * @returns {Promise<{success: boolean, results: Array|null}>}
+ */
+export async function loadAndExecuteProvenExpectations(page, manifestPath, projectDir, silenceTracker) {
+  try {
+    if (!existsSync(manifestPath)) {
+      silenceTracker.record('expectation_manifest_not_found');
+      return { success: false, results: null };
+    }
+
+    const manifestContent = readFileSyncWithEncoding(manifestPath, 'utf8');
+    const manifest = JSON.parse(typeof manifestContent === 'string' ? manifestContent : manifestContent.toString());
+
+    if (!manifest.expectations || !Array.isArray(manifest.expectations)) {
+      silenceTracker.record('expectation_manifest_invalid_format');
+      return { success: false, results: null };
+    }
+
+    // Return empty results for now (expectation execution handled in main observe function)
+    return { success: true, results: [] };
+  } catch (error) {
+    silenceTracker.record('expectation_manifest_load_error');
+    return { success: false, results: null };
+  }
+}
+
+/**
+ * Load and compare snapshot with previous observation
+ * 
+ * @param {string} projectDir - Project directory
+ * @param {Object} silenceTracker - Silence tracker
+ * @returns {Promise<{currentSnapshot: Object|null, previousSnapshot: Object|null}>}
+ */
+export async function loadAndCompareSnapshot(projectDir, silenceTracker) {
+  try {
+    const snapshotDir = join(projectDir, '.verax', 'snapshots');
+    
+    if (!existsSync(snapshotDir)) {
+      mkdirSync(snapshotDir, { recursive: true });
+    }
+
+    // Load previous snapshot if exists
+    const previousSnapshotPath = join(snapshotDir, 'previous.json');
+    let previousSnapshot = null;
+    if (existsSync(previousSnapshotPath)) {
+      try {
+        const content = readFileSyncWithEncoding(previousSnapshotPath, 'utf8');
+        previousSnapshot = JSON.parse(typeof content === 'string' ? content : content.toString());
+      } catch {
+        silenceTracker.record('snapshot_previous_load_error');
+      }
+    }
+
+    // Load current snapshot if exists
+    const currentSnapshotPath = join(snapshotDir, 'current.json');
+    let currentSnapshot = null;
+    if (existsSync(currentSnapshotPath)) {
+      try {
+        const content = readFileSyncWithEncoding(currentSnapshotPath, 'utf8');
+        currentSnapshot = JSON.parse(typeof content === 'string' ? content : content.toString());
+      } catch {
+        silenceTracker.record('snapshot_current_load_error');
+      }
+    }
+
+    return { currentSnapshot, previousSnapshot };
+  } catch (error) {
+    silenceTracker.record('snapshot_comparison_error');
+    return { currentSnapshot: null, previousSnapshot: null };
+  }
+}
+
+/**
+ * Build snapshot object from observation data
+ * 
+ * @param {Array} traces - Array of interaction traces
+ * @param {string} baseOrigin - Base origin URL
+ * @returns {Object}
+ */
+export function buildSnapshot(traces, baseOrigin) {
+  const snapshot = {
+    timestamp: new Date().toISOString(),
+    baseOrigin,
+    totalTraces: traces.length,
+    verifiedExpectations: traces.filter(t => t.expectationDriven).length,
+    observedExpectations: traces.filter(t => t.observedExpectation).length,
+    unprovable: traces.filter(t => t.unprovenResult).length
+  };
+
+  return snapshot;
+}
+
+/**
+ * Save snapshot for future comparison
+ * 
+ * @param {Object} snapshot - Snapshot object
+ * @param {string} projectDir - Project directory
+ */
+export function saveSnapshot(snapshot, projectDir) {
+  try {
+    const snapshotDir = join(projectDir, '.verax', 'snapshots');
+    if (!existsSync(snapshotDir)) {
+      mkdirSync(snapshotDir, { recursive: true });
+    }
+
+    const snapshotPath = join(snapshotDir, 'current.json');
+    writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2));
+  } catch (error) {
+    // Silently fail on snapshot save
+  }
+}

package/src/verax/observe/incremental-skip.js

@@ -0,0 +1,46 @@
+/**
+ * Incremental Skip Phantom Trace Builder
+ * 
+ * Extracted from observe/index.js (STAGE D2.4)
+ * 
+ * Builds the minimal phantom trace object that represents a skipped
+ * interaction in incremental mode. The phantom trace preserves interaction
+ * metadata but has no execution result (before/after URLs are identical).
+ * 
+ * Preserves 100% of original behavior:
+ * - Same 5 top-level properties
+ * - Same nested object shapes
+ * - incremental flag always true
+ * - resultType always 'INCREMENTAL_SKIP'
+ */
+
+/**
+ * Build a phantom trace for an incremental skip.
+ * 
+ * When an interaction is skipped in incremental mode (because it was
+ * unchanged from the previous run), a phantom trace is created to:
+ * 1. Preserve the interaction metadata for the observation record
+ * 2. Mark the trace as incremental (via incremental: true) for filtering
+ * 3. Enable transparent output (trace appears in JSON but marked as skipped)
+ * 
+ * @param {Object} params - Function parameters
+ * @param {Object} params.interaction - The interaction that was skipped
+ * @param {string} params.interaction.type - Interaction type (e.g., 'click')
+ * @param {string} params.interaction.selector - CSS selector
+ * @param {string} params.interaction.label - Human-readable label
+ * @param {string} params.currentUrl - Current page URL (used for before/after)
+ * @returns {Object} Phantom trace object with incremental flag set
+ */
+export function buildIncrementalPhantomTrace({ interaction, currentUrl }) {
+  return {
+    interaction: {
+      type: interaction.type,
+      selector: interaction.selector,
+      label: interaction.label
+    },
+    before: { url: currentUrl },
+    after: { url: currentUrl },
+    incremental: true,
+    resultType: 'INCREMENTAL_SKIP'
+  };
+}

package/src/verax/observe/index.js

@@ -7,13 +7,25 @@ import { runInteraction } from './interaction-runner.js';
 import { writeTraces } from './traces-writer.js';
 import { getBaseOrigin, isExternalUrl } from './domain-boundary.js';
 
+// STAGE D1: Extracted modules for observe orchestration
+import { setupNetworkFirewall } from './network-firewall.js';
+
+// STAGE D2.1: Extracted modules for snapshot operations
+import { initializeSnapshot, finalizeSnapshot } from './snapshot-ops.js';
+
+// STAGE D2.2: Extracted modules for coverage gap accumulation and warnings
+import { accumulateCoverageGaps, buildCoverageObject, generateCoverageWarnings } from './coverage-gaps.js';
+
+// STAGE D2.4: Extracted modules for incremental skip handling
+import { buildIncrementalPhantomTrace } from './incremental-skip.js';
+
 import { DEFAULT_SCAN_BUDGET } from '../shared/scan-budget.js';
 import { executeProvenExpectations } from './expectation-executor.js';
 import { isProvenExpectation } from '../shared/expectation-prover.js';
 import { PageFrontier } from './page-frontier.js';
 import { deriveObservedExpectation, shouldAttemptRepeatObservedExpectation, evaluateObservedExpectation } from './observed-expectation.js';
 import { computeRouteBudget } from '../core/budget-engine.js';
-import { loadPreviousSnapshot, saveSnapshot, buildSnapshot, compareSnapshots, shouldSkipInteractionIncremental } from '../core/incremental-store.js';
+import { shouldSkipInteractionIncremental } from '../core/incremental-store.js';
 import SilenceTracker from '../core/silence-model.js';
 import { DecisionRecorder, recordBudgetProfile, recordTimeoutConfig, recordTruncation, recordEnvironment } from '../core/determinism-model.js';
 
@@ -32,8 +44,8 @@ import { DecisionRecorder, recordBudgetProfile, recordTimeoutConfig, recordTrunc
  * All silence is explicit in output - no silent success.
  * 
  * PHASE 4: Safety mode enabled by default
- * - Blocks risky/write actions unless flags allow
- * - Blocks POST/PUT/PATCH/DELETE unless --allow-writes
+ * - Blocks risky/write actions unconditionally
+ * - Blocks POST/PUT/PATCH/DELETE (read-only mode enforced)
  * - Blocks cross-origin unless --allow-cross-origin
  * 
  * PHASE 5: Deterministic artifact paths
@@ -63,72 +75,14 @@ export async function observe(url, manifestPath = null, scanBudgetOverride = nul
   }
   
   // Phase 4: Extract safety flags
-  const { allowWrites = false, allowRiskyActions = false, allowCrossOrigin = false } = safetyFlags;
+  const { allowRiskyActions = false, allowCrossOrigin = false } = safetyFlags;
   let blockedNetworkWrites = [];
   let blockedCrossOrigin = [];
   
-  // Phase 4: Setup network interception firewall
-  await page.route('**/*', (route) => {
-    const request = route.request();
-    const method = request.method();
-    const requestUrl = request.url();
-    const resourceType = request.resourceType();
-    
-    // Check cross-origin blocking (skip for file:// URLs)
-    if (!allowCrossOrigin && !requestUrl.startsWith('file://')) {
-      try {
-        const reqOrigin = new URL(requestUrl).origin;
-        if (reqOrigin !== baseOrigin) {
-          blockedCrossOrigin.push({
-            url: requestUrl,
-            origin: reqOrigin,
-            method,
-            resourceType,
-            timestamp: Date.now()
-          });
-          
-          silenceTracker.record({
-            scope: 'safety',
-            reason: 'cross_origin_blocked',
-            description: `Cross-origin request blocked: ${method} ${requestUrl}`,
-            context: { url: requestUrl, origin: reqOrigin, method, baseOrigin },
-            impact: 'request_blocked'
-          });
-          
-          return route.abort('blockedbyclient');
-        }
-      } catch (e) {
-        // Invalid URL, allow and let browser handle
-      }
-    }
-    
-    // Check write method blocking
-    if (!allowWrites && ['POST', 'PUT', 'PATCH', 'DELETE'].includes(method)) {
-      // Check if it's a GraphQL mutation (best-effort)
-      const isGraphQLMutation = requestUrl.includes('/graphql') && method === 'POST';
-      
-      blockedNetworkWrites.push({
-        url: requestUrl,
-        method,
-        resourceType,
-        isGraphQLMutation,
-        timestamp: Date.now()
-      });
-      
-      silenceTracker.record({
-        scope: 'safety',
-        reason: 'blocked_network_write',
-        description: `Network write blocked: ${method} ${requestUrl}${isGraphQLMutation ? ' (GraphQL mutation)' : ''}`,
-        context: { url: requestUrl, method, resourceType, isGraphQLMutation },
-        impact: 'write_blocked'
-      });
-      
-      return route.abort('blockedbyclient');
-    }
-    
-    // Allow request
-    route.continue();
-  });
+  // Phase 4: Setup network interception firewall (STAGE D1: moved to module)
+  const firewallResult = await setupNetworkFirewall(page, baseOrigin, allowCrossOrigin, silenceTracker);
+  blockedNetworkWrites = firewallResult.blockedNetworkWrites;
+  blockedCrossOrigin = firewallResult.blockedCrossOrigin;
   
   try {
     await navigateToUrl(page, url, scanBudget);
@@ -156,15 +110,14 @@ export async function observe(url, manifestPath = null, scanBudgetOverride = nul
     if (manifestPath && existsSync(manifestPath)) {
       try {
         const manifestContent = readFileSync(manifestPath, 'utf-8');
+  // @ts-expect-error - readFileSync with encoding returns string
         manifest = JSON.parse(manifestContent);
         
-        // SCALE INTELLIGENCE: Load previous snapshot for incremental mode
-        oldSnapshot = loadPreviousSnapshot(projectDir);
-        if (oldSnapshot) {
-          const currentSnapshot = buildSnapshot(manifest, []);
-          snapshotDiff = compareSnapshots(oldSnapshot, currentSnapshot);
-          incrementalMode = !snapshotDiff.hasChanges; // Use incremental if nothing changed
-        }
+        // STAGE D2.1: Snapshot initialization (moved to snapshot-ops module)
+        const snapshotResult = await initializeSnapshot(projectDir, manifest);
+        oldSnapshot = snapshotResult.oldSnapshot;
+        snapshotDiff = snapshotResult.snapshotDiff;
+        incrementalMode = snapshotResult.incrementalMode;
         
         const provenCount = (manifest.staticExpectations || []).filter(exp => isProvenExpectation(exp)).length;
         if (provenCount > 0) {
@@ -406,17 +359,7 @@ export async function observe(url, manifestPath = null, scanBudgetOverride = nul
           const shouldSkip = shouldSkipInteractionIncremental(interaction, currentUrl, oldSnapshot, snapshotDiff);
           if (shouldSkip) {
             // Create a trace for skipped interaction (marked as incremental - will not produce findings)
-            const skippedTrace = {
-              interaction: {
-                type: interaction.type,
-                selector: interaction.selector,
-                label: interaction.label
-              },
-              before: { url: currentUrl },
-              after: { url: currentUrl },
-              incremental: true, // Mark as skipped in incremental mode - detect phase will skip this
-              resultType: 'INCREMENTAL_SKIP'
-            };
+            const skippedTrace = buildIncrementalPhantomTrace({ interaction, currentUrl });
             traces.push(skippedTrace);
             
             // Track incremental skip as silence
@@ -494,6 +437,7 @@ export async function observe(url, manifestPath = null, scanBudgetOverride = nul
 
         // Phase 4: Check action classification and safety mode
         const { shouldBlockAction } = await import('../core/action-classifier.js');
+        const allowWrites = allowRiskyActions;
         const blockCheck = shouldBlockAction(interaction, { allowWrites, allowRiskyActions });
         
         if (blockCheck.shouldBlock) {
@@ -745,65 +689,24 @@ export async function observe(url, manifestPath = null, scanBudgetOverride = nul
     }
 
     // Combine all coverage gaps
-    if (remainingInteractionsGaps.length > 0) {
-      expectationCoverageGaps.push(...remainingInteractionsGaps.map(gap => ({
-        expectationId: null,
-        type: gap.interaction.type,
-        reason: gap.reason,
-        fromPath: gap.url,
-        source: null,
-        evidence: {
-          interaction: gap.interaction
-        }
-      })));
-    }
-    
-    // Record frontier capping as coverage gap if it occurred
-    if (frontier.frontierCapped) {
-      expectationCoverageGaps.push({
-        expectationId: null,
-        type: 'navigation',
-        reason: 'frontier_capped',
-        fromPath: page.url(),
-        source: null,
-        evidence: {
-          message: `Frontier capped at ${scanBudget.maxUniqueUrls || 'unlimited'} unique URLs`
-        }
-      });
-    }
+    expectationCoverageGaps.push(...accumulateCoverageGaps(remainingInteractionsGaps, frontier, page.url(), scanBudget));
 
     // Build coverage object matching writeTraces expected format
-    const coverage = {
-      candidatesDiscovered: totalInteractionsDiscovered,
-      candidatesSelected: totalInteractionsExecuted,
-      cap: scanBudget.maxTotalInteractions,
-      capped: totalInteractionsExecuted >= scanBudget.maxTotalInteractions || remainingInteractionsGaps.length > 0,
-      pagesVisited: frontier.pagesVisited,
-      pagesDiscovered: frontier.pagesDiscovered,
-      skippedInteractions: skippedInteractions.length,
-      interactionsDiscovered: totalInteractionsDiscovered,
-      interactionsExecuted: totalInteractionsExecuted
-    };
+    const coverage = buildCoverageObject(
+      totalInteractionsDiscovered,
+      totalInteractionsExecuted,
+      scanBudget,
+      frontier,
+      skippedInteractions,
+      remainingInteractionsGaps
+    );
     
     // Ensure we increment pagesVisited when we navigate via getNextUrl()
     // getNextUrl() marks as visited but doesn't increment counter - we do it here
     // BUT: when alreadyOnPage is true, we've already marked it, so don't double-count
 
     // Record warnings
-    if (coverage.capped) {
-      observeWarnings.push({
-        code: 'INTERACTIONS_CAPPED',
-        message: `Interaction execution capped. Visited ${coverage.pagesVisited} pages, discovered ${coverage.pagesDiscovered}, executed ${coverage.candidatesSelected} of ${coverage.candidatesDiscovered} interactions. Coverage incomplete.`
-      });
-    }
-    
-    if (skippedInteractions.length > 0) {
-      observeWarnings.push({
-        code: 'INTERACTIONS_SKIPPED',
-        message: `Skipped ${skippedInteractions.length} dangerous interactions`,
-        details: skippedInteractions
-      });
-    }
+    observeWarnings.push(...generateCoverageWarnings(coverage, skippedInteractions));
 
     // Append expectation traces for completeness
     if (expectationResults && expectationResults.results) {
@@ -838,26 +741,19 @@ export async function observe(url, manifestPath = null, scanBudgetOverride = nul
       observation.expectationCoverageGaps = expectationCoverageGaps;
     }
     
-    // SCALE INTELLIGENCE: Save snapshot for next incremental run
-    if (manifest) {
-      // Build snapshot from current run (extract interactions from traces)
-      const observedInteractions = traces
-        .filter(t => t.interaction && !t.incremental)
-        .map(t => ({
-          type: t.interaction?.type,
-          selector: t.interaction?.selector,
-          url: t.before?.url || url
-        }));
-      
-      const currentSnapshot = buildSnapshot(manifest, observedInteractions);
-      saveSnapshot(projectDir, currentSnapshot, runId);
-      
-      // Add incremental mode metadata to observation
-      observation.incremental = {
-        enabled: incrementalMode,
-        snapshotDiff: snapshotDiff,
-        skippedInteractionsCount: skippedInteractions.filter(s => s.reason === 'incremental_unchanged').length
-      };
+    // STAGE D2.1: Snapshot finalization (moved to snapshot-ops module)
+    const incrementalMetadata = await finalizeSnapshot(
+      manifest,
+      traces,
+      skippedInteractions,
+      incrementalMode,
+      snapshotDiff,
+      projectDir,
+      runId,
+      url
+    );
+    if (incrementalMetadata) {
+      observation.incremental = incrementalMetadata;
     }
 
     await closeBrowser(browser);

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

@@ -0,0 +1,192 @@
+/**
+ * INTERACTION EXECUTION ENGINE
+ * 
+ * Handles execution of interactions on pages, evidence capture, and tracing.
+ */
+
+import { runInteraction } from './interaction-runner.js';
+import { deriveObservedExpectation, shouldAttemptRepeatObservedExpectation, evaluateObservedExpectation } from './observed-expectation.js';
+import { isExternalUrl } from './domain-boundary.js';
+
+/**
+ * Execute a single interaction and capture results
+ * 
+ * @param {Object} page - Playwright page
+ * @param {Object} interaction - Interaction to execute
+ * @param {number} timestamp - Execution timestamp
+ * @param {number} interactionIndex - Index in execution sequence
+ * @param {string} screenshotsDir - Directory for screenshots
+ * @param {string} baseOrigin - Base origin for URL checking
+ * @param {number} startTime - Scan start time
+ * @param {Object} routeBudget - Route-specific budget
+ * @param {Object} expectationResults - Results from proven expectations
+ * @param {Object} silenceTracker - Silence tracker
+ * @returns {Promise<{trace: Object, totalExecuted: number, navigatedToNewPage: boolean, newPageUrl: string|null}>}
+ */
+export async function executeInteraction(
+  page,
+  interaction,
+  timestamp,
+  interactionIndex,
+  screenshotsDir,
+  baseOrigin,
+  startTime,
+  routeBudget,
+  expectationResults,
+  silenceTracker
+) {
+  const beforeUrl = page.url();
+
+  const trace = await runInteraction(
+    page,
+    interaction,
+    timestamp,
+    interactionIndex,
+    screenshotsDir,
+    baseOrigin,
+    startTime,
+    routeBudget,
+    null,
+    silenceTracker
+  );
+
+  let totalExecuted = 1;
+
+  if (trace) {
+    // Check if this matched a proven expectation
+    const matchingExpectation = expectationResults?.results?.find(
+      r => r.trace?.interaction?.selector === trace.interaction.selector
+    );
+    
+    if (matchingExpectation) {
+      trace.expectationDriven = true;
+      trace.expectationId = matchingExpectation.expectationId;
+      trace.expectationOutcome = matchingExpectation.outcome;
+    } else {
+      // Derive observed expectation from trace
+      const observedExpectation = deriveObservedExpectation(interaction, trace, baseOrigin);
+      if (observedExpectation) {
+        trace.observedExpectation = observedExpectation;
+        trace.resultType = 'OBSERVED_EXPECTATION';
+
+        // Attempt repeat if eligible and budget allows
+        const repeatEligible = shouldAttemptRepeatObservedExpectation(observedExpectation, trace);
+        const budgetAllowsRepeat = repeatEligible &&
+          (Date.now() - startTime) < routeBudget.maxScanDurationMs;
+
+        if (budgetAllowsRepeat) {
+          const repeatIndex = interactionIndex + 1;
+          const repeatResult = await repeatObservedInteraction(
+            page,
+            interaction,
+            observedExpectation,
+            timestamp,
+            repeatIndex,
+            screenshotsDir,
+            baseOrigin,
+            startTime,
+            routeBudget
+          );
+
+          if (repeatResult) {
+            const repeatEvaluation = repeatResult.repeatEvaluation;
+            trace.observedExpectation.repeatAttempted = true;
+            trace.observedExpectation.repeated = repeatEvaluation.outcome === 'VERIFIED';
+            trace.observedExpectation.repeatOutcome = repeatEvaluation.outcome;
+            trace.observedExpectation.repeatReason = repeatEvaluation.reason;
+
+            if (repeatEvaluation.outcome === 'OBSERVED_BREAK') {
+              trace.observedExpectation.outcome = 'OBSERVED_BREAK';
+              trace.observedExpectation.reason = 'inconsistent_on_repeat';
+              trace.observedExpectation.confidenceLevel = 'LOW';
+            } else if (trace.observedExpectation.repeated && trace.observedExpectation.outcome === 'VERIFIED') {
+              trace.observedExpectation.confidenceLevel = 'MEDIUM';
+            }
+
+            totalExecuted = 2;
+          }
+        }
+      } else {
+        trace.unprovenResult = true;
+        trace.resultType = 'UNPROVEN_RESULT';
+      }
+    }
+  }
+
+  // Check for same-origin navigation
+  let navigatedToNewPage = false;
+  let newPageUrl = null;
+
+  if (trace) {
+    const afterUrl = trace.after?.url || page.url();
+    const navigatedSameOrigin = afterUrl && afterUrl !== beforeUrl && !isExternalUrl(afterUrl, baseOrigin);
+    if (navigatedSameOrigin && interaction.type === 'link') {
+      navigatedToNewPage = true;
+      newPageUrl = afterUrl;
+    }
+  }
+
+  return {
+    trace,
+    totalExecuted,
+    navigatedToNewPage,
+    newPageUrl
+  };
+}
+
+/**
+ * Repeat an observed interaction to verify consistency
+ */
+async function repeatObservedInteraction(
+  page,
+  interaction,
+  observedExpectation,
+  timestamp,
+  interactionIndex,
+  screenshotsDir,
+  baseOrigin,
+  startTime,
+  scanBudget
+) {
+  const selector = observedExpectation.evidence?.selector || interaction.selector;
+  if (!selector) return null;
+
+  const locator = page.locator(selector).first();
+  const count = await locator.count();
+  if (count === 0) {
+    return null;
+  }
+
+  const repeatInteraction = {
+    ...interaction,
+    element: locator
+  };
+
+  const repeatTrace = await runInteraction(
+    page,
+    repeatInteraction,
+    timestamp,
+    interactionIndex,
+    screenshotsDir,
+    baseOrigin,
+    startTime,
+    scanBudget,
+    null,
+    null // No silence tracker for repeat executions
+  );
+
+  if (!repeatTrace) {
+    return null;
+  }
+
+  repeatTrace.repeatExecution = true;
+  repeatTrace.repeatOfObservedExpectationId = observedExpectation.id;
+  repeatTrace.resultType = 'OBSERVED_EXPECTATION_REPEAT';
+
+  const repeatEvaluation = evaluateObservedExpectation(observedExpectation, repeatTrace);
+
+  return {
+    repeatTrace,
+    repeatEvaluation
+  };
+}