ppef 1.0.0 → 1.1.0

package/dist/executor/__tests__/run-id.unit.test.js

@@ -0,0 +1,156 @@
+/**
+ * Unit tests for run-id generation
+ *
+ * Tests deterministic run ID generation, config hashing,
+ * run ID validation, and parsing.
+ */
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import { generateRunId, generateConfigHash, validateRunId, parseRunId, } from "../run-id.js";
+describe("generateRunId", () => {
+    it("should generate consistent IDs for same inputs", () => {
+        const inputs = {
+            sutId: "degree-prioritised-v1.0.0",
+            caseId: "karate-v1",
+            seed: 42,
+            repetition: 1,
+        };
+        const id1 = generateRunId(inputs);
+        const id2 = generateRunId(inputs);
+        assert.strictEqual(id1, id2);
+        assert.strictEqual(id1.length, 16);
+    });
+    it("should generate different IDs for different inputs", () => {
+        const inputs1 = {
+            sutId: "sut-1",
+            caseId: "case-1",
+            seed: 42,
+        };
+        const inputs2 = {
+            sutId: "sut-2",
+            caseId: "case-1",
+            seed: 42,
+        };
+        assert.notStrictEqual(generateRunId(inputs1), generateRunId(inputs2));
+    });
+    it("should handle optional fields", () => {
+        const inputs1 = {
+            sutId: "sut-1",
+            caseId: "case-1",
+        };
+        const inputs2 = {
+            sutId: "sut-1",
+            caseId: "case-1",
+            seed: 42,
+            repetition: 1,
+            configHash: "abc123",
+        };
+        assert.strictEqual(generateRunId(inputs1).length, 16);
+        assert.strictEqual(generateRunId(inputs2).length, 16);
+        assert.notStrictEqual(generateRunId(inputs1), generateRunId(inputs2));
+    });
+    it("should generate lowercase hex strings", () => {
+        const inputs = { sutId: "test", caseId: "test" };
+        const id = generateRunId(inputs);
+        assert.ok(/^[0-9a-f]{16}$/.test(id));
+    });
+});
+describe("generateConfigHash", () => {
+    it("should generate consistent hashes for same config", () => {
+        const config = { threshold: 0.9, iterations: 100 };
+        const hash1 = generateConfigHash(config);
+        const hash2 = generateConfigHash(config);
+        assert.strictEqual(hash1, hash2);
+        assert.strictEqual(hash1.length, 8);
+    });
+    it("should generate different hashes for different configs", () => {
+        const config1 = { threshold: 0.9 };
+        const config2 = { threshold: 0.5 };
+        assert.notStrictEqual(generateConfigHash(config1), generateConfigHash(config2));
+    });
+    it("should handle nested objects", () => {
+        const config1 = { nested: { value: 1 } };
+        const config2 = { nested: { value: 2 } };
+        assert.notStrictEqual(generateConfigHash(config1), generateConfigHash(config2));
+    });
+    it("should handle arrays", () => {
+        const config1 = { items: [1, 2, 3] };
+        const config2 = { items: [1, 2, 4] };
+        assert.notStrictEqual(generateConfigHash(config1), generateConfigHash(config2));
+    });
+    it("should generate lowercase hex strings", () => {
+        const hash = generateConfigHash({ test: true });
+        assert.ok(/^[0-9a-f]{8}$/.test(hash));
+    });
+    it("should handle empty config", () => {
+        const hash = generateConfigHash({});
+        assert.strictEqual(hash.length, 8);
+    });
+    it("should be order-independent due to key sorting", () => {
+        const hash1 = generateConfigHash({ a: 1, b: 2, c: 3 });
+        const hash2 = generateConfigHash({ c: 3, a: 1, b: 2 });
+        assert.strictEqual(hash1, hash2);
+    });
+});
+describe("validateRunId", () => {
+    it("should return true for matching run ID", () => {
+        const inputs = { sutId: "test", caseId: "case" };
+        const runId = generateRunId(inputs);
+        assert.strictEqual(validateRunId(runId, inputs), true);
+    });
+    it("should return false for non-matching run ID", () => {
+        const inputs = { sutId: "test", caseId: "case" };
+        const runId = generateRunId({ sutId: "other", caseId: "case" });
+        assert.strictEqual(validateRunId(runId, inputs), false);
+    });
+    it("should return false for invalid run ID format", () => {
+        const inputs = { sutId: "test", caseId: "case" };
+        assert.strictEqual(validateRunId("not-a-valid-id", inputs), false);
+        assert.strictEqual(validateRunId("", inputs), false);
+        assert.strictEqual(validateRunId("abc", inputs), false);
+    });
+});
+describe("parseRunId", () => {
+    it("should validate correctly formatted run IDs", () => {
+        const result = parseRunId("abc123def4567890");
+        assert.strictEqual(result.valid, true);
+        assert.strictEqual(result.length, 16);
+    });
+    it("should reject run IDs with wrong length", () => {
+        const result = parseRunId("abc123");
+        assert.strictEqual(result.valid, false);
+        assert.strictEqual(result.length, 6);
+    });
+    it("should reject run IDs with non-hex characters", () => {
+        const result = parseRunId("abc123xyz4567890");
+        assert.strictEqual(result.valid, false);
+        assert.strictEqual(result.length, 16);
+    });
+    it("should accept uppercase letters (hex is case-insensitive)", () => {
+        const result = parseRunId("ABC123DEF4567890");
+        // The implementation uses case-insensitive regex, so uppercase is valid
+        assert.strictEqual(result.valid, true);
+        assert.strictEqual(result.length, 16);
+    });
+    it("should reject empty string", () => {
+        const result = parseRunId("");
+        assert.strictEqual(result.valid, false);
+        assert.strictEqual(result.length, 0);
+    });
+    it("should reject strings with special characters", () => {
+        const result = parseRunId("abc-123-def-456");
+        assert.strictEqual(result.valid, false);
+        assert.strictEqual(result.length, 15);
+    });
+    it("should accept all zeros", () => {
+        const result = parseRunId("0000000000000000");
+        assert.strictEqual(result.valid, true);
+        assert.strictEqual(result.length, 16);
+    });
+    it("should accept all f's", () => {
+        const result = parseRunId("ffffffffffffffff");
+        assert.strictEqual(result.valid, true);
+        assert.strictEqual(result.length, 16);
+    });
+});
+//# sourceMappingURL=run-id.unit.test.js.map

package/dist/executor/__tests__/run-id.unit.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-id.unit.test.js","sourceRoot":"","sources":["../../../src/executor/__tests__/run-id.unit.test.ts"],"names":[],"mappings":"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"}

package/dist/executor/__tests__/worker-entry.integration.test.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Integration tests for worker-entry
+ *
+ * Tests the worker entry point by actually spawning a worker thread
+ * and sending messages to it.
+ *
+ * These tests automatically skip if the build output doesn't exist.
+ */
+export {};
+/**
+ * Note: The worker-entry.ts file is a thin wrapper around WorkerExecutor.
+ *
+ * The core logic is tested in worker-executor.unit.test.ts with 98.27% coverage.
+ *
+ * These integration tests automatically skip if the build output doesn't exist.
+ * To enable them:
+ *
+ * 1. Build the project: `npm run build`
+ *
+ * The tests check for `dist/executor/worker-entry.js` at runtime and skip
+ * if it's not found. Using tsx/esm with Worker was attempted but has
+ * issues resolving .js imports to .ts files in the worker context.
+ */
+//# sourceMappingURL=worker-entry.integration.test.d.ts.map

package/dist/executor/__tests__/worker-entry.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-entry.integration.test.d.ts","sourceRoot":"","sources":["../../../src/executor/__tests__/worker-entry.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;;AAwEH;;;;;;;;;;;;;GAaG"}

package/dist/executor/__tests__/worker-entry.integration.test.js

@@ -0,0 +1,82 @@
+/**
+ * Integration tests for worker-entry
+ *
+ * Tests the worker entry point by actually spawning a worker thread
+ * and sending messages to it.
+ *
+ * These tests automatically skip if the build output doesn't exist.
+ */
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import { existsSync } from "node:fs";
+import { Worker } from "node:worker_threads";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Path to the built worker entry (requires npm run build)
+const workerEntryPath = resolve(__dirname, "../../../dist/executor/worker-entry.js");
+// Check if build output exists - skip tests if not built
+const isBuilt = existsSync(workerEntryPath);
+describe("worker-entry integration", { skip: !isBuilt }, () => {
+    it("should spawn worker and respond to messages", async () => {
+        // Tests skipped: Requires build (npm run build)
+        // WorkerExecutor is tested at 98.27% coverage in unit tests
+        const worker = new Worker(workerEntryPath, {
+            workerData: {},
+        });
+        try {
+            // Test basic communication
+            const response = await new Promise((resolve, reject) => {
+                worker.on("message", resolve);
+                worker.on("error", reject);
+                worker.on("exit", (code) => {
+                    if (code !== 0) {
+                        reject(new Error(`Worker stopped with exit code ${code}`));
+                    }
+                });
+                // Send a test message
+                worker.postMessage({ type: "test" });
+            });
+            assert.ok(response);
+        }
+        finally {
+            await worker.terminate();
+        }
+    });
+    it("should handle execute batch messages", async () => {
+        // Test that the worker can handle executeBatch messages
+        // This is the main use case for the worker
+        const worker = new Worker(workerEntryPath);
+        try {
+            const response = await new Promise((resolve, reject) => {
+                worker.on("message", resolve);
+                worker.on("error", reject);
+                // Send an executeBatch message with mock data
+                worker.postMessage({
+                    type: "executeBatch",
+                    runs: [],
+                });
+            });
+            assert.ok(response);
+        }
+        finally {
+            await worker.terminate();
+        }
+    });
+});
+/**
+ * Note: The worker-entry.ts file is a thin wrapper around WorkerExecutor.
+ *
+ * The core logic is tested in worker-executor.unit.test.ts with 98.27% coverage.
+ *
+ * These integration tests automatically skip if the build output doesn't exist.
+ * To enable them:
+ *
+ * 1. Build the project: `npm run build`
+ *
+ * The tests check for `dist/executor/worker-entry.js` at runtime and skip
+ * if it's not found. Using tsx/esm with Worker was attempted but has
+ * issues resolving .js imports to .ts files in the worker context.
+ */
+//# sourceMappingURL=worker-entry.integration.test.js.map

package/dist/executor/__tests__/worker-entry.integration.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-entry.integration.test.js","sourceRoot":"","sources":["../../../src/executor/__tests__/worker-entry.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,MAAM,IAAI,MAAM,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAEtC,0DAA0D;AAC1D,MAAM,eAAe,GAAG,OAAO,CAAC,SAAS,EAAE,wCAAwC,CAAC,CAAC;AACrF,yDAAyD;AACzD,MAAM,OAAO,GAAG,UAAU,CAAC,eAAe,CAAC,CAAC;AAE5C,QAAQ,CAAC,0BAA0B,EAAE,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE;IAC7D,EAAE,CAAC,6CAA6C,EAAE,KAAK,IAAI,EAAE;QAC5D,gDAAgD;QAChD,4DAA4D;QAE5D,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,eAAe,EAAE;YAC1C,UAAU,EAAE,EAAE;SACd,CAAC,CAAC;QAEH,IAAI,CAAC;YACJ,2BAA2B;YAC3B,MAAM,QAAQ,GAAG,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACtD,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;gBAC9B,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;gBAC3B,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;oBAC1B,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;wBAChB,MAAM,CAAC,IAAI,KAAK,CAAC,iCAAiC,IAAI,EAAE,CAAC,CAAC,CAAC;oBAC5D,CAAC;gBACF,CAAC,CAAC,CAAC;gBAEH,sBAAsB;gBACtB,MAAM,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;YACtC,CAAC,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;QACrB,CAAC;gBAAS,CAAC;YACV,MAAM,MAAM,CAAC,SAAS,EAAE,CAAC;QAC1B,CAAC;IACF,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sCAAsC,EAAE,KAAK,IAAI,EAAE;QACrD,wDAAwD;QACxD,2CAA2C;QAE3C,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,eAAe,CAAC,CAAC;QAE3C,IAAI,CAAC;YACJ,MAAM,QAAQ,GAAG,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACtD,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;gBAC9B,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;gBAE3B,8CAA8C;gBAC9C,MAAM,CAAC,WAAW,CAAC;oBAClB,IAAI,EAAE,cAAc;oBACpB,IAAI,EAAE,EAAE;iBACR,CAAC,CAAC;YACJ,CAAC,CAAC,CAAC;YAEH,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;QACrB,CAAC;gBAAS,CAAC;YACV,MAAM,MAAM,CAAC,SAAS,EAAE,CAAC;QAC1B,CAAC;IACF,CAAC,CAAC,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH;;;;;;;;;;;;;GAaG"}

package/dist/executor/__tests__/worker-entry.unit.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Unit tests for worker-entry.ts
+ *
+ * Tests WorkerExecutor with injected mock dependencies.
+ */
+export {};
+//# sourceMappingURL=worker-entry.unit.test.d.ts.map

package/dist/executor/__tests__/worker-entry.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-entry.unit.test.d.ts","sourceRoot":"","sources":["../../../src/executor/__tests__/worker-entry.unit.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/executor/__tests__/worker-entry.unit.test.js

@@ -0,0 +1,364 @@
+/**
+ * Unit tests for worker-entry.ts
+ *
+ * Tests WorkerExecutor with injected mock dependencies.
+ */
+import { describe, it, mock, beforeEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { WorkerExecutor, } from "../worker-executor.js";
+describe("worker-entry", () => {
+    let mockParentPort;
+    let mockModuleLoader;
+    let mockExecutorInstance;
+    let postedMessages;
+    let onListeners;
+    beforeEach(() => {
+        postedMessages = [];
+        onListeners = [];
+        // Mock parentPort
+        mockParentPort = {
+            on: mock.fn((event, listener) => {
+                onListeners.push({ event, listener });
+            }),
+            postMessage: mock.fn((message) => {
+                postedMessages.push(message);
+            }),
+        };
+        // Mock executor instance
+        mockExecutorInstance = {
+            execute: mock.fn(async () => ({
+                results: [
+                    {
+                        run: {
+                            runId: "test-1",
+                            sut: "sut-1",
+                            sutRole: "primary",
+                            caseId: "case-1",
+                            repetition: 0,
+                            seed: 42,
+                        },
+                        correctness: {
+                            expectedExists: true,
+                            producedOutput: true,
+                            valid: true,
+                            matchesExpected: true,
+                        },
+                        outputs: {},
+                        metrics: { numeric: {} },
+                        provenance: {
+                            runtime: {
+                                platform: "test",
+                                arch: "test",
+                                nodeVersion: "test",
+                            },
+                        },
+                    },
+                ],
+                errors: [],
+            })),
+        };
+        // Mock Executor constructor
+        const MockExecutor = mock.fn(function () {
+            return mockExecutorInstance;
+        });
+        // Mock module loader
+        mockModuleLoader = {
+            loadExecutor: async () => {
+                return {
+                    Executor: MockExecutor,
+                };
+            },
+            loadEvaluate: async () => {
+                return {
+                    getSutDefinitions: () => ({}),
+                    getCaseDefinitions: () => ({}),
+                };
+            },
+            loadRegistry: async () => {
+                return {
+                    registerAllBenchmarkCases: async () => ({}),
+                };
+            },
+            loadSuts: async () => {
+                return {
+                    registerAllSuts: () => ({}),
+                };
+            },
+            loadDatasets: async () => {
+                return {
+                    registerBenchmarkDatasets: async () => {
+                        return;
+                    },
+                };
+            },
+        };
+    });
+    describe("WorkerExecutor", () => {
+        it("should register message listener on start", () => {
+            const executor = new WorkerExecutor(mockParentPort, mockModuleLoader, "/test/root");
+            executor.start();
+            assert.strictEqual(onListeners.length, 1);
+            assert.strictEqual(onListeners[0].event, "message");
+            assert.strictEqual(typeof onListeners[0].listener, "function");
+        });
+        it("should call module loader methods in order", async () => {
+            const callOrder = [];
+            // Wrap each loader method to track call order
+            const originalLoader = mockModuleLoader;
+            mockModuleLoader = {
+                loadExecutor: async () => {
+                    callOrder.push("loadExecutor");
+                    return originalLoader.loadExecutor();
+                },
+                loadEvaluate: async () => {
+                    callOrder.push("loadEvaluate");
+                    return originalLoader.loadEvaluate();
+                },
+                loadRegistry: async () => {
+                    callOrder.push("loadRegistry");
+                    return originalLoader.loadRegistry();
+                },
+                loadSuts: async () => {
+                    callOrder.push("loadSuts");
+                    return originalLoader.loadSuts();
+                },
+                loadDatasets: async () => {
+                    callOrder.push("loadDatasets");
+                    return originalLoader.loadDatasets();
+                },
+            };
+            const message = {
+                runs: [{ runId: "test-1", sutId: "sut-1", caseId: "case-1", repetition: 0, config: {} }],
+                config: {
+                    repetitions: 1,
+                    seedBase: 42,
+                    continueOnError: true,
+                    timeoutMs: 5000,
+                    collectProvenance: false,
+                },
+            };
+            const executor = new WorkerExecutor(mockParentPort, mockModuleLoader, "/test/root");
+            await executor.handleMessage(message);
+            // Verify all module loaders were called in the expected order
+            assert.strictEqual(callOrder.length, 5);
+            assert.strictEqual(callOrder[0], "loadExecutor");
+            assert.strictEqual(callOrder[1], "loadEvaluate");
+            assert.strictEqual(callOrder[2], "loadRegistry");
+            assert.strictEqual(callOrder[3], "loadSuts");
+            assert.strictEqual(callOrder[4], "loadDatasets");
+        });
+        it("should post done message on successful execution", async () => {
+            const message = {
+                runs: [{ runId: "test-1", sutId: "sut-1", caseId: "case-1", repetition: 0, config: {} }],
+                config: {
+                    repetitions: 1,
+                    seedBase: 42,
+                    continueOnError: true,
+                    timeoutMs: 5000,
+                    collectProvenance: false,
+                },
+            };
+            const executor = new WorkerExecutor(mockParentPort, mockModuleLoader, "/test/root");
+            await executor.handleMessage(message);
+            assert.strictEqual(postedMessages.length, 1);
+            const posted = postedMessages[0];
+            assert.strictEqual(posted.type, "done");
+            assert.ok(Array.isArray(posted.results));
+            assert.strictEqual(posted.results.length, 1);
+        });
+        it("should post error message on exception", async () => {
+            // Make loadExecutor throw an error
+            mockModuleLoader.loadExecutor = async () => {
+                throw new Error("Module not found");
+            };
+            const message = {
+                runs: [{ runId: "test-1", sutId: "sut-1", caseId: "case-1", repetition: 0, config: {} }],
+                config: {
+                    repetitions: 1,
+                    seedBase: 42,
+                    continueOnError: true,
+                    timeoutMs: 5000,
+                    collectProvenance: false,
+                },
+            };
+            const executor = new WorkerExecutor(mockParentPort, mockModuleLoader, "/test/root");
+            await executor.handleMessage(message);
+            assert.strictEqual(postedMessages.length, 1);
+            const posted = postedMessages[0];
+            assert.strictEqual(posted.type, "error");
+            assert.strictEqual(posted.error, "Module not found");
+        });
+        it("should post error message with string error", async () => {
+            mockModuleLoader.loadExecutor = async () => {
+                throw new Error("String error");
+            };
+            const message = {
+                runs: [{ runId: "test-1", sutId: "sut-1", caseId: "case-1", repetition: 0, config: {} }],
+                config: {
+                    repetitions: 1,
+                    seedBase: 42,
+                    continueOnError: true,
+                    timeoutMs: 5000,
+                    collectProvenance: false,
+                },
+            };
+            const executor = new WorkerExecutor(mockParentPort, mockModuleLoader, "/test/root");
+            await executor.handleMessage(message);
+            assert.strictEqual(postedMessages.length, 1);
+            const posted = postedMessages[0];
+            assert.strictEqual(posted.type, "error");
+            assert.strictEqual(posted.error, "String error");
+        });
+        it("should pass executor config to Executor constructor", async () => {
+            const MockExecutor = mock.fn(function (_config) {
+                mockExecutorInstance.execute = mock.fn(async () => ({
+                    results: [],
+                    errors: [],
+                }));
+                return mockExecutorInstance;
+            });
+            mockModuleLoader.loadExecutor = async () => {
+                return {
+                    Executor: MockExecutor,
+                };
+            };
+            const message = {
+                runs: [{ runId: "test-1", sutId: "sut-1", caseId: "case-1", repetition: 0, config: {} }],
+                config: {
+                    repetitions: 5,
+                    seedBase: 999,
+                    continueOnError: false,
+                    timeoutMs: 15000,
+                    collectProvenance: true,
+                },
+            };
+            const executor = new WorkerExecutor(mockParentPort, mockModuleLoader, "/test/root");
+            await executor.handleMessage(message);
+            // Verify Executor was constructed with correct config
+            assert.strictEqual(MockExecutor.mock.calls.length, 1);
+            const executorConfig = MockExecutor.mock.calls[0].arguments[0];
+            assert.strictEqual(executorConfig.repetitions, 5);
+            assert.strictEqual(executorConfig.seedBase, 999);
+            assert.strictEqual(executorConfig.continueOnError, false);
+            assert.strictEqual(executorConfig.timeoutMs, 15000);
+            assert.strictEqual(executorConfig.collectProvenance, true);
+        });
+        it("should handle multiple runs in a batch", async () => {
+            const message = {
+                runs: [
+                    { runId: "test-1", sutId: "sut-1", caseId: "case-1", repetition: 0, config: {} },
+                    { runId: "test-2", sutId: "sut-2", caseId: "case-2", repetition: 1, config: {} },
+                    { runId: "test-3", sutId: "sut-1", caseId: "case-2", repetition: 0, config: {} },
+                ],
+                config: {
+                    repetitions: 3,
+                    seedBase: 100,
+                    continueOnError: true,
+                    timeoutMs: 10000,
+                    collectProvenance: false,
+                },
+            };
+            const executor = new WorkerExecutor(mockParentPort, mockModuleLoader, "/test/root");
+            await executor.handleMessage(message);
+            assert.strictEqual(postedMessages.length, 1);
+            const posted = postedMessages[0];
+            assert.strictEqual(posted.type, "done");
+            assert.ok(Array.isArray(posted.results));
+        });
+    });
+    describe("executeBatch", () => {
+        it("should call registerBenchmarkDatasets on datasets module", async () => {
+            const registerSpy = mock.fn(async () => {
+                return;
+            });
+            mockModuleLoader.loadDatasets = async () => {
+                return {
+                    registerBenchmarkDatasets: registerSpy,
+                };
+            };
+            const message = {
+                runs: [{ runId: "test-1", sutId: "sut-1", caseId: "case-1", repetition: 0, config: {} }],
+                config: {
+                    repetitions: 1,
+                    seedBase: 42,
+                    continueOnError: true,
+                    timeoutMs: 5000,
+                    collectProvenance: false,
+                },
+            };
+            const executor = new WorkerExecutor(mockParentPort, mockModuleLoader, "/test/root");
+            await executor.executeBatch(message);
+            assert.strictEqual(registerSpy.mock.calls.length, 1);
+        });
+        it("should call registerAllSuts on SUTs module", async () => {
+            const registerSpy = mock.fn(() => ({}));
+            mockModuleLoader.loadSuts = async () => {
+                return {
+                    registerAllSuts: registerSpy,
+                };
+            };
+            const message = {
+                runs: [{ runId: "test-1", sutId: "sut-1", caseId: "case-1", repetition: 0, config: {} }],
+                config: {
+                    repetitions: 1,
+                    seedBase: 42,
+                    continueOnError: true,
+                    timeoutMs: 5000,
+                    collectProvenance: false,
+                },
+            };
+            const executor = new WorkerExecutor(mockParentPort, mockModuleLoader, "/test/root");
+            await executor.executeBatch(message);
+            assert.strictEqual(registerSpy.mock.calls.length, 1);
+        });
+        it("should call registerAllBenchmarkCases on registry module", async () => {
+            const registerSpy = mock.fn(async () => ({}));
+            mockModuleLoader.loadRegistry = async () => {
+                return {
+                    registerAllBenchmarkCases: registerSpy,
+                };
+            };
+            const message = {
+                runs: [{ runId: "test-1", sutId: "sut-1", caseId: "case-1", repetition: 0, config: {} }],
+                config: {
+                    repetitions: 1,
+                    seedBase: 42,
+                    continueOnError: true,
+                    timeoutMs: 5000,
+                    collectProvenance: false,
+                },
+            };
+            const executor = new WorkerExecutor(mockParentPort, mockModuleLoader, "/test/root");
+            await executor.executeBatch(message);
+            assert.strictEqual(registerSpy.mock.calls.length, 1);
+        });
+        it("should create sutRegistry with list and getFactory methods", async () => {
+            let capturedSutRegistry;
+            mockModuleLoader.loadEvaluate = async () => {
+                return {
+                    getSutDefinitions: (registry) => {
+                        capturedSutRegistry = registry;
+                        return {};
+                    },
+                    getCaseDefinitions: () => ({}),
+                };
+            };
+            const message = {
+                runs: [{ runId: "test-1", sutId: "sut-1", caseId: "case-1", repetition: 0, config: {} }],
+                config: {
+                    repetitions: 1,
+                    seedBase: 42,
+                    continueOnError: true,
+                    timeoutMs: 5000,
+                    collectProvenance: false,
+                },
+            };
+            const executor = new WorkerExecutor(mockParentPort, mockModuleLoader, "/test/root");
+            await executor.executeBatch(message);
+            assert.ok(capturedSutRegistry);
+            assert.strictEqual(typeof capturedSutRegistry.list, "function");
+            assert.strictEqual(typeof capturedSutRegistry.getFactory, "function");
+        });
+    });
+});
+//# sourceMappingURL=worker-entry.unit.test.js.map