@react-native-harness/cli 1.1.0 → 1.2.0

package/dist/__tests__/platform-commands.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=platform-commands.test.d.ts.map

package/dist/__tests__/platform-commands.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-commands.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/platform-commands.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/platform-commands.test.js

@@ -0,0 +1,207 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { discoverPlatformCommands, runPlatformCommand, } from '../platform-commands.js';
+const createCommandModuleUrl = (body) => `data:text/javascript,${encodeURIComponent(body)}`;
+const globalState = globalThis;
+describe('platform CLI command discovery', () => {
+    afterEach(() => {
+        delete globalState.__platformCommandCall;
+    });
+    it('runs a discovered platform command', async () => {
+        const moduleUrl = createCommandModuleUrl(`
+      export const commands = [{
+        name: 'xctest',
+        async run(args, context) {
+          globalThis.__platformCommandCall = { args, context };
+        }
+      }];
+    `);
+        const loadConfig = vi.fn(async () => ({
+            projectRoot: '/tmp/project',
+            config: {
+                entryPoint: 'index.js',
+                appRegistryComponentName: 'App',
+                runners: [
+                    {
+                        name: 'ios',
+                        config: {},
+                        runner: '/virtual/runner.js',
+                        cli: moduleUrl,
+                        platformId: 'ios',
+                    },
+                ],
+                plugins: [],
+                metroPort: 8081,
+                webSocketPort: undefined,
+                bridgeTimeout: 60000,
+                platformReadyTimeout: 300000,
+                bundleStartTimeout: 60000,
+                maxAppRestarts: 2,
+                resetEnvironmentBetweenTestFiles: true,
+                unstable__skipAlreadyIncludedModules: false,
+                unstable__enableMetroCache: false,
+                permissions: false,
+                detectNativeCrashes: true,
+                crashDetectionInterval: 500,
+                disableViewFlattening: false,
+                forwardClientLogs: false,
+            },
+        }));
+        expect(await runPlatformCommand({
+            argv: ['xctest', 'build', '--destination', 'simulator'],
+            cwd: '/tmp/project',
+            loadConfig,
+        })).toBe(true);
+        expect(globalState.__platformCommandCall).toEqual({
+            args: ['build', '--destination', 'simulator'],
+            context: {
+                cwd: '/tmp/project',
+                projectRoot: '/tmp/project',
+            },
+        });
+    });
+    it('deduplicates platform CLI modules across runners', async () => {
+        const moduleUrl = createCommandModuleUrl(`
+      export const commands = [{
+        name: 'xctest',
+        async run() {}
+      }];
+    `);
+        const loadConfig = vi.fn(async () => ({
+            projectRoot: '/tmp/project',
+            config: {
+                entryPoint: 'index.js',
+                appRegistryComponentName: 'App',
+                runners: [
+                    {
+                        name: 'ios-sim',
+                        config: {},
+                        runner: '/virtual/ios-sim-runner.js',
+                        cli: moduleUrl,
+                        platformId: 'ios',
+                    },
+                    {
+                        name: 'ios-device',
+                        config: {},
+                        runner: '/virtual/ios-device-runner.js',
+                        cli: moduleUrl,
+                        platformId: 'ios',
+                    },
+                ],
+                plugins: [],
+                metroPort: 8081,
+                webSocketPort: undefined,
+                bridgeTimeout: 60000,
+                platformReadyTimeout: 300000,
+                bundleStartTimeout: 60000,
+                maxAppRestarts: 2,
+                resetEnvironmentBetweenTestFiles: true,
+                unstable__skipAlreadyIncludedModules: false,
+                unstable__enableMetroCache: false,
+                permissions: false,
+                detectNativeCrashes: true,
+                crashDetectionInterval: 500,
+                disableViewFlattening: false,
+                forwardClientLogs: false,
+            },
+        }));
+        const discoveredCommands = await discoverPlatformCommands({
+            cwd: '/tmp/project',
+            loadConfig,
+        });
+        expect(discoveredCommands?.commands).toHaveLength(1);
+    });
+    it('returns false when no platform command matches', async () => {
+        const loadConfig = vi.fn(async () => ({
+            projectRoot: '/tmp/project',
+            config: {
+                entryPoint: 'index.js',
+                appRegistryComponentName: 'App',
+                runners: [
+                    {
+                        name: 'android',
+                        config: {},
+                        runner: '/virtual/android-runner.js',
+                        platformId: 'android',
+                    },
+                ],
+                plugins: [],
+                metroPort: 8081,
+                webSocketPort: undefined,
+                bridgeTimeout: 60000,
+                platformReadyTimeout: 300000,
+                bundleStartTimeout: 60000,
+                maxAppRestarts: 2,
+                resetEnvironmentBetweenTestFiles: true,
+                unstable__skipAlreadyIncludedModules: false,
+                unstable__enableMetroCache: false,
+                permissions: false,
+                detectNativeCrashes: true,
+                crashDetectionInterval: 500,
+                disableViewFlattening: false,
+                forwardClientLogs: false,
+            },
+        }));
+        await expect(runPlatformCommand({
+            argv: ['xctest', 'build'],
+            cwd: '/tmp/project',
+            loadConfig,
+        })).resolves.toBe(false);
+    });
+    it('throws when two platform modules define the same command', async () => {
+        const firstModuleUrl = createCommandModuleUrl(`
+      export const commands = [{
+        name: 'xctest',
+        async run() {}
+      }];
+    `);
+        const secondModuleUrl = createCommandModuleUrl(`
+      // second module
+      export const commands = [{
+        name: 'xctest',
+        async run() {}
+      }];
+    `);
+        const loadConfig = vi.fn(async () => ({
+            projectRoot: '/tmp/project',
+            config: {
+                entryPoint: 'index.js',
+                appRegistryComponentName: 'App',
+                runners: [
+                    {
+                        name: 'ios',
+                        config: {},
+                        runner: '/virtual/ios-runner.js',
+                        cli: firstModuleUrl,
+                        platformId: 'ios',
+                    },
+                    {
+                        name: 'android',
+                        config: {},
+                        runner: '/virtual/android-runner.js',
+                        cli: secondModuleUrl,
+                        platformId: 'android',
+                    },
+                ],
+                plugins: [],
+                metroPort: 8081,
+                webSocketPort: undefined,
+                bridgeTimeout: 60000,
+                platformReadyTimeout: 300000,
+                bundleStartTimeout: 60000,
+                maxAppRestarts: 2,
+                resetEnvironmentBetweenTestFiles: true,
+                unstable__skipAlreadyIncludedModules: false,
+                unstable__enableMetroCache: false,
+                permissions: false,
+                detectNativeCrashes: true,
+                crashDetectionInterval: 500,
+                disableViewFlattening: false,
+                forwardClientLogs: false,
+            },
+        }));
+        await expect(discoverPlatformCommands({
+            cwd: '/tmp/project',
+            loadConfig,
+        })).rejects.toThrow("Duplicate platform CLI command 'xctest'");
+    });
+});

package/dist/bundlers/metro.d.ts

@@ -0,0 +1,5 @@
+import { type ChildProcess } from 'node:child_process';
+export declare const runMetro: (isExpo?: boolean) => Promise<ChildProcess>;
+export declare const waitForMetro: (port?: number, maxRetries?: number, retryDelay?: number) => Promise<void>;
+export declare const reloadApp: () => Promise<void>;
+//# sourceMappingURL=metro.d.ts.map

package/dist/bundlers/metro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metro.d.ts","sourceRoot":"","sources":["../../src/bundlers/metro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAcvD,eAAO,MAAM,QAAQ,GAAU,gBAAc,KAAG,OAAO,CAAC,YAAY,CAiDnE,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,aAAW,EACX,mBAAe,EACf,mBAAiB,KAChB,OAAO,CAAC,IAAI,CA4Bd,CAAC;AAEF,eAAO,MAAM,SAAS,QAAa,OAAO,CAAC,IAAI,CAE9C,CAAC"}

package/dist/bundlers/metro.js

@@ -0,0 +1,71 @@
+import { getReactNativeCliPath, getExpoCliPath, getTimeoutSignal, spawn, logger, SubprocessError, } from '@react-native-harness/tools';
+import { isPortAvailable } from '../utils.js';
+import { MetroPortUnavailableError } from '../errors/errors.js';
+const METRO_PORT = 8081;
+export const runMetro = async (isExpo = false) => {
+    const metro = spawn('node', [
+        isExpo ? getExpoCliPath() : getReactNativeCliPath(),
+        'start',
+        '--port',
+        METRO_PORT.toString(),
+    ], {
+        env: {
+            ...process.env,
+            RN_HARNESS: 'true',
+            ...(isExpo && { EXPO_NO_METRO_WORKSPACE_ROOT: 'true' }),
+        },
+    });
+    // Forward metro output to logger
+    metro.nodeChildProcess.then((childProcess) => {
+        if (childProcess.stdout) {
+            childProcess.stdout.on('data', (data) => {
+                logger.debug(data.toString().trim());
+            });
+        }
+        if (childProcess.stderr) {
+            childProcess.stderr.on('data', (data) => {
+                logger.debug(data.toString().trim());
+            });
+        }
+    });
+    metro.catch((error) => {
+        // This process is going to be killed by us, so we don't need to throw an error
+        if (error instanceof SubprocessError && error.signalName === 'SIGTERM') {
+            return;
+        }
+        logger.error('Metro crashed unexpectedly', error);
+    });
+    const isDefaultPortAvailable = await isPortAvailable(METRO_PORT);
+    if (!isDefaultPortAvailable) {
+        throw new MetroPortUnavailableError(METRO_PORT);
+    }
+    await waitForMetro();
+    return metro.nodeChildProcess;
+};
+export const waitForMetro = async (port = 8081, maxRetries = 20, retryDelay = 1000) => {
+    let attempts = 0;
+    while (attempts < maxRetries) {
+        attempts++;
+        try {
+            const response = await fetch(`http://localhost:${port}/status`, {
+                signal: getTimeoutSignal(100),
+            });
+            if (response.ok) {
+                const body = await response.text();
+                if (body === 'packager-status:running') {
+                    return;
+                }
+            }
+        }
+        catch {
+            // Errors are expected here, we're just waiting for the process to be ready
+        }
+        if (attempts < maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+    }
+    throw new Error(`Metro bundler is not ready after ${maxRetries} attempts`);
+};
+export const reloadApp = async () => {
+    await fetch(`http://localhost:${METRO_PORT}/reload`);
+};

package/dist/bundlers/webpack.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=webpack.d.ts.map

package/dist/bundlers/webpack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack.d.ts","sourceRoot":"","sources":["../../src/bundlers/webpack.ts"],"names":[],"mappings":""}

package/dist/bundlers/webpack.js

@@ -0,0 +1,49 @@
+// import { ChildProcess, spawn } from 'node:child_process';
+export {};
+// export const runWebpack = async (configPath: string): Promise<ChildProcess> => {
+//   const webpack = await new Promise<ChildProcess>((resolve) => {
+//     const webpackProcess = spawn(
+//       'webpack',
+//       [
+//         'serve',
+//         '--config',
+//         configPath,
+//         '--mode',
+//         'development',
+//         '--hot',
+//         '--port',
+//         '8081',
+//       ],
+//       {
+//         stdio: 'ignore',
+//         env: {
+//           ...process.env,
+//           RN_HARNESS: 'true',
+//         },
+//       }
+//     );
+//     resolve(webpackProcess);
+//   });
+//   await waitForWebpack(8081);
+//   return webpack;
+// };
+// export const waitForWebpack = async (
+//   port: number = 8081,
+//   maxRetries: number = 10,
+//   retryDelay: number = 2000
+// ): Promise<void> => {
+//   let attempts = 0;
+//   while (attempts < maxRetries) {
+//     attempts++;
+//     try {
+//       const response = await fetch(`http://localhost:${port}`);
+//       if (response.ok) {
+//         return;
+//       }
+//     } catch {}
+//     if (attempts < maxRetries) {
+//       await new Promise((resolve) => setTimeout(resolve, retryDelay));
+//     }
+//   }
+//   throw new Error(`Metro bundler is not ready after ${maxRetries} attempts`);
+// };

package/dist/commands/test.d.ts

@@ -0,0 +1,3 @@
+import { type TestFilterOptions } from '../discovery/index.js';
+export declare const testCommand: (runnerName?: string, options?: TestFilterOptions) => Promise<void>;
+//# sourceMappingURL=test.d.ts.map

package/dist/commands/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../src/commands/test.ts"],"names":[],"mappings":"AAsBA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,uBAAuB,CAAC;AAiK/B,eAAO,MAAM,WAAW,GACtB,aAAa,MAAM,EACnB,UAAS,iBAAsB,KAC9B,OAAO,CAAC,IAAI,CA0Cd,CAAC"}

package/dist/commands/test.js

@@ -0,0 +1,140 @@
+import { getBridgeServer, } from '@react-native-harness/bridge/server';
+import { getConfig, } from '@react-native-harness/config';
+import { getPlatformAdapter } from '../platforms/platform-registry.js';
+import { intro, logger, outro, spinner } from '@react-native-harness/tools';
+import { BridgeTimeoutError } from '../errors/errors.js';
+import { assert } from '../utils.js';
+import { EnvironmentInitializationError, NoRunnerSpecifiedError, RpcClientError, RunnerNotFoundError, } from '../errors/errors.js';
+import { discoverTestFiles, } from '../discovery/index.js';
+const setupEnvironment = async (context) => {
+    const startSpinner = spinner();
+    const platform = context.runner.platform;
+    startSpinner.start(`Starting "${context.runner.name}" (${platform}) runner`);
+    const platformAdapter = await getPlatformAdapter(platform);
+    const serverBridge = await getBridgeServer({
+        port: 3001,
+    });
+    context.bridge = serverBridge;
+    const readyPromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new BridgeTimeoutError(context.config.bridgeTimeout, context.runner.name, platform));
+        }, context.config.bridgeTimeout);
+        serverBridge.once('ready', () => {
+            clearTimeout(timeout);
+            resolve();
+        });
+    });
+    context.environment = await platformAdapter.getEnvironment(context.runner);
+    logger.debug('Waiting for bridge to be ready');
+    await readyPromise;
+    logger.debug('Bridge is ready');
+    if (!context.environment) {
+        throw new EnvironmentInitializationError('Failed to initialize environment', context.runner.name, platform, 'Platform adapter returned null environment');
+    }
+    startSpinner.stop(`"${context.runner.name}" (${platform}) runner started`);
+};
+const findTestFiles = async (context, options = {}) => {
+    const discoverSpinner = spinner();
+    discoverSpinner.start('Discovering tests');
+    context.testFiles = await discoverTestFiles(context.projectRoot, context.config.include, options);
+    discoverSpinner.stop(`Found ${context.testFiles.length} test files`);
+};
+const runTests = async (context, options = {}) => {
+    const { bridge, environment, testFiles, config } = context;
+    assert(bridge != null, 'Bridge not initialized');
+    assert(environment != null, 'Environment not initialized');
+    assert(testFiles != null, 'Test files not initialized');
+    let runSpinner = spinner();
+    runSpinner.start('Running tests');
+    let shouldRestart = false;
+    for (const testFile of testFiles) {
+        if (shouldRestart) {
+            runSpinner = spinner();
+            runSpinner.start(`Restarting environment for next test file`);
+            await new Promise((resolve) => {
+                bridge.once('ready', resolve);
+                environment.restart();
+            });
+        }
+        runSpinner.message(`Running tests in ${testFile}`);
+        const client = bridge.rpc.clients.at(-1);
+        if (!client) {
+            throw new RpcClientError('No RPC client available', 3001, 'No clients connected');
+        }
+        // Pass only testNamePattern to runtime (file filtering already done)
+        const executionOptions = {
+            testNamePattern: options.testNamePattern,
+        };
+        const result = await client.runTests(testFile, executionOptions);
+        context.results = [...(context.results ?? []), ...result.suites];
+        if (config.resetEnvironmentBetweenTestFiles) {
+            shouldRestart = true;
+        }
+        runSpinner.stop(`Test file ${testFile} completed`);
+    }
+    runSpinner.stop('Tests completed');
+};
+const cleanUp = async (context) => {
+    if (context.bridge) {
+        context.bridge.dispose();
+    }
+    if (context.environment) {
+        await context.environment.dispose();
+    }
+};
+const hasFailedTests = (results) => {
+    for (const suite of results) {
+        // Check if the suite itself failed
+        if (suite.status === 'failed') {
+            return true;
+        }
+        // Check individual tests in the suite
+        for (const test of suite.tests) {
+            if (test.status === 'failed') {
+                return true;
+            }
+        }
+        // Recursively check nested suites
+        if (suite.suites && hasFailedTests(suite.suites)) {
+            return true;
+        }
+    }
+    return false;
+};
+export const testCommand = async (runnerName, options = {}) => {
+    intro('React Native Test Harness');
+    const { config, projectRoot } = await getConfig(process.cwd());
+    const selectedRunnerName = runnerName ?? config.defaultRunner;
+    if (!selectedRunnerName) {
+        throw new NoRunnerSpecifiedError(config.runners);
+    }
+    const runner = config.runners.find((r) => r.name === selectedRunnerName);
+    if (!runner) {
+        throw new RunnerNotFoundError(selectedRunnerName, config.runners);
+    }
+    const context = {
+        config,
+        runner,
+        testFiles: [],
+        results: [],
+        projectRoot,
+    };
+    try {
+        await setupEnvironment(context);
+        await findTestFiles(context, options);
+        await runTests(context, options);
+        assert(context.results != null, 'Results not initialized');
+        config.reporter?.report(context.results);
+    }
+    finally {
+        await cleanUp(context);
+    }
+    // Check if any tests failed and exit with appropriate code
+    if (hasFailedTests(context.results)) {
+        outro('Test run completed with failures');
+        process.exit(1);
+    }
+    else {
+        outro('Test run completed successfully');
+    }
+};

package/dist/discovery/index.d.ts

@@ -0,0 +1,3 @@
+export { discoverTestFiles } from './testDiscovery.js';
+export type { TestFilterOptions } from './testDiscovery.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/discovery/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/discovery/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/discovery/index.js

@@ -0,0 +1 @@
+export { discoverTestFiles } from './testDiscovery.js';

package/dist/discovery/testDiscovery.d.ts

@@ -0,0 +1,11 @@
+export type TestFilterOptions = {
+    testNamePattern?: string;
+    testPathPattern?: string;
+    testPathIgnorePatterns?: string[];
+    testMatch?: string[];
+};
+/**
+ * Discovers test files based on patterns and filtering options
+ */
+export declare const discoverTestFiles: (projectRoot: string, configInclude: string | string[], options?: TestFilterOptions) => Promise<string[]>;
+//# sourceMappingURL=testDiscovery.d.ts.map

package/dist/discovery/testDiscovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testDiscovery.d.ts","sourceRoot":"","sources":["../../src/discovery/testDiscovery.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;IAClC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,aAAa,MAAM,EACnB,eAAe,MAAM,GAAG,MAAM,EAAE,EAChC,UAAS,iBAAsB,KAC9B,OAAO,CAAC,MAAM,EAAE,CAiClB,CAAC"}

package/dist/discovery/testDiscovery.js

@@ -0,0 +1,29 @@
+import { Glob } from 'glob';
+/**
+ * Discovers test files based on patterns and filtering options
+ */
+export const discoverTestFiles = async (projectRoot, configInclude, options = {}) => {
+    // Priority: testMatch > configInclude
+    const patterns = options.testMatch || configInclude;
+    const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+    // Glob discovery
+    const allFiles = [];
+    for (const pattern of patternArray) {
+        const glob = new Glob(pattern, { cwd: projectRoot, nodir: true });
+        const files = await glob.walk();
+        allFiles.push(...files);
+    }
+    // Remove duplicates
+    let uniqueFiles = [...new Set(allFiles)];
+    // Apply testPathPattern filtering
+    if (options.testPathPattern) {
+        const regex = new RegExp(options.testPathPattern);
+        uniqueFiles = uniqueFiles.filter((file) => regex.test(file));
+    }
+    // Apply testPathIgnorePatterns filtering
+    if (options.testPathIgnorePatterns?.length) {
+        const ignoreRegexes = options.testPathIgnorePatterns.map((p) => new RegExp(p));
+        uniqueFiles = uniqueFiles.filter((file) => !ignoreRegexes.some((regex) => regex.test(file)));
+    }
+    return uniqueFiles;
+};

package/dist/errors/appNotInstalledError.d.ts

@@ -0,0 +1,7 @@
+export declare class AppNotInstalledError extends Error {
+    readonly deviceName: string;
+    readonly bundleId: string;
+    readonly platform: 'ios' | 'android';
+    constructor(deviceName: string, bundleId: string, platform: 'ios' | 'android');
+}
+//# sourceMappingURL=appNotInstalledError.d.ts.map

package/dist/errors/appNotInstalledError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appNotInstalledError.d.ts","sourceRoot":"","sources":["../../src/errors/appNotInstalledError.ts"],"names":[],"mappings":"AAAA,qBAAa,oBAAqB,SAAQ,KAAK;aAEvB,UAAU,EAAE,MAAM;aAClB,QAAQ,EAAE,MAAM;aAChB,QAAQ,EAAE,KAAK,GAAG,SAAS;gBAF3B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,KAAK,GAAG,SAAS;CAKlD"}

package/dist/errors/appNotInstalledError.js

@@ -0,0 +1,12 @@
+export class AppNotInstalledError extends Error {
+    deviceName;
+    bundleId;
+    platform;
+    constructor(deviceName, bundleId, platform) {
+        super(`App "${bundleId}" is not installed on ${platform === 'ios' ? 'simulator' : 'emulator'} "${deviceName}"`);
+        this.deviceName = deviceName;
+        this.bundleId = bundleId;
+        this.platform = platform;
+        this.name = 'AppNotInstalledError';
+    }
+}

package/dist/errors/bridgeTimeoutError.d.ts

@@ -0,0 +1,7 @@
+export declare class BridgeTimeoutError extends Error {
+    readonly timeout: number;
+    readonly runnerName: string;
+    readonly platform: string;
+    constructor(timeout: number, runnerName: string, platform: string);
+}
+//# sourceMappingURL=bridgeTimeoutError.d.ts.map

package/dist/errors/bridgeTimeoutError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridgeTimeoutError.d.ts","sourceRoot":"","sources":["../../src/errors/bridgeTimeoutError.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAmB,SAAQ,KAAK;aAErB,OAAO,EAAE,MAAM;aACf,UAAU,EAAE,MAAM;aAClB,QAAQ,EAAE,MAAM;gBAFhB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM;CAKvC"}

package/dist/errors/bridgeTimeoutError.js

@@ -0,0 +1,12 @@
+export class BridgeTimeoutError extends Error {
+    timeout;
+    runnerName;
+    platform;
+    constructor(timeout, runnerName, platform) {
+        super(`Bridge connection timed out after ${timeout}ms while waiting for "${runnerName}" (${platform}) runner to be ready`);
+        this.timeout = timeout;
+        this.runnerName = runnerName;
+        this.platform = platform;
+        this.name = 'BridgeTimeoutError';
+    }
+}

package/dist/errors/errorHandler.d.ts

@@ -0,0 +1,2 @@
+export declare const formatError: (error: unknown) => string;
+//# sourceMappingURL=errorHandler.d.ts.map

package/dist/errors/errorHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandler.d.ts","sourceRoot":"","sources":["../../src/errors/errorHandler.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,MAqK5C,CAAC"}