ui5-test-runner 6.0.0-beta.4 → 6.0.0

package/README.md

@@ -1,4 +1,4 @@
-# UI5 Test runner 6️⃣ β
+# UI5 Test runner
 
 [![Node.js CI](https://github.com/ArnaudBuchholz/ui5-test-runner/actions/workflows/node.js.yml/badge.svg)](https://github.com/ArnaudBuchholz/ui5-test-runner/actions/workflows/node.js.yml)
 [![Package Quality](https://npm.packagequality.com/shield/ui5-test-runner.svg)](https://packagequality.com/#?package=ui5-test-runner)
@@ -6,48 +6,39 @@
 [![ui5-test-runner](https://badge.fury.io/js/ui5-test-runner.svg)](https://www.npmjs.org/package/ui5-test-runner)
 [![PackagePhobia](https://img.shields.io/badge/%F0%9F%93%A6package-phobia-lightgrey)](https://packagephobia.com/result?p=ui5-test-runner)
 [![MIT License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner?ref=badge_shield)
-[![Documentation](https://img.shields.io/badge/-%F0%9F%93%9Adocumentation-blueviolet)](https://arnaudbuchholz.github.io/ui5-test-runner/)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner.svg?type=shield&issueType=license)](https://app.fossa.com/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner?ref=badge_shield&issueType=license)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner.svg?type=shield&issueType=security)](https://app.fossa.com/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner?ref=badge_shield&issueType=security)
+[![Documentation](https://img.shields.io/badge/-%F0%9F%93%9Adocumentation-blueviolet)](https://github.com/ArnaudBuchholz/ui5-test-runner/tree/main/docs#-documentation)
 
-A self-sufficient test runner for UI5 applications enabling parallel execution of tests.
 
-> To put it in a nutshell, some UI5 applications have so many tests that when you run them in a browser, it ends up **crashing**. The main reason is **memory consumption** : the browser process goes up to 2 GB and it blows up. JavaScript is based on garbage collecting but it needs time to operate and the stress caused by executing the tests as well as the use of iframes do not let enough bandwidth for the browser to free up the memory.
+A self-sufficient test runner for [UI5 applications](https://ui5.sap.com/) enabling parallel execution of tests.
 
-> This tool is designed and built as a **substitute** of the [UI5 karma runner](https://github.com/SAP/karma-ui5). It executes all the tests in **parallel** thanks to several browser instances *(which also **reduces the total execution time**)*.
+> To put it in a nutshell, some [UI5 applications](https://ui5.sap.com/) have so many tests that when you run them in a browser, it ends up **crashing**. The main reason is **memory consumption** : the browser process goes up to 2 GB and it blows up. JavaScript is based on garbage collecting but it needs time to operate and the stress caused by executing the tests as well as the use of iframes do not let enough bandwidth for the browser to free up the memory.
 
-## 📚 [Documentation](https://arnaudbuchholz.github.io/ui5-test-runner/)
+> This tool is designed and built as a **substitute** of the [UI5 karma runner](https://github.com/SAP/karma-ui5). It executes all the tests in **parallel** thanks to several browser tabs *(which also **reduces the total execution time**)*.
 
 ## 💿 How to install
 
-* Works with [Node.js](https://nodejs.org/en/download/) >= 24
+* Works with [Node.js](https://nodejs.org/en/download/) >= 24.11.1
 * Local installation
-  * `npm install --save-dev ui5-test-runner`
+  * `npm install --save-dev ui5-test-runner@6`
   * Trigger either with `npx ui5-test-runner` or through an npm script invoking `ui5-test-runner`
 * Global installation
-  * `npm install --global ui5-test-runner`
+  * `npm install --global ui5-test-runner@6`
   * Trigger with `ui5-test-runner`
 
-**NOTE** : additional packages might be needed during the execution (`puppeteer`, `selenium-webdriver`, `nyc`...) . If they are found installed **locally** in the tested project, they are used. Otherwise, they are installed **globally**.
+**NOTE** : additional packages might be needed during the execution (`puppeteer`, `selenium-webdriver`, `nyc`...) . If they are found installed **locally** in the tested project, they are used. Otherwise, they are installed **on demand**.
 
-## ⚖️ License
-[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner?ref=badge_large)
+## 🤖 AI-powered documentation
 
-## ⚠️ Breaking changes
+Use `npx ui5-test-runner@6 --mcp` to start an MCP server exposing the latest indexed documentation to your AI client.
 
-| Version | Reason | 
-|-|-|
-| **6**.0.0 | • Drop support of Node.js < 24 |
-| **5**.0.0 | • Some coverage reports now includes **all** files, leading to a potential decrease of coverage |
-| **4**.0.0 | • Drop support of Node.js 16 |
-| **3**.0.0 | • Drop support of Node.js 14 |
-| **2**.0.0 | • Command line **parameters** as well as configuration file **syntax** have changed |
-|| • Dependencies are installed **on demand** |
-|| • Browser instantiation command evolved in an **incompatible way** (see [documentation](https://arnaudbuchholz.github.io/ui5-test-runner/browser.html)) |
-|| • Output is different (report, traces) |
+## 🧭 Links
+
+* 📚 [Documentation](https://github.com/ArnaudBuchholz/ui5-test-runner/tree/main/docs#-documentation)
+
+* ⚠️ [Breaking changes](https://github.com/ArnaudBuchholz/ui5-test-runner/blob/main/docs/v6_breaking_changes.md)
+
+* ✒ [Contributors](https://github.com/ArnaudBuchholz/ui5-test-runner/graphs/contributors?all=1)
 
-## ✒ Contributors
 
-* [Marian Zeis](https://github.com/marianfoo): Documentation page revamp [PR #54](https://github.com/ArnaudBuchholz/ui5-test-runner/pull/54)
-* [Raj Singh](https://github.com/rajxsingh): Basic HTTP Authentication in Puppeteer [PR #71](https://github.com/ArnaudBuchholz/ui5-test-runner/pull/71)
-* [Andreas Kunz](https://github.com/akudev): Improved documentation for TypeScript testing and reviewed `nyc` settings handling [PR #110](https://github.com/ArnaudBuchholz/ui5-test-runner/pull/110)
-* [Juri Zeisler](https://github.com/juriz889): Added screenshots to the JUnit XML Report [PR #158](https://github.com/ArnaudBuchholz/ui5-test-runner/pull/158)

package/dist/Command.js

@@ -0,0 +1,52 @@
+import { assert } from './platform/index.js';
+import { Npm } from './Npm.js';
+const QUOTED_AND_UNQUOTED_TOKENS = /"[^"]*"|'[^']*'|[^ ]+/g;
+export const Command = {
+    split(command) {
+        return command
+            .matchAll(QUOTED_AND_UNQUOTED_TOKENS)
+            .map(([value]) => {
+            return (value.startsWith("'") && value.endsWith("'")) || (value.startsWith('"') && value.endsWith('"'))
+                ? value.slice(1, -1)
+                : value;
+        })
+            .toArray();
+    },
+    substitute(configuration, value, extras = {}) {
+        return value.replaceAll(/\{\{(\w+)\}\}/g, (_, optionName) => {
+            if (optionName in extras) {
+                return extras[optionName];
+            }
+            assert(optionName in configuration, `Invalid command line substitution parameter: ${optionName}`);
+            return configuration[optionName]?.toString() ?? '';
+        });
+    },
+    async parse(configuration, command, extras = {}) {
+        let executable = 'node';
+        const tokens = Command.split(command);
+        const environment = {};
+        while (tokens.length > 0 && /^\w+=/.test(tokens[0])) {
+            const [key, ...rest] = tokens.shift().split('=');
+            environment[key] = Command.substitute(configuration, rest.join('='), extras);
+        }
+        const [commandSpecifier, ...parameters] = tokens;
+        assert(!!commandSpecifier);
+        if (commandSpecifier === 'npm') {
+            parameters.unshift(await Npm.getCliPath());
+        }
+        else if (commandSpecifier !== 'node') {
+            const scripts = await Npm.listPackageScriptNames(configuration.cwd);
+            if (scripts.includes(commandSpecifier)) {
+                parameters.unshift(await Npm.getCliPath(), 'run', commandSpecifier);
+            }
+            else {
+                executable = commandSpecifier;
+            }
+        }
+        return [
+            executable,
+            parameters.map((parameter) => Command.substitute(configuration, parameter, extras)),
+            environment
+        ];
+    }
+};

package/dist/Npm.js

@@ -1,80 +1,230 @@
-import { logger, FileSystem, Http, Path, Process } from './platform/index.js';
+import { assert, logger, FileSystem, Http, Module, Path, Process, Url } from './platform/index.js';
 import { memoize } from './utils/shared/memoize.js';
-const getNpmCliPath = memoize(async () => {
+export const getNpmCliPath = async () => {
     const npmChildProcess = Process.spawn('npm', [], {
         shell: true
     });
     await npmChildProcess.closed;
-    const error = new Error('Unable to initialize NPM');
     const match = /^npm@([^ ]+) (.*)$/gm.exec(npmChildProcess.stdout);
-    if (!match) {
-        logger.fatal({ source: 'npm', message: 'Unable to match NPM output', error });
-        throw error;
-    }
+    assert(match !== null, 'unable to match NPM output');
     const [, semver, path] = match;
-    if (!semver || !path) {
-        logger.fatal({ source: 'npm', message: 'Failed to parse NPM output', error, data: { semver, path } });
-        throw error;
-    }
+    assert(!!semver && !!path, 'failed to parse NPM output');
     logger.debug({ source: 'npm', message: `npm@${semver} ${path}` });
     return Path.join(path, 'bin/npm-cli.js');
-});
+};
+const memoizedNpmCliPath = memoize(getNpmCliPath);
 const npm = async (...arguments_) => {
-    const npmCliPath = await getNpmCliPath();
+    const npmCliPath = await memoizedNpmCliPath();
     return Process.spawn('node', [npmCliPath, ...arguments_], {
         detached: true
     });
 };
+const validateRoot = async (proc, label) => {
+    if (proc.code !== 0) {
+        logger.fatal({ source: 'npm', message: `npm root ${label} failed with code ${proc.code}` });
+    }
+    const value = proc.stdout.trim();
+    if (value === '' || !Path.isAbsolute(value)) {
+        logger.fatal({ source: 'npm', message: `npm root ${label} returned an invalid path: "${value}"` });
+    }
+    try {
+        await FileSystem.access(value, FileSystem.constants.R_OK);
+    }
+    catch {
+        logger.fatal({ source: 'npm', message: `npm root ${label} directory is not accessible: "${value}"` });
+    }
+    return value;
+};
 const getRoots = memoize(async () => {
     const localRootProcess = await npm('root');
     const globalRootProcess = await npm('root', '--global');
     await Promise.all([localRootProcess.closed, globalRootProcess.closed]);
-    const local = localRootProcess.stdout.trim();
-    const global = globalRootProcess.stdout.trim();
-    logger.debug({ source: 'npm', message: 'Roots', data: { local, global } });
-    return {
-        local: localRootProcess.stdout.trim(),
-        global: globalRootProcess.stdout.trim()
-    };
+    const local = await validateRoot(localRootProcess, '(local)');
+    const global = await validateRoot(globalRootProcess, '(global)');
+    logger.debug({ source: 'npm', message: 'roots', data: { local, global } });
+    return { local, global };
 });
-export const Npm = {
-    async getLatestVersion(moduleName) {
+const buildInstallPlan = (strategy, moduleName, options) => {
+    const { globalRoot, prefix, allowScripts, minReleaseAge } = options;
+    const noScripts = allowScripts ? [] : ['--ignore-scripts'];
+    const releaseAge = minReleaseAge > 0 ? [`--min-release-age=${minReleaseAge}`] : [];
+    const extraFlags = [...noScripts, ...releaseAge];
+    if (strategy === 'global') {
+        return { installArguments: ['install', '-g', ...extraFlags, moduleName], reimportPath: globalRoot };
+    }
+    return strategy === 'prefix'
+        ? {
+            installArguments: ['install', '--prefix', prefix, '--no-save', ...extraFlags, moduleName],
+            reimportPath: Path.join(prefix, 'node_modules')
+        }
+        : { installArguments: ['install', '--no-save', ...extraFlags, moduleName], reimportPath: undefined };
+};
+export class Npm {
+    static dynamicImport(specifier) {
+        return import(specifier);
+    }
+    static tryResolvePackageDir(moduleName, nodeModulesPath) {
         try {
-            const response = await Http.get(`https://registry.npmjs.org/${moduleName}/latest`);
+            const packageJsonPath = Module.findPackageJSON(moduleName, `${nodeModulesPath}/`);
+            return packageJsonPath === undefined ? undefined : Path.dirname(packageJsonPath);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    static async tryImportFromPath(configuration, moduleName, nodeModulesPath) {
+        try {
+            const require = Module.createRequire(`${Url.pathToFileURL(configuration.cwd).href}/`);
+            const resolved = require.resolve(moduleName, { paths: [nodeModulesPath] });
+            return await this.dynamicImport(Url.pathToFileURL(resolved).href);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    static async tryImportFromRoots(configuration, moduleName, roots) {
+        for (const { path, label, checkVersion } of roots) {
+            const result = await this.tryImportFromPath(configuration, moduleName, path);
+            if (result !== undefined) {
+                logger.debug({ source: 'npm', message: `Module ${moduleName} ${label}` });
+                if (checkVersion)
+                    void this.checkIfLatestVersion(configuration, moduleName);
+                return result;
+            }
+        }
+        return undefined;
+    }
+    static async import(configuration, moduleName) {
+        logger.debug({ source: 'npm', message: `Importing module: ${moduleName}` });
+        try {
+            const module = await this.dynamicImport(moduleName);
+            logger.debug({ source: 'npm', message: `Module ${moduleName} found locally` });
+            void this.checkIfLatestVersion(configuration, moduleName);
+            return module;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ERR_MODULE_NOT_FOUND' && code !== 'MODULE_NOT_FOUND') {
+                throw error;
+            }
+            if (moduleName === this.packageNameOf(moduleName)) {
+                logger.warn({ source: 'npm', message: `Module ${moduleName} not found locally` });
+            }
+        }
+        const { local: localRoot, global: globalRoot } = await getRoots();
+        const extraRoots = [
+            ...(configuration.alternateNpmPath
+                ? [{ path: configuration.alternateNpmPath, label: 'found in alternateNpmPath' }]
+                : []),
+            ...(configuration.npmInstallPrefix
+                ? [{ path: Path.join(configuration.npmInstallPrefix, 'node_modules'), label: 'found in npmInstallPrefix' }]
+                : [])
+        ];
+        const found = await this.tryImportFromRoots(configuration, moduleName, [
+            { path: localRoot, label: 'found in local node_modules', checkVersion: true },
+            { path: globalRoot, label: 'found globally', checkVersion: true },
+            ...extraRoots
+        ]);
+        if (found !== undefined)
+            return found;
+        if (configuration.noNpmInstall) {
+            const message = `Module ${moduleName} not found and noNpmInstall is set`;
+            logger.fatal({ source: 'npm', message });
+        }
+        const strategy = configuration.npmInstall;
+        logger.info({ source: 'npm', message: `Installing ${moduleName} (strategy: ${strategy})` });
+        const { installArguments, reimportPath } = buildInstallPlan(strategy, moduleName, {
+            globalRoot,
+            prefix: configuration.npmInstallPrefix ?? '',
+            allowScripts: !!configuration.npmAllowInstallScripts,
+            minReleaseAge: configuration.npmInstallMinReleaseAge
+        });
+        const installProcess = await npm(...installArguments);
+        await installProcess.closed;
+        if (reimportPath !== undefined) {
+            const result = await this.tryImportFromPath(configuration, moduleName, reimportPath);
+            if (result === undefined) {
+                const message = `Module ${moduleName} could not be loaded after install`;
+                logger.fatal({ source: 'npm', message });
+            }
+            return result;
+        }
+        return await this.dynamicImport(moduleName);
+    }
+    static async resolvePackageDir(configuration, moduleName) {
+        const { local, global: globalRoot } = await getRoots();
+        const fromLocal = this.tryResolvePackageDir(moduleName, local);
+        if (fromLocal)
+            return fromLocal;
+        const fromGlobal = this.tryResolvePackageDir(moduleName, globalRoot);
+        if (fromGlobal)
+            return fromGlobal;
+        if (configuration.alternateNpmPath) {
+            const fromAlternate = this.tryResolvePackageDir(moduleName, configuration.alternateNpmPath);
+            if (fromAlternate)
+                return fromAlternate;
+        }
+        if (configuration.npmInstallPrefix) {
+            const fromPrefix = this.tryResolvePackageDir(moduleName, Path.join(configuration.npmInstallPrefix, 'node_modules'));
+            if (fromPrefix)
+                return fromPrefix;
+        }
+        throw new Error(`Cannot locate package directory for ${moduleName}`);
+    }
+    static packageNameOf(moduleName) {
+        if (moduleName.startsWith('@')) {
+            const [scope, package_] = moduleName.split('/', 2);
+            return `${scope}/${package_}`;
+        }
+        return moduleName.split('/', 1)[0];
+    }
+    static async getLatestVersion(packageName) {
+        try {
+            const response = await Http.getAsText(`https://registry.npmjs.org/${packageName}/latest`);
             const { version } = JSON.parse(response);
             return version;
         }
         catch (error) {
-            throw new Error(`Unable to fetch latest version of ${moduleName} from NPM registry`, {
+            throw new Error(`Unable to fetch latest version of ${packageName} from NPM registry`, {
                 cause: error
             });
         }
-    },
-    async checkIfLatestVersion(moduleName, isLocal) {
+    }
+    static _checkedPackages = new Set();
+    static async checkIfLatestVersion(configuration, moduleName) {
+        const packageName = this.packageNameOf(moduleName);
+        if (this._checkedPackages.has(packageName)) {
+            return;
+        }
+        this._checkedPackages.add(packageName);
         try {
-            const { local, global } = await getRoots();
-            const { version: installedVersion } = JSON.parse(await FileSystem.readFile(Path.join(isLocal ? local : global, moduleName, 'package.json'), 'utf8'));
-            logger.info({ source: 'npm', message: `Installed version of ${moduleName} is ${installedVersion}` });
-            const latestVersion = await Npm.getLatestVersion(moduleName);
+            const packageDirectory = await this.resolvePackageDir(configuration, packageName);
+            const { version: installedVersion } = JSON.parse(await FileSystem.readFile(Path.join(packageDirectory, 'package.json'), 'utf8'));
+            logger.info({ source: 'npm', message: `Installed version of ${packageName} is ${installedVersion}` });
+            const latestVersion = await this.getLatestVersion(packageName);
             if (latestVersion !== installedVersion) {
-                logger.warn({ source: 'npm', message: `[PKGVRS] Latest version of ${moduleName} is ${latestVersion}` });
+                logger.warn({ source: 'npm', message: `Latest version of ${packageName} is ${latestVersion}` });
             }
         }
         catch (error) {
-            logger.error({ source: 'npm', message: 'Failed in checkIfLatestVersion', error });
+            logger.error({ source: 'npm', message: 'failed in checkIfLatestVersion', error });
         }
-    },
-    async import(moduleName) {
-        logger.debug({ source: 'npm', message: `Npm.import(${moduleName})` });
+    }
+    static async getCliPath() {
+        return await memoizedNpmCliPath();
+    }
+    static async listPackageScriptNames(cwd) {
         try {
-            const module = (await import(moduleName));
-            logger.debug({ source: 'npm', message: `Module ${moduleName} found locally` });
-            void this.checkIfLatestVersion(moduleName, true);
-            return module;
+            const packageJsonPath = Module.findPackageJSON(`${Url.pathToFileURL(cwd).href}/`);
+            if (!packageJsonPath) {
+                return [];
+            }
+            const content = JSON.parse(await FileSystem.readFile(packageJsonPath, 'utf8'));
+            return Object.keys(content?.scripts ?? {});
         }
-        catch {
-            logger.warn({ source: 'npm', message: `Module ${moduleName} not found locally` });
+        catch (error) {
+            logger.error({ source: 'npm', message: 'failed to list package script names', error, data: { cwd } });
+            return [];
         }
-        throw new Error('Not implemented');
     }
-};
+}

package/dist/browsers/RecoverableBrowserError.js

@@ -0,0 +1,6 @@
+export class RecoverableBrowserError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RecoverableBrowserError';
+    }
+}

package/dist/browsers/chromeArguments.js

@@ -0,0 +1,5 @@
+import { Host } from '../platform/index.js';
+export const getExtraChromeArguments = () => {
+    const raw = Host.env['UI5TR_CHROME_ARGS'];
+    return raw === undefined ? [] : raw.split(/\s+/).filter((argument) => argument.length > 0);
+};

package/dist/browsers/chromeOptions.js

@@ -0,0 +1,29 @@
+import { getExtraChromeArguments } from './chromeArguments.js';
+export const DEFAULT_CHROME_ARGS = [
+    '--disable-background-timer-throttling',
+    '--disable-backgrounding-occluded-windows',
+    '--disable-renderer-backgrounding'
+];
+export const buildChromeLaunchOptions = (options, extraArguments = [], shouldIncludeEnvironmentArguments = true) => {
+    const rawArguments = options?.['args'];
+    const userArguments = Array.isArray(rawArguments)
+        ? rawArguments.filter((a) => typeof a === 'string')
+        : [];
+    const rawIgnoreDefaultArguments = options?.['ignoreDefaultArgs'];
+    let ignoreDefaultArguments;
+    if (rawIgnoreDefaultArguments === true) {
+        ignoreDefaultArguments = true;
+    }
+    else if (Array.isArray(rawIgnoreDefaultArguments)) {
+        ignoreDefaultArguments = rawIgnoreDefaultArguments.filter((argument) => typeof argument === 'string');
+    }
+    return {
+        args: [
+            ...DEFAULT_CHROME_ARGS,
+            ...extraArguments,
+            ...userArguments,
+            ...(shouldIncludeEnvironmentArguments ? getExtraChromeArguments() : [])
+        ],
+        ...(ignoreDefaultArguments !== undefined && { ignoreDefaultArgs: ignoreDefaultArguments })
+    };
+};

package/dist/browsers/consoleMessage.js

@@ -0,0 +1,23 @@
+import { logger } from '../platform/index.js';
+import { agentLogPrefix } from '../types/AgentState.js';
+const LOG_TYPES = {
+    error: 'error',
+    warn: 'warn',
+    assert: 'warn',
+    debug: 'debug'
+};
+export const handleConsoleMessage = (type, text, pageId) => {
+    const normalizedType = type === 'warning' ? 'warn' : type;
+    const logType = LOG_TYPES[normalizedType] ?? 'info';
+    let source;
+    let message;
+    if (text.startsWith(agentLogPrefix)) {
+        source = 'browser/agent';
+        message = text.slice(agentLogPrefix.length);
+    }
+    else {
+        source = 'browser/console';
+        message = text;
+    }
+    logger[logType]({ source, message, pageId, data: { type: normalizedType } });
+};

package/dist/browsers/factory.js

@@ -1,9 +1,174 @@
-import { factory as puppeteerFactory } from './puppeteer.js';
+import { factory as puppeteerFactory, descriptor as puppeteerDescriptor } from './puppeteer.js';
+import { factory as playwrightFactory, descriptor as playwrightDescriptor } from './playwright.js';
+import { factory as webdriverioFactory, descriptor as webdriverioDescriptor } from './webdriverio.js';
+import { factory as seleniumWebdriverFactory, descriptor as seleniumWebdriverDescriptor } from './seleniumWebdriver.js';
+import { Exit, logger } from '../platform/index.js';
+import { RecoverableBrowserError } from './RecoverableBrowserError.js';
+const DRIVERS = ['puppeteer', 'playwright', 'webdriverio', 'selenium-webdriver'];
+export const isDriver = (value) => DRIVERS.includes(value);
 const factories = {
-    puppeteer: puppeteerFactory
+    puppeteer: puppeteerFactory,
+    playwright: playwrightFactory,
+    webdriverio: webdriverioFactory,
+    'selenium-webdriver': seleniumWebdriverFactory
+};
+const descriptors = {
+    puppeteer: puppeteerDescriptor,
+    playwright: playwrightDescriptor,
+    webdriverio: webdriverioDescriptor,
+    'selenium-webdriver': seleniumWebdriverDescriptor
+};
+export const getDescriptor = (driver) => descriptors[driver];
+let _instanceCount = 0;
+const _activeInstances = new Set();
+const shutdown = async (browser, inner) => {
+    logger.debug({ source: browser, message: 'shutdown' });
+    try {
+        await inner.shutdown();
+        logger.debug({ source: browser, message: 'shutdown completed' });
+    }
+    catch (error) {
+        logger.warn({
+            source: browser,
+            message: 'shutdown failed',
+            error
+        });
+    }
 };
 export const BrowserFactory = {
-    async build(browser) {
-        return await factories[browser]();
+    async build(configuration, browser) {
+        if (_activeInstances.has(browser)) {
+            logger.fatal({ source: browser, message: 'build failed: already has an active instance' });
+        }
+        _activeInstances.add(browser);
+        const abortController = new AbortController();
+        let inner;
+        try {
+            logger.debug({ source: browser, message: 'build' });
+            inner = await factories[browser](configuration, abortController.signal);
+            logger.debug({ source: browser, message: 'build completed' });
+        }
+        catch (error) {
+            _activeInstances.delete(browser);
+            logger.fatal({ source: browser, message: 'build failed', error });
+            throw error;
+        }
+        const _openWindows = new Set();
+        const closeAllWindows = async () => {
+            await Promise.all([..._openWindows].map(async (w) => {
+                try {
+                    await w.close();
+                }
+                catch {
+                }
+            }));
+        };
+        let task;
+        return {
+            async setup(settings) {
+                task = Exit.registerAsyncTask({
+                    name: `${browser}#${++_instanceCount}`,
+                    async stop() {
+                        abortController.abort();
+                        await closeAllWindows();
+                        await shutdown(browser, inner);
+                    }
+                });
+                logger.debug({ source: browser, message: 'setup', data: settings });
+                try {
+                    const capabilities = await inner.setup(settings);
+                    logger.debug({ source: browser, message: 'setup completed', data: capabilities });
+                    return capabilities;
+                }
+                catch (error) {
+                    task[Symbol.dispose]();
+                    _activeInstances.delete(browser);
+                    logger.fatal({
+                        source: browser,
+                        message: 'setup failed',
+                        error
+                    });
+                    throw error;
+                }
+            },
+            async newWindow(settings) {
+                const { pageId } = settings;
+                logger.debug({ source: browser, message: 'newWindow', pageId, data: settings });
+                try {
+                    const innerWindow = await inner.newWindow(settings);
+                    logger.debug({ source: browser, message: 'newWindow completed', pageId });
+                    const wrapped = wrapWindow(innerWindow, browser, pageId, () => _openWindows.delete(wrapped));
+                    _openWindows.add(wrapped);
+                    return wrapped;
+                }
+                catch (error) {
+                    const logMethod = error instanceof RecoverableBrowserError ? 'error' : 'fatal';
+                    logger[logMethod]({
+                        source: browser,
+                        message: 'newWindow failed',
+                        error
+                    });
+                    throw error;
+                }
+            },
+            async shutdown() {
+                await closeAllWindows();
+                await shutdown(browser, inner);
+                task?.[Symbol.dispose]();
+                _activeInstances.delete(browser);
+            }
+        };
     }
 };
+const wrapWindow = (innerWindow, source, pageId, onClosed) => {
+    let isClosed = false;
+    return {
+        async eval(script) {
+            logger.debug({ source, message: 'eval', pageId, data: { script } });
+            try {
+                if (isClosed) {
+                    throw new Error('window closed');
+                }
+                const result = await innerWindow.eval(script);
+                logger.debug({ source, message: 'eval completed', pageId, data: { result } });
+                return result;
+            }
+            catch (error) {
+                logger.error({ source, message: 'eval failed', pageId, error });
+                throw error;
+            }
+        },
+        async screenshot(path) {
+            logger.debug({ source, message: 'screenshot', pageId, data: { path } });
+            try {
+                if (isClosed) {
+                    throw new Error('window closed');
+                }
+                await innerWindow.screenshot(path);
+                logger.debug({ source, message: 'screenshot completed', pageId, data: { path } });
+            }
+            catch (error) {
+                logger.error({ source, message: 'screenshot failed', pageId, error, data: { path } });
+                throw error;
+            }
+        },
+        async close() {
+            if (isClosed) {
+                logger.warn({ source, message: 'closing an already closed window, ignored', pageId });
+                return;
+            }
+            isClosed = true;
+            logger.debug({ source, message: 'window close', pageId });
+            try {
+                await innerWindow.close();
+                logger.debug({ source, message: 'window closed', pageId });
+            }
+            catch (error) {
+                logger.error({ source, message: 'window close failed', error });
+            }
+            finally {
+                onClosed();
+            }
+        }
+    };
+};