groundswell 0.0.1 → 0.0.3

package/dist/__tests__/adversarial/deep-analysis.test.js

@@ -0,0 +1,877 @@
+/**
+ * Deep Analysis Tests
+ * These tests probe deeper into edge cases, error scenarios, and potential bugs
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { describe, it, expect } from 'vitest';
+import { Workflow, Step, Task, ObservedState } from '../../index.js';
+import { WorkflowTreeDebugger } from '../../debugger/tree-debugger.js';
+describe('Deep Analysis Tests', () => {
+    describe('Observable Edge Cases', () => {
+        it('should handle Observable.subscribe with empty observer object', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    this.emitEvent({ type: 'stepStart', node: this.node, step: 'test' });
+                }
+            }
+            const workflow = new TestWorkflow();
+            const debuggerInstance = new WorkflowTreeDebugger(workflow);
+            // Subscribe with empty observer - should not crash
+            debuggerInstance.events.subscribe({});
+            await workflow.run();
+        });
+        it('should handle Observable.unsubscribe during event emission', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    for (let i = 0; i < 10; i++) {
+                        this.emitEvent({ type: 'stepStart', node: this.node, step: `step-${i}` });
+                    }
+                }
+            }
+            const workflow = new TestWorkflow();
+            const debuggerInstance = new WorkflowTreeDebugger(workflow);
+            let count = 0;
+            const subscription = debuggerInstance.events.subscribe({
+                next: () => {
+                    count++;
+                    if (count === 5) {
+                        subscription.unsubscribe();
+                    }
+                },
+            });
+            await workflow.run();
+            // Should have received 5 events before unsubscribing
+            expect(count).toBe(5);
+        });
+    });
+    describe('WorkflowLogger Edge Cases', () => {
+        it('should handle logger.child() with empty parentLogId', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    const childLogger = this.logger.child('');
+                    childLogger.info('Child log with empty parent');
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+            expect(workflow.node.logs.length).toBe(1);
+            // Empty string is passed through as parentLogId
+            expect(workflow.node.logs[0].parentLogId).toBeUndefined();
+        });
+        it('should handle logger with very long messages', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    const longMessage = 'A'.repeat(10000);
+                    this.logger.info(longMessage);
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+            expect(workflow.node.logs[0].message.length).toBe(10000);
+        });
+        it('should handle logger with special characters in data', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    this.logger.info('Test', {
+                        null: null,
+                        undefined: undefined,
+                        circular: { self: null },
+                        function: () => { },
+                        symbol: Symbol('test'),
+                    });
+                }
+            }
+            const workflow = new TestWorkflow();
+            // Should not throw
+            await workflow.run();
+        });
+    });
+    describe('Step Decorator Edge Cases', () => {
+        it('should handle @Step on synchronous method that returns Promise', async () => {
+            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 Promise.resolve('done');
+                    }
+                    async run() {
+                        return this.testStep();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const result = await workflow.run();
+            expect(result).toBe('done');
+        });
+        it('should handle @Step that returns undefined', async () => {
+            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() {
+                        // No return
+                    }
+                    async run() {
+                        return this.testStep();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const result = await workflow.run();
+            expect(result).toBeUndefined();
+        });
+        it('should handle @Step that throws non-Error', async () => {
+            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() {
+                        throw 'string error';
+                    }
+                    async run() {
+                        try {
+                            await this.testStep();
+                        }
+                        catch (err) {
+                            // Non-Error throws get wrapped with 'Unknown error' message
+                            // but the original is preserved
+                            expect(err.message).toBe('Unknown error');
+                            expect(err.original).toBe('string error');
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            await workflow.run();
+        });
+        it('should handle @Step that throws null', async () => {
+            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() {
+                        throw null;
+                    }
+                    async run() {
+                        try {
+                            await this.testStep();
+                        }
+                        catch (err) {
+                            expect(err).not.toBeNull();
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            await workflow.run();
+        });
+    });
+    describe('Task Decorator Edge Cases', () => {
+        it('should handle @Task that returns primitive value', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _returnsString_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _returnsString_decorators = [Task()];
+                        __esDecorate(this, null, _returnsString_decorators, { kind: "method", name: "returnsString", static: false, private: false, access: { has: obj => "returnsString" in obj, get: obj => obj.returnsString }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async returnsString() {
+                        return 'not a workflow';
+                    }
+                    async run() {
+                        return this.returnsString();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const result = await workflow.run();
+            expect(result).toBe('not a workflow');
+            expect(workflow.children.length).toBe(0);
+        });
+        it('should handle @Task that returns number', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _returnsNumber_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _returnsNumber_decorators = [Task()];
+                        __esDecorate(this, null, _returnsNumber_decorators, { kind: "method", name: "returnsNumber", static: false, private: false, access: { has: obj => "returnsNumber" in obj, get: obj => obj.returnsNumber }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async returnsNumber() {
+                        return 42;
+                    }
+                    async run() {
+                        return this.returnsNumber();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const result = await workflow.run();
+            expect(result).toBe(42);
+        });
+        it('should handle @Task that returns object with id property (duck typing)', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _returnsDuck_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _returnsDuck_decorators = [Task()];
+                        __esDecorate(this, null, _returnsDuck_decorators, { kind: "method", name: "returnsDuck", static: false, private: false, access: { has: obj => "returnsDuck" in obj, get: obj => obj.returnsDuck }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async returnsDuck() {
+                        return { id: 'duck-123', name: 'Duck' };
+                    }
+                    async run() {
+                        return this.returnsDuck();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const result = await workflow.run();
+            // Duck typing - objects with 'id' property get parent attached
+            // The returned object is mutated to have a parent property
+            expect(result.id).toBe('duck-123');
+            expect(result.name).toBe('Duck');
+            expect(result.parent).toBeDefined();
+            // Duck typing treats it as a workflow and attaches it
+            expect(workflow.children.length).toBe(1);
+        });
+        it('should handle @Task with concurrent on single non-workflow', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _returnsString_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _returnsString_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _returnsString_decorators, { kind: "method", name: "returnsString", static: false, private: false, access: { has: obj => "returnsString" in obj, get: obj => obj.returnsString }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async returnsString() {
+                        return 'not a workflow';
+                    }
+                    async run() {
+                        return this.returnsString();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const result = await workflow.run();
+            expect(result).toBe('not a workflow');
+        });
+        it('should handle @Task with concurrent: true but no run method', async () => {
+            class ChildWorkflow extends Workflow {
+            }
+            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({ concurrent: true })];
+                        __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() {
+                        // Child will be attached but running it will throw
+                        return this.spawnChild();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new ParentWorkflow();
+            await workflow.run();
+            // Child should still be attached
+            expect(workflow.children.length).toBe(1);
+        });
+    });
+    describe('ObservedState Edge Cases', () => {
+        it('should handle undefined value in observed state', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _undefinedField_decorators;
+                let _undefinedField_initializers = [];
+                let _undefinedField_extraInitializers = [];
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _undefinedField_decorators = [ObservedState()];
+                        __esDecorate(null, null, _undefinedField_decorators, { kind: "field", name: "undefinedField", static: false, private: false, access: { has: obj => "undefinedField" in obj, get: obj => obj.undefinedField, set: (obj, value) => { obj.undefinedField = value; } }, metadata: _metadata }, _undefinedField_initializers, _undefinedField_extraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    undefinedField = __runInitializers(this, _undefinedField_initializers, undefined);
+                    async run() {
+                        this.snapshotState();
+                        return this.node.stateSnapshot;
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _undefinedField_extraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const snapshot = await workflow.run();
+            expect(snapshot?.undefinedField).toBeUndefined();
+        });
+        it('should handle circular reference in observed state', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _circular_decorators;
+                let _circular_initializers = [];
+                let _circular_extraInitializers = [];
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _circular_decorators = [ObservedState()];
+                        __esDecorate(null, null, _circular_decorators, { kind: "field", name: "circular", static: false, private: false, access: { has: obj => "circular" in obj, get: obj => obj.circular, set: (obj, value) => { obj.circular = value; } }, metadata: _metadata }, _circular_initializers, _circular_extraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    circular = __runInitializers(this, _circular_initializers, {});
+                    async run() {
+                        this.circular.self = this.circular;
+                        this.snapshotState();
+                        return this.node.stateSnapshot;
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _circular_extraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            // Should not crash
+            await workflow.run();
+        });
+        it('should handle deeply nested object in observed state', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _nested_decorators;
+                let _nested_initializers = [];
+                let _nested_extraInitializers = [];
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _nested_decorators = [ObservedState()];
+                        __esDecorate(null, null, _nested_decorators, { kind: "field", name: "nested", static: false, private: false, access: { has: obj => "nested" in obj, get: obj => obj.nested, set: (obj, value) => { obj.nested = value; } }, metadata: _metadata }, _nested_initializers, _nested_extraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    nested = __runInitializers(this, _nested_initializers, { level: 1 });
+                    async run() {
+                        for (let i = 2; i <= 100; i++) {
+                            this.nested = { level: i, child: this.nested };
+                        }
+                        this.snapshotState();
+                        return this.node.stateSnapshot;
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _nested_extraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const snapshot = await workflow.run();
+            expect(snapshot?.nested).toBeDefined();
+        });
+    });
+    describe('Workflow Construction Edge Cases', () => {
+        it('should handle Workflow with no arguments', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            const workflow = new TestWorkflow();
+            expect(workflow.node.name).toBe('TestWorkflow');
+            expect(workflow.parent).toBeNull();
+        });
+        it('should handle Workflow with only parent argument', async () => {
+            class ChildWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            class ParentWorkflow extends Workflow {
+                async run() {
+                    const child = new ChildWorkflow(undefined, this);
+                    expect(child.parent).toBe(this);
+                }
+            }
+            const workflow = new ParentWorkflow();
+            await workflow.run();
+        });
+        it('should handle functional workflow pattern', async () => {
+            const workflow = new Workflow({ name: 'FunctionalWorkflow' }, async (ctx) => {
+                await ctx.step('test', async () => {
+                    return 'done';
+                });
+            });
+            const result = await workflow.run();
+            expect(result).toBeDefined();
+        });
+    });
+    describe('Tree Debugger Edge Cases', () => {
+        it('should handle toTreeString on deep hierarchy', async () => {
+            // Create a root workflow with deep children
+            class RootWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            const root = new RootWorkflow();
+            let lastWorkflow = root;
+            // Build deep hierarchy
+            for (let i = 0; i < 20; i++) {
+                const ChildWorkflow = class extends Workflow {
+                    async run() {
+                        return 'done';
+                    }
+                };
+                const child = new ChildWorkflow(`Workflow-${i}`, lastWorkflow);
+                await child.run();
+                lastWorkflow = child;
+            }
+            // Create debugger on the root
+            const debuggerInstance = new WorkflowTreeDebugger(root);
+            const treeString = debuggerInstance.toTreeString();
+            expect(treeString.length).toBeGreaterThan(0);
+            expect(treeString.split('\n').length).toBeGreaterThan(20);
+        });
+        it('should handle toLogString on workflow with no logs', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    // No logs
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+            const debuggerInstance = new WorkflowTreeDebugger(workflow);
+            const logString = debuggerInstance.toLogString();
+            expect(typeof logString).toBe('string');
+        });
+        it('should handle getNode on non-existent ID', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            const workflow = new TestWorkflow();
+            const debuggerInstance = new WorkflowTreeDebugger(workflow);
+            const node = debuggerInstance.getNode('non-existent-id');
+            expect(node).toBeUndefined();
+        });
+        it('should handle getStats on complex tree', async () => {
+            let ChildWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _step_decorators;
+                return class ChildWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _step_decorators = [Step()];
+                        __esDecorate(this, null, _step_decorators, { kind: "method", name: "step", static: false, private: false, access: { has: obj => "step" in obj, get: obj => obj.step }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async step() {
+                        this.logger.info('Child log');
+                        return 'done';
+                    }
+                    async run() {
+                        return this.step();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        return [
+                            new ChildWorkflow('Child1', this),
+                            new ChildWorkflow('Child2', this),
+                            new ChildWorkflow('Child3', this),
+                        ];
+                    }
+                    async run() {
+                        await this.spawnChildren();
+                        await Promise.all(this.children.map(c => c.run()));
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new ParentWorkflow();
+            await workflow.run();
+            const debuggerInstance = new WorkflowTreeDebugger(workflow);
+            const stats = debuggerInstance.getStats();
+            expect(stats.totalNodes).toBe(4); // 1 parent + 3 children
+            expect(stats.totalLogs).toBeGreaterThan(0);
+            expect(stats.totalEvents).toBeGreaterThan(0);
+            expect(stats.byStatus).toBeDefined();
+        });
+    });
+    describe('Event Propagation Edge Cases', () => {
+        it('should handle events emitted during observer callback', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    let callCount = 0;
+                    this.addObserver({
+                        onLog: () => { },
+                        onEvent: () => {
+                            callCount++;
+                            // Emit another event during callback
+                            if (callCount === 1) {
+                                this.emitEvent({ type: 'stepStart', node: this.node, step: 'nested' });
+                            }
+                        },
+                        onStateUpdated: () => { },
+                        onTreeChanged: () => { },
+                    });
+                    this.emitEvent({ type: 'stepStart', node: this.node, step: 'initial' });
+                    expect(callCount).toBeGreaterThanOrEqual(1);
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+        });
+        it('should handle multiple observers with different behaviors', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    const results = {};
+                    this.addObserver({
+                        onLog: () => { results.observer1 = (results.observer1 || 0) + 1; },
+                        onEvent: () => { results.observer1 = (results.observer1 || 0) + 1; },
+                        onStateUpdated: () => { },
+                        onTreeChanged: () => { },
+                    });
+                    this.addObserver({
+                        onLog: () => { results.observer2 = (results.observer2 || 0) + 1; },
+                        onEvent: () => { results.observer2 = (results.observer2 || 0) + 1; },
+                        onStateUpdated: () => { },
+                        onTreeChanged: () => { },
+                    });
+                    this.emitEvent({ type: 'stepStart', node: this.node, step: 'test' });
+                    expect(results.observer1).toBeGreaterThan(0);
+                    expect(results.observer2).toBeGreaterThan(0);
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+        });
+    });
+    describe('State Transition Edge Cases', () => {
+        it('should handle status changes during execution', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    expect(this.status).toBe('idle');
+                    this.setStatus('running');
+                    expect(this.status).toBe('running');
+                    this.setStatus('completed');
+                    expect(this.status).toBe('completed');
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+        });
+        it('should handle invalid status values', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    // TypeScript should prevent this at compile time, but let's test runtime
+                    this.setStatus('invalid');
+                    // Status should be set (no validation at runtime)
+                    expect(this.status).toBe('invalid');
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+        });
+    });
+    describe('Child Attachment Edge Cases', () => {
+        it('should prevent attaching the same child twice', async () => {
+            class ChildWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            class ParentWorkflow extends Workflow {
+                async run() {
+                    const child = new ChildWorkflow('Child', this);
+                    // Try to attach again
+                    expect(() => {
+                        this.attachChild(child);
+                    }).toThrow('Child already attached');
+                }
+            }
+            const workflow = new ParentWorkflow();
+            await workflow.run();
+        });
+        it('should handle child with parent set in constructor', async () => {
+            class ChildWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            class ParentWorkflow extends Workflow {
+                async run() {
+                    const child = new ChildWorkflow('Child', this);
+                    // Child should already be attached
+                    expect(this.children.length).toBe(1);
+                    expect(this.children[0]).toBe(child);
+                }
+            }
+            const workflow = new ParentWorkflow();
+            await workflow.run();
+        });
+    });
+    describe('Memory and Resource Edge Cases', () => {
+        it('should handle rapid workflow creation and destruction', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            for (let i = 0; i < 100; i++) {
+                const workflow = new TestWorkflow(`Workflow-${i}`);
+                await workflow.run();
+            }
+            // If we got here without crashing, memory management is reasonable
+            expect(true).toBe(true);
+        });
+        it('should handle many observers on single workflow', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    this.emitEvent({ type: 'stepStart', node: this.node, step: 'test' });
+                }
+            }
+            const workflow = new TestWorkflow();
+            // Add 100 observers
+            for (let i = 0; i < 100; i++) {
+                workflow.addObserver({
+                    onLog: () => { },
+                    onEvent: () => { },
+                    onStateUpdated: () => { },
+                    onTreeChanged: () => { },
+                });
+            }
+            await workflow.run();
+            // Should complete without issues
+            expect(true).toBe(true);
+        });
+    });
+    describe('Error Recovery Edge Cases', () => {
+        it('should handle error in @Step followed by another @Step', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _failingStep_decorators;
+                let _successStep_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _failingStep_decorators = [Step()];
+                        _successStep_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(this, null, _successStep_decorators, { kind: "method", name: "successStep", static: false, private: false, access: { has: obj => "successStep" in obj, get: obj => obj.successStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async failingStep() {
+                        throw new Error('Failed');
+                    }
+                    async successStep() {
+                        return 'success';
+                    }
+                    async run() {
+                        try {
+                            await this.failingStep();
+                        }
+                        catch (err) {
+                            // Expected
+                        }
+                        return await this.successStep();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const result = await workflow.run();
+            expect(result).toBe('success');
+        });
+        it('should handle multiple sequential errors', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _errorStep1_decorators;
+                let _errorStep2_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _errorStep1_decorators = [Step()];
+                        _errorStep2_decorators = [Step()];
+                        __esDecorate(this, null, _errorStep1_decorators, { kind: "method", name: "errorStep1", static: false, private: false, access: { has: obj => "errorStep1" in obj, get: obj => obj.errorStep1 }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        __esDecorate(this, null, _errorStep2_decorators, { kind: "method", name: "errorStep2", static: false, private: false, access: { has: obj => "errorStep2" in obj, get: obj => obj.errorStep2 }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async errorStep1() {
+                        throw new Error('Error 1');
+                    }
+                    async errorStep2() {
+                        throw new Error('Error 2');
+                    }
+                    async run() {
+                        try {
+                            await this.errorStep1();
+                        }
+                        catch (err) {
+                            // Expected
+                        }
+                        try {
+                            await this.errorStep2();
+                        }
+                        catch (err) {
+                            // Expected
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            await workflow.run();
+            // Should have multiple error events
+            const errorEvents = workflow.node.events.filter(e => e.type === 'error');
+            expect(errorEvents.length).toBe(2);
+        });
+    });
+});
+//# sourceMappingURL=deep-analysis.test.js.map