@cucumber/cucumber 12.9.0 → 13.0.0

package/lib/runtime/make_suggestion.js

@@ -28,4 +28,4 @@ function makeSuggestion({ newId, snippetBuilder, pickleStep, }) {
         snippets,
     };
 }
-//# sourceMappingURL=make_suggestion.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFrZV9zdWdnZXN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3J1bnRpbWUvbWFrZV9zdWdnZXN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBc0JBLHdDQXFCQztBQTNDRCxpREFLMkI7QUFDM0Isa0RBQWtEO0FBR2xELFNBQVMsOEJBQThCLENBQUMsSUFBcUI7SUFDM0QsUUFBUSxJQUFJLEVBQUUsQ0FBQztRQUNiLEtBQUsseUJBQWMsQ0FBQyxPQUFPO1lBQ3pCLE9BQU8scUJBQVcsQ0FBQyxZQUFZLENBQUE7UUFDakMsS0FBSyx5QkFBYyxDQUFDLE1BQU07WUFDeEIsT0FBTyxxQkFBVyxDQUFDLEtBQUssQ0FBQTtRQUMxQixLQUFLLHlCQUFjLENBQUMsT0FBTztZQUN6QixPQUFPLHFCQUFXLENBQUMsT0FBTyxDQUFBO1FBQzVCO1lBQ0UsT0FBTyxxQkFBVyxDQUFDLFlBQVksQ0FBQTtJQUNuQyxDQUFDO0FBQ0gsQ0FBQztBQUVELFNBQWdCLGNBQWMsQ0FBQyxFQUM3QixLQUFLLEVBQ0wsY0FBYyxFQUNkLFVBQVUsR0FLWDtJQUNDLE1BQU0sV0FBVyxHQUFHLDhCQUE4QixDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQTtJQUNuRSxNQUFNLEtBQUssR0FBRyxjQUFjLENBQUMsYUFBYSxDQUFDLEVBQUUsV0FBVyxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUE7SUFDdkUsTUFBTSxRQUFRLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQztRQUNwQyxJQUFJO1FBQ0osUUFBUSxFQUFFLFlBQVk7S0FDdkIsQ0FBQyxDQUFDLENBQUE7SUFFSCxPQUFPO1FBQ0wsRUFBRSxFQUFFLEtBQUssRUFBRTtRQUNYLFlBQVksRUFBRSxVQUFVLENBQUMsRUFBRTtRQUMzQixRQUFRO0tBQ1QsQ0FBQTtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICB0eXBlIElkR2VuZXJhdG9yLFxuICB0eXBlIFBpY2tsZVN0ZXAsXG4gIFBpY2tsZVN0ZXBUeXBlLFxuICB0eXBlIFN1Z2dlc3Rpb24sXG59IGZyb20gJ0BjdWN1bWJlci9tZXNzYWdlcydcbmltcG9ydCB7IEtleXdvcmRUeXBlIH0gZnJvbSAnLi4vZm9ybWF0dGVyL2hlbHBlcnMnXG5pbXBvcnQgdHlwZSBTdGVwRGVmaW5pdGlvblNuaXBwZXRCdWlsZGVyIGZyb20gJy4uL2Zvcm1hdHRlci9zdGVwX2RlZmluaXRpb25fc25pcHBldF9idWlsZGVyJ1xuXG5mdW5jdGlvbiBtYXBQaWNrbGVTdGVwVHlwZVRvS2V5d29yZFR5cGUodHlwZT86IFBpY2tsZVN0ZXBUeXBlKTogS2V5d29yZFR5cGUge1xuICBzd2l0Y2ggKHR5cGUpIHtcbiAgICBjYXNlIFBpY2tsZVN0ZXBUeXBlLkNPTlRFWFQ6XG4gICAgICByZXR1cm4gS2V5d29yZFR5cGUuUHJlY29uZGl0aW9uXG4gICAgY2FzZSBQaWNrbGVTdGVwVHlwZS5BQ1RJT046XG4gICAgICByZXR1cm4gS2V5d29yZFR5cGUuRXZlbnRcbiAgICBjYXNlIFBpY2tsZVN0ZXBUeXBlLk9VVENPTUU6XG4gICAgICByZXR1cm4gS2V5d29yZFR5cGUuT3V0Y29tZVxuICAgIGRlZmF1bHQ6XG4gICAgICByZXR1cm4gS2V5d29yZFR5cGUuUHJlY29uZGl0aW9uXG4gIH1cbn1cblxuZXhwb3J0IGZ1bmN0aW9uIG1ha2VTdWdnZXN0aW9uKHtcbiAgbmV3SWQsXG4gIHNuaXBwZXRCdWlsZGVyLFxuICBwaWNrbGVTdGVwLFxufToge1xuICBuZXdJZDogSWRHZW5lcmF0b3IuTmV3SWRcbiAgc25pcHBldEJ1aWxkZXI6IFN0ZXBEZWZpbml0aW9uU25pcHBldEJ1aWxkZXJcbiAgcGlja2xlU3RlcDogUGlja2xlU3RlcFxufSk6IFN1Z2dlc3Rpb24ge1xuICBjb25zdCBrZXl3b3JkVHlwZSA9IG1hcFBpY2tsZVN0ZXBUeXBlVG9LZXl3b3JkVHlwZShwaWNrbGVTdGVwLnR5cGUpXG4gIGNvbnN0IGNvZGVzID0gc25pcHBldEJ1aWxkZXIuYnVpbGRNdWx0aXBsZSh7IGtleXdvcmRUeXBlLCBwaWNrbGVTdGVwIH0pXG4gIGNvbnN0IHNuaXBwZXRzID0gY29kZXMubWFwKChjb2RlKSA9PiAoe1xuICAgIGNvZGUsXG4gICAgbGFuZ3VhZ2U6ICdqYXZhc2NyaXB0JyxcbiAgfSkpXG5cbiAgcmV0dXJuIHtcbiAgICBpZDogbmV3SWQoKSxcbiAgICBwaWNrbGVTdGVwSWQ6IHBpY2tsZVN0ZXAuaWQsXG4gICAgc25pcHBldHMsXG4gIH1cbn1cbiJdfQ==

package/lib/runtime/parallel/adapter.d.ts

@@ -1,28 +1,18 @@
-import { ChildProcess } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import { SupportCodeLibrary } from '../../support_code_library_builder/types';
-import { AssembledTestCase } from '../../assemble';
-import { ILogger, IRunEnvironment } from '../../environment';
-import { RuntimeAdapter } from '../types';
-import { IRunOptionsRuntime } from '../../api';
-import { FormatOptions } from '../../formatter';
-import { WorkerToCoordinatorEvent } from './types';
-declare const enum WorkerState {
-    'idle' = 0,
-    'closed' = 1,
-    'running' = 2,
-    'new' = 3
-}
-interface ManagedWorker {
-    state: WorkerState;
-    process: ChildProcess;
-    id: string;
-}
-interface WorkPlacement {
-    index: number;
-    item: AssembledTestCase;
-}
-export declare class ChildProcessAdapter implements RuntimeAdapter {
+import type { EventEmitter } from 'node:events';
+import type { IRunOptionsRuntime } from '../../api';
+import type { AssembledTestCase } from '../../assemble';
+import type { ILogger, IRunEnvironment } from '../../environment';
+import type { FormatOptions } from '../../formatter';
+import type { SupportCodeLibrary } from '../../support_code_library_builder/types';
+import type { RuntimeAdapter } from '../types';
+/**
+ * An adapter that distributes work across multiple worker threads
+ * @remarks
+ * Each phase of the test run is self-contained and self-orchestrating - every
+ * FINISHED message from a worker may cause the next piece of work to be
+ * triggered or the phase to be settled.
+ */
+export declare class WorkerThreadsAdapter implements RuntimeAdapter {
     private readonly testRunStartedId;
     private readonly environment;
     private readonly logger;
@@ -30,20 +20,18 @@ export declare class ChildProcessAdapter implements RuntimeAdapter {
     private readonly options;
     private readonly snippetOptions;
     private readonly supportCodeLibrary;
-    private idleInterventions;
-    private failing;
-    private onFinish;
-    private todo;
-    private readonly inProgress;
+    private readiness;
+    private phase;
     private readonly workers;
+    private readonly running;
     constructor(testRunStartedId: string, environment: IRunEnvironment, logger: ILogger, eventBroadcaster: EventEmitter, options: IRunOptionsRuntime, snippetOptions: Pick<FormatOptions, 'snippetInterface' | 'snippetSyntax'>, supportCodeLibrary: SupportCodeLibrary);
-    parseWorkerMessage(worker: ManagedWorker, message: WorkerToCoordinatorEvent): void;
-    awakenWorkers(triggeringWorker: ManagedWorker): void;
-    startWorker(id: string, total: number): void;
-    onWorkerProcessClose(exitCode: number): void;
-    run(assembledTestCases: ReadonlyArray<AssembledTestCase>): Promise<boolean>;
-    nextWorkPlacement(): WorkPlacement;
-    placementAt(index: number): WorkPlacement;
-    giveWork(worker: ManagedWorker, force?: boolean): void;
+    setup(): Promise<void>;
+    runBeforeAllHooks(): Promise<boolean>;
+    runTestCases(assembledTestCases: ReadonlyArray<AssembledTestCase>): Promise<boolean>;
+    runAfterAllHooks(): Promise<boolean>;
+    teardown(): Promise<void>;
+    private startPhase;
+    private issueCommandToWorker;
+    private handleEventFromWorker;
+    private handleErrorFromWorker;
 }
-export {};

package/lib/runtime/parallel/adapter.js

@@ -3,11 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChildProcessAdapter = void 0;
-const node_child_process_1 = require("node:child_process");
+exports.WorkerThreadsAdapter = void 0;
 const node_path_1 = __importDefault(require("node:path"));
-const runWorkerPath = node_path_1.default.resolve(__dirname, 'run_worker.js');
-class ChildProcessAdapter {
+const node_worker_threads_1 = require("node:worker_threads");
+const test_cases_phase_1 = require("./test_cases_phase");
+const test_run_hooks_phase_1 = require("./test_run_hooks_phase");
+/**
+ * An adapter that distributes work across multiple worker threads
+ * @remarks
+ * Each phase of the test run is self-contained and self-orchestrating - every
+ * FINISHED message from a worker may cause the next piece of work to be
+ * triggered or the phase to be settled.
+ */
+class WorkerThreadsAdapter {
     testRunStartedId;
     environment;
     logger;
@@ -15,12 +23,10 @@ class ChildProcessAdapter {
     options;
     snippetOptions;
     supportCodeLibrary;
-    idleInterventions = 0;
-    failing = false;
-    onFinish;
-    todo = [];
-    inProgress = {};
-    workers = {};
+    readiness;
+    phase;
+    workers = new Set();
+    running = new Map();
     constructor(testRunStartedId, environment, logger, eventBroadcaster, options, snippetOptions, supportCodeLibrary) {
         this.testRunStartedId = testRunStartedId;
         this.environment = environment;
@@ -30,131 +36,127 @@ class ChildProcessAdapter {
         this.snippetOptions = snippetOptions;
         this.supportCodeLibrary = supportCodeLibrary;
     }
-    parseWorkerMessage(worker, message) {
-        switch (message.type) {
-            case 'READY':
-                worker.state = 0 /* WorkerState.idle */;
-                this.awakenWorkers(worker);
-                break;
-            case 'ENVELOPE':
-                this.eventBroadcaster.emit('envelope', message.envelope);
-                break;
-            case 'FINISHED':
-                if (!message.success) {
-                    this.failing = true;
-                }
-                delete this.inProgress[worker.id];
-                worker.state = 0 /* WorkerState.idle */;
-                this.awakenWorkers(worker);
-                break;
-            default:
-                throw new Error(`Unexpected message from worker: ${JSON.stringify(message)}`);
-        }
-    }
-    awakenWorkers(triggeringWorker) {
-        Object.values(this.workers).forEach((worker) => {
-            if (worker.state === 0 /* WorkerState.idle */) {
-                this.giveWork(worker);
+    async setup() {
+        await new Promise((resolve, reject) => {
+            this.readiness = { resolve, reject };
+            const total = this.options.parallel;
+            for (let i = 0; i < total; i++) {
+                const id = i.toString();
+                // spin up a dedicated message channel for coordinator-worker comms
+                const { port1, port2 } = new node_worker_threads_1.MessageChannel();
+                const workerThread = new node_worker_threads_1.Worker(node_path_1.default.resolve(__dirname, 'worker.mjs'), {
+                    env: {
+                        ...this.environment.env,
+                        CUCUMBER_PARALLEL: 'true',
+                        CUCUMBER_TOTAL_WORKERS: total.toString(),
+                        CUCUMBER_WORKER_ID: id,
+                    },
+                    resourceLimits: this.options.workerOptions?.resourceLimits,
+                    workerData: {
+                        cwd: this.environment.cwd,
+                        testRunStartedId: this.testRunStartedId,
+                        supportCodeCoordinates: this.supportCodeLibrary.originalCoordinates,
+                        supportCodeIds: {
+                            stepDefinitionIds: this.supportCodeLibrary.stepDefinitions.map((s) => s.id),
+                            beforeTestCaseHookDefinitionIds: this.supportCodeLibrary.beforeTestCaseHookDefinitions.map((h) => h.id),
+                            afterTestCaseHookDefinitionIds: this.supportCodeLibrary.afterTestCaseHookDefinitions.map((h) => h.id),
+                            beforeTestRunHookDefinitionIds: this.supportCodeLibrary.beforeTestRunHookDefinitions.map((h) => h.id),
+                            afterTestRunHookDefinitionIds: this.supportCodeLibrary.afterTestRunHookDefinitions.map((h) => h.id),
+                        },
+                        options: this.options,
+                        snippetOptions: this.snippetOptions,
+                        port: port2,
+                    },
+                    transferList: [port2],
+                });
+                const worker = {
+                    id,
+                    workerThread,
+                    port: port1,
+                    ready: false,
+                };
+                this.workers.add(worker);
+                port1.on('message', (event) => {
+                    this.handleEventFromWorker(worker, event);
+                });
+                workerThread.on('error', (error) => {
+                    this.handleErrorFromWorker(error, worker);
+                });
             }
-            return worker.state !== 0 /* WorkerState.idle */;
         });
-        if (Object.keys(this.inProgress).length == 0 && this.todo.length > 0) {
-            this.giveWork(triggeringWorker, true);
-            this.idleInterventions++;
-        }
+        delete this.readiness;
     }
-    startWorker(id, total) {
-        const workerProcess = (0, node_child_process_1.fork)(runWorkerPath, [], {
-            cwd: this.environment.cwd,
-            env: {
-                ...this.environment.env,
-                CUCUMBER_PARALLEL: 'true',
-                CUCUMBER_TOTAL_WORKERS: total.toString(),
-                CUCUMBER_WORKER_ID: id,
-            },
-            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+    async runBeforeAllHooks() {
+        const success = await new Promise((resolve, reject) => {
+            this.phase = new test_run_hooks_phase_1.TestRunHooksPhase(resolve, reject, 'BEFOREALL_HOOKS');
+            this.startPhase();
         });
-        const worker = { state: 3 /* WorkerState.new */, process: workerProcess, id };
-        this.workers[id] = worker;
-        worker.process.on('message', (message) => {
-            this.parseWorkerMessage(worker, message);
-        });
-        worker.process.on('close', (exitCode) => {
-            worker.state = 1 /* WorkerState.closed */;
-            this.onWorkerProcessClose(exitCode);
+        delete this.phase;
+        return success;
+    }
+    async runTestCases(assembledTestCases) {
+        const success = await new Promise((resolve, reject) => {
+            this.phase = new test_cases_phase_1.TestCasesPhase(resolve, reject, this.logger, this.supportCodeLibrary.parallelCanAssign, assembledTestCases);
+            this.startPhase();
         });
-        worker.process.send({
-            type: 'INITIALIZE',
-            testRunStartedId: this.testRunStartedId,
-            supportCodeCoordinates: this.supportCodeLibrary.originalCoordinates,
-            supportCodeIds: {
-                stepDefinitionIds: this.supportCodeLibrary.stepDefinitions.map((s) => s.id),
-                beforeTestCaseHookDefinitionIds: this.supportCodeLibrary.beforeTestCaseHookDefinitions.map((h) => h.id),
-                afterTestCaseHookDefinitionIds: this.supportCodeLibrary.afterTestCaseHookDefinitions.map((h) => h.id),
-                beforeTestRunHookDefinitionIds: this.supportCodeLibrary.beforeTestRunHookDefinitions.map((h) => h.id),
-                afterTestRunHookDefinitionIds: this.supportCodeLibrary.afterTestRunHookDefinitions.map((h) => h.id),
-            },
-            options: this.options,
-            snippetOptions: this.snippetOptions,
+        delete this.phase;
+        return success;
+    }
+    async runAfterAllHooks() {
+        const success = await new Promise((resolve, reject) => {
+            this.phase = new test_run_hooks_phase_1.TestRunHooksPhase(resolve, reject, 'AFTERALL_HOOKS');
+            this.startPhase();
         });
+        delete this.phase;
+        return success;
     }
-    onWorkerProcessClose(exitCode) {
-        if (exitCode !== 0) {
-            this.failing = true;
-        }
-        if (Object.values(this.workers).every((x) => x.state === 1 /* WorkerState.closed */)) {
-            this.onFinish(!this.failing);
+    async teardown() {
+        for (const worker of this.workers.values()) {
+            await worker.workerThread.terminate();
+            // close our end of the channel so it stops keeping the loop alive
+            worker.port.close();
         }
     }
-    async run(assembledTestCases) {
-        this.todo = Array.from(assembledTestCases);
-        return await new Promise((resolve) => {
-            for (let i = 0; i < this.options.parallel; i++) {
-                this.startWorker(i.toString(), this.options.parallel);
-            }
-            this.onFinish = (status) => {
-                if (this.idleInterventions > 0) {
-                    this.logger.warn(`WARNING: All workers went idle ${this.idleInterventions} time(s). Consider revising handler passed to setParallelCanAssign.`);
-                }
-                resolve(status);
-            };
-        });
-    }
-    nextWorkPlacement() {
-        for (let index = 0; index < this.todo.length; index++) {
-            const placement = this.placementAt(index);
-            if (this.supportCodeLibrary.parallelCanAssign(placement.item.pickle, Object.values(this.inProgress).map(({ pickle }) => pickle))) {
-                return placement;
+    startPhase() {
+        for (const worker of this.workers) {
+            const command = this.phase.fill();
+            if (command) {
+                this.issueCommandToWorker(worker, command);
             }
         }
-        return null;
     }
-    placementAt(index) {
-        return {
-            index,
-            item: this.todo[index],
-        };
+    issueCommandToWorker(worker, command) {
+        this.running.set(worker, command);
+        worker.port.postMessage(command);
     }
-    giveWork(worker, force = false) {
-        if (this.todo.length < 1) {
-            worker.state = 2 /* WorkerState.running */;
-            worker.process.send({ type: 'FINALIZE' });
-            return;
-        }
-        const workPlacement = force ? this.placementAt(0) : this.nextWorkPlacement();
-        if (workPlacement === null) {
-            return;
+    handleEventFromWorker(worker, event) {
+        switch (event.type) {
+            case 'READY':
+                worker.ready = true;
+                if ([...this.workers].every((mw) => mw.ready)) {
+                    this.readiness?.resolve();
+                }
+                break;
+            case 'ENVELOPE':
+                this.eventBroadcaster.emit('envelope', event.envelope);
+                break;
+            case 'FINISHED': {
+                const previousCommand = this.running.get(worker);
+                this.running.delete(worker);
+                const nextCommand = this.phase?.next(previousCommand, event);
+                if (nextCommand) {
+                    this.issueCommandToWorker(worker, nextCommand);
+                }
+                break;
+            }
         }
-        const { index: nextIndex, item } = workPlacement;
-        this.todo.splice(nextIndex, 1);
-        this.inProgress[worker.id] = item;
-        worker.state = 2 /* WorkerState.running */;
-        worker.process.send({
-            type: 'RUN',
-            assembledTestCase: item,
-            failing: this.failing,
-        });
+    }
+    handleErrorFromWorker(error, worker) {
+        const reason = new Error(`Error on worker ${worker.id}`, { cause: error });
+        this.readiness?.reject(reason);
+        this.phase?.reject(reason);
+        void this.teardown();
     }
 }
-exports.ChildProcessAdapter = ChildProcessAdapter;
-//# sourceMappingURL=adapter.js.map
+exports.WorkerThreadsAdapter = WorkerThreadsAdapter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../../src/runtime/parallel/adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import type { EventEmitter } from 'node:events'\nimport path from 'node:path'\nimport { MessageChannel, Worker } from 'node:worker_threads'\nimport type { IRunOptionsRuntime } from '../../api'\nimport type { AssembledTestCase } from '../../assemble'\nimport type { ILogger, IRunEnvironment } from '../../environment'\nimport type { FormatOptions } from '../../formatter'\nimport type { SupportCodeLibrary } from '../../support_code_library_builder/types'\nimport type { RuntimeAdapter } from '../types'\nimport { TestCasesPhase } from './test_cases_phase'\nimport { TestRunHooksPhase } from './test_run_hooks_phase'\nimport type { ManagedWorker, Phase, WorkerCommand, WorkerData, WorkerEvent } from './types'\n\n/**\n * An adapter that distributes work across multiple worker threads\n * @remarks\n * Each phase of the test run is self-contained and self-orchestrating - every\n * FINISHED message from a worker may cause the next piece of work to be\n * triggered or the phase to be settled.\n */\nexport class WorkerThreadsAdapter implements RuntimeAdapter {\n  private readiness: {\n    resolve: () => void\n    reject: (reason: unknown) => void\n  }\n  private phase: Phase\n  private readonly workers: Set<ManagedWorker> = new Set()\n  private readonly running: Map<ManagedWorker, WorkerCommand> = new Map()\n\n  constructor(\n    private readonly testRunStartedId: string,\n    private readonly environment: IRunEnvironment,\n    private readonly logger: ILogger,\n    private readonly eventBroadcaster: EventEmitter,\n    private readonly options: IRunOptionsRuntime,\n    private readonly snippetOptions: Pick<FormatOptions, 'snippetInterface' | 'snippetSyntax'>,\n    private readonly supportCodeLibrary: SupportCodeLibrary\n  ) {}\n\n  async setup(): Promise<void> {\n    await new Promise<void>((resolve, reject) => {\n      this.readiness = { resolve, reject }\n      const total = this.options.parallel\n      for (let i = 0; i < total; i++) {\n        const id = i.toString()\n        // spin up a dedicated message channel for coordinator-worker comms\n        const { port1, port2 } = new MessageChannel()\n        const workerThread = new Worker(path.resolve(__dirname, 'worker.mjs'), {\n          env: {\n            ...this.environment.env,\n            CUCUMBER_PARALLEL: 'true',\n            CUCUMBER_TOTAL_WORKERS: total.toString(),\n            CUCUMBER_WORKER_ID: id,\n          },\n          resourceLimits: this.options.workerOptions?.resourceLimits,\n          workerData: {\n            cwd: this.environment.cwd,\n            testRunStartedId: this.testRunStartedId,\n            supportCodeCoordinates: this.supportCodeLibrary.originalCoordinates,\n            supportCodeIds: {\n              stepDefinitionIds: this.supportCodeLibrary.stepDefinitions.map((s) => s.id),\n              beforeTestCaseHookDefinitionIds:\n                this.supportCodeLibrary.beforeTestCaseHookDefinitions.map((h) => h.id),\n              afterTestCaseHookDefinitionIds:\n                this.supportCodeLibrary.afterTestCaseHookDefinitions.map((h) => h.id),\n              beforeTestRunHookDefinitionIds:\n                this.supportCodeLibrary.beforeTestRunHookDefinitions.map((h) => h.id),\n              afterTestRunHookDefinitionIds:\n                this.supportCodeLibrary.afterTestRunHookDefinitions.map((h) => h.id),\n            },\n            options: this.options,\n            snippetOptions: this.snippetOptions,\n            port: port2,\n          } satisfies WorkerData,\n          transferList: [port2],\n        })\n        const worker = {\n          id,\n          workerThread,\n          port: port1,\n          ready: false,\n        }\n        this.workers.add(worker)\n        port1.on('message', (event: WorkerEvent) => {\n          this.handleEventFromWorker(worker, event)\n        })\n        workerThread.on('error', (error) => {\n          this.handleErrorFromWorker(error, worker)\n        })\n      }\n    })\n    delete this.readiness\n  }\n\n  async runBeforeAllHooks(): Promise<boolean> {\n    const success = await new Promise<boolean>((resolve, reject) => {\n      this.phase = new TestRunHooksPhase(resolve, reject, 'BEFOREALL_HOOKS')\n      this.startPhase()\n    })\n    delete this.phase\n    return success\n  }\n\n  async runTestCases(assembledTestCases: ReadonlyArray<AssembledTestCase>): Promise<boolean> {\n    const success = await new Promise<boolean>((resolve, reject) => {\n      this.phase = new TestCasesPhase(\n        resolve,\n        reject,\n        this.logger,\n        this.supportCodeLibrary.parallelCanAssign,\n        assembledTestCases\n      )\n      this.startPhase()\n    })\n    delete this.phase\n    return success\n  }\n\n  async runAfterAllHooks(): Promise<boolean> {\n    const success = await new Promise<boolean>((resolve, reject) => {\n      this.phase = new TestRunHooksPhase(resolve, reject, 'AFTERALL_HOOKS')\n      this.startPhase()\n    })\n    delete this.phase\n    return success\n  }\n\n  async teardown(): Promise<void> {\n    for (const worker of this.workers.values()) {\n      await worker.workerThread.terminate()\n      // close our end of the channel so it stops keeping the loop alive\n      worker.port.close()\n    }\n  }\n\n  private startPhase() {\n    for (const worker of this.workers) {\n      const command = this.phase.fill()\n      if (command) {\n        this.issueCommandToWorker(worker, command)\n      }\n    }\n  }\n\n  private issueCommandToWorker(worker: ManagedWorker, command: WorkerCommand) {\n    this.running.set(worker, command)\n    worker.port.postMessage(command)\n  }\n\n  private handleEventFromWorker(worker: ManagedWorker, event: WorkerEvent) {\n    switch (event.type) {\n      case 'READY':\n        worker.ready = true\n        if ([...this.workers].every((mw) => mw.ready)) {\n          this.readiness?.resolve()\n        }\n        break\n      case 'ENVELOPE':\n        this.eventBroadcaster.emit('envelope', event.envelope)\n        break\n      case 'FINISHED': {\n        const previousCommand = this.running.get(worker)\n        this.running.delete(worker)\n        const nextCommand = this.phase?.next(previousCommand, event)\n        if (nextCommand) {\n          this.issueCommandToWorker(worker, nextCommand)\n        }\n        break\n      }\n    }\n  }\n\n  private handleErrorFromWorker(error: Error, worker: ManagedWorker) {\n    const reason = new Error(`Error on worker ${worker.id}`, { cause: error })\n    this.readiness?.reject(reason)\n    this.phase?.reject(reason)\n    void this.teardown()\n  }\n}\n"]}

package/lib/runtime/parallel/test_cases_phase.d.ts

@@ -0,0 +1,19 @@
+import type { AssembledTestCase } from '../../assemble';
+import type { ILogger } from '../../environment';
+import type { ParallelAssignmentValidator } from '../../support_code_library_builder/types';
+import type { FinishedEvent, Phase, RunTestCaseCommand } from './types';
+export declare class TestCasesPhase implements Phase<RunTestCaseCommand> {
+    private readonly resolve;
+    readonly reject: (reason: unknown) => void;
+    private readonly logger;
+    private readonly canAssign;
+    private failing;
+    private idleInterventions;
+    private readonly queue;
+    private readonly running;
+    constructor(resolve: (success: boolean) => void, reject: (reason: unknown) => void, logger: ILogger, canAssign: ParallelAssignmentValidator, assembledTestCases: ReadonlyArray<AssembledTestCase>);
+    fill(): RunTestCaseCommand | undefined;
+    next(command: RunTestCaseCommand, event: FinishedEvent): RunTestCaseCommand | undefined;
+    private select;
+    private dequeue;
+}

package/lib/runtime/parallel/test_cases_phase.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCasesPhase = void 0;
+class TestCasesPhase {
+    resolve;
+    reject;
+    logger;
+    canAssign;
+    failing = false;
+    idleInterventions = 0;
+    queue = [];
+    running = new Set();
+    constructor(resolve, reject, logger, canAssign, assembledTestCases) {
+        this.resolve = resolve;
+        this.reject = reject;
+        this.logger = logger;
+        this.canAssign = canAssign;
+        this.queue.push(...assembledTestCases);
+    }
+    fill() {
+        return this.select();
+    }
+    next(command, event) {
+        if (!event.success) {
+            this.failing = true;
+        }
+        this.running.delete(command.assembledTestCase.pickle);
+        if (this.queue.length === 0 && this.running.size === 0) {
+            if (this.idleInterventions > 0) {
+                this.logger.warn(`WARNING: All workers went idle ${this.idleInterventions} time(s). Consider revising handler passed to setParallelCanAssign.`);
+            }
+            this.resolve(!this.failing);
+            return undefined;
+        }
+        return this.select();
+    }
+    select() {
+        if (this.queue.length === 0) {
+            return undefined;
+        }
+        for (const assembledTestCase of this.queue) {
+            if (this.canAssign(assembledTestCase.pickle, [...this.running])) {
+                return this.dequeue(assembledTestCase);
+            }
+        }
+        if (this.running.size === 0) {
+            this.idleInterventions++;
+            return this.dequeue(this.queue.at(0));
+        }
+        return undefined;
+    }
+    dequeue(assembledTestCase) {
+        this.queue.splice(this.queue.indexOf(assembledTestCase), 1);
+        this.running.add(assembledTestCase.pickle);
+        return {
+            type: 'TEST_CASE',
+            assembledTestCase,
+            failing: this.failing,
+        };
+    }
+}
+exports.TestCasesPhase = TestCasesPhase;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/runtime/parallel/test_run_hooks_phase.d.ts

@@ -0,0 +1,11 @@
+import type { FinishedEvent, Phase, RunAfterAllHooksCommand, RunBeforeAllHooksCommand } from './types';
+export declare class TestRunHooksPhase implements Phase<RunBeforeAllHooksCommand | RunAfterAllHooksCommand> {
+    private readonly resolve;
+    readonly reject: (reason: unknown) => void;
+    private readonly type;
+    private failing;
+    private waiting;
+    constructor(resolve: (success: boolean) => void, reject: (reason: unknown) => void, type: 'BEFOREALL_HOOKS' | 'AFTERALL_HOOKS');
+    fill(): RunBeforeAllHooksCommand | RunAfterAllHooksCommand;
+    next(_command: RunBeforeAllHooksCommand | RunAfterAllHooksCommand, event: FinishedEvent): undefined;
+}

package/lib/runtime/parallel/test_run_hooks_phase.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestRunHooksPhase = void 0;
+class TestRunHooksPhase {
+    resolve;
+    reject;
+    type;
+    failing = false;
+    waiting = 0;
+    constructor(resolve, reject, type) {
+        this.resolve = resolve;
+        this.reject = reject;
+        this.type = type;
+    }
+    fill() {
+        this.waiting++;
+        return {
+            type: this.type,
+        };
+    }
+    next(_command, event) {
+        if (!event.success) {
+            this.failing = true;
+        }
+        this.waiting--;
+        if (this.waiting === 0) {
+            this.resolve(!this.failing);
+        }
+        return undefined;
+    }
+}
+exports.TestRunHooksPhase = TestRunHooksPhase;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/runtime/parallel/types.d.ts

@@ -1,35 +1,51 @@
-import { Envelope } from '@cucumber/messages';
-import { RuntimeOptions } from '../index';
-import { ISupportCodeCoordinates } from '../../api';
-import { AssembledTestCase } from '../../assemble';
-import { CanonicalSupportCodeIds } from '../../support_code_library_builder/types';
-import { FormatOptions } from '../../formatter';
-export type CoordinatorToWorkerCommand = InitializeCommand | RunCommand | FinalizeCommand;
-export interface InitializeCommand {
-    type: 'INITIALIZE';
+import type { MessagePort, Worker } from 'node:worker_threads';
+import type { Envelope } from '@cucumber/messages';
+import type { ISupportCodeCoordinates } from '../../api';
+import type { AssembledTestCase } from '../../assemble';
+import type { FormatOptions } from '../../formatter';
+import type { CanonicalSupportCodeIds } from '../../support_code_library_builder/types';
+import type { RuntimeOptions } from '../types';
+export type ManagedWorker = {
+    id: string;
+    workerThread: Worker;
+    port: MessagePort;
+    ready: boolean;
+};
+export type WorkerData = {
+    cwd: string;
     testRunStartedId: string;
     supportCodeCoordinates: ISupportCodeCoordinates;
     supportCodeIds: CanonicalSupportCodeIds;
     options: RuntimeOptions;
     snippetOptions: Pick<FormatOptions, 'snippetInterface' | 'snippetSyntax'>;
-}
-export interface RunCommand {
-    type: 'RUN';
+    port: MessagePort;
+};
+export type RunBeforeAllHooksCommand = {
+    type: 'BEFOREALL_HOOKS';
+};
+export type RunTestCaseCommand = {
+    type: 'TEST_CASE';
     assembledTestCase: AssembledTestCase;
     failing: boolean;
-}
-export interface FinalizeCommand {
-    type: 'FINALIZE';
-}
-export type WorkerToCoordinatorEvent = ReadyEvent | EnvelopeEvent | FinishedEvent;
-export interface ReadyEvent {
+};
+export type RunAfterAllHooksCommand = {
+    type: 'AFTERALL_HOOKS';
+};
+export type WorkerCommand = RunBeforeAllHooksCommand | RunTestCaseCommand | RunAfterAllHooksCommand;
+export type ReadyEvent = {
     type: 'READY';
-}
-export interface EnvelopeEvent {
+};
+export type EnvelopeEvent = {
     type: 'ENVELOPE';
     envelope: Envelope;
-}
-export interface FinishedEvent {
+};
+export type FinishedEvent = {
     type: 'FINISHED';
     success: boolean;
+};
+export type WorkerEvent = ReadyEvent | EnvelopeEvent | FinishedEvent;
+export interface Phase<T extends WorkerCommand = WorkerCommand> {
+    fill: () => T | undefined;
+    next: (command: T, event: FinishedEvent) => T | undefined;
+    reject: (reason: unknown) => void;
 }

package/lib/runtime/parallel/types.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=data:application/json;base64,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