@rstest/browser 0.11.5 → 0.11.7

package/dist/client/runner.js

@@ -0,0 +1,675 @@
+import { projectSetupLoaders, projectTestContexts, projects } from "__rstest_virtual_browser_manifest__";
+import { RSTEST_API_GLOBAL_KEY, RSTEST_ENV_SYMBOL_KEY, RSTEST_IMPORT_META_GLOBAL_KEY, SNAPSHOT_HEADER, createBrowserTaskContext, createRstestRuntime, formatConsoleArgs, globalApis, setRealTimers, unwrapRegex } from "@rstest/core/internal/browser-runtime";
+import { normalize } from "pathe";
+import { AnyMap, TraceMap, encodedMap, originalPositionFor } from "@jridgewell/trace-mapping";
+import convert_source_map from "convert-source-map";
+import { createRequestId, createRunnerLifecycleRequest, dispatchRpc, setRpcPhase, disposeDispatchTransport, DISPATCH_NAMESPACE_FILE_CLEANUP, sendDispatchRequest, RSTEST_BROWSER_CACHE_CLEANERS_KEY, RSTEST_CONFIG_MESSAGE_TYPE, DISPATCH_MESSAGE_TYPE, DISPATCH_NAMESPACE_SNAPSHOT, getRunIdentity, adoptRunIdentity, getRpcTimeout } from "./240~1.js";
+const flattenSourceMap = (sourceMap, sourceMapUrl)=>encodedMap(new AnyMap(sourceMap, sourceMapUrl));
+const normalizeJavaScriptUrl = (value, options)=>{
+    try {
+        const url = options?.origin ? new URL(value, options.origin) : new URL(value);
+        if ('http:' !== url.protocol && 'https:' !== url.protocol) return null;
+        url.hash = '';
+        return url.toString();
+    } catch  {
+        return null;
+    }
+};
+const resolveInlineSourceMap = (code, sourceMapUrl)=>{
+    try {
+        const converter = convert_source_map.fromSource(code);
+        return converter ? flattenSourceMap(converter.toObject(), sourceMapUrl) : null;
+    } catch  {
+        return null;
+    }
+};
+const fetchSourceMap = async (jsUrl, fetcher)=>{
+    const jsResponse = await fetcher(jsUrl);
+    if (!jsResponse.ok) return null;
+    const code = await jsResponse.text();
+    const inlineMap = resolveInlineSourceMap(code, jsUrl);
+    if (inlineMap) return inlineMap;
+    const mapUrl = new URL(jsUrl);
+    mapUrl.pathname += '.map';
+    const mapResponse = await fetcher(mapUrl.href);
+    if (!mapResponse.ok) return null;
+    return flattenSourceMap(await mapResponse.json(), mapUrl.href);
+};
+const loadSourceMapWithCache = async ({ jsUrl, cache, force = false, origin, fetcher = fetch })=>{
+    const normalizedUrl = normalizeJavaScriptUrl(jsUrl, {
+        origin
+    });
+    if (!normalizedUrl) return null;
+    if (!force && cache.has(normalizedUrl)) return cache.get(normalizedUrl) ?? null;
+    try {
+        const sourceMap = await fetchSourceMap(normalizedUrl, fetcher);
+        cache.set(normalizedUrl, sourceMap);
+        return sourceMap;
+    } catch  {
+        cache.set(normalizedUrl, null);
+        return null;
+    }
+};
+const sourceMapCache = new Map();
+const sourceMapPayloadCache = new Map();
+const getSourceMap = (url)=>sourceMapCache.get(url) ?? null;
+const preloadSourceMap = async (jsUrl, force = false)=>{
+    const normalizedUrl = normalizeJavaScriptUrl(jsUrl, {
+        origin: window.location.origin
+    });
+    if (!normalizedUrl) return;
+    if (!force && sourceMapCache.has(normalizedUrl)) return;
+    const sourceMap = await loadSourceMapWithCache({
+        jsUrl: normalizedUrl,
+        cache: sourceMapPayloadCache,
+        force,
+        origin: window.location.origin
+    });
+    sourceMapCache.set(normalizedUrl, sourceMap ? new TraceMap(sourceMap) : null);
+};
+const getScriptUrls = ()=>{
+    const scripts = document.querySelectorAll("script[src]");
+    const urls = new Set();
+    for (const script of scripts){
+        const src = script.getAttribute('src');
+        if (src) {
+            const fullUrl = src.startsWith('http') ? src : `${window.location.origin}${src.startsWith('/') ? '' : '/'}${src}`;
+            urls.add(fullUrl);
+        }
+    }
+    return urls;
+};
+const findNewScriptUrl = (beforeUrls, afterUrls)=>{
+    for (const url of afterUrls)if (!beforeUrls.has(url)) return url;
+    return null;
+};
+const preloadTestFileSourceMap = async (chunkUrl)=>{
+    await preloadSourceMap(chunkUrl, true);
+};
+const preloadRunnerSourceMap = async ()=>{
+    const runnerUrl = `${window.location.origin}/static/js/runner.js`;
+    await preloadSourceMap(runnerUrl);
+};
+const mapStackFrame = (frame)=>{
+    const { file, line, column } = frame;
+    const fullUrl = normalizeJavaScriptUrl(file, {
+        origin: window.location.origin
+    });
+    if (!fullUrl) return frame;
+    const traceMap = getSourceMap(fullUrl);
+    if (!traceMap) return frame;
+    const pos = originalPositionFor(traceMap, {
+        line,
+        column: column - 1
+    });
+    if (pos.source && null != pos.line && null != pos.column) return {
+        ...frame,
+        file: pos.source,
+        line: pos.line,
+        column: pos.column + 1,
+        method: pos.name || frame.method
+    };
+    return frame;
+};
+const createSnapshotDispatchRequest = (requestId, call)=>({
+        requestId,
+        namespace: DISPATCH_NAMESPACE_SNAPSHOT,
+        method: call.method,
+        args: call.args
+    });
+const sendRpcRequest = (call)=>{
+    const requestId = createRequestId('snapshot-rpc');
+    const rpcTimeout = getRpcTimeout();
+    const dispatchRequest = createSnapshotDispatchRequest(requestId, call);
+    return dispatchRpc({
+        requestId,
+        request: dispatchRequest,
+        timeoutMs: rpcTimeout,
+        staleMessage: 'Stale snapshot RPC request ignored.',
+        timeoutMessage: `Snapshot RPC timeout after ${rpcTimeout / 1000}s: ${call.method}`
+    });
+};
+class BrowserSnapshotEnvironment {
+    getVersion() {
+        return '1';
+    }
+    getHeader() {
+        return `${SNAPSHOT_HEADER} v${this.getVersion()}`;
+    }
+    async resolveRawPath(_testPath, rawPath) {
+        return rawPath;
+    }
+    async resolvePath(filepath) {
+        return sendRpcRequest({
+            method: 'resolveSnapshotPath',
+            args: {
+                testPath: filepath
+            }
+        });
+    }
+    async prepareDirectory() {}
+    async saveSnapshotFile(filepath, snapshot) {
+        await sendRpcRequest({
+            method: 'saveSnapshotFile',
+            args: {
+                filepath,
+                content: snapshot
+            }
+        });
+    }
+    async readSnapshotFile(filepath) {
+        return sendRpcRequest({
+            method: 'readSnapshotFile',
+            args: {
+                filepath
+            }
+        });
+    }
+    async removeSnapshotFile(filepath) {
+        await sendRpcRequest({
+            method: 'removeSnapshotFile',
+            args: {
+                filepath
+            }
+        });
+    }
+    processStackTrace(stack) {
+        const mapped = mapStackFrame(stack);
+        return {
+            file: mapped.file,
+            line: mapped.line,
+            column: mapped.column,
+            method: mapped.method || stack.method
+        };
+    }
+}
+const debugLog = (...args)=>{
+    if (window.__RSTEST_BROWSER_OPTIONS__?.debug) console.log(...args);
+};
+const RSTEST_ENV_SYMBOL = Symbol.for(RSTEST_ENV_SYMBOL_KEY);
+const installRuntimeGlobals = (runtime, runtimeConfig)=>{
+    Object.assign(globalThis, {
+        [RSTEST_API_GLOBAL_KEY]: runtime.api,
+        [RSTEST_IMPORT_META_GLOBAL_KEY]: runtime.resolveImportMetaRstest
+    });
+    if (runtimeConfig.globals) for (const apiKey of globalApis)globalThis[apiKey] = runtime.api[apiKey];
+};
+const clearBrowserTestEntryCache = (testEntryPath)=>{
+    const cleaners = globalThis[RSTEST_BROWSER_CACHE_CLEANERS_KEY];
+    cleaners?.forEach((clean)=>clean(testEntryPath));
+};
+const restoreRuntimeConfig = (config)=>{
+    const { testNamePattern } = config;
+    return {
+        ...config,
+        testNamePattern: 'string' == typeof testNamePattern ? unwrapRegex(testNamePattern) : testNamePattern
+    };
+};
+const ensureRuntimeEnv = (env)=>{
+    const globalRef = globalThis;
+    if (!globalRef.global) globalRef.global = globalRef;
+    const existingEnv = globalRef[RSTEST_ENV_SYMBOL];
+    let runtimeEnv;
+    if (existingEnv && 'object' == typeof existingEnv) runtimeEnv = existingEnv;
+    else {
+        runtimeEnv = {};
+        globalRef[RSTEST_ENV_SYMBOL] = runtimeEnv;
+    }
+    if (env) for (const [key, value] of Object.entries(env)){
+        const normalizedValue = 'string' == typeof value ? value : null == value ? void 0 : String(value);
+        if (void 0 === normalizedValue) delete runtimeEnv[key];
+        else runtimeEnv[key] = normalizedValue;
+    }
+};
+const getFileTaskId = (testPath)=>`file:${testPath}`;
+const interceptConsole = (projectName, getCurrentTask, printConsoleTrace)=>{
+    const originalConsole = {
+        log: console.log.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+        info: console.info.bind(console),
+        debug: console.debug.bind(console)
+    };
+    const getConsoleTrace = ()=>{
+        if (!printConsoleTrace) return;
+        const stack = new Error('STACK_TRACE').stack;
+        return stack?.split('\n').slice(4).join('\n');
+    };
+    const createConsoleInterceptor = (level)=>(...args)=>{
+            originalConsole[level](...args);
+            const content = formatConsoleArgs(args);
+            const currentTask = getCurrentTask();
+            send({
+                type: 'log',
+                payload: {
+                    level,
+                    content,
+                    projectName,
+                    taskId: currentTask?.taskId,
+                    taskName: currentTask?.taskName,
+                    taskParentNames: currentTask?.taskParentNames,
+                    taskType: currentTask?.taskType,
+                    testPath: currentTask?.testPath ?? '',
+                    type: 'error' === level || 'warn' === level ? 'stderr' : 'stdout',
+                    trace: getConsoleTrace()
+                }
+            });
+        };
+    console.log = createConsoleInterceptor('log');
+    console.warn = createConsoleInterceptor('warn');
+    console.error = createConsoleInterceptor('error');
+    console.info = createConsoleInterceptor('info');
+    console.debug = createConsoleInterceptor('debug');
+    return ()=>{
+        console.log = originalConsole.log;
+        console.warn = originalConsole.warn;
+        console.error = originalConsole.error;
+        console.info = originalConsole.info;
+        console.debug = originalConsole.debug;
+    };
+};
+const send = (message)=>{
+    const envelope = {
+        runId: getRunIdentity(),
+        message
+    };
+    if (window.parent !== window) return void window.parent.postMessage({
+        type: DISPATCH_MESSAGE_TYPE,
+        payload: envelope
+    }, '*');
+    window[DISPATCH_MESSAGE_TYPE]?.(envelope);
+};
+const dispatchRunnerLifecycle = (method, payload)=>{
+    sendDispatchRequest(createRunnerLifecycleRequest(method, payload), (error)=>{
+        debugLog('[Runner] Failed to dispatch lifecycle method:', method, error);
+    });
+};
+const CONFIG_WAIT_TIMEOUT_MS = 30000;
+const waitForConfig = ()=>{
+    if (window.parent === window || window.__RSTEST_BROWSER_OPTIONS__) return Promise.resolve();
+    return new Promise((resolve, reject)=>{
+        const handleMessage = (event)=>{
+            if (event.data?.type === RSTEST_CONFIG_MESSAGE_TYPE && 'string' == typeof event.data.payload?.runId) {
+                window.__RSTEST_BROWSER_OPTIONS__ = event.data.payload;
+                debugLog('[Runner] Received config from container:', event.data.payload);
+                window.removeEventListener('message', handleMessage);
+                resolve();
+            }
+        };
+        window.addEventListener('message', handleMessage);
+        setTimeout(()=>{
+            window.removeEventListener('message', handleMessage);
+            reject(new Error(`[Rstest] Failed to receive browser config within ${CONFIG_WAIT_TIMEOUT_MS / 1000}s. This may indicate a connection issue between the runner iframe and container.`));
+        }, CONFIG_WAIT_TIMEOUT_MS);
+    });
+};
+const toContextKey = (absolutePath, projectRoot)=>{
+    const normalizedAbsolute = normalize(absolutePath);
+    const normalizedRoot = normalize(projectRoot);
+    const withinRoot = normalizedAbsolute === normalizedRoot || normalizedAbsolute.startsWith(`${normalizedRoot}/`);
+    if (!withinRoot) return normalizedAbsolute;
+    const relative = normalizedAbsolute.slice(normalizedRoot.length);
+    return relative.startsWith('/') ? `.${relative}` : `./${relative}`;
+};
+const toAbsolutePath = (key, projectRoot)=>{
+    if (!key.startsWith('.')) return key;
+    const normalizedRoot = normalize(projectRoot).replace(/\/$/, '');
+    return normalizedRoot + key.slice(1);
+};
+const findProjectForTestFile = (testFile, allProjects)=>{
+    const normalizedTestFile = normalize(testFile);
+    const sorted = [
+        ...allProjects
+    ].sort((a, b)=>b.projectRoot.length - a.projectRoot.length);
+    for (const proj of sorted){
+        const normalizedRoot = normalize(proj.projectRoot);
+        if (normalizedTestFile.startsWith(normalizedRoot)) return proj;
+    }
+    return allProjects[0];
+};
+const run = async ()=>{
+    await waitForConfig();
+    let options = window.__RSTEST_BROWSER_OPTIONS__;
+    if (options?.runId) adoptRunIdentity(options.runId);
+    const urlParams = new URLSearchParams(window.location.search);
+    const urlTestFile = urlParams.get('testFile');
+    const urlTestNamePattern = urlParams.get('testNamePattern');
+    if (urlTestFile && options) options = {
+        ...options,
+        testFile: urlTestFile
+    };
+    if (urlTestNamePattern && options) options = {
+        ...options,
+        projects: options.projects.map((project)=>({
+                ...project,
+                runtimeConfig: {
+                    ...project.runtimeConfig,
+                    testNamePattern: urlTestNamePattern
+                }
+            }))
+    };
+    if (!options) {
+        send({
+            type: 'fatal',
+            payload: {
+                message: 'Browser test runtime is not configured.'
+            }
+        });
+        window.__RSTEST_DONE__ = true;
+        return;
+    }
+    send({
+        type: 'ready'
+    });
+    setRealTimers();
+    await preloadRunnerSourceMap();
+    const targetTestFile = options.testFile;
+    const currentProject = targetTestFile ? findProjectForTestFile(targetTestFile, projects) : projects["0"];
+    if (!currentProject) {
+        send({
+            type: 'fatal',
+            payload: {
+                message: 'No project found for test file'
+            }
+        });
+        window.__RSTEST_DONE__ = true;
+        return;
+    }
+    const projectRuntime = options.projects.find((p)=>p.name === currentProject.name);
+    if (!projectRuntime) {
+        send({
+            type: 'fatal',
+            payload: {
+                message: `Project ${currentProject.name} not found in runtime options`
+            }
+        });
+        window.__RSTEST_DONE__ = true;
+        return;
+    }
+    const runtimeConfig = restoreRuntimeConfig(projectRuntime.runtimeConfig);
+    ensureRuntimeEnv(runtimeConfig.env);
+    const currentSetupLoaders = projectSetupLoaders[currentProject.name] || [];
+    const currentTestContext = projectTestContexts[currentProject.name];
+    if (!currentTestContext) {
+        send({
+            type: 'fatal',
+            payload: {
+                message: `Test context not found for project ${currentProject.name}`
+            }
+        });
+        window.__RSTEST_DONE__ = true;
+        return;
+    }
+    const loadSetupFiles = async ()=>{
+        for (const loadSetup of currentSetupLoaders)await loadSetup();
+    };
+    let testKeysToRun;
+    if (targetTestFile) {
+        const key = toContextKey(targetTestFile, currentProject.projectRoot);
+        testKeysToRun = [
+            key
+        ];
+    } else testKeysToRun = currentTestContext.getTestKeys();
+    const executionMode = options.mode || 'run';
+    if ('collect' === executionMode) {
+        for (const key of testKeysToRun){
+            const testPath = toAbsolutePath(key, currentProject.projectRoot);
+            const workerState = {
+                project: projectRuntime.name,
+                projectRoot: projectRuntime.projectRoot,
+                rootPath: options.rootPath,
+                runtimeConfig,
+                taskId: 0,
+                buildId: 0,
+                outputModule: false,
+                environment: 'browser',
+                testPath,
+                distPath: testPath,
+                snapshotOptions: {
+                    updateSnapshot: options.snapshot.updateSnapshot,
+                    snapshotEnvironment: new BrowserSnapshotEnvironment(),
+                    snapshotFormat: runtimeConfig.snapshotFormat
+                }
+            };
+            const runtime = await createRstestRuntime(workerState, {
+                taskContext: createBrowserTaskContext()
+            });
+            installRuntimeGlobals(runtime, runtimeConfig);
+            try {
+                setRpcPhase('framework');
+                await loadSetupFiles();
+                clearBrowserTestEntryCache(testPath);
+                await currentTestContext.loadTest(key);
+                const tests = await runtime.runner.collectTests();
+                send({
+                    type: 'collect-result',
+                    payload: {
+                        testPath,
+                        project: projectRuntime.name,
+                        tests
+                    }
+                });
+            } catch (_error) {
+                const error = _error instanceof Error ? _error : new Error(String(_error));
+                send({
+                    type: 'fatal',
+                    payload: {
+                        message: error.message,
+                        stack: error.stack
+                    }
+                });
+                window.__RSTEST_DONE__ = true;
+                return;
+            }
+        }
+        send({
+            type: 'collect-complete'
+        });
+        window.__RSTEST_DONE__ = true;
+        return;
+    }
+    let activeUnhandledErrors;
+    const onWindowError = (event)=>{
+        activeUnhandledErrors?.push(event.error instanceof Error ? event.error : new Error(event.message || String(event.error)));
+    };
+    const onUnhandledRejection = (event)=>{
+        const { reason } = event;
+        activeUnhandledErrors?.push(reason instanceof Error ? reason : new Error(String(reason)));
+    };
+    window.addEventListener('error', onWindowError);
+    window.addEventListener('unhandledrejection', onUnhandledRejection);
+    for (const key of testKeysToRun){
+        const testPath = toAbsolutePath(key, currentProject.projectRoot);
+        const taskStack = [
+            {
+                taskId: getFileTaskId(testPath),
+                taskType: 'file',
+                testPath
+            }
+        ];
+        const taskContext = createBrowserTaskContext();
+        const shouldInterceptConsole = !runtimeConfig.disableConsoleIntercept || true === runtimeConfig.silent || 'passed-only' === runtimeConfig.silent;
+        const restoreConsole = shouldInterceptConsole ? interceptConsole(projectRuntime.name, ()=>taskContext.getCurrent() ?? taskStack[taskStack.length - 1], runtimeConfig.disableConsoleIntercept ? false : runtimeConfig.printConsoleTrace ?? false) : ()=>{};
+        const workerState = {
+            project: projectRuntime.name,
+            projectRoot: projectRuntime.projectRoot,
+            rootPath: options.rootPath,
+            runtimeConfig,
+            taskId: 0,
+            buildId: 0,
+            outputModule: false,
+            environment: 'browser',
+            currentTask: taskStack[0],
+            testPath,
+            distPath: testPath,
+            snapshotOptions: {
+                updateSnapshot: options.snapshot.updateSnapshot,
+                snapshotEnvironment: new BrowserSnapshotEnvironment(),
+                snapshotFormat: runtimeConfig.snapshotFormat
+            }
+        };
+        const syncCurrentTask = ()=>{
+            workerState.currentTask = taskStack[taskStack.length - 1];
+        };
+        const removeTaskFromStack = (taskId)=>{
+            const taskIndex = taskStack.findLastIndex((task)=>task.taskId === taskId);
+            if (taskIndex < 0) return;
+            taskStack.splice(taskIndex, 1);
+            syncCurrentTask();
+        };
+        const runtime = await createRstestRuntime(workerState, {
+            taskContext
+        });
+        installRuntimeGlobals(runtime, runtimeConfig);
+        let failedTestsCount = 0;
+        const dispatchFileCleanup = async (method, result, waitForAcknowledgement = true)=>{
+            const requestId = createRequestId(`file-cleanup-${method}`);
+            const request = {
+                requestId,
+                namespace: DISPATCH_NAMESPACE_FILE_CLEANUP,
+                method,
+                args: {
+                    projectName: projectRuntime.name,
+                    result,
+                    runId: getRunIdentity(),
+                    testPath
+                }
+            };
+            if (!waitForAcknowledgement) return void sendDispatchRequest(request);
+            await dispatchRpc({
+                requestId,
+                request,
+                timeoutMs: getRpcTimeout('framework'),
+                timeoutMessage: `File cleanup ${method} acknowledgement timed out for ${testPath}.`,
+                staleMessage: `File cleanup ${method} became stale for ${testPath}.`
+            });
+        };
+        const runnerHooks = {
+            onFileCleanupStart: async (result)=>{
+                if (result && globalThis.__coverage__) result.coverage = globalThis.__coverage__;
+                await dispatchFileCleanup('start', result, window.parent !== window);
+            },
+            onFileCleanupEnd: ()=>dispatchFileCleanup('end', void 0, window.parent !== window),
+            onSnapshotSetupStart: async ()=>{
+                setRpcPhase('framework');
+            },
+            onSnapshotSetupEnd: async ()=>{
+                setRpcPhase('test');
+            },
+            onSnapshotFinishStart: async ()=>{
+                setRpcPhase('framework');
+            },
+            onSnapshotFinishEnd: async ()=>{
+                setRpcPhase('test');
+            },
+            onTestFileReady: async (test)=>{
+                dispatchRunnerLifecycle('file-ready', test);
+            },
+            onTestSuiteStart: async (test)=>{
+                taskStack.push({
+                    taskId: test.testId,
+                    taskName: test.name,
+                    taskParentNames: test.parentNames,
+                    taskType: 'suite',
+                    testPath: test.testPath
+                });
+                syncCurrentTask();
+                dispatchRunnerLifecycle('suite-start', test);
+            },
+            onTestSuiteResult: async (result)=>{
+                removeTaskFromStack(result.testId);
+                dispatchRunnerLifecycle('suite-result', result);
+            },
+            onTestCaseStart: async (test)=>{
+                taskStack.push({
+                    taskId: test.testId,
+                    taskName: test.name,
+                    taskParentNames: test.parentNames,
+                    taskType: 'case',
+                    testPath: test.testPath
+                });
+                syncCurrentTask();
+                dispatchRunnerLifecycle('case-start', test);
+            },
+            onTestCaseResult: async (result)=>{
+                removeTaskFromStack(result.testId);
+                if ('fail' === result.status) failedTestsCount++;
+                send({
+                    type: 'case-result',
+                    payload: result
+                });
+            },
+            getCountOfFailedTests: async ()=>failedTestsCount
+        };
+        send({
+            type: 'file-start',
+            payload: {
+                testPath,
+                projectName: projectRuntime.name
+            }
+        });
+        const unhandledErrors = [];
+        activeUnhandledErrors = unhandledErrors;
+        try {
+            setRpcPhase('framework');
+            await loadSetupFiles();
+            const beforeScripts = getScriptUrls();
+            await currentTestContext.loadTest(key);
+            const afterScripts = getScriptUrls();
+            const chunkUrl = findNewScriptUrl(beforeScripts, afterScripts);
+            if (chunkUrl) await preloadTestFileSourceMap(chunkUrl);
+            const result = await runtime.runner.runTests(testPath, runnerHooks, runtime.api);
+            for(let i = 0; i < 2; i++)await new Promise((resolve)=>{
+                setTimeout(resolve, 0);
+            });
+            if (unhandledErrors.length > 0) {
+                result.status = 'fail';
+                result.errors = [
+                    ...result.errors ?? [],
+                    ...unhandledErrors.map((error)=>({
+                            name: error.name,
+                            message: error.message,
+                            stack: error.stack
+                        }))
+                ];
+            }
+            send({
+                type: 'file-complete',
+                payload: result
+            });
+        } catch (_error) {
+            const error = _error instanceof Error ? _error : new Error(String(_error));
+            send({
+                type: 'fatal',
+                payload: {
+                    message: error.message,
+                    stack: error.stack
+                }
+            });
+            window.__RSTEST_DONE__ = true;
+            return;
+        } finally{
+            restoreConsole();
+            activeUnhandledErrors = void 0;
+        }
+    }
+    window.removeEventListener('error', onWindowError);
+    window.removeEventListener('unhandledrejection', onUnhandledRejection);
+    send({
+        type: 'complete'
+    });
+    window.__RSTEST_DONE__ = true;
+};
+run().catch((error)=>{
+    const err = error instanceof Error ? error : new Error(String(error));
+    send({
+        type: 'fatal',
+        payload: {
+            message: err.message,
+            stack: err.stack
+        }
+    });
+    window.__RSTEST_DONE__ = true;
+}).finally(()=>{
+    disposeDispatchTransport();
+});

package/dist/client/sourceMap/sourceMapLoader.d.ts

@@ -0,0 +1,25 @@
+import { type DecodedSourceMapXInput, type EncodedSourceMapXInput } from '@jridgewell/trace-mapping';
+export type SourceMapPayload = EncodedSourceMapXInput | DecodedSourceMapXInput;
+export type LoadedSourceMap = {
+    sourceMap: SourceMapPayload;
+    sourceMapUrl: string;
+};
+type Fetcher = typeof fetch;
+export declare const normalizeJavaScriptUrl: (value: string, options?: {
+    origin?: string;
+}) => string | null;
+export declare const resolveInlineSourceMap: (code: string, sourceMapUrl?: string) => SourceMapPayload | null;
+export declare const loadSourceMapForSource: ({ jsUrl, signal, source, fetcher }: {
+    jsUrl: string;
+    signal?: AbortSignal;
+    source: string;
+    fetcher?: Fetcher;
+}) => Promise<LoadedSourceMap | null>;
+export declare const loadSourceMapWithCache: ({ jsUrl, cache, force, origin, fetcher }: {
+    jsUrl: string;
+    cache: Map<string, SourceMapPayload | null>;
+    force?: boolean;
+    origin?: string;
+    fetcher?: Fetcher;
+}) => Promise<SourceMapPayload | null>;
+export { };