groundswell 0.0.3 → 1.0.0

package/dist/__tests__/adversarial/edge-case.test.js

@@ -1,857 +0,0 @@
-/**
- * Adversarial and Edge Case Tests for Hierarchical Workflow Engine
- * These tests explore potential bugs, edge cases, and PRD compliance issues
- */
-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;
-};
-var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
-    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-};
-import { describe, it, expect } from 'vitest';
-import { Workflow, Step, Task, ObservedState } from '../../index.js';
-import { WorkflowTreeDebugger } from '../../debugger/tree-debugger.js';
-describe('Adversarial Edge Case Tests', () => {
-    describe('PRD Requirement: Step Decorator Defaults', () => {
-        /**
-         * PRD Section 8.1 specifies @Step options with defaults
-         * - trackTiming should be true by default (mentioned in skeleton but not explicit)
-         */
-        it('should track timing by default when trackTiming is not specified', async () => {
-            let stepEndEmitted = false;
-            let durationEmitted;
-            let TestWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _instanceExtraInitializers = [];
-                let _testStep_decorators;
-                return class TestWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _testStep_decorators = [Step()];
-                        __esDecorate(this, null, _testStep_decorators, { kind: "method", name: "testStep", static: false, private: false, access: { has: obj => "testStep" in obj, get: obj => obj.testStep }, metadata: _metadata }, null, _instanceExtraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    async testStep() {
-                        return 'done';
-                    }
-                    async run() {
-                        return this.testStep();
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _instanceExtraInitializers);
-                    }
-                };
-            })();
-            const workflow = new TestWorkflow();
-            const debuggerInstance = new WorkflowTreeDebugger(workflow);
-            // Subscribe to events correctly
-            debuggerInstance.events.subscribe({
-                next: (event) => {
-                    if (event.type === 'stepEnd') {
-                        stepEndEmitted = true;
-                        durationEmitted = event.duration;
-                    }
-                },
-            });
-            await workflow.run();
-            expect(stepEndEmitted).toBe(true);
-            expect(typeof durationEmitted).toBe('number');
-            expect(durationEmitted).toBeGreaterThanOrEqual(0);
-        });
-        it('should NOT track timing when explicitly set to false', async () => {
-            let stepEndEmitted = false;
-            let TestWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _instanceExtraInitializers = [];
-                let _testStep_decorators;
-                return class TestWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _testStep_decorators = [Step({ trackTiming: false })];
-                        __esDecorate(this, null, _testStep_decorators, { kind: "method", name: "testStep", static: false, private: false, access: { has: obj => "testStep" in obj, get: obj => obj.testStep }, metadata: _metadata }, null, _instanceExtraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    async testStep() {
-                        return 'done';
-                    }
-                    async run() {
-                        return this.testStep();
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _instanceExtraInitializers);
-                    }
-                };
-            })();
-            const workflow = new TestWorkflow();
-            const debuggerInstance = new WorkflowTreeDebugger(workflow);
-            debuggerInstance.events.subscribe({
-                next: (event) => {
-                    if (event.type === 'stepEnd') {
-                        stepEndEmitted = true;
-                    }
-                },
-            });
-            await workflow.run();
-            // stepEnd should NOT be emitted when trackTiming is false
-            // This is based on the implementation: trackTiming !== false controls emission
-            expect(stepEndEmitted).toBe(false);
-        });
-    });
-    describe('PRD Requirement: WorkflowLogger.child() Behavior', () => {
-        /**
-         * PRD Section 12.1 shows WorkflowLogger.child(meta: Partial<LogEntry>)
-         * But implementation shows: child(parentLogId: string)
-         * This is a mismatch between PRD and implementation
-         */
-        it('should have child() method that accepts parentLogId', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    // Access logger to verify child method exists
-                    const childLogger = this.logger.child('parent-id-123');
-                    expect(childLogger).toBeDefined();
-                }
-            }
-            const workflow = new TestWorkflow();
-            await workflow.run();
-        });
-    });
-    describe('Edge Case: Empty and Null Values', () => {
-        it('should reject empty string workflow name', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    return 'done';
-                }
-            }
-            expect(() => new TestWorkflow('')).toThrow('Workflow name cannot be empty or whitespace only');
-        });
-        it('should handle null and undefined observed state values', async () => {
-            let TestWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _nullableValue_decorators;
-                let _nullableValue_initializers = [];
-                let _nullableValue_extraInitializers = [];
-                let _undefinedValue_decorators;
-                let _undefinedValue_initializers = [];
-                let _undefinedValue_extraInitializers = [];
-                let _emptyValue_decorators;
-                let _emptyValue_initializers = [];
-                let _emptyValue_extraInitializers = [];
-                return class TestWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _nullableValue_decorators = [ObservedState()];
-                        _undefinedValue_decorators = [ObservedState()];
-                        _emptyValue_decorators = [ObservedState()];
-                        __esDecorate(null, null, _nullableValue_decorators, { kind: "field", name: "nullableValue", static: false, private: false, access: { has: obj => "nullableValue" in obj, get: obj => obj.nullableValue, set: (obj, value) => { obj.nullableValue = value; } }, metadata: _metadata }, _nullableValue_initializers, _nullableValue_extraInitializers);
-                        __esDecorate(null, null, _undefinedValue_decorators, { kind: "field", name: "undefinedValue", static: false, private: false, access: { has: obj => "undefinedValue" in obj, get: obj => obj.undefinedValue, set: (obj, value) => { obj.undefinedValue = value; } }, metadata: _metadata }, _undefinedValue_initializers, _undefinedValue_extraInitializers);
-                        __esDecorate(null, null, _emptyValue_decorators, { kind: "field", name: "emptyValue", static: false, private: false, access: { has: obj => "emptyValue" in obj, get: obj => obj.emptyValue, set: (obj, value) => { obj.emptyValue = value; } }, metadata: _metadata }, _emptyValue_initializers, _emptyValue_extraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    nullableValue = __runInitializers(this, _nullableValue_initializers, null);
-                    undefinedValue = (__runInitializers(this, _nullableValue_extraInitializers), __runInitializers(this, _undefinedValue_initializers, undefined));
-                    emptyValue = (__runInitializers(this, _undefinedValue_extraInitializers), __runInitializers(this, _emptyValue_initializers, ''));
-                    async run() {
-                        this.snapshotState();
-                        return this.node.stateSnapshot;
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _emptyValue_extraInitializers);
-                    }
-                };
-            })();
-            const workflow = new TestWorkflow();
-            const snapshot = await workflow.run();
-            expect(snapshot).toHaveProperty('nullableValue', null);
-            expect(snapshot).toHaveProperty('undefinedValue', undefined);
-            expect(snapshot).toHaveProperty('emptyValue', '');
-        });
-        it('should handle empty array from @Task', async () => {
-            class ChildWorkflow extends Workflow {
-                async run() {
-                    return 'child';
-                }
-            }
-            let ParentWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _instanceExtraInitializers = [];
-                let _returnsEmpty_decorators;
-                return class ParentWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _returnsEmpty_decorators = [Task()];
-                        __esDecorate(this, null, _returnsEmpty_decorators, { kind: "method", name: "returnsEmpty", static: false, private: false, access: { has: obj => "returnsEmpty" in obj, get: obj => obj.returnsEmpty }, metadata: _metadata }, null, _instanceExtraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    async returnsEmpty() {
-                        return [];
-                    }
-                    async run() {
-                        return this.returnsEmpty();
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _instanceExtraInitializers);
-                    }
-                };
-            })();
-            const workflow = new ParentWorkflow();
-            const result = await workflow.run();
-            expect(Array.isArray(result)).toBe(true);
-            expect(result.length).toBe(0);
-        });
-        it('should handle null return from @Task', async () => {
-            let ParentWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _instanceExtraInitializers = [];
-                let _returnsNull_decorators;
-                return class ParentWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _returnsNull_decorators = [Task()];
-                        __esDecorate(this, null, _returnsNull_decorators, { kind: "method", name: "returnsNull", static: false, private: false, access: { has: obj => "returnsNull" in obj, get: obj => obj.returnsNull }, metadata: _metadata }, null, _instanceExtraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    async returnsNull() {
-                        return null;
-                    }
-                    async run() {
-                        return this.returnsNull();
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _instanceExtraInitializers);
-                    }
-                };
-            })();
-            const workflow = new ParentWorkflow();
-            const result = await workflow.run();
-            expect(result).toBe(null);
-        });
-        it('should handle undefined return from @Task', async () => {
-            let ParentWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _instanceExtraInitializers = [];
-                let _returnsUndefined_decorators;
-                return class ParentWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _returnsUndefined_decorators = [Task()];
-                        __esDecorate(this, null, _returnsUndefined_decorators, { kind: "method", name: "returnsUndefined", static: false, private: false, access: { has: obj => "returnsUndefined" in obj, get: obj => obj.returnsUndefined }, metadata: _metadata }, null, _instanceExtraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    async returnsUndefined() {
-                        return undefined;
-                    }
-                    async run() {
-                        return this.returnsUndefined();
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _instanceExtraInitializers);
-                    }
-                };
-            })();
-            const workflow = new ParentWorkflow();
-            const result = await workflow.run();
-            expect(result).toBe(undefined);
-        });
-    });
-    describe('Edge Case: Unicode and Special Characters', () => {
-        it('should handle unicode in workflow names', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    return 'done';
-                }
-            }
-            const unicodeNames = [
-                '🚀 Rocket',
-                '测试工作流',
-                'العملية',
-                '🎯Target',
-            ];
-            for (const name of unicodeNames) {
-                const workflow = new TestWorkflow(name);
-                expect(workflow.node.name).toBe(name);
-                await workflow.run();
-            }
-        });
-        it('should handle unicode in log messages', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    this.logger.info('测试消息 🚀');
-                    this.logger.warn('⚠️ Warning');
-                    this.logger.error('❌ Error with emoji');
-                }
-            }
-            const workflow = new TestWorkflow();
-            await workflow.run();
-            expect(workflow.node.logs.length).toBe(3);
-            expect(workflow.node.logs[0].message).toBe('测试消息 🚀');
-        });
-        it('should handle unicode in observed state values', async () => {
-            let TestWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _unicodeField_decorators;
-                let _unicodeField_initializers = [];
-                let _unicodeField_extraInitializers = [];
-                return class TestWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _unicodeField_decorators = [ObservedState()];
-                        __esDecorate(null, null, _unicodeField_decorators, { kind: "field", name: "unicodeField", static: false, private: false, access: { has: obj => "unicodeField" in obj, get: obj => obj.unicodeField, set: (obj, value) => { obj.unicodeField = value; } }, metadata: _metadata }, _unicodeField_initializers, _unicodeField_extraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    unicodeField = __runInitializers(this, _unicodeField_initializers, '测试 🎯');
-                    async run() {
-                        this.snapshotState();
-                        return this.node.stateSnapshot;
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _unicodeField_extraInitializers);
-                    }
-                };
-            })();
-            const workflow = new TestWorkflow();
-            const snapshot = await workflow.run();
-            expect(snapshot?.unicodeField).toBe('测试 🎯');
-        });
-    });
-    describe('Edge Case: Deep Hierarchies', () => {
-        it('should handle very deep workflow hierarchies', async () => {
-            // Create a chain of 100 nested workflows
-            let lastWorkflow = null;
-            for (let i = 0; i < 100; i++) {
-                const name = `Workflow-${i}`;
-                const DynamicWorkflow = (() => {
-                    let _classSuper = Workflow;
-                    let _instanceExtraInitializers = [];
-                    let _doWork_decorators;
-                    return class extends _classSuper {
-                        static { __setFunctionName(this, "DynamicWorkflow"); }
-                        static {
-                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                            _doWork_decorators = [Step()];
-                            __esDecorate(this, null, _doWork_decorators, { kind: "method", name: "doWork", static: false, private: false, access: { has: obj => "doWork" in obj, get: obj => obj.doWork }, metadata: _metadata }, null, _instanceExtraInitializers);
-                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                        }
-                        async doWork() {
-                            return `level-${i}`;
-                        }
-                        async run() {
-                            return this.doWork();
-                        }
-                        constructor() {
-                            super(...arguments);
-                            __runInitializers(this, _instanceExtraInitializers);
-                        }
-                    };
-                })();
-                lastWorkflow = new DynamicWorkflow(name, lastWorkflow);
-            }
-            await lastWorkflow.run();
-            // Verify hierarchy depth
-            let depth = 0;
-            let current = lastWorkflow;
-            while (current.parent) {
-                depth++;
-                current = current.parent;
-            }
-            expect(depth).toBe(99);
-        });
-        it('should handle wide workflow hierarchies (many siblings)', async () => {
-            let ChildWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _instanceExtraInitializers = [];
-                let _doWork_decorators;
-                return class ChildWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _doWork_decorators = [Step()];
-                        __esDecorate(this, null, _doWork_decorators, { kind: "method", name: "doWork", static: false, private: false, access: { has: obj => "doWork" in obj, get: obj => obj.doWork }, metadata: _metadata }, null, _instanceExtraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    async doWork() {
-                        return 'child-work';
-                    }
-                    async run() {
-                        return this.doWork();
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _instanceExtraInitializers);
-                    }
-                };
-            })();
-            let ParentWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _instanceExtraInitializers = [];
-                let _spawnMany_decorators;
-                return class ParentWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _spawnMany_decorators = [Task({ concurrent: true })];
-                        __esDecorate(this, null, _spawnMany_decorators, { kind: "method", name: "spawnMany", static: false, private: false, access: { has: obj => "spawnMany" in obj, get: obj => obj.spawnMany }, metadata: _metadata }, null, _instanceExtraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    async spawnMany() {
-                        return Array.from({ length: 50 }, (_, i) => new ChildWorkflow(`Child-${i}`, this));
-                    }
-                    async run() {
-                        return this.spawnMany();
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _instanceExtraInitializers);
-                    }
-                };
-            })();
-            const workflow = new ParentWorkflow();
-            await workflow.run();
-            expect(workflow.children.length).toBe(50);
-        });
-    });
-    describe('Edge Case: Rapid State Changes', () => {
-        it('should handle rapid status changes', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    this.setStatus('running');
-                    this.setStatus('running');
-                    this.setStatus('running');
-                    this.setStatus('completed');
-                }
-            }
-            const workflow = new TestWorkflow();
-            await workflow.run();
-            expect(workflow.status).toBe('completed');
-            expect(workflow.node.status).toBe('completed');
-        });
-        it('should handle multiple rapid snapshots', async () => {
-            let TestWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _counter_decorators;
-                let _counter_initializers = [];
-                let _counter_extraInitializers = [];
-                return class TestWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _counter_decorators = [ObservedState()];
-                        __esDecorate(null, null, _counter_decorators, { kind: "field", name: "counter", static: false, private: false, access: { has: obj => "counter" in obj, get: obj => obj.counter, set: (obj, value) => { obj.counter = value; } }, metadata: _metadata }, _counter_initializers, _counter_extraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    counter = __runInitializers(this, _counter_initializers, 0);
-                    async run() {
-                        for (let i = 0; i < 10; i++) {
-                            this.counter = i;
-                            this.snapshotState();
-                        }
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _counter_extraInitializers);
-                    }
-                };
-            })();
-            const workflow = new TestWorkflow();
-            await workflow.run();
-            expect(workflow.node.stateSnapshot?.counter).toBe(9);
-        });
-    });
-    describe('Edge Case: Concurrent Execution', () => {
-        it('should handle concurrent task execution with errors', async () => {
-            class GoodChild extends Workflow {
-                async run() {
-                    return 'good';
-                }
-            }
-            class BadChild extends Workflow {
-                async run() {
-                    throw new Error('Bad child error');
-                }
-            }
-            let ParentWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _instanceExtraInitializers = [];
-                let _spawnMixed_decorators;
-                return class ParentWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _spawnMixed_decorators = [Task({ concurrent: true })];
-                        __esDecorate(this, null, _spawnMixed_decorators, { kind: "method", name: "spawnMixed", static: false, private: false, access: { has: obj => "spawnMixed" in obj, get: obj => obj.spawnMixed }, metadata: _metadata }, null, _instanceExtraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    async spawnMixed() {
-                        return [
-                            new GoodChild('Good', this),
-                            new BadChild('Bad', this),
-                        ];
-                    }
-                    async run() {
-                        // This should throw because concurrent runs happen
-                        try {
-                            await this.spawnMixed();
-                        }
-                        catch (err) {
-                            // Expected to throw
-                        }
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _instanceExtraInitializers);
-                    }
-                };
-            })();
-            const workflow = new ParentWorkflow();
-            await workflow.run();
-            // Both children should be attached
-            expect(workflow.children.length).toBe(2);
-        });
-        it('should handle @Task with concurrent: true on single workflow', async () => {
-            class ChildWorkflow extends Workflow {
-                async run() {
-                    return 'child-result';
-                }
-            }
-            let ParentWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _instanceExtraInitializers = [];
-                let _spawnOne_decorators;
-                return class ParentWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _spawnOne_decorators = [Task({ concurrent: true })];
-                        __esDecorate(this, null, _spawnOne_decorators, { kind: "method", name: "spawnOne", static: false, private: false, access: { has: obj => "spawnOne" in obj, get: obj => obj.spawnOne }, metadata: _metadata }, null, _instanceExtraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    async spawnOne() {
-                        return new ChildWorkflow('SingleChild', this);
-                    }
-                    async run() {
-                        return this.spawnOne();
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _instanceExtraInitializers);
-                    }
-                };
-            })();
-            const workflow = new ParentWorkflow();
-            const result = await workflow.run();
-            // Single workflow should still be returned
-            expect(result).toBeDefined();
-            expect(workflow.children.length).toBe(1);
-        });
-    });
-    describe('Edge Case: Observers and Event Handling', () => {
-        it('should handle observer that throws errors', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    this.emitEvent({ type: 'stepStart', node: this.node, step: 'test' });
-                }
-            }
-            const workflow = new TestWorkflow();
-            // Add an observer that throws
-            workflow.addObserver({
-                onLog: () => {
-                    throw new Error('Observer error');
-                },
-                onEvent: () => {
-                    throw new Error('Event observer error');
-                },
-                onStateUpdated: () => {
-                    throw new Error('State observer error');
-                },
-                onTreeChanged: () => {
-                    throw new Error('Tree observer error');
-                },
-            });
-            // Should not throw, errors are caught and console.error'd
-            await workflow.run();
-        });
-        it('should handle multiple observers', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    this.emitEvent({ type: 'stepStart', node: this.node, step: 'test' });
-                }
-            }
-            const workflow = new TestWorkflow();
-            const counts = { onLog: 0, onEvent: 0, onStateUpdated: 0, onTreeChanged: 0 };
-            // Add multiple observers
-            for (let i = 0; i < 5; i++) {
-                workflow.addObserver({
-                    onLog: () => counts.onLog++,
-                    onEvent: () => counts.onEvent++,
-                    onStateUpdated: () => counts.onStateUpdated++,
-                    onTreeChanged: () => counts.onTreeChanged++,
-                });
-            }
-            await workflow.run();
-            // Each observer should have been called
-            expect(counts.onEvent).toBe(5);
-        });
-    });
-    describe('Edge Case: Circular References', () => {
-        it('should detect circular parent-child relationships', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    return 'done';
-                }
-            }
-            const parent = new TestWorkflow('Parent');
-            const child = new TestWorkflow('Child', parent);
-            // Try to create a circular reference
-            expect(() => {
-                parent.attachChild(child); // This should throw
-            }).toThrow('Child already attached');
-        });
-        it('should prevent creating cycles through getRoot', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    return 'done';
-                }
-            }
-            const root = new TestWorkflow('Root');
-            const child = new TestWorkflow('Child', root);
-            // getRoot should work correctly
-            const rootFromChild = child.getRoot();
-            expect(rootFromChild.id).toBe(root.id);
-        });
-    });
-    describe('Edge Case: Memory and Performance', () => {
-        it('should handle large number of events', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    for (let i = 0; i < 1000; i++) {
-                        this.emitEvent({ type: 'stepStart', node: this.node, step: `step-${i}` });
-                    }
-                }
-            }
-            const workflow = new TestWorkflow();
-            await workflow.run();
-            expect(workflow.node.events.length).toBe(1000);
-        });
-        it('should handle large number of logs', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    for (let i = 0; i < 1000; i++) {
-                        this.logger.info(`Log entry ${i}`);
-                    }
-                }
-            }
-            const workflow = new TestWorkflow();
-            await workflow.run();
-            expect(workflow.node.logs.length).toBe(1000);
-        });
-    });
-    describe('PRD Compliance: Error Event Format', () => {
-        /**
-         * PRD Section 5.1 specifies WorkflowError interface
-         * Verifying the error structure matches PRD
-         */
-        it('should emit error with all required fields', async () => {
-            let TestWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _instanceExtraInitializers = [];
-                let _testField_decorators;
-                let _testField_initializers = [];
-                let _testField_extraInitializers = [];
-                let _failingStep_decorators;
-                return class TestWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _testField_decorators = [ObservedState()];
-                        _failingStep_decorators = [Step()];
-                        __esDecorate(this, null, _failingStep_decorators, { kind: "method", name: "failingStep", static: false, private: false, access: { has: obj => "failingStep" in obj, get: obj => obj.failingStep }, metadata: _metadata }, null, _instanceExtraInitializers);
-                        __esDecorate(null, null, _testField_decorators, { kind: "field", name: "testField", static: false, private: false, access: { has: obj => "testField" in obj, get: obj => obj.testField, set: (obj, value) => { obj.testField = value; } }, metadata: _metadata }, _testField_initializers, _testField_extraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    testField = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _testField_initializers, 'test-value'));
-                    async failingStep() {
-                        this.logger.info('About to fail');
-                        throw new Error('Test error');
-                    }
-                    async run() {
-                        try {
-                            await this.failingStep();
-                        }
-                        catch (err) {
-                            // Expected
-                        }
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _testField_extraInitializers);
-                    }
-                };
-            })();
-            const workflow = new TestWorkflow();
-            let capturedError = null;
-            workflow.addObserver({
-                onLog: () => { },
-                onEvent: (event) => {
-                    if (event.type === 'error') {
-                        capturedError = event.error;
-                    }
-                },
-                onStateUpdated: () => { },
-                onTreeChanged: () => { },
-            });
-            await workflow.run();
-            expect(capturedError).not.toBeNull();
-            expect(capturedError.message).toBe('Test error');
-            expect(capturedError.workflowId).toBe(workflow.id);
-            expect(capturedError.original).toBeDefined();
-            expect(capturedError.state).toBeDefined();
-            expect(capturedError.logs).toBeDefined();
-            expect(Array.isArray(capturedError.logs)).toBe(true);
-        });
-    });
-    describe('PRD Compliance: Event Types', () => {
-        /**
-         * PRD Section 4.2 specifies all WorkflowEvent types
-         * Verifying all event types are properly emitted
-         */
-        it('should emit childAttached event', async () => {
-            class ChildWorkflow extends Workflow {
-                async run() {
-                    return 'child';
-                }
-            }
-            let ParentWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _instanceExtraInitializers = [];
-                let _spawnChild_decorators;
-                return class ParentWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _spawnChild_decorators = [Task()];
-                        __esDecorate(this, null, _spawnChild_decorators, { kind: "method", name: "spawnChild", static: false, private: false, access: { has: obj => "spawnChild" in obj, get: obj => obj.spawnChild }, metadata: _metadata }, null, _instanceExtraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    async spawnChild() {
-                        return new ChildWorkflow('Child', this);
-                    }
-                    async run() {
-                        return this.spawnChild();
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _instanceExtraInitializers);
-                    }
-                };
-            })();
-            const workflow = new ParentWorkflow();
-            let childAttachedFired = false;
-            workflow.addObserver({
-                onLog: () => { },
-                onEvent: (event) => {
-                    if (event.type === 'childAttached') {
-                        childAttachedFired = true;
-                        expect(event.parentId).toBe(workflow.id);
-                        expect(event.child).toBeDefined();
-                    }
-                },
-                onStateUpdated: () => { },
-                onTreeChanged: () => { },
-            });
-            await workflow.run();
-            expect(childAttachedFired).toBe(true);
-        });
-        it('should emit stateSnapshot event', async () => {
-            let TestWorkflow = (() => {
-                let _classSuper = Workflow;
-                let _testField_decorators;
-                let _testField_initializers = [];
-                let _testField_extraInitializers = [];
-                return class TestWorkflow extends _classSuper {
-                    static {
-                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-                        _testField_decorators = [ObservedState()];
-                        __esDecorate(null, null, _testField_decorators, { kind: "field", name: "testField", static: false, private: false, access: { has: obj => "testField" in obj, get: obj => obj.testField, set: (obj, value) => { obj.testField = value; } }, metadata: _metadata }, _testField_initializers, _testField_extraInitializers);
-                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-                    }
-                    testField = __runInitializers(this, _testField_initializers, 'value');
-                    async run() {
-                        this.snapshotState();
-                    }
-                    constructor() {
-                        super(...arguments);
-                        __runInitializers(this, _testField_extraInitializers);
-                    }
-                };
-            })();
-            const workflow = new TestWorkflow();
-            let snapshotFired = false;
-            workflow.addObserver({
-                onLog: () => { },
-                onEvent: (event) => {
-                    if (event.type === 'stateSnapshot') {
-                        snapshotFired = true;
-                        expect(event.node).toBeDefined();
-                    }
-                },
-                onStateUpdated: () => { },
-                onTreeChanged: () => { },
-            });
-            await workflow.run();
-            expect(snapshotFired).toBe(true);
-        });
-        it('should emit treeUpdated event', async () => {
-            class TestWorkflow extends Workflow {
-                async run() {
-                    this.emitEvent({ type: 'treeUpdated', root: this.node });
-                }
-            }
-            const workflow = new TestWorkflow();
-            let treeUpdatedFired = false;
-            workflow.addObserver({
-                onLog: () => { },
-                onEvent: (event) => {
-                    if (event.type === 'treeUpdated') {
-                        treeUpdatedFired = true;
-                    }
-                },
-                onStateUpdated: () => { },
-                onTreeChanged: () => { },
-            });
-            await workflow.run();
-            expect(treeUpdatedFired).toBe(true);
-        });
-    });
-});
-//# sourceMappingURL=edge-case.test.js.map