groundswell 0.0.1 → 0.0.3

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

@@ -0,0 +1,857 @@
+/**
+ * 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