@midscene/cli 1.8.7 → 1.8.8-beta-20260601092605.0

package/dist/lib/index.js

@@ -262,200 +262,6 @@ var __webpack_modules__ = {
             get: assembleStyles
         });
     },
-    "../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js" (module) {
-        "use strict";
-        module.exports = balanced;
-        function balanced(a, b, str) {
-            if (a instanceof RegExp) a = maybeMatch(a, str);
-            if (b instanceof RegExp) b = maybeMatch(b, str);
-            var r = range(a, b, str);
-            return r && {
-                start: r[0],
-                end: r[1],
-                pre: str.slice(0, r[0]),
-                body: str.slice(r[0] + a.length, r[1]),
-                post: str.slice(r[1] + b.length)
-            };
-        }
-        function maybeMatch(reg, str) {
-            var m = str.match(reg);
-            return m ? m[0] : null;
-        }
-        balanced.range = range;
-        function range(a, b, str) {
-            var begs, beg, left, right, result;
-            var ai = str.indexOf(a);
-            var bi = str.indexOf(b, ai + 1);
-            var i = ai;
-            if (ai >= 0 && bi > 0) {
-                if (a === b) return [
-                    ai,
-                    bi
-                ];
-                begs = [];
-                left = str.length;
-                while(i >= 0 && !result){
-                    if (i == ai) {
-                        begs.push(i);
-                        ai = str.indexOf(a, i + 1);
-                    } else if (1 == begs.length) result = [
-                        begs.pop(),
-                        bi
-                    ];
-                    else {
-                        beg = begs.pop();
-                        if (beg < left) {
-                            left = beg;
-                            right = bi;
-                        }
-                        bi = str.indexOf(b, i + 1);
-                    }
-                    i = ai < bi && ai >= 0 ? ai : bi;
-                }
-                if (begs.length) result = [
-                    left,
-                    right
-                ];
-            }
-            return result;
-        }
-    },
-    "../../node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js" (module, __unused_rspack_exports, __webpack_require__) {
-        var balanced = __webpack_require__("../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js");
-        module.exports = expandTop;
-        var escSlash = '\0SLASH' + Math.random() + '\0';
-        var escOpen = '\0OPEN' + Math.random() + '\0';
-        var escClose = '\0CLOSE' + Math.random() + '\0';
-        var escComma = '\0COMMA' + Math.random() + '\0';
-        var escPeriod = '\0PERIOD' + Math.random() + '\0';
-        function numeric(str) {
-            return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
-        }
-        function escapeBraces(str) {
-            return str.split('\\\\').join(escSlash).split('\\{').join(escOpen).split('\\}').join(escClose).split('\\,').join(escComma).split('\\.').join(escPeriod);
-        }
-        function unescapeBraces(str) {
-            return str.split(escSlash).join('\\').split(escOpen).join('{').split(escClose).join('}').split(escComma).join(',').split(escPeriod).join('.');
-        }
-        function parseCommaParts(str) {
-            if (!str) return [
-                ''
-            ];
-            var parts = [];
-            var m = balanced('{', '}', str);
-            if (!m) return str.split(',');
-            var pre = m.pre;
-            var body = m.body;
-            var post = m.post;
-            var p = pre.split(',');
-            p[p.length - 1] += '{' + body + '}';
-            var postParts = parseCommaParts(post);
-            if (post.length) {
-                p[p.length - 1] += postParts.shift();
-                p.push.apply(p, postParts);
-            }
-            parts.push.apply(parts, p);
-            return parts;
-        }
-        function expandTop(str) {
-            if (!str) return [];
-            if ('{}' === str.substr(0, 2)) str = '\\{\\}' + str.substr(2);
-            return expand(escapeBraces(str), true).map(unescapeBraces);
-        }
-        function embrace(str) {
-            return '{' + str + '}';
-        }
-        function isPadded(el) {
-            return /^-?0\d/.test(el);
-        }
-        function lte(i, y) {
-            return i <= y;
-        }
-        function gte(i, y) {
-            return i >= y;
-        }
-        function expand(str, isTop) {
-            var expansions = [];
-            var m = balanced('{', '}', str);
-            if (!m) return [
-                str
-            ];
-            var pre = m.pre;
-            var post = m.post.length ? expand(m.post, false) : [
-                ''
-            ];
-            if (/\$$/.test(m.pre)) for(var k = 0; k < post.length; k++){
-                var expansion = pre + '{' + m.body + '}' + post[k];
-                expansions.push(expansion);
-            }
-            else {
-                var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-                var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-                var isSequence = isNumericSequence || isAlphaSequence;
-                var isOptions = m.body.indexOf(',') >= 0;
-                if (!isSequence && !isOptions) {
-                    if (m.post.match(/,.*\}/)) {
-                        str = m.pre + '{' + m.body + escClose + m.post;
-                        return expand(str);
-                    }
-                    return [
-                        str
-                    ];
-                }
-                var n;
-                if (isSequence) n = m.body.split(/\.\./);
-                else {
-                    n = parseCommaParts(m.body);
-                    if (1 === n.length) {
-                        n = expand(n[0], false).map(embrace);
-                        if (1 === n.length) return post.map(function(p) {
-                            return m.pre + n[0] + p;
-                        });
-                    }
-                }
-                var N;
-                if (isSequence) {
-                    var x = numeric(n[0]);
-                    var y = numeric(n[1]);
-                    var width = Math.max(n[0].length, n[1].length);
-                    var incr = 3 == n.length ? Math.abs(numeric(n[2])) : 1;
-                    var test = lte;
-                    var reverse = y < x;
-                    if (reverse) {
-                        incr *= -1;
-                        test = gte;
-                    }
-                    var pad = n.some(isPadded);
-                    N = [];
-                    for(var i = x; test(i, y); i += incr){
-                        var c;
-                        if (isAlphaSequence) {
-                            c = String.fromCharCode(i);
-                            if ('\\' === c) c = '';
-                        } else {
-                            c = String(i);
-                            if (pad) {
-                                var need = width - c.length;
-                                if (need > 0) {
-                                    var z = new Array(need + 1).join('0');
-                                    c = i < 0 ? '-' + z + c.slice(1) : z + c;
-                                }
-                            }
-                        }
-                        N.push(c);
-                    }
-                } else {
-                    N = [];
-                    for(var j = 0; j < n.length; j++)N.push.apply(N, expand(n[j], false));
-                }
-                for(var j = 0; j < N.length; j++)for(var k = 0; k < post.length; k++){
-                    var expansion = pre + N[j] + post[k];
-                    if (!isTop || isSequence || expansion) expansions.push(expansion);
-                }
-            }
-            return expansions;
-        }
-    },
     "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         "use strict";
         const ansiStyles = __webpack_require__("../../node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js");
@@ -3007,1153 +2813,570 @@ var __webpack_modules__ = {
         };
         module.exports = (string, columns, options)=>String(string).normalize().replace(/\r\n/g, '\n').split('\n').map((line)=>exec(line, columns, options)).join('\n');
     },
-    "./src/index.ts" (__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+    "./src/framework/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         "use strict";
-        const external_node_fs_namespaceObject = require("node:fs");
-        var external_node_fs_namespaceObject_0 = /*#__PURE__*/ __webpack_require__.t(external_node_fs_namespaceObject, 2);
-        const external_node_path_namespaceObject = require("node:path");
-        var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-        const core_namespaceObject = require("@midscene/core");
-        const cli_namespaceObject = require("@midscene/shared/cli");
-        var main = __webpack_require__("../../node_modules/.pnpm/dotenv@16.4.5/node_modules/dotenv/lib/main.js");
-        var main_default = /*#__PURE__*/ __webpack_require__.n(main);
-        var package_namespaceObject = {
-            rE: "1.8.7"
-        };
-        const yaml_namespaceObject = require("@midscene/core/yaml");
+        __webpack_require__.d(__webpack_exports__, {
+            runFrameworkTestConfig: ()=>runFrameworkTestConfig
+        });
+        var external_node_fs_ = __webpack_require__("node:fs");
+        var external_node_path_ = __webpack_require__("node:path");
         const common_namespaceObject = require("@midscene/shared/common");
-        const puppeteer_agent_launcher_namespaceObject = require("@midscene/web/puppeteer-agent-launcher");
-        const external_lodash_merge_namespaceObject = require("lodash.merge");
-        var external_lodash_merge_default = /*#__PURE__*/ __webpack_require__.n(external_lodash_merge_namespaceObject);
-        class Node {
-            value;
-            next;
-            constructor(value){
-                this.value = value;
-            }
-        }
-        class Queue {
-            #head;
-            #tail;
-            #size;
-            constructor(){
-                this.clear();
-            }
-            enqueue(value) {
-                const node = new Node(value);
-                if (this.#head) {
-                    this.#tail.next = node;
-                    this.#tail = node;
-                } else {
-                    this.#head = node;
-                    this.#tail = node;
-                }
-                this.#size++;
-            }
-            dequeue() {
-                const current = this.#head;
-                if (!current) return;
-                this.#head = this.#head.next;
-                this.#size--;
-                return current.value;
-            }
-            peek() {
-                if (!this.#head) return;
-                return this.#head.value;
-            }
-            clear() {
-                this.#head = void 0;
-                this.#tail = void 0;
-                this.#size = 0;
+        const notExecutedError = 'Not executed (previous task failed)';
+        function execution_summary_createNotExecutedYamlResult(file) {
+            return {
+                file,
+                success: false,
+                executed: false,
+                output: void 0,
+                report: void 0,
+                duration: 0,
+                resultType: 'notExecuted',
+                error: notExecutedError
+            };
+        }
+        function getExecutionSummary(results) {
+            return {
+                total: results.length,
+                successful: getResultsByType(results, 'success').length,
+                failed: getResultsByType(results, 'failed').length,
+                partialFailed: getResultsByType(results, 'partialFailed').length,
+                notExecuted: getResultsByType(results, 'notExecuted').length,
+                totalDuration: results.reduce((sum, r)=>sum + (r.duration || 0), 0)
+            };
+        }
+        function getResultsByType(results, resultType) {
+            return results.filter((result)=>result.resultType === resultType);
+        }
+        function getSummaryAbsolutePath(summary) {
+            return (0, external_node_path_.resolve)((0, common_namespaceObject.getMidsceneRunSubDir)('output'), summary);
+        }
+        function execution_summary_writeExecutionSummaryFile(summary, results) {
+            const indexPath = getSummaryAbsolutePath(summary);
+            const outputDir = (0, external_node_path_.dirname)(indexPath);
+            (0, external_node_fs_.mkdirSync)(outputDir, {
+                recursive: true
+            });
+            const executionSummary = getExecutionSummary(results);
+            const indexData = {
+                summary: {
+                    ...executionSummary,
+                    generatedAt: new Date().toLocaleString()
+                },
+                results: results.map((result)=>({
+                        script: (0, external_node_path_.relative)(outputDir, result.file),
+                        success: result.success,
+                        resultType: result.resultType,
+                        output: result.output ? (()=>{
+                            const relativePath = (0, external_node_path_.relative)(outputDir, result.output);
+                            return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+                        })() : void 0,
+                        report: result.report ? (0, external_node_path_.relative)(outputDir, result.report) : void 0,
+                        error: result.error,
+                        duration: result.duration
+                    }))
+            };
+            (0, external_node_fs_.writeFileSync)(indexPath, JSON.stringify(indexData, null, 2));
+            return indexPath;
+        }
+        function execution_summary_printExecutionPlan(config) {
+            console.log('   Scripts:');
+            for (const file of config.files)console.log(`     - ${file}`);
+            console.log('📋 Execution plan');
+            console.log(`   Concurrency: ${config.concurrent}`);
+            console.log(`   Keep window: ${config.keepWindow}`);
+            console.log(`   Headed: ${config.headed}`);
+            console.log(`   Continue on error: ${config.continueOnError}`);
+            console.log(`   Share browser context: ${config.shareBrowserContext ?? false}`);
+            console.log(`   Summary output: ${config.summary}`);
+        }
+        function execution_summary_printExecutionFinished() {
+            console.log('Execution finished:');
+        }
+        function printExecutionSummary(results, summaryPath) {
+            const summary = getExecutionSummary(results);
+            const successfulFiles = getResultsByType(results, 'success');
+            const failedFiles = getResultsByType(results, 'failed');
+            const partialFailedFiles = getResultsByType(results, 'partialFailed');
+            const notExecutedFiles = getResultsByType(results, 'notExecuted');
+            const success = 0 === summary.failed && 0 === summary.partialFailed && 0 === summary.notExecuted;
+            console.log('\n📊 Execution Summary:');
+            console.log(`   Total files: ${summary.total}`);
+            console.log(`   Successful: ${summary.successful}`);
+            console.log(`   Failed: ${summary.failed}`);
+            console.log(`   Partial failed: ${summary.partialFailed}`);
+            console.log(`   Not executed: ${summary.notExecuted}`);
+            console.log(`   Duration: ${(summary.totalDuration / 1000).toFixed(2)}s`);
+            console.log(`   Summary: ${summaryPath}`);
+            if (successfulFiles.length > 0) {
+                console.log('\n✅ Successful files:');
+                successfulFiles.forEach((result)=>{
+                    console.log(`   ${result.file}`);
+                });
             }
-            get size() {
-                return this.#size;
+            if (failedFiles.length > 0) {
+                console.log('\n❌ Failed files');
+                failedFiles.forEach((result)=>{
+                    console.log(`   ${result.file}`);
+                    if (result.error) console.log(`     Error: ${result.error}`);
+                });
             }
-            *[Symbol.iterator]() {
-                let current = this.#head;
-                while(current){
-                    yield current.value;
-                    current = current.next;
-                }
+            if (partialFailedFiles.length > 0) {
+                console.log('\n⚠️  Partial failed files (some tasks failed with continueOnError)');
+                partialFailedFiles.forEach((result)=>{
+                    console.log(`   ${result.file}`);
+                    if (result.error) console.log(`     Error: ${result.error}`);
+                });
             }
-            *drain() {
-                while(this.#head)yield this.dequeue();
+            if (notExecutedFiles.length > 0) {
+                console.log('\n⏸️ Not executed files');
+                notExecutedFiles.forEach((result)=>{
+                    console.log(`   ${result.file}`);
+                });
             }
-        }
-        function pLimit(concurrency) {
-            validateConcurrency(concurrency);
-            const queue = new Queue();
-            let activeCount = 0;
-            const resumeNext = ()=>{
-                if (activeCount < concurrency && queue.size > 0) {
-                    queue.dequeue()();
-                    activeCount++;
-                }
-            };
-            const next = ()=>{
-                activeCount--;
-                resumeNext();
-            };
-            const run = async (function_, resolve, arguments_)=>{
-                const result = (async ()=>function_(...arguments_))();
-                resolve(result);
-                try {
-                    await result;
-                } catch  {}
-                next();
+            if (success) console.log('\n🎉 All files executed successfully!');
+            else console.log('\n⚠️ Some files failed or were not executed.');
+            return success;
+        }
+        const DEFAULT_YAML_TEST_TIMEOUT = 0;
+        const toPosixPath = (value)=>value.split(external_node_path_.sep).join('/');
+        const toImportLiteral = (value)=>JSON.stringify(toPosixPath(value));
+        const toVirtualModuleId = (fileStem)=>`virtual:midscene-yaml/${fileStem}.test.ts`;
+        const safeFileStem = (file, index)=>{
+            const base = (0, external_node_path_.basename)(file, (0, external_node_path_.extname)(file)).replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+            return `${String(index + 1).padStart(3, '0')}-${base || 'case'}`;
+        };
+        const resolveTestName = (projectDir, yamlFile)=>{
+            const relativePath = (0, external_node_path_.relative)(projectDir, yamlFile);
+            return toPosixPath(relativePath.startsWith('..') ? yamlFile : relativePath);
+        };
+        const createGeneratedTestContent = (options)=>{
+            const testOptions = {
+                testName: options.testName,
+                yamlFile: options.yamlFile,
+                resultFile: options.resultFile,
+                ...options.caseOptions ? {
+                    caseOptions: options.caseOptions
+                } : {},
+                ...options.webRuntimeOptions ? {
+                    webRuntimeOptions: options.webRuntimeOptions
+                } : {}
             };
-            const enqueue = (function_, resolve, arguments_)=>{
-                new Promise((internalResolve)=>{
-                    queue.enqueue(internalResolve);
-                }).then(run.bind(void 0, function_, resolve, arguments_));
-                (async ()=>{
-                    await Promise.resolve();
-                    if (activeCount < concurrency) resumeNext();
-                })();
+            return `import { defineYamlCaseTest } from ${toImportLiteral(options.frameworkImport)};
+
+defineYamlCaseTest(${JSON.stringify(testOptions, null, 2)});
+`;
+        };
+        const createGeneratedBatchTestContent = (options)=>{
+            const testOptions = {
+                testName: options.testName,
+                config: options.config,
+                resultFiles: options.resultFiles
             };
-            const generator = (function_, ...arguments_)=>new Promise((resolve)=>{
-                    enqueue(function_, resolve, arguments_);
-                });
-            Object.defineProperties(generator, {
-                activeCount: {
-                    get: ()=>activeCount
-                },
-                pendingCount: {
-                    get: ()=>queue.size
-                },
-                clearQueue: {
-                    value () {
-                        queue.clear();
-                    }
-                },
-                concurrency: {
-                    get: ()=>concurrency,
-                    set (newConcurrency) {
-                        validateConcurrency(newConcurrency);
-                        concurrency = newConcurrency;
-                        queueMicrotask(()=>{
-                            while(activeCount < concurrency && queue.size > 0)resumeNext();
-                        });
-                    }
-                }
+            return `import { defineYamlBatchTest } from ${toImportLiteral(options.frameworkImport)};
+
+defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
+`;
+        };
+        const resolveDefaultFrameworkImport = ()=>{
+            const entry = process.argv[1] ? (0, external_node_path_.resolve)(process.argv[1]) : '';
+            const candidates = [
+                entry ? (0, external_node_path_.join)((0, external_node_path_.dirname)(entry), 'framework', 'index.js') : '',
+                entry ? (0, external_node_path_.join)((0, external_node_path_.dirname)(entry), '..', 'dist', 'lib', 'framework', 'index.js') : ''
+            ].filter(Boolean);
+            const matched = candidates.find((candidate)=>(0, external_node_fs_.existsSync)(candidate));
+            return matched || '@midscene/cli/dist/lib/framework/index.js';
+        };
+        function createRstestYamlProject(options) {
+            const projectDir = (0, external_node_path_.resolve)(options.projectDir || process.cwd());
+            const outputDir = options.outputDir || (0, external_node_path_.join)((0, common_namespaceObject.getMidsceneRunSubDir)('tmp'), `rstest-yaml-${Date.now()}`);
+            const resultDir = options.resultDir || (0, external_node_path_.join)(outputDir, 'results');
+            const frameworkImport = options.frameworkImport || resolveDefaultFrameworkImport();
+            const testTimeout = options.testTimeout ?? DEFAULT_YAML_TEST_TIMEOUT;
+            (0, external_node_fs_.rmSync)(outputDir, {
+                recursive: true,
+                force: true
             });
-            return generator;
-        }
-        function validateConcurrency(concurrency) {
-            if (!((Number.isInteger(concurrency) || concurrency === 1 / 0) && concurrency > 0)) throw new TypeError('Expected `concurrency` to be a number from 1 and up');
-        }
-        const external_puppeteer_namespaceObject = require("puppeteer");
-        var external_puppeteer_default = /*#__PURE__*/ __webpack_require__.n(external_puppeteer_namespaceObject);
-        const external_http_server_namespaceObject = require("http-server");
-        const external_node_assert_namespaceObject = require("node:assert");
-        var external_node_assert_default = /*#__PURE__*/ __webpack_require__.n(external_node_assert_namespaceObject);
-        const agent_namespaceObject = require("@midscene/core/agent");
-        const utils_namespaceObject = require("@midscene/core/utils");
-        const logger_namespaceObject = require("@midscene/shared/logger");
-        const bridge_mode_namespaceObject = require("@midscene/web/bridge-mode");
-        const debug = (0, logger_namespaceObject.getDebug)('create-yaml-player');
-        const launchServer = async (dir)=>new Promise((resolve)=>{
-                const server = (0, external_http_server_namespaceObject.createServer)({
-                    root: dir
-                });
-                server.listen(0, '127.0.0.1', ()=>{
-                    resolve(server);
+            (0, external_node_fs_.mkdirSync)(resultDir, {
+                recursive: true
+            });
+            const virtualModules = {};
+            const cases = options.files.map((file, index)=>{
+                const yamlFile = (0, external_node_path_.resolve)(file);
+                const testName = resolveTestName(projectDir, yamlFile);
+                const fileStem = safeFileStem(yamlFile, index);
+                const resultFile = (0, external_node_path_.join)(resultDir, `${fileStem}.json`);
+                const testModule = toVirtualModuleId(fileStem);
+                virtualModules[testModule] = createGeneratedTestContent({
+                    frameworkImport,
+                    yamlFile,
+                    resultFile,
+                    testName,
+                    caseOptions: options.caseOptions?.[yamlFile],
+                    webRuntimeOptions: options.webRuntimeOptions?.[yamlFile]
                 });
+                return {
+                    yamlFile,
+                    testModule,
+                    resultFile,
+                    testName
+                };
             });
-        function resolveReportFileName(yamlReportFileName, cliTestId, yamlTestId, fileName) {
-            const baseName = yamlReportFileName ?? cliTestId ?? yamlTestId ?? fileName;
-            return (0, agent_namespaceObject.getReportFileName)(baseName);
-        }
-        function buildAgentOptions(yamlAgent, reportFileName, fileName) {
+            if (options.batchConfig) {
+                const batchModule = 'virtual:midscene-yaml/batch.test.ts';
+                const resultFiles = Object.fromEntries(cases.map((item)=>[
+                        item.yamlFile,
+                        item.resultFile
+                    ]));
+                return {
+                    projectDir,
+                    outputDir,
+                    resultDir,
+                    include: [
+                        batchModule
+                    ],
+                    virtualModules: {
+                        [batchModule]: createGeneratedBatchTestContent({
+                            frameworkImport,
+                            testName: 'midscene yaml batch',
+                            config: options.batchConfig,
+                            resultFiles
+                        })
+                    },
+                    cases,
+                    maxConcurrency: 1,
+                    testTimeout,
+                    bail: options.bail
+                };
+            }
             return {
-                ...yamlAgent || {},
-                cache: (0, utils_namespaceObject.processCacheConfig)(yamlAgent?.cache, fileName),
-                reportFileName
+                projectDir,
+                outputDir,
+                resultDir,
+                include: cases.map((item)=>item.testModule),
+                virtualModules,
+                cases,
+                maxConcurrency: options.maxConcurrency,
+                testTimeout,
+                bail: options.bail
             };
         }
-        async function createYamlPlayer(file, script, options) {
-            const yamlScript = script || (0, yaml_namespaceObject.parseYamlScript)((0, external_node_fs_namespaceObject.readFileSync)(file, 'utf-8'), file);
-            const clonedYamlScript = structuredClone(yamlScript);
-            const fileName = (0, external_node_path_namespaceObject.basename)(file, (0, external_node_path_namespaceObject.extname)(file));
-            const preference = {
-                headed: options?.headed,
-                keepWindow: options?.keepWindow,
-                reportFileName: resolveReportFileName(clonedYamlScript.agent?.reportFileName, options?.testId, clonedYamlScript.agent?.testId, fileName)
-            };
-            const player = new yaml_namespaceObject.ScriptPlayer(clonedYamlScript, async ()=>{
-                const freeFn = [];
-                const webTarget = clonedYamlScript.web || clonedYamlScript.target;
-                const targetCount = [
-                    void 0 !== webTarget,
-                    void 0 !== clonedYamlScript.android,
-                    void 0 !== clonedYamlScript.ios,
-                    void 0 !== clonedYamlScript.computer,
-                    void 0 !== clonedYamlScript.interface
-                ].filter(Boolean).length;
-                if (targetCount > 1) {
-                    const specifiedTargets = [
-                        void 0 !== webTarget ? 'web' : null,
-                        void 0 !== clonedYamlScript.android ? 'android' : null,
-                        void 0 !== clonedYamlScript.ios ? 'ios' : null,
-                        void 0 !== clonedYamlScript.computer ? 'computer' : null,
-                        void 0 !== clonedYamlScript.interface ? 'interface' : null
-                    ].filter(Boolean);
-                    throw new Error(`Only one target type can be specified, but found multiple: ${specifiedTargets.join(', ')}. Please specify only one of: web, android, ios, computer, or interface.`);
-                }
-                if (void 0 !== webTarget) {
-                    if (void 0 !== clonedYamlScript.target) console.warn("target is deprecated, please use web instead. See https://midscenejs.com/automate-with-scripts-in-yaml for more information. Sorry for the inconvenience.");
-                    let localServer;
-                    let urlToVisit;
-                    if (webTarget.serve) {
-                        external_node_assert_default()('string' == typeof webTarget.url, 'url is required in serve mode');
-                        localServer = await launchServer(webTarget.serve);
-                        const serverAddress = localServer.server.address();
-                        freeFn.push({
-                            name: 'local_server',
-                            fn: ()=>localServer?.server.close()
-                        });
-                        urlToVisit = webTarget.url.startsWith('/') ? `http://${serverAddress?.address}:${serverAddress?.port}${webTarget.url}` : `http://${serverAddress?.address}:${serverAddress?.port}/${webTarget.url}`;
-                        webTarget.url = urlToVisit;
-                    }
-                    if (webTarget.cdpEndpoint && webTarget.bridgeMode) throw new Error('cdpEndpoint and bridgeMode are mutually exclusive. Please specify only one.');
-                    if (webTarget.cdpEndpoint) {
-                        const cdpBrowser = options?.browser ?? await external_puppeteer_default().connect({
-                            browserWSEndpoint: webTarget.cdpEndpoint,
-                            defaultViewport: null
-                        });
-                        if (webTarget.chromeArgs) console.warn('chromeArgs are not supported in CDP mode (browser is already running). They will be ignored.');
-                        const { agent, freeFn: newFreeFn } = await (0, puppeteer_agent_launcher_namespaceObject.puppeteerAgentForTarget)(webTarget, {
-                            ...preference,
-                            ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
-                        }, cdpBrowser, options?.page);
-                        const cleanFreeFn = newFreeFn.filter((f)=>'puppeteer_browser' !== f.name);
-                        if (!options?.browser) cleanFreeFn.push({
-                            name: 'cdp_browser_disconnect',
-                            fn: ()=>cdpBrowser.disconnect()
-                        });
-                        freeFn.push(...cleanFreeFn);
-                        return {
-                            agent,
-                            freeFn
-                        };
-                    }
-                    if (!webTarget.bridgeMode) {
-                        const { agent, freeFn: newFreeFn } = await (0, puppeteer_agent_launcher_namespaceObject.puppeteerAgentForTarget)(webTarget, {
-                            ...preference,
-                            ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
-                        }, options?.browser, options?.page);
-                        freeFn.push(...newFreeFn);
-                        return {
-                            agent,
-                            freeFn
-                        };
-                    }
-                    external_node_assert_default()('newTabWithUrl' === webTarget.bridgeMode || 'currentTab' === webTarget.bridgeMode, `bridgeMode config value must be either "newTabWithUrl" or "currentTab", but got ${webTarget.bridgeMode}`);
-                    if (webTarget.userAgent || null != webTarget.viewportWidth || null != webTarget.viewportHeight || null != webTarget.deviceScaleFactor || webTarget.waitForNetworkIdle || webTarget.cookie || webTarget.chromeArgs) console.warn('puppeteer options (userAgent, viewportWidth, viewportHeight, deviceScaleFactor, waitForNetworkIdle, cookie, chromeArgs) are not supported in bridge mode. They will be ignored.');
-                    const agent = new bridge_mode_namespaceObject.AgentOverChromeBridge({
-                        closeNewTabsAfterDisconnect: webTarget.closeNewTabsAfterDisconnect,
-                        closeConflictServer: true,
-                        ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
-                    });
-                    if ('newTabWithUrl' === webTarget.bridgeMode) await agent.connectNewTabWithUrl(webTarget.url);
-                    else {
-                        if (webTarget.url) console.warn('url will be ignored in bridge mode with "currentTab"');
-                        await agent.connectCurrentTab();
+        const external_node_module_namespaceObject = require("node:module");
+        var external_node_url_ = __webpack_require__("node:url");
+        const requireFromCliEntry = ()=>{
+            const entry = process.argv[1] ? (0, external_node_path_.resolve)(process.argv[1]) : (0, external_node_path_.join)(process.cwd(), 'midscene-cli.js');
+            return (0, external_node_module_namespaceObject.createRequire)(entry);
+        };
+        const resolvePackageFromRstestCore = (packageName)=>{
+            const require1 = requireFromCliEntry();
+            const rstestPackageJsonPath = require1.resolve('@rstest/core/package.json');
+            return (0, external_node_module_namespaceObject.createRequire)(rstestPackageJsonPath).resolve(packageName);
+        };
+        const formatRunError = (error)=>error.stack || `${error.name}: ${error.message}`;
+        async function runRstestYamlProject(options) {
+            const [{ runRstest }, { rspack }] = await Promise.all([
+                import("@rstest/core/api"),
+                import((0, external_node_url_.pathToFileURL)(resolvePackageFromRstestCore('@rsbuild/core')).href)
+            ]);
+            const { project } = options;
+            const maxConcurrency = void 0 !== project.maxConcurrency ? Math.max(1, project.maxConcurrency) : void 0;
+            const inlineConfig = {
+                root: project.projectDir,
+                include: project.include,
+                testEnvironment: 'node',
+                testTimeout: project.testTimeout,
+                ...void 0 !== maxConcurrency ? {
+                    maxConcurrency
+                } : {},
+                ...void 0 !== maxConcurrency ? {
+                    pool: {
+                        maxWorkers: maxConcurrency,
+                        minWorkers: maxConcurrency
+                    }
+                } : {},
+                ...void 0 !== project.bail ? {
+                    bail: project.bail
+                } : {},
+                reporters: [],
+                tools: {
+                    rspack: (_config, { appendPlugins })=>{
+                        appendPlugins(new rspack.experiments.VirtualModulesPlugin(project.virtualModules));
                     }
-                    freeFn.push({
-                        name: 'destroy_agent_over_chrome_bridge',
-                        fn: ()=>agent.destroy()
-                    });
-                    return {
-                        agent,
-                        freeFn
-                    };
-                }
-                if (void 0 !== clonedYamlScript.android) {
-                    const androidTarget = clonedYamlScript.android;
-                    const { agentFromAdbDevice } = await import("@midscene/android");
-                    const agent = await agentFromAdbDevice(androidTarget?.deviceId, {
-                        ...androidTarget,
-                        ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
-                    });
-                    if (androidTarget?.launch) await agent.launch(androidTarget.launch);
-                    freeFn.push({
-                        name: 'destroy_android_agent',
-                        fn: ()=>agent.destroy()
-                    });
-                    return {
-                        agent,
-                        freeFn
-                    };
-                }
-                if (void 0 !== clonedYamlScript.ios) {
-                    const iosTarget = clonedYamlScript.ios;
-                    const { agentFromWebDriverAgent } = await import("@midscene/ios");
-                    const agent = await agentFromWebDriverAgent({
-                        ...iosTarget,
-                        ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
-                    });
-                    if (iosTarget?.launch) await agent.launch(iosTarget.launch);
-                    freeFn.push({
-                        name: 'destroy_ios_agent',
-                        fn: ()=>agent.destroy()
-                    });
-                    return {
-                        agent,
-                        freeFn
-                    };
-                }
-                if (void 0 !== clonedYamlScript.computer) {
-                    const computerTarget = clonedYamlScript.computer;
-                    const { agentForComputer } = await import("@midscene/computer");
-                    const agent = await agentForComputer({
-                        ...computerTarget,
-                        ...buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName)
-                    });
-                    freeFn.push({
-                        name: 'destroy_computer_agent',
-                        fn: ()=>agent.destroy()
-                    });
-                    return {
-                        agent,
-                        freeFn
-                    };
                 }
-                if (void 0 !== clonedYamlScript.interface) {
-                    const interfaceTarget = clonedYamlScript.interface;
-                    const moduleSpecifier = interfaceTarget.module;
-                    let finalModuleSpecifier;
-                    if (moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../') || external_node_path_default().isAbsolute(moduleSpecifier)) {
-                        const resolvedPath = (0, external_node_path_namespaceObject.join)(process.cwd(), moduleSpecifier);
-                        finalModuleSpecifier = resolvedPath;
-                    } else finalModuleSpecifier = moduleSpecifier;
-                    debug('importing module config', interfaceTarget.module, 'with export config', interfaceTarget.export, 'final module specifier', finalModuleSpecifier);
-                    const importedModule = await import(finalModuleSpecifier);
-                    const DeviceClass = interfaceTarget.export ? importedModule[interfaceTarget.export] : importedModule.default || importedModule;
-                    debug('DeviceClass', DeviceClass, 'with param', interfaceTarget.param);
-                    const device = new DeviceClass(interfaceTarget.param || {});
-                    debug('creating agent from device', device);
-                    const agent = (0, agent_namespaceObject.createAgent)(device, buildAgentOptions(clonedYamlScript.agent, preference.reportFileName, fileName));
-                    freeFn.push({
-                        name: 'destroy_general_interface_agent',
-                        fn: ()=>{
-                            agent.destroy();
-                        }
-                    });
-                    return {
-                        agent,
-                        freeFn
-                    };
-                }
-                throw new Error('No valid interface configuration found in the yaml script, should be either "web", "android", "ios", "computer", or "interface"');
-            }, void 0, file);
-            return player;
-        }
-        var chalk_source = __webpack_require__("../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js");
-        var source_default = /*#__PURE__*/ __webpack_require__.n(chalk_source);
-        const isTTY = process.env.MIDSCENE_CLI_LOG_ON_NON_TTY ? false : process.stdout.isTTY;
-        const printer_indent = '  ';
-        const spinnerInterval = 80;
-        const spinnerFrames = [
-            '◰',
-            '◳',
-            '◲',
-            '◱'
-        ];
-        const currentSpinningFrame = ()=>spinnerFrames[Math.floor(Date.now() / spinnerInterval) % spinnerFrames.length];
-        function indicatorForStatus(status) {
-            if ('init' === status) return source_default().gray('◌');
-            if ('running' === status) return source_default().yellowBright(currentSpinningFrame());
-            if ('done' === status) return source_default().green('✔︎');
-            if ('error' === status) return source_default().red('✘');
-        }
-        const contextInfo = (context)=>{
-            const filePath = context.file;
-            const filePathToShow = (0, external_node_path_namespaceObject.relative)(process.cwd(), filePath);
-            const fileNameToPrint = `${source_default().gray(`${filePathToShow}`)}`;
-            const fileStatusText = indicatorForStatus(context.player.status);
-            const contextActionText = void 0 === context.player.currentTaskIndex && 'running' === context.player.status ? source_default().gray('(navigating)') : '';
-            const errorText = context.player.errorInSetup ? `\n${printer_indent}${source_default().red('error:')} ${context.player.errorInSetup?.message}\n${printer_indent}${printer_indent}${context.player.errorInSetup?.stack}` : '';
-            const outputFile = context.player.output;
-            const outputText = outputFile && Object.keys(context.player.result || {}).length > 0 ? `\n${printer_indent}${source_default().gray(`output: ${outputFile}`)}` : '';
-            const reportFile = context.player.reportFile;
-            const reportText = reportFile ? `\n${printer_indent}${source_default().gray(`report: ${reportFile}`)}` : '';
-            const agentStatusTip = context.player.agentStatusTip;
-            const agentStatusText = agentStatusTip ? `\n${printer_indent}${source_default().gray(`agent status: ${agentStatusTip}`)}` : '';
-            const mergedText = `${fileStatusText} ${fileNameToPrint} ${contextActionText}${outputText}${reportText}${errorText}${agentStatusText}`.trim();
-            return {
-                fileNameToPrint,
-                fileStatusText,
-                contextActionText,
-                outputText,
-                reportText,
-                mergedText
             };
-        };
-        const singleTaskInfo = (task)=>{
-            let stepText = '';
-            if ('init' === task.status) stepText = '';
-            else if ('running' === task.status || 'error' === task.status) if (void 0 === task.currentStep) stepText = source_default().gray('(navigating)');
-            else if ('number' == typeof task.currentStep) {
-                const actionText = '';
-                stepText = source_default().gray(`(task ${task.currentStep + 1}/${task.totalSteps}${actionText})`.trim());
-            } else stepText = source_default().gray('(unknown task)');
-            const errorText = 'error' === task.status ? `\n${printer_indent}${source_default().gray('error:')}\n${printer_indent}${printer_indent}${task.error?.message}` : '';
-            const statusText = indicatorForStatus(task.status);
-            const mergedLine = `${statusText} ${task.name} ${stepText}${errorText}`;
-            return {
-                nameText: task.name,
-                stepText,
-                errorText,
-                itemStatusText: statusText,
-                mergedLine
+            const result = await runRstest({
+                cwd: options.cwd || project.projectDir,
+                inlineConfig
+            });
+            if (!result.ok && 'pipe' !== options.stdio && result.unhandledErrors.length) console.error(result.unhandledErrors.map((error)=>formatRunError(error)).join('\n'));
+            return result.ok ? 0 : 1;
+        }
+        const createCaseOptions = (config)=>{
+            const caseOptions = {};
+            for (const file of config.files)caseOptions[(0, external_node_path_.resolve)(file)] = {
+                globalConfig: config.globalConfig
             };
+            return caseOptions;
         };
-        function paddingLines(lines) {
-            return lines.map((line)=>`${printer_indent}${line}`);
-        }
-        const contextTaskListSummary = (taskStatusArray, context)=>{
-            const prefixLines = [];
-            const currentLine = [];
-            const suffixText = [];
-            const { mergedText: fileInfo } = contextInfo(context);
-            if (!context.player.errorInSetup) for (const task of taskStatusArray){
-                const { mergedLine } = singleTaskInfo(task);
-                if ('init' === context.player.status) suffixText.push(mergedLine);
-                else if ('running' === context.player.status) currentLine.push(mergedLine);
-                else if ('done' === context.player.status) prefixLines.push(mergedLine);
-                else if ('error' === context.player.status) prefixLines.push(mergedLine);
-            }
-            const lines = [
-                fileInfo
-            ];
-            if (prefixLines.length > 0) lines.push(...paddingLines(prefixLines));
-            if (currentLine.length > 0) lines.push(...paddingLines(currentLine));
-            if (suffixText.length > 0) lines.push(...paddingLines(suffixText));
-            return lines.join('\n');
-        };
-        const external_node_util_namespaceObject = require("node:util");
-        const external_node_process_namespaceObject = require("node:process");
-        const copyProperty = (to, from, property, ignoreNonConfigurable)=>{
-            if ('length' === property || 'prototype' === property) return;
-            if ('arguments' === property || 'caller' === property) return;
-            const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
-            const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
-            if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) return;
-            Object.defineProperty(to, property, fromDescriptor);
-        };
-        const canCopyProperty = function(toDescriptor, fromDescriptor) {
-            return void 0 === toDescriptor || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
-        };
-        const changePrototype = (to, from)=>{
-            const fromPrototype = Object.getPrototypeOf(from);
-            if (fromPrototype === Object.getPrototypeOf(to)) return;
-            Object.setPrototypeOf(to, fromPrototype);
+        const createWebRuntimeOptions = (config, runtimeOptions)=>{
+            const caseOptions = {};
+            for (const file of config.files)caseOptions[(0, external_node_path_.resolve)(file)] = {
+                headed: runtimeOptions.headed ?? config.headed,
+                keepWindow: runtimeOptions.keepWindow ?? config.keepWindow
+            };
+            return caseOptions;
         };
-        const wrappedToString = (withName, fromBody)=>`/* Wrapped ${withName}*/\n${fromBody}`;
-        const toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, 'toString');
-        const toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, 'name');
-        const changeToString = (to, from, name)=>{
-            const withName = '' === name ? '' : `with ${name.trim()}() `;
-            const newToString = wrappedToString.bind(null, withName, from.toString());
-            Object.defineProperty(newToString, 'name', toStringName);
-            const { writable, enumerable, configurable } = toStringDescriptor;
-            Object.defineProperty(to, 'toString', {
-                value: newToString,
-                writable,
-                enumerable,
-                configurable
+        const readProjectResults = (project)=>project.cases.map((item)=>{
+                if ((0, external_node_fs_.existsSync)(item.resultFile)) return JSON.parse((0, external_node_fs_.readFileSync)(item.resultFile, 'utf8'));
+                return execution_summary_createNotExecutedYamlResult(item.yamlFile);
             });
-        };
-        function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
-            const { name } = to;
-            for (const property of Reflect.ownKeys(from))copyProperty(to, from, property, ignoreNonConfigurable);
-            changePrototype(to, from);
-            changeToString(to, from, name);
-            return to;
-        }
-        const calledFunctions = new WeakMap();
-        const onetime_onetime = (function_, options = {})=>{
-            if ('function' != typeof function_) throw new TypeError('Expected a function');
-            let returnValue;
-            let callCount = 0;
-            const functionName = function_.displayName || function_.name || '<anonymous>';
-            const onetime = function(...arguments_) {
-                calledFunctions.set(onetime, ++callCount);
-                if (1 === callCount) {
-                    returnValue = function_.apply(this, arguments_);
-                    function_ = void 0;
-                } else if (true === options.throw) throw new Error(`Function \`${functionName}\` can only be called once`);
-                return returnValue;
+        async function runFrameworkTestConfig(config, commandOptions = {}) {
+            execution_summary_printExecutionPlan(config);
+            const projectDir = (0, external_node_path_.resolve)(commandOptions.projectDir || process.cwd());
+            const project = createRstestYamlProject({
+                files: config.files,
+                projectDir,
+                outputDir: commandOptions.outputDir,
+                frameworkImport: commandOptions.frameworkImport,
+                caseOptions: createCaseOptions(config),
+                webRuntimeOptions: createWebRuntimeOptions(config, commandOptions),
+                maxConcurrency: commandOptions.concurrent ?? config.concurrent,
+                bail: config.continueOnError ? 0 : 1,
+                batchConfig: config.shareBrowserContext ? config : void 0
+            });
+            const runner = commandOptions.rstestRunner || runRstestYamlProject;
+            const exitCode = await runner({
+                project,
+                cwd: projectDir,
+                stdio: commandOptions.stdio
+            });
+            const results = readProjectResults(project);
+            const summaryPath = execution_summary_writeExecutionSummaryFile(config.summary, results);
+            execution_summary_printExecutionFinished();
+            const success = printExecutionSummary(results, summaryPath);
+            return success ? exitCode : 1;
+        }
+        require("@rstest/core");
+        __webpack_require__("@midscene/core/yaml");
+        require("@midscene/web/puppeteer-agent-launcher");
+        __webpack_require__("lodash.merge");
+        require("puppeteer");
+        require("http-server");
+        require("node:assert");
+        require("@midscene/core/agent");
+        require("@midscene/core/utils");
+        var logger_ = __webpack_require__("@midscene/shared/logger");
+        require("@midscene/web/bridge-mode");
+        (0, logger_.getDebug)('create-yaml-player');
+        __webpack_require__("../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js");
+        process.env.MIDSCENE_CLI_LOG_ON_NON_TTY || process.stdout.isTTY;
+        require("node:util");
+    },
+    "./src/index.ts" (__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+        "use strict";
+        var external_node_fs_ = __webpack_require__("node:fs");
+        var external_node_fs_namespaceObject = /*#__PURE__*/ __webpack_require__.t(external_node_fs_, 2);
+        var external_node_path_ = __webpack_require__("node:path");
+        const core_namespaceObject = require("@midscene/core");
+        const cli_namespaceObject = require("@midscene/shared/cli");
+        var main = __webpack_require__("../../node_modules/.pnpm/dotenv@16.4.5/node_modules/dotenv/lib/main.js");
+        var main_default = /*#__PURE__*/ __webpack_require__.n(main);
+        var package_namespaceObject = JSON.parse('{"rE":"1.8.8-beta-20260601092605.0"}');
+        var logger_ = __webpack_require__("@midscene/shared/logger");
+        const balanced = (a, b, str)=>{
+            const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+            const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+            const r = null !== ma && null != mb && range(ma, mb, str);
+            return r && {
+                start: r[0],
+                end: r[1],
+                pre: str.slice(0, r[0]),
+                body: str.slice(r[0] + ma.length, r[1]),
+                post: str.slice(r[1] + mb.length)
             };
-            mimicFunction(onetime, function_);
-            calledFunctions.set(onetime, callCount);
-            return onetime;
         };
-        onetime_onetime.callCount = (function_)=>{
-            if (!calledFunctions.has(function_)) throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
-            return calledFunctions.get(function_);
+        const maybeMatch = (reg, str)=>{
+            const m = str.match(reg);
+            return m ? m[0] : null;
         };
-        const node_modules_onetime = onetime_onetime;
-        const signals = [];
-        signals.push('SIGHUP', 'SIGINT', 'SIGTERM');
-        if ('win32' !== process.platform) signals.push('SIGALRM', 'SIGABRT', 'SIGVTALRM', 'SIGXCPU', 'SIGXFSZ', 'SIGUSR2', 'SIGTRAP', 'SIGSYS', 'SIGQUIT', 'SIGIOT');
-        if ('linux' === process.platform) signals.push('SIGIO', 'SIGPOLL', 'SIGPWR', 'SIGSTKFLT');
-        const processOk = (process1)=>!!process1 && 'object' == typeof process1 && 'function' == typeof process1.removeListener && 'function' == typeof process1.emit && 'function' == typeof process1.reallyExit && 'function' == typeof process1.listeners && 'function' == typeof process1.kill && 'number' == typeof process1.pid && 'function' == typeof process1.on;
-        const kExitEmitter = Symbol.for('signal-exit emitter');
-        const global = globalThis;
-        const ObjectDefineProperty = Object.defineProperty.bind(Object);
-        class Emitter {
-            emitted = {
-                afterExit: false,
-                exit: false
-            };
-            listeners = {
-                afterExit: [],
-                exit: []
-            };
-            count = 0;
-            id = Math.random();
-            constructor(){
-                if (global[kExitEmitter]) return global[kExitEmitter];
-                ObjectDefineProperty(global, kExitEmitter, {
-                    value: this,
-                    writable: false,
-                    enumerable: false,
-                    configurable: false
-                });
-            }
-            on(ev, fn) {
-                this.listeners[ev].push(fn);
-            }
-            removeListener(ev, fn) {
-                const list = this.listeners[ev];
-                const i = list.indexOf(fn);
-                if (-1 === i) return;
-                if (0 === i && 1 === list.length) list.length = 0;
-                else list.splice(i, 1);
-            }
-            emit(ev, code, signal) {
-                if (this.emitted[ev]) return false;
-                this.emitted[ev] = true;
-                let ret = false;
-                for (const fn of this.listeners[ev])ret = true === fn(code, signal) || ret;
-                if ('exit' === ev) ret = this.emit('afterExit', code, signal) || ret;
-                return ret;
-            }
-        }
-        class SignalExitBase {
-        }
-        const signalExitWrap = (handler)=>({
-                onExit (cb, opts) {
-                    return handler.onExit(cb, opts);
-                },
-                load () {
-                    return handler.load();
-                },
-                unload () {
-                    return handler.unload();
-                }
-            });
-        class SignalExitFallback extends SignalExitBase {
-            onExit() {
-                return ()=>{};
-            }
-            load() {}
-            unload() {}
-        }
-        class SignalExit extends SignalExitBase {
-            #hupSig = 'win32' === mjs_process.platform ? 'SIGINT' : 'SIGHUP';
-            #emitter = new Emitter();
-            #process;
-            #originalProcessEmit;
-            #originalProcessReallyExit;
-            #sigListeners = {};
-            #loaded = false;
-            constructor(process1){
-                super();
-                this.#process = process1;
-                this.#sigListeners = {};
-                for (const sig of signals)this.#sigListeners[sig] = ()=>{
-                    const listeners = this.#process.listeners(sig);
-                    let { count } = this.#emitter;
-                    const p = process1;
-                    if ('object' == typeof p.__signal_exit_emitter__ && 'number' == typeof p.__signal_exit_emitter__.count) count += p.__signal_exit_emitter__.count;
-                    if (listeners.length === count) {
-                        this.unload();
-                        const ret = this.#emitter.emit('exit', null, sig);
-                        const s = 'SIGHUP' === sig ? this.#hupSig : sig;
-                        if (!ret) process1.kill(process1.pid, s);
+        const range = (a, b, str)=>{
+            let begs, beg, left, right, result;
+            let ai = str.indexOf(a);
+            let bi = str.indexOf(b, ai + 1);
+            let i = ai;
+            if (ai >= 0 && bi > 0) {
+                if (a === b) return [
+                    ai,
+                    bi
+                ];
+                begs = [];
+                left = str.length;
+                while(i >= 0 && !result){
+                    if (i === ai) {
+                        begs.push(i);
+                        ai = str.indexOf(a, i + 1);
+                    } else if (1 === begs.length) {
+                        const r = begs.pop();
+                        if (void 0 !== r) result = [
+                            r,
+                            bi
+                        ];
+                    } else {
+                        beg = begs.pop();
+                        if (void 0 !== beg && beg < left) {
+                            left = beg;
+                            right = bi;
+                        }
+                        bi = str.indexOf(b, i + 1);
                     }
-                };
-                this.#originalProcessReallyExit = process1.reallyExit;
-                this.#originalProcessEmit = process1.emit;
-            }
-            onExit(cb, opts) {
-                if (!processOk(this.#process)) return ()=>{};
-                if (false === this.#loaded) this.load();
-                const ev = opts?.alwaysLast ? 'afterExit' : 'exit';
-                this.#emitter.on(ev, cb);
-                return ()=>{
-                    this.#emitter.removeListener(ev, cb);
-                    if (0 === this.#emitter.listeners['exit'].length && 0 === this.#emitter.listeners['afterExit'].length) this.unload();
-                };
-            }
-            load() {
-                if (this.#loaded) return;
-                this.#loaded = true;
-                this.#emitter.count += 1;
-                for (const sig of signals)try {
-                    const fn = this.#sigListeners[sig];
-                    if (fn) this.#process.on(sig, fn);
-                } catch (_) {}
-                this.#process.emit = (ev, ...a)=>this.#processEmit(ev, ...a);
-                this.#process.reallyExit = (code)=>this.#processReallyExit(code);
-            }
-            unload() {
-                if (!this.#loaded) return;
-                this.#loaded = false;
-                signals.forEach((sig)=>{
-                    const listener = this.#sigListeners[sig];
-                    if (!listener) throw new Error('Listener not defined for signal: ' + sig);
-                    try {
-                        this.#process.removeListener(sig, listener);
-                    } catch (_) {}
-                });
-                this.#process.emit = this.#originalProcessEmit;
-                this.#process.reallyExit = this.#originalProcessReallyExit;
-                this.#emitter.count -= 1;
-            }
-            #processReallyExit(code) {
-                if (!processOk(this.#process)) return 0;
-                this.#process.exitCode = code || 0;
-                this.#emitter.emit('exit', this.#process.exitCode, null);
-                return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
-            }
-            #processEmit(ev, ...args) {
-                const og = this.#originalProcessEmit;
-                if (!('exit' === ev && processOk(this.#process))) return og.call(this.#process, ev, ...args);
-                {
-                    if ('number' == typeof args[0]) this.#process.exitCode = args[0];
-                    const ret = og.call(this.#process, ev, ...args);
-                    this.#emitter.emit('exit', this.#process.exitCode, null);
-                    return ret;
+                    i = ai < bi && ai >= 0 ? ai : bi;
                 }
+                if (begs.length && void 0 !== right) result = [
+                    left,
+                    right
+                ];
             }
+            return result;
+        };
+        const escSlash = '\0SLASH' + Math.random() + '\0';
+        const escOpen = '\0OPEN' + Math.random() + '\0';
+        const escClose = '\0CLOSE' + Math.random() + '\0';
+        const escComma = '\0COMMA' + Math.random() + '\0';
+        const escPeriod = '\0PERIOD' + Math.random() + '\0';
+        const escSlashPattern = new RegExp(escSlash, 'g');
+        const escOpenPattern = new RegExp(escOpen, 'g');
+        const escClosePattern = new RegExp(escClose, 'g');
+        const escCommaPattern = new RegExp(escComma, 'g');
+        const escPeriodPattern = new RegExp(escPeriod, 'g');
+        const slashPattern = /\\\\/g;
+        const openPattern = /\\{/g;
+        const closePattern = /\\}/g;
+        const commaPattern = /\\,/g;
+        const periodPattern = /\\\./g;
+        const EXPANSION_MAX = 100000;
+        function numeric(str) {
+            return isNaN(str) ? str.charCodeAt(0) : parseInt(str, 10);
         }
-        const mjs_process = globalThis.process;
-        const { onExit, load, unload } = signalExitWrap(processOk(mjs_process) ? new SignalExit(mjs_process) : new SignalExitFallback());
-        const terminal = external_node_process_namespaceObject.stderr.isTTY ? external_node_process_namespaceObject.stderr : external_node_process_namespaceObject.stdout.isTTY ? external_node_process_namespaceObject.stdout : void 0;
-        const restoreCursor = terminal ? node_modules_onetime(()=>{
-            onExit(()=>{
-                terminal.write('\u001B[?25h');
-            }, {
-                alwaysLast: true
-            });
-        }) : ()=>{};
-        const restore_cursor = restoreCursor;
-        function _define_property(obj, key, value) {
-            if (key in obj) Object.defineProperty(obj, key, {
-                value: value,
-                enumerable: true,
-                configurable: true,
-                writable: true
-            });
-            else obj[key] = value;
-            return obj;
+        function escapeBraces(str) {
+            return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
         }
-        const DEFAULT_RENDER_INTERVAL = 160;
-        const ESC = '\x1B[';
-        const CLEAR_LINE = `${ESC}K`;
-        const MOVE_CURSOR_ONE_ROW_UP = `${ESC}1A`;
-        const HIDE_CURSOR = `${ESC}?25l`;
-        const SHOW_CURSOR = `${ESC}?25h`;
-        const SYNC_START = `${ESC}?2026h`;
-        const SYNC_END = `${ESC}?2026l`;
-        class TTYWindowRenderer {
-            start() {
-                this.finished = false;
-                this.renderInterval = setInterval(()=>this.flushBuffer(), this.options.interval);
-            }
-            stop() {
-                this.flushBuffer();
-                this.write(SHOW_CURSOR, 'output');
-                this.cleanups.splice(0).map((fn)=>fn());
-                clearInterval(this.renderInterval);
-            }
-            finish() {
-                this.finished = true;
-                this.flushBuffer();
-                clearInterval(this.renderInterval);
-            }
-            flushBuffer() {
-                if (0 === this.buffer.length) return this.render();
-                let current;
-                for (const next of this.buffer.splice(0)){
-                    if (!current) {
-                        current = next;
-                        continue;
-                    }
-                    if (current.type !== next.type) {
-                        this.render(current.message, current.type);
-                        current = next;
-                        continue;
-                    }
-                    current.message += next.message;
-                }
-                if (current) this.render(current?.message, current?.type);
-            }
-            render(message, type = 'output') {
-                if (this.finished) {
-                    this.clearWindow();
-                    return this.write(message || '', type);
-                }
-                const windowContent = this.options.getWindow();
-                const rowCount = getRenderedRowCount(windowContent, this.options.outputStream);
-                let padding = this.windowHeight - rowCount;
-                if (padding > 0 && message) padding -= getRenderedRowCount([
-                    message
-                ], this.options.outputStream);
-                this.write(SYNC_START);
-                this.clearWindow();
-                if (message) this.write(message, type);
-                if (padding > 0) this.write('\n'.repeat(padding));
-                this.write(windowContent.join('\n'));
-                this.write(SYNC_END);
-                this.windowHeight = rowCount + Math.max(0, padding);
-            }
-            clearWindow() {
-                if (0 === this.windowHeight) return;
-                this.write(CLEAR_LINE);
-                for(let i = 1; i < this.windowHeight; i++)this.write(`${MOVE_CURSOR_ONE_ROW_UP}${CLEAR_LINE}`);
-                this.windowHeight = 0;
-            }
-            interceptStream(stream, type) {
-                const original = stream.write;
-                stream.write = (chunk, _, callback)=>{
-                    if (chunk) if (this.finished) this.write(chunk.toString(), type);
-                    else this.buffer.push({
-                        type,
-                        message: chunk.toString()
-                    });
-                    callback?.();
-                };
-                return function() {
-                    stream.write = original;
-                };
-            }
-            write(message, type = 'output') {
-                this.streams[type](message);
-            }
-            constructor(options){
-                _define_property(this, "options", void 0);
-                _define_property(this, "streams", void 0);
-                _define_property(this, "buffer", []);
-                _define_property(this, "renderInterval", void 0);
-                _define_property(this, "windowHeight", 0);
-                _define_property(this, "finished", false);
-                _define_property(this, "cleanups", []);
-                this.options = {
-                    interval: DEFAULT_RENDER_INTERVAL,
-                    ...options
-                };
-                this.streams = {
-                    output: options.outputStream.write.bind(options.outputStream),
-                    error: options.errorStream.write.bind(options.errorStream)
-                };
-                this.cleanups.push(this.interceptStream(process.stdout, 'output'), this.interceptStream(process.stderr, 'error'));
-                restore_cursor();
-                this.write(HIDE_CURSOR, 'output');
-                this.start();
-            }
+        function unescapeBraces(str) {
+            return str.replace(escSlashPattern, '\\').replace(escOpenPattern, '{').replace(escClosePattern, '}').replace(escCommaPattern, ',').replace(escPeriodPattern, '.');
         }
-        function getRenderedRowCount(contents, stream) {
-            let count = 0;
-            const columns = 'columns' in stream ? stream.columns : 80;
-            for (const content of contents){
-                const rows = content.split('\n');
-                for (const row of rows){
-                    const text = (0, external_node_util_namespaceObject.stripVTControlCharacters)(row);
-                    count += Math.max(1, Math.ceil(text.length / columns));
-                }
+        function parseCommaParts(str) {
+            if (!str) return [
+                ''
+            ];
+            const parts = [];
+            const m = balanced('{', '}', str);
+            if (!m) return str.split(',');
+            const { pre, body, post } = m;
+            const p = pre.split(',');
+            p[p.length - 1] += '{' + body + '}';
+            const postParts = parseCommaParts(post);
+            if (post.length) {
+                p[p.length - 1] += postParts.shift();
+                p.push.apply(p, postParts);
             }
-            return count;
+            parts.push.apply(parts, p);
+            return parts;
         }
-        function batch_runner_define_property(obj, key, value) {
-            if (key in obj) Object.defineProperty(obj, key, {
-                value: value,
-                enumerable: true,
-                configurable: true,
-                writable: true
-            });
-            else obj[key] = value;
-            return obj;
+        function expand(str, options = {}) {
+            if (!str) return [];
+            const { max = EXPANSION_MAX } = options;
+            if ('{}' === str.slice(0, 2)) str = '\\{\\}' + str.slice(2);
+            return expand_(escapeBraces(str), max, true).map(unescapeBraces);
         }
-        class BatchRunner {
-            async run() {
-                const { keepWindow, headed } = this.config;
-                this.printExecutionPlan();
-                const fileContextList = [];
-                let browser = null;
-                let sharedPage = null;
-                try {
-                    for (const file of this.config.files){
-                        const fileConfig = await this.loadFileConfig(file);
-                        const context = await this.createFileContext(file, fileConfig, {
-                            headed,
-                            keepWindow
-                        });
-                        fileContextList.push(context);
-                    }
-                    const needsBrowser = fileContextList.some((ctx)=>Object.keys(ctx.executionConfig.web || ctx.executionConfig.target || {}).length > 0);
-                    if (needsBrowser && this.config.shareBrowserContext) {
-                        const globalWebConfig = this.config.globalConfig?.web;
-                        if (globalWebConfig?.cdpEndpoint) browser = await external_puppeteer_default().connect({
-                            browserWSEndpoint: globalWebConfig.cdpEndpoint,
-                            defaultViewport: null
-                        });
-                        else {
-                            const width = globalWebConfig?.viewportWidth ?? puppeteer_agent_launcher_namespaceObject.defaultViewportWidth;
-                            const height = globalWebConfig?.viewportHeight ?? puppeteer_agent_launcher_namespaceObject.defaultViewportHeight;
-                            const args = (0, puppeteer_agent_launcher_namespaceObject.buildChromeArgs)({
-                                userAgent: globalWebConfig?.userAgent,
-                                windowSize: headed ? {
-                                    width,
-                                    height
-                                } : void 0,
-                                chromeArgs: globalWebConfig?.chromeArgs
-                            });
-                            browser = await external_puppeteer_default().launch({
-                                headless: !headed,
-                                defaultViewport: headed ? null : {
-                                    width,
-                                    height
-                                },
-                                args,
-                                acceptInsecureCerts: globalWebConfig?.acceptInsecureCerts
-                            });
-                        }
-                        sharedPage = await browser.newPage();
-                        for (const context of fileContextList){
-                            context.options.browser = browser;
-                            context.options.page = sharedPage;
-                        }
-                    }
-                    const { executedResults, notExecutedContexts } = await this.executeFiles(fileContextList);
-                    this.results = await this.processResults(executedResults, notExecutedContexts);
-                } finally{
-                    if (browser && !this.config.keepWindow) {
-                        const isCdp = !!this.config.globalConfig?.web?.cdpEndpoint;
-                        if (isCdp) browser.disconnect();
-                        else await browser.close();
-                    }
-                    await this.generateOutputIndex();
-                }
-                return this.results;
-            }
-            async createFileContext(file, fileConfig, options) {
-                const { globalConfig } = this.config;
-                const clonedFileConfig = JSON.parse(JSON.stringify(fileConfig));
-                if (clonedFileConfig.target) {
-                    clonedFileConfig.web = {
-                        ...clonedFileConfig.target,
-                        ...clonedFileConfig.web
-                    };
-                    delete clonedFileConfig.target;
-                }
-                if (globalConfig?.target) {
-                    globalConfig.web = {
-                        ...globalConfig.target,
-                        ...globalConfig.web
-                    };
-                    delete globalConfig.target;
-                }
-                const executionConfig = external_lodash_merge_default()(clonedFileConfig, globalConfig);
-                return {
-                    file,
-                    executionConfig,
-                    options
-                };
-            }
-            async executeFiles(fileContextList) {
-                const executedResults = [];
-                const notExecutedContexts = [];
-                const allFileContexts = [];
-                for (const context of fileContextList){
-                    const player = await createYamlPlayer(context.file, context.executionConfig, context.options);
-                    allFileContexts.push({
-                        file: context.file,
-                        player
-                    });
-                }
-                let ttyRenderer;
-                if (isTTY) {
-                    const summaryContents = ()=>{
-                        const summary = [
-                            ''
-                        ];
-                        for (const context of allFileContexts)summary.push(contextTaskListSummary(context.player.taskStatusList, context));
-                        summary.push('');
-                        return summary;
-                    };
-                    ttyRenderer = new TTYWindowRenderer({
-                        outputStream: process.stdout,
-                        errorStream: process.stderr,
-                        getWindow: summaryContents,
-                        interval: spinnerInterval
-                    });
-                    ttyRenderer.start();
-                }
-                try {
-                    const executeFile = async (context)=>{
-                        const allFileContext = allFileContexts.find((c)=>c.file === context.file);
-                        if (!allFileContext) throw new Error(`Player not found for file: ${context.file}`);
-                        if (!isTTY) {
-                            const { mergedText } = contextInfo(allFileContext);
-                            console.log(mergedText);
-                        }
-                        if (context.outputPath) allFileContext.player.output = context.outputPath;
-                        const startTime = Date.now();
-                        await allFileContext.player.run();
-                        const endTime = Date.now();
-                        const duration = endTime - startTime;
-                        const executedContext = {
-                            file: context.file,
-                            player: allFileContext.player,
-                            duration
-                        };
-                        if (!isTTY) console.log(contextTaskListSummary(allFileContext.player.taskStatusList, executedContext));
-                        return executedContext;
-                    };
-                    await this.executeConcurrently(fileContextList, executeFile, executedResults, notExecutedContexts);
-                    if (!isTTY) {
-                        console.log('\n📋 Execution Results:');
-                        for (const context of executedResults)console.log(contextTaskListSummary(context.player.taskStatusList, context));
-                    }
-                } finally{
-                    if (ttyRenderer) ttyRenderer.stop();
-                }
-                return {
-                    executedResults,
-                    notExecutedContexts
-                };
+        function embrace(str) {
+            return '{' + str + '}';
+        }
+        function isPadded(el) {
+            return /^-?0\d/.test(el);
+        }
+        function lte(i, y) {
+            return i <= y;
+        }
+        function gte(i, y) {
+            return i >= y;
+        }
+        function expand_(str, max, isTop) {
+            const expansions = [];
+            const m = balanced('{', '}', str);
+            if (!m) return [
+                str
+            ];
+            const pre = m.pre;
+            const post = m.post.length ? expand_(m.post, max, false) : [
+                ''
+            ];
+            if (/\$$/.test(m.pre)) for(let k = 0; k < post.length && k < max; k++){
+                const expansion = pre + '{' + m.body + '}' + post[k];
+                expansions.push(expansion);
             }
-            async executeConcurrently(fileContextList, executeFile, executedResults, notExecutedContexts) {
-                const limit = pLimit(this.config.concurrent);
-                if (this.config.continueOnError) {
-                    const tasks = fileContextList.map((context)=>limit(async ()=>{
-                            const executedContext = await executeFile(context);
-                            executedResults.push(executedContext);
-                        }));
-                    await Promise.allSettled(tasks);
-                } else {
-                    let shouldStop = false;
-                    const stopLock = {
-                        value: false
-                    };
-                    const tasks = fileContextList.map((context)=>limit(async ()=>{
-                            if (stopLock.value) return void notExecutedContexts.push({
-                                file: context.file,
-                                player: null
-                            });
-                            const executedContext = await executeFile(context);
-                            executedResults.push(executedContext);
-                            if ('error' === executedContext.player.status && !stopLock.value) {
-                                stopLock.value = true;
-                                shouldStop = true;
-                            }
-                        }));
-                    await Promise.allSettled(tasks);
-                    if (shouldStop) {
-                        for (const context of fileContextList)if (!executedResults.some((r)=>r.file === context.file) && !notExecutedContexts.some((ctx)=>ctx.file === context.file)) notExecutedContexts.push({
-                            file: context.file,
-                            player: null
-                        });
+            else {
+                const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+                const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+                const isSequence = isNumericSequence || isAlphaSequence;
+                const isOptions = m.body.indexOf(',') >= 0;
+                if (!isSequence && !isOptions) {
+                    if (m.post.match(/,(?!,).*\}/)) {
+                        str = m.pre + '{' + m.body + escClose + m.post;
+                        return expand_(str, max, true);
                     }
+                    return [
+                        str
+                    ];
                 }
-            }
-            async processResults(executedContexts, notExecutedContexts) {
-                const results = [];
-                for (const context of executedContexts){
-                    const { file, player, duration } = context;
-                    const hasFailedTasks = player.taskStatusList?.some((task)=>'error' === task.status) ?? false;
-                    const hasPlayerError = 'error' === player.status;
-                    let success;
-                    let resultType;
-                    if (hasPlayerError) {
-                        success = false;
-                        resultType = 'failed';
-                    } else if (hasFailedTasks) {
-                        success = false;
-                        resultType = 'partialFailed';
-                    } else {
-                        success = true;
-                        resultType = 'success';
-                    }
-                    let reportFile;
-                    if (player.reportFile) reportFile = player.reportFile;
-                    let outputPath = player.output || void 0;
-                    if (outputPath && !(0, external_node_fs_namespaceObject.existsSync)(outputPath)) outputPath = void 0;
-                    let errorMessage;
-                    if (player.errorInSetup?.message) errorMessage = player.errorInSetup.message;
-                    else if (hasPlayerError || hasFailedTasks) {
-                        const taskErrors = player.taskStatusList?.filter((task)=>'error' === task.status && task.error?.message).map((task)=>task.error.message);
-                        errorMessage = taskErrors && taskErrors.length > 0 ? taskErrors.join('; ') : hasPlayerError ? 'Execution failed' : 'Some tasks failed';
-                    }
-                    results.push({
-                        file,
-                        success,
-                        executed: true,
-                        output: outputPath,
-                        report: reportFile,
-                        duration,
-                        resultType,
-                        error: errorMessage
-                    });
-                }
-                for (const context of notExecutedContexts)results.push({
-                    file: context.file,
-                    success: false,
-                    executed: false,
-                    output: void 0,
-                    report: void 0,
-                    duration: 0,
-                    resultType: 'notExecuted',
-                    error: 'Not executed (previous task failed)'
-                });
-                return results;
-            }
-            async loadFileConfig(file) {
-                const content = (0, external_node_fs_namespaceObject.readFileSync)(file, 'utf8');
-                return (0, yaml_namespaceObject.parseYamlScript)(content, file);
-            }
-            getSummaryAbsolutePath() {
-                return (0, external_node_path_namespaceObject.resolve)((0, common_namespaceObject.getMidsceneRunSubDir)('output'), this.config.summary);
-            }
-            printExecutionPlan() {
-                console.log('   Scripts:');
-                for (const file of this.config.files)console.log(`     - ${file}`);
-                console.log('📋 Execution plan');
-                console.log(`   Concurrency: ${this.config.concurrent}`);
-                console.log(`   Keep window: ${this.config.keepWindow}`);
-                console.log(`   Headed: ${this.config.headed}`);
-                console.log(`   Continue on error: ${this.config.continueOnError}`);
-                console.log(`   Share browser context: ${this.config.shareBrowserContext ?? false}`);
-                console.log(`   Summary output: ${this.config.summary}`);
-            }
-            async generateOutputIndex() {
-                const indexPath = (0, external_node_path_namespaceObject.resolve)((0, common_namespaceObject.getMidsceneRunSubDir)('output'), this.config.summary);
-                const outputDir = (0, external_node_path_namespaceObject.dirname)(indexPath);
-                try {
-                    (0, external_node_fs_namespaceObject.mkdirSync)(outputDir, {
-                        recursive: true
-                    });
-                    const indexData = {
-                        summary: {
-                            total: this.results.length,
-                            successful: this.results.filter((r)=>'success' === r.resultType).length,
-                            failed: this.results.filter((r)=>'failed' === r.resultType).length,
-                            partialFailed: this.results.filter((r)=>'partialFailed' === r.resultType).length,
-                            notExecuted: this.results.filter((r)=>'notExecuted' === r.resultType).length,
-                            totalDuration: this.results.reduce((sum, r)=>sum + (r.duration || 0), 0),
-                            generatedAt: new Date().toLocaleString()
-                        },
-                        results: this.results.map((result)=>({
-                                script: (0, external_node_path_namespaceObject.relative)(outputDir, result.file),
-                                success: result.success,
-                                resultType: result.resultType,
-                                output: result.output ? (()=>{
-                                    const relativePath = (0, external_node_path_namespaceObject.relative)(outputDir, result.output);
-                                    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
-                                })() : void 0,
-                                report: result.report ? (0, external_node_path_namespaceObject.relative)(outputDir, result.report) : void 0,
-                                error: result.error,
-                                duration: result.duration
-                            }))
-                    };
-                    (0, external_node_fs_namespaceObject.writeFileSync)(indexPath, JSON.stringify(indexData, null, 2));
-                    console.log('Execution finished:');
-                } catch (error) {
-                    console.error('Failed to generate output index:', error);
-                }
-            }
-            getExecutionSummary() {
-                const successful = this.results.filter((r)=>'success' === r.resultType).length;
-                const failed = this.results.filter((r)=>'failed' === r.resultType).length;
-                const partialFailed = this.results.filter((r)=>'partialFailed' === r.resultType).length;
-                const notExecuted = this.results.filter((r)=>'notExecuted' === r.resultType).length;
-                return {
-                    total: this.results.length,
-                    successful,
-                    failed,
-                    partialFailed,
-                    notExecuted,
-                    totalDuration: this.results.reduce((sum, r)=>sum + (r.duration || 0), 0)
-                };
-            }
-            getFailedFiles() {
-                return this.results.filter((r)=>'failed' === r.resultType).map((r)=>r.file);
-            }
-            getPartialFailedFiles() {
-                return this.results.filter((r)=>'partialFailed' === r.resultType).map((r)=>r.file);
-            }
-            getNotExecutedFiles() {
-                return this.results.filter((r)=>'notExecuted' === r.resultType).map((r)=>r.file);
-            }
-            getSuccessfulFiles() {
-                return this.results.filter((r)=>'success' === r.resultType).map((r)=>r.file);
-            }
-            getResults() {
-                return [
-                    ...this.results
-                ];
-            }
-            printExecutionSummary() {
-                const summary = this.getExecutionSummary();
-                const success = 0 === summary.failed && 0 === summary.partialFailed && 0 === summary.notExecuted;
-                console.log('\n📊 Execution Summary:');
-                console.log(`   Total files: ${summary.total}`);
-                console.log(`   Successful: ${summary.successful}`);
-                console.log(`   Failed: ${summary.failed}`);
-                console.log(`   Partial failed: ${summary.partialFailed}`);
-                console.log(`   Not executed: ${summary.notExecuted}`);
-                console.log(`   Duration: ${(summary.totalDuration / 1000).toFixed(2)}s`);
-                console.log(`   Summary: ${this.getSummaryAbsolutePath()}`);
-                if (summary.successful > 0) {
-                    console.log('\n✅ Successful files:');
-                    this.getSuccessfulFiles().forEach((file)=>{
-                        console.log(`   ${file}`);
-                    });
-                }
-                if (summary.failed > 0) {
-                    console.log('\n❌ Failed files');
-                    this.getFailedFiles().forEach((file)=>{
-                        console.log(`   ${file}`);
-                    });
-                }
-                if (summary.partialFailed > 0) {
-                    console.log('\n⚠️  Partial failed files (some tasks failed with continueOnError)');
-                    this.getPartialFailedFiles().forEach((file)=>{
-                        console.log(`   ${file}`);
-                    });
+                let n;
+                if (isSequence) n = m.body.split(/\.\./);
+                else {
+                    n = parseCommaParts(m.body);
+                    if (1 === n.length && void 0 !== n[0]) {
+                        n = expand_(n[0], max, false).map(embrace);
+                        if (1 === n.length) return post.map((p)=>m.pre + n[0] + p);
+                    }
+                }
+                let N;
+                if (isSequence && void 0 !== n[0] && void 0 !== n[1]) {
+                    const x = numeric(n[0]);
+                    const y = numeric(n[1]);
+                    const width = Math.max(n[0].length, n[1].length);
+                    let incr = 3 === n.length && void 0 !== n[2] ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
+                    let test = lte;
+                    const reverse = y < x;
+                    if (reverse) {
+                        incr *= -1;
+                        test = gte;
+                    }
+                    const pad = n.some(isPadded);
+                    N = [];
+                    for(let i = x; test(i, y); i += incr){
+                        let c;
+                        if (isAlphaSequence) {
+                            c = String.fromCharCode(i);
+                            if ('\\' === c) c = '';
+                        } else {
+                            c = String(i);
+                            if (pad) {
+                                const need = width - c.length;
+                                if (need > 0) {
+                                    const z = new Array(need + 1).join('0');
+                                    c = i < 0 ? '-' + z + c.slice(1) : z + c;
+                                }
+                            }
+                        }
+                        N.push(c);
+                    }
+                } else {
+                    N = [];
+                    for(let j = 0; j < n.length; j++)N.push.apply(N, expand_(n[j], max, false));
                 }
-                if (summary.notExecuted > 0) {
-                    console.log('\n⏸️ Not executed files');
-                    this.getNotExecutedFiles().forEach((file)=>{
-                        console.log(`   ${file}`);
-                    });
+                for(let j = 0; j < N.length; j++)for(let k = 0; k < post.length && expansions.length < max; k++){
+                    const expansion = pre + N[j] + post[k];
+                    if (!isTop || isSequence || expansion) expansions.push(expansion);
                 }
-                if (success) console.log('\n🎉 All files executed successfully!');
-                else console.log('\n⚠️ Some files failed or were not executed.');
-                return success;
-            }
-            constructor(config){
-                batch_runner_define_property(this, "config", void 0);
-                batch_runner_define_property(this, "results", []);
-                this.config = config;
             }
+            return expansions;
         }
-        var brace_expansion = __webpack_require__("../../node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js");
         const MAX_PATTERN_LENGTH = 65536;
         const assertValidPattern = (pattern)=>{
             if ('string' != typeof pattern) throw new TypeError('invalid pattern');
@@ -4319,7 +3542,11 @@ var __webpack_modules__ = {
                 true
             ];
         };
-        const unescape_unescape = (s, { windowsPathsNoEscape = false } = {})=>windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, '$1') : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, '$1$2').replace(/\\([^\/])/g, '$1');
+        const unescape_unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {})=>{
+            if (magicalBraces) return windowsPathsNoEscape ? s.replace(/\[([^/\\])\]/g, '$1') : s.replace(/((?!\\).|^)\[([^/\\])\]/g, '$1$2').replace(/\\([^/])/g, '$1');
+            return windowsPathsNoEscape ? s.replace(/\[([^/\\{}])\]/g, '$1') : s.replace(/((?!\\).|^)\[([^/\\{}])\]/g, '$1$2').replace(/\\([^/{}])/g, '$1');
+        };
+        var ast_a;
         const types = new Set([
             '!',
             '?',
@@ -4328,6 +3555,168 @@ var __webpack_modules__ = {
             '@'
         ]);
         const isExtglobType = (c)=>types.has(c);
+        const isExtglobAST = (c)=>isExtglobType(c.type);
+        const adoptionMap = new Map([
+            [
+                '!',
+                [
+                    '@'
+                ]
+            ],
+            [
+                '?',
+                [
+                    '?',
+                    '@'
+                ]
+            ],
+            [
+                '@',
+                [
+                    '@'
+                ]
+            ],
+            [
+                '*',
+                [
+                    '*',
+                    '+',
+                    '?',
+                    '@'
+                ]
+            ],
+            [
+                '+',
+                [
+                    '+',
+                    '@'
+                ]
+            ]
+        ]);
+        const adoptionWithSpaceMap = new Map([
+            [
+                '!',
+                [
+                    '?'
+                ]
+            ],
+            [
+                '@',
+                [
+                    '?'
+                ]
+            ],
+            [
+                '+',
+                [
+                    '?',
+                    '*'
+                ]
+            ]
+        ]);
+        const adoptionAnyMap = new Map([
+            [
+                '!',
+                [
+                    '?',
+                    '@'
+                ]
+            ],
+            [
+                '?',
+                [
+                    '?',
+                    '@'
+                ]
+            ],
+            [
+                '@',
+                [
+                    '?',
+                    '@'
+                ]
+            ],
+            [
+                '*',
+                [
+                    '*',
+                    '+',
+                    '?',
+                    '@'
+                ]
+            ],
+            [
+                '+',
+                [
+                    '+',
+                    '@',
+                    '?',
+                    '*'
+                ]
+            ]
+        ]);
+        const usurpMap = new Map([
+            [
+                '!',
+                new Map([
+                    [
+                        '!',
+                        '@'
+                    ]
+                ])
+            ],
+            [
+                '?',
+                new Map([
+                    [
+                        '*',
+                        '*'
+                    ],
+                    [
+                        '+',
+                        '*'
+                    ]
+                ])
+            ],
+            [
+                '@',
+                new Map([
+                    [
+                        '!',
+                        '!'
+                    ],
+                    [
+                        '?',
+                        '?'
+                    ],
+                    [
+                        '@',
+                        '@'
+                    ],
+                    [
+                        '*',
+                        '*'
+                    ],
+                    [
+                        '+',
+                        '+'
+                    ]
+                ])
+            ],
+            [
+                '+',
+                new Map([
+                    [
+                        '?',
+                        '*'
+                    ],
+                    [
+                        '*',
+                        '*'
+                    ]
+                ])
+            ]
+        ]);
         const startNoTraversal = '(?!(?:^|/)\\.\\.?(?:$|/))';
         const startNoDot = '(?!\\.)';
         const addPatternStart = new Set([
@@ -4343,6 +3732,7 @@ var __webpack_modules__ = {
         const qmark = '[^/]';
         const star = qmark + '*?';
         const starNoEmpty = qmark + '+?';
+        let ID = 0;
         class ast_AST {
             type;
             #root;
@@ -4356,6 +3746,22 @@ var __webpack_modules__ = {
             #options;
             #toString;
             #emptyExt = false;
+            id = ++ID;
+            get depth() {
+                return (this.#parent?.depth ?? -1) + 1;
+            }
+            [Symbol.for('nodejs.util.inspect.custom')]() {
+                return {
+                    '@@type': 'AST',
+                    id: this.id,
+                    type: this.type,
+                    root: this.#root.id,
+                    parent: this.#parent?.id,
+                    depth: this.depth,
+                    partsLength: this.#parts.length,
+                    parts: this.#parts
+                };
+            }
             constructor(type, parent, options = {}){
                 this.type = type;
                 if (type) this.#hasMagic = true;
@@ -4374,9 +3780,7 @@ var __webpack_modules__ = {
                 return this.#hasMagic;
             }
             toString() {
-                if (void 0 !== this.#toString) return this.#toString;
-                if (!this.type) return this.#toString = this.#parts.map((p)=>String(p)).join('');
-                return this.#toString = this.type + '(' + this.#parts.map((p)=>String(p)).join('|') + ')';
+                return void 0 !== this.#toString ? this.#toString : this.type ? this.#toString = this.type + '(' + this.#parts.map((p)=>String(p)).join('|') + ')' : this.#toString = this.#parts.map((p)=>String(p)).join('');
             }
             #fillNegs() {
                 if (this !== this.#root) throw new Error('should only call on root');
@@ -4401,7 +3805,7 @@ var __webpack_modules__ = {
             }
             push(...parts) {
                 for (const p of parts)if ('' !== p) {
-                    if ('string' != typeof p && !(p instanceof ast_AST && p.#parent === this)) throw new Error('invalid part: ' + p);
+                    if ('string' != typeof p && !(p instanceof ast_a && p.#parent === this)) throw new Error('invalid part: ' + p);
                     this.#parts.push(p);
                 }
             }
@@ -4421,7 +3825,7 @@ var __webpack_modules__ = {
                 const p = this.#parent;
                 for(let i = 0; i < this.#parentIndex; i++){
                     const pp = p.#parts[i];
-                    if (!(pp instanceof ast_AST && '!' === pp.type)) return false;
+                    if (!(pp instanceof ast_a && '!' === pp.type)) return false;
                 }
                 return true;
             }
@@ -4438,11 +3842,12 @@ var __webpack_modules__ = {
                 else this.push(part.clone(this));
             }
             clone(parent) {
-                const c = new ast_AST(this.type, parent);
+                const c = new ast_a(this.type, parent);
                 for (const p of this.#parts)c.copyIn(p);
                 return c;
             }
-            static #parseAST(str, ast, pos, opt) {
+            static #parseAST(str, ast, pos, opt, extDepth) {
+                const maxDepth = opt.maxExtglobRecursion ?? 2;
                 let escaping = false;
                 let inBrace = false;
                 let braceStart = -1;
@@ -4471,11 +3876,12 @@ var __webpack_modules__ = {
                             acc += c;
                             continue;
                         }
-                        if (!opt.noext && isExtglobType(c) && '(' === str.charAt(i)) {
+                        const doRecurse = !opt.noext && isExtglobType(c) && '(' === str.charAt(i) && extDepth <= maxDepth;
+                        if (doRecurse) {
                             ast.push(acc);
                             acc = '';
-                            const ext = new ast_AST(c, ast);
-                            i = ast_AST.#parseAST(str, ext, i, opt);
+                            const ext = new ast_a(c, ast);
+                            i = ast_a.#parseAST(str, ext, i, opt, extDepth + 1);
                             ast.push(ext);
                             continue;
                         }
@@ -4485,7 +3891,7 @@ var __webpack_modules__ = {
                     return i;
                 }
                 let i = pos + 1;
-                let part = new ast_AST(null, ast);
+                let part = new ast_a(null, ast);
                 const parts = [];
                 let acc = '';
                 while(i < str.length){
@@ -4509,19 +3915,21 @@ var __webpack_modules__ = {
                         acc += c;
                         continue;
                     }
-                    if (isExtglobType(c) && '(' === str.charAt(i)) {
+                    const doRecurse = !opt.noext && isExtglobType(c) && '(' === str.charAt(i) && (extDepth <= maxDepth || ast && ast.#canAdoptType(c));
+                    if (doRecurse) {
+                        const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
                         part.push(acc);
                         acc = '';
-                        const ext = new ast_AST(c, part);
+                        const ext = new ast_a(c, part);
                         part.push(ext);
-                        i = ast_AST.#parseAST(str, ext, i, opt);
+                        i = ast_a.#parseAST(str, ext, i, opt, extDepth + depthAdd);
                         continue;
                     }
                     if ('|' === c) {
                         part.push(acc);
                         acc = '';
                         parts.push(part);
-                        part = new ast_AST(null, ast);
+                        part = new ast_a(null, ast);
                         continue;
                     }
                     if (')' === c) {
@@ -4540,9 +3948,55 @@ var __webpack_modules__ = {
                 ];
                 return i;
             }
+            #canAdoptWithSpace(child) {
+                return this.#canAdopt(child, adoptionWithSpaceMap);
+            }
+            #canAdopt(child, map = adoptionMap) {
+                if (!child || 'object' != typeof child || null !== child.type || 1 !== child.#parts.length || null === this.type) return false;
+                const gc = child.#parts[0];
+                if (!gc || 'object' != typeof gc || null === gc.type) return false;
+                return this.#canAdoptType(gc.type, map);
+            }
+            #canAdoptType(c, map = adoptionAnyMap) {
+                return !!map.get(this.type)?.includes(c);
+            }
+            #adoptWithSpace(child, index) {
+                const gc = child.#parts[0];
+                const blank = new ast_a(null, gc, this.options);
+                blank.#parts.push('');
+                gc.push(blank);
+                this.#adopt(child, index);
+            }
+            #adopt(child, index) {
+                const gc = child.#parts[0];
+                this.#parts.splice(index, 1, ...gc.#parts);
+                for (const p of gc.#parts)if ('object' == typeof p) p.#parent = this;
+                this.#toString = void 0;
+            }
+            #canUsurpType(c) {
+                const m = usurpMap.get(this.type);
+                return !!m?.has(c);
+            }
+            #canUsurp(child) {
+                if (!child || 'object' != typeof child || null !== child.type || 1 !== child.#parts.length || null === this.type || 1 !== this.#parts.length) return false;
+                const gc = child.#parts[0];
+                if (!gc || 'object' != typeof gc || null === gc.type) return false;
+                return this.#canUsurpType(gc.type);
+            }
+            #usurp(child) {
+                const m = usurpMap.get(this.type);
+                const gc = child.#parts[0];
+                const nt = m?.get(gc.type);
+                if (!nt) return false;
+                this.#parts = gc.#parts;
+                for (const p of this.#parts)if ('object' == typeof p) p.#parent = this;
+                this.type = nt;
+                this.#toString = void 0;
+                this.#emptyExt = false;
+            }
             static fromGlob(pattern, options = {}) {
-                const ast = new ast_AST(null, void 0, options);
-                ast_AST.#parseAST(pattern, ast, 0, options);
+                const ast = new ast_a(null, void 0, options);
+                ast_a.#parseAST(pattern, ast, 0, options, 0);
                 return ast;
             }
             toMMPattern() {
@@ -4562,11 +4016,14 @@ var __webpack_modules__ = {
             }
             toRegExpSource(allowDot) {
                 const dot = allowDot ?? !!this.#options.dot;
-                if (this.#root === this) this.#fillNegs();
-                if (!this.type) {
-                    const noEmpty = this.isStart() && this.isEnd();
+                if (this.#root === this) {
+                    this.#flatten();
+                    this.#fillNegs();
+                }
+                if (!isExtglobAST(this)) {
+                    const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s)=>'string' != typeof s);
                     const src = this.#parts.map((p)=>{
-                        const [re, _, hasMagic, uflag] = 'string' == typeof p ? ast_AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+                        const [re, _, hasMagic, uflag] = 'string' == typeof p ? ast_a.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
                         this.#hasMagic = this.#hasMagic || hasMagic;
                         this.#uflag = this.#uflag || uflag;
                         return re;
@@ -4598,11 +4055,12 @@ var __webpack_modules__ = {
                 let body = this.#partsToRegExp(dot);
                 if (this.isStart() && this.isEnd() && !body && '!' !== this.type) {
                     const s = this.toString();
-                    this.#parts = [
+                    const me = this;
+                    me.#parts = [
                         s
                     ];
-                    this.type = null;
-                    this.#hasMagic = void 0;
+                    me.type = null;
+                    me.#hasMagic = void 0;
                     return [
                         s,
                         unescape_unescape(this.toString()),
@@ -4626,6 +4084,32 @@ var __webpack_modules__ = {
                     this.#uflag
                 ];
             }
+            #flatten() {
+                if (isExtglobAST(this)) {
+                    let iterations = 0;
+                    let done = false;
+                    do {
+                        done = true;
+                        for(let i = 0; i < this.#parts.length; i++){
+                            const c = this.#parts[i];
+                            if ('object' == typeof c) {
+                                c.#flatten();
+                                if (this.#canAdopt(c)) {
+                                    done = false;
+                                    this.#adopt(c, i);
+                                } else if (this.#canAdoptWithSpace(c)) {
+                                    done = false;
+                                    this.#adoptWithSpace(c, i);
+                                } else if (this.#canUsurp(c)) {
+                                    done = false;
+                                    this.#usurp(c);
+                                }
+                            }
+                        }
+                    }while (!done && ++iterations < 10);
+                } else for (const p of this.#parts)if ('object' == typeof p) p.#flatten();
+                this.#toString = void 0;
+            }
             #partsToRegExp(dot) {
                 return this.#parts.map((p)=>{
                     if ('string' == typeof p) throw new Error('string type in extglob ast??');
@@ -4638,6 +4122,7 @@ var __webpack_modules__ = {
                 let escaping = false;
                 let re = '';
                 let uflag = false;
+                let inStar = false;
                 for(let i = 0; i < glob.length; i++){
                     const c = glob.charAt(i);
                     if (escaping) {
@@ -4645,6 +4130,14 @@ var __webpack_modules__ = {
                         re += (reSpecials.has(c) ? '\\' : '') + c;
                         continue;
                     }
+                    if ('*' === c) {
+                        if (inStar) continue;
+                        inStar = true;
+                        re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star;
+                        hasMagic = true;
+                        continue;
+                    }
+                    inStar = false;
                     if ('\\' === c) {
                         if (i === glob.length - 1) re += '\\\\';
                         else escaping = true;
@@ -4660,12 +4153,6 @@ var __webpack_modules__ = {
                             continue;
                         }
                     }
-                    if ('*' === c) {
-                        if (noEmpty && '*' === glob) re += starNoEmpty;
-                        else re += star;
-                        hasMagic = true;
-                        continue;
-                    }
                     if ('?' === c) {
                         re += qmark;
                         hasMagic = true;
@@ -4681,13 +4168,17 @@ var __webpack_modules__ = {
                 ];
             }
         }
-        const escape_escape = (s, { windowsPathsNoEscape = false } = {})=>windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, '[$&]') : s.replace(/[?*()[\]\\]/g, '\\$&');
+        ast_a = ast_AST;
+        const escape_escape = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {})=>{
+            if (magicalBraces) return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, '[$&]') : s.replace(/[?*()[\]\\{}]/g, '\\$&');
+            return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, '[$&]') : s.replace(/[?*()[\]\\]/g, '\\$&');
+        };
         const minimatch = (p, pattern, options = {})=>{
             assertValidPattern(pattern);
             if (!options.nocomment && '#' === pattern.charAt(0)) return false;
             return new esm_Minimatch(pattern, options).match(p);
         };
-        const starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+        const starDotExtRE = /^\*+([^+@!?*[(]*)$/;
         const starDotExtTest = (ext)=>(f)=>!f.startsWith('.') && f.endsWith(ext);
         const starDotExtTestDot = (ext)=>(f)=>f.endsWith(ext);
         const starDotExtTestNocase = (ext)=>{
@@ -4706,7 +4197,7 @@ var __webpack_modules__ = {
         const starRE = /^\*+$/;
         const starTest = (f)=>0 !== f.length && !f.startsWith('.');
         const starTestDot = (f)=>0 !== f.length && '.' !== f && '..' !== f;
-        const qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+        const qmarksRE = /^\?+([^+@!?*[(]*)?$/;
         const qmarksTestNocase = ([$0, ext = ''])=>{
             const noext = qmarksTestNoExt([
                 $0
@@ -4801,7 +4292,9 @@ var __webpack_modules__ = {
             if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) return [
                 pattern
             ];
-            return brace_expansion(pattern);
+            return expand(pattern, {
+                max: options.braceExpandMax
+            });
         };
         minimatch.braceExpand = braceExpand;
         const makeRe = (pattern, options = {})=>new esm_Minimatch(pattern, options).makeRe();
@@ -4832,15 +4325,18 @@ var __webpack_modules__ = {
             isWindows;
             platform;
             windowsNoMagicRoot;
+            maxGlobstarRecursion;
             regexp;
             constructor(pattern, options = {}){
                 assertValidPattern(pattern);
                 options = options || {};
                 this.options = options;
+                this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
                 this.pattern = pattern;
                 this.platform = options.platform || defaultPlatform;
                 this.isWindows = 'win32' === this.platform;
-                this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || false === options.allowWindowsEscape;
+                const awe = "allowWindowsEscape";
+                this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || false === options[awe];
                 if (this.windowsPathsNoEscape) this.pattern = this.pattern.replace(/\\/g, '/');
                 this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
                 this.regexp = null;
@@ -4907,7 +4403,7 @@ var __webpack_modules__ = {
             }
             preprocess(globParts) {
                 if (this.options.noglobstar) {
-                    for(let i = 0; i < globParts.length; i++)for(let j = 0; j < globParts[i].length; j++)if ('**' === globParts[i][j]) globParts[i][j] = '*';
+                    for (const partset of globParts)for(let j = 0; j < partset.length; j++)if ('**' === partset[j]) partset[j] = '*';
                 }
                 const { optimizationLevel = 1 } = this.options;
                 if (optimizationLevel >= 2) {
@@ -4970,7 +4466,7 @@ var __webpack_modules__ = {
                     let dd = 0;
                     while(-1 !== (dd = parts.indexOf('..', dd + 1))){
                         const p = parts[dd - 1];
-                        if (p && '.' !== p && '..' !== p && '**' !== p) {
+                        if (p && '.' !== p && '..' !== p && '**' !== p && !(this.isWindows && /^[a-z]:$/i.test(p))) {
                             didSomething = true;
                             parts.splice(dd - 1, 2);
                             dd -= 2;
@@ -5092,7 +4588,8 @@ var __webpack_modules__ = {
                 this.negate = negate;
             }
             matchOne(file, pattern, partial = false) {
-                const options = this.options;
+                let fileStartIndex = 0;
+                let patternStartIndex = 0;
                 if (this.isWindows) {
                     const fileDrive = 'string' == typeof file[0] && /^[a-z]:$/i.test(file[0]);
                     const fileUNC = !fileDrive && '' === file[0] && '' === file[1] && '?' === file[2] && /^[a-z]:$/i.test(file[3]);
@@ -5107,57 +4604,116 @@ var __webpack_modules__ = {
                         ];
                         if (fd.toLowerCase() === pd.toLowerCase()) {
                             pattern[pdi] = fd;
-                            if (pdi > fdi) pattern = pattern.slice(pdi);
-                            else if (fdi > pdi) file = file.slice(fdi);
+                            patternStartIndex = pdi;
+                            fileStartIndex = fdi;
                         }
                     }
                 }
                 const { optimizationLevel = 1 } = this.options;
                 if (optimizationLevel >= 2) file = this.levelTwoFileOptimize(file);
-                this.debug('matchOne', this, {
-                    file,
-                    pattern
-                });
-                this.debug('matchOne', file.length, pattern.length);
-                for(var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++){
+                if (pattern.includes(GLOBSTAR)) return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
+                return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
+            }
+            #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
+                const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
+                const lastgs = pattern.lastIndexOf(GLOBSTAR);
+                const [head, body, tail] = partial ? [
+                    pattern.slice(patternIndex, firstgs),
+                    pattern.slice(firstgs + 1),
+                    []
+                ] : [
+                    pattern.slice(patternIndex, firstgs),
+                    pattern.slice(firstgs + 1, lastgs),
+                    pattern.slice(lastgs + 1)
+                ];
+                if (head.length) {
+                    const fileHead = file.slice(fileIndex, fileIndex + head.length);
+                    if (!this.#matchOne(fileHead, head, partial, 0, 0)) return false;
+                    fileIndex += head.length;
+                    patternIndex += head.length;
+                }
+                let fileTailMatch = 0;
+                if (tail.length) {
+                    if (tail.length + fileIndex > file.length) return false;
+                    let tailStart = file.length - tail.length;
+                    if (this.#matchOne(file, tail, partial, tailStart, 0)) fileTailMatch = tail.length;
+                    else {
+                        if ('' !== file[file.length - 1] || fileIndex + tail.length === file.length) return false;
+                        tailStart--;
+                        if (!this.#matchOne(file, tail, partial, tailStart, 0)) return false;
+                        fileTailMatch = tail.length + 1;
+                    }
+                }
+                if (!body.length) {
+                    let sawSome = !!fileTailMatch;
+                    for(let i = fileIndex; i < file.length - fileTailMatch; i++){
+                        const f = String(file[i]);
+                        sawSome = true;
+                        if ('.' === f || '..' === f || !this.options.dot && f.startsWith('.')) return false;
+                    }
+                    return partial || sawSome;
+                }
+                const bodySegments = [
+                    [
+                        [],
+                        0
+                    ]
+                ];
+                let currentBody = bodySegments[0];
+                let nonGsParts = 0;
+                const nonGsPartsSums = [
+                    0
+                ];
+                for (const b of body)if (b === GLOBSTAR) {
+                    nonGsPartsSums.push(nonGsParts);
+                    currentBody = [
+                        [],
+                        0
+                    ];
+                    bodySegments.push(currentBody);
+                } else {
+                    currentBody[0].push(b);
+                    nonGsParts++;
+                }
+                let i = bodySegments.length - 1;
+                const fileLength = file.length - fileTailMatch;
+                for (const b of bodySegments)b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);
+                return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
+            }
+            #matchGlobStarBodySections(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+                const bs = bodySegments[bodyIndex];
+                if (!bs) {
+                    for(let i = fileIndex; i < file.length; i++){
+                        sawTail = true;
+                        const f = file[i];
+                        if ('.' === f || '..' === f || !this.options.dot && f.startsWith('.')) return false;
+                    }
+                    return sawTail;
+                }
+                const [body, after] = bs;
+                while(fileIndex <= after){
+                    const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
+                    if (m && globStarDepth < this.maxGlobstarRecursion) {
+                        const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+                        if (false !== sub) return sub;
+                    }
+                    const f = file[fileIndex];
+                    if ('.' === f || '..' === f || !this.options.dot && f.startsWith('.')) return false;
+                    fileIndex++;
+                }
+                return partial || null;
+            }
+            #matchOne(file, pattern, partial, fileIndex, patternIndex) {
+                let fi;
+                let pi;
+                let pl;
+                let fl;
+                for(fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++){
                     this.debug('matchOne loop');
-                    var p = pattern[pi];
-                    var f = file[fi];
+                    let p = pattern[pi];
+                    let f = file[fi];
                     this.debug(pattern, p, f);
-                    if (false === p) return false;
-                    if (p === GLOBSTAR) {
-                        this.debug('GLOBSTAR', [
-                            pattern,
-                            p,
-                            f
-                        ]);
-                        var fr = fi;
-                        var pr = pi + 1;
-                        if (pr === pl) {
-                            this.debug('** at the end');
-                            for(; fi < fl; fi++)if ('.' === file[fi] || '..' === file[fi] || !options.dot && '.' === file[fi].charAt(0)) return false;
-                            return true;
-                        }
-                        while(fr < fl){
-                            var swallowee = file[fr];
-                            this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
-                            if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-                                this.debug('globstar found match!', fr, fl, swallowee);
-                                return true;
-                            }
-                            if ('.' === swallowee || '..' === swallowee || !options.dot && '.' === swallowee.charAt(0)) {
-                                this.debug('dot detected!', file, fr, pattern, pr);
-                                break;
-                            }
-                            this.debug('globstar swallow a segment, and continue');
-                            fr++;
-                        }
-                        if (partial) {
-                            this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
-                            if (fr === fl) return true;
-                        }
-                        return false;
-                    }
+                    if (false === p || p === GLOBSTAR) return false;
                     let hit;
                     if ('string' == typeof p) {
                         hit = f === p;
@@ -5217,13 +4773,19 @@ var __webpack_modules__ = {
                         if (p !== GLOBSTAR || prev === GLOBSTAR) return;
                         if (void 0 === prev) if (void 0 !== next && next !== GLOBSTAR) pp[i + 1] = '(?:\\/|' + twoStar + '\\/)?' + next;
                         else pp[i] = twoStar;
-                        else if (void 0 === next) pp[i - 1] = prev + '(?:\\/|' + twoStar + ')?';
+                        else if (void 0 === next) pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + ')?';
                         else if (next !== GLOBSTAR) {
                             pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next;
                             pp[i + 1] = GLOBSTAR;
                         }
                     });
-                    return pp.filter((p)=>p !== GLOBSTAR).join('/');
+                    const filtered = pp.filter((p)=>p !== GLOBSTAR);
+                    if (this.partial && filtered.length >= 1) {
+                        const prefixes = [];
+                        for(let i = 1; i <= filtered.length; i++)prefixes.push(filtered.slice(0, i).join('/'));
+                        return '(?:' + prefixes.join('|') + ')';
+                    }
+                    return filtered.join('/');
                 }).join('|');
                 const [open, close] = set.length > 1 ? [
                     '(?:',
@@ -5233,19 +4795,20 @@ var __webpack_modules__ = {
                     ''
                 ];
                 re = '^' + open + re + close + '$';
+                if (this.partial) re = '^(?:\\/|' + open + re.slice(1, -1) + close + ')$';
                 if (this.negate) re = '^(?!' + re + ').+$';
                 try {
                     this.regexp = new RegExp(re, [
                         ...flags
                     ].join(''));
-                } catch (ex) {
+                } catch  {
                     this.regexp = false;
                 }
                 return this.regexp;
             }
             slashSplit(p) {
                 if (this.preserveMultipleSlashes) return p.split('/');
-                if (this.isWindows && /^\/\/[^\/]+/.test(p)) return [
+                if (this.isWindows && /^\/\/[^/]+/.test(p)) return [
                     '',
                     ...p.split(/\/+/)
                 ];
@@ -5264,8 +4827,7 @@ var __webpack_modules__ = {
                 this.debug(this.pattern, 'set', set);
                 let filename = ff[ff.length - 1];
                 if (!filename) for(let i = ff.length - 2; !filename && i >= 0; i--)filename = ff[i];
-                for(let i = 0; i < set.length; i++){
-                    const pattern = set[i];
+                for (const pattern of set){
                     let file = ff;
                     if (options.matchBase && 1 === pattern.length) file = [
                         filename
@@ -5287,86 +4849,48 @@ var __webpack_modules__ = {
         minimatch.Minimatch = esm_Minimatch;
         minimatch.escape = escape_escape;
         minimatch.unescape = unescape_unescape;
-        const external_node_url_namespaceObject = require("node:url");
-        const perf = 'object' == typeof performance && performance && 'function' == typeof performance.now ? performance : Date;
-        const warned = new Set();
-        const PROCESS = 'object' == typeof process && process ? process : {};
-        const emitWarning = (msg, type, code, fn)=>{
-            'function' == typeof PROCESS.emitWarning ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
-        };
-        let AC = globalThis.AbortController;
-        let AS = globalThis.AbortSignal;
-        if (void 0 === AC) {
-            AS = class {
-                onabort;
-                _onabort = [];
-                reason;
-                aborted = false;
-                addEventListener(_, fn) {
-                    this._onabort.push(fn);
-                }
-            };
-            AC = class {
-                constructor(){
-                    warnACPolyfill();
-                }
-                signal = new AS();
-                abort(reason) {
-                    if (this.signal.aborted) return;
-                    this.signal.reason = reason;
-                    this.signal.aborted = true;
-                    for (const fn of this.signal._onabort)fn(reason);
-                    this.signal.onabort?.(reason);
-                }
-            };
-            let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== '1';
-            const warnACPolyfill = ()=>{
-                if (!printACPolyfillWarning) return;
-                printACPolyfillWarning = false;
-                emitWarning("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", 'NO_ABORT_CONTROLLER', 'ENOTSUP', warnACPolyfill);
-            };
-        }
-        const shouldWarn = (code)=>!warned.has(code);
-        Symbol('type');
-        const isPosInt = (n)=>n && n === Math.floor(n) && n > 0 && isFinite(n);
-        const getUintArray = (max)=>isPosInt(max) ? max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null : null;
-        class ZeroArray extends Array {
-            constructor(size){
-                super(size);
-                this.fill(0);
-            }
-        }
-        class Stack {
+        var external_node_url_ = __webpack_require__("node:url");
+        const external_node_diagnostics_channel_namespaceObject = require("node:diagnostics_channel");
+        var S = (0, external_node_diagnostics_channel_namespaceObject.channel)("lru-cache:metrics"), W = (0, external_node_diagnostics_channel_namespaceObject.tracingChannel)("lru-cache");
+        var D = ()=>S.hasSubscribers || W.hasSubscribers, G = "object" == typeof performance && performance && "function" == typeof performance.now ? performance : Date, M = new Set, C = "object" == typeof process && process ? process : {}, P = (u, e1, t1, i)=>{
+            "function" == typeof C.emitWarning ? C.emitWarning(u, e1, t1, i) : console.error(`[${t1}] ${e1}: ${u}`);
+        }, H = (u)=>!M.has(u), F = (Symbol("type"), (u)=>!!u && u === Math.floor(u) && u > 0 && isFinite(u)), U = (u)=>F(u) ? u <= Math.pow(2, 8) ? Uint8Array : u <= Math.pow(2, 16) ? Uint16Array : u <= Math.pow(2, 32) ? Uint32Array : u <= Number.MAX_SAFE_INTEGER ? O : null : null, O = class extends Array {
+            constructor(e1){
+                super(e1), this.fill(0);
+            }
+        }, R = class u {
             heap;
             length;
-            static #constructing = false;
-            static create(max) {
-                const HeapCls = getUintArray(max);
-                if (!HeapCls) return [];
-                Stack.#constructing = true;
-                const s = new Stack(max, HeapCls);
-                Stack.#constructing = false;
-                return s;
-            }
-            constructor(max, HeapCls){
-                if (!Stack.#constructing) throw new TypeError('instantiate Stack using Stack.create(n)');
-                this.heap = new HeapCls(max);
-                this.length = 0;
-            }
-            push(n) {
-                this.heap[this.length++] = n;
+            static #o = !1;
+            static create(e1) {
+                let t1 = U(e1);
+                if (!t1) return [];
+                u.#o = !0;
+                let i = new u(e1, t1);
+                return u.#o = !1, i;
+            }
+            constructor(e1, t1){
+                if (!u.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
+                this.heap = new t1(e1), this.length = 0;
+            }
+            push(e1) {
+                this.heap[this.length++] = e1;
             }
             pop() {
                 return this.heap[--this.length];
             }
-        }
-        class LRUCache {
-            #max;
-            #maxSize;
-            #dispose;
-            #disposeAfter;
-            #fetchMethod;
-            #memoMethod;
+        }, L = class u {
+            #o;
+            #u;
+            #w;
+            #D;
+            #S;
+            #M;
+            #U;
+            #m;
+            get perf() {
+                return this.#m;
+            }
             ttl;
             ttlResolution;
             ttlAutopurge;
@@ -5382,823 +4906,613 @@ var __webpack_modules__ = {
             allowStaleOnFetchAbort;
             allowStaleOnFetchRejection;
             ignoreFetchAbort;
-            #size;
-            #calculatedSize;
-            #keyMap;
-            #keyList;
-            #valList;
-            #next;
-            #prev;
-            #head;
-            #tail;
-            #free;
-            #disposed;
-            #sizes;
-            #starts;
-            #ttls;
-            #hasDispose;
-            #hasFetchMethod;
-            #hasDisposeAfter;
-            static unsafeExposeInternals(c) {
+            #n;
+            #b;
+            #s;
+            #i;
+            #t;
+            #a;
+            #c;
+            #l;
+            #h;
+            #y;
+            #r;
+            #_;
+            #F;
+            #d;
+            #g;
+            #T;
+            #W;
+            #f;
+            #j;
+            static unsafeExposeInternals(e1) {
                 return {
-                    starts: c.#starts,
-                    ttls: c.#ttls,
-                    sizes: c.#sizes,
-                    keyMap: c.#keyMap,
-                    keyList: c.#keyList,
-                    valList: c.#valList,
-                    next: c.#next,
-                    prev: c.#prev,
+                    starts: e1.#F,
+                    ttls: e1.#d,
+                    autopurgeTimers: e1.#g,
+                    sizes: e1.#_,
+                    keyMap: e1.#s,
+                    keyList: e1.#i,
+                    valList: e1.#t,
+                    next: e1.#a,
+                    prev: e1.#c,
                     get head () {
-                        return c.#head;
+                        return e1.#l;
                     },
                     get tail () {
-                        return c.#tail;
+                        return e1.#h;
                     },
-                    free: c.#free,
-                    isBackgroundFetch: (p)=>c.#isBackgroundFetch(p),
-                    backgroundFetch: (k, index, options, context)=>c.#backgroundFetch(k, index, options, context),
-                    moveToTail: (index)=>c.#moveToTail(index),
-                    indexes: (options)=>c.#indexes(options),
-                    rindexes: (options)=>c.#rindexes(options),
-                    isStale: (index)=>c.#isStale(index)
+                    free: e1.#y,
+                    isBackgroundFetch: (t1)=>e1.#e(t1),
+                    backgroundFetch: (t1, i, s, n)=>e1.#P(t1, i, s, n),
+                    moveToTail: (t1)=>e1.#L(t1),
+                    indexes: (t1)=>e1.#A(t1),
+                    rindexes: (t1)=>e1.#z(t1),
+                    isStale: (t1)=>e1.#p(t1)
                 };
             }
             get max() {
-                return this.#max;
+                return this.#o;
             }
             get maxSize() {
-                return this.#maxSize;
+                return this.#u;
             }
             get calculatedSize() {
-                return this.#calculatedSize;
+                return this.#b;
             }
             get size() {
-                return this.#size;
+                return this.#n;
             }
             get fetchMethod() {
-                return this.#fetchMethod;
+                return this.#M;
             }
             get memoMethod() {
-                return this.#memoMethod;
+                return this.#U;
             }
             get dispose() {
-                return this.#dispose;
+                return this.#w;
             }
-            get disposeAfter() {
-                return this.#disposeAfter;
+            get onInsert() {
+                return this.#D;
             }
-            constructor(options){
-                const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
-                if (0 !== max && !isPosInt(max)) throw new TypeError('max option must be a nonnegative integer');
-                const UintArray = max ? getUintArray(max) : Array;
-                if (!UintArray) throw new Error('invalid max value: ' + max);
-                this.#max = max;
-                this.#maxSize = maxSize;
-                this.maxEntrySize = maxEntrySize || this.#maxSize;
-                this.sizeCalculation = sizeCalculation;
-                if (this.sizeCalculation) {
-                    if (!this.#maxSize && !this.maxEntrySize) throw new TypeError('cannot set sizeCalculation without setting maxSize or maxEntrySize');
-                    if ('function' != typeof this.sizeCalculation) throw new TypeError('sizeCalculation set to non-function');
-                }
-                if (void 0 !== memoMethod && 'function' != typeof memoMethod) throw new TypeError('memoMethod must be a function if defined');
-                this.#memoMethod = memoMethod;
-                if (void 0 !== fetchMethod && 'function' != typeof fetchMethod) throw new TypeError('fetchMethod must be a function if specified');
-                this.#fetchMethod = fetchMethod;
-                this.#hasFetchMethod = !!fetchMethod;
-                this.#keyMap = new Map();
-                this.#keyList = new Array(max).fill(void 0);
-                this.#valList = new Array(max).fill(void 0);
-                this.#next = new UintArray(max);
-                this.#prev = new UintArray(max);
-                this.#head = 0;
-                this.#tail = 0;
-                this.#free = Stack.create(max);
-                this.#size = 0;
-                this.#calculatedSize = 0;
-                if ('function' == typeof dispose) this.#dispose = dispose;
-                if ('function' == typeof disposeAfter) {
-                    this.#disposeAfter = disposeAfter;
-                    this.#disposed = [];
-                } else {
-                    this.#disposeAfter = void 0;
-                    this.#disposed = void 0;
-                }
-                this.#hasDispose = !!this.#dispose;
-                this.#hasDisposeAfter = !!this.#disposeAfter;
-                this.noDisposeOnSet = !!noDisposeOnSet;
-                this.noUpdateTTL = !!noUpdateTTL;
-                this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
-                this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
-                this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
-                this.ignoreFetchAbort = !!ignoreFetchAbort;
-                if (0 !== this.maxEntrySize) {
-                    if (0 !== this.#maxSize) {
-                        if (!isPosInt(this.#maxSize)) throw new TypeError('maxSize must be a positive integer if specified');
-                    }
-                    if (!isPosInt(this.maxEntrySize)) throw new TypeError('maxEntrySize must be a positive integer if specified');
-                    this.#initializeSizeTracking();
-                }
-                this.allowStale = !!allowStale;
-                this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
-                this.updateAgeOnGet = !!updateAgeOnGet;
-                this.updateAgeOnHas = !!updateAgeOnHas;
-                this.ttlResolution = isPosInt(ttlResolution) || 0 === ttlResolution ? ttlResolution : 1;
-                this.ttlAutopurge = !!ttlAutopurge;
-                this.ttl = ttl || 0;
-                if (this.ttl) {
-                    if (!isPosInt(this.ttl)) throw new TypeError('ttl must be a positive integer if specified');
-                    this.#initializeTTLTracking();
-                }
-                if (0 === this.#max && 0 === this.ttl && 0 === this.#maxSize) throw new TypeError('At least one of max, maxSize, or ttl is required');
-                if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
-                    const code = 'LRU_CACHE_UNBOUNDED';
-                    if (shouldWarn(code)) {
-                        warned.add(code);
-                        const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";
-                        emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache);
-                    }
-                }
-            }
-            getRemainingTTL(key) {
-                return this.#keyMap.has(key) ? 1 / 0 : 0;
-            }
-            #initializeTTLTracking() {
-                const ttls = new ZeroArray(this.#max);
-                const starts = new ZeroArray(this.#max);
-                this.#ttls = ttls;
-                this.#starts = starts;
-                this.#setItemTTL = (index, ttl, start = perf.now())=>{
-                    starts[index] = 0 !== ttl ? start : 0;
-                    ttls[index] = ttl;
-                    if (0 !== ttl && this.ttlAutopurge) {
-                        const t1 = setTimeout(()=>{
-                            if (this.#isStale(index)) this.#delete(this.#keyList[index], 'expire');
-                        }, ttl + 1);
-                        if (t1.unref) t1.unref();
-                    }
-                };
-                this.#updateItemAge = (index)=>{
-                    starts[index] = 0 !== ttls[index] ? perf.now() : 0;
+            get disposeAfter() {
+                return this.#S;
+            }
+            constructor(e1){
+                let { max: t1 = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: r, allowStale: h, dispose: l, onInsert: c, disposeAfter: f, noDisposeOnSet: g, noUpdateTTL: p, maxSize: T = 0, maxEntrySize: w = 0, sizeCalculation: y, fetchMethod: a, memoMethod: m, noDeleteOnFetchRejection: _, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: z, perf: x } = e1;
+                if (void 0 !== x && "function" != typeof x?.now) throw new TypeError("perf option must have a now() method if specified");
+                if (this.#m = x ?? G, 0 !== t1 && !F(t1)) throw new TypeError("max option must be a nonnegative integer");
+                let v = t1 ? U(t1) : Array;
+                if (!v) throw new Error("invalid max value: " + t1);
+                if (this.#o = t1, this.#u = T, this.maxEntrySize = w || this.#u, this.sizeCalculation = y, this.sizeCalculation) {
+                    if (!this.#u && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+                    if ("function" != typeof this.sizeCalculation) throw new TypeError("sizeCalculation set to non-function");
+                }
+                if (void 0 !== m && "function" != typeof m) throw new TypeError("memoMethod must be a function if defined");
+                if (this.#U = m, void 0 !== a && "function" != typeof a) throw new TypeError("fetchMethod must be a function if specified");
+                if (this.#M = a, this.#W = !!a, this.#s = new Map, this.#i = Array.from({
+                    length: t1
+                }).fill(void 0), this.#t = Array.from({
+                    length: t1
+                }).fill(void 0), this.#a = new v(t1), this.#c = new v(t1), this.#l = 0, this.#h = 0, this.#y = R.create(t1), this.#n = 0, this.#b = 0, "function" == typeof l && (this.#w = l), "function" == typeof c && (this.#D = c), "function" == typeof f ? (this.#S = f, this.#r = []) : (this.#S = void 0, this.#r = void 0), this.#T = !!this.#w, this.#j = !!this.#D, this.#f = !!this.#S, this.noDisposeOnSet = !!g, this.noUpdateTTL = !!p, this.noDeleteOnFetchRejection = !!_, this.allowStaleOnFetchRejection = !!d, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!z, 0 !== this.maxEntrySize) {
+                    if (0 !== this.#u && !F(this.#u)) throw new TypeError("maxSize must be a positive integer if specified");
+                    if (!F(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+                    this.#X();
+                }
+                if (this.allowStale = !!h, this.noDeleteOnStaleGet = !!b, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!r, this.ttlResolution = F(s) || 0 === s ? s : 1, this.ttlAutopurge = !!n, this.ttl = i || 0, this.ttl) {
+                    if (!F(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+                    this.#H();
+                }
+                if (0 === this.#o && 0 === this.ttl && 0 === this.#u) throw new TypeError("At least one of max, maxSize, or ttl is required");
+                if (!this.ttlAutopurge && !this.#o && !this.#u) {
+                    let E = "LRU_CACHE_UNBOUNDED";
+                    H(E) && (M.add(E), P("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, u));
+                }
+            }
+            getRemainingTTL(e1) {
+                return this.#s.has(e1) ? 1 / 0 : 0;
+            }
+            #H() {
+                let e1 = new O(this.#o), t1 = new O(this.#o);
+                this.#d = e1, this.#F = t1;
+                let i = this.ttlAutopurge ? Array.from({
+                    length: this.#o
+                }) : void 0;
+                this.#g = i, this.#N = (r, h, l = this.#m.now())=>{
+                    t1[r] = 0 !== h ? l : 0, e1[r] = h, s(r, h);
+                }, this.#x = (r)=>{
+                    t1[r] = 0 !== e1[r] ? this.#m.now() : 0, s(r, e1[r]);
                 };
-                this.#statusTTL = (status, index)=>{
-                    if (ttls[index]) {
-                        const ttl = ttls[index];
-                        const start = starts[index];
-                        if (!ttl || !start) return;
-                        status.ttl = ttl;
-                        status.start = start;
-                        status.now = cachedNow || getNow();
-                        const age = status.now - start;
-                        status.remainingTTL = ttl - age;
+                let s = this.ttlAutopurge ? (r, h)=>{
+                    if (i?.[r] && (clearTimeout(i[r]), i[r] = void 0), h && 0 !== h && i) {
+                        let l = setTimeout(()=>{
+                            this.#p(r) && this.#v(this.#i[r], "expire");
+                        }, h + 1);
+                        l.unref && l.unref(), i[r] = l;
+                    }
+                } : ()=>{};
+                this.#E = (r, h)=>{
+                    if (e1[h]) {
+                        let l = e1[h], c = t1[h];
+                        if (!l || !c) return;
+                        r.ttl = l, r.start = c, r.now = n || o();
+                        let f = r.now - c;
+                        r.remainingTTL = l - f;
                     }
                 };
-                let cachedNow = 0;
-                const getNow = ()=>{
-                    const n = perf.now();
+                let n = 0, o = ()=>{
+                    let r = this.#m.now();
                     if (this.ttlResolution > 0) {
-                        cachedNow = n;
-                        const t1 = setTimeout(()=>cachedNow = 0, this.ttlResolution);
-                        if (t1.unref) t1.unref();
+                        n = r;
+                        let h = setTimeout(()=>n = 0, this.ttlResolution);
+                        h.unref && h.unref();
                     }
-                    return n;
-                };
-                this.getRemainingTTL = (key)=>{
-                    const index = this.#keyMap.get(key);
-                    if (void 0 === index) return 0;
-                    const ttl = ttls[index];
-                    const start = starts[index];
-                    if (!ttl || !start) return 1 / 0;
-                    const age = (cachedNow || getNow()) - start;
-                    return ttl - age;
+                    return r;
                 };
-                this.#isStale = (index)=>{
-                    const s = starts[index];
-                    const t1 = ttls[index];
-                    return !!t1 && !!s && (cachedNow || getNow()) - s > t1;
+                this.getRemainingTTL = (r)=>{
+                    let h = this.#s.get(r);
+                    if (void 0 === h) return 0;
+                    let l = e1[h], c = t1[h];
+                    if (!l || !c) return 1 / 0;
+                    let f = (n || o()) - c;
+                    return l - f;
+                }, this.#p = (r)=>{
+                    let h = t1[r], l = e1[r];
+                    return !!l && !!h && (n || o()) - h > l;
                 };
             }
-            #updateItemAge = ()=>{};
-            #statusTTL = ()=>{};
-            #setItemTTL = ()=>{};
-            #isStale = ()=>false;
-            #initializeSizeTracking() {
-                const sizes = new ZeroArray(this.#max);
-                this.#calculatedSize = 0;
-                this.#sizes = sizes;
-                this.#removeItemSize = (index)=>{
-                    this.#calculatedSize -= sizes[index];
-                    sizes[index] = 0;
-                };
-                this.#requireSize = (k, v, size, sizeCalculation)=>{
-                    if (this.#isBackgroundFetch(v)) return 0;
-                    if (!isPosInt(size)) if (sizeCalculation) {
-                        if ('function' != typeof sizeCalculation) throw new TypeError('sizeCalculation must be a function');
-                        size = sizeCalculation(v, k);
-                        if (!isPosInt(size)) throw new TypeError('sizeCalculation return invalid (expect positive integer)');
+            #x = ()=>{};
+            #E = ()=>{};
+            #N = ()=>{};
+            #p = ()=>!1;
+            #X() {
+                let e1 = new O(this.#o);
+                this.#b = 0, this.#_ = e1, this.#R = (t1)=>{
+                    this.#b -= e1[t1], e1[t1] = 0;
+                }, this.#k = (t1, i, s, n)=>{
+                    if (this.#e(i)) return 0;
+                    if (!F(s)) if (n) {
+                        if ("function" != typeof n) throw new TypeError("sizeCalculation must be a function");
+                        if (s = n(i, t1), !F(s)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
                     } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
-                    return size;
-                };
-                this.#addItemSize = (index, size, status)=>{
-                    sizes[index] = size;
-                    if (this.#maxSize) {
-                        const maxSize = this.#maxSize - sizes[index];
-                        while(this.#calculatedSize > maxSize)this.#evict(true);
-                    }
-                    this.#calculatedSize += sizes[index];
-                    if (status) {
-                        status.entrySize = size;
-                        status.totalCalculatedSize = this.#calculatedSize;
+                    return s;
+                }, this.#I = (t1, i, s)=>{
+                    if (e1[t1] = i, this.#u) {
+                        let n = this.#u - e1[t1];
+                        for(; this.#b > n;)this.#G(!0);
                     }
+                    this.#b += e1[t1], s && (s.entrySize = i, s.totalCalculatedSize = this.#b);
                 };
             }
-            #removeItemSize = (_i)=>{};
-            #addItemSize = (_i, _s, _st)=>{};
-            #requireSize = (_k, _v, size, sizeCalculation)=>{
-                if (size || sizeCalculation) throw new TypeError('cannot set size without setting maxSize or maxEntrySize on cache');
+            #R = (e1)=>{};
+            #I = (e1, t1, i)=>{};
+            #k = (e1, t1, i, s)=>{
+                if (i || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
                 return 0;
             };
-            *#indexes({ allowStale = this.allowStale } = {}) {
-                if (this.#size) for(let i = this.#tail; true;){
-                    if (!this.#isValidIndex(i)) break;
-                    if (allowStale || !this.#isStale(i)) yield i;
-                    if (i === this.#head) break;
-                    i = this.#prev[i];
-                }
+            *#A({ allowStale: e1 = this.allowStale } = {}) {
+                if (this.#n) for(let t1 = this.#h; this.#V(t1) && ((e1 || !this.#p(t1)) && (yield t1), t1 !== this.#l);)t1 = this.#c[t1];
             }
-            *#rindexes({ allowStale = this.allowStale } = {}) {
-                if (this.#size) for(let i = this.#head; true;){
-                    if (!this.#isValidIndex(i)) break;
-                    if (allowStale || !this.#isStale(i)) yield i;
-                    if (i === this.#tail) break;
-                    i = this.#next[i];
-                }
+            *#z({ allowStale: e1 = this.allowStale } = {}) {
+                if (this.#n) for(let t1 = this.#l; this.#V(t1) && ((e1 || !this.#p(t1)) && (yield t1), t1 !== this.#h);)t1 = this.#a[t1];
             }
-            #isValidIndex(index) {
-                return void 0 !== index && this.#keyMap.get(this.#keyList[index]) === index;
+            #V(e1) {
+                return void 0 !== e1 && this.#s.get(this.#i[e1]) === e1;
             }
             *entries() {
-                for (const i of this.#indexes())if (void 0 !== this.#valList[i] && void 0 !== this.#keyList[i] && !this.#isBackgroundFetch(this.#valList[i])) yield [
-                    this.#keyList[i],
-                    this.#valList[i]
-                ];
+                for (let e1 of this.#A())void 0 === this.#t[e1] || void 0 === this.#i[e1] || this.#e(this.#t[e1]) || (yield [
+                    this.#i[e1],
+                    this.#t[e1]
+                ]);
             }
             *rentries() {
-                for (const i of this.#rindexes())if (void 0 !== this.#valList[i] && void 0 !== this.#keyList[i] && !this.#isBackgroundFetch(this.#valList[i])) yield [
-                    this.#keyList[i],
-                    this.#valList[i]
-                ];
+                for (let e1 of this.#z())void 0 === this.#t[e1] || void 0 === this.#i[e1] || this.#e(this.#t[e1]) || (yield [
+                    this.#i[e1],
+                    this.#t[e1]
+                ]);
             }
             *keys() {
-                for (const i of this.#indexes()){
-                    const k = this.#keyList[i];
-                    if (void 0 !== k && !this.#isBackgroundFetch(this.#valList[i])) yield k;
+                for (let e1 of this.#A()){
+                    let t1 = this.#i[e1];
+                    void 0 === t1 || this.#e(this.#t[e1]) || (yield t1);
                 }
             }
             *rkeys() {
-                for (const i of this.#rindexes()){
-                    const k = this.#keyList[i];
-                    if (void 0 !== k && !this.#isBackgroundFetch(this.#valList[i])) yield k;
+                for (let e1 of this.#z()){
+                    let t1 = this.#i[e1];
+                    void 0 === t1 || this.#e(this.#t[e1]) || (yield t1);
                 }
             }
             *values() {
-                for (const i of this.#indexes()){
-                    const v = this.#valList[i];
-                    if (void 0 !== v && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
-                }
+                for (let e1 of this.#A())void 0 === this.#t[e1] || this.#e(this.#t[e1]) || (yield this.#t[e1]);
             }
             *rvalues() {
-                for (const i of this.#rindexes()){
-                    const v = this.#valList[i];
-                    if (void 0 !== v && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
-                }
+                for (let e1 of this.#z())void 0 === this.#t[e1] || this.#e(this.#t[e1]) || (yield this.#t[e1]);
             }
             [Symbol.iterator]() {
                 return this.entries();
             }
-            [Symbol.toStringTag] = 'LRUCache';
-            find(fn, getOptions = {}) {
-                for (const i of this.#indexes()){
-                    const v = this.#valList[i];
-                    const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-                    if (void 0 !== value) {
-                        if (fn(value, this.#keyList[i], this)) return this.get(this.#keyList[i], getOptions);
-                    }
+            [Symbol.toStringTag] = "LRUCache";
+            find(e1, t1 = {}) {
+                for (let i of this.#A()){
+                    let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+                    if (void 0 !== n && e1(n, this.#i[i], this)) return this.#C(this.#i[i], t1);
                 }
             }
-            forEach(fn, thisp = this) {
-                for (const i of this.#indexes()){
-                    const v = this.#valList[i];
-                    const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-                    if (void 0 !== value) fn.call(thisp, value, this.#keyList[i], this);
+            forEach(e1, t1 = this) {
+                for (let i of this.#A()){
+                    let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+                    void 0 !== n && e1.call(t1, n, this.#i[i], this);
                 }
             }
-            rforEach(fn, thisp = this) {
-                for (const i of this.#rindexes()){
-                    const v = this.#valList[i];
-                    const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-                    if (void 0 !== value) fn.call(thisp, value, this.#keyList[i], this);
+            rforEach(e1, t1 = this) {
+                for (let i of this.#z()){
+                    let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+                    void 0 !== n && e1.call(t1, n, this.#i[i], this);
                 }
             }
             purgeStale() {
-                let deleted = false;
-                for (const i of this.#rindexes({
-                    allowStale: true
-                }))if (this.#isStale(i)) {
-                    this.#delete(this.#keyList[i], 'expire');
-                    deleted = true;
-                }
-                return deleted;
-            }
-            info(key) {
-                const i = this.#keyMap.get(key);
-                if (void 0 === i) return;
-                const v = this.#valList[i];
-                const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-                if (void 0 === value) return;
-                const entry = {
-                    value
+                let e1 = !1;
+                for (let t1 of this.#z({
+                    allowStale: !0
+                }))this.#p(t1) && (this.#v(this.#i[t1], "expire"), e1 = !0);
+                return e1;
+            }
+            info(e1) {
+                let t1 = this.#s.get(e1);
+                if (void 0 === t1) return;
+                let i = this.#t[t1], s = this.#e(i) ? i.__staleWhileFetching : i;
+                if (void 0 === s) return;
+                let n = {
+                    value: s
                 };
-                if (this.#ttls && this.#starts) {
-                    const ttl = this.#ttls[i];
-                    const start = this.#starts[i];
-                    if (ttl && start) {
-                        const remain = ttl - (perf.now() - start);
-                        entry.ttl = remain;
-                        entry.start = Date.now();
+                if (this.#d && this.#F) {
+                    let o = this.#d[t1], r = this.#F[t1];
+                    if (o && r) {
+                        let h = o - (this.#m.now() - r);
+                        n.ttl = h, n.start = Date.now();
                     }
                 }
-                if (this.#sizes) entry.size = this.#sizes[i];
-                return entry;
+                return this.#_ && (n.size = this.#_[t1]), n;
             }
             dump() {
-                const arr = [];
-                for (const i of this.#indexes({
-                    allowStale: true
+                let e1 = [];
+                for (let t1 of this.#A({
+                    allowStale: !0
                 })){
-                    const key = this.#keyList[i];
-                    const v = this.#valList[i];
-                    const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-                    if (void 0 === value || void 0 === key) continue;
-                    const entry = {
-                        value
+                    let i = this.#i[t1], s = this.#t[t1], n = this.#e(s) ? s.__staleWhileFetching : s;
+                    if (void 0 === n || void 0 === i) continue;
+                    let o = {
+                        value: n
                     };
-                    if (this.#ttls && this.#starts) {
-                        entry.ttl = this.#ttls[i];
-                        const age = perf.now() - this.#starts[i];
-                        entry.start = Math.floor(Date.now() - age);
-                    }
-                    if (this.#sizes) entry.size = this.#sizes[i];
-                    arr.unshift([
-                        key,
-                        entry
+                    if (this.#d && this.#F) {
+                        o.ttl = this.#d[t1];
+                        let r = this.#m.now() - this.#F[t1];
+                        o.start = Math.floor(Date.now() - r);
+                    }
+                    this.#_ && (o.size = this.#_[t1]), e1.unshift([
+                        i,
+                        o
                     ]);
                 }
-                return arr;
+                return e1;
             }
-            load(arr) {
+            load(e1) {
                 this.clear();
-                for (const [key, entry] of arr){
-                    if (entry.start) {
-                        const age = Date.now() - entry.start;
-                        entry.start = perf.now() - age;
-                    }
-                    this.set(key, entry.value, entry);
-                }
-            }
-            set(k, v, setOptions = {}) {
-                if (void 0 === v) {
-                    this.delete(k);
-                    return this;
-                }
-                const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
-                let { noUpdateTTL = this.noUpdateTTL } = setOptions;
-                const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
-                if (this.maxEntrySize && size > this.maxEntrySize) {
-                    if (status) {
-                        status.set = 'miss';
-                        status.maxEntrySizeExceeded = true;
-                    }
-                    this.#delete(k, 'set');
-                    return this;
-                }
-                let index = 0 === this.#size ? void 0 : this.#keyMap.get(k);
-                if (void 0 === index) {
-                    index = 0 === this.#size ? this.#tail : 0 !== this.#free.length ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
-                    this.#keyList[index] = k;
-                    this.#valList[index] = v;
-                    this.#keyMap.set(k, index);
-                    this.#next[this.#tail] = index;
-                    this.#prev[index] = this.#tail;
-                    this.#tail = index;
-                    this.#size++;
-                    this.#addItemSize(index, size, status);
-                    if (status) status.set = 'add';
-                    noUpdateTTL = false;
-                } else {
-                    this.#moveToTail(index);
-                    const oldVal = this.#valList[index];
-                    if (v !== oldVal) {
-                        if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
-                            oldVal.__abortController.abort(new Error('replaced'));
-                            const { __staleWhileFetching: s } = oldVal;
-                            if (void 0 !== s && !noDisposeOnSet) {
-                                if (this.#hasDispose) this.#dispose?.(s, k, 'set');
-                                if (this.#hasDisposeAfter) this.#disposed?.push([
-                                    s,
-                                    k,
-                                    'set'
-                                ]);
-                            }
-                        } else if (!noDisposeOnSet) {
-                            if (this.#hasDispose) this.#dispose?.(oldVal, k, 'set');
-                            if (this.#hasDisposeAfter) this.#disposed?.push([
-                                oldVal,
-                                k,
-                                'set'
-                            ]);
-                        }
-                        this.#removeItemSize(index);
-                        this.#addItemSize(index, size, status);
-                        this.#valList[index] = v;
-                        if (status) {
-                            status.set = 'replace';
-                            const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
-                            if (void 0 !== oldValue) status.oldValue = oldValue;
+                for (let [t1, i] of e1){
+                    if (i.start) {
+                        let s = Date.now() - i.start;
+                        i.start = this.#m.now() - s;
+                    }
+                    this.#O(t1, i.value, i);
+                }
+            }
+            set(e1, t1, i = {}) {
+                let { status: s = S.hasSubscribers ? {} : void 0 } = i;
+                i.status = s, s && (s.op = "set", s.key = e1, void 0 !== t1 && (s.value = t1));
+                let n = this.#O(e1, t1, i);
+                return s && S.hasSubscribers && S.publish(s), n;
+            }
+            #O(e1, t1, i = {}) {
+                let { ttl: s = this.ttl, start: n, noDisposeOnSet: o = this.noDisposeOnSet, sizeCalculation: r = this.sizeCalculation, status: h } = i;
+                if (void 0 === t1) return h && (h.set = "deleted"), this.delete(e1), this;
+                let { noUpdateTTL: l = this.noUpdateTTL } = i;
+                h && !this.#e(t1) && (h.value = t1);
+                let c = this.#k(e1, t1, i.size || 0, r, h);
+                if (this.maxEntrySize && c > this.maxEntrySize) return this.#v(e1, "set"), h && (h.set = "miss", h.maxEntrySizeExceeded = !0), this;
+                let f = 0 === this.#n ? void 0 : this.#s.get(e1);
+                if (void 0 === f) f = 0 === this.#n ? this.#h : 0 !== this.#y.length ? this.#y.pop() : this.#n === this.#o ? this.#G(!1) : this.#n, this.#i[f] = e1, this.#t[f] = t1, this.#s.set(e1, f), this.#a[this.#h] = f, this.#c[f] = this.#h, this.#h = f, this.#n++, this.#I(f, c, h), h && (h.set = "add"), l = !1, this.#j && this.#D?.(t1, e1, "add");
+                else {
+                    this.#L(f);
+                    let g = this.#t[f];
+                    if (t1 !== g) {
+                        if (this.#W && this.#e(g)) {
+                            g.__abortController.abort(new Error("replaced"));
+                            let { __staleWhileFetching: p } = g;
+                            void 0 !== p && !o && (this.#T && this.#w?.(p, e1, "set"), this.#f && this.#r?.push([
+                                p,
+                                e1,
+                                "set"
+                            ]));
+                        } else o || (this.#T && this.#w?.(g, e1, "set"), this.#f && this.#r?.push([
+                            g,
+                            e1,
+                            "set"
+                        ]));
+                        if (this.#R(f), this.#I(f, c, h), this.#t[f] = t1, h) {
+                            h.set = "replace";
+                            let p = g && this.#e(g) ? g.__staleWhileFetching : g;
+                            void 0 !== p && (h.oldValue = p);
                         }
-                    } else if (status) status.set = 'update';
+                    } else h && (h.set = "update");
+                    this.#j && this.onInsert?.(t1, e1, t1 === g ? "update" : "replace");
                 }
-                if (0 !== ttl && !this.#ttls) this.#initializeTTLTracking();
-                if (this.#ttls) {
-                    if (!noUpdateTTL) this.#setItemTTL(index, ttl, start);
-                    if (status) this.#statusTTL(status, index);
-                }
-                if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
-                    const dt = this.#disposed;
-                    let task;
-                    while(task = dt?.shift())this.#disposeAfter?.(...task);
+                if (0 === s || this.#d || this.#H(), this.#d && (l || this.#N(f, s, n), h && this.#E(h, f)), !o && this.#f && this.#r) {
+                    let g = this.#r, p;
+                    for(; p = g?.shift();)this.#S?.(...p);
                 }
                 return this;
             }
             pop() {
                 try {
-                    while(this.#size){
-                        const val = this.#valList[this.#head];
-                        this.#evict(true);
-                        if (this.#isBackgroundFetch(val)) {
-                            if (val.__staleWhileFetching) return val.__staleWhileFetching;
-                        } else if (void 0 !== val) return val;
+                    for(; this.#n;){
+                        let e1 = this.#t[this.#l];
+                        if (this.#G(!0), this.#e(e1)) {
+                            if (e1.__staleWhileFetching) return e1.__staleWhileFetching;
+                        } else if (void 0 !== e1) return e1;
                     }
                 } finally{
-                    if (this.#hasDisposeAfter && this.#disposed) {
-                        const dt = this.#disposed;
-                        let task;
-                        while(task = dt?.shift())this.#disposeAfter?.(...task);
+                    if (this.#f && this.#r) {
+                        let e1 = this.#r, t1;
+                        for(; t1 = e1?.shift();)this.#S?.(...t1);
                     }
                 }
             }
-            #evict(free) {
-                const head = this.#head;
-                const k = this.#keyList[head];
-                const v = this.#valList[head];
-                if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) v.__abortController.abort(new Error('evicted'));
-                else if (this.#hasDispose || this.#hasDisposeAfter) {
-                    if (this.#hasDispose) this.#dispose?.(v, k, 'evict');
-                    if (this.#hasDisposeAfter) this.#disposed?.push([
-                        v,
-                        k,
-                        'evict'
-                    ]);
+            #G(e1) {
+                let t1 = this.#l, i = this.#i[t1], s = this.#t[t1];
+                return this.#W && this.#e(s) ? s.__abortController.abort(new Error("evicted")) : (this.#T || this.#f) && (this.#T && this.#w?.(s, i, "evict"), this.#f && this.#r?.push([
+                    s,
+                    i,
+                    "evict"
+                ])), this.#R(t1), this.#g?.[t1] && (clearTimeout(this.#g[t1]), this.#g[t1] = void 0), e1 && (this.#i[t1] = void 0, this.#t[t1] = void 0, this.#y.push(t1)), 1 === this.#n ? (this.#l = this.#h = 0, this.#y.length = 0) : this.#l = this.#a[t1], this.#s.delete(i), this.#n--, t1;
+            }
+            has(e1, t1 = {}) {
+                let { status: i = S.hasSubscribers ? {} : void 0 } = t1;
+                t1.status = i, i && (i.op = "has", i.key = e1);
+                let s = this.#Y(e1, t1);
+                return S.hasSubscribers && S.publish(i), s;
+            }
+            #Y(e1, t1 = {}) {
+                let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = t1, n = this.#s.get(e1);
+                if (void 0 !== n) {
+                    let o = this.#t[n];
+                    if (this.#e(o) && void 0 === o.__staleWhileFetching) return !1;
+                    if (!this.#p(n)) return i && this.#x(n), s && (s.has = "hit", this.#E(s, n)), !0;
+                    s && (s.has = "stale", this.#E(s, n));
+                } else s && (s.has = "miss");
+                return !1;
+            }
+            peek(e1, t1 = {}) {
+                let { status: i = D() ? {} : void 0 } = t1;
+                i && (i.op = "peek", i.key = e1), t1.status = i;
+                let s = this.#J(e1, t1);
+                return S.hasSubscribers && S.publish(i), s;
+            }
+            #J(e1, t1) {
+                let { status: i, allowStale: s = this.allowStale } = t1, n = this.#s.get(e1);
+                if (void 0 === n || !s && this.#p(n)) {
+                    i && (i.peek = void 0 === n ? "miss" : "stale");
+                    return;
                 }
-                this.#removeItemSize(head);
-                if (free) {
-                    this.#keyList[head] = void 0;
-                    this.#valList[head] = void 0;
-                    this.#free.push(head);
-                }
-                if (1 === this.#size) {
-                    this.#head = this.#tail = 0;
-                    this.#free.length = 0;
-                } else this.#head = this.#next[head];
-                this.#keyMap.delete(k);
-                this.#size--;
-                return head;
-            }
-            has(k, hasOptions = {}) {
-                const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
-                const index = this.#keyMap.get(k);
-                if (void 0 !== index) {
-                    const v = this.#valList[index];
-                    if (this.#isBackgroundFetch(v) && void 0 === v.__staleWhileFetching) return false;
-                    if (this.#isStale(index)) {
-                        if (status) {
-                            status.has = 'stale';
-                            this.#statusTTL(status, index);
-                        }
-                    } else {
-                        if (updateAgeOnHas) this.#updateItemAge(index);
-                        if (status) {
-                            status.has = 'hit';
-                            this.#statusTTL(status, index);
-                        }
-                        return true;
-                    }
-                } else if (status) status.has = 'miss';
-                return false;
+                let o = this.#t[n], r = this.#e(o) ? o.__staleWhileFetching : o;
+                return i && (void 0 !== r ? (i.peek = "hit", i.value = r) : i.peek = "miss"), r;
             }
-            peek(k, peekOptions = {}) {
-                const { allowStale = this.allowStale } = peekOptions;
-                const index = this.#keyMap.get(k);
-                if (void 0 === index || !allowStale && this.#isStale(index)) return;
-                const v = this.#valList[index];
-                return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-            }
-            #backgroundFetch(k, index, options, context) {
-                const v = void 0 === index ? void 0 : this.#valList[index];
-                if (this.#isBackgroundFetch(v)) return v;
-                const ac = new AC();
-                const { signal } = options;
-                signal?.addEventListener('abort', ()=>ac.abort(signal.reason), {
-                    signal: ac.signal
+            #P(e1, t1, i, s) {
+                let n = void 0 === t1 ? void 0 : this.#t[t1];
+                if (this.#e(n)) return n;
+                let o = new AbortController, { signal: r } = i;
+                r?.addEventListener("abort", ()=>o.abort(r.reason), {
+                    signal: o.signal
                 });
-                const fetchOpts = {
-                    signal: ac.signal,
-                    options,
-                    context
-                };
-                const cb = (v, updateCache = false)=>{
-                    const { aborted } = ac.signal;
-                    const ignoreAbort = options.ignoreFetchAbort && void 0 !== v;
-                    if (options.status) if (aborted && !updateCache) {
-                        options.status.fetchAborted = true;
-                        options.status.fetchError = ac.signal.reason;
-                        if (ignoreAbort) options.status.fetchAbortIgnored = true;
-                    } else options.status.fetchResolved = true;
-                    if (aborted && !ignoreAbort && !updateCache) return fetchFail(ac.signal.reason);
-                    const bf = p;
-                    if (this.#valList[index] === p) if (void 0 === v) if (bf.__staleWhileFetching) this.#valList[index] = bf.__staleWhileFetching;
-                    else this.#delete(k, 'fetch');
-                    else {
-                        if (options.status) options.status.fetchUpdated = true;
-                        this.set(k, v, fetchOpts.options);
-                    }
-                    return v;
-                };
-                const eb = (er)=>{
-                    if (options.status) {
-                        options.status.fetchRejected = true;
-                        options.status.fetchError = er;
-                    }
-                    return fetchFail(er);
-                };
-                const fetchFail = (er)=>{
-                    const { aborted } = ac.signal;
-                    const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
-                    const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
-                    const noDelete = allowStale || options.noDeleteOnFetchRejection;
-                    const bf = p;
-                    if (this.#valList[index] === p) {
-                        const del = !noDelete || void 0 === bf.__staleWhileFetching;
-                        if (del) this.#delete(k, 'fetch');
-                        else if (!allowStaleAborted) this.#valList[index] = bf.__staleWhileFetching;
-                    }
-                    if (allowStale) {
-                        if (options.status && void 0 !== bf.__staleWhileFetching) options.status.returnedStale = true;
-                        return bf.__staleWhileFetching;
-                    }
-                    if (bf.__returned === bf) throw er;
-                };
-                const pcall = (res, rej)=>{
-                    const fmp = this.#fetchMethod?.(k, v, fetchOpts);
-                    if (fmp && fmp instanceof Promise) fmp.then((v)=>res(void 0 === v ? void 0 : v), rej);
-                    ac.signal.addEventListener('abort', ()=>{
-                        if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
-                            res(void 0);
-                            if (options.allowStaleOnFetchAbort) res = (v)=>cb(v, true);
-                        }
+                let h = {
+                    signal: o.signal,
+                    options: i,
+                    context: s
+                }, l = (w, y = !1)=>{
+                    let { aborted: a } = o.signal, m = i.ignoreFetchAbort && void 0 !== w, _ = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && void 0 !== w);
+                    if (i.status && (a && !y ? (i.status.fetchAborted = !0, i.status.fetchError = o.signal.reason, m && (i.status.fetchAbortIgnored = !0)) : i.status.fetchResolved = !0), a && !m && !y) return f(o.signal.reason, _);
+                    let b = p, d = this.#t[t1];
+                    return (d === p || void 0 === d && m && y) && (void 0 === w ? void 0 !== b.__staleWhileFetching ? this.#t[t1] = b.__staleWhileFetching : this.#v(e1, "fetch") : (i.status && (i.status.fetchUpdated = !0), this.#O(e1, w, h.options))), w;
+                }, c = (w)=>(i.status && (i.status.fetchRejected = !0, i.status.fetchError = w), f(w, !1)), f = (w, y)=>{
+                    let { aborted: a } = o.signal, m = a && i.allowStaleOnFetchAbort, _ = m || i.allowStaleOnFetchRejection, b = _ || i.noDeleteOnFetchRejection, d = p;
+                    if (this.#t[t1] === p && (b && (y || void 0 !== d.__staleWhileFetching) ? m || (this.#t[t1] = d.__staleWhileFetching) : this.#v(e1, "fetch")), _) return i.status && void 0 !== d.__staleWhileFetching && (i.status.returnedStale = !0), d.__staleWhileFetching;
+                    if (d.__returned === d) throw w;
+                }, g = (w, y)=>{
+                    let a = this.#M?.(e1, n, h);
+                    a && a instanceof Promise && a.then((m)=>w(void 0 === m ? void 0 : m), y), o.signal.addEventListener("abort", ()=>{
+                        (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (w(void 0), i.allowStaleOnFetchAbort && (w = (m)=>l(m, !0)));
                     });
                 };
-                if (options.status) options.status.fetchDispatched = true;
-                const p = new Promise(pcall).then(cb, eb);
-                const bf = Object.assign(p, {
-                    __abortController: ac,
-                    __staleWhileFetching: v,
+                i.status && (i.status.fetchDispatched = !0);
+                let p = new Promise(g).then(l, c), T = Object.assign(p, {
+                    __abortController: o,
+                    __staleWhileFetching: n,
                     __returned: void 0
                 });
-                if (void 0 === index) {
-                    this.set(k, bf, {
-                        ...fetchOpts.options,
-                        status: void 0
-                    });
-                    index = this.#keyMap.get(k);
-                } else this.#valList[index] = bf;
-                return bf;
-            }
-            #isBackgroundFetch(p) {
-                if (!this.#hasFetchMethod) return false;
-                const b = p;
-                return !!b && b instanceof Promise && b.hasOwnProperty('__staleWhileFetching') && b.__abortController instanceof AC;
-            }
-            async fetch(k, fetchOptions = {}) {
-                const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL, noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, ignoreFetchAbort = this.ignoreFetchAbort, allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, context, forceRefresh = false, status, signal } = fetchOptions;
-                if (!this.#hasFetchMethod) {
-                    if (status) status.fetch = 'get';
-                    return this.get(k, {
-                        allowStale,
-                        updateAgeOnGet,
-                        noDeleteOnStaleGet,
-                        status
-                    });
-                }
-                const options = {
-                    allowStale,
-                    updateAgeOnGet,
-                    noDeleteOnStaleGet,
-                    ttl,
-                    noDisposeOnSet,
-                    size,
-                    sizeCalculation,
-                    noUpdateTTL,
-                    noDeleteOnFetchRejection,
-                    allowStaleOnFetchRejection,
-                    allowStaleOnFetchAbort,
-                    ignoreFetchAbort,
-                    status,
-                    signal
-                };
-                let index = this.#keyMap.get(k);
-                if (void 0 === index) {
-                    if (status) status.fetch = 'miss';
-                    const p = this.#backgroundFetch(k, index, options, context);
-                    return p.__returned = p;
+                return void 0 === t1 ? (this.#O(e1, T, {
+                    ...h.options,
+                    status: void 0
+                }), t1 = this.#s.get(e1)) : this.#t[t1] = T, T;
+            }
+            #e(e1) {
+                if (!this.#W) return !1;
+                let t1 = e1;
+                return !!t1 && t1 instanceof Promise && t1.hasOwnProperty("__staleWhileFetching") && t1.__abortController instanceof AbortController;
+            }
+            fetch(e1, t1 = {}) {
+                let i = W.hasSubscribers, { status: s = D() ? {} : void 0 } = t1;
+                t1.status = s, s && t1.context && (s.context = t1.context);
+                let n = this.#B(e1, t1);
+                return s && D() && i && (s.trace = !0, W.tracePromise(()=>n, s).catch(()=>{})), n;
+            }
+            async #B(e1, t1 = {}) {
+                let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: r = this.noDisposeOnSet, size: h = 0, sizeCalculation: l = this.sizeCalculation, noUpdateTTL: c = this.noUpdateTTL, noDeleteOnFetchRejection: f = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: g = this.allowStaleOnFetchRejection, ignoreFetchAbort: p = this.ignoreFetchAbort, allowStaleOnFetchAbort: T = this.allowStaleOnFetchAbort, context: w, forceRefresh: y = !1, status: a, signal: m } = t1;
+                if (a && (a.op = "fetch", a.key = e1, y && (a.forceRefresh = !0)), !this.#W) return a && (a.fetch = "get"), this.#C(e1, {
+                    allowStale: i,
+                    updateAgeOnGet: s,
+                    noDeleteOnStaleGet: n,
+                    status: a
+                });
+                let _ = {
+                    allowStale: i,
+                    updateAgeOnGet: s,
+                    noDeleteOnStaleGet: n,
+                    ttl: o,
+                    noDisposeOnSet: r,
+                    size: h,
+                    sizeCalculation: l,
+                    noUpdateTTL: c,
+                    noDeleteOnFetchRejection: f,
+                    allowStaleOnFetchRejection: g,
+                    allowStaleOnFetchAbort: T,
+                    ignoreFetchAbort: p,
+                    status: a,
+                    signal: m
+                }, b = this.#s.get(e1);
+                if (void 0 === b) {
+                    a && (a.fetch = "miss");
+                    let d = this.#P(e1, b, _, w);
+                    return d.__returned = d;
                 }
                 {
-                    const v = this.#valList[index];
-                    if (this.#isBackgroundFetch(v)) {
-                        const stale = allowStale && void 0 !== v.__staleWhileFetching;
-                        if (status) {
-                            status.fetch = 'inflight';
-                            if (stale) status.returnedStale = true;
-                        }
-                        return stale ? v.__staleWhileFetching : v.__returned = v;
-                    }
-                    const isStale = this.#isStale(index);
-                    if (!forceRefresh && !isStale) {
-                        if (status) status.fetch = 'hit';
-                        this.#moveToTail(index);
-                        if (updateAgeOnGet) this.#updateItemAge(index);
-                        if (status) this.#statusTTL(status, index);
-                        return v;
-                    }
-                    const p = this.#backgroundFetch(k, index, options, context);
-                    const hasStale = void 0 !== p.__staleWhileFetching;
-                    const staleVal = hasStale && allowStale;
-                    if (status) {
-                        status.fetch = isStale ? 'stale' : 'refresh';
-                        if (staleVal && isStale) status.returnedStale = true;
-                    }
-                    return staleVal ? p.__staleWhileFetching : p.__returned = p;
-                }
-            }
-            async forceFetch(k, fetchOptions = {}) {
-                const v = await this.fetch(k, fetchOptions);
-                if (void 0 === v) throw new Error('fetch() returned undefined');
-                return v;
-            }
-            memo(k, memoOptions = {}) {
-                const memoMethod = this.#memoMethod;
-                if (!memoMethod) throw new Error('no memoMethod provided to constructor');
-                const { context, forceRefresh, ...options } = memoOptions;
-                const v = this.get(k, options);
-                if (!forceRefresh && void 0 !== v) return v;
-                const vv = memoMethod(k, v, {
-                    options,
-                    context
+                    let d = this.#t[b];
+                    if (this.#e(d)) {
+                        let E = i && void 0 !== d.__staleWhileFetching;
+                        return a && (a.fetch = "inflight", E && (a.returnedStale = !0)), E ? d.__staleWhileFetching : d.__returned = d;
+                    }
+                    let A = this.#p(b);
+                    if (!y && !A) return a && (a.fetch = "hit"), this.#L(b), s && this.#x(b), a && this.#E(a, b), d;
+                    let z = this.#P(e1, b, _, w), v = void 0 !== z.__staleWhileFetching && i;
+                    return a && (a.fetch = A ? "stale" : "refresh", v && A && (a.returnedStale = !0)), v ? z.__staleWhileFetching : z.__returned = z;
+                }
+            }
+            forceFetch(e1, t1 = {}) {
+                let i = W.hasSubscribers, { status: s = D() ? {} : void 0 } = t1;
+                t1.status = s, s && t1.context && (s.context = t1.context);
+                let n = this.#K(e1, t1);
+                return s && D() && i && (s.trace = !0, W.tracePromise(()=>n, s).catch(()=>{})), n;
+            }
+            async #K(e1, t1 = {}) {
+                let i = await this.#B(e1, t1);
+                if (void 0 === i) throw new Error("fetch() returned undefined");
+                return i;
+            }
+            memo(e1, t1 = {}) {
+                let { status: i = S.hasSubscribers ? {} : void 0 } = t1;
+                t1.status = i, i && (i.op = "memo", i.key = e1, t1.context && (i.context = t1.context));
+                let s = this.#Q(e1, t1);
+                return i && (i.value = s), S.hasSubscribers && S.publish(i), s;
+            }
+            #Q(e1, t1 = {}) {
+                let i = this.#U;
+                if (!i) throw new Error("no memoMethod provided to constructor");
+                let { context: s, status: n, forceRefresh: o, ...r } = t1;
+                n && o && (n.forceRefresh = !0);
+                let h = this.#C(e1, r), l = o || void 0 === h;
+                if (n && (n.memo = l ? "miss" : "hit", l || (n.value = h)), !l) return h;
+                let c = i(e1, h, {
+                    options: r,
+                    context: s
                 });
-                this.set(k, vv, options);
-                return vv;
-            }
-            get(k, getOptions = {}) {
-                const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
-                const index = this.#keyMap.get(k);
-                if (void 0 !== index) {
-                    const value = this.#valList[index];
-                    const fetching = this.#isBackgroundFetch(value);
-                    if (status) this.#statusTTL(status, index);
-                    if (this.#isStale(index)) {
-                        if (status) status.get = 'stale';
-                        if (fetching) {
-                            if (status && allowStale && void 0 !== value.__staleWhileFetching) status.returnedStale = true;
-                            return allowStale ? value.__staleWhileFetching : void 0;
-                        }
-                        if (!noDeleteOnStaleGet) this.#delete(k, 'expire');
-                        if (status && allowStale) status.returnedStale = true;
-                        return allowStale ? value : void 0;
-                    }
-                    if (status) status.get = 'hit';
-                    if (fetching) return value.__staleWhileFetching;
-                    this.#moveToTail(index);
-                    if (updateAgeOnGet) this.#updateItemAge(index);
-                    return value;
+                return n && (n.value = c), this.#O(e1, c, r), c;
+            }
+            get(e1, t1 = {}) {
+                let { status: i = S.hasSubscribers ? {} : void 0 } = t1;
+                t1.status = i, i && (i.op = "get", i.key = e1);
+                let s = this.#C(e1, t1);
+                return i && (void 0 !== s && (i.value = s), S.hasSubscribers && S.publish(i)), s;
+            }
+            #C(e1, t1 = {}) {
+                let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: o } = t1, r = this.#s.get(e1);
+                if (void 0 === r) {
+                    o && (o.get = "miss");
+                    return;
                 }
-                if (status) status.get = 'miss';
+                let h = this.#t[r], l = this.#e(h);
+                return o && this.#E(o, r), this.#p(r) ? l ? (o && (o.get = "stale-fetching"), i && void 0 !== h.__staleWhileFetching ? (o && (o.returnedStale = !0), h.__staleWhileFetching) : void 0) : (n || this.#v(e1, "expire"), o && (o.get = "stale"), i ? (o && (o.returnedStale = !0), h) : void 0) : (o && (o.get = l ? "fetching" : "hit"), this.#L(r), s && this.#x(r), l ? h.__staleWhileFetching : h);
             }
-            #connect(p, n) {
-                this.#prev[n] = p;
-                this.#next[p] = n;
+            #$(e1, t1) {
+                this.#c[t1] = e1, this.#a[e1] = t1;
             }
-            #moveToTail(index) {
-                if (index !== this.#tail) {
-                    if (index === this.#head) this.#head = this.#next[index];
-                    else this.#connect(this.#prev[index], this.#next[index]);
-                    this.#connect(this.#tail, index);
-                    this.#tail = index;
-                }
+            #L(e1) {
+                e1 !== this.#h && (e1 === this.#l ? this.#l = this.#a[e1] : this.#$(this.#c[e1], this.#a[e1]), this.#$(this.#h, e1), this.#h = e1);
             }
-            delete(k) {
-                return this.#delete(k, 'delete');
+            delete(e1) {
+                return this.#v(e1, "delete");
             }
-            #delete(k, reason) {
-                let deleted = false;
-                if (0 !== this.#size) {
-                    const index = this.#keyMap.get(k);
-                    if (void 0 !== index) {
-                        deleted = true;
-                        if (1 === this.#size) this.#clear(reason);
+            #v(e1, t1) {
+                S.hasSubscribers && S.publish({
+                    op: "delete",
+                    delete: t1,
+                    key: e1
+                });
+                let i = !1;
+                if (0 !== this.#n) {
+                    let s = this.#s.get(e1);
+                    if (void 0 !== s) if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = void 0), i = !0, 1 === this.#n) this.#q(t1);
+                    else {
+                        this.#R(s);
+                        let n = this.#t[s];
+                        if (this.#e(n) ? n.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#w?.(n, e1, t1), this.#f && this.#r?.push([
+                            n,
+                            e1,
+                            t1
+                        ])), this.#s.delete(e1), this.#i[s] = void 0, this.#t[s] = void 0, s === this.#h) this.#h = this.#c[s];
+                        else if (s === this.#l) this.#l = this.#a[s];
                         else {
-                            this.#removeItemSize(index);
-                            const v = this.#valList[index];
-                            if (this.#isBackgroundFetch(v)) v.__abortController.abort(new Error('deleted'));
-                            else if (this.#hasDispose || this.#hasDisposeAfter) {
-                                if (this.#hasDispose) this.#dispose?.(v, k, reason);
-                                if (this.#hasDisposeAfter) this.#disposed?.push([
-                                    v,
-                                    k,
-                                    reason
-                                ]);
-                            }
-                            this.#keyMap.delete(k);
-                            this.#keyList[index] = void 0;
-                            this.#valList[index] = void 0;
-                            if (index === this.#tail) this.#tail = this.#prev[index];
-                            else if (index === this.#head) this.#head = this.#next[index];
-                            else {
-                                const pi = this.#prev[index];
-                                this.#next[pi] = this.#next[index];
-                                const ni = this.#next[index];
-                                this.#prev[ni] = this.#prev[index];
-                            }
-                            this.#size--;
-                            this.#free.push(index);
+                            let o = this.#c[s];
+                            this.#a[o] = this.#a[s];
+                            let r = this.#a[s];
+                            this.#c[r] = this.#c[s];
                         }
+                        this.#n--, this.#y.push(s);
                     }
                 }
-                if (this.#hasDisposeAfter && this.#disposed?.length) {
-                    const dt = this.#disposed;
-                    let task;
-                    while(task = dt?.shift())this.#disposeAfter?.(...task);
+                if (this.#f && this.#r?.length) {
+                    let s = this.#r, n;
+                    for(; n = s?.shift();)this.#S?.(...n);
                 }
-                return deleted;
+                return i;
             }
             clear() {
-                return this.#clear('delete');
+                return this.#q("delete");
             }
-            #clear(reason) {
-                for (const index of this.#rindexes({
-                    allowStale: true
+            #q(e1) {
+                for (let t1 of this.#z({
+                    allowStale: !0
                 })){
-                    const v = this.#valList[index];
-                    if (this.#isBackgroundFetch(v)) v.__abortController.abort(new Error('deleted'));
+                    let i = this.#t[t1];
+                    if (this.#e(i)) i.__abortController.abort(new Error("deleted"));
                     else {
-                        const k = this.#keyList[index];
-                        if (this.#hasDispose) this.#dispose?.(v, k, reason);
-                        if (this.#hasDisposeAfter) this.#disposed?.push([
-                            v,
-                            k,
-                            reason
+                        let s = this.#i[t1];
+                        this.#T && this.#w?.(i, s, e1), this.#f && this.#r?.push([
+                            i,
+                            s,
+                            e1
                         ]);
                     }
                 }
-                this.#keyMap.clear();
-                this.#valList.fill(void 0);
-                this.#keyList.fill(void 0);
-                if (this.#ttls && this.#starts) {
-                    this.#ttls.fill(0);
-                    this.#starts.fill(0);
+                if (this.#s.clear(), this.#t.fill(void 0), this.#i.fill(void 0), this.#d && this.#F) {
+                    this.#d.fill(0), this.#F.fill(0);
+                    for (let t1 of this.#g ?? [])void 0 !== t1 && clearTimeout(t1);
+                    this.#g?.fill(void 0);
                 }
-                if (this.#sizes) this.#sizes.fill(0);
-                this.#head = 0;
-                this.#tail = 0;
-                this.#free.length = 0;
-                this.#calculatedSize = 0;
-                this.#size = 0;
-                if (this.#hasDisposeAfter && this.#disposed) {
-                    const dt = this.#disposed;
-                    let task;
-                    while(task = dt?.shift())this.#disposeAfter?.(...task);
+                if (this.#_ && this.#_.fill(0), this.#l = 0, this.#h = 0, this.#y.length = 0, this.#b = 0, this.#n = 0, this.#f && this.#r) {
+                    let t1 = this.#r, i;
+                    for(; i = t1?.shift();)this.#S?.(...i);
                 }
             }
-        }
+        };
         var external_fs_ = __webpack_require__("fs");
         const promises_namespaceObject = require("node:fs/promises");
         const external_node_events_namespaceObject = require("node:events");
@@ -6275,7 +5589,7 @@ var __webpack_modules__ = {
             }
             constructor(src, dest, opts){
                 super(src, dest, opts);
-                this.proxyErrors = (er)=>dest.emit('error', er);
+                this.proxyErrors = (er)=>this.dest.emit('error', er);
                 src.on('error', this.proxyErrors);
             }
         }
@@ -6727,7 +6041,8 @@ var __webpack_modules__ = {
                     return: stop,
                     [Symbol.asyncIterator] () {
                         return this;
-                    }
+                    },
+                    [Symbol.asyncDispose]: async ()=>{}
                 };
             }
             [Symbol.iterator]() {
@@ -6761,7 +6076,8 @@ var __webpack_modules__ = {
                     return: stop,
                     [Symbol.iterator] () {
                         return this;
-                    }
+                    },
+                    [Symbol.dispose]: ()=>{}
                 };
             }
             destroy(er) {
@@ -6798,7 +6114,7 @@ var __webpack_modules__ = {
                 realpath: promises_namespaceObject.realpath
             }
         };
-        const fsFromOption = (fsOption)=>fsOption && fsOption !== defaultFS && fsOption !== external_node_fs_namespaceObject_0 ? {
+        const fsFromOption = (fsOption)=>fsOption && fsOption !== defaultFS && fsOption !== external_node_fs_namespaceObject ? {
                 ...defaultFS,
                 ...fsOption,
                 promises: {
@@ -6828,7 +6144,9 @@ var __webpack_modules__ = {
         const ENOCHILD = ENOTDIR | ENOENT | ENOREALPATH;
         const TYPEMASK = 1023;
         const entToType = (s)=>s.isFile() ? IFREG : s.isDirectory() ? IFDIR : s.isSymbolicLink() ? IFLNK : s.isCharacterDevice() ? IFCHR : s.isBlockDevice() ? IFBLK : s.isSocket() ? IFSOCK : s.isFIFO() ? IFIFO : UNKNOWN;
-        const normalizeCache = new Map();
+        const normalizeCache = new L({
+            max: 4096
+        });
         const normalize = (s)=>{
             const c = normalizeCache.get(s);
             if (c) return c;
@@ -6836,7 +6154,9 @@ var __webpack_modules__ = {
             normalizeCache.set(s, n);
             return n;
         };
-        const normalizeNocaseCache = new Map();
+        const normalizeNocaseCache = new L({
+            max: 4096
+        });
         const normalizeNocase = (s)=>{
             const c = normalizeNocaseCache.get(s);
             if (c) return c;
@@ -6844,14 +6164,14 @@ var __webpack_modules__ = {
             normalizeNocaseCache.set(s, n);
             return n;
         };
-        class ResolveCache extends LRUCache {
+        class ResolveCache extends L {
             constructor(){
                 super({
                     max: 256
                 });
             }
         }
-        class ChildrenCache extends LRUCache {
+        class ChildrenCache extends L {
             constructor(maxSize = 16384){
                 super({
                     maxSize,
@@ -7405,7 +6725,7 @@ var __webpack_modules__ = {
                 return new PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
             }
             getRootString(path) {
-                return external_node_path_namespaceObject.win32.parse(path).root;
+                return external_node_path_.win32.parse(path).root;
             }
             getRoot(rootPath) {
                 rootPath = uncToDrive(rootPath.toUpperCase());
@@ -7446,7 +6766,7 @@ var __webpack_modules__ = {
             #fs;
             constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16384, fs = defaultFS } = {}){
                 this.#fs = fsFromOption(fs);
-                if (cwd instanceof URL || cwd.startsWith('file://')) cwd = (0, external_node_url_namespaceObject.fileURLToPath)(cwd);
+                if (cwd instanceof URL || cwd.startsWith('file://')) cwd = (0, external_node_url_.fileURLToPath)(cwd);
                 const cwdPath = pathImpl.resolve(cwd);
                 this.roots = Object.create(null);
                 this.rootPath = this.parseRootPath(cwdPath);
@@ -7814,7 +7134,7 @@ var __webpack_modules__ = {
             sep = '\\';
             constructor(cwd = process.cwd(), opts = {}){
                 const { nocase = true } = opts;
-                super(cwd, external_node_path_namespaceObject.win32, '\\', {
+                super(cwd, external_node_path_.win32, '\\', {
                     ...opts,
                     nocase
                 });
@@ -7822,7 +7142,7 @@ var __webpack_modules__ = {
                 for(let p = this.cwd; p; p = p.parent)p.nocase = this.nocase;
             }
             parseRootPath(dir) {
-                return external_node_path_namespaceObject.win32.parse(dir).root.toUpperCase();
+                return external_node_path_.win32.parse(dir).root.toUpperCase();
             }
             newRoot(fs) {
                 return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), {
@@ -7837,7 +7157,7 @@ var __webpack_modules__ = {
             sep = '/';
             constructor(cwd = process.cwd(), opts = {}){
                 const { nocase = false } = opts;
-                super(cwd, external_node_path_namespaceObject.posix, '/', {
+                super(cwd, external_node_path_.posix, '/', {
                     ...opts,
                     nocase
                 });
@@ -8536,7 +7856,7 @@ var __webpack_modules__ = {
                 this.nodir = !!opts.nodir;
                 this.mark = !!opts.mark;
                 if (opts.cwd) {
-                    if (opts.cwd instanceof URL || opts.cwd.startsWith('file://')) opts.cwd = (0, external_node_url_namespaceObject.fileURLToPath)(opts.cwd);
+                    if (opts.cwd instanceof URL || opts.cwd.startsWith('file://')) opts.cwd = (0, external_node_url_.fileURLToPath)(opts.cwd);
                 } else this.cwd = '';
                 this.cwd = opts.cwd || '';
                 this.root = opts.root;
@@ -8688,7 +8008,7 @@ var __webpack_modules__ = {
             return new Glob(pattern, options).iterate();
         }
         const streamSync = globStreamSync;
-        const esm_stream = Object.assign(globStream, {
+        const stream = Object.assign(globStream, {
             sync: globStreamSync
         });
         const iterateSync = globIterateSync;
@@ -8704,7 +8024,7 @@ var __webpack_modules__ = {
             globSync,
             sync: esm_sync,
             globStream,
-            stream: esm_stream,
+            stream,
             globStreamSync,
             streamSync,
             globIterate,
@@ -9564,7 +8884,7 @@ var __webpack_modules__ = {
         var external_assert_ = __webpack_require__("assert");
         new RegExp("\x1b(?:\\[(?:\\d+[ABCDEFGJKSTm]|\\d+;\\d+[Hfm]|\\d+;\\d+;\\d+m|6n|s|u|\\?25[lh])|\\w)", 'g');
         const external_url_namespaceObject = require("url");
-        const platform_shims_node = {
+        const node = {
             fs: {
                 readFileSync: external_fs_.readFileSync,
                 writeFile: external_fs_.writeFile
@@ -9714,7 +9034,7 @@ var __webpack_modules__ = {
                 locale: y18n.locale
             };
         }
-        const y18n_y18n = (opts)=>lib_y18n(opts, platform_shims_node);
+        const y18n_y18n = (opts)=>lib_y18n(opts, node);
         const node_modules_y18n = y18n_y18n;
         let esm_dirname;
         try {
@@ -9733,6 +9053,8 @@ var __webpack_modules__ = {
         Yargs.hideBin = processArgv.hideBin;
         Yargs.Parser = yargs_Parser;
         const yargs = Yargs;
+        const external_node_process_namespaceObject = require("node:process");
+        var yaml_ = __webpack_require__("@midscene/core/yaml");
         /*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT */ function isNothing(subject) {
             return null == subject;
         }
@@ -11805,12 +11127,14 @@ var __webpack_modules__ = {
                 throw new Error('Function yaml.' + from + " is removed in js-yaml 4. Use yaml." + to + ' instead, which is now safe by default.');
             };
         }
-        var js_yaml_load = loader.load;
+        var load = loader.load;
         loader.loadAll;
         dumper.dump;
         renamed('safeLoad', 'load');
         renamed('safeLoadAll', 'loadAll');
         renamed('safeDump', 'dump');
+        var external_lodash_merge_ = __webpack_require__("lodash.merge");
+        var external_lodash_merge_default = /*#__PURE__*/ __webpack_require__.n(external_lodash_merge_);
         const config_factory_defaultConfig = {
             concurrent: 1,
             continueOnError: false,
@@ -11833,19 +11157,19 @@ var __webpack_modules__ = {
             return allFiles;
         }
         async function parseConfigYaml(configYamlPath) {
-            const basePath = (0, external_node_path_namespaceObject.dirname)((0, external_node_path_namespaceObject.resolve)(configYamlPath));
-            const configContent = (0, external_node_fs_namespaceObject.readFileSync)(configYamlPath, 'utf8');
-            const interpolatedContent = (0, yaml_namespaceObject.interpolateEnvVars)(configContent);
+            const basePath = (0, external_node_path_.dirname)((0, external_node_path_.resolve)(configYamlPath));
+            const configContent = (0, external_node_fs_.readFileSync)(configYamlPath, 'utf8');
+            const interpolatedContent = (0, yaml_.interpolateEnvVars)(configContent);
             let configYaml;
             try {
-                configYaml = js_yaml_load(interpolatedContent);
+                configYaml = load(interpolatedContent);
             } catch (error) {
                 throw new Error(`Failed to parse config YAML: ${error}`);
             }
             if (!configYaml?.files || !Array.isArray(configYaml?.files)) throw new Error('Config YAML must contain a "files" array');
             const files = await expandFilePatterns(configYaml?.files, basePath);
             if (0 === files.length) throw new Error('No YAML files found matching the patterns in "files"');
-            const configFileName = (0, external_node_path_namespaceObject.basename)(configYamlPath, (0, external_node_path_namespaceObject.extname)(configYamlPath));
+            const configFileName = (0, external_node_path_.basename)(configYamlPath, (0, external_node_path_.extname)(configYamlPath));
             const timestamp = Date.now();
             const defaultSummary = `${configFileName}-${timestamp}.json`;
             const config = {
@@ -11882,7 +11206,7 @@ var __webpack_modules__ = {
             const finalHeaded = keepWindow || headed;
             let files = parsedConfig.files;
             if (options?.files && options.files.length > 0) {
-                const basePath = (0, external_node_path_namespaceObject.dirname)((0, external_node_path_namespaceObject.resolve)(configYamlPath));
+                const basePath = (0, external_node_path_.dirname)((0, external_node_path_.resolve)(configYamlPath));
                 files = await expandFilePatterns(options.files, basePath);
             }
             return {
@@ -11922,7 +11246,7 @@ var __webpack_modules__ = {
                 }
             };
         }
-        const cli_utils_debug = (0, logger_namespaceObject.getDebug)('midscene:cli');
+        const debug = (0, logger_.getDebug)('midscene:cli');
         function kebabToCamel(str) {
             return str.replace(/-([a-z])/g, (_, letter)=>letter.toUpperCase());
         }
@@ -11981,7 +11305,7 @@ Usage:
                     type: 'boolean',
                     description: `Turn on logging to help debug why certain keys or values are not being set as you expect, default is ${config_factory_defaultConfig.dotenvDebug}`
                 }
-            }).version('version', 'Show version number', "1.8.7").help().epilogue(`For complete list of configuration options, please visit:
+            }).version('version', 'Show version number', "1.8.8-beta-20260601092605.0").help().epilogue(`For complete list of configuration options, please visit:
   • Web options: https://midscenejs.com/automate-with-scripts-in-yaml#the-web-part
   • Android options: https://midscenejs.com/automate-with-scripts-in-yaml#the-android-part
   • iOS options: https://midscenejs.com/automate-with-scripts-in-yaml#the-ios-part
@@ -11991,7 +11315,7 @@ Examples:
   $0 script.yaml --android.device-id emulator-5554 --android.ime-strategy yadb-for-non-ascii
   $0 script.yaml --ios.wda-port 8100 --ios.auto-dismiss-keyboard`).wrap(yargs().terminalWidth());
             const argv = await args.argv;
-            cli_utils_debug('argv', argv);
+            debug('argv', argv);
             const transformedArgv = {
                 ...argv
             };
@@ -12015,7 +11339,7 @@ Examples:
             };
         };
         async function matchYamlFiles(fileGlob, options) {
-            if ((0, external_node_fs_namespaceObject.existsSync)(fileGlob) && (0, external_node_fs_namespaceObject.statSync)(fileGlob).isDirectory()) fileGlob = (0, external_node_path_namespaceObject.join)(fileGlob, '**/*.{yml,yaml}');
+            if ((0, external_node_fs_.existsSync)(fileGlob) && (0, external_node_fs_.statSync)(fileGlob).isDirectory()) fileGlob = (0, external_node_path_.join)(fileGlob, '**/*.{yml,yaml}');
             const { cwd } = options || {};
             const ignore = [
                 '**/node_modules/**'
@@ -12029,6 +11353,7 @@ Examples:
             });
             return files.filter((file)=>file.endsWith('.yml') || file.endsWith('.yaml')).sort();
         }
+        var framework = __webpack_require__("./src/framework/index.ts");
         Promise.resolve((async ()=>{
             const rawArgs = process.argv.slice(2);
             const [firstArg] = rawArgs;
@@ -12087,8 +11412,8 @@ Examples:
                 console.error('Could not create a valid configuration.');
                 process.exit(1);
             }
-            const dotEnvConfigFile = (0, external_node_path_namespaceObject.join)(process.cwd(), '.env');
-            if ((0, external_node_fs_namespaceObject.existsSync)(dotEnvConfigFile)) {
+            const dotEnvConfigFile = (0, external_node_path_.join)(process.cwd(), '.env');
+            if ((0, external_node_fs_.existsSync)(dotEnvConfigFile)) {
                 console.log(`   Env file: ${dotEnvConfigFile}`);
                 main_default().config({
                     path: dotEnvConfigFile,
@@ -12096,21 +11421,24 @@ Examples:
                     override: config.dotenvOverride
                 });
             }
-            const executor = new BatchRunner(config);
-            await executor.run();
-            const success = executor.printExecutionSummary();
+            const exitCode = await (0, framework.runFrameworkTestConfig)(config);
             if (config.keepWindow) setInterval(()=>{
                 console.log('browser is still running, use ctrl+c to stop it');
             }, 5000);
-            else {
-                if (!success) process.exit(1);
-                process.exit(0);
-            }
+            else process.exit(exitCode);
         })().catch((e1)=>{
             console.error(e1);
             process.exit(1);
         }));
     },
+    "@midscene/core/yaml" (module) {
+        "use strict";
+        module.exports = require("@midscene/core/yaml");
+    },
+    "@midscene/shared/logger" (module) {
+        "use strict";
+        module.exports = require("@midscene/shared/logger");
+    },
     assert (module) {
         "use strict";
         module.exports = require("assert");
@@ -12123,6 +11451,22 @@ Examples:
         "use strict";
         module.exports = require("fs");
     },
+    "lodash.merge" (module) {
+        "use strict";
+        module.exports = require("lodash.merge");
+    },
+    "node:fs" (module) {
+        "use strict";
+        module.exports = require("node:fs");
+    },
+    "node:path" (module) {
+        "use strict";
+        module.exports = require("node:path");
+    },
+    "node:url" (module) {
+        "use strict";
+        module.exports = require("node:url");
+    },
     os (module) {
         "use strict";
         module.exports = require("os");