@flemist/test-variants 2.0.0-alpha → 2.0.1

package/dist/lib/index.cjs

@@ -2,8 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var testVariants_saveErrorVariants = require('./test-variants/saveErrorVariants.cjs');
 var testVariants_createTestVariants = require('./test-variants/createTestVariants.cjs');
 require('tslib');
+require('fs');
+require('path');
 require('./test-variants/testVariantsIterable.cjs');
 require('./test-variants/testVariantsCreateTestRun.cjs');
 require('@flemist/async-utils');
@@ -15,4 +18,5 @@ require('./garbage-collect/garbageCollect.cjs');
 
 
 
+exports.generateErrorVariantFilePath = testVariants_saveErrorVariants.generateErrorVariantFilePath;
 exports.createTestVariants = testVariants_createTestVariants.createTestVariants;

package/dist/lib/index.d.ts

@@ -1,5 +1,6 @@
-export { type Obj, } from "./test-variants/types";
+export { type Obj, type GenerateErrorVariantFilePathOptions, type SaveErrorVariantsOptions, } from "./test-variants/types";
+export { generateErrorVariantFilePath, } from "./test-variants/saveErrorVariants";
 export { type TestVariantsTemplate, type TestVariantsTemplates, type TestVariantsTemplatesExt, } from "./test-variants/testVariantsIterable";
 export { type ErrorEvent, type OnErrorCallback, type TestVariantsTest, type TestVariantsTestResult, type TestVariantsCreateTestRunOptions, type TestVariantsTestRun, type TestVariantsTestRunResult, } from "./test-variants/testVariantsCreateTestRun";
-export { type TestVariantsFindBestErrorOptions, type TestVariantsRunOptions, type TestVariantsBestError, type TestVariantsRunResult, } from "./test-variants/testVariantsRun";
+export { type GetSeedParams, type TestVariantsFindBestErrorOptions, type TestVariantsRunOptions, type TestVariantsBestError, type TestVariantsRunResult, } from "./test-variants/testVariantsRun";
 export { type TestVariantsSetArgs, type TestVariantsCall, createTestVariants, } from './test-variants/createTestVariants';

package/dist/lib/index.mjs

@@ -1,5 +1,8 @@
+export { generateErrorVariantFilePath } from './test-variants/saveErrorVariants.mjs';
 export { createTestVariants } from './test-variants/createTestVariants.mjs';
 import 'tslib';
+import 'fs';
+import 'path';
 import './test-variants/testVariantsIterable.mjs';
 import './test-variants/testVariantsCreateTestRun.mjs';
 import '@flemist/async-utils';

package/dist/lib/test-variants/createTestVariants.cjs

@@ -11,6 +11,9 @@ require('./argsToString.cjs');
 require('@flemist/abort-controller-fast');
 require('@flemist/time-limits');
 require('../garbage-collect/garbageCollect.cjs');
+require('./saveErrorVariants.cjs');
+require('fs');
+require('path');
 
 function createTestVariants(test) {
     return function testVariantsArgs(args) {

package/dist/lib/test-variants/createTestVariants.d.ts

@@ -3,6 +3,6 @@ import { TestVariantsTemplatesExt } from "./testVariantsIterable";
 import { TestVariantsCreateTestRunOptions, TestVariantsTest } from "./testVariantsCreateTestRun";
 import { TestVariantsRunOptions, TestVariantsRunResult } from "./testVariantsRun";
 import { Obj } from "./types";
-export declare type TestVariantsCall<Args extends Obj> = (options?: null | TestVariantsRunOptions & TestVariantsCreateTestRunOptions<Args>) => PromiseOrValue<TestVariantsRunResult<Args>>;
+export declare type TestVariantsCall<Args extends Obj> = <SavedArgs = Args>(options?: null | TestVariantsRunOptions<Args, SavedArgs> & TestVariantsCreateTestRunOptions<Args>) => PromiseOrValue<TestVariantsRunResult<Args>>;
 export declare type TestVariantsSetArgs<Args extends Obj> = <ArgsExtra extends Obj>(args: TestVariantsTemplatesExt<Omit<Args, 'seed'>, Omit<ArgsExtra, 'seed'>>) => TestVariantsCall<Args>;
 export declare function createTestVariants<Args extends Obj>(test: TestVariantsTest<Args>): TestVariantsSetArgs<Args>;

package/dist/lib/test-variants/createTestVariants.mjs

@@ -7,6 +7,9 @@ import './argsToString.mjs';
 import '@flemist/abort-controller-fast';
 import '@flemist/time-limits';
 import '../garbage-collect/garbageCollect.mjs';
+import './saveErrorVariants.mjs';
+import 'fs';
+import 'path';
 
 function createTestVariants(test) {
     return function testVariantsArgs(args) {

package/dist/lib/test-variants/createTestVariants.perf.cjs

@@ -11,6 +11,9 @@ require('./testVariantsRun.cjs');
 require('@flemist/abort-controller-fast');
 require('@flemist/time-limits');
 require('../garbage-collect/garbageCollect.cjs');
+require('./saveErrorVariants.cjs');
+require('fs');
+require('path');
 
 describe('test > testVariants perf', function () {
     this.timeout(300000);

package/dist/lib/test-variants/createTestVariants.perf.mjs

@@ -9,6 +9,9 @@ import './testVariantsRun.mjs';
 import '@flemist/abort-controller-fast';
 import '@flemist/time-limits';
 import '../garbage-collect/garbageCollect.mjs';
+import './saveErrorVariants.mjs';
+import 'fs';
+import 'path';
 
 describe('test > testVariants perf', function () {
     this.timeout(300000);

package/dist/lib/test-variants/saveErrorVariants.cjs

@@ -0,0 +1,97 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var fs = require('fs');
+var path = require('path');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+/** Reads saved error variant files from directory, sorted by filename descending (newest first) */
+function readErrorVariantFiles(dir) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        const stat = yield fs__namespace.promises.stat(dir).catch(() => null);
+        if (stat == null) {
+            return [];
+        }
+        if (!stat.isDirectory()) {
+            throw new Error(`[saveErrorVariants] path is not a directory: ${dir}`);
+        }
+        const files = yield fs__namespace.promises.readdir(dir);
+        const jsonFiles = files
+            .filter(file => file.endsWith('.json'))
+            .sort((a, b) => a > b ? -1 : a < b ? 1 : 0);
+        return jsonFiles.map(file => path__namespace.join(dir, file));
+    });
+}
+/** Parses saved error variant file and transforms JSON to args */
+function parseErrorVariantFile(filePath, jsonToArgs) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        const content = yield fs__namespace.promises.readFile(filePath, 'utf-8');
+        let json;
+        try {
+            json = JSON.parse(content);
+        }
+        catch (err) {
+            throw new Error(`[saveErrorVariants] invalid JSON in file: ${filePath}`);
+        }
+        if (jsonToArgs) {
+            try {
+                return jsonToArgs(json);
+            }
+            catch (err) {
+                throw new Error(`[saveErrorVariants] jsonToArgs failed for file: ${filePath}`);
+            }
+        }
+        return json;
+    });
+}
+/** Generates default error variant file path: YYYY-MM-DD_HH-mm-ss.json (UTC) */
+function generateErrorVariantFilePath(options) {
+    return options.sessionDate.toISOString().substring(0, 19).replace('T', '_').replaceAll(':', '-') + '.json';
+}
+/** Saves error-causing args to a JSON file, overwrites if file exists */
+function saveErrorVariantFile(args, filePath, argsToJson) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        let content;
+        if (argsToJson) {
+            const result = argsToJson(args);
+            if (typeof result === 'string') {
+                content = result;
+            }
+            else {
+                content = JSON.stringify(result, null, 2);
+            }
+        }
+        else {
+            content = JSON.stringify(args, null, 2);
+        }
+        yield fs__namespace.promises.mkdir(path__namespace.dirname(filePath), { recursive: true });
+        yield fs__namespace.promises.writeFile(filePath, content, 'utf-8');
+    });
+}
+
+exports.generateErrorVariantFilePath = generateErrorVariantFilePath;
+exports.parseErrorVariantFile = parseErrorVariantFile;
+exports.readErrorVariantFiles = readErrorVariantFiles;
+exports.saveErrorVariantFile = saveErrorVariantFile;

package/dist/lib/test-variants/saveErrorVariants.d.ts

@@ -0,0 +1,9 @@
+import { type GenerateErrorVariantFilePathOptions, type Obj } from "./types";
+/** Reads saved error variant files from directory, sorted by filename descending (newest first) */
+export declare function readErrorVariantFiles(dir: string): Promise<string[]>;
+/** Parses saved error variant file and transforms JSON to args */
+export declare function parseErrorVariantFile<Args extends Obj, SavedArgs>(filePath: string, jsonToArgs?: null | ((json: SavedArgs) => Args)): Promise<Args>;
+/** Generates default error variant file path: YYYY-MM-DD_HH-mm-ss.json (UTC) */
+export declare function generateErrorVariantFilePath(options: GenerateErrorVariantFilePathOptions): string;
+/** Saves error-causing args to a JSON file, overwrites if file exists */
+export declare function saveErrorVariantFile<Args extends Obj, SavedArgs>(args: Args, filePath: string, argsToJson?: null | ((args: Args) => string | SavedArgs)): Promise<void>;

package/dist/lib/test-variants/saveErrorVariants.mjs

@@ -0,0 +1,69 @@
+import { __awaiter } from 'tslib';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/** Reads saved error variant files from directory, sorted by filename descending (newest first) */
+function readErrorVariantFiles(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const stat = yield fs.promises.stat(dir).catch(() => null);
+        if (stat == null) {
+            return [];
+        }
+        if (!stat.isDirectory()) {
+            throw new Error(`[saveErrorVariants] path is not a directory: ${dir}`);
+        }
+        const files = yield fs.promises.readdir(dir);
+        const jsonFiles = files
+            .filter(file => file.endsWith('.json'))
+            .sort((a, b) => a > b ? -1 : a < b ? 1 : 0);
+        return jsonFiles.map(file => path.join(dir, file));
+    });
+}
+/** Parses saved error variant file and transforms JSON to args */
+function parseErrorVariantFile(filePath, jsonToArgs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const content = yield fs.promises.readFile(filePath, 'utf-8');
+        let json;
+        try {
+            json = JSON.parse(content);
+        }
+        catch (err) {
+            throw new Error(`[saveErrorVariants] invalid JSON in file: ${filePath}`);
+        }
+        if (jsonToArgs) {
+            try {
+                return jsonToArgs(json);
+            }
+            catch (err) {
+                throw new Error(`[saveErrorVariants] jsonToArgs failed for file: ${filePath}`);
+            }
+        }
+        return json;
+    });
+}
+/** Generates default error variant file path: YYYY-MM-DD_HH-mm-ss.json (UTC) */
+function generateErrorVariantFilePath(options) {
+    return options.sessionDate.toISOString().substring(0, 19).replace('T', '_').replaceAll(':', '-') + '.json';
+}
+/** Saves error-causing args to a JSON file, overwrites if file exists */
+function saveErrorVariantFile(args, filePath, argsToJson) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let content;
+        if (argsToJson) {
+            const result = argsToJson(args);
+            if (typeof result === 'string') {
+                content = result;
+            }
+            else {
+                content = JSON.stringify(result, null, 2);
+            }
+        }
+        else {
+            content = JSON.stringify(args, null, 2);
+        }
+        yield fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+        yield fs.promises.writeFile(filePath, content, 'utf-8');
+    });
+}
+
+export { generateErrorVariantFilePath, parseErrorVariantFile, readErrorVariantFiles, saveErrorVariantFile };

package/dist/lib/test-variants/testVariantsRun.cjs

@@ -7,15 +7,57 @@ var abortControllerFast = require('@flemist/abort-controller-fast');
 var asyncUtils = require('@flemist/async-utils');
 var timeLimits = require('@flemist/time-limits');
 var garbageCollect_garbageCollect = require('../garbage-collect/garbageCollect.cjs');
+var testVariants_saveErrorVariants = require('./saveErrorVariants.cjs');
+var path = require('path');
+require('fs');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
 
 function testVariantsRun(testRun, variants, options = {}) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     return tslib.__awaiter(this, void 0, void 0, function* () {
-        const GC_Iterations = (_a = options.GC_Iterations) !== null && _a !== void 0 ? _a : 1000000;
-        const GC_IterationsAsync = (_b = options.GC_IterationsAsync) !== null && _b !== void 0 ? _b : 10000;
-        const GC_Interval = (_c = options.GC_Interval) !== null && _c !== void 0 ? _c : 1000;
-        const logInterval = (_d = options.logInterval) !== null && _d !== void 0 ? _d : 5000;
-        const logCompleted = (_e = options.logCompleted) !== null && _e !== void 0 ? _e : true;
+        const saveErrorVariants = options.saveErrorVariants;
+        const retriesPerVariant = (_a = saveErrorVariants === null || saveErrorVariants === void 0 ? void 0 : saveErrorVariants.retriesPerVariant) !== null && _a !== void 0 ? _a : 1;
+        const sessionDate = new Date();
+        const errorVariantFilePath = saveErrorVariants
+            ? path__namespace.resolve(saveErrorVariants.dir, (_c = (_b = saveErrorVariants.getFilePath) === null || _b === void 0 ? void 0 : _b.call(saveErrorVariants, { sessionDate })) !== null && _c !== void 0 ? _c : testVariants_saveErrorVariants.generateErrorVariantFilePath({ sessionDate }))
+            : null;
+        // Replay phase: run previously saved error variants before normal iteration
+        if (saveErrorVariants) {
+            const files = yield testVariants_saveErrorVariants.readErrorVariantFiles(saveErrorVariants.dir);
+            for (const filePath of files) {
+                const args = yield testVariants_saveErrorVariants.parseErrorVariantFile(filePath, saveErrorVariants.jsonToArgs);
+                for (let retry = 0; retry < retriesPerVariant; retry++) {
+                    const promiseOrResult = testRun(args, -1, null);
+                    if (asyncUtils.isPromiseLike(promiseOrResult)) {
+                        yield promiseOrResult;
+                    }
+                }
+            }
+        }
+        const GC_Iterations = (_d = options.GC_Iterations) !== null && _d !== void 0 ? _d : 1000000;
+        const GC_IterationsAsync = (_e = options.GC_IterationsAsync) !== null && _e !== void 0 ? _e : 10000;
+        const GC_Interval = (_f = options.GC_Interval) !== null && _f !== void 0 ? _f : 1000;
+        const logInterval = (_g = options.logInterval) !== null && _g !== void 0 ? _g : 5000;
+        const logCompleted = (_h = options.logCompleted) !== null && _h !== void 0 ? _h : true;
         const abortSignalExternal = options.abortSignal;
         const findBestError = options.findBestError;
         const parallel = options.parallel === true
@@ -23,30 +65,55 @@ function testVariantsRun(testRun, variants, options = {}) {
             : !options.parallel || options.parallel <= 0
                 ? 1
                 : options.parallel;
-        const seedsIterator = (_f = findBestError === null || findBestError === void 0 ? void 0 : findBestError.seeds[Symbol.iterator]()) !== null && _f !== void 0 ? _f : null;
-        let seedResult = seedsIterator === null || seedsIterator === void 0 ? void 0 : seedsIterator.next();
+        const limitVariantsCount = (_j = options.limitVariantsCount) !== null && _j !== void 0 ? _j : null;
+        let cycleIndex = 0;
+        let repeatIndex = 0;
+        let seed = void 0;
         let bestError = null;
         let index = -1;
         let args = {};
         let variantsIterator = variants[Symbol.iterator]();
         function nextVariant() {
             while (true) {
+                // Try next repeat for current variant
+                if (findBestError && index >= 0 && (bestError == null || index < bestError.index)) {
+                    repeatIndex++;
+                    if (repeatIndex < findBestError.repeatsPerVariant) {
+                        seed = findBestError.getSeed({
+                            variantIndex: index,
+                            cycleIndex,
+                            repeatIndex,
+                            totalIndex: cycleIndex * findBestError.repeatsPerVariant + repeatIndex,
+                        });
+                        return true;
+                    }
+                }
+                repeatIndex = 0;
                 index++;
-                if (seedResult && seedResult.done) {
+                if (findBestError && cycleIndex >= findBestError.cycles) {
                     return false;
                 }
-                if (bestError == null || index < bestError.index) {
+                if ((limitVariantsCount == null || index < limitVariantsCount)
+                    && (bestError == null || index < bestError.index)) {
                     const result = variantsIterator.next();
                     if (!result.done) {
                         args = result.value;
+                        if (findBestError) {
+                            seed = findBestError.getSeed({
+                                variantIndex: index,
+                                cycleIndex,
+                                repeatIndex,
+                                totalIndex: cycleIndex * findBestError.repeatsPerVariant + repeatIndex,
+                            });
+                        }
                         return true;
                     }
                 }
-                if (!seedsIterator) {
+                if (!findBestError) {
                     return false;
                 }
-                seedResult = seedsIterator.next();
-                if (seedResult.done) {
+                cycleIndex++;
+                if (cycleIndex >= findBestError.cycles) {
                     return false;
                 }
                 index = -1;
@@ -75,7 +142,7 @@ function testVariantsRun(testRun, variants, options = {}) {
             return tslib.__awaiter(this, void 0, void 0, function* () {
                 while (!(abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) && (debug || nextVariant())) {
                     const _index = index;
-                    const _args = Object.assign(Object.assign({}, args), { seed: seedResult === null || seedResult === void 0 ? void 0 : seedResult.value });
+                    const _args = Object.assign(Object.assign({}, args), { seed });
                     const now = (logInterval || GC_Interval) && Date.now();
                     if (logInterval && now - prevLogTime >= logInterval) {
                         // the log is required to prevent the karma browserNoActivityTimeout
@@ -109,6 +176,9 @@ function testVariantsRun(testRun, variants, options = {}) {
                             iterations += _iterationsSync + _iterationsAsync;
                         }
                         catch (err) {
+                            if (errorVariantFilePath) {
+                                yield testVariants_saveErrorVariants.saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
+                            }
                             if (findBestError) {
                                 bestError = {
                                     error: err,
@@ -146,6 +216,9 @@ function testVariantsRun(testRun, variants, options = {}) {
                                 iterations += _iterationsSync + _iterationsAsync;
                             }
                             catch (err) {
+                                if (errorVariantFilePath) {
+                                    yield testVariants_saveErrorVariants.saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
+                                }
                                 if (findBestError) {
                                     bestError = {
                                         error: err,

package/dist/lib/test-variants/testVariantsRun.d.ts

@@ -1,10 +1,27 @@
 import { TestVariantsTestRun } from './testVariantsCreateTestRun';
 import { type IAbortSignalFast } from '@flemist/abort-controller-fast';
-import { Obj } from "./types";
+import { Obj, type SaveErrorVariantsOptions } from "./types";
+/** Parameters passed to getSeed function for generating test seeds */
+export declare type GetSeedParams = {
+    /** Index of current variant/parameter-combination being tested */
+    variantIndex: number;
+    /** Index of current cycle - full pass through all variants (0..cycles-1) */
+    cycleIndex: number;
+    /** Index of repeat for current variant within this cycle (0..repeatsPerVariant-1) */
+    repeatIndex: number;
+    /** Total index across all cycles: cycleIndex × repeatsPerVariant + repeatIndex */
+    totalIndex: number;
+};
+/** Options for finding the earliest failing variant across multiple test runs */
 export declare type TestVariantsFindBestErrorOptions = {
-    seeds: Iterable<any>;
+    /** Function to generate seed based on current iteration state */
+    getSeed: (params: GetSeedParams) => any;
+    /** Number of full passes through all variants */
+    cycles: number;
+    /** Number of repeat tests per variant within each cycle */
+    repeatsPerVariant: number;
 };
-export declare type TestVariantsRunOptions = {
+export declare type TestVariantsRunOptions<Args extends Obj = Obj, SavedArgs = Args> = {
     /** Wait for garbage collection after iterations */
     GC_Iterations?: null | number;
     /** Same as GC_Iterations but only for async test variants, required for 10000 and more of Promise rejections */
@@ -18,6 +35,10 @@ export declare type TestVariantsRunOptions = {
     abortSignal?: null | IAbortSignalFast;
     parallel?: null | number | boolean;
     findBestError?: null | TestVariantsFindBestErrorOptions;
+    /** Save error-causing args to files and replay them before normal iteration */
+    saveErrorVariants?: null | SaveErrorVariantsOptions<Args, SavedArgs>;
+    /** Tests only first N variants, ignores the rest. If null or not specified, tests all variants */
+    limitVariantsCount?: null | number;
 };
 export declare type TestVariantsBestError<Args extends Obj> = {
     error: any;
@@ -28,4 +49,4 @@ export declare type TestVariantsRunResult<Arg extends Obj> = {
     iterations: number;
     bestError: null | TestVariantsBestError<Arg>;
 };
-export declare function testVariantsRun<Args extends Obj>(testRun: TestVariantsTestRun<Args>, variants: Iterable<Args>, options?: TestVariantsRunOptions): Promise<TestVariantsRunResult<Args>>;
+export declare function testVariantsRun<Args extends Obj, SavedArgs = Args>(testRun: TestVariantsTestRun<Args>, variants: Iterable<Args>, options?: TestVariantsRunOptions<Args, SavedArgs>): Promise<TestVariantsRunResult<Args>>;

package/dist/lib/test-variants/testVariantsRun.mjs

@@ -1,17 +1,39 @@
 import { __awaiter } from 'tslib';
 import { AbortControllerFast } from '@flemist/abort-controller-fast';
-import { combineAbortSignals, isPromiseLike } from '@flemist/async-utils';
+import { isPromiseLike, combineAbortSignals } from '@flemist/async-utils';
 import { Pool } from '@flemist/time-limits';
 import { garbageCollect } from '../garbage-collect/garbageCollect.mjs';
+import { generateErrorVariantFilePath, readErrorVariantFiles, parseErrorVariantFile, saveErrorVariantFile } from './saveErrorVariants.mjs';
+import * as path from 'path';
+import 'fs';
 
 function testVariantsRun(testRun, variants, options = {}) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     return __awaiter(this, void 0, void 0, function* () {
-        const GC_Iterations = (_a = options.GC_Iterations) !== null && _a !== void 0 ? _a : 1000000;
-        const GC_IterationsAsync = (_b = options.GC_IterationsAsync) !== null && _b !== void 0 ? _b : 10000;
-        const GC_Interval = (_c = options.GC_Interval) !== null && _c !== void 0 ? _c : 1000;
-        const logInterval = (_d = options.logInterval) !== null && _d !== void 0 ? _d : 5000;
-        const logCompleted = (_e = options.logCompleted) !== null && _e !== void 0 ? _e : true;
+        const saveErrorVariants = options.saveErrorVariants;
+        const retriesPerVariant = (_a = saveErrorVariants === null || saveErrorVariants === void 0 ? void 0 : saveErrorVariants.retriesPerVariant) !== null && _a !== void 0 ? _a : 1;
+        const sessionDate = new Date();
+        const errorVariantFilePath = saveErrorVariants
+            ? path.resolve(saveErrorVariants.dir, (_c = (_b = saveErrorVariants.getFilePath) === null || _b === void 0 ? void 0 : _b.call(saveErrorVariants, { sessionDate })) !== null && _c !== void 0 ? _c : generateErrorVariantFilePath({ sessionDate }))
+            : null;
+        // Replay phase: run previously saved error variants before normal iteration
+        if (saveErrorVariants) {
+            const files = yield readErrorVariantFiles(saveErrorVariants.dir);
+            for (const filePath of files) {
+                const args = yield parseErrorVariantFile(filePath, saveErrorVariants.jsonToArgs);
+                for (let retry = 0; retry < retriesPerVariant; retry++) {
+                    const promiseOrResult = testRun(args, -1, null);
+                    if (isPromiseLike(promiseOrResult)) {
+                        yield promiseOrResult;
+                    }
+                }
+            }
+        }
+        const GC_Iterations = (_d = options.GC_Iterations) !== null && _d !== void 0 ? _d : 1000000;
+        const GC_IterationsAsync = (_e = options.GC_IterationsAsync) !== null && _e !== void 0 ? _e : 10000;
+        const GC_Interval = (_f = options.GC_Interval) !== null && _f !== void 0 ? _f : 1000;
+        const logInterval = (_g = options.logInterval) !== null && _g !== void 0 ? _g : 5000;
+        const logCompleted = (_h = options.logCompleted) !== null && _h !== void 0 ? _h : true;
         const abortSignalExternal = options.abortSignal;
         const findBestError = options.findBestError;
         const parallel = options.parallel === true
@@ -19,30 +41,55 @@ function testVariantsRun(testRun, variants, options = {}) {
             : !options.parallel || options.parallel <= 0
                 ? 1
                 : options.parallel;
-        const seedsIterator = (_f = findBestError === null || findBestError === void 0 ? void 0 : findBestError.seeds[Symbol.iterator]()) !== null && _f !== void 0 ? _f : null;
-        let seedResult = seedsIterator === null || seedsIterator === void 0 ? void 0 : seedsIterator.next();
+        const limitVariantsCount = (_j = options.limitVariantsCount) !== null && _j !== void 0 ? _j : null;
+        let cycleIndex = 0;
+        let repeatIndex = 0;
+        let seed = void 0;
         let bestError = null;
         let index = -1;
         let args = {};
         let variantsIterator = variants[Symbol.iterator]();
         function nextVariant() {
             while (true) {
+                // Try next repeat for current variant
+                if (findBestError && index >= 0 && (bestError == null || index < bestError.index)) {
+                    repeatIndex++;
+                    if (repeatIndex < findBestError.repeatsPerVariant) {
+                        seed = findBestError.getSeed({
+                            variantIndex: index,
+                            cycleIndex,
+                            repeatIndex,
+                            totalIndex: cycleIndex * findBestError.repeatsPerVariant + repeatIndex,
+                        });
+                        return true;
+                    }
+                }
+                repeatIndex = 0;
                 index++;
-                if (seedResult && seedResult.done) {
+                if (findBestError && cycleIndex >= findBestError.cycles) {
                     return false;
                 }
-                if (bestError == null || index < bestError.index) {
+                if ((limitVariantsCount == null || index < limitVariantsCount)
+                    && (bestError == null || index < bestError.index)) {
                     const result = variantsIterator.next();
                     if (!result.done) {
                         args = result.value;
+                        if (findBestError) {
+                            seed = findBestError.getSeed({
+                                variantIndex: index,
+                                cycleIndex,
+                                repeatIndex,
+                                totalIndex: cycleIndex * findBestError.repeatsPerVariant + repeatIndex,
+                            });
+                        }
                         return true;
                     }
                 }
-                if (!seedsIterator) {
+                if (!findBestError) {
                     return false;
                 }
-                seedResult = seedsIterator.next();
-                if (seedResult.done) {
+                cycleIndex++;
+                if (cycleIndex >= findBestError.cycles) {
                     return false;
                 }
                 index = -1;
@@ -71,7 +118,7 @@ function testVariantsRun(testRun, variants, options = {}) {
             return __awaiter(this, void 0, void 0, function* () {
                 while (!(abortSignalExternal === null || abortSignalExternal === void 0 ? void 0 : abortSignalExternal.aborted) && (debug || nextVariant())) {
                     const _index = index;
-                    const _args = Object.assign(Object.assign({}, args), { seed: seedResult === null || seedResult === void 0 ? void 0 : seedResult.value });
+                    const _args = Object.assign(Object.assign({}, args), { seed });
                     const now = (logInterval || GC_Interval) && Date.now();
                     if (logInterval && now - prevLogTime >= logInterval) {
                         // the log is required to prevent the karma browserNoActivityTimeout
@@ -105,6 +152,9 @@ function testVariantsRun(testRun, variants, options = {}) {
                             iterations += _iterationsSync + _iterationsAsync;
                         }
                         catch (err) {
+                            if (errorVariantFilePath) {
+                                yield saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
+                            }
                             if (findBestError) {
                                 bestError = {
                                     error: err,
@@ -142,6 +192,9 @@ function testVariantsRun(testRun, variants, options = {}) {
                                 iterations += _iterationsSync + _iterationsAsync;
                             }
                             catch (err) {
+                                if (errorVariantFilePath) {
+                                    yield saveErrorVariantFile(_args, errorVariantFilePath, saveErrorVariants.argsToJson);
+                                }
                                 if (findBestError) {
                                     bestError = {
                                         error: err,

package/dist/lib/test-variants/types.d.ts

@@ -1 +1,18 @@
 export declare type Obj = Record<string, any>;
+/** Options for generating error variant file path */
+export declare type GenerateErrorVariantFilePathOptions = {
+    sessionDate: Date;
+};
+/** Options for saving and replaying error-causing parameter combinations */
+export declare type SaveErrorVariantsOptions<Args, SavedArgs = Args> = {
+    /** Directory path for error variant JSON files */
+    dir: string;
+    /** Retry attempts per variant during replay phase (default: 1) */
+    retriesPerVariant?: null | number;
+    /** Custom file path generator; returns path relative to dir; null - use default path */
+    getFilePath?: null | ((options: GenerateErrorVariantFilePathOptions) => string | null);
+    /** Transform args before JSON serialization */
+    argsToJson?: null | ((args: Args) => string | SavedArgs);
+    /** Transform parsed JSON back to args */
+    jsonToArgs?: null | ((json: SavedArgs) => Args);
+};