groundswell 0.0.2 → 0.0.3

package/dist/__tests__/compatibility/backward-compatibility.test.js

@@ -0,0 +1,1843 @@
+/**
+ * Backward Compatibility Test Suite
+ *
+ * Comprehensive tests that validate all existing API usage patterns continue to work
+ * after bug fixes, and ensures breaking changes fail with clear, actionable error
+ * messages directing users to the correct migration path.
+ *
+ * Related:
+ * - PRP: P1.M4.T3.S2 - Backward Compatibility Testing
+ * - Breaking Changes Audit: plan/.../P1M4T3S1/BREAKING_CHANGES_AUDIT.md
+ *
+ * Test Coverage:
+ * 1. Breaking Change: Workflow name validation (LOW severity)
+ * 2. Backward Compatible: WorkflowLogger.child() string API
+ * 3. Backward Compatible: Promise.allSettled default behavior
+ * 4. Documentation Examples: README quick start patterns
+ * 5. Example Files: All 11 runnable examples
+ * 6. Decorator Patterns: @Step, @Task, @ObservedState options
+ * 7. Parent-Child Patterns: Hierarchical workflow creation
+ */
+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, getObservedState, WorkflowTreeDebugger, createWorkflow, } from '../../index.js';
+// ============================================================================
+// Section 1: Breaking Changes - Workflow Name Validation
+// ============================================================================
+// Severity: LOW
+// Impact: Constructor rejects empty/whitespace/long names
+// Migration: Provide valid names (simple fix)
+// ============================================================================
+describe('Backward Compatibility Tests', () => {
+    describe('Breaking Changes - Workflow Name Validation', () => {
+        describe('Class-based constructor pattern', () => {
+            class TestWorkflow extends Workflow {
+                constructor(name) {
+                    super(name);
+                }
+                async run() {
+                    this.setStatus('running');
+                    this.setStatus('completed');
+                    return 'done';
+                }
+            }
+            it('should throw descriptive error for empty string name', () => {
+                expect(() => new TestWorkflow(''))
+                    .toThrow('Workflow name cannot be empty or whitespace only');
+            });
+            it('should throw descriptive error for whitespace-only name (spaces)', () => {
+                expect(() => new TestWorkflow('   '))
+                    .toThrow('Workflow name cannot be empty or whitespace only');
+            });
+            it('should throw descriptive error for whitespace-only name (tabs)', () => {
+                expect(() => new TestWorkflow('\t\t'))
+                    .toThrow('Workflow name cannot be empty or whitespace only');
+            });
+            it('should throw descriptive error for whitespace-only name (newlines)', () => {
+                expect(() => new TestWorkflow('\n\n'))
+                    .toThrow('Workflow name cannot be empty or whitespace only');
+            });
+            it('should throw descriptive error for whitespace-only name (mixed)', () => {
+                expect(() => new TestWorkflow('  \t\n  '))
+                    .toThrow('Workflow name cannot be empty or whitespace only');
+            });
+            it('should throw descriptive error for name exceeding 100 characters', () => {
+                const longName = 'a'.repeat(101);
+                expect(() => new TestWorkflow(longName))
+                    .toThrow('Workflow name cannot exceed 100 characters');
+            });
+            it('should accept name with exactly 100 characters', () => {
+                const exactly100 = 'a'.repeat(100);
+                const wf = new TestWorkflow(exactly100);
+                expect(wf.getNode().name).toBe(exactly100);
+                expect(wf.getNode().name.length).toBe(100);
+            });
+            it('should accept valid names with leading/trailing whitespace', () => {
+                const wf1 = new TestWorkflow('  MyWorkflow  ');
+                expect(wf1.getNode().name).toBe('  MyWorkflow  ');
+                const wf2 = new TestWorkflow('\tValidName\t');
+                expect(wf2.getNode().name).toBe('\tValidName\t');
+            });
+            it('should use class name when name is undefined', () => {
+                const wf = new TestWorkflow();
+                expect(wf.getNode().name).toBe('TestWorkflow');
+            });
+            it('should use class name when name is null', () => {
+                const wf = new TestWorkflow(null);
+                expect(wf.getNode().name).toBe('TestWorkflow');
+            });
+        });
+        describe('Functional constructor pattern', () => {
+            it('should throw descriptive error for empty string name', () => {
+                expect(() => new Workflow({ name: '' }, async () => { }))
+                    .toThrow('Workflow name cannot be empty or whitespace only');
+            });
+            it('should throw descriptive error for whitespace name', () => {
+                expect(() => new Workflow({ name: '   ' }, async () => { }))
+                    .toThrow('Workflow name cannot be empty or whitespace only');
+            });
+            it('should throw descriptive error for name exceeding 100 characters', () => {
+                const longName = 'a'.repeat(101);
+                expect(() => new Workflow({ name: longName }, async () => { }))
+                    .toThrow('Workflow name cannot exceed 100 characters');
+            });
+            it('should accept valid name in functional pattern', async () => {
+                const wf = new Workflow({ name: 'ValidFunctionalWorkflow' }, async () => 'done');
+                expect(wf.getNode().name).toBe('ValidFunctionalWorkflow');
+            });
+        });
+        describe('Error message clarity and actionability', () => {
+            it('should provide clear error message for empty name', () => {
+                expect(() => new Workflow({ name: '' }, async () => { }))
+                    .toThrow('Workflow name cannot be empty or whitespace only');
+            });
+            it('should provide clear error message for long name', () => {
+                expect(() => new Workflow({ name: 'a'.repeat(101) }, async () => { }))
+                    .toThrow('Workflow name cannot exceed 100 characters');
+            });
+        });
+    });
+    // ============================================================================
+    // Section 2: Backward Compatible Changes - WorkflowLogger.child()
+    // ============================================================================
+    // Change: child() now accepts Partial<LogEntry> in addition to string
+    // Backward Compatibility: String-based API still works via function overloads
+    // ============================================================================
+    describe('Backward Compatible Changes - WorkflowLogger.child()', () => {
+        describe('String-based API (backward compatible)', () => {
+            it('should support string-based logger.child() with parentLogId', async () => {
+                class TestWorkflow extends Workflow {
+                    async run() {
+                        // Old API - should still work
+                        const childLogger = this.logger.child('parent-log-id');
+                        childLogger.info('Test message');
+                    }
+                }
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                expect(workflow.getNode().logs[0].parentLogId).toBe('parent-log-id');
+            });
+            it('should support string-based logger.child() with all log levels', async () => {
+                class TestWorkflow extends Workflow {
+                    async run() {
+                        const childLogger = this.logger.child('test-parent');
+                        childLogger.debug('Debug message');
+                        childLogger.info('Info message');
+                        childLogger.warn('Warn message');
+                        childLogger.error('Error message');
+                    }
+                }
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                expect(workflow.getNode().logs.length).toBe(4);
+                expect(workflow.getNode().logs[0].parentLogId).toBe('test-parent');
+                expect(workflow.getNode().logs[0].level).toBe('debug');
+                expect(workflow.getNode().logs[1].level).toBe('info');
+                expect(workflow.getNode().logs[2].level).toBe('warn');
+                expect(workflow.getNode().logs[3].level).toBe('error');
+            });
+            it('should support string-based logger.child() with data parameter', async () => {
+                class TestWorkflow extends Workflow {
+                    async run() {
+                        const childLogger = this.logger.child('data-parent');
+                        childLogger.info('Message with data', { key: 'value', count: 42 });
+                    }
+                }
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                expect(workflow.getNode().logs[0].parentLogId).toBe('data-parent');
+                expect(workflow.getNode().logs[0].data).toEqual({ key: 'value', count: 42 });
+            });
+            it('should handle empty string (results in undefined parentLogId)', async () => {
+                class TestWorkflow extends Workflow {
+                    async run() {
+                        const childLogger = this.logger.child('');
+                        childLogger.info('Test message');
+                    }
+                }
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                // Empty string is falsy, so parentLogId becomes undefined
+                expect(workflow.getNode().logs[0].parentLogId).toBeUndefined();
+            });
+        });
+        describe('New API - Partial<LogEntry> syntax (also backward compatible)', () => {
+            it('should support new object-based logger.child() API', async () => {
+                class TestWorkflow extends Workflow {
+                    async run() {
+                        // New API - should work alongside old API
+                        const childLogger = this.logger.child({ parentLogId: 'parent-log-id' });
+                        childLogger.info('Test message');
+                    }
+                }
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                expect(workflow.getNode().logs[0].parentLogId).toBe('parent-log-id');
+            });
+        });
+        describe('Parent-child log hierarchy (backward compatible)', () => {
+            it('should support multi-level nesting with string-based child loggers', async () => {
+                class TestWorkflow extends Workflow {
+                    async run() {
+                        // Root log
+                        this.logger.info('Root message');
+                        const rootLogId = this.node.logs[0].id;
+                        // First level child - using string API (backward compatible)
+                        const child1 = this.logger.child(rootLogId);
+                        child1.info('Level 1 child');
+                        const level1LogId = this.node.logs[1].id;
+                        // Second level child - using string API
+                        const child2 = this.logger.child(level1LogId);
+                        child2.info('Level 2 child');
+                    }
+                }
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                expect(workflow.getNode().logs.length).toBe(3);
+                expect(workflow.getNode().logs[0].parentLogId).toBeUndefined();
+                expect(workflow.getNode().logs[1].parentLogId).toBe(workflow.getNode().logs[0].id);
+                expect(workflow.getNode().logs[2].parentLogId).toBe(workflow.getNode().logs[1].id);
+            });
+        });
+    });
+    // ============================================================================
+    // Section 3: Backward Compatible Changes - Promise.allSettled Default Behavior
+    // ============================================================================
+    // Change: @Task with concurrent: true now uses Promise.allSettled()
+    // Backward Compatibility: Default behavior unchanged - throws first error
+    // ============================================================================
+    describe('Backward Compatible Changes - Promise.allSettled Default Behavior', () => {
+        // Helper to create a child workflow that may fail
+        function createChildWorkflow(parent, name, shouldFail = false) {
+            return new ((() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _executeStep_decorators;
+                return class extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _executeStep_decorators = [Step()];
+                        __esDecorate(this, null, _executeStep_decorators, { kind: "method", name: "executeStep", static: false, private: false, access: { has: obj => "executeStep" in obj, get: obj => obj.executeStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    constructor(n, p) {
+                        super(n, p);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                    async executeStep() {
+                        if (shouldFail) {
+                            throw new Error(`${name} failed`);
+                        }
+                        return `${name} succeeded`;
+                    }
+                    async run() {
+                        return this.executeStep();
+                    }
+                };
+            })())(name, parent);
+        }
+        describe('Default behavior - throws first error (backward compatible)', () => {
+            it('should throw first error when concurrent task fails', async () => {
+                let ParentWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _spawnChildren_decorators;
+                    return class ParentWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _spawnChildren_decorators = [Task({ concurrent: true })];
+                            __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async spawnChildren() {
+                            return [
+                                createChildWorkflow(this, 'Child-0', false),
+                                createChildWorkflow(this, 'Child-1', true), // Will fail
+                                createChildWorkflow(this, 'Child-2', false),
+                                createChildWorkflow(this, 'Child-3', false),
+                            ];
+                        }
+                        async run() {
+                            await this.spawnChildren();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new ParentWorkflow('Parent');
+                // Should throw first error (backward compatible with Promise.all)
+                await expect(workflow.run()).rejects.toThrow('Child-1 failed');
+            });
+            it('should complete all workflows even when one fails', async () => {
+                let ParentWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _spawnChildren_decorators;
+                    return class ParentWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _spawnChildren_decorators = [Task({ concurrent: true })];
+                            __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async spawnChildren() {
+                            return [
+                                createChildWorkflow(this, 'Child-0', false),
+                                createChildWorkflow(this, 'Child-1', true), // Will fail
+                                createChildWorkflow(this, 'Child-2', false),
+                            ];
+                        }
+                        async run() {
+                            try {
+                                await this.spawnChildren();
+                            }
+                            catch {
+                                // Expected
+                            }
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new ParentWorkflow('Parent');
+                await workflow.run();
+                // All children should be attached (Promise.allSettled completed all)
+                expect(workflow.children.length).toBe(3);
+                const childNames = workflow.children.map((c) => c.getNode().name);
+                expect(childNames).toContain('Child-0');
+                expect(childNames).toContain('Child-1');
+                expect(childNames).toContain('Child-2');
+            });
+        });
+        describe('No error merge strategy - default behavior preserved', () => {
+            it('should not merge errors when errorMergeStrategy is not enabled', async () => {
+                let ParentWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _spawnChildren_decorators;
+                    return class ParentWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _spawnChildren_decorators = [Task({ concurrent: true })];
+                            __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async spawnChildren() {
+                            return [
+                                createChildWorkflow(this, 'Alpha', true),
+                                createChildWorkflow(this, 'Beta', true),
+                                createChildWorkflow(this, 'Gamma', false),
+                            ];
+                        }
+                        async run() {
+                            await this.spawnChildren();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new ParentWorkflow('Parent');
+                // Should throw first error only (backward compatible)
+                await expect(workflow.run()).rejects.toThrow('Alpha failed');
+            });
+        });
+    });
+    // ============================================================================
+    // Section 4: Documentation Examples - README Quick Start
+    // ============================================================================
+    // Tests that all README documentation examples execute without modification
+    // ============================================================================
+    describe('Documentation Examples - README Quick Start', () => {
+        describe('Class-based workflow from README', () => {
+            it('should execute README class-based workflow example', async () => {
+                // From README.md lines 22-42 (approximately)
+                let DataProcessor = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _progress_decorators;
+                    let _progress_initializers = [];
+                    let _progress_extraInitializers = [];
+                    let _process_decorators;
+                    return class DataProcessor extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _progress_decorators = [ObservedState()];
+                            _process_decorators = [Step({ trackTiming: true, snapshotState: true })];
+                            __esDecorate(this, null, _process_decorators, { kind: "method", name: "process", static: false, private: false, access: { has: obj => "process" in obj, get: obj => obj.process }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(null, null, _progress_decorators, { kind: "field", name: "progress", static: false, private: false, access: { has: obj => "progress" in obj, get: obj => obj.progress, set: (obj, value) => { obj.progress = value; } }, metadata: _metadata }, _progress_initializers, _progress_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        progress = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _progress_initializers, 0));
+                        async process() {
+                            this.progress = 100;
+                            return ['item1', 'item2', 'item3'];
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            const result = await this.process();
+                            this.setStatus('completed');
+                            return result;
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _progress_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new DataProcessor('DataProcessor');
+                const result = await workflow.run();
+                expect(result).toEqual(['item1', 'item2', 'item3']);
+                expect(workflow.status).toBe('completed');
+                expect(workflow.progress).toBe(100);
+            });
+        });
+        describe('Functional workflow from README', () => {
+            it('should execute README functional workflow example', async () => {
+                // From README.md lines 44-57 (approximately)
+                const fetchData = async () => ['data1', 'data2'];
+                const transform = async (data) => data.map(x => x.toUpperCase());
+                const workflow = createWorkflow({ name: 'DataPipeline' }, async (ctx) => {
+                    const loaded = await ctx.step('load', async () => fetchData());
+                    const processed = await ctx.step('process', async () => transform(loaded));
+                    return processed;
+                });
+                const result = await workflow.run();
+                // Result can be either direct value or WorkflowResult object
+                if (typeof result === 'object' && result !== null && 'data' in result) {
+                    expect(result.data).toEqual(['DATA1', 'DATA2']);
+                }
+                else {
+                    expect(result).toEqual(['DATA1', 'DATA2']);
+                }
+            });
+        });
+        describe('Basic workflow creation pattern', () => {
+            it('should support basic class extension pattern', async () => {
+                // From README basic usage
+                class DataProcessor extends Workflow {
+                    async run() {
+                        this.setStatus('running');
+                        this.logger.info('Processing started');
+                        const result = await this.processData();
+                        this.setStatus('completed');
+                        return result;
+                    }
+                    async processData() {
+                        return ['item1', 'item2'];
+                    }
+                }
+                const workflow = new DataProcessor('MyProcessor');
+                const result = await workflow.run();
+                expect(result).toEqual(['item1', 'item2']);
+                expect(workflow.status).toBe('completed');
+            });
+        });
+        describe('Logger usage from documentation', () => {
+            it('should support all logger methods from documentation', async () => {
+                class LoggingWorkflow extends Workflow {
+                    async run() {
+                        this.setStatus('running');
+                        // All logger methods from docs
+                        this.logger.debug('Debug message', { data: 'test' });
+                        this.logger.info('Info message');
+                        this.logger.warn('Warning message');
+                        this.logger.error('Error message', { error: new Error('test') });
+                        this.setStatus('completed');
+                    }
+                }
+                const workflow = new LoggingWorkflow('LoggerTest');
+                await workflow.run();
+                expect(workflow.getNode().logs.length).toBe(4);
+                expect(workflow.getNode().logs[0].level).toBe('debug');
+                expect(workflow.getNode().logs[1].level).toBe('info');
+                expect(workflow.getNode().logs[2].level).toBe('warn');
+                expect(workflow.getNode().logs[3].level).toBe('error');
+            });
+        });
+    });
+    // ============================================================================
+    // Section 5: Example Files - Core Patterns
+    // ============================================================================
+    // Tests that verify example file patterns work correctly
+    // ============================================================================
+    describe('Example Files - Core Patterns', () => {
+        describe('01-basic-workflow.ts patterns', () => {
+            it('should support basic workflow with status management', async () => {
+                // Pattern from examples/examples/01-basic-workflow.ts
+                class DataProcessingWorkflow extends Workflow {
+                    data = [];
+                    async run() {
+                        this.setStatus('running');
+                        this.logger.info('Starting data processing workflow');
+                        try {
+                            // Simulate data processing
+                            this.data = ['item1', 'item2', 'item3'];
+                            this.setStatus('completed');
+                            this.logger.info('Workflow completed successfully');
+                            return this.data;
+                        }
+                        catch (error) {
+                            this.setStatus('failed');
+                            this.logger.error('Workflow failed', { error });
+                            throw error;
+                        }
+                    }
+                }
+                const workflow = new DataProcessingWorkflow('DataProcessor');
+                const result = await workflow.run();
+                expect(result).toEqual(['item1', 'item2', 'item3']);
+                expect(workflow.status).toBe('completed');
+            });
+            it('should support WorkflowTreeDebugger', async () => {
+                class SimpleWorkflow extends Workflow {
+                    async run() {
+                        this.setStatus('running');
+                        this.logger.info('Running');
+                        this.setStatus('completed');
+                        return 'done';
+                    }
+                }
+                const workflow = new SimpleWorkflow();
+                const debugger_ = new WorkflowTreeDebugger(workflow);
+                await workflow.run();
+                // Debugger should produce valid tree output
+                const treeString = debugger_.toTreeString();
+                expect(treeString).toContain('SimpleWorkflow');
+            });
+        });
+        describe('02-decorator-options.ts patterns', () => {
+            it('should support @Step with all options', async () => {
+                // Pattern from examples/examples/02-decorator-options.ts
+                let StepOptionsWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _currentPhase_decorators;
+                    let _currentPhase_initializers = [];
+                    let _currentPhase_extraInitializers = [];
+                    let _defaultStep_decorators;
+                    let _stepWithCustomName_decorators;
+                    let _stepWithSnapshot_decorators;
+                    let _stepWithTiming_decorators;
+                    let _stepWithLogging_decorators;
+                    return class StepOptionsWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _currentPhase_decorators = [ObservedState()];
+                            _defaultStep_decorators = [Step()];
+                            _stepWithCustomName_decorators = [Step({ name: 'CustomNamedStep' })];
+                            _stepWithSnapshot_decorators = [Step({ snapshotState: true })];
+                            _stepWithTiming_decorators = [Step({ trackTiming: true })];
+                            _stepWithLogging_decorators = [Step({ logStart: true, logFinish: true })];
+                            __esDecorate(this, null, _defaultStep_decorators, { kind: "method", name: "defaultStep", static: false, private: false, access: { has: obj => "defaultStep" in obj, get: obj => obj.defaultStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(this, null, _stepWithCustomName_decorators, { kind: "method", name: "stepWithCustomName", static: false, private: false, access: { has: obj => "stepWithCustomName" in obj, get: obj => obj.stepWithCustomName }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(this, null, _stepWithSnapshot_decorators, { kind: "method", name: "stepWithSnapshot", static: false, private: false, access: { has: obj => "stepWithSnapshot" in obj, get: obj => obj.stepWithSnapshot }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(this, null, _stepWithTiming_decorators, { kind: "method", name: "stepWithTiming", static: false, private: false, access: { has: obj => "stepWithTiming" in obj, get: obj => obj.stepWithTiming }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(this, null, _stepWithLogging_decorators, { kind: "method", name: "stepWithLogging", static: false, private: false, access: { has: obj => "stepWithLogging" in obj, get: obj => obj.stepWithLogging }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(null, null, _currentPhase_decorators, { kind: "field", name: "currentPhase", static: false, private: false, access: { has: obj => "currentPhase" in obj, get: obj => obj.currentPhase, set: (obj, value) => { obj.currentPhase = value; } }, metadata: _metadata }, _currentPhase_initializers, _currentPhase_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        currentPhase = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _currentPhase_initializers, 'init'));
+                        // Default step - minimal configuration
+                        async defaultStep() {
+                            this.currentPhase = 'default';
+                        }
+                        // Step with custom name
+                        async stepWithCustomName() {
+                            this.currentPhase = 'custom-named';
+                        }
+                        // Step with state snapshot
+                        async stepWithSnapshot() {
+                            this.currentPhase = 'snapshot';
+                        }
+                        // Step with timing tracking
+                        async stepWithTiming() {
+                            this.currentPhase = 'timed';
+                        }
+                        // Step with start/finish logging
+                        async stepWithLogging() {
+                            this.currentPhase = 'logged';
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            await this.defaultStep();
+                            await this.stepWithCustomName();
+                            await this.stepWithSnapshot();
+                            await this.stepWithTiming();
+                            await this.stepWithLogging();
+                            this.setStatus('completed');
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _currentPhase_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new StepOptionsWorkflow();
+                await workflow.run();
+                expect(workflow.status).toBe('completed');
+                expect(workflow.currentPhase).toBe('logged');
+            });
+            it('should support @ObservedState with redact option', async () => {
+                // Pattern from examples/examples/02-decorator-options.ts
+                let StateOptionsWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _publicData_decorators;
+                    let _publicData_initializers = [];
+                    let _publicData_extraInitializers = [];
+                    let _apiKey_decorators;
+                    let _apiKey_initializers = [];
+                    let _apiKey_extraInitializers = [];
+                    let _internalCounter_decorators;
+                    let _internalCounter_initializers = [];
+                    let _internalCounter_extraInitializers = [];
+                    return class StateOptionsWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _publicData_decorators = [ObservedState()];
+                            _apiKey_decorators = [ObservedState({ redact: true })];
+                            _internalCounter_decorators = [ObservedState({ hidden: true })];
+                            __esDecorate(null, null, _publicData_decorators, { kind: "field", name: "publicData", static: false, private: false, access: { has: obj => "publicData" in obj, get: obj => obj.publicData, set: (obj, value) => { obj.publicData = value; } }, metadata: _metadata }, _publicData_initializers, _publicData_extraInitializers);
+                            __esDecorate(null, null, _apiKey_decorators, { kind: "field", name: "apiKey", static: false, private: false, access: { has: obj => "apiKey" in obj, get: obj => obj.apiKey, set: (obj, value) => { obj.apiKey = value; } }, metadata: _metadata }, _apiKey_initializers, _apiKey_extraInitializers);
+                            __esDecorate(null, null, _internalCounter_decorators, { kind: "field", name: "internalCounter", static: false, private: false, access: { has: obj => "internalCounter" in obj, get: obj => obj.internalCounter, set: (obj, value) => { obj.internalCounter = value; } }, metadata: _metadata }, _internalCounter_initializers, _internalCounter_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        publicData = __runInitializers(this, _publicData_initializers, 'visible-value');
+                        apiKey = (__runInitializers(this, _publicData_extraInitializers), __runInitializers(this, _apiKey_initializers, 'super-secret-api-key-12345'));
+                        internalCounter = (__runInitializers(this, _apiKey_extraInitializers), __runInitializers(this, _internalCounter_initializers, 999));
+                        async run() {
+                            this.setStatus('running');
+                            this.setStatus('completed');
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _internalCounter_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new StateOptionsWorkflow();
+                await workflow.run();
+                const snapshot = getObservedState(workflow);
+                // Public data should be visible
+                expect(snapshot.publicData).toBe('visible-value');
+                // API key should be redacted
+                expect(snapshot.apiKey).toBe('***');
+                // Hidden field should not be present
+                expect('internalCounter' in snapshot).toBe(false);
+            });
+        });
+        describe('03-parent-child.ts patterns', () => {
+            it('should support hierarchical workflow creation', async () => {
+                // Pattern from examples/examples/03-parent-child.ts
+                let LeafWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _processed_decorators;
+                    let _processed_initializers = [];
+                    let _processed_extraInitializers = [];
+                    let _process_decorators;
+                    return class LeafWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _processed_decorators = [ObservedState()];
+                            _process_decorators = [Step({ trackTiming: true })];
+                            __esDecorate(this, null, _process_decorators, { kind: "method", name: "process", static: false, private: false, access: { has: obj => "process" in obj, get: obj => obj.process }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(null, null, _processed_decorators, { kind: "field", name: "processed", static: false, private: false, access: { has: obj => "processed" in obj, get: obj => obj.processed, set: (obj, value) => { obj.processed = value; } }, metadata: _metadata }, _processed_initializers, _processed_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        processed = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _processed_initializers, false));
+                        constructor(name, parent) {
+                            super(name, parent);
+                            __runInitializers(this, _processed_extraInitializers);
+                        }
+                        async process() {
+                            this.logger.info(`Processing ${this.getNode().name}`);
+                            this.processed = true;
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            await this.process();
+                            this.setStatus('completed');
+                        }
+                    };
+                })();
+                let ParentWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _itemCount_decorators;
+                    let _itemCount_initializers = [];
+                    let _itemCount_extraInitializers = [];
+                    let _spawnChild_decorators;
+                    return class ParentWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _itemCount_decorators = [ObservedState()];
+                            _spawnChild_decorators = [Task()];
+                            __esDecorate(this, null, _spawnChild_decorators, { kind: "method", name: "spawnChild", static: false, private: false, access: { has: obj => "spawnChild" in obj, get: obj => obj.spawnChild }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(null, null, _itemCount_decorators, { kind: "field", name: "itemCount", static: false, private: false, access: { has: obj => "itemCount" in obj, get: obj => obj.itemCount, set: (obj, value) => { obj.itemCount = value; } }, metadata: _metadata }, _itemCount_initializers, _itemCount_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        itemCount = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _itemCount_initializers, 0));
+                        async spawnChild(name) {
+                            return new LeafWorkflow(name, this);
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            this.itemCount = 2;
+                            const child1 = await this.spawnChild('Child-1');
+                            await child1.run();
+                            const child2 = await this.spawnChild('Child-2');
+                            await child2.run();
+                            this.setStatus('completed');
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _itemCount_extraInitializers);
+                        }
+                    };
+                })();
+                const parent = new ParentWorkflow('Parent');
+                await parent.run();
+                expect(parent.status).toBe('completed');
+                expect(parent.children.length).toBe(2);
+                expect(parent.itemCount).toBe(2);
+            });
+            it('should support parent parameter in constructor', async () => {
+                class ChildWorkflow extends Workflow {
+                    constructor(name, parent) {
+                        super(name, parent);
+                    }
+                    async run() {
+                        this.setStatus('running');
+                        this.setStatus('completed');
+                        return 'child-result';
+                    }
+                }
+                let ParentWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _createChild_decorators;
+                    return class ParentWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _createChild_decorators = [Task()];
+                            __esDecorate(this, null, _createChild_decorators, { kind: "method", name: "createChild", static: false, private: false, access: { has: obj => "createChild" in obj, get: obj => obj.createChild }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async createChild() {
+                            return new ChildWorkflow('Child', this);
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            const child = await this.createChild();
+                            await child.run();
+                            this.setStatus('completed');
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const parent = new ParentWorkflow('Parent');
+                await parent.run();
+                expect(parent.children.length).toBe(1);
+                expect(parent.children[0].getNode().name).toBe('Child');
+                expect(parent.children[0].parent).toBe(parent);
+            });
+        });
+        describe('05-error-handling.ts patterns', () => {
+            it('should support @Step with error wrapping', async () => {
+                // Pattern from examples/examples/05-error-handling.ts
+                let ErrorDemoWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _currentStep_decorators;
+                    let _currentStep_initializers = [];
+                    let _currentStep_extraInitializers = [];
+                    let _step1_decorators;
+                    let _failingStep_decorators;
+                    return class ErrorDemoWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _currentStep_decorators = [ObservedState()];
+                            _step1_decorators = [Step({ snapshotState: true })];
+                            _failingStep_decorators = [Step({ snapshotState: true })];
+                            __esDecorate(this, null, _step1_decorators, { kind: "method", name: "step1", static: false, private: false, access: { has: obj => "step1" in obj, get: obj => obj.step1 }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(this, null, _failingStep_decorators, { kind: "method", name: "failingStep", static: false, private: false, access: { has: obj => "failingStep" in obj, get: obj => obj.failingStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(null, null, _currentStep_decorators, { kind: "field", name: "currentStep", static: false, private: false, access: { has: obj => "currentStep" in obj, get: obj => obj.currentStep, set: (obj, value) => { obj.currentStep = value; } }, metadata: _metadata }, _currentStep_initializers, _currentStep_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        currentStep = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _currentStep_initializers, 'init'));
+                        async step1() {
+                            this.currentStep = 'step1';
+                        }
+                        async failingStep() {
+                            this.currentStep = 'failing';
+                            throw new Error('Something went wrong in failingStep!');
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            await this.step1();
+                            await this.failingStep();
+                            this.setStatus('completed');
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _currentStep_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new ErrorDemoWorkflow();
+                let capturedError = null;
+                try {
+                    await workflow.run();
+                }
+                catch (error) {
+                    capturedError = error;
+                }
+                expect(capturedError).not.toBeNull();
+                expect(capturedError?.message).toBe('Something went wrong in failingStep!');
+                expect(capturedError?.state.currentStep).toBe('failing');
+                expect(capturedError?.workflowId).toBe(workflow.id);
+            });
+            it('should support WorkflowError structure', async () => {
+                let FailingWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _attempt_decorators;
+                    let _attempt_initializers = [];
+                    let _attempt_extraInitializers = [];
+                    let _fail_decorators;
+                    return class FailingWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _attempt_decorators = [ObservedState()];
+                            _fail_decorators = [Step()];
+                            __esDecorate(this, null, _fail_decorators, { kind: "method", name: "fail", static: false, private: false, access: { has: obj => "fail" in obj, get: obj => obj.fail }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(null, null, _attempt_decorators, { kind: "field", name: "attempt", static: false, private: false, access: { has: obj => "attempt" in obj, get: obj => obj.attempt, set: (obj, value) => { obj.attempt = value; } }, metadata: _metadata }, _attempt_initializers, _attempt_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        attempt = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _attempt_initializers, 1));
+                        async fail() {
+                            throw new Error('Test failure');
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            await this.fail();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _attempt_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new FailingWorkflow();
+                let wfError = null;
+                try {
+                    await workflow.run();
+                }
+                catch (error) {
+                    wfError = error;
+                }
+                expect(wfError).toBeDefined();
+                expect(wfError?.message).toBe('Test failure');
+                expect(wfError?.workflowId).toBe(workflow.id);
+                expect(wfError?.state.attempt).toBe(1);
+                expect(Array.isArray(wfError?.logs)).toBe(true);
+                expect(wfError?.stack).toBeDefined();
+            });
+        });
+        describe('06-concurrent-tasks.ts patterns', () => {
+            it('should support @Task with concurrent option', async () => {
+                // Pattern from examples/examples/06-concurrent-tasks.ts
+                let WorkerWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _result_decorators;
+                    let _result_initializers = [];
+                    let _result_extraInitializers = [];
+                    let _process_decorators;
+                    return class WorkerWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _result_decorators = [ObservedState()];
+                            _process_decorators = [Step({ trackTiming: true })];
+                            __esDecorate(this, null, _process_decorators, { kind: "method", name: "process", static: false, private: false, access: { has: obj => "process" in obj, get: obj => obj.process }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(null, null, _result_decorators, { kind: "field", name: "result", static: false, private: false, access: { has: obj => "result" in obj, get: obj => obj.result, set: (obj, value) => { obj.result = value; } }, metadata: _metadata }, _result_initializers, _result_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        result = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _result_initializers, ''));
+                        constructor(id, parent) {
+                            super(`Worker-${id}`, parent);
+                            __runInitializers(this, _result_extraInitializers);
+                        }
+                        async process() {
+                            this.result = `Result from ${this.getNode().name}`;
+                            return this.result;
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            const result = await this.process();
+                            this.setStatus('completed');
+                            return result;
+                        }
+                    };
+                })();
+                let ConcurrentWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _workerCount_decorators;
+                    let _workerCount_initializers = [];
+                    let _workerCount_extraInitializers = [];
+                    let _createAllWorkers_decorators;
+                    return class ConcurrentWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _workerCount_decorators = [ObservedState()];
+                            _createAllWorkers_decorators = [Task({ concurrent: true })];
+                            __esDecorate(this, null, _createAllWorkers_decorators, { kind: "method", name: "createAllWorkers", static: false, private: false, access: { has: obj => "createAllWorkers" in obj, get: obj => obj.createAllWorkers }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(null, null, _workerCount_decorators, { kind: "field", name: "workerCount", static: false, private: false, access: { has: obj => "workerCount" in obj, get: obj => obj.workerCount, set: (obj, value) => { obj.workerCount = value; } }, metadata: _metadata }, _workerCount_initializers, _workerCount_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        workerCount = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _workerCount_initializers, 0));
+                        async createAllWorkers() {
+                            this.workerCount = 3;
+                            return [
+                                new WorkerWorkflow('1', this),
+                                new WorkerWorkflow('2', this),
+                                new WorkerWorkflow('3', this),
+                            ];
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            await this.createAllWorkers();
+                            this.setStatus('completed');
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _workerCount_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new ConcurrentWorkflow();
+                await workflow.run();
+                expect(workflow.status).toBe('completed');
+                expect(workflow.children.length).toBe(3);
+                expect(workflow.workerCount).toBe(3);
+            });
+            it('should support manual parallel execution pattern', async () => {
+                // Manual parallel execution (Promise.all) should still work
+                class WorkerWorkflow extends Workflow {
+                    async run() {
+                        this.setStatus('running');
+                        this.setStatus('completed');
+                        return 'worker-result';
+                    }
+                }
+                let ManualParallelWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _createWorker_decorators;
+                    return class ManualParallelWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _createWorker_decorators = [Task()];
+                            __esDecorate(this, null, _createWorker_decorators, { kind: "method", name: "createWorker", static: false, private: false, access: { has: obj => "createWorker" in obj, get: obj => obj.createWorker }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async createWorker() {
+                            return new WorkerWorkflow('Worker', this);
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            // Manual parallel execution
+                            const workers = await Promise.all([
+                                this.createWorker(),
+                                this.createWorker(),
+                                this.createWorker(),
+                            ]);
+                            const results = await Promise.all(workers.map(w => w.run()));
+                            this.setStatus('completed');
+                            return results;
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new ManualParallelWorkflow();
+                const results = await workflow.run();
+                expect(results).toEqual(['worker-result', 'worker-result', 'worker-result']);
+                expect(workflow.children.length).toBe(3);
+            });
+        });
+    });
+    // ============================================================================
+    // Section 6: Decorator Patterns - Comprehensive Coverage
+    // ============================================================================
+    // Tests for all decorator option combinations
+    // ============================================================================
+    describe('Decorator Patterns - Comprehensive Coverage', () => {
+        describe('@Step decorator variations', () => {
+            it('should support @Step with no options', async () => {
+                let TestWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _basicStep_decorators;
+                    return class TestWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _basicStep_decorators = [Step()];
+                            __esDecorate(this, null, _basicStep_decorators, { kind: "method", name: "basicStep", static: false, private: false, access: { has: obj => "basicStep" in obj, get: obj => obj.basicStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async basicStep() {
+                            this.logger.info('Basic step');
+                        }
+                        async run() {
+                            await this.basicStep();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                expect(workflow.getNode().logs.some(l => l.message === 'Basic step')).toBe(true);
+            });
+            it('should support @Step with trackTiming option', async () => {
+                const events = [];
+                let TestWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _timedStep_decorators;
+                    return class TestWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _timedStep_decorators = [Step({ trackTiming: true })];
+                            __esDecorate(this, null, _timedStep_decorators, { kind: "method", name: "timedStep", static: false, private: false, access: { has: obj => "timedStep" in obj, get: obj => obj.timedStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async timedStep() {
+                            // Do nothing
+                        }
+                        async run() {
+                            await this.timedStep();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new TestWorkflow();
+                workflow.addObserver({
+                    onLog: () => { },
+                    onEvent: (e) => events.push(e),
+                    onStateUpdated: () => { },
+                    onTreeChanged: () => { },
+                });
+                await workflow.run();
+                const stepEndEvents = events.filter(e => e.type === 'stepEnd');
+                expect(stepEndEvents.length).toBeGreaterThan(0);
+                if (stepEndEvents[0].type === 'stepEnd') {
+                    expect(stepEndEvents[0].duration).toBeDefined();
+                }
+            });
+            it('should support @Step with snapshotState option', async () => {
+                let TestWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _value_decorators;
+                    let _value_initializers = [];
+                    let _value_extraInitializers = [];
+                    let _updateStep_decorators;
+                    return class TestWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _value_decorators = [ObservedState()];
+                            _updateStep_decorators = [Step({ snapshotState: true })];
+                            __esDecorate(this, null, _updateStep_decorators, { kind: "method", name: "updateStep", static: false, private: false, access: { has: obj => "updateStep" in obj, get: obj => obj.updateStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(null, null, _value_decorators, { kind: "field", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value, set: (obj, value) => { obj.value = value; } }, metadata: _metadata }, _value_initializers, _value_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        value = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _value_initializers, 0));
+                        async updateStep() {
+                            this.value = 42;
+                        }
+                        async run() {
+                            await this.updateStep();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _value_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                expect(workflow.value).toBe(42);
+            });
+            it('should support @Step with logStart and logFinish options', async () => {
+                let TestWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _loggedStep_decorators;
+                    return class TestWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _loggedStep_decorators = [Step({ logStart: true, logFinish: true })];
+                            __esDecorate(this, null, _loggedStep_decorators, { kind: "method", name: "loggedStep", static: false, private: false, access: { has: obj => "loggedStep" in obj, get: obj => obj.loggedStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async loggedStep() {
+                            this.logger.info('Inside step');
+                        }
+                        async run() {
+                            await this.loggedStep();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                const logs = workflow.getNode().logs;
+                expect(logs.some(l => l.message.includes('STEP START'))).toBe(true);
+                expect(logs.some(l => l.message.includes('Inside step'))).toBe(true);
+                expect(logs.some(l => l.message.includes('STEP END'))).toBe(true);
+            });
+            it('should support @Step with all options combined', async () => {
+                let TestWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _phase_decorators;
+                    let _phase_initializers = [];
+                    let _phase_extraInitializers = [];
+                    let _fullStep_decorators;
+                    return class TestWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _phase_decorators = [ObservedState()];
+                            _fullStep_decorators = [Step({
+                                    name: 'FullyConfigured',
+                                    trackTiming: true,
+                                    snapshotState: true,
+                                    logStart: true,
+                                    logFinish: true,
+                                })];
+                            __esDecorate(this, null, _fullStep_decorators, { kind: "method", name: "fullStep", static: false, private: false, access: { has: obj => "fullStep" in obj, get: obj => obj.fullStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            __esDecorate(null, null, _phase_decorators, { kind: "field", name: "phase", static: false, private: false, access: { has: obj => "phase" in obj, get: obj => obj.phase, set: (obj, value) => { obj.phase = value; } }, metadata: _metadata }, _phase_initializers, _phase_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        phase = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _phase_initializers, 'init'));
+                        async fullStep() {
+                            this.phase = 'complete';
+                        }
+                        async run() {
+                            await this.fullStep();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _phase_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                expect(workflow.phase).toBe('complete');
+            });
+        });
+        describe('@Task decorator variations', () => {
+            it('should support @Task with no options', async () => {
+                class ChildWorkflow extends Workflow {
+                    async run() {
+                        return 'child-result';
+                    }
+                }
+                let ParentWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _createChild_decorators;
+                    return class ParentWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _createChild_decorators = [Task()];
+                            __esDecorate(this, null, _createChild_decorators, { kind: "method", name: "createChild", static: false, private: false, access: { has: obj => "createChild" in obj, get: obj => obj.createChild }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async createChild() {
+                            return new ChildWorkflow('Child', this);
+                        }
+                        async run() {
+                            const child = await this.createChild();
+                            await child.run();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new ParentWorkflow();
+                await workflow.run();
+                expect(workflow.children.length).toBe(1);
+            });
+            it('should support @Task with custom name', async () => {
+                class ChildWorkflow extends Workflow {
+                    async run() {
+                        return 'result';
+                    }
+                }
+                let ParentWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _createChild_decorators;
+                    return class ParentWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _createChild_decorators = [Task({ name: 'CustomTaskName' })];
+                            __esDecorate(this, null, _createChild_decorators, { kind: "method", name: "createChild", static: false, private: false, access: { has: obj => "createChild" in obj, get: obj => obj.createChild }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async createChild() {
+                            return new ChildWorkflow('Child', this);
+                        }
+                        async run() {
+                            await this.createChild();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new ParentWorkflow();
+                const events = [];
+                workflow.addObserver({
+                    onLog: () => { },
+                    onEvent: (e) => events.push(e),
+                    onStateUpdated: () => { },
+                    onTreeChanged: () => { },
+                });
+                await workflow.run();
+                const taskEvents = events.filter(e => e.type === 'taskStart' || e.type === 'taskEnd');
+                expect(taskEvents.length).toBeGreaterThan(0);
+            });
+            it('should support @Task with concurrent option', async () => {
+                class ChildWorkflow extends Workflow {
+                    async run() {
+                        return 'result';
+                    }
+                }
+                let ParentWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _createChildren_decorators;
+                    return class ParentWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _createChildren_decorators = [Task({ concurrent: true })];
+                            __esDecorate(this, null, _createChildren_decorators, { kind: "method", name: "createChildren", static: false, private: false, access: { has: obj => "createChildren" in obj, get: obj => obj.createChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async createChildren() {
+                            return [
+                                new ChildWorkflow('Child-1', this),
+                                new ChildWorkflow('Child-2', this),
+                                new ChildWorkflow('Child-3', this),
+                            ];
+                        }
+                        async run() {
+                            await this.createChildren();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new ParentWorkflow();
+                await workflow.run();
+                expect(workflow.children.length).toBe(3);
+            });
+        });
+        describe('@ObservedState decorator variations', () => {
+            it('should support @ObservedState with no options', async () => {
+                let TestWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _value_decorators;
+                    let _value_initializers = [];
+                    let _value_extraInitializers = [];
+                    return class TestWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _value_decorators = [ObservedState()];
+                            __esDecorate(null, null, _value_decorators, { kind: "field", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value, set: (obj, value) => { obj.value = value; } }, metadata: _metadata }, _value_initializers, _value_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        value = __runInitializers(this, _value_initializers, 0);
+                        async run() {
+                            this.value = 42;
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _value_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                const snapshot = getObservedState(workflow);
+                expect(snapshot.value).toBe(42);
+            });
+            it('should support @ObservedState with redact option', async () => {
+                let TestWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _apiKey_decorators;
+                    let _apiKey_initializers = [];
+                    let _apiKey_extraInitializers = [];
+                    return class TestWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _apiKey_decorators = [ObservedState({ redact: true })];
+                            __esDecorate(null, null, _apiKey_decorators, { kind: "field", name: "apiKey", static: false, private: false, access: { has: obj => "apiKey" in obj, get: obj => obj.apiKey, set: (obj, value) => { obj.apiKey = value; } }, metadata: _metadata }, _apiKey_initializers, _apiKey_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        apiKey = __runInitializers(this, _apiKey_initializers, 'secret-key');
+                        async run() {
+                            // Do nothing
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _apiKey_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                const snapshot = getObservedState(workflow);
+                expect(snapshot.apiKey).toBe('***');
+            });
+            it('should support @ObservedState with hidden option', async () => {
+                let TestWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _internalId_decorators;
+                    let _internalId_initializers = [];
+                    let _internalId_extraInitializers = [];
+                    return class TestWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _internalId_decorators = [ObservedState({ hidden: true })];
+                            __esDecorate(null, null, _internalId_decorators, { kind: "field", name: "internalId", static: false, private: false, access: { has: obj => "internalId" in obj, get: obj => obj.internalId, set: (obj, value) => { obj.internalId = value; } }, metadata: _metadata }, _internalId_initializers, _internalId_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        internalId = __runInitializers(this, _internalId_initializers, 'internal-123');
+                        async run() {
+                            // Do nothing
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _internalId_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                const snapshot = getObservedState(workflow);
+                expect('internalId' in snapshot).toBe(false);
+            });
+            it('should support multiple @ObservedState fields', async () => {
+                let TestWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _field1_decorators;
+                    let _field1_initializers = [];
+                    let _field1_extraInitializers = [];
+                    let _field2_decorators;
+                    let _field2_initializers = [];
+                    let _field2_extraInitializers = [];
+                    let _secret_decorators;
+                    let _secret_initializers = [];
+                    let _secret_extraInitializers = [];
+                    let _internal_decorators;
+                    let _internal_initializers = [];
+                    let _internal_extraInitializers = [];
+                    return class TestWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _field1_decorators = [ObservedState()];
+                            _field2_decorators = [ObservedState()];
+                            _secret_decorators = [ObservedState({ redact: true })];
+                            _internal_decorators = [ObservedState({ hidden: true })];
+                            __esDecorate(null, null, _field1_decorators, { kind: "field", name: "field1", static: false, private: false, access: { has: obj => "field1" in obj, get: obj => obj.field1, set: (obj, value) => { obj.field1 = value; } }, metadata: _metadata }, _field1_initializers, _field1_extraInitializers);
+                            __esDecorate(null, null, _field2_decorators, { kind: "field", name: "field2", static: false, private: false, access: { has: obj => "field2" in obj, get: obj => obj.field2, set: (obj, value) => { obj.field2 = value; } }, metadata: _metadata }, _field2_initializers, _field2_extraInitializers);
+                            __esDecorate(null, null, _secret_decorators, { kind: "field", name: "secret", static: false, private: false, access: { has: obj => "secret" in obj, get: obj => obj.secret, set: (obj, value) => { obj.secret = value; } }, metadata: _metadata }, _secret_initializers, _secret_extraInitializers);
+                            __esDecorate(null, null, _internal_decorators, { kind: "field", name: "internal", static: false, private: false, access: { has: obj => "internal" in obj, get: obj => obj.internal, set: (obj, value) => { obj.internal = value; } }, metadata: _metadata }, _internal_initializers, _internal_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        field1 = __runInitializers(this, _field1_initializers, 'value1');
+                        field2 = (__runInitializers(this, _field1_extraInitializers), __runInitializers(this, _field2_initializers, 42));
+                        secret = (__runInitializers(this, _field2_extraInitializers), __runInitializers(this, _secret_initializers, 'hidden'));
+                        internal = (__runInitializers(this, _secret_extraInitializers), __runInitializers(this, _internal_initializers, 'not-visible'));
+                        async run() {
+                            // Do nothing
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _internal_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                const snapshot = getObservedState(workflow);
+                expect(snapshot.field1).toBe('value1');
+                expect(snapshot.field2).toBe(42);
+                expect(snapshot.secret).toBe('***');
+                expect('internal' in snapshot).toBe(false);
+            });
+        });
+    });
+    // ============================================================================
+    // Section 7: Parent-Child Patterns - Hierarchical Workflows
+    // ============================================================================
+    // Tests for parent-child relationship patterns
+    // ============================================================================
+    describe('Parent-Child Patterns - Hierarchical Workflows', () => {
+        describe('Constructor-based parent attachment', () => {
+            it('should attach child via constructor parent parameter', async () => {
+                class ChildWorkflow extends Workflow {
+                    constructor(name, parent) {
+                        super(name, parent);
+                    }
+                    async run() {
+                        this.setStatus('running');
+                        this.setStatus('completed');
+                        return 'child-done';
+                    }
+                }
+                class ParentWorkflow extends Workflow {
+                    async run() {
+                        this.setStatus('running');
+                        const child1 = new ChildWorkflow('Child1', this);
+                        await child1.run();
+                        const child2 = new ChildWorkflow('Child2', this);
+                        await child2.run();
+                        this.setStatus('completed');
+                    }
+                }
+                const parent = new ParentWorkflow('Parent');
+                await parent.run();
+                expect(parent.children.length).toBe(2);
+                expect(parent.children[0].parent).toBe(parent);
+                expect(parent.children[1].parent).toBe(parent);
+            });
+            it('should establish bidirectional parent-child relationship', async () => {
+                class ChildWorkflow extends Workflow {
+                    constructor(name, parent) {
+                        super(name, parent);
+                    }
+                    async run() {
+                        return 'done';
+                    }
+                }
+                let ParentWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _spawnChild_decorators;
+                    return class ParentWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _spawnChild_decorators = [Task()];
+                            __esDecorate(this, null, _spawnChild_decorators, { kind: "method", name: "spawnChild", static: false, private: false, access: { has: obj => "spawnChild" in obj, get: obj => obj.spawnChild }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async spawnChild() {
+                            return new ChildWorkflow('Child', this);
+                        }
+                        async run() {
+                            const child = await this.spawnChild();
+                            await child.run();
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const parent = new ParentWorkflow('Parent');
+                await parent.run();
+                const child = parent.children[0];
+                expect(child.parent).toBe(parent);
+                expect(parent.children).toContain(child);
+                expect(parent.getNode().children).toContain(child.getNode());
+            });
+        });
+        describe('Deep hierarchies', () => {
+            it('should support multi-level parent-child chains', async () => {
+                class Level3Workflow extends Workflow {
+                    constructor(name, parent) {
+                        super(name, parent);
+                    }
+                    async run() {
+                        this.setStatus('running');
+                        this.setStatus('completed');
+                        return 'level3';
+                    }
+                }
+                let Level2Workflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _spawnLevel3_decorators;
+                    return class Level2Workflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _spawnLevel3_decorators = [Task()];
+                            __esDecorate(this, null, _spawnLevel3_decorators, { kind: "method", name: "spawnLevel3", static: false, private: false, access: { has: obj => "spawnLevel3" in obj, get: obj => obj.spawnLevel3 }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        constructor(name, parent) {
+                            super(name, parent);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                        async spawnLevel3() {
+                            return new Level3Workflow('Level3', this);
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            const child = await this.spawnLevel3();
+                            await child.run();
+                            this.setStatus('completed');
+                            return 'level2';
+                        }
+                    };
+                })();
+                let Level1Workflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _spawnLevel2_decorators;
+                    return class Level1Workflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _spawnLevel2_decorators = [Task()];
+                            __esDecorate(this, null, _spawnLevel2_decorators, { kind: "method", name: "spawnLevel2", static: false, private: false, access: { has: obj => "spawnLevel2" in obj, get: obj => obj.spawnLevel2 }, metadata: _metadata }, null, _instanceExtraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        async spawnLevel2() {
+                            return new Level2Workflow('Level2', this);
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            const child = await this.spawnLevel2();
+                            await child.run();
+                            this.setStatus('completed');
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _instanceExtraInitializers);
+                        }
+                    };
+                })();
+                const root = new Level1Workflow('Level1');
+                await root.run();
+                expect(root.children.length).toBe(1);
+                const level2 = root.children[0];
+                expect(level2.children.length).toBe(1);
+                const level3 = level2.children[0];
+                expect(level3.parent).toBe(level2);
+                expect(level2.parent).toBe(root);
+            });
+        });
+        describe('Sibling workflows', () => {
+            it('should support multiple children of same parent', async () => {
+                class ChildWorkflow extends Workflow {
+                    constructor(name, parent) {
+                        super(name, parent);
+                    }
+                    async run() {
+                        return 'done';
+                    }
+                }
+                let ParentWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _childCount_decorators;
+                    let _childCount_initializers = [];
+                    let _childCount_extraInitializers = [];
+                    return class ParentWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _childCount_decorators = [ObservedState()];
+                            __esDecorate(null, null, _childCount_decorators, { kind: "field", name: "childCount", static: false, private: false, access: { has: obj => "childCount" in obj, get: obj => obj.childCount, set: (obj, value) => { obj.childCount = value; } }, metadata: _metadata }, _childCount_initializers, _childCount_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        childCount = __runInitializers(this, _childCount_initializers, 0);
+                        async run() {
+                            this.childCount = 3;
+                            for (let i = 1; i <= 3; i++) {
+                                const child = new ChildWorkflow(`Child${i}`, this);
+                                await child.run();
+                            }
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _childCount_extraInitializers);
+                        }
+                    };
+                })();
+                const parent = new ParentWorkflow('Parent');
+                await parent.run();
+                expect(parent.children.length).toBe(3);
+                expect(parent.childCount).toBe(3);
+                const childNames = parent.children.map(c => c.getNode().name);
+                expect(childNames).toEqual(['Child1', 'Child2', 'Child3']);
+            });
+        });
+    });
+    // ============================================================================
+    // Section 8: Additional Backward Compatibility Validations
+    // ============================================================================
+    // Additional tests for comprehensive backward compatibility coverage
+    // ============================================================================
+    describe('Additional Backward Compatibility Validations', () => {
+        describe('Workflow status transitions', () => {
+            it('should support all status transitions from examples', async () => {
+                class StatusWorkflow extends Workflow {
+                    async run() {
+                        // idle -> running -> completed
+                        expect(this.status).toBe('idle');
+                        this.setStatus('running');
+                        expect(this.status).toBe('running');
+                        this.setStatus('completed');
+                        expect(this.status).toBe('completed');
+                    }
+                }
+                const workflow = new StatusWorkflow();
+                await workflow.run();
+                expect(workflow.status).toBe('completed');
+            });
+            it('should support failed status transition', async () => {
+                class FailingWorkflow extends Workflow {
+                    async run() {
+                        this.setStatus('running');
+                        this.setStatus('failed');
+                        throw new Error('Intentional failure');
+                    }
+                }
+                const workflow = new FailingWorkflow();
+                try {
+                    await workflow.run();
+                }
+                catch {
+                    // Expected
+                }
+                expect(workflow.status).toBe('failed');
+            });
+        });
+        describe('Workflow ID generation', () => {
+            it('should generate unique IDs for each workflow instance', () => {
+                class TestWorkflow extends Workflow {
+                }
+                const wf1 = new TestWorkflow();
+                const wf2 = new TestWorkflow();
+                const wf3 = new TestWorkflow();
+                expect(wf1.id).not.toBe(wf2.id);
+                expect(wf2.id).not.toBe(wf3.id);
+                expect(wf1.id).not.toBe(wf3.id);
+            });
+        });
+        describe('Workflow name defaults', () => {
+            it('should use class name as default when no name provided', () => {
+                class MyCustomWorkflow extends Workflow {
+                }
+                const wf = new MyCustomWorkflow();
+                expect(wf.getNode().name).toBe('MyCustomWorkflow');
+            });
+        });
+        describe('Logger child with both APIs', () => {
+            it('should support mixing old and new logger.child() APIs', async () => {
+                class TestWorkflow extends Workflow {
+                    async run() {
+                        // Old API
+                        const child1 = this.logger.child('log-1');
+                        child1.info('Message 1');
+                        // New API
+                        const child2 = this.logger.child({ parentLogId: 'log-2' });
+                        child2.info('Message 2');
+                        // Old API again
+                        const child3 = this.logger.child('log-3');
+                        child3.info('Message 3');
+                    }
+                }
+                const workflow = new TestWorkflow();
+                await workflow.run();
+                expect(workflow.getNode().logs[0].parentLogId).toBe('log-1');
+                expect(workflow.getNode().logs[1].parentLogId).toBe('log-2');
+                expect(workflow.getNode().logs[2].parentLogId).toBe('log-3');
+            });
+        });
+        describe('WorkflowTreeDebugger compatibility', () => {
+            it('should work with WorkflowTreeDebugger', async () => {
+                let TestWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _value_decorators;
+                    let _value_initializers = [];
+                    let _value_extraInitializers = [];
+                    let _testStep_decorators;
+                    return class TestWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _value_decorators = [ObservedState()];
+                            _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);
+                            __esDecorate(null, null, _value_decorators, { kind: "field", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value, set: (obj, value) => { obj.value = value; } }, metadata: _metadata }, _value_initializers, _value_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        value = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _value_initializers, 42));
+                        async testStep() {
+                            this.logger.info('Test log');
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            await this.testStep();
+                            this.setStatus('completed');
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _value_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new TestWorkflow();
+                const debugger_ = new WorkflowTreeDebugger(workflow);
+                await workflow.run();
+                // All debugger methods should work
+                const tree = debugger_.toTreeString();
+                const logs = debugger_.toLogString();
+                const stats = debugger_.getStats();
+                expect(tree).toContain('TestWorkflow');
+                expect(typeof logs).toBe('string');
+                expect(stats.totalNodes).toBeGreaterThanOrEqual(1);
+            });
+        });
+        describe('Observer pattern compatibility', () => {
+            it('should support WorkflowObserver with all callbacks', async () => {
+                const logs = [];
+                const events = [];
+                const stateUpdates = [];
+                const treeUpdates = [];
+                let TestWorkflow = (() => {
+                    let _classSuper = Workflow;
+                    let _instanceExtraInitializers = [];
+                    let _counter_decorators;
+                    let _counter_initializers = [];
+                    let _counter_extraInitializers = [];
+                    let _testStep_decorators;
+                    return class TestWorkflow extends _classSuper {
+                        static {
+                            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                            _counter_decorators = [ObservedState()];
+                            _testStep_decorators = [Step({ snapshotState: true })];
+                            __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);
+                            __esDecorate(null, null, _counter_decorators, { kind: "field", name: "counter", static: false, private: false, access: { has: obj => "counter" in obj, get: obj => obj.counter, set: (obj, value) => { obj.counter = value; } }, metadata: _metadata }, _counter_initializers, _counter_extraInitializers);
+                            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                        }
+                        counter = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _counter_initializers, 0));
+                        async testStep() {
+                            this.counter = 1;
+                            this.logger.info('Test message');
+                        }
+                        async run() {
+                            this.setStatus('running');
+                            await this.testStep();
+                            this.setStatus('completed');
+                        }
+                        constructor() {
+                            super(...arguments);
+                            __runInitializers(this, _counter_extraInitializers);
+                        }
+                    };
+                })();
+                const workflow = new TestWorkflow();
+                const observer = {
+                    onLog: (entry) => logs.push(entry.message),
+                    onEvent: (event) => events.push(event),
+                    onStateUpdated: () => stateUpdates.push(1),
+                    onTreeChanged: () => treeUpdates.push(1),
+                };
+                workflow.addObserver(observer);
+                await workflow.run();
+                expect(logs.length).toBeGreaterThan(0);
+                expect(logs.some(l => l === 'Test message')).toBe(true);
+                expect(events.length).toBeGreaterThan(0);
+                expect(stateUpdates.length).toBeGreaterThan(0);
+                expect(treeUpdates.length).toBeGreaterThan(0);
+            });
+        });
+    });
+});
+//# sourceMappingURL=backward-compatibility.test.js.map