@rstest/browser 0.7.9

package/dist/index.js

@@ -0,0 +1,2576 @@
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { existsSync } from "node:fs";
+import promises from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { TEMP_RSTEST_OUTPUT_DIR, color, getSetupFiles, getTestEntries, isDebug, logger, rsbuild, serializableConfig } from "@rstest/core/browser";
+import open_editor from "open-editor";
+import { basename, dirname, join, normalize, relative, resolve as external_pathe_resolve } from "pathe";
+import sirv from "sirv";
+import { WebSocketServer } from "ws";
+__webpack_require__.add({
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const pico = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js");
+        function picomatch(glob, options, returnState = false) {
+            if (options && (null === options.windows || void 0 === options.windows)) options = {
+                ...options,
+                windows: utils.isWindows()
+            };
+            return pico(glob, options, returnState);
+        }
+        Object.assign(picomatch, pico);
+        module.exports = picomatch;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js" (module) {
+        const WIN_SLASH = '\\\\/';
+        const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+        const DOT_LITERAL = '\\.';
+        const PLUS_LITERAL = '\\+';
+        const QMARK_LITERAL = '\\?';
+        const SLASH_LITERAL = '\\/';
+        const ONE_CHAR = '(?=.)';
+        const QMARK = '[^/]';
+        const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+        const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+        const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+        const NO_DOT = `(?!${DOT_LITERAL})`;
+        const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+        const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+        const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+        const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+        const STAR = `${QMARK}*?`;
+        const SEP = '/';
+        const POSIX_CHARS = {
+            DOT_LITERAL,
+            PLUS_LITERAL,
+            QMARK_LITERAL,
+            SLASH_LITERAL,
+            ONE_CHAR,
+            QMARK,
+            END_ANCHOR,
+            DOTS_SLASH,
+            NO_DOT,
+            NO_DOTS,
+            NO_DOT_SLASH,
+            NO_DOTS_SLASH,
+            QMARK_NO_DOT,
+            STAR,
+            START_ANCHOR,
+            SEP
+        };
+        const WINDOWS_CHARS = {
+            ...POSIX_CHARS,
+            SLASH_LITERAL: `[${WIN_SLASH}]`,
+            QMARK: WIN_NO_SLASH,
+            STAR: `${WIN_NO_SLASH}*?`,
+            DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+            NO_DOT: `(?!${DOT_LITERAL})`,
+            NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+            NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+            NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+            QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+            START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+            END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+            SEP: '\\'
+        };
+        const POSIX_REGEX_SOURCE = {
+            alnum: 'a-zA-Z0-9',
+            alpha: 'a-zA-Z',
+            ascii: '\\x00-\\x7F',
+            blank: ' \\t',
+            cntrl: '\\x00-\\x1F\\x7F',
+            digit: '0-9',
+            graph: '\\x21-\\x7E',
+            lower: 'a-z',
+            print: '\\x20-\\x7E ',
+            punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+            space: ' \\t\\r\\n\\v\\f',
+            upper: 'A-Z',
+            word: 'A-Za-z0-9_',
+            xdigit: 'A-Fa-f0-9'
+        };
+        module.exports = {
+            MAX_LENGTH: 65536,
+            POSIX_REGEX_SOURCE,
+            REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+            REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+            REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+            REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+            REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+            REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+            REPLACEMENTS: {
+                __proto__: null,
+                '***': '*',
+                '**/**': '**',
+                '**/**/**': '**'
+            },
+            CHAR_0: 48,
+            CHAR_9: 57,
+            CHAR_UPPERCASE_A: 65,
+            CHAR_LOWERCASE_A: 97,
+            CHAR_UPPERCASE_Z: 90,
+            CHAR_LOWERCASE_Z: 122,
+            CHAR_LEFT_PARENTHESES: 40,
+            CHAR_RIGHT_PARENTHESES: 41,
+            CHAR_ASTERISK: 42,
+            CHAR_AMPERSAND: 38,
+            CHAR_AT: 64,
+            CHAR_BACKWARD_SLASH: 92,
+            CHAR_CARRIAGE_RETURN: 13,
+            CHAR_CIRCUMFLEX_ACCENT: 94,
+            CHAR_COLON: 58,
+            CHAR_COMMA: 44,
+            CHAR_DOT: 46,
+            CHAR_DOUBLE_QUOTE: 34,
+            CHAR_EQUAL: 61,
+            CHAR_EXCLAMATION_MARK: 33,
+            CHAR_FORM_FEED: 12,
+            CHAR_FORWARD_SLASH: 47,
+            CHAR_GRAVE_ACCENT: 96,
+            CHAR_HASH: 35,
+            CHAR_HYPHEN_MINUS: 45,
+            CHAR_LEFT_ANGLE_BRACKET: 60,
+            CHAR_LEFT_CURLY_BRACE: 123,
+            CHAR_LEFT_SQUARE_BRACKET: 91,
+            CHAR_LINE_FEED: 10,
+            CHAR_NO_BREAK_SPACE: 160,
+            CHAR_PERCENT: 37,
+            CHAR_PLUS: 43,
+            CHAR_QUESTION_MARK: 63,
+            CHAR_RIGHT_ANGLE_BRACKET: 62,
+            CHAR_RIGHT_CURLY_BRACE: 125,
+            CHAR_RIGHT_SQUARE_BRACKET: 93,
+            CHAR_SEMICOLON: 59,
+            CHAR_SINGLE_QUOTE: 39,
+            CHAR_SPACE: 32,
+            CHAR_TAB: 9,
+            CHAR_UNDERSCORE: 95,
+            CHAR_VERTICAL_LINE: 124,
+            CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+            extglobChars (chars) {
+                return {
+                    '!': {
+                        type: 'negate',
+                        open: '(?:(?!(?:',
+                        close: `))${chars.STAR})`
+                    },
+                    '?': {
+                        type: 'qmark',
+                        open: '(?:',
+                        close: ')?'
+                    },
+                    '+': {
+                        type: 'plus',
+                        open: '(?:',
+                        close: ')+'
+                    },
+                    '*': {
+                        type: 'star',
+                        open: '(?:',
+                        close: ')*'
+                    },
+                    '@': {
+                        type: 'at',
+                        open: '(?:',
+                        close: ')'
+                    }
+                };
+            },
+            globChars (win32) {
+                return true === win32 ? WINDOWS_CHARS : POSIX_CHARS;
+            }
+        };
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const constants = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js");
+        const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants;
+        const expandRange = (args, options)=>{
+            if ('function' == typeof options.expandRange) return options.expandRange(...args, options);
+            args.sort();
+            const value = `[${args.join('-')}]`;
+            try {
+                new RegExp(value);
+            } catch (ex) {
+                return args.map((v)=>utils.escapeRegex(v)).join('..');
+            }
+            return value;
+        };
+        const syntaxError = (type, char)=>`Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+        const parse = (input, options)=>{
+            if ('string' != typeof input) throw new TypeError('Expected a string');
+            input = REPLACEMENTS[input] || input;
+            const opts = {
+                ...options
+            };
+            const max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            let len = input.length;
+            if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            const bos = {
+                type: 'bos',
+                value: '',
+                output: opts.prepend || ''
+            };
+            const tokens = [
+                bos
+            ];
+            const capture = opts.capture ? '' : '?:';
+            const PLATFORM_CHARS = constants.globChars(opts.windows);
+            const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+            const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS;
+            const globstar = (opts)=>`(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+            const nodot = opts.dot ? '' : NO_DOT;
+            const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+            let star = true === opts.bash ? globstar(opts) : STAR;
+            if (opts.capture) star = `(${star})`;
+            if ('boolean' == typeof opts.noext) opts.noextglob = opts.noext;
+            const state = {
+                input,
+                index: -1,
+                start: 0,
+                dot: true === opts.dot,
+                consumed: '',
+                output: '',
+                prefix: '',
+                backtrack: false,
+                negated: false,
+                brackets: 0,
+                braces: 0,
+                parens: 0,
+                quotes: 0,
+                globstar: false,
+                tokens
+            };
+            input = utils.removePrefix(input, state);
+            len = input.length;
+            const extglobs = [];
+            const braces = [];
+            const stack = [];
+            let prev = bos;
+            let value;
+            const eos = ()=>state.index === len - 1;
+            const peek = state.peek = (n = 1)=>input[state.index + n];
+            const advance = state.advance = ()=>input[++state.index] || '';
+            const remaining = ()=>input.slice(state.index + 1);
+            const consume = (value = '', num = 0)=>{
+                state.consumed += value;
+                state.index += num;
+            };
+            const append = (token)=>{
+                state.output += null != token.output ? token.output : token.value;
+                consume(token.value);
+            };
+            const negate = ()=>{
+                let count = 1;
+                while('!' === peek() && ('(' !== peek(2) || '?' === peek(3))){
+                    advance();
+                    state.start++;
+                    count++;
+                }
+                if (count % 2 === 0) return false;
+                state.negated = true;
+                state.start++;
+                return true;
+            };
+            const increment = (type)=>{
+                state[type]++;
+                stack.push(type);
+            };
+            const decrement = (type)=>{
+                state[type]--;
+                stack.pop();
+            };
+            const push = (tok)=>{
+                if ('globstar' === prev.type) {
+                    const isBrace = state.braces > 0 && ('comma' === tok.type || 'brace' === tok.type);
+                    const isExtglob = true === tok.extglob || extglobs.length && ('pipe' === tok.type || 'paren' === tok.type);
+                    if ('slash' !== tok.type && 'paren' !== tok.type && !isBrace && !isExtglob) {
+                        state.output = state.output.slice(0, -prev.output.length);
+                        prev.type = 'star';
+                        prev.value = '*';
+                        prev.output = star;
+                        state.output += prev.output;
+                    }
+                }
+                if (extglobs.length && 'paren' !== tok.type) extglobs[extglobs.length - 1].inner += tok.value;
+                if (tok.value || tok.output) append(tok);
+                if (prev && 'text' === prev.type && 'text' === tok.type) {
+                    prev.output = (prev.output || prev.value) + tok.value;
+                    prev.value += tok.value;
+                    return;
+                }
+                tok.prev = prev;
+                tokens.push(tok);
+                prev = tok;
+            };
+            const extglobOpen = (type, value)=>{
+                const token = {
+                    ...EXTGLOB_CHARS[value],
+                    conditions: 1,
+                    inner: ''
+                };
+                token.prev = prev;
+                token.parens = state.parens;
+                token.output = state.output;
+                const output = (opts.capture ? '(' : '') + token.open;
+                increment('parens');
+                push({
+                    type,
+                    value,
+                    output: state.output ? '' : ONE_CHAR
+                });
+                push({
+                    type: 'paren',
+                    extglob: true,
+                    value: advance(),
+                    output
+                });
+                extglobs.push(token);
+            };
+            const extglobClose = (token)=>{
+                let output = token.close + (opts.capture ? ')' : '');
+                let rest;
+                if ('negate' === token.type) {
+                    let extglobStar = star;
+                    if (token.inner && token.inner.length > 1 && token.inner.includes('/')) extglobStar = globstar(opts);
+                    if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) output = token.close = `)$))${extglobStar}`;
+                    if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+                        const expression = parse(rest, {
+                            ...options,
+                            fastpaths: false
+                        }).output;
+                        output = token.close = `)${expression})${extglobStar})`;
+                    }
+                    if ('bos' === token.prev.type) state.negatedExtglob = true;
+                }
+                push({
+                    type: 'paren',
+                    extglob: true,
+                    value,
+                    output
+                });
+                decrement('parens');
+            };
+            if (false !== opts.fastpaths && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+                let backslashes = false;
+                let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index)=>{
+                    if ('\\' === first) {
+                        backslashes = true;
+                        return m;
+                    }
+                    if ('?' === first) {
+                        if (esc) return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+                        if (0 === index) return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+                        return QMARK.repeat(chars.length);
+                    }
+                    if ('.' === first) return DOT_LITERAL.repeat(chars.length);
+                    if ('*' === first) {
+                        if (esc) return esc + first + (rest ? star : '');
+                        return star;
+                    }
+                    return esc ? m : `\\${m}`;
+                });
+                if (true === backslashes) output = true === opts.unescape ? output.replace(/\\/g, '') : output.replace(/\\+/g, (m)=>m.length % 2 === 0 ? '\\\\' : m ? '\\' : '');
+                if (output === input && true === opts.contains) {
+                    state.output = input;
+                    return state;
+                }
+                state.output = utils.wrapOutput(output, state, options);
+                return state;
+            }
+            while(!eos()){
+                value = advance();
+                if ('\u0000' === value) continue;
+                if ('\\' === value) {
+                    const next = peek();
+                    if ('/' === next && true !== opts.bash) continue;
+                    if ('.' === next || ';' === next) continue;
+                    if (!next) {
+                        value += '\\';
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    const match = /^\\+/.exec(remaining());
+                    let slashes = 0;
+                    if (match && match[0].length > 2) {
+                        slashes = match[0].length;
+                        state.index += slashes;
+                        if (slashes % 2 !== 0) value += '\\';
+                    }
+                    if (true === opts.unescape) value = advance();
+                    else value += advance();
+                    if (0 === state.brackets) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                }
+                if (state.brackets > 0 && (']' !== value || '[' === prev.value || '[^' === prev.value)) {
+                    if (false !== opts.posix && ':' === value) {
+                        const inner = prev.value.slice(1);
+                        if (inner.includes('[')) {
+                            prev.posix = true;
+                            if (inner.includes(':')) {
+                                const idx = prev.value.lastIndexOf('[');
+                                const pre = prev.value.slice(0, idx);
+                                const rest = prev.value.slice(idx + 2);
+                                const posix = POSIX_REGEX_SOURCE[rest];
+                                if (posix) {
+                                    prev.value = pre + posix;
+                                    state.backtrack = true;
+                                    advance();
+                                    if (!bos.output && 1 === tokens.indexOf(prev)) bos.output = ONE_CHAR;
+                                    continue;
+                                }
+                            }
+                        }
+                    }
+                    if ('[' === value && ':' !== peek() || '-' === value && ']' === peek()) value = `\\${value}`;
+                    if (']' === value && ('[' === prev.value || '[^' === prev.value)) value = `\\${value}`;
+                    if (true === opts.posix && '!' === value && '[' === prev.value) value = '^';
+                    prev.value += value;
+                    append({
+                        value
+                    });
+                    continue;
+                }
+                if (1 === state.quotes && '"' !== value) {
+                    value = utils.escapeRegex(value);
+                    prev.value += value;
+                    append({
+                        value
+                    });
+                    continue;
+                }
+                if ('"' === value) {
+                    state.quotes = 1 === state.quotes ? 0 : 1;
+                    if (true === opts.keepQuotes) push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('(' === value) {
+                    increment('parens');
+                    push({
+                        type: 'paren',
+                        value
+                    });
+                    continue;
+                }
+                if (')' === value) {
+                    if (0 === state.parens && true === opts.strictBrackets) throw new SyntaxError(syntaxError('opening', '('));
+                    const extglob = extglobs[extglobs.length - 1];
+                    if (extglob && state.parens === extglob.parens + 1) {
+                        extglobClose(extglobs.pop());
+                        continue;
+                    }
+                    push({
+                        type: 'paren',
+                        value,
+                        output: state.parens ? ')' : '\\)'
+                    });
+                    decrement('parens');
+                    continue;
+                }
+                if ('[' === value) {
+                    if (true !== opts.nobracket && remaining().includes(']')) increment('brackets');
+                    else {
+                        if (true !== opts.nobracket && true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ']'));
+                        value = `\\${value}`;
+                    }
+                    push({
+                        type: 'bracket',
+                        value
+                    });
+                    continue;
+                }
+                if (']' === value) {
+                    if (true === opts.nobracket || prev && 'bracket' === prev.type && 1 === prev.value.length) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    if (0 === state.brackets) {
+                        if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('opening', '['));
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    decrement('brackets');
+                    const prevValue = prev.value.slice(1);
+                    if (true !== prev.posix && '^' === prevValue[0] && !prevValue.includes('/')) value = `/${value}`;
+                    prev.value += value;
+                    append({
+                        value
+                    });
+                    if (false === opts.literalBrackets || utils.hasRegexChars(prevValue)) continue;
+                    const escaped = utils.escapeRegex(prev.value);
+                    state.output = state.output.slice(0, -prev.value.length);
+                    if (true === opts.literalBrackets) {
+                        state.output += escaped;
+                        prev.value = escaped;
+                        continue;
+                    }
+                    prev.value = `(${capture}${escaped}|${prev.value})`;
+                    state.output += prev.value;
+                    continue;
+                }
+                if ('{' === value && true !== opts.nobrace) {
+                    increment('braces');
+                    const open = {
+                        type: 'brace',
+                        value,
+                        output: '(',
+                        outputIndex: state.output.length,
+                        tokensIndex: state.tokens.length
+                    };
+                    braces.push(open);
+                    push(open);
+                    continue;
+                }
+                if ('}' === value) {
+                    const brace = braces[braces.length - 1];
+                    if (true === opts.nobrace || !brace) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: value
+                        });
+                        continue;
+                    }
+                    let output = ')';
+                    if (true === brace.dots) {
+                        const arr = tokens.slice();
+                        const range = [];
+                        for(let i = arr.length - 1; i >= 0; i--){
+                            tokens.pop();
+                            if ('brace' === arr[i].type) break;
+                            if ('dots' !== arr[i].type) range.unshift(arr[i].value);
+                        }
+                        output = expandRange(range, opts);
+                        state.backtrack = true;
+                    }
+                    if (true !== brace.comma && true !== brace.dots) {
+                        const out = state.output.slice(0, brace.outputIndex);
+                        const toks = state.tokens.slice(brace.tokensIndex);
+                        brace.value = brace.output = '\\{';
+                        value = output = '\\}';
+                        state.output = out;
+                        for (const t of toks)state.output += t.output || t.value;
+                    }
+                    push({
+                        type: 'brace',
+                        value,
+                        output
+                    });
+                    decrement('braces');
+                    braces.pop();
+                    continue;
+                }
+                if ('|' === value) {
+                    if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (',' === value) {
+                    let output = value;
+                    const brace = braces[braces.length - 1];
+                    if (brace && 'braces' === stack[stack.length - 1]) {
+                        brace.comma = true;
+                        output = '|';
+                    }
+                    push({
+                        type: 'comma',
+                        value,
+                        output
+                    });
+                    continue;
+                }
+                if ('/' === value) {
+                    if ('dot' === prev.type && state.index === state.start + 1) {
+                        state.start = state.index + 1;
+                        state.consumed = '';
+                        state.output = '';
+                        tokens.pop();
+                        prev = bos;
+                        continue;
+                    }
+                    push({
+                        type: 'slash',
+                        value,
+                        output: SLASH_LITERAL
+                    });
+                    continue;
+                }
+                if ('.' === value) {
+                    if (state.braces > 0 && 'dot' === prev.type) {
+                        if ('.' === prev.value) prev.output = DOT_LITERAL;
+                        const brace = braces[braces.length - 1];
+                        prev.type = 'dots';
+                        prev.output += value;
+                        prev.value += value;
+                        brace.dots = true;
+                        continue;
+                    }
+                    if (state.braces + state.parens === 0 && 'bos' !== prev.type && 'slash' !== prev.type) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: DOT_LITERAL
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'dot',
+                        value,
+                        output: DOT_LITERAL
+                    });
+                    continue;
+                }
+                if ('?' === value) {
+                    const isGroup = prev && '(' === prev.value;
+                    if (!isGroup && true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('qmark', value);
+                        continue;
+                    }
+                    if (prev && 'paren' === prev.type) {
+                        const next = peek();
+                        let output = value;
+                        if ('(' === prev.value && !/[!=<:]/.test(next) || '<' === next && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value}`;
+                        push({
+                            type: 'text',
+                            value,
+                            output
+                        });
+                        continue;
+                    }
+                    if (true !== opts.dot && ('slash' === prev.type || 'bos' === prev.type)) {
+                        push({
+                            type: 'qmark',
+                            value,
+                            output: QMARK_NO_DOT
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'qmark',
+                        value,
+                        output: QMARK
+                    });
+                    continue;
+                }
+                if ('!' === value) {
+                    if (true !== opts.noextglob && '(' === peek()) {
+                        if ('?' !== peek(2) || !/[!=<:]/.test(peek(3))) {
+                            extglobOpen('negate', value);
+                            continue;
+                        }
+                    }
+                    if (true !== opts.nonegate && 0 === state.index) {
+                        negate();
+                        continue;
+                    }
+                }
+                if ('+' === value) {
+                    if (true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('plus', value);
+                        continue;
+                    }
+                    if (prev && '(' === prev.value || false === opts.regex) {
+                        push({
+                            type: 'plus',
+                            value,
+                            output: PLUS_LITERAL
+                        });
+                        continue;
+                    }
+                    if (prev && ('bracket' === prev.type || 'paren' === prev.type || 'brace' === prev.type) || state.parens > 0) {
+                        push({
+                            type: 'plus',
+                            value
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'plus',
+                        value: PLUS_LITERAL
+                    });
+                    continue;
+                }
+                if ('@' === value) {
+                    if (true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        push({
+                            type: 'at',
+                            extglob: true,
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('*' !== value) {
+                    if ('$' === value || '^' === value) value = `\\${value}`;
+                    const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+                    if (match) {
+                        value += match[0];
+                        state.index += match[0].length;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (prev && ('globstar' === prev.type || true === prev.star)) {
+                    prev.type = 'star';
+                    prev.star = true;
+                    prev.value += value;
+                    prev.output = star;
+                    state.backtrack = true;
+                    state.globstar = true;
+                    consume(value);
+                    continue;
+                }
+                let rest = remaining();
+                if (true !== opts.noextglob && /^\([^?]/.test(rest)) {
+                    extglobOpen('star', value);
+                    continue;
+                }
+                if ('star' === prev.type) {
+                    if (true === opts.noglobstar) {
+                        consume(value);
+                        continue;
+                    }
+                    const prior = prev.prev;
+                    const before = prior.prev;
+                    const isStart = 'slash' === prior.type || 'bos' === prior.type;
+                    const afterStar = before && ('star' === before.type || 'globstar' === before.type);
+                    if (true === opts.bash && (!isStart || rest[0] && '/' !== rest[0])) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    const isBrace = state.braces > 0 && ('comma' === prior.type || 'brace' === prior.type);
+                    const isExtglob = extglobs.length && ('pipe' === prior.type || 'paren' === prior.type);
+                    if (!isStart && 'paren' !== prior.type && !isBrace && !isExtglob) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    while('/**' === rest.slice(0, 3)){
+                        const after = input[state.index + 4];
+                        if (after && '/' !== after) break;
+                        rest = rest.slice(3);
+                        consume('/**', 3);
+                    }
+                    if ('bos' === prior.type && eos()) {
+                        prev.type = 'globstar';
+                        prev.value += value;
+                        prev.output = globstar(opts);
+                        state.output = prev.output;
+                        state.globstar = true;
+                        consume(value);
+                        continue;
+                    }
+                    if ('slash' === prior.type && 'bos' !== prior.prev.type && !afterStar && eos()) {
+                        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+                        prior.output = `(?:${prior.output}`;
+                        prev.type = 'globstar';
+                        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+                        prev.value += value;
+                        state.globstar = true;
+                        state.output += prior.output + prev.output;
+                        consume(value);
+                        continue;
+                    }
+                    if ('slash' === prior.type && 'bos' !== prior.prev.type && '/' === rest[0]) {
+                        const end = void 0 !== rest[1] ? '|$' : '';
+                        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+                        prior.output = `(?:${prior.output}`;
+                        prev.type = 'globstar';
+                        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+                        prev.value += value;
+                        state.output += prior.output + prev.output;
+                        state.globstar = true;
+                        consume(value + advance());
+                        push({
+                            type: 'slash',
+                            value: '/',
+                            output: ''
+                        });
+                        continue;
+                    }
+                    if ('bos' === prior.type && '/' === rest[0]) {
+                        prev.type = 'globstar';
+                        prev.value += value;
+                        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+                        state.output = prev.output;
+                        state.globstar = true;
+                        consume(value + advance());
+                        push({
+                            type: 'slash',
+                            value: '/',
+                            output: ''
+                        });
+                        continue;
+                    }
+                    state.output = state.output.slice(0, -prev.output.length);
+                    prev.type = 'globstar';
+                    prev.output = globstar(opts);
+                    prev.value += value;
+                    state.output += prev.output;
+                    state.globstar = true;
+                    consume(value);
+                    continue;
+                }
+                const token = {
+                    type: 'star',
+                    value,
+                    output: star
+                };
+                if (true === opts.bash) {
+                    token.output = '.*?';
+                    if ('bos' === prev.type || 'slash' === prev.type) token.output = nodot + token.output;
+                    push(token);
+                    continue;
+                }
+                if (prev && ('bracket' === prev.type || 'paren' === prev.type) && true === opts.regex) {
+                    token.output = value;
+                    push(token);
+                    continue;
+                }
+                if (state.index === state.start || 'slash' === prev.type || 'dot' === prev.type) {
+                    if ('dot' === prev.type) {
+                        state.output += NO_DOT_SLASH;
+                        prev.output += NO_DOT_SLASH;
+                    } else if (true === opts.dot) {
+                        state.output += NO_DOTS_SLASH;
+                        prev.output += NO_DOTS_SLASH;
+                    } else {
+                        state.output += nodot;
+                        prev.output += nodot;
+                    }
+                    if ('*' !== peek()) {
+                        state.output += ONE_CHAR;
+                        prev.output += ONE_CHAR;
+                    }
+                }
+                push(token);
+            }
+            while(state.brackets > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ']'));
+                state.output = utils.escapeLast(state.output, '[');
+                decrement('brackets');
+            }
+            while(state.parens > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ')'));
+                state.output = utils.escapeLast(state.output, '(');
+                decrement('parens');
+            }
+            while(state.braces > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', '}'));
+                state.output = utils.escapeLast(state.output, '{');
+                decrement('braces');
+            }
+            if (true !== opts.strictSlashes && ('star' === prev.type || 'bracket' === prev.type)) push({
+                type: 'maybe_slash',
+                value: '',
+                output: `${SLASH_LITERAL}?`
+            });
+            if (true === state.backtrack) {
+                state.output = '';
+                for (const token of state.tokens){
+                    state.output += null != token.output ? token.output : token.value;
+                    if (token.suffix) state.output += token.suffix;
+                }
+            }
+            return state;
+        };
+        parse.fastpaths = (input, options)=>{
+            const opts = {
+                ...options
+            };
+            const max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            const len = input.length;
+            if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            input = REPLACEMENTS[input] || input;
+            const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(opts.windows);
+            const nodot = opts.dot ? NO_DOTS : NO_DOT;
+            const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+            const capture = opts.capture ? '' : '?:';
+            const state = {
+                negated: false,
+                prefix: ''
+            };
+            let star = true === opts.bash ? '.*?' : STAR;
+            if (opts.capture) star = `(${star})`;
+            const globstar = (opts)=>{
+                if (true === opts.noglobstar) return star;
+                return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+            };
+            const create = (str)=>{
+                switch(str){
+                    case '*':
+                        return `${nodot}${ONE_CHAR}${star}`;
+                    case '.*':
+                        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '*.*':
+                        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '*/*':
+                        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+                    case '**':
+                        return nodot + globstar(opts);
+                    case '**/*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+                    case '**/*.*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '**/.*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    default:
+                        {
+                            const match = /^(.*?)\.(\w+)$/.exec(str);
+                            if (!match) return;
+                            const source = create(match[1]);
+                            if (!source) return;
+                            return source + DOT_LITERAL + match[2];
+                        }
+                }
+            };
+            const output = utils.removePrefix(input, state);
+            let source = create(output);
+            if (source && true !== opts.strictSlashes) source += `${SLASH_LITERAL}?`;
+            return source;
+        };
+        module.exports = parse;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const scan = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/scan.js");
+        const parse = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/parse.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js");
+        const constants = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js");
+        const isObject = (val)=>val && 'object' == typeof val && !Array.isArray(val);
+        const picomatch = (glob, options, returnState = false)=>{
+            if (Array.isArray(glob)) {
+                const fns = glob.map((input)=>picomatch(input, options, returnState));
+                const arrayMatcher = (str)=>{
+                    for (const isMatch of fns){
+                        const state = isMatch(str);
+                        if (state) return state;
+                    }
+                    return false;
+                };
+                return arrayMatcher;
+            }
+            const isState = isObject(glob) && glob.tokens && glob.input;
+            if ('' === glob || 'string' != typeof glob && !isState) throw new TypeError('Expected pattern to be a non-empty string');
+            const opts = options || {};
+            const posix = opts.windows;
+            const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+            const state = regex.state;
+            delete regex.state;
+            let isIgnored = ()=>false;
+            if (opts.ignore) {
+                const ignoreOpts = {
+                    ...options,
+                    ignore: null,
+                    onMatch: null,
+                    onResult: null
+                };
+                isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+            }
+            const matcher = (input, returnObject = false)=>{
+                const { isMatch, match, output } = picomatch.test(input, regex, options, {
+                    glob,
+                    posix
+                });
+                const result = {
+                    glob,
+                    state,
+                    regex,
+                    posix,
+                    input,
+                    output,
+                    match,
+                    isMatch
+                };
+                if ('function' == typeof opts.onResult) opts.onResult(result);
+                if (false === isMatch) {
+                    result.isMatch = false;
+                    return returnObject ? result : false;
+                }
+                if (isIgnored(input)) {
+                    if ('function' == typeof opts.onIgnore) opts.onIgnore(result);
+                    result.isMatch = false;
+                    return returnObject ? result : false;
+                }
+                if ('function' == typeof opts.onMatch) opts.onMatch(result);
+                return returnObject ? result : true;
+            };
+            if (returnState) matcher.state = state;
+            return matcher;
+        };
+        picomatch.test = (input, regex, options, { glob, posix } = {})=>{
+            if ('string' != typeof input) throw new TypeError('Expected input to be a string');
+            if ('' === input) return {
+                isMatch: false,
+                output: ''
+            };
+            const opts = options || {};
+            const format = opts.format || (posix ? utils.toPosixSlashes : null);
+            let match = input === glob;
+            let output = match && format ? format(input) : input;
+            if (false === match) {
+                output = format ? format(input) : input;
+                match = output === glob;
+            }
+            if (false === match || true === opts.capture) match = true === opts.matchBase || true === opts.basename ? picomatch.matchBase(input, regex, options, posix) : regex.exec(output);
+            return {
+                isMatch: Boolean(match),
+                match,
+                output
+            };
+        };
+        picomatch.matchBase = (input, glob, options)=>{
+            const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+            return regex.test(utils.basename(input));
+        };
+        picomatch.isMatch = (str, patterns, options)=>picomatch(patterns, options)(str);
+        picomatch.parse = (pattern, options)=>{
+            if (Array.isArray(pattern)) return pattern.map((p)=>picomatch.parse(p, options));
+            return parse(pattern, {
+                ...options,
+                fastpaths: false
+            });
+        };
+        picomatch.scan = (input, options)=>scan(input, options);
+        picomatch.compileRe = (state, options, returnOutput = false, returnState = false)=>{
+            if (true === returnOutput) return state.output;
+            const opts = options || {};
+            const prepend = opts.contains ? '' : '^';
+            const append = opts.contains ? '' : '$';
+            let source = `${prepend}(?:${state.output})${append}`;
+            if (state && true === state.negated) source = `^(?!${source}).*$`;
+            const regex = picomatch.toRegex(source, options);
+            if (true === returnState) regex.state = state;
+            return regex;
+        };
+        picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false)=>{
+            if (!input || 'string' != typeof input) throw new TypeError('Expected a non-empty string');
+            let parsed = {
+                negated: false,
+                fastpaths: true
+            };
+            if (false !== options.fastpaths && ('.' === input[0] || '*' === input[0])) parsed.output = parse.fastpaths(input, options);
+            if (!parsed.output) parsed = parse(input, options);
+            return picomatch.compileRe(parsed, options, returnOutput, returnState);
+        };
+        picomatch.toRegex = (source, options)=>{
+            try {
+                const opts = options || {};
+                return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+            } catch (err) {
+                if (options && true === options.debug) throw err;
+                return /$^/;
+            }
+        };
+        picomatch.constants = constants;
+        module.exports = picomatch;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/scan.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js");
+        const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js");
+        const isPathSeparator = (code)=>code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+        const depth = (token)=>{
+            if (true !== token.isPrefix) token.depth = token.isGlobstar ? 1 / 0 : 1;
+        };
+        const scan = (input, options)=>{
+            const opts = options || {};
+            const length = input.length - 1;
+            const scanToEnd = true === opts.parts || true === opts.scanToEnd;
+            const slashes = [];
+            const tokens = [];
+            const parts = [];
+            let str = input;
+            let index = -1;
+            let start = 0;
+            let lastIndex = 0;
+            let isBrace = false;
+            let isBracket = false;
+            let isGlob = false;
+            let isExtglob = false;
+            let isGlobstar = false;
+            let braceEscaped = false;
+            let backslashes = false;
+            let negated = false;
+            let negatedExtglob = false;
+            let finished = false;
+            let braces = 0;
+            let prev;
+            let code;
+            let token = {
+                value: '',
+                depth: 0,
+                isGlob: false
+            };
+            const eos = ()=>index >= length;
+            const peek = ()=>str.charCodeAt(index + 1);
+            const advance = ()=>{
+                prev = code;
+                return str.charCodeAt(++index);
+            };
+            while(index < length){
+                code = advance();
+                let next;
+                if (code === CHAR_BACKWARD_SLASH) {
+                    backslashes = token.backslashes = true;
+                    code = advance();
+                    if (code === CHAR_LEFT_CURLY_BRACE) braceEscaped = true;
+                    continue;
+                }
+                if (true === braceEscaped || code === CHAR_LEFT_CURLY_BRACE) {
+                    braces++;
+                    while(true !== eos() && (code = advance())){
+                        if (code === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = true;
+                            advance();
+                            continue;
+                        }
+                        if (code === CHAR_LEFT_CURLY_BRACE) {
+                            braces++;
+                            continue;
+                        }
+                        if (true !== braceEscaped && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+                            isBrace = token.isBrace = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            if (true === scanToEnd) continue;
+                            break;
+                        }
+                        if (true !== braceEscaped && code === CHAR_COMMA) {
+                            isBrace = token.isBrace = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            if (true === scanToEnd) continue;
+                            break;
+                        }
+                        if (code === CHAR_RIGHT_CURLY_BRACE) {
+                            braces--;
+                            if (0 === braces) {
+                                braceEscaped = false;
+                                isBrace = token.isBrace = true;
+                                finished = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_FORWARD_SLASH) {
+                    slashes.push(index);
+                    tokens.push(token);
+                    token = {
+                        value: '',
+                        depth: 0,
+                        isGlob: false
+                    };
+                    if (true === finished) continue;
+                    if (prev === CHAR_DOT && index === start + 1) {
+                        start += 2;
+                        continue;
+                    }
+                    lastIndex = index + 1;
+                    continue;
+                }
+                if (true !== opts.noext) {
+                    const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+                    if (true === isExtglobChar && peek() === CHAR_LEFT_PARENTHESES) {
+                        isGlob = token.isGlob = true;
+                        isExtglob = token.isExtglob = true;
+                        finished = true;
+                        if (code === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
+                        if (true === scanToEnd) {
+                            while(true !== eos() && (code = advance())){
+                                if (code === CHAR_BACKWARD_SLASH) {
+                                    backslashes = token.backslashes = true;
+                                    code = advance();
+                                    continue;
+                                }
+                                if (code === CHAR_RIGHT_PARENTHESES) {
+                                    isGlob = token.isGlob = true;
+                                    finished = true;
+                                    break;
+                                }
+                            }
+                            continue;
+                        }
+                        break;
+                    }
+                }
+                if (code === CHAR_ASTERISK) {
+                    if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+                    isGlob = token.isGlob = true;
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_QUESTION_MARK) {
+                    isGlob = token.isGlob = true;
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_LEFT_SQUARE_BRACKET) {
+                    while(true !== eos() && (next = advance())){
+                        if (next === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = true;
+                            advance();
+                            continue;
+                        }
+                        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                            isBracket = token.isBracket = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            break;
+                        }
+                    }
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (true !== opts.nonegate && code === CHAR_EXCLAMATION_MARK && index === start) {
+                    negated = token.negated = true;
+                    start++;
+                    continue;
+                }
+                if (true !== opts.noparen && code === CHAR_LEFT_PARENTHESES) {
+                    isGlob = token.isGlob = true;
+                    if (true === scanToEnd) {
+                        while(true !== eos() && (code = advance())){
+                            if (code === CHAR_LEFT_PARENTHESES) {
+                                backslashes = token.backslashes = true;
+                                code = advance();
+                                continue;
+                            }
+                            if (code === CHAR_RIGHT_PARENTHESES) {
+                                finished = true;
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                if (true === isGlob) {
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+            }
+            if (true === opts.noext) {
+                isExtglob = false;
+                isGlob = false;
+            }
+            let base = str;
+            let prefix = '';
+            let glob = '';
+            if (start > 0) {
+                prefix = str.slice(0, start);
+                str = str.slice(start);
+                lastIndex -= start;
+            }
+            if (base && true === isGlob && lastIndex > 0) {
+                base = str.slice(0, lastIndex);
+                glob = str.slice(lastIndex);
+            } else if (true === isGlob) {
+                base = '';
+                glob = str;
+            } else base = str;
+            if (base && '' !== base && '/' !== base && base !== str) {
+                if (isPathSeparator(base.charCodeAt(base.length - 1))) base = base.slice(0, -1);
+            }
+            if (true === opts.unescape) {
+                if (glob) glob = utils.removeBackslashes(glob);
+                if (base && true === backslashes) base = utils.removeBackslashes(base);
+            }
+            const state = {
+                prefix,
+                input,
+                start,
+                base,
+                glob,
+                isBrace,
+                isBracket,
+                isGlob,
+                isExtglob,
+                isGlobstar,
+                negated,
+                negatedExtglob
+            };
+            if (true === opts.tokens) {
+                state.maxDepth = 0;
+                if (!isPathSeparator(code)) tokens.push(token);
+                state.tokens = tokens;
+            }
+            if (true === opts.parts || true === opts.tokens) {
+                let prevIndex;
+                for(let idx = 0; idx < slashes.length; idx++){
+                    const n = prevIndex ? prevIndex + 1 : start;
+                    const i = slashes[idx];
+                    const value = input.slice(n, i);
+                    if (opts.tokens) {
+                        if (0 === idx && 0 !== start) {
+                            tokens[idx].isPrefix = true;
+                            tokens[idx].value = prefix;
+                        } else tokens[idx].value = value;
+                        depth(tokens[idx]);
+                        state.maxDepth += tokens[idx].depth;
+                    }
+                    if (0 !== idx || '' !== value) parts.push(value);
+                    prevIndex = i;
+                }
+                if (prevIndex && prevIndex + 1 < input.length) {
+                    const value = input.slice(prevIndex + 1);
+                    parts.push(value);
+                    if (opts.tokens) {
+                        tokens[tokens.length - 1].value = value;
+                        depth(tokens[tokens.length - 1]);
+                        state.maxDepth += tokens[tokens.length - 1].depth;
+                    }
+                }
+                state.slashes = slashes;
+                state.parts = parts;
+            }
+            return state;
+        };
+        module.exports = scan;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js" (__unused_rspack_module, exports, __webpack_require__) {
+        const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js");
+        exports.isObject = (val)=>null !== val && 'object' == typeof val && !Array.isArray(val);
+        exports.hasRegexChars = (str)=>REGEX_SPECIAL_CHARS.test(str);
+        exports.isRegexChar = (str)=>1 === str.length && exports.hasRegexChars(str);
+        exports.escapeRegex = (str)=>str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+        exports.toPosixSlashes = (str)=>str.replace(REGEX_BACKSLASH, '/');
+        exports.isWindows = ()=>{
+            if ("u" > typeof navigator && navigator.platform) {
+                const platform = navigator.platform.toLowerCase();
+                return 'win32' === platform || 'windows' === platform;
+            }
+            if ("u" > typeof process && process.platform) return 'win32' === process.platform;
+            return false;
+        };
+        exports.removeBackslashes = (str)=>str.replace(REGEX_REMOVE_BACKSLASH, (match)=>'\\' === match ? '' : match);
+        exports.escapeLast = (input, char, lastIdx)=>{
+            const idx = input.lastIndexOf(char, lastIdx);
+            if (-1 === idx) return input;
+            if ('\\' === input[idx - 1]) return exports.escapeLast(input, char, idx - 1);
+            return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+        };
+        exports.removePrefix = (input, state = {})=>{
+            let output = input;
+            if (output.startsWith('./')) {
+                output = output.slice(2);
+                state.prefix = './';
+            }
+            return output;
+        };
+        exports.wrapOutput = (input, state = {}, options = {})=>{
+            const prepend = options.contains ? '' : '^';
+            const append = options.contains ? '' : '$';
+            let output = `${prepend}(?:${input})${append}`;
+            if (true === state.negated) output = `(?:^(?!${output}).*$)`;
+            return output;
+        };
+        exports.basename = (path, { windows } = {})=>{
+            const segs = path.split(windows ? /[\\/]/ : '/');
+            const last = segs[segs.length - 1];
+            if ('' === last) return segs[segs.length - 2];
+            return last;
+        };
+    }
+});
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+    return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout: dist_clearTimeout, setTimeout: dist_setTimeout } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc($functions, options) {
+    const { post, on, off = ()=>{}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT } = options;
+    let $closed = false;
+    const _rpcPromiseMap = /* @__PURE__ */ new Map();
+    let _promiseInit;
+    let rpc;
+    async function _call(method, args, event, optional) {
+        if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+        const req = {
+            m: method,
+            a: args,
+            t: TYPE_REQUEST
+        };
+        if (optional) req.o = true;
+        const send = async (_req)=>post(serialize(_req));
+        if (event) return void await send(req);
+        if (_promiseInit) try {
+            await _promiseInit;
+        } finally{
+            _promiseInit = void 0;
+        }
+        let { promise, resolve, reject } = createPromiseWithResolvers();
+        const id = nanoid();
+        req.i = id;
+        let timeoutId;
+        async function handler(newReq = req) {
+            if (timeout >= 0) {
+                timeoutId = dist_setTimeout(()=>{
+                    try {
+                        const handleResult = options.onTimeoutError?.call(rpc, method, args);
+                        if (true !== handleResult) throw new Error(`[birpc] timeout on calling "${method}"`);
+                    } catch (e) {
+                        reject(e);
+                    }
+                    _rpcPromiseMap.delete(id);
+                }, timeout);
+                if ("object" == typeof timeoutId) timeoutId = timeoutId.unref?.();
+            }
+            _rpcPromiseMap.set(id, {
+                resolve,
+                reject,
+                timeoutId,
+                method
+            });
+            await send(newReq);
+            return promise;
+        }
+        try {
+            if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+            else await handler();
+        } catch (e) {
+            if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+            return;
+        } finally{
+            dist_clearTimeout(timeoutId);
+            _rpcPromiseMap.delete(id);
+        }
+        return promise;
+    }
+    const $call = (method, ...args)=>_call(method, args, false);
+    const $callOptional = (method, ...args)=>_call(method, args, false, true);
+    const $callEvent = (method, ...args)=>_call(method, args, true);
+    const $callRaw = (options2)=>_call(options2.method, options2.args, options2.event, options2.optional);
+    const builtinMethods = {
+        $call,
+        $callOptional,
+        $callEvent,
+        $callRaw,
+        $rejectPendingCalls,
+        get $closed () {
+            return $closed;
+        },
+        get $meta () {
+            return options.meta;
+        },
+        $close,
+        $functions
+    };
+    rpc = new Proxy({}, {
+        get (_, method) {
+            if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+            if ("then" === method && !eventNames.includes("then") && !("then" in $functions)) return;
+            const sendEvent = (...args)=>_call(method, args, true);
+            if (eventNames.includes(method)) {
+                sendEvent.asEvent = sendEvent;
+                return sendEvent;
+            }
+            const sendCall = (...args)=>_call(method, args, false);
+            sendCall.asEvent = sendEvent;
+            return sendCall;
+        }
+    });
+    function $close(customError) {
+        $closed = true;
+        _rpcPromiseMap.forEach(({ reject, method })=>{
+            const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+            if (customError) {
+                customError.cause ??= error;
+                return reject(customError);
+            }
+            reject(error);
+        });
+        _rpcPromiseMap.clear();
+        off(onMessage);
+    }
+    function $rejectPendingCalls(handler) {
+        const entries = Array.from(_rpcPromiseMap.values());
+        const handlerResults = entries.map(({ method, reject })=>{
+            if (!handler) return reject(new Error(`[birpc]: rejected pending call "${method}".`));
+            return handler({
+                method,
+                reject
+            });
+        });
+        _rpcPromiseMap.clear();
+        return handlerResults;
+    }
+    async function onMessage(data, ...extra) {
+        let msg;
+        try {
+            msg = deserialize(data);
+        } catch (e) {
+            if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+            return;
+        }
+        if (msg.t === TYPE_REQUEST) {
+            const { m: method, a: args, o: optional } = msg;
+            let result, error;
+            let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+            if (optional) fn ||= ()=>void 0;
+            if (fn) try {
+                result = await fn.apply("rpc" === bind ? rpc : $functions, args);
+            } catch (e) {
+                error = e;
+            }
+            else error = new Error(`[birpc] function "${method}" not found`);
+            if (msg.i) {
+                if (error && options.onError) options.onError.call(rpc, error, method, args);
+                if (error && options.onFunctionError) {
+                    if (true === options.onFunctionError.call(rpc, error, method, args)) return;
+                }
+                if (!error) try {
+                    await post(serialize({
+                        t: TYPE_RESPONSE,
+                        i: msg.i,
+                        r: result
+                    }), ...extra);
+                    return;
+                } catch (e) {
+                    error = e;
+                    if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+                }
+                try {
+                    await post(serialize({
+                        t: TYPE_RESPONSE,
+                        i: msg.i,
+                        e: error
+                    }), ...extra);
+                } catch (e) {
+                    if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+                }
+            }
+        } else {
+            const { i: ack, r: result, e: error } = msg;
+            const promise = _rpcPromiseMap.get(ack);
+            if (promise) {
+                dist_clearTimeout(promise.timeoutId);
+                if (error) promise.reject(error);
+                else promise.resolve(result);
+            }
+            _rpcPromiseMap.delete(ack);
+        }
+    }
+    _promiseInit = on(onMessage);
+    return rpc;
+}
+function createPromiseWithResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        promise,
+        resolve,
+        reject
+    };
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+    let id = "";
+    let i = size;
+    while(i--)id += urlAlphabet[64 * random() | 0];
+    return id;
+}
+const picomatch = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js");
+const { createRsbuild: createRsbuild, rspack: rspack } = rsbuild;
+const hostController_dirname = dirname(fileURLToPath(import.meta.url));
+class ContainerRpcManager {
+    wss;
+    ws = null;
+    rpc = null;
+    methods;
+    constructor(wss, methods){
+        this.wss = wss;
+        this.methods = methods;
+        this.setupConnectionHandler();
+    }
+    updateMethods(methods) {
+        this.methods = methods;
+        if (this.ws && this.ws.readyState === this.ws.OPEN) this.attachWebSocket(this.ws);
+    }
+    setupConnectionHandler() {
+        this.wss.on('connection', (ws)=>{
+            logger.log(color.gray('[Browser UI] Container WebSocket connected'));
+            logger.log(color.gray(`[Browser UI] Current ws: ${this.ws ? 'exists' : 'null'}, new ws: ${ws ? 'exists' : 'null'}`));
+            this.attachWebSocket(ws);
+        });
+    }
+    attachWebSocket(ws) {
+        this.ws = ws;
+        this.rpc = createBirpc(this.methods, {
+            post: (data)=>{
+                if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(data));
+            },
+            on: (fn)=>{
+                ws.on('message', (message)=>{
+                    try {
+                        const data = JSON.parse(message.toString());
+                        fn(data);
+                    } catch  {}
+                });
+            }
+        });
+        ws.on('close', ()=>{
+            if (this.ws === ws) {
+                this.ws = null;
+                this.rpc = null;
+            }
+        });
+    }
+    get isConnected() {
+        return null !== this.ws && this.ws.readyState === this.ws.OPEN;
+    }
+    get currentWebSocket() {
+        return this.ws;
+    }
+    reattach(ws) {
+        this.attachWebSocket(ws);
+    }
+    async notifyTestFileUpdate(files) {
+        await this.rpc?.onTestFileUpdate(files);
+    }
+    async reloadTestFile(testFile, testNamePattern) {
+        logger.log(color.gray(`[Browser UI] reloadTestFile called, rpc: ${this.rpc ? 'exists' : 'null'}, ws: ${this.ws ? 'exists' : 'null'}`));
+        if (!this.rpc) return void logger.log(color.yellow('[Browser UI] RPC not available, skipping reloadTestFile'));
+        logger.log(color.gray(`[Browser UI] Calling reloadTestFile: ${testFile}`));
+        await this.rpc.reloadTestFile(testFile, testNamePattern);
+    }
+}
+const watchContext = {
+    runtime: null,
+    lastTestFiles: [],
+    hooksEnabled: false,
+    cleanupRegistered: false
+};
+const ensureProcessExitCode = (code)=>{
+    if (void 0 === process.exitCode || 0 === process.exitCode) process.exitCode = code;
+};
+const globToRegexp = (glob)=>{
+    const regex = picomatch.makeRe(glob, {
+        fastpaths: false,
+        noglobstar: false,
+        bash: false
+    });
+    if (!regex) throw new Error(`Invalid glob pattern: ${glob}`);
+    if (!glob.startsWith('./')) return regex;
+    return new RegExp([
+        '^\\.',
+        glob.startsWith('./**') ? '' : '[\\\\/]',
+        regex.source.substring(1)
+    ].join(''));
+};
+const globPatternsToRegExp = (patterns)=>{
+    const regexParts = patterns.map((pattern)=>{
+        const regex = globToRegexp(pattern);
+        let source = regex.source;
+        if (source.startsWith('^')) source = source.substring(1);
+        if (source.endsWith('$')) source = source.substring(0, source.length - 1);
+        return source;
+    });
+    return new RegExp(`(?:${regexParts.join('|')})$`);
+};
+const excludePatternsToRegExp = (patterns)=>{
+    const keywords = [];
+    for (const pattern of patterns){
+        const match = pattern.match(/\*\*\/\.?\{?([^/*{}]+(?:,[^/*{}]+)*)\}?\/?\*?\*?/);
+        if (match) {
+            const parts = match[1].split(',');
+            for (const part of parts){
+                const cleaned = part.replace(/^\./, '');
+                if (cleaned && !keywords.includes(cleaned)) keywords.push(cleaned);
+            }
+        }
+    }
+    if (0 === keywords.length) return null;
+    return new RegExp(`[\\\\/](${keywords.join('|')})[\\\\/]`);
+};
+const getRuntimeConfigFromProject = (project)=>{
+    const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate, coverage, snapshotFormat, env, bail, logHeapUsage, chaiConfig, includeTaskLocation } = project.normalizedConfig;
+    return {
+        env,
+        testNamePattern,
+        testTimeout,
+        hookTimeout,
+        passWithNoTests,
+        retry,
+        globals,
+        clearMocks,
+        resetMocks,
+        restoreMocks,
+        unstubEnvs,
+        unstubGlobals,
+        maxConcurrency,
+        printConsoleTrace,
+        disableConsoleIntercept,
+        testEnvironment,
+        isolate,
+        coverage,
+        snapshotFormat,
+        bail,
+        logHeapUsage,
+        chaiConfig,
+        includeTaskLocation
+    };
+};
+const getBrowserProjects = (context)=>context.projects.filter((project)=>project.normalizedConfig.browser.enabled);
+const collectProjectEntries = async (context)=>{
+    const projectEntries = [];
+    const browserProjects = getBrowserProjects(context);
+    for (const project of browserProjects){
+        const { normalizedConfig: { include, exclude, includeSource, setupFiles } } = project;
+        const tests = await getTestEntries({
+            include,
+            exclude: exclude.patterns,
+            includeSource,
+            rootPath: context.rootPath,
+            projectRoot: project.rootPath,
+            fileFilters: context.fileFilters || []
+        });
+        const setup = getSetupFiles(setupFiles, project.rootPath);
+        projectEntries.push({
+            project,
+            setupFiles: Object.values(setup),
+            testFiles: Object.values(tests)
+        });
+    }
+    return projectEntries;
+};
+const resolveBrowserFile = (relativePath)=>{
+    const candidates = [
+        external_pathe_resolve(hostController_dirname, '../src', relativePath),
+        external_pathe_resolve(hostController_dirname, relativePath)
+    ];
+    for (const candidate of candidates)if (existsSync(candidate)) return candidate;
+    throw new Error(`Unable to resolve browser client file: ${relativePath}`);
+};
+const resolveContainerDist = ()=>{
+    const distPath = external_pathe_resolve(hostController_dirname, 'browser-container');
+    if (existsSync(distPath)) return distPath;
+    throw new Error(`Browser container build not found at ${distPath}. Please run "pnpm --filter @rstest/browser build".`);
+};
+const toSafeVarName = (name)=>name.replace(/[^a-zA-Z0-9_]/g, '_');
+const generateManifestModule = ({ manifestPath, entries })=>{
+    const manifestDirPosix = normalize(dirname(manifestPath));
+    const toRelativeImport = (filePath)=>{
+        const posixPath = normalize(filePath);
+        let relativePath = relative(manifestDirPosix, posixPath);
+        if (!relativePath.startsWith('.')) relativePath = `./${relativePath}`;
+        return relativePath;
+    };
+    const lines = [];
+    lines.push('// All projects configuration');
+    lines.push('export const projects = [');
+    for (const { project } of entries){
+        lines.push('  {');
+        lines.push(`    name: ${JSON.stringify(project.name)},`);
+        lines.push(`    environmentName: ${JSON.stringify(project.environmentName)},`);
+        lines.push(`    projectRoot: ${JSON.stringify(normalize(project.rootPath))},`);
+        lines.push('  },');
+    }
+    lines.push('];');
+    lines.push('');
+    lines.push('// Setup loaders for each project');
+    lines.push('export const projectSetupLoaders = {');
+    for (const { project, setupFiles } of entries){
+        lines.push(`  ${JSON.stringify(project.name)}: [`);
+        for (const filePath of setupFiles){
+            const relativePath = toRelativeImport(filePath);
+            lines.push(`    () => import(${JSON.stringify(relativePath)}),`);
+        }
+        lines.push('  ],');
+    }
+    lines.push('};');
+    lines.push('');
+    lines.push('// Test context for each project');
+    for (const { project } of entries){
+        const varName = `context_${toSafeVarName(project.environmentName)}`;
+        const projectRootPosix = normalize(project.rootPath);
+        const includeRegExp = globPatternsToRegExp(project.normalizedConfig.include);
+        const excludePatterns = project.normalizedConfig.exclude.patterns;
+        const excludeRegExp = excludePatternsToRegExp(excludePatterns);
+        lines.push(`const ${varName} = import.meta.webpackContext(${JSON.stringify(projectRootPosix)}, {`);
+        lines.push('  recursive: true,');
+        lines.push(`  regExp: ${includeRegExp.toString()},`);
+        if (excludeRegExp) lines.push(`  exclude: ${excludeRegExp.toString()},`);
+        lines.push("  mode: 'lazy',");
+        lines.push('});');
+        lines.push('');
+    }
+    lines.push('export const projectTestContexts = {');
+    for (const { project } of entries){
+        const varName = `context_${toSafeVarName(project.environmentName)}`;
+        lines.push(`  ${JSON.stringify(project.name)}: {`);
+        lines.push(`    getTestKeys: () => ${varName}.keys(),`);
+        lines.push(`    loadTest: (key) => ${varName}(key),`);
+        lines.push(`    projectRoot: ${JSON.stringify(normalize(project.rootPath))},`);
+        lines.push('  },');
+    }
+    lines.push('};');
+    lines.push('');
+    lines.push('// Backward compatibility: export first project as default');
+    lines.push('export const projectConfig = projects[0];');
+    lines.push('export const setupLoaders = projectSetupLoaders[projects[0].name] || [];');
+    lines.push('const _defaultCtx = projectTestContexts[projects[0].name];');
+    lines.push('export const getTestKeys = () => _defaultCtx ? _defaultCtx.getTestKeys() : [];');
+    lines.push('export const loadTest = (key) => _defaultCtx ? _defaultCtx.loadTest(key) : Promise.reject(new Error("No project found"));');
+    return `${lines.join('\n')}\n`;
+};
+const htmlTemplate = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>Rstest Browser Runner</title>
+  </head>
+  <body>
+    <script type="module" src="/static/js/runner.js"></script>
+  </body>
+</html>
+`;
+const destroyBrowserRuntime = async (runtime)=>{
+    try {
+        await runtime.browser?.close?.();
+    } catch  {}
+    try {
+        await runtime.devServer?.close?.();
+    } catch  {}
+    try {
+        runtime.wss?.close();
+    } catch  {}
+    await promises.rm(runtime.tempDir, {
+        recursive: true,
+        force: true
+    }).catch(()=>{});
+};
+const registerWatchCleanup = ()=>{
+    if (watchContext.cleanupRegistered) return;
+    const cleanup = async ()=>{
+        if (!watchContext.runtime) return;
+        await destroyBrowserRuntime(watchContext.runtime);
+        watchContext.runtime = null;
+    };
+    for (const signal of [
+        'SIGINT',
+        'SIGTERM'
+    ])process.once(signal, ()=>{
+        cleanup();
+    });
+    process.once('exit', ()=>{
+        cleanup();
+    });
+    watchContext.cleanupRegistered = true;
+};
+const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tempDir, isWatchMode, onTriggerRerun, containerDistPath, containerDevServer, forceHeadless })=>{
+    const virtualManifestPlugin = new rspack.experiments.VirtualModulesPlugin({
+        [manifestPath]: manifestSource
+    });
+    const optionsPlaceholder = '__RSTEST_OPTIONS_PLACEHOLDER__';
+    const containerHtmlTemplate = containerDistPath ? await promises.readFile(join(containerDistPath, 'container.html'), 'utf-8') : null;
+    let injectedContainerHtml = null;
+    let serializedOptions = 'null';
+    const setContainerOptions = (options)=>{
+        serializedOptions = JSON.stringify(options).replace(/</g, '\\u003c');
+        if (containerHtmlTemplate) injectedContainerHtml = containerHtmlTemplate.replace(optionsPlaceholder, serializedOptions);
+    };
+    const browserProjects = getBrowserProjects(context);
+    const firstProject = browserProjects[0];
+    const userPlugins = firstProject?.normalizedConfig.plugins || [];
+    const userRsbuildConfig = firstProject?.normalizedConfig ?? {};
+    const browserRuntimePath = fileURLToPath(import.meta.resolve('@rstest/core/browser-runtime'));
+    const rstestInternalAliases = {
+        '@rstest/browser-manifest': manifestPath,
+        '@rstest/core': resolveBrowserFile('client/public.ts'),
+        '@rstest/core/browser-runtime': browserRuntimePath,
+        '@sinonjs/fake-timers': resolveBrowserFile('client/fakeTimersStub.ts')
+    };
+    const rsbuildInstance = await createRsbuild({
+        callerName: 'rstest-browser',
+        rsbuildConfig: {
+            root: context.rootPath,
+            mode: 'development',
+            plugins: userPlugins,
+            server: {
+                printUrls: false,
+                port: context.normalizedConfig.browser.port,
+                strictPort: void 0 !== context.normalizedConfig.browser.port
+            },
+            dev: {
+                client: {
+                    logLevel: 'error'
+                }
+            },
+            environments: {
+                web: {}
+            }
+        }
+    });
+    rsbuildInstance.addPlugins([
+        {
+            name: 'rstest:browser-user-config',
+            setup (api) {
+                api.modifyEnvironmentConfig((config, { mergeEnvironmentConfig })=>{
+                    const merged = mergeEnvironmentConfig(config, userRsbuildConfig, {
+                        source: {
+                            entry: {
+                                runner: resolveBrowserFile('client/entry.ts')
+                            }
+                        },
+                        resolve: {
+                            alias: rstestInternalAliases
+                        },
+                        output: {
+                            target: 'web',
+                            sourceMap: {
+                                js: 'source-map'
+                            }
+                        },
+                        tools: {
+                            rspack: (rspackConfig)=>{
+                                rspackConfig.mode = 'development';
+                                rspackConfig.lazyCompilation = {
+                                    imports: true,
+                                    entries: false
+                                };
+                                rspackConfig.plugins = rspackConfig.plugins || [];
+                                rspackConfig.plugins.push(virtualManifestPlugin);
+                                const browserRuntimeDir = dirname(browserRuntimePath);
+                                rspackConfig.module = rspackConfig.module || {};
+                                rspackConfig.module.rules = rspackConfig.module.rules || [];
+                                rspackConfig.module.rules.unshift({
+                                    test: /\.js$/,
+                                    include: browserRuntimeDir,
+                                    extractSourceMap: true
+                                });
+                                if (isDebug()) logger.log(`[rstest:browser] extractSourceMap rule added for: ${browserRuntimeDir}`);
+                            }
+                        }
+                    });
+                    return merged;
+                });
+            }
+        }
+    ]);
+    if (isWatchMode && onTriggerRerun) rsbuildInstance.addPlugins([
+        {
+            name: 'rstest:browser-watch',
+            setup (api) {
+                api.onBeforeDevCompile(()=>{
+                    if (!watchContext.hooksEnabled) return;
+                    logger.log(color.cyan('\nFile changed, re-running tests...\n'));
+                });
+                api.onAfterDevCompile(async ()=>{
+                    if (!watchContext.hooksEnabled) return;
+                    await onTriggerRerun();
+                });
+            }
+        }
+    ]);
+    const devServer = await rsbuildInstance.createDevServer({
+        getPortSilently: true
+    });
+    const serveContainer = containerDistPath ? sirv(containerDistPath, {
+        dev: false,
+        single: 'container.html'
+    }) : null;
+    const containerDevBase = containerDevServer ? new URL(containerDevServer) : null;
+    const respondWithDevServerHtml = async (url, res)=>{
+        if (!containerDevBase) return false;
+        try {
+            const target = new URL(url.pathname + url.search, containerDevBase);
+            const response = await fetch(target);
+            if (!response.ok) return false;
+            let html = await response.text();
+            html = html.replace(optionsPlaceholder, serializedOptions);
+            res.statusCode = response.status;
+            response.headers.forEach((value, key)=>{
+                if ('content-length' === key.toLowerCase()) return;
+                res.setHeader(key, value);
+            });
+            res.setHeader('Content-Type', 'text/html');
+            res.end(html);
+            return true;
+        } catch (error) {
+            logger.log(color.yellow(`[Browser UI] Failed to fetch container HTML from dev server: ${String(error)}`));
+            return false;
+        }
+    };
+    const proxyDevServerAsset = async (req, res)=>{
+        if (!containerDevBase || !req.url) return false;
+        try {
+            const target = new URL(req.url, containerDevBase);
+            const response = await fetch(target);
+            if (!response.ok) return false;
+            const buffer = Buffer.from(await response.arrayBuffer());
+            res.statusCode = response.status;
+            response.headers.forEach((value, key)=>{
+                if ('content-length' === key.toLowerCase()) return;
+                res.setHeader(key, value);
+            });
+            res.end(buffer);
+            return true;
+        } catch (error) {
+            logger.log(color.yellow(`[Browser UI] Failed to proxy asset from dev server: ${String(error)}`));
+            return false;
+        }
+    };
+    devServer.middlewares.use(async (req, res, next)=>{
+        if (!req.url) return void next();
+        const url = new URL(req.url, 'http://localhost');
+        if ('/__open-in-editor' === url.pathname) {
+            const file = url.searchParams.get('file');
+            if (!file) {
+                res.statusCode = 400;
+                res.end('Missing file');
+                return;
+            }
+            try {
+                await open_editor([
+                    {
+                        file
+                    }
+                ]);
+                res.statusCode = 204;
+                res.end();
+            } catch (error) {
+                logger.log(color.yellow(`[Browser UI] Failed to open editor: ${String(error)}`));
+                res.statusCode = 500;
+                res.end('Failed to open editor');
+            }
+            return;
+        }
+        if ('/' === url.pathname || '/container.html' === url.pathname) {
+            if (await respondWithDevServerHtml(url, res)) return;
+            const html = injectedContainerHtml || containerHtmlTemplate?.replace(optionsPlaceholder, 'null');
+            if (html) {
+                res.setHeader('Content-Type', 'text/html');
+                res.end(html);
+                return;
+            }
+            res.statusCode = 502;
+            res.end('Container UI is not available.');
+            return;
+        }
+        if (url.pathname.startsWith('/container-static/')) {
+            if (await proxyDevServerAsset(req, res)) return;
+            if (serveContainer) return void serveContainer(req, res, next);
+            res.statusCode = 502;
+            res.end('Container assets are not available.');
+            return;
+        }
+        if ('/runner.html' === url.pathname) {
+            res.setHeader('Content-Type', 'text/html');
+            res.end(htmlTemplate);
+            return;
+        }
+        next();
+    });
+    const { port } = await devServer.listen();
+    const wsPort = port + 1;
+    const wss = new WebSocketServer({
+        port: wsPort
+    });
+    logger.log(color.gray(`[Browser UI] WebSocket server started on port ${wsPort}`));
+    let browserLauncher;
+    const browserName = context.normalizedConfig.browser.browser;
+    try {
+        const playwright = await import("playwright");
+        browserLauncher = playwright[browserName];
+    } catch (_error) {
+        wss.close();
+        await devServer.close();
+        throw _error;
+    }
+    let browser;
+    try {
+        browser = await browserLauncher.launch({
+            headless: forceHeadless ?? context.normalizedConfig.browser.headless,
+            args: 'chromium' === browserName ? [
+                '--disable-popup-blocking',
+                '--no-first-run',
+                '--no-default-browser-check'
+            ] : void 0
+        });
+    } catch (_error) {
+        wss.close();
+        await devServer.close();
+        throw _error;
+    }
+    return {
+        rsbuildInstance,
+        devServer,
+        browser,
+        port,
+        wsPort,
+        manifestPath,
+        tempDir,
+        manifestPlugin: virtualManifestPlugin,
+        setContainerOptions,
+        wss
+    };
+};
+const runBrowserController = async (context)=>{
+    const buildStart = Date.now();
+    const containerDevServerEnv = process.env.RSTEST_CONTAINER_DEV_SERVER;
+    let containerDevServer;
+    let containerDistPath;
+    if (containerDevServerEnv) try {
+        containerDevServer = new URL(containerDevServerEnv).toString();
+        logger.log(color.gray(`[Browser UI] Using dev server for container: ${containerDevServer}`));
+    } catch (error) {
+        logger.error(color.red(`Invalid RSTEST_CONTAINER_DEV_SERVER value: ${String(error)}`));
+        ensureProcessExitCode(1);
+        return;
+    }
+    if (!containerDevServer) try {
+        containerDistPath = resolveContainerDist();
+    } catch (error) {
+        logger.error(color.red(String(error)));
+        ensureProcessExitCode(1);
+        return;
+    }
+    const projectEntries = await collectProjectEntries(context);
+    const totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
+    if (0 === totalTests) {
+        const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
+        logger.log(color[code ? 'red' : 'yellow'](`No test files found, exiting with code ${code}.`));
+        if (0 !== code) ensureProcessExitCode(code);
+        return;
+    }
+    const isWatchMode = 'watch' === context.command;
+    const tempDir = isWatchMode && watchContext.runtime ? watchContext.runtime.tempDir : isWatchMode ? join(context.rootPath, TEMP_RSTEST_OUTPUT_DIR, 'browser', 'watch') : join(context.rootPath, TEMP_RSTEST_OUTPUT_DIR, 'browser', Date.now().toString());
+    const manifestPath = join(tempDir, 'manifest.ts');
+    const manifestSource = generateManifestModule({
+        manifestPath,
+        entries: projectEntries
+    });
+    if (isWatchMode) watchContext.lastTestFiles = projectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
+                testPath,
+                projectName: entry.project.name
+            })));
+    let runtime = isWatchMode ? watchContext.runtime : null;
+    let triggerRerun;
+    if (!runtime) {
+        try {
+            runtime = await createBrowserRuntime({
+                context,
+                manifestPath,
+                manifestSource,
+                tempDir,
+                isWatchMode,
+                onTriggerRerun: isWatchMode ? async ()=>{
+                    await triggerRerun?.();
+                } : void 0,
+                containerDistPath,
+                containerDevServer
+            });
+        } catch (error) {
+            logger.error(error instanceof Error ? error : new Error(String(error)));
+            ensureProcessExitCode(1);
+            await promises.rm(tempDir, {
+                recursive: true,
+                force: true
+            }).catch(()=>{});
+            return;
+        }
+        if (isWatchMode) {
+            watchContext.runtime = runtime;
+            registerWatchCleanup();
+        }
+    }
+    const { browser, port, wsPort, wss } = runtime;
+    const buildTime = Date.now() - buildStart;
+    const allTestFiles = projectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
+                testPath: normalize(testPath),
+                projectName: entry.project.name
+            })));
+    const browserProjectsForRuntime = getBrowserProjects(context);
+    const projectRuntimeConfigs = browserProjectsForRuntime.map((project)=>({
+            name: project.name,
+            environmentName: project.environmentName,
+            projectRoot: normalize(project.rootPath),
+            runtimeConfig: serializableConfig(getRuntimeConfigFromProject(project))
+        }));
+    const maxTestTimeoutForRpc = Math.max(...browserProjectsForRuntime.map((p)=>p.normalizedConfig.testTimeout ?? 5000));
+    const hostOptions = {
+        rootPath: normalize(context.rootPath),
+        projects: projectRuntimeConfigs,
+        snapshot: {
+            updateSnapshot: context.snapshotManager.options.updateSnapshot
+        },
+        runnerUrl: `http://localhost:${port}`,
+        wsPort,
+        debug: isDebug(),
+        rpcTimeout: maxTestTimeoutForRpc
+    };
+    runtime.setContainerOptions(hostOptions);
+    const reporterResults = [];
+    const caseResults = [];
+    let completedTests = 0;
+    let fatalError = null;
+    let resolveAllTests;
+    const allTestsPromise = new Promise((resolve)=>{
+        resolveAllTests = resolve;
+    });
+    let containerContext;
+    let containerPage;
+    let isNewPage = false;
+    if (isWatchMode && runtime.containerPage && runtime.containerContext) {
+        containerContext = runtime.containerContext;
+        containerPage = runtime.containerPage;
+        logger.log(color.gray('\n[Watch] Reusing existing container page\n'));
+    } else {
+        isNewPage = true;
+        containerContext = await browser.newContext({
+            viewport: null
+        });
+        containerPage = await containerContext.newPage();
+        containerPage.on('popup', async (popup)=>{
+            await popup.close().catch(()=>{});
+        });
+        containerContext.on('page', async (page)=>{
+            if (page !== containerPage) await page.close().catch(()=>{});
+        });
+        if (isWatchMode) {
+            runtime.containerPage = containerPage;
+            runtime.containerContext = containerContext;
+        }
+        containerPage.on('console', (msg)=>{
+            const text = msg.text();
+            if (text.includes('[Container]') || text.includes('[Runner]')) logger.log(color.gray(`[Browser Console] ${text}`));
+        });
+    }
+    const createRpcMethods = ()=>({
+            async rerunTest (testFile, testNamePattern) {
+                logger.log(color.cyan(`\nRe-running test: ${testFile}${testNamePattern ? ` (pattern: ${testNamePattern})` : ''}\n`));
+                await rpcManager.reloadTestFile(testFile, testNamePattern);
+            },
+            async getTestFiles () {
+                return allTestFiles;
+            },
+            async onTestFileStart (payload) {
+                await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileStart?.({
+                        testPath: payload.testPath,
+                        tests: []
+                    })));
+            },
+            async onTestCaseResult (payload) {
+                caseResults.push(payload);
+                await Promise.all(context.reporters.map((reporter)=>reporter.onTestCaseResult?.(payload)));
+            },
+            async onTestFileComplete (payload) {
+                reporterResults.push(payload);
+                if (payload.snapshotResult) context.snapshotManager.add(payload.snapshotResult);
+                await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileResult?.(payload)));
+                completedTests++;
+                if (completedTests >= allTestFiles.length && resolveAllTests) resolveAllTests();
+            },
+            async onLog (payload) {
+                const log = {
+                    content: payload.content,
+                    name: payload.level,
+                    testPath: payload.testPath,
+                    type: payload.type,
+                    trace: payload.trace
+                };
+                const shouldLog = context.normalizedConfig.onConsoleLog?.(log.content) ?? true;
+                if (shouldLog) await Promise.all(context.reporters.map((reporter)=>reporter.onUserConsoleLog?.(log)));
+            },
+            async onFatal (payload) {
+                fatalError = new Error(payload.message);
+                fatalError.stack = payload.stack;
+                if (resolveAllTests) resolveAllTests();
+            },
+            async resolveSnapshotPath (testPath) {
+                const snapExtension = '.snap';
+                const resolver = context.normalizedConfig.resolveSnapshotPath || (()=>join(dirname(testPath), '__snapshots__', `${basename(testPath)}${snapExtension}`));
+                return resolver(testPath, snapExtension);
+            },
+            async readSnapshotFile (filepath) {
+                try {
+                    return await promises.readFile(filepath, 'utf-8');
+                } catch  {
+                    return null;
+                }
+            },
+            async saveSnapshotFile (filepath, content) {
+                const dir = dirname(filepath);
+                await promises.mkdir(dir, {
+                    recursive: true
+                });
+                await promises.writeFile(filepath, content, 'utf-8');
+            },
+            async removeSnapshotFile (filepath) {
+                try {
+                    await promises.unlink(filepath);
+                } catch  {}
+            }
+        });
+    let rpcManager;
+    if (isWatchMode && runtime.rpcManager) {
+        rpcManager = runtime.rpcManager;
+        rpcManager.updateMethods(createRpcMethods());
+        const existingWs = rpcManager.currentWebSocket;
+        if (existingWs) rpcManager.reattach(existingWs);
+    } else {
+        rpcManager = new ContainerRpcManager(wss, createRpcMethods());
+        if (isWatchMode) runtime.rpcManager = rpcManager;
+    }
+    if (isNewPage) {
+        await containerPage.goto(`http://localhost:${port}/container.html`, {
+            waitUntil: 'load'
+        });
+        logger.log(color.cyan(`\nContainer page opened at http://localhost:${port}/container.html\n`));
+    }
+    const maxTestTimeout = Math.max(...browserProjectsForRuntime.map((p)=>p.normalizedConfig.testTimeout ?? 5000));
+    const totalTimeoutMs = maxTestTimeout * allTestFiles.length + 30000;
+    let timeoutId;
+    const testTimeout = new Promise((resolve)=>{
+        timeoutId = setTimeout(()=>{
+            logger.log(color.yellow(`\nTest execution timeout after ${totalTimeoutMs / 1000}s. Completed: ${completedTests}/${allTestFiles.length}\n`));
+            resolve();
+        }, totalTimeoutMs);
+    });
+    const testStart = Date.now();
+    await Promise.race([
+        allTestsPromise,
+        testTimeout
+    ]);
+    if (timeoutId) clearTimeout(timeoutId);
+    const testTime = Date.now() - testStart;
+    if (isWatchMode) triggerRerun = async ()=>{
+        const newProjectEntries = await collectProjectEntries(context);
+        const currentTestFiles = newProjectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
+                    testPath: normalize(testPath),
+                    projectName: entry.project.name
+                })));
+        const serialize = (files)=>JSON.stringify(files.map((f)=>`${f.projectName}:${f.testPath}`).sort());
+        const filesChanged = serialize(currentTestFiles) !== serialize(watchContext.lastTestFiles);
+        if (filesChanged) {
+            watchContext.lastTestFiles = currentTestFiles;
+            await rpcManager.notifyTestFileUpdate(currentTestFiles);
+        }
+        logger.log(color.cyan('Tests will be re-executed automatically\n'));
+    };
+    if (!isWatchMode) await destroyBrowserRuntime(runtime);
+    if (fatalError) {
+        logger.error(color.red(`Browser test run failed: ${fatalError.message}`));
+        ensureProcessExitCode(1);
+        return;
+    }
+    const duration = {
+        totalTime: buildTime + testTime,
+        buildTime,
+        testTime
+    };
+    context.updateReporterResultState(reporterResults, caseResults);
+    const isFailure = reporterResults.some((result)=>'fail' === result.status);
+    if (isFailure) ensureProcessExitCode(1);
+    for (const reporter of context.reporters)await reporter.onTestRunEnd?.({
+        results: context.reporterResults.results,
+        testResults: context.reporterResults.testResults,
+        duration,
+        snapshotSummary: context.snapshotManager.summary,
+        getSourcemap: async ()=>null
+    });
+    if (isWatchMode && triggerRerun) {
+        watchContext.hooksEnabled = true;
+        logger.log(color.cyan('\nWatch mode enabled - will re-run tests on file changes\n'));
+    }
+};
+const listBrowserTests = async (context)=>{
+    const projectEntries = await collectProjectEntries(context);
+    const totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
+    if (0 === totalTests) return {
+        list: [],
+        close: async ()=>{}
+    };
+    const tempDir = join(context.rootPath, TEMP_RSTEST_OUTPUT_DIR, 'browser', `list-${Date.now()}`);
+    const manifestPath = join(tempDir, 'manifest.ts');
+    const manifestSource = generateManifestModule({
+        manifestPath,
+        entries: projectEntries
+    });
+    let runtime;
+    try {
+        runtime = await createBrowserRuntime({
+            context,
+            manifestPath,
+            manifestSource,
+            tempDir,
+            isWatchMode: false,
+            containerDistPath: void 0,
+            containerDevServer: void 0,
+            forceHeadless: true
+        });
+    } catch (error) {
+        logger.error(color.red('Failed to load Playwright. Please install "playwright" to use browser mode.'), error);
+        throw error;
+    }
+    const { browser, port } = runtime;
+    const browserProjects = getBrowserProjects(context);
+    const projectRuntimeConfigs = browserProjects.map((project)=>({
+            name: project.name,
+            environmentName: project.environmentName,
+            projectRoot: normalize(project.rootPath),
+            runtimeConfig: serializableConfig(getRuntimeConfigFromProject(project))
+        }));
+    const maxTestTimeoutForRpc = Math.max(...browserProjects.map((p)=>p.normalizedConfig.testTimeout ?? 5000));
+    const hostOptions = {
+        rootPath: normalize(context.rootPath),
+        projects: projectRuntimeConfigs,
+        snapshot: {
+            updateSnapshot: context.snapshotManager.options.updateSnapshot
+        },
+        mode: 'collect',
+        debug: isDebug(),
+        rpcTimeout: maxTestTimeoutForRpc
+    };
+    runtime.setContainerOptions(hostOptions);
+    const collectResults = [];
+    let fatalError = null;
+    let collectCompleted = false;
+    let resolveCollect;
+    const collectPromise = new Promise((resolve)=>{
+        resolveCollect = resolve;
+    });
+    const browserContext = await browser.newContext({
+        viewport: null
+    });
+    const page = await browserContext.newPage();
+    await page.exposeFunction('__rstest_dispatch__', (message)=>{
+        switch(message.type){
+            case 'collect-result':
+                {
+                    const payload = message.payload;
+                    collectResults.push({
+                        testPath: payload.testPath,
+                        project: payload.project,
+                        tests: payload.tests
+                    });
+                    break;
+                }
+            case 'collect-complete':
+                collectCompleted = true;
+                resolveCollect?.();
+                break;
+            case 'fatal':
+                {
+                    const payload = message.payload;
+                    fatalError = new Error(payload.message);
+                    fatalError.stack = payload.stack;
+                    resolveCollect?.();
+                    break;
+                }
+            case 'ready':
+            case 'log':
+                break;
+            default:
+                logger.debug(`[List] Unexpected message: ${message.type}`);
+        }
+    });
+    const serializedOptions = JSON.stringify(hostOptions).replace(/</g, '\\u003c');
+    await page.addInitScript(`window.__RSTEST_BROWSER_OPTIONS__ = ${serializedOptions};`);
+    await page.goto(`http://localhost:${port}/runner.html`, {
+        waitUntil: 'load'
+    });
+    const timeoutMs = 30000;
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve)=>{
+        timeoutId = setTimeout(()=>{
+            if (!collectCompleted) logger.warn(color.yellow(`[List] Browser test collection timed out after ${timeoutMs}ms`));
+            resolve();
+        }, timeoutMs);
+    });
+    await Promise.race([
+        collectPromise,
+        timeoutPromise
+    ]);
+    if (timeoutId) clearTimeout(timeoutId);
+    const cleanup = async ()=>{
+        try {
+            await page.close();
+            await browserContext.close();
+        } catch  {}
+        await destroyBrowserRuntime(runtime);
+    };
+    if (fatalError) {
+        await cleanup();
+        const errorResult = {
+            testPath: '',
+            project: '',
+            tests: [],
+            errors: [
+                {
+                    name: 'BrowserCollectError',
+                    message: fatalError.message,
+                    stack: fatalError.stack
+                }
+            ]
+        };
+        return {
+            list: [
+                errorResult
+            ],
+            close: async ()=>{}
+        };
+    }
+    return {
+        list: collectResults,
+        close: cleanup
+    };
+};
+async function runBrowserTests(context) {
+    await runBrowserController(context);
+}
+async function src_listBrowserTests(context) {
+    return listBrowserTests(context);
+}
+export { runBrowserTests, src_listBrowserTests as listBrowserTests };