@react-native-harness/jest 1.2.0-rc.1 → 1.3.0

package/dist/client-log-handler.js

@@ -1,41 +1,19 @@
-import chalk from 'chalk';
 import util from 'node:util';
-import { log } from './logs.js';
 /**
- * Gets the display level for a log level.
+ * Gets the Jest console level for a client log level.
  * Note: Metro treats 'trace' as 'log' because Hermes doesn't include stack traces.
  */
-const getDisplayLevel = (level) => {
-    // Metro converts trace to log for display (Hermes doesn't provide stack traces)
-    if (level === 'trace') {
-        return 'LOG';
-    }
-    return level.toUpperCase();
-};
-/**
- * Creates a styled tag for a log level with colored box appearance.
- */
-const createLevelTag = (level) => {
-    const displayLevel = getDisplayLevel(level);
-    const label = ` ${displayLevel} `;
-    if (!chalk.supportsColor) {
-        return `[${displayLevel}]`;
-    }
+const getJestLogLevel = (level) => {
     switch (level) {
-        case 'error':
-            return chalk.reset.inverse.bold.red(label);
-        case 'warn':
-            return chalk.reset.inverse.bold.yellow(label);
-        case 'info':
-            return chalk.reset.inverse.bold.cyan(label);
-        case 'debug':
-            return chalk.reset.inverse.bold.blue(label);
+        case 'group':
+        case 'groupCollapsed':
+        case 'groupEnd':
+            return null;
         case 'trace':
-            // Trace displays as LOG but with a distinct color
-            return chalk.reset.inverse.bold.magenta(label);
+            return 'log';
         case 'log':
         default:
-            return chalk.reset.inverse.bold.white(label);
+            return level;
     }
 };
 /**
@@ -49,36 +27,36 @@ export const formatClientLogMessage = (data) => {
     return util.format(...data);
 };
 /**
- * Formats a client log event into a log line with styled level prefix.
- */
-export const formatClientLogLine = (event) => {
-    const tag = createLevelTag(event.level);
-    const message = formatClientLogMessage(event.data);
-    return `${tag} ${message}`;
-};
-/**
- * Handles a client_log event by formatting and logging it.
- * Returns true if the event was handled, false otherwise.
+ * Formats a client log event into Jest's buffered console entry format.
  */
-export const handleClientLogEvent = (event) => {
-    if (event.type !== 'client_log') {
-        return false;
+export const formatClientLogEntry = (event) => {
+    const logLevel = getJestLogLevel(event.level);
+    if (!logLevel) {
+        return null;
     }
-    // Skip group events - they don't produce output
-    if (event.level === 'group' ||
-        event.level === 'groupCollapsed' ||
-        event.level === 'groupEnd') {
-        return true;
-    }
-    const logLine = formatClientLogLine(event);
-    log(logLine);
-    return true;
+    const message = formatClientLogMessage(event.data);
+    return {
+        message,
+        origin: '',
+        type: logLevel,
+    };
 };
-/**
- * Creates a client log event listener that can be added to the Metro reporter.
- */
-export const createClientLogListener = () => {
-    return (event) => {
-        handleClientLogEvent(event);
+export const createClientLogCollector = () => {
+    let buffer = [];
+    return {
+        handleEvent: (event) => {
+            if (event.type !== 'client_log') {
+                return;
+            }
+            const entry = formatClientLogEntry(event);
+            if (entry) {
+                buffer.push(entry);
+            }
+        },
+        flush: () => {
+            const flushed = buffer;
+            buffer = [];
+            return flushed;
+        },
     };
 };

package/dist/crash-monitor.d.ts

@@ -1,16 +1,23 @@
-import { HarnessPlatformRunner } from '@react-native-harness/platforms';
-import { BridgeServer } from '@react-native-harness/bridge/server';
+import { type AppMonitor, type HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { type NativeCrashPhase } from './errors.js';
+export declare class CrashWatchCancelledError extends Error {
+    constructor();
+}
+export type CrashWatch = {
+    readonly promise: Promise<never>;
+    cancel: () => void;
+};
 export type CrashMonitor = {
-    startMonitoring(testFilePath: string): Promise<never>;
-    stopMonitoring(): void;
-    markIntentionalRestart(): void;
-    clearIntentionalRestart(): void;
-    dispose(): void;
+    watch: (testFilePath: string, phase: NativeCrashPhase) => CrashWatch;
+    isAlive: () => boolean;
+    stop: () => Promise<void>;
+    start: () => Promise<void>;
+    reset: () => void;
+    dispose: () => Promise<void>;
 };
 export type CrashMonitorOptions = {
-    interval: number;
+    appMonitor: AppMonitor;
     platformRunner: HarnessPlatformRunner;
-    bridgeServer: BridgeServer;
 };
-export declare const createCrashMonitor: ({ interval, platformRunner, bridgeServer, }: CrashMonitorOptions) => CrashMonitor;
+export declare const createCrashMonitor: ({ appMonitor, platformRunner, }: CrashMonitorOptions) => CrashMonitor;
 //# sourceMappingURL=crash-monitor.d.ts.map

package/dist/crash-monitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crash-monitor.d.ts","sourceRoot":"","sources":["../src/crash-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAInE,MAAM,MAAM,YAAY,GAAG;IACzB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACtD,cAAc,IAAI,IAAI,CAAC;IACvB,sBAAsB,IAAI,IAAI,CAAC;IAC/B,uBAAuB,IAAI,IAAI,CAAC;IAChC,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,qBAAqB,CAAC;IACtC,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,6CAIhC,mBAAmB,KAAG,YAqFxB,CAAC"}
+{"version":3,"file":"crash-monitor.d.ts","sourceRoot":"","sources":["../src/crash-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAIf,KAAK,qBAAqB,EAC3B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,aAAa,CAAC;AAKrB,qBAAa,wBAAyB,SAAQ,KAAK;;CAKlD;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACjC,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,KAAK,UAAU,CAAC;IACrE,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,qBAAqB,CAAC;CACvC,CAAC;AA6BF,eAAO,MAAM,kBAAkB,GAAI,iCAGhC,mBAAmB,KAAG,YA+KxB,CAAC"}

package/dist/crash-monitor.js

@@ -1,75 +1,176 @@
-import { NativeCrashError } from './errors.js';
+import { NativeCrashError, } from './errors.js';
 import { logger } from '@react-native-harness/tools';
-export const createCrashMonitor = ({ interval, platformRunner, bridgeServer, }) => {
-    let pollingInterval = null;
-    let isIntentionalRestart = false;
-    let currentTestFilePath = null;
-    let rejectFn = null;
-    const handleDisconnect = () => {
-        // Verify if it's actually a crash by checking if app is still running
-        if (!isIntentionalRestart && currentTestFilePath) {
-            // Capture the value to avoid it being null when setTimeout callback runs
-            const testFilePath = currentTestFilePath;
-            logger.debug('Bridge disconnected, checking if app crashed');
-            // Use a slight delay to allow the OS to clean up the process
-            setTimeout(async () => {
-                const isRunning = await platformRunner.isAppRunning();
-                if (!isRunning && !isIntentionalRestart && rejectFn) {
-                    logger.debug(`Native crash detected during: ${testFilePath}`);
-                    rejectFn(new NativeCrashError(testFilePath));
-                }
-            }, 100);
+const crashLogger = logger.child('crash');
+export class CrashWatchCancelledError extends Error {
+    constructor() {
+        super('Crash watch was cancelled');
+        this.name = 'CrashWatchCancelledError';
+    }
+}
+const mergeCrashDetails = (phase, initial, enriched, fallbackSummary) => ({
+    phase,
+    source: enriched?.source ?? initial?.source,
+    summary: enriched?.summary ?? initial?.summary ?? fallbackSummary,
+    signal: enriched?.signal ?? initial?.signal,
+    exceptionType: enriched?.exceptionType ?? initial?.exceptionType,
+    processName: enriched?.processName ?? initial?.processName,
+    pid: enriched?.pid ?? initial?.pid,
+    stackTrace: enriched?.stackTrace ?? initial?.stackTrace,
+    rawLines: enriched?.rawLines ?? initial?.rawLines,
+    artifactType: enriched?.artifactType ?? initial?.artifactType,
+    artifactPath: enriched?.artifactPath ?? initial?.artifactPath,
+});
+export const createCrashMonitor = ({ appMonitor, platformRunner, }) => {
+    let alive = false;
+    let monitoring = true;
+    let isResolvingCrash = false;
+    let disposed = false;
+    // Both updated when watch() is called so crashes are attributed to the
+    // correct test file and lifecycle phase.
+    let currentTestFilePath = '';
+    let currentPhase = 'startup';
+    const watchers = new Set();
+    const getCrashDetailsProvider = () => {
+        if ('getCrashDetails' in appMonitor) {
+            return appMonitor;
         }
+        if (platformRunner.getCrashDetails) {
+            return platformRunner;
+        }
+        return null;
     };
-    const startMonitoring = (testFilePath) => {
-        currentTestFilePath = testFilePath;
-        return new Promise((_, reject) => {
-            rejectFn = reject;
-            // Listen for bridge disconnect as early indicator
-            bridgeServer.on('disconnect', handleDisconnect);
-            // Poll for app running status
-            pollingInterval = setInterval(async () => {
-                // Skip check during intentional restarts
-                if (isIntentionalRestart) {
-                    return;
-                }
-                try {
-                    const isRunning = await platformRunner.isAppRunning();
-                    if (!isRunning && currentTestFilePath) {
-                        logger.debug(`Native crash detected during: ${currentTestFilePath}`);
-                        stopMonitoring();
-                        reject(new NativeCrashError(currentTestFilePath));
-                    }
-                }
-                catch (error) {
-                    logger.error('Error checking app status:', error);
-                }
-            }, interval);
-        });
+    const notifyCrash = (err) => {
+        const pending = [...watchers];
+        watchers.clear();
+        for (const fn of pending)
+            fn(err);
     };
-    const stopMonitoring = () => {
-        if (pollingInterval) {
-            clearInterval(pollingInterval);
-            pollingInterval = null;
+    const handleCrash = async (phase, details, fallbackSummary) => {
+        if (isResolvingCrash)
+            return;
+        isResolvingCrash = true;
+        alive = false;
+        crashLogger.debug('native crash detected (phase=%s)', phase);
+        for (const line of details?.rawLines ?? []) {
+            crashLogger.debug('%s', line);
+        }
+        try {
+            const enriched = await getCrashDetailsProvider()?.getCrashDetails?.({
+                processName: details?.processName,
+                pid: details?.pid,
+                occurredAt: Date.now(),
+            });
+            const merged = mergeCrashDetails(phase, details, enriched, fallbackSummary);
+            crashLogger.debug('crash details: %o', {
+                phase: merged.phase,
+                source: merged.source,
+                summary: merged.summary,
+                signal: merged.signal,
+                exceptionType: merged.exceptionType,
+                processName: merged.processName,
+                pid: merged.pid,
+            });
+            notifyCrash(new NativeCrashError(currentTestFilePath, merged));
+        }
+        finally {
+            isResolvingCrash = false;
         }
-        bridgeServer.off('disconnect', handleDisconnect);
-        currentTestFilePath = null;
-        rejectFn = null;
     };
-    const markIntentionalRestart = () => {
-        isIntentionalRestart = true;
+    const confirmAndHandleCrash = async (phase, details, fallbackSummary) => {
+        if (disposed || !monitoring)
+            return;
+        try {
+            const isRunning = await platformRunner.isAppRunning();
+            if (!isRunning) {
+                void handleCrash(phase, details, fallbackSummary);
+            }
+        }
+        catch (error) {
+            crashLogger.debug('crash confirmation failed', error);
+        }
     };
-    const clearIntentionalRestart = () => {
-        isIntentionalRestart = false;
+    const extractCrashDetails = (event) => event.crashDetails
+        ? {
+            source: event.crashDetails.source ?? event.source,
+            summary: event.crashDetails.summary,
+            signal: event.crashDetails.signal,
+            exceptionType: event.crashDetails.exceptionType,
+            processName: event.crashDetails.processName,
+            pid: event.crashDetails.pid ?? event.pid,
+            stackTrace: event.crashDetails.stackTrace,
+            rawLines: event.crashDetails.rawLines ??
+                (event.line ? [event.line] : undefined),
+        }
+        : undefined;
+    const appMonitorListener = (event) => {
+        if (disposed || !monitoring)
+            return;
+        if (event.type === 'app_started') {
+            alive = true;
+            return;
+        }
+        if (event.type === 'app_exited') {
+            const details = extractCrashDetails(event);
+            if (event.isConfirmed ?? event.source === 'polling') {
+                void handleCrash(currentPhase, details);
+            }
+            else {
+                void confirmAndHandleCrash(currentPhase, details);
+            }
+            return;
+        }
+        if (event.type === 'possible_crash') {
+            const details = extractCrashDetails(event);
+            const fallback = `possible crash signal (${event.source ?? 'unknown'})`;
+            if (event.isConfirmed) {
+                void handleCrash(currentPhase, details, fallback);
+            }
+            else {
+                void confirmAndHandleCrash(currentPhase, details, fallback);
+            }
+        }
     };
-    const dispose = () => {
-        stopMonitoring();
+    appMonitor.addListener(appMonitorListener);
+    const watch = (testFilePath, phase) => {
+        currentTestFilePath = testFilePath;
+        currentPhase = phase;
+        let rejectFn;
+        const promise = new Promise((_, reject) => {
+            rejectFn = (err) => {
+                watchers.delete(rejectFn);
+                reject(err);
+            };
+            watchers.add(rejectFn);
+        });
+        const cancel = () => {
+            rejectFn(new CrashWatchCancelledError());
+        };
+        return { promise, cancel };
     };
     return {
-        startMonitoring,
-        stopMonitoring,
-        markIntentionalRestart,
-        clearIntentionalRestart,
-        dispose,
+        watch,
+        isAlive: () => alive,
+        stop: async () => {
+            monitoring = false;
+            await appMonitor.stop();
+        },
+        start: async () => {
+            monitoring = true;
+            await appMonitor.start();
+        },
+        reset: () => {
+            alive = false;
+            watchers.clear();
+            isResolvingCrash = false;
+            currentTestFilePath = '';
+        },
+        dispose: async () => {
+            disposed = true;
+            monitoring = false;
+            watchers.clear();
+            isResolvingCrash = false;
+            appMonitor.removeListener(appMonitorListener);
+            await appMonitor.dispose();
+        },
     };
 };

package/dist/execute-run.d.ts

@@ -0,0 +1,4 @@
+import type { OnTestFailure, OnTestStart, OnTestSuccess, Test, TestWatcher, Config } from 'jest-runner';
+import { type HarnessSession } from './harness-session.js';
+export declare const executeRun: (session: HarnessSession, tests: Array<Test>, watcher: TestWatcher, onStart: OnTestStart, onResult: OnTestSuccess, onFailure: OnTestFailure, globalConfig: Config.GlobalConfig) => Promise<void>;
+//# sourceMappingURL=execute-run.d.ts.map

package/dist/execute-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-run.d.ts","sourceRoot":"","sources":["../src/execute-run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,aAAa,EACb,IAAI,EACJ,WAAW,EACX,MAAM,EACP,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,sBAAsB,CAAC;AAsCjF,eAAO,MAAM,UAAU,GACrB,SAAS,cAAc,EACvB,OAAO,KAAK,CAAC,IAAI,CAAC,EAClB,SAAS,WAAW,EACpB,SAAS,WAAW,EACpB,UAAU,aAAa,EACvB,WAAW,aAAa,EACxB,cAAc,MAAM,CAAC,YAAY,KAChC,OAAO,CAAC,IAAI,CA8Id,CAAC"}

package/dist/execute-run.js

@@ -0,0 +1,151 @@
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { runHarnessTestFile } from './run.js';
+import { NativeCrashError, StartupStallError, } from './errors.js';
+import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
+const createRunSummary = () => ({ passed: 0, failed: 0, skipped: 0, todo: 0 });
+const applyJestResultToSummary = (summary, result) => {
+    summary.passed += result.numPassingTests;
+    summary.failed += result.numFailingTests;
+    summary.skipped += result.numPendingTests;
+    summary.todo += result.numTodoTests;
+};
+class CancelRun extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelRun';
+    }
+}
+const buildTestFailure = (err) => {
+    if (err instanceof NativeCrashError ||
+        err instanceof StartupStallError ||
+        err instanceof DeviceNotRespondingError) {
+        return { message: err.message, stack: '' };
+    }
+    return err;
+};
+export const executeRun = async (session, tests, watcher, onStart, onResult, onFailure, globalConfig) => {
+    const runId = randomUUID();
+    const startTime = Date.now();
+    const watchMode = globalConfig.watch || globalConfig.watchAll;
+    const rootDir = globalConfig.rootDir ?? process.cwd();
+    const testFiles = tests.map((t) => path.relative(rootDir, t.path));
+    const summary = createRunSummary();
+    const updateRunState = (overrides = {}) => {
+        const state = {
+            runId,
+            startTime,
+            testFiles,
+            watchMode,
+            coverageEnabled: globalConfig.collectCoverage,
+            summary,
+            status: summary.failed > 0 ? 'failed' : 'passed',
+            ...overrides,
+        };
+        session.setRunState(state);
+        return state;
+    };
+    updateRunState();
+    await session.callHook('run:started', {
+        runId,
+        startTime,
+        testFiles,
+        watchMode,
+        coverageEnabled: globalConfig.collectCoverage,
+    });
+    await session.callHook('metro:initialized', {
+        runId,
+        port: session.config.metroPort,
+        host: session.config.host?.trim() || undefined,
+    });
+    const shouldResetEnv = session.config.resetEnvironmentBetweenTestFiles;
+    let isFirstTest = true;
+    let runError;
+    try {
+        for (const test of tests) {
+            if (watcher.isInterrupted())
+                throw new CancelRun();
+            const relativeTestPath = path.relative(rootDir, test.path);
+            const fileStartedAt = Date.now();
+            let emittedTestFileFinished = false;
+            const emitTestFileFinished = async (options) => {
+                emittedTestFileFinished = true;
+                await session.callHook('test-file:finished', {
+                    runId,
+                    file: relativeTestPath,
+                    duration: options.duration,
+                    status: options.status,
+                    result: options.result,
+                });
+            };
+            await session.callHook('test-file:started', { runId, file: relativeTestPath });
+            try {
+                if (shouldResetEnv && !isFirstTest) {
+                    await session.restartApp(test.path);
+                }
+                isFirstTest = false;
+                session.flushClientLogs();
+                await onStart(test);
+                await session.ensureAppReady(test.path);
+                // Crash detection is handled inside session.runTestFile; NativeCrashError
+                // propagates here if a crash wins the race.
+                const result = await runHarnessTestFile({
+                    testPath: test.path,
+                    session,
+                    globalConfig,
+                    projectConfig: test.context.config,
+                });
+                applyJestResultToSummary(summary, result.jestResult);
+                const clientLogs = session.flushClientLogs();
+                if (clientLogs.length > 0) {
+                    result.jestResult.console = clientLogs;
+                }
+                updateRunState();
+                await emitTestFileFinished({
+                    status: result.harnessResult.status,
+                    duration: result.duration,
+                    result: result.harnessResult,
+                });
+                await onResult(test, result.jestResult);
+            }
+            catch (err) {
+                if (!emittedTestFileFinished) {
+                    await emitTestFileFinished({
+                        status: 'failed',
+                        duration: Date.now() - fileStartedAt,
+                        result: null,
+                    });
+                }
+                const isRuntimeFailure = err instanceof NativeCrashError ||
+                    err instanceof StartupStallError ||
+                    err instanceof DeviceNotRespondingError;
+                if (isRuntimeFailure) {
+                    summary.failed += 1;
+                    updateRunState();
+                }
+                if (err instanceof NativeCrashError) {
+                    session.resetCrashState();
+                }
+                updateRunState({ error: isRuntimeFailure ? undefined : err });
+                onFailure(test, buildTestFailure(err));
+            }
+        }
+    }
+    catch (err) {
+        runError = err;
+        if (!(err instanceof CancelRun))
+            throw err;
+    }
+    finally {
+        const runState = updateRunState(runError != null ? { error: runError, status: 'failed' } : {});
+        await session.callHook('run:finished', {
+            runId,
+            startTime,
+            duration: Date.now() - startTime,
+            testFiles,
+            summary,
+            status: runState.status ?? (runError != null ? 'failed' : 'passed'),
+            ...(runError != null ? { error: runError } : {}),
+        });
+    }
+};

package/dist/harness-session.d.ts

@@ -0,0 +1,34 @@
+import { type HarnessContext, type TestExecutionOptions, type TestSuiteResult } from '@react-native-harness/bridge';
+import { type HarnessPlatform } from '@react-native-harness/platforms';
+import { type HarnessPluginManager, type HarnessRunStatus, type HarnessRunSummary } from '@react-native-harness/plugins';
+import { type Config as HarnessConfig } from '@react-native-harness/config';
+import type { Config as JestConfig } from 'jest-runner';
+import { type ClientLogBuffer } from './client-log-handler.js';
+import { type ResourceLockManager } from './resource-lock.js';
+export type HarnessRunState = {
+    readonly runId: string;
+    readonly startTime: number;
+    readonly testFiles: string[];
+    readonly watchMode: boolean;
+    readonly coverageEnabled: boolean;
+    readonly summary?: HarnessRunSummary;
+    readonly status?: HarnessRunStatus;
+    readonly error?: unknown;
+};
+export type HarnessRunTestsOptions = Exclude<TestExecutionOptions, 'platform'>;
+export type HarnessSession = {
+    readonly config: HarnessConfig;
+    readonly context: HarnessContext;
+    runTestFile: (path: string, options: HarnessRunTestsOptions) => Promise<TestSuiteResult>;
+    ensureAppReady: (testFilePath: string) => Promise<void>;
+    restartApp: (testFilePath?: string) => Promise<void>;
+    resetCrashState: () => void;
+    flushClientLogs: () => ClientLogBuffer;
+    callHook: HarnessPluginManager<HarnessConfig, HarnessPlatform>['callHook'];
+    setRunState: (state: HarnessRunState | null) => void;
+    dispose: (reason?: 'normal' | 'abort' | 'error') => Promise<void>;
+};
+export declare const createHarnessSession: (globalConfig: JestConfig.GlobalConfig, { lockManager }?: {
+    lockManager?: ResourceLockManager;
+}) => Promise<HarnessSession>;
+//# sourceMappingURL=harness-session.d.ts.map

package/dist/harness-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness-session.d.ts","sourceRoot":"","sources":["../src/harness-session.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,cAAc,EAEnB,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACrB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAEL,KAAK,eAAe,EAGrB,MAAM,iCAAiC,CAAC;AASzC,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAOvC,OAAO,EAEL,KAAK,MAAM,IAAI,aAAa,EAE7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAMxD,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAEL,KAAK,mBAAmB,EAEzB,MAAM,oBAAoB,CAAC;AAkB5B,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,oBAAoB,EAAE,UAAU,CAAC,CAAC;AAE/E,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IACzF,cAAc,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,UAAU,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,eAAe,EAAE,MAAM,eAAe,CAAC;IACvC,QAAQ,EAAE,oBAAoB,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC,UAAU,CAAC,CAAC;IAC3E,WAAW,EAAE,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,KAAK,IAAI,CAAC;IACrD,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE,CAAC;AAuOF,eAAO,MAAM,oBAAoB,GAC/B,cAAc,UAAU,CAAC,YAAY,EACrC,kBAA8C;IAAE,WAAW,CAAC,EAAE,mBAAmB,CAAA;CAAO,KACvF,OAAO,CAAC,cAAc,CA6YxB,CAAC"}