groundswell 0.0.2 → 0.0.3

package/dist/__tests__/adversarial/concurrent-task-failures.test.js

@@ -0,0 +1,667 @@
+/**
+ * Concurrent Task Failure Scenarios Test Suite
+ *
+ * Tests the Promise.allSettled implementation in @Task decorator
+ * for concurrent execution with various failure scenarios.
+ *
+ * Validates:
+ * - Single child failure in concurrent batch
+ * - Multiple children failing concurrently
+ * - Mixed success/failure scenarios
+ * - All children failing edge case
+ * - No orphaned or hanging promises
+ * - Error collection correctness
+ * - Event emission during failures
+ *
+ * Related:
+ * - S2 Implementation: Promise.allSettled in task.ts (lines 111-120)
+ * - Bug: 001_e8e04329daf3 - Concurrent task error collection
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { describe, it, expect } from 'vitest';
+import { Workflow, Task, Step } from '../../index.js';
+describe('@Task decorator concurrent failure scenarios', () => {
+    /**
+     * Helper to create a child workflow that may fail
+     * Pattern from: src/__tests__/adversarial/edge-case.test.ts (lines 146-167)
+     */
+    function createChildWorkflow(parent, name, shouldFail = false) {
+        return new ((() => {
+            let _classSuper = Workflow;
+            let _instanceExtraInitializers = [];
+            let _executeStep_decorators;
+            return class extends _classSuper {
+                static {
+                    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                    _executeStep_decorators = [Step()];
+                    __esDecorate(this, null, _executeStep_decorators, { kind: "method", name: "executeStep", static: false, private: false, access: { has: obj => "executeStep" in obj, get: obj => obj.executeStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                    if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                }
+                constructor(n, p) {
+                    super(n, p);
+                    __runInitializers(this, _instanceExtraInitializers);
+                }
+                async executeStep() {
+                    if (shouldFail) {
+                        throw new Error(`${name} failed`);
+                    }
+                    return `${name} succeeded`;
+                }
+                async run() {
+                    return this.executeStep();
+                }
+            };
+        })())(name, parent);
+    }
+    /**
+     * Helper to setup event observer for event collection
+     * Pattern from: src/__tests__/adversarial/observer-propagation.test.ts (lines 42-49)
+     */
+    function setupEventObserver(workflow) {
+        const events = [];
+        workflow.addObserver({
+            onLog: () => { },
+            onEvent: (e) => events.push(e),
+            onStateUpdated: () => { },
+            onTreeChanged: () => { },
+        });
+        return events;
+    }
+    describe('Single child failure scenarios', () => {
+        it('should complete all siblings when one child fails', async () => {
+            // ARRANGE: Create parent with 4 children, child[1] will fail
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        return [
+                            createChildWorkflow(this, 'Child-0', false),
+                            createChildWorkflow(this, 'Child-1', true), // Will fail
+                            createChildWorkflow(this, 'Child-2', false),
+                            createChildWorkflow(this, 'Child-3', false),
+                        ];
+                    }
+                    async run() {
+                        try {
+                            await this.spawnChildren();
+                        }
+                        catch (err) {
+                            // Expected - first error thrown after all complete
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const parent = new ParentWorkflow('Parent');
+            // ACT: Run parent (children run concurrently)
+            await parent.run();
+            // ASSERT: All 4 children attached (Promise.allSettled completed all)
+            expect(parent.children.length).toBe(4);
+            // ASSERT: Verify child names match what we created
+            const childNames = parent.children.map((c) => c.node.name);
+            expect(childNames).toContain('Child-0');
+            expect(childNames).toContain('Child-1');
+            expect(childNames).toContain('Child-2');
+            expect(childNames).toContain('Child-3');
+        });
+    });
+    describe('Multiple concurrent failures', () => {
+        it('should collect all errors when multiple children fail concurrently', async () => {
+            // ARRANGE: Create parent with 6 children, 3 will fail
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        return [
+                            createChildWorkflow(this, 'Alpha', false),
+                            createChildWorkflow(this, 'Beta', true), // Will fail
+                            createChildWorkflow(this, 'Gamma', false),
+                            createChildWorkflow(this, 'Delta', true), // Will fail
+                            createChildWorkflow(this, 'Epsilon', false),
+                            createChildWorkflow(this, 'Zeta', true), // Will fail
+                        ];
+                    }
+                    async run() {
+                        try {
+                            await this.spawnChildren();
+                        }
+                        catch (err) {
+                            // Expected
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const parent = new ParentWorkflow('Parent');
+            // ACT
+            await parent.run();
+            // ASSERT: All 6 children attached (Promise.allSettled completed all)
+            expect(parent.children.length).toBe(6);
+            // ASSERT: Verify expected child names are present
+            const childNames = parent.children.map((c) => c.node.name);
+            expect(childNames).toContain('Alpha');
+            expect(childNames).toContain('Beta');
+            expect(childNames).toContain('Gamma');
+            expect(childNames).toContain('Delta');
+            expect(childNames).toContain('Epsilon');
+            expect(childNames).toContain('Zeta');
+        });
+        it('should preserve error context for each failure', async () => {
+            // ARRANGE: Create parent with multiple failing children
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        return [
+                            createChildWorkflow(this, 'Alpha', true),
+                            createChildWorkflow(this, 'Beta', true),
+                            createChildWorkflow(this, 'Gamma', true),
+                        ];
+                    }
+                    async run() {
+                        try {
+                            await this.spawnChildren();
+                        }
+                        catch (err) {
+                            // Expected
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const parent = new ParentWorkflow('Parent');
+            const events = setupEventObserver(parent);
+            // ACT
+            await parent.run();
+            // ASSERT: Error events emitted for all failures
+            const errorEvents = events.filter((e) => e.type === 'error');
+            expect(errorEvents.length).toBeGreaterThanOrEqual(3);
+            // ASSERT: Each error event has correct structure
+            errorEvents.forEach((event) => {
+                expect(event.type).toBe('error');
+                if (event.type === 'error') {
+                    expect(event.error).toBeDefined();
+                    expect(event.error.workflowId).toBeDefined();
+                    expect(event.error.message).toBeDefined();
+                    expect(Array.isArray(event.error.logs)).toBe(true);
+                }
+            });
+            // ASSERT: All three distinct error messages captured
+            const errorMessages = errorEvents
+                .filter((e) => e.type === 'error')
+                .map((e) => e.error.message);
+            expect(errorMessages).toContain('Alpha failed');
+            expect(errorMessages).toContain('Beta failed');
+            expect(errorMessages).toContain('Gamma failed');
+        });
+    });
+    describe('Mixed success/failure scenarios', () => {
+        it('should complete successful workflows despite failures', async () => {
+            // ARRANGE: Create parent with mixed success/failure children
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        return [
+                            createChildWorkflow(this, 'Success-1', false),
+                            createChildWorkflow(this, 'Fail-1', true),
+                            createChildWorkflow(this, 'Success-2', false),
+                            createChildWorkflow(this, 'Fail-2', true),
+                            createChildWorkflow(this, 'Success-3', false),
+                        ];
+                    }
+                    async run() {
+                        try {
+                            await this.spawnChildren();
+                        }
+                        catch (err) {
+                            // Expected
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const parent = new ParentWorkflow('Parent');
+            // ACT
+            await parent.run();
+            // ASSERT: All 5 children attached (Promise.allSettled completed all)
+            expect(parent.children.length).toBe(5);
+            // ASSERT: Verify all expected children are present
+            const childNames = parent.children.map((c) => c.node.name);
+            expect(childNames).toContain('Success-1');
+            expect(childNames).toContain('Fail-1');
+            expect(childNames).toContain('Success-2');
+            expect(childNames).toContain('Fail-2');
+            expect(childNames).toContain('Success-3');
+        });
+        it('should ensure no orphaned workflows in mixed scenario', async () => {
+            // ARRANGE: Track all completions
+            const completedWorkflows = new Set();
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        const children = [
+                            createChildWorkflow(this, 'Alpha', false),
+                            createChildWorkflow(this, 'Beta', true),
+                            createChildWorkflow(this, 'Gamma', false),
+                            createChildWorkflow(this, 'Delta', false),
+                            createChildWorkflow(this, 'Epsilon', true),
+                        ];
+                        // Track completion for all children
+                        children.forEach((child) => {
+                            child.run().then(() => completedWorkflows.add(child.id), () => completedWorkflows.add(child.id));
+                        });
+                        return children;
+                    }
+                    async run() {
+                        try {
+                            await this.spawnChildren();
+                        }
+                        catch (err) {
+                            // Expected
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const parent = new ParentWorkflow('Parent');
+            // ACT
+            await parent.run();
+            // ASSERT: All 5 workflows accounted for (no orphans)
+            expect(completedWorkflows.size).toBe(5);
+            expect(parent.children.length).toBe(5);
+        });
+    });
+    describe('All children failing', () => {
+        it('should handle edge case of all children failing', async () => {
+            // ARRANGE: All children will fail
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        return Array.from({ length: 5 }, (_, i) => createChildWorkflow(this, `FailChild-${i}`, true) // All fail
+                        );
+                    }
+                    async run() {
+                        try {
+                            await this.spawnChildren();
+                        }
+                        catch (err) {
+                            // Expected - first error thrown
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const parent = new ParentWorkflow('Parent');
+            const events = setupEventObserver(parent);
+            // ACT
+            await parent.run();
+            // ASSERT: All 5 children attached
+            expect(parent.children.length).toBe(5);
+            // ASSERT: Error events emitted for all failures
+            const errorEvents = events.filter((e) => e.type === 'error');
+            expect(errorEvents.length).toBeGreaterThanOrEqual(5);
+            // ASSERT: Each failure has distinct error message
+            const errorMessages = errorEvents
+                .filter((e) => e.type === 'error')
+                .map((e) => e.error.message);
+            for (let i = 0; i < 5; i++) {
+                expect(errorMessages).toContain(`FailChild-${i} failed`);
+            }
+        });
+    });
+    describe('No orphaned workflows', () => {
+        it('should verify all workflows complete with no hanging promises', async () => {
+            // ARRANGE: Track all completions
+            const completedWorkflows = new Set();
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        const children = Array.from({ length: 10 }, (_, i) => createChildWorkflow(this, `Child-${i}`, Math.random() < 0.3 // 30% failure rate
+                        ));
+                        // Track completion for all children
+                        children.forEach((child) => {
+                            child.run().then(() => completedWorkflows.add(child.id), () => completedWorkflows.add(child.id));
+                        });
+                        return children;
+                    }
+                    async run() {
+                        try {
+                            await this.spawnChildren();
+                        }
+                        catch (err) {
+                            // Expected
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const parent = new ParentWorkflow('Parent');
+            // ACT: Run with timeout to detect hanging promises
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout: workflows hung')), 5000));
+            const runPromise = parent.run();
+            await Promise.race([runPromise, timeoutPromise]);
+            // ASSERT: All 10 workflows accounted for (no orphans)
+            expect(completedWorkflows.size).toBe(10);
+        });
+    });
+    describe('Event emission verification', () => {
+        it('should emit error events for all failing workflows', async () => {
+            // ARRANGE: Setup event observer
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        return [
+                            createChildWorkflow(this, 'Good', false),
+                            createChildWorkflow(this, 'Bad1', true),
+                            createChildWorkflow(this, 'Bad2', true),
+                        ];
+                    }
+                    async run() {
+                        try {
+                            await this.spawnChildren();
+                        }
+                        catch (err) {
+                            // Expected
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const parent = new ParentWorkflow('Parent');
+            const events = [];
+            // CRITICAL: Add observer to root workflow
+            parent.addObserver({
+                onLog: () => { },
+                onEvent: (e) => events.push(e),
+                onStateUpdated: () => { },
+                onTreeChanged: () => { },
+            });
+            // ACT
+            await parent.run();
+            // ASSERT: Error events emitted for both failures
+            const errorEvents = events.filter((e) => e.type === 'error');
+            expect(errorEvents.length).toBeGreaterThanOrEqual(2);
+            // ASSERT: Each error event has correct structure
+            errorEvents.forEach((event) => {
+                expect(event.type).toBe('error');
+                if (event.type === 'error') {
+                    expect(event.error).toBeDefined();
+                    expect(event.error.workflowId).toBeDefined();
+                    expect(event.error.message).toBeDefined();
+                    expect(Array.isArray(event.error.logs)).toBe(true);
+                }
+            });
+            // ASSERT: Verify expected error messages
+            const errorMessages = errorEvents
+                .filter((e) => e.type === 'error')
+                .map((e) => e.error.message);
+            expect(errorMessages).toContain('Bad1 failed');
+            expect(errorMessages).toContain('Bad2 failed');
+        });
+        it('should capture logs from both successful and failed workflows', async () => {
+            // ARRANGE: Create workflows that log before completion/failure
+            let ChildWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _executeStep_decorators;
+                return class ChildWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _executeStep_decorators = [Step()];
+                        __esDecorate(this, null, _executeStep_decorators, { kind: "method", name: "executeStep", static: false, private: false, access: { has: obj => "executeStep" in obj, get: obj => obj.executeStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    shouldFail = __runInitializers(this, _instanceExtraInitializers);
+                    constructor(name, parent, shouldFail) {
+                        super(name, parent);
+                        this.shouldFail = shouldFail;
+                    }
+                    async executeStep() {
+                        this.logger.info(`${this.node.name} is running`);
+                        if (this.shouldFail) {
+                            this.logger.error(`${this.node.name} is about to fail`);
+                            throw new Error(`${this.node.name} failed`);
+                        }
+                        this.logger.info(`${this.node.name} completed successfully`);
+                        return `${this.node.name} succeeded`;
+                    }
+                    async run() {
+                        return this.executeStep();
+                    }
+                };
+            })();
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        return [
+                            new ChildWorkflow('SuccessChild', this, false),
+                            new ChildWorkflow('FailChild', this, true),
+                        ];
+                    }
+                    async run() {
+                        try {
+                            await this.spawnChildren();
+                        }
+                        catch (err) {
+                            // Expected
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const parent = new ParentWorkflow('Parent');
+            const allLogs = [];
+            parent.addObserver({
+                onLog: (entry) => allLogs.push(entry.message),
+                onEvent: () => { },
+                onStateUpdated: () => { },
+                onTreeChanged: () => { },
+            });
+            // ACT
+            await parent.run();
+            // ASSERT: Logs from both children captured
+            expect(allLogs.length).toBeGreaterThan(0);
+            // ASSERT: Success child logs present
+            expect(allLogs.some((msg) => msg.includes('SuccessChild is running'))).toBe(true);
+            expect(allLogs.some((msg) => msg.includes('SuccessChild completed successfully'))).toBe(true);
+            // ASSERT: Fail child logs present
+            expect(allLogs.some((msg) => msg.includes('FailChild is running'))).toBe(true);
+            expect(allLogs.some((msg) => msg.includes('FailChild is about to fail'))).toBe(true);
+        });
+    });
+    describe('Error collection correctness', () => {
+        it('should verify error messages are preserved correctly', async () => {
+            // ARRANGE: Create children with specific error messages
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        return [
+                            createChildWorkflow(this, 'Task-Alpha', false),
+                            createChildWorkflow(this, 'Task-Beta', true), // Will fail with "Task-Beta failed"
+                            createChildWorkflow(this, 'Task-Gamma', false),
+                        ];
+                    }
+                    async run() {
+                        try {
+                            await this.spawnChildren();
+                        }
+                        catch (err) {
+                            // Expected - error should be thrown
+                            return err;
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const parent = new ParentWorkflow('Parent');
+            const events = setupEventObserver(parent);
+            // ACT
+            const thrownError = await parent.run();
+            // ASSERT: Error was thrown
+            expect(thrownError).toBeDefined();
+            // ASSERT: Error message is preserved (WorkflowError wraps the original)
+            expect(thrownError.message).toContain('Task-Beta failed');
+            // ASSERT: Error events captured with correct messages
+            const errorEvents = events.filter((e) => e.type === 'error');
+            expect(errorEvents.length).toBeGreaterThanOrEqual(1);
+            const matchingError = errorEvents.find((e) => {
+                if (e.type === 'error') {
+                    return e.error.message.includes('Task-Beta');
+                }
+                return false;
+            });
+            expect(matchingError).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=concurrent-task-failures.test.js.map