codeflash 0.1.0 → 0.3.0

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "codeflash",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Codeflash - AI-powered code optimization for JavaScript and TypeScript",
   "main": "runtime/index.js",
+  "types": "runtime/index.d.ts",
   "bin": {
     "codeflash": "./bin/codeflash.js",
     "codeflash-setup": "./bin/codeflash-setup.js"
@@ -12,6 +13,7 @@
   },
   "exports": {
     ".": {
+      "types": "./runtime/index.d.ts",
       "require": "./runtime/index.js",
       "import": "./runtime/index.js"
     },
@@ -26,6 +28,10 @@
     "./comparator": {
       "require": "./runtime/comparator.js",
       "import": "./runtime/comparator.js"
+    },
+    "./loop-runner": {
+      "require": "./runtime/loop-runner.js",
+      "import": "./runtime/loop-runner.js"
     }
   },
   "scripts": {
@@ -63,14 +69,21 @@
     "node": ">=18.0.0"
   },
   "peerDependencies": {
-    "jest": ">=27.0.0"
+    "jest": ">=27.0.0",
+    "jest-runner": ">=27.0.0"
   },
   "peerDependenciesMeta": {
     "jest": {
       "optional": true
+    },
+    "jest-runner": {
+      "optional": true
     }
   },
-  "optionalDependencies": {
-    "better-sqlite3": "^9.0.0"
+  "dependencies": {
+    "better-sqlite3": "^12.0.0",
+    "@msgpack/msgpack": "^3.0.0",
+    "jest-runner": "^29.7.0",
+    "jest-junit": "^16.0.0"
   }
 }

package/runtime/capture.js

@@ -28,30 +28,111 @@
 
 const fs = require('fs');
 const path = require('path');
+const Database = require('better-sqlite3');
 
 // Load the codeflash serializer for robust value serialization
 const serializer = require('./serializer');
 
 // Try to load better-sqlite3, fall back to JSON if not available
-let Database;
 let useSqlite = false;
-try {
-    Database = require('better-sqlite3');
-    useSqlite = true;
-} catch (e) {
-    // better-sqlite3 not available, will use JSON fallback
-    console.warn('[codeflash] better-sqlite3 not found, using JSON fallback');
-}
 
 // Configuration from environment
-const OUTPUT_FILE = process.env.CODEFLASH_OUTPUT_FILE || '/tmp/codeflash_results.sqlite';
+const OUTPUT_FILE = process.env.CODEFLASH_OUTPUT_FILE;
 const LOOP_INDEX = parseInt(process.env.CODEFLASH_LOOP_INDEX || '1', 10);
-const TEST_ITERATION = process.env.CODEFLASH_TEST_ITERATION || '0';
-const TEST_MODULE = process.env.CODEFLASH_TEST_MODULE || '';
+const TEST_ITERATION = process.env.CODEFLASH_TEST_ITERATION;
+const TEST_MODULE = process.env.CODEFLASH_TEST_MODULE;
+
+// Performance loop configuration - controls batched looping in capturePerf
+// Batched looping ensures fair distribution across all test invocations:
+//   Batch 1: Test1(5 loops) → Test2(5 loops) → Test3(5 loops)
+//   Batch 2: Test1(5 loops) → Test2(5 loops) → Test3(5 loops)
+//   ...until time budget exhausted
+const PERF_LOOP_COUNT = parseInt(process.env.CODEFLASH_PERF_LOOP_COUNT || '1', 10);
+const PERF_MIN_LOOPS = parseInt(process.env.CODEFLASH_PERF_MIN_LOOPS || '5', 10);
+const PERF_TARGET_DURATION_MS = parseInt(process.env.CODEFLASH_PERF_TARGET_DURATION_MS || '10000', 10);
+const PERF_BATCH_SIZE = parseInt(process.env.CODEFLASH_PERF_BATCH_SIZE || '10', 10);
+const PERF_STABILITY_CHECK = (process.env.CODEFLASH_PERF_STABILITY_CHECK || 'false').toLowerCase() === 'true';
+// Current batch number - set by loop-runner before each batch
+// This allows continuous loop indices even when Jest resets module state
+const PERF_CURRENT_BATCH = parseInt(process.env.CODEFLASH_PERF_CURRENT_BATCH || '0', 10);
+
+// Stability constants (matching Python's config_consts.py)
+const STABILITY_WINDOW_SIZE = 0.35;
+const STABILITY_CENTER_TOLERANCE = 0.0025;
+const STABILITY_SPREAD_TOLERANCE = 0.0025;
+
+// Shared state for coordinating batched looping across all capturePerf calls
+// Uses process object to persist across Jest's module reloads per test file
+const PERF_STATE_KEY = '__codeflash_perf_state__';
+if (!process[PERF_STATE_KEY]) {
+    process[PERF_STATE_KEY] = {
+        startTime: null,           // When benchmarking started
+        totalLoopsCompleted: 0,    // Total loops across all invocations
+        shouldStop: false,         // Flag to stop all further looping
+        currentBatch: 0,           // Current batch number (incremented by runner)
+        invocationLoopCounts: {},  // Track loops per invocation: {invocationKey: loopCount}
+    };
+}
+const sharedPerfState = process[PERF_STATE_KEY];
+
+/**
+ * Check if the shared time budget has been exceeded.
+ * @returns {boolean} True if we should stop looping
+ */
+function checkSharedTimeLimit() {
+    if (sharedPerfState.shouldStop) return true;
+    if (sharedPerfState.startTime === null) {
+        sharedPerfState.startTime = Date.now();
+        return false;
+    }
+    const elapsed = Date.now() - sharedPerfState.startTime;
+    if (elapsed >= PERF_TARGET_DURATION_MS && sharedPerfState.totalLoopsCompleted >= PERF_MIN_LOOPS) {
+        sharedPerfState.shouldStop = true;
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Get the current loop index for a specific invocation.
+ * Each invocation tracks its own loop count independently within a batch.
+ * The actual loop index is computed as: (batch - 1) * BATCH_SIZE + localIndex
+ * This ensures continuous loop indices even when Jest resets module state.
+ * @param {string} invocationKey - Unique key for this test invocation
+ * @returns {number} The next global loop index for this invocation
+ */
+function getInvocationLoopIndex(invocationKey) {
+    // Track local loop count within this batch (starts at 0)
+    if (!sharedPerfState.invocationLoopCounts[invocationKey]) {
+        sharedPerfState.invocationLoopCounts[invocationKey] = 0;
+    }
+    const localIndex = ++sharedPerfState.invocationLoopCounts[invocationKey];
+
+    // Calculate global loop index using batch number from environment
+    // PERF_CURRENT_BATCH is 1-based (set by loop-runner before each batch)
+    const currentBatch = parseInt(process.env.CODEFLASH_PERF_CURRENT_BATCH || '1', 10);
+    const globalIndex = (currentBatch - 1) * PERF_BATCH_SIZE + localIndex;
+
+    return globalIndex;
+}
+
+/**
+ * Increment the batch counter. Called by loop-runner between test file runs.
+ */
+function incrementBatch() {
+    sharedPerfState.currentBatch++;
+}
+
+/**
+ * Get current batch number.
+ */
+function getCurrentBatch() {
+    return sharedPerfState.currentBatch;
+}
 
 // Random seed for reproducible test runs
 // Both original and optimized runs use the same seed to get identical "random" values
-const RANDOM_SEED = parseInt(process.env.CODEFLASH_RANDOM_SEED || '0', 10);
+const RANDOM_SEED = parseInt(process.env.CODEFLASH_RANDOM_SEED, 10);
 
 /**
  * Seeded random number generator using mulberry32 algorithm.
@@ -167,6 +248,30 @@ const results = [];
 // SQLite database (lazy initialized)
 let db = null;
 
+/**
+ * Check if performance has stabilized (for internal looping).
+ * Matches Python's pytest_plugin.should_stop() logic.
+ */
+function shouldStopStability(runtimes, window, minWindowSize) {
+    if (runtimes.length < window || runtimes.length < minWindowSize) {
+        return false;
+    }
+    const recent = runtimes.slice(-window);
+    const recentSorted = [...recent].sort((a, b) => a - b);
+    const mid = Math.floor(window / 2);
+    const median = window % 2 ? recentSorted[mid] : (recentSorted[mid - 1] + recentSorted[mid]) / 2;
+
+    for (const r of recent) {
+        if (Math.abs(r - median) / median > STABILITY_CENTER_TOLERANCE) {
+            return false;
+        }
+    }
+    const rMin = recentSorted[0];
+    const rMax = recentSorted[recentSorted.length - 1];
+    if (rMin === 0) return false;
+    return (rMax - rMin) / rMin <= STABILITY_SPREAD_TOLERANCE;
+}
+
 /**
  * Get high-resolution time in nanoseconds.
  * Prefers process.hrtime.bigint() for nanosecond precision,
@@ -484,7 +589,9 @@ function capture(funcName, lineId, fn, ...args) {
  * It prints start/end tags to stdout (no SQLite writes, no serialization overhead).
  * Used when we've already verified behavior and just need accurate timing.
  *
- * The timing measurement is done exactly around the function call for accuracy.
+ * When CODEFLASH_PERF_LOOP_COUNT > 1, this function loops internally to avoid
+ * Jest environment overhead per iteration. This dramatically improves utilization
+ * (time spent in actual function execution vs overhead).
  *
  * Output format matches Python's codeflash_performance wrapper:
  * Start: !$######test_module:test_class.test_name:func_name:loop_index:invocation_id######$!
@@ -498,16 +605,16 @@ function capture(funcName, lineId, fn, ...args) {
  * @throws {Error} - Re-throws any error from the function
  */
 function capturePerf(funcName, lineId, fn, ...args) {
-    // Get test context
-    // Use TEST_MODULE env var if set, otherwise derive from test file path
+    // Check if we should skip looping entirely (shared time budget exceeded)
+    const shouldLoop = PERF_LOOP_COUNT > 1 && !checkSharedTimeLimit();
+
+    // Get test context (computed once, reused across batch)
     let testModulePath;
     if (TEST_MODULE) {
         testModulePath = TEST_MODULE;
     } else if (currentTestPath) {
-        // Get relative path from cwd and convert to module-style path
         const path = require('path');
         const relativePath = path.relative(process.cwd(), currentTestPath);
-        // Convert to Python module-style path (e.g., "tests/test_foo.test.js" -> "tests.test_foo.test")
         testModulePath = relativePath
             .replace(/\\/g, '/')
             .replace(/\.js$/, '')
@@ -516,70 +623,109 @@ function capturePerf(funcName, lineId, fn, ...args) {
     } else {
         testModulePath = currentTestName || 'unknown';
     }
-    const testClassName = null;  // Jest doesn't use classes like Python
+    const testClassName = null;
     const testFunctionName = currentTestName || 'unknown';
 
-    // Sanitized versions for stdout tags (avoid regex conflicts)
     const safeModulePath = sanitizeTestId(testModulePath);
     const safeTestFunctionName = sanitizeTestId(testFunctionName);
 
-    // Create testId for invocation tracking (matches Python format)
-    const testId = `${safeModulePath}:${testClassName}:${safeTestFunctionName}:${lineId}:${LOOP_INDEX}`;
+    // Create unique key for this invocation (identifies this specific capturePerf call site)
+    const invocationKey = `${safeModulePath}:${testClassName}:${safeTestFunctionName}:${funcName}:${lineId}`;
 
-    // Get invocation index (increments if same testId seen again)
-    const invocationIndex = getInvocationIndex(testId);
-    const invocationId = `${lineId}_${invocationIndex}`;
+    // Check if we've already completed all loops for this invocation
+    // If so, just execute the function once without timing (for test assertions)
+    const peekLoopIndex = (sharedPerfState.invocationLoopCounts[invocationKey] || 0);
+    const currentBatch = parseInt(process.env.CODEFLASH_PERF_CURRENT_BATCH || '1', 10);
+    const nextGlobalIndex = (currentBatch - 1) * PERF_BATCH_SIZE + peekLoopIndex + 1;
 
-    // Format stdout tag (matches Python format, uses sanitized names)
-    const testStdoutTag = `${safeModulePath}:${testClassName ? testClassName + '.' : ''}${safeTestFunctionName}:${funcName}:${LOOP_INDEX}:${invocationId}`;
+    if (shouldLoop && nextGlobalIndex > PERF_LOOP_COUNT) {
+        // All loops completed, just execute once for test assertion
+        return fn(...args);
+    }
 
-    // Print start tag
-    console.log(`!$######${testStdoutTag}######$!`);
+    let lastReturnValue;
+    let lastError = null;
 
-    // Timing with nanosecond precision - exactly around the function call
-    let returnValue;
-    let error = null;
-    let durationNs;
+    // Batched looping: run BATCH_SIZE loops per capturePerf call
+    // This ensures fair distribution across all test invocations
+    const batchSize = shouldLoop ? PERF_BATCH_SIZE : 1;
 
-    try {
-        const startTime = getTimeNs();
-        returnValue = fn(...args);
-        const endTime = getTimeNs();
-        durationNs = getDurationNs(startTime, endTime);
+    for (let batchIndex = 0; batchIndex < batchSize; batchIndex++) {
+        // Check shared time limit BEFORE each iteration
+        if (shouldLoop && checkSharedTimeLimit()) {
+            break;
+        }
 
-        // Handle promises (async functions)
-        if (returnValue instanceof Promise) {
-            return returnValue.then(
-                (resolved) => {
-                    // For async, we measure until resolution
-                    const asyncEndTime = getTimeNs();
-                    const asyncDurationNs = getDurationNs(startTime, asyncEndTime);
-                    // Print end tag with timing
-                    console.log(`!######${testStdoutTag}:${asyncDurationNs}######!`);
-                    return resolved;
-                },
-                (err) => {
-                    const asyncEndTime = getTimeNs();
-                    const asyncDurationNs = getDurationNs(startTime, asyncEndTime);
-                    // Print end tag with timing even on error
-                    console.log(`!######${testStdoutTag}:${asyncDurationNs}######!`);
-                    throw err;
-                }
-            );
+        // Get the global loop index for this invocation (increments across batches)
+        const loopIndex = getInvocationLoopIndex(invocationKey);
+
+        // Check if we've exceeded max loops for this invocation
+        if (loopIndex > PERF_LOOP_COUNT) {
+            break;
+        }
+
+        // Get invocation index for the timing marker
+        const testId = `${safeModulePath}:${testClassName}:${safeTestFunctionName}:${lineId}:${loopIndex}`;
+        const invocationIndex = getInvocationIndex(testId);
+        const invocationId = `${lineId}_${invocationIndex}`;
+
+        // Format stdout tag with current loop index
+        const testStdoutTag = `${safeModulePath}:${testClassName ? testClassName + '.' : ''}${safeTestFunctionName}:${funcName}:${loopIndex}:${invocationId}`;
+
+        // Timing with nanosecond precision
+        let durationNs;
+        try {
+            const startTime = getTimeNs();
+            lastReturnValue = fn(...args);
+            const endTime = getTimeNs();
+            durationNs = getDurationNs(startTime, endTime);
+
+            // Handle promises - for async functions, run once and return
+            if (lastReturnValue instanceof Promise) {
+                return lastReturnValue.then(
+                    (resolved) => {
+                        const asyncEndTime = getTimeNs();
+                        const asyncDurationNs = getDurationNs(startTime, asyncEndTime);
+                        console.log(`!######${testStdoutTag}:${asyncDurationNs}######!`);
+                        sharedPerfState.totalLoopsCompleted++;
+                        return resolved;
+                    },
+                    (err) => {
+                        const asyncEndTime = getTimeNs();
+                        const asyncDurationNs = getDurationNs(startTime, asyncEndTime);
+                        console.log(`!######${testStdoutTag}:${asyncDurationNs}######!`);
+                        sharedPerfState.totalLoopsCompleted++;
+                        throw err;
+                    }
+                );
+            }
+
+            lastError = null;
+        } catch (e) {
+            durationNs = 0;
+            lastError = e;
+        }
+
+        // Print end tag with timing
+        console.log(`!######${testStdoutTag}:${durationNs}######!`);
+
+        // Update shared loop counter
+        sharedPerfState.totalLoopsCompleted++;
+
+        // If we had an error, stop looping
+        if (lastError) {
+            break;
         }
-    } catch (e) {
-        const endTime = getTimeNs();
-        // For sync errors, we still need to calculate duration
-        // Use a fallback if we didn't capture startTime yet
-        durationNs = 0;
-        error = e;
     }
 
-    // Print end tag with timing (no rounding)
-    console.log(`!######${testStdoutTag}:${durationNs}######!`);
+    if (lastError) throw lastError;
 
-    if (error) throw error;
-    return returnValue;
+    // If we never executed (e.g., hit loop limit on first iteration), run once for assertion
+    if (lastReturnValue === undefined && !lastError) {
+        return fn(...args);
+    }
+
+    return lastReturnValue;
 }
 
 /**
@@ -629,6 +775,16 @@ function writeResults() {
     }
 }
 
+/**
+ * Reset shared performance state.
+ * Should be called at the start of each test file to reset timing.
+ */
+function resetPerfState() {
+    sharedPerfState.startTime = null;
+    sharedPerfState.totalLoopsCompleted = 0;
+    sharedPerfState.shouldStop = false;
+}
+
 /**
  * Clear all recorded results.
  * Useful for resetting between test files.
@@ -636,6 +792,7 @@ function writeResults() {
 function clearResults() {
     results.length = 0;
     resetInvocationCounters();
+    resetPerfState();
 }
 
 /**
@@ -698,10 +855,17 @@ module.exports = {
     resetInvocationCounters,
     getInvocationIndex,
     sanitizeTestId,    // Sanitize test names for stdout tags
+    // Batch looping control (used by loop-runner)
+    incrementBatch,
+    getCurrentBatch,
+    checkSharedTimeLimit,
     // Serializer info
     getSerializerType: serializer.getSerializerType,
     // Constants
     LOOP_INDEX,
     OUTPUT_FILE,
-    TEST_ITERATION
+    TEST_ITERATION,
+    // Batch configuration
+    PERF_BATCH_SIZE,
+    PERF_LOOP_COUNT,
 };

package/runtime/compare-results.js

@@ -32,7 +32,8 @@ const path = require('path');
 const { deserialize } = require('./serializer');
 const { comparator } = require('./comparator');
 
-// Lazy-load better-sqlite3 to avoid exit on require()
+// Lazy-load better-sqlite3 to avoid process.exit during module require
+// This prevents crashes when this module is imported by test files that don't use it
 let Database = null;
 let databaseLoadError = null;
 
@@ -60,6 +61,7 @@ function readTestResults(dbPath) {
         throw new Error(`Database not found: ${dbPath}`);
     }
 
+    // Get Database lazily - throws if not available
     const { Database: DB, error } = getDatabase();
     if (error) {
         throw new Error(error);

package/runtime/index.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Codeflash TypeScript Declarations
+ */
+
+/**
+ * Capture a function call for behavior verification.
+ * Records inputs, outputs, timing to SQLite database.
+ *
+ * @param funcName - Name of the function being tested
+ * @param lineId - Line number identifier in test file
+ * @param fn - The function to call
+ * @param args - Arguments to pass to the function
+ * @returns The function's return value
+ */
+export function capture<T extends (...args: any[]) => any>(
+    funcName: string,
+    lineId: string,
+    fn: T,
+    ...args: Parameters<T>
+): ReturnType<T>;
+
+/**
+ * Capture a function call for performance benchmarking.
+ * Only measures timing, prints to stdout.
+ *
+ * @param funcName - Name of the function being tested
+ * @param lineId - Line number identifier in test file
+ * @param fn - The function to call
+ * @param args - Arguments to pass to the function
+ * @returns The function's return value
+ */
+export function capturePerf<T extends (...args: any[]) => any>(
+    funcName: string,
+    lineId: string,
+    fn: T,
+    ...args: Parameters<T>
+): ReturnType<T>;
+
+/**
+ * Capture multiple invocations for benchmarking.
+ *
+ * @param funcName - Name of the function being tested
+ * @param lineId - Line number identifier
+ * @param fn - The function to call
+ * @param argsList - List of argument arrays to test
+ * @returns Array of return values
+ */
+export function captureMultiple<T extends (...args: any[]) => any>(
+    funcName: string,
+    lineId: string,
+    fn: T,
+    argsList: Parameters<T>[]
+): ReturnType<T>[];
+
+/**
+ * Write remaining results to file.
+ */
+export function writeResults(): void;
+
+/**
+ * Clear all recorded results.
+ */
+export function clearResults(): void;
+
+/**
+ * Get the current results buffer.
+ */
+export function getResults(): any[];
+
+/**
+ * Set the current test name.
+ */
+export function setTestName(name: string): void;
+
+/**
+ * Serialize a value for storage.
+ */
+export function safeSerialize(value: any): Buffer;
+
+/**
+ * Deserialize a buffer back to a value.
+ */
+export function safeDeserialize(buffer: Buffer | Uint8Array): any;
+
+/**
+ * Initialize the SQLite database.
+ */
+export function initDatabase(): void;
+
+/**
+ * Reset invocation counters.
+ */
+export function resetInvocationCounters(): void;
+
+/**
+ * Get invocation index for a testId.
+ */
+export function getInvocationIndex(testId: string): number;
+
+/**
+ * Sanitize a string for use in test IDs.
+ */
+export function sanitizeTestId(str: string): string;
+
+/**
+ * Get the serializer type being used.
+ */
+export function getSerializerType(): 'v8' | 'msgpack';
+
+/**
+ * Current loop index from environment.
+ */
+export const LOOP_INDEX: number;
+
+/**
+ * Output file path from environment.
+ */
+export const OUTPUT_FILE: string;
+
+/**
+ * Test iteration from environment.
+ */
+export const TEST_ITERATION: string;
+
+// Default export for CommonJS compatibility
+declare const codeflash: {
+    capture: typeof capture;
+    capturePerf: typeof capturePerf;
+    captureMultiple: typeof captureMultiple;
+    writeResults: typeof writeResults;
+    clearResults: typeof clearResults;
+    getResults: typeof getResults;
+    setTestName: typeof setTestName;
+    safeSerialize: typeof safeSerialize;
+    safeDeserialize: typeof safeDeserialize;
+    initDatabase: typeof initDatabase;
+    resetInvocationCounters: typeof resetInvocationCounters;
+    getInvocationIndex: typeof getInvocationIndex;
+    sanitizeTestId: typeof sanitizeTestId;
+    getSerializerType: typeof getSerializerType;
+    LOOP_INDEX: typeof LOOP_INDEX;
+    OUTPUT_FILE: typeof OUTPUT_FILE;
+    TEST_ITERATION: typeof TEST_ITERATION;
+};
+
+export default codeflash;

package/runtime/index.js

@@ -73,6 +73,13 @@ module.exports = {
     OUTPUT_FILE: capture.OUTPUT_FILE,
     TEST_ITERATION: capture.TEST_ITERATION,
 
+    // === Batch Looping Control (used by loop-runner) ===
+    incrementBatch: capture.incrementBatch,
+    getCurrentBatch: capture.getCurrentBatch,
+    checkSharedTimeLimit: capture.checkSharedTimeLimit,
+    PERF_BATCH_SIZE: capture.PERF_BATCH_SIZE,
+    PERF_LOOP_COUNT: capture.PERF_LOOP_COUNT,
+
     // === Feature Detection ===
     hasV8: serializer.hasV8,
     hasMsgpack: serializer.hasMsgpack,

package/runtime/loop-runner.js

@@ -0,0 +1,226 @@
+/**
+ * Codeflash Loop Runner - Custom Jest Test Runner for Performance Benchmarking
+ *
+ * Implements BATCHED LOOPING for fair distribution across all test invocations:
+ *
+ *   Batch 1: Test1(5 loops) → Test2(5 loops) → Test3(5 loops) → ...
+ *   Batch 2: Test1(5 loops) → Test2(5 loops) → Test3(5 loops) → ...
+ *   ...until time budget exhausted
+ *
+ * This ensures:
+ *   - Fair distribution: All test invocations get equal loop counts
+ *   - Batched overhead: Console.log overhead amortized over batches
+ *   - Good utilization: Time budget shared across all tests
+ *
+ * Configuration via environment variables:
+ *   CODEFLASH_PERF_LOOP_COUNT - Max loops per invocation (default: 10000)
+ *   CODEFLASH_PERF_BATCH_SIZE - Loops per batch (default: 5)
+ *   CODEFLASH_PERF_MIN_LOOPS - Min loops before stopping (default: 5)
+ *   CODEFLASH_PERF_TARGET_DURATION_MS - Target total duration (default: 10000)
+ *
+ * Usage:
+ *   npx jest --runner=codeflash/loop-runner
+ */
+
+'use strict';
+
+const { createRequire } = require('module');
+const path = require('path');
+
+const jestRunnerPath = require.resolve('jest-runner');
+const internalRequire = createRequire(jestRunnerPath);
+const runTest = internalRequire('./runTest').default;
+
+// Configuration
+const MAX_BATCHES = parseInt(process.env.CODEFLASH_PERF_LOOP_COUNT || '10000', 10);
+const TARGET_DURATION_MS = parseInt(process.env.CODEFLASH_PERF_TARGET_DURATION_MS || '10000', 10);
+const MIN_BATCHES = parseInt(process.env.CODEFLASH_PERF_MIN_LOOPS || '5', 10);
+
+/**
+ * Simple event emitter for Jest compatibility.
+ */
+class SimpleEventEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+
+    on(eventName, listener) {
+        if (!this.listeners.has(eventName)) {
+            this.listeners.set(eventName, new Set());
+        }
+        this.listeners.get(eventName).add(listener);
+        return () => {
+            const set = this.listeners.get(eventName);
+            if (set) set.delete(listener);
+        };
+    }
+
+    async emit(eventName, data) {
+        const set = this.listeners.get(eventName);
+        if (set) {
+            for (const listener of set) {
+                await listener(data);
+            }
+        }
+    }
+}
+
+/**
+ * Deep copy utility.
+ */
+function deepCopy(obj, seen = new WeakMap()) {
+    if (obj === null || typeof obj !== 'object') return obj;
+    if (seen.has(obj)) return seen.get(obj);
+    if (Array.isArray(obj)) {
+        const copy = [];
+        seen.set(obj, copy);
+        for (let i = 0; i < obj.length; i++) copy[i] = deepCopy(obj[i], seen);
+        return copy;
+    }
+    if (obj instanceof Date) return new Date(obj.getTime());
+    if (obj instanceof RegExp) return new RegExp(obj.source, obj.flags);
+    const copy = {};
+    seen.set(obj, copy);
+    for (const key of Object.keys(obj)) copy[key] = deepCopy(obj[key], seen);
+    return copy;
+}
+
+/**
+ * Codeflash Loop Runner with Batched Looping
+ */
+class CodeflashLoopRunner {
+    constructor(globalConfig, context) {
+        this._globalConfig = globalConfig;
+        this._context = context || {};
+        this._eventEmitter = new SimpleEventEmitter();
+    }
+
+    get supportsEventEmitters() {
+        return true;
+    }
+
+    get isSerial() {
+        return true;
+    }
+
+    on(eventName, listener) {
+        return this._eventEmitter.on(eventName, listener);
+    }
+
+    /**
+     * Run tests with batched looping for fair distribution.
+     */
+    async runTests(tests, watcher, options) {
+        const startTime = Date.now();
+        let batchCount = 0;
+        let hasFailure = false;
+        let allConsoleOutput = '';
+
+        // Import shared state functions from capture module
+        // We need to do this dynamically since the module may be reloaded
+        let checkSharedTimeLimit;
+        let incrementBatch;
+        try {
+            const capture = require('codeflash');
+            checkSharedTimeLimit = capture.checkSharedTimeLimit;
+            incrementBatch = capture.incrementBatch;
+        } catch (e) {
+            // Fallback if codeflash module not available
+            checkSharedTimeLimit = () => {
+                const elapsed = Date.now() - startTime;
+                return elapsed >= TARGET_DURATION_MS && batchCount >= MIN_BATCHES;
+            };
+            incrementBatch = () => {};
+        }
+
+        // Batched looping: run all test files multiple times
+        while (batchCount < MAX_BATCHES) {
+            batchCount++;
+
+            // Check time limit BEFORE each batch
+            if (batchCount > MIN_BATCHES && checkSharedTimeLimit()) {
+                break;
+            }
+
+            // Check if interrupted
+            if (watcher.isInterrupted()) {
+                break;
+            }
+
+            // Increment batch counter in shared state and set env var
+            // The env var persists across Jest module resets, ensuring continuous loop indices
+            incrementBatch();
+            process.env.CODEFLASH_PERF_CURRENT_BATCH = String(batchCount);
+
+            // Run all test files in this batch
+            const batchResult = await this._runAllTestsOnce(tests, watcher);
+            allConsoleOutput += batchResult.consoleOutput;
+
+            if (batchResult.hasFailure) {
+                hasFailure = true;
+                break;
+            }
+
+            // Check time limit AFTER each batch
+            if (checkSharedTimeLimit()) {
+                break;
+            }
+        }
+
+        const totalTimeMs = Date.now() - startTime;
+
+        // Output all collected console logs - this is critical for timing marker extraction
+        // The console output contains the !######...######! timing markers from capturePerf
+        if (allConsoleOutput) {
+            process.stdout.write(allConsoleOutput);
+        }
+
+        console.log(`[codeflash] Batched runner completed: ${batchCount} batches, ${tests.length} test files, ${totalTimeMs}ms total`);
+    }
+
+    /**
+     * Run all test files once (one batch).
+     */
+    async _runAllTestsOnce(tests, watcher) {
+        let hasFailure = false;
+        let allConsoleOutput = '';
+
+        for (const test of tests) {
+            if (watcher.isInterrupted()) break;
+
+            const sendMessageToJest = (eventName, args) => {
+                this._eventEmitter.emit(eventName, deepCopy(args));
+            };
+
+            await this._eventEmitter.emit('test-file-start', [test]);
+
+            try {
+                const result = await runTest(
+                    test.path,
+                    this._globalConfig,
+                    test.context.config,
+                    test.context.resolver,
+                    this._context,
+                    sendMessageToJest
+                );
+
+                if (result.console && Array.isArray(result.console)) {
+                    allConsoleOutput += result.console.map(e => e.message || '').join('\n') + '\n';
+                }
+
+                if (result.numFailingTests > 0) {
+                    hasFailure = true;
+                }
+
+                await this._eventEmitter.emit('test-file-success', [test, result]);
+            } catch (error) {
+                hasFailure = true;
+                await this._eventEmitter.emit('test-file-failure', [test, error]);
+            }
+        }
+
+        return { consoleOutput: allConsoleOutput, hasFailure };
+    }
+}
+
+module.exports = CodeflashLoopRunner;