groundswell 0.0.3 → 1.0.0

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

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