@flemist/test-variants 2.0.0-alpha → 2.0.0

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,4 +1,5 @@
-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";

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,7 +65,7 @@ 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;
+        const seedsIterator = (_j = findBestError === null || findBestError === void 0 ? void 0 : findBestError.seeds[Symbol.iterator]()) !== null && _j !== void 0 ? _j : null;
         let seedResult = seedsIterator === null || seedsIterator === void 0 ? void 0 : seedsIterator.next();
         let bestError = null;
         let index = -1;
@@ -109,6 +151,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 +191,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,10 @@
 import { TestVariantsTestRun } from './testVariantsCreateTestRun';
 import { type IAbortSignalFast } from '@flemist/abort-controller-fast';
-import { Obj } from "./types";
+import { Obj, type SaveErrorVariantsOptions } from "./types";
 export declare type TestVariantsFindBestErrorOptions = {
     seeds: Iterable<any>;
 };
-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 +18,8 @@ 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>;
 };
 export declare type TestVariantsBestError<Args extends Obj> = {
     error: any;
@@ -28,4 +30,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,7 +41,7 @@ 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;
+        const seedsIterator = (_j = findBestError === null || findBestError === void 0 ? void 0 : findBestError.seeds[Symbol.iterator]()) !== null && _j !== void 0 ? _j : null;
         let seedResult = seedsIterator === null || seedsIterator === void 0 ? void 0 : seedsIterator.next();
         let bestError = null;
         let index = -1;
@@ -105,6 +127,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 +167,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);
+};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@flemist/test-variants",
-  "version": "2.0.0-alpha",
+  "version": "2.0.0",
   "description": "Runs a test function with all possible combinations of its parameters.",
   "main": "dist/lib/index.cjs",
   "module": "dist/lib/index.mjs",
   "types": "dist/lib/index.d.ts",
   "engines": {
-    "node": ">=10.4.0",
+    "node": ">=11.14.0",
     "pnpm": ">=7.1.6"
   },
   "repository": {
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "scripts": {
-    "_prepublishOnly": "pnpm run audit && pnpm run lint && pnpm run build && pnpm run test:mocha:ci && pnpm run test:karma",
+    "_prepublishOnly": "pnpm run audit && pnpm run lint && pnpm run build && pnpm run test:mocha:ci && pnpm run test:karma && npm login",
     "audit": "pnpm audit --prod",
     "lint": "eslint ./**/*.{js,cjs,mjs,ts,tsx}",
     "lint:fix": "eslint --fix ./**/*.{js,cjs,mjs,ts,tsx}",
@@ -47,9 +47,11 @@
     "test:mocha:watch": "mocha --watch ./src/**/*.test.*",
     "test:karma": "rimraf tmp/coverage/karma && karma start --single-run --log-level debug",
     "test:mocha:ci": "rimraf tmp/coverage/mocha && nyc --all mocha ./{src,dist/lib}/**/*.test.*",
-    "coveralls": "pnpm run coverage:check && nyc report --reporter=text-lcov --temp-dir \"tmp/coverage/merge/\" | coveralls"
+    "coveralls": "pnpm run coverage:check && nyc report --reporter=text-lcov --temp-dir \"tmp/coverage/merge/\" | coveralls",
+    "mcp:tools": "mcp-project-tools"
   },
   "devDependencies": {
+    "@anthropic-ai/claude-code": "^2.0.76",
     "@babel/core": "7.18.5",
     "@babel/plugin-syntax-dynamic-import": "7.8.3",
     "@babel/plugin-transform-classes": "7.18.4",
@@ -58,6 +60,7 @@
     "@babel/runtime-corejs3": "7.28.3",
     "@flemist/copy-glob-flat": "0.0.5",
     "@flemist/karma-custom-launcher": "0.0.0",
+    "@flemist/mcp-project-tools": "3.0.19",
     "@flemist/test-utils": "1.0.2",
     "@rollup/plugin-alias": "3.1.9",
     "@rollup/plugin-babel": "5.3.1",