groundswell 0.0.2 → 0.0.3

package/dist/__tests__/adversarial/prd-compliance.test.js

@@ -0,0 +1,886 @@
+/**
+ * PRD Compliance Tests
+ * These tests verify that the implementation matches the PRD specifications
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { describe, it, expect } from 'vitest';
+import { Workflow, Step, Task, ObservedState } from '../../index.js';
+import { WorkflowTreeDebugger } from '../../debugger/tree-debugger.js';
+describe('PRD Compliance Tests', () => {
+    describe('PRD Section 3.1: WorkflowNode Interface', () => {
+        it('should have all required WorkflowNode properties', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            const workflow = new TestWorkflow();
+            const node = workflow.getNode();
+            expect(node).toHaveProperty('id');
+            expect(node).toHaveProperty('name');
+            expect(node).toHaveProperty('parent');
+            expect(node).toHaveProperty('children');
+            expect(node).toHaveProperty('status');
+            expect(node).toHaveProperty('logs');
+            expect(node).toHaveProperty('events');
+            expect(node).toHaveProperty('stateSnapshot');
+        });
+        it('should initialize with correct default values', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            const workflow = new TestWorkflow();
+            const node = workflow.getNode();
+            expect(node.id).toBeDefined();
+            expect(node.name).toBe('TestWorkflow');
+            expect(node.parent).toBeNull();
+            expect(node.children).toEqual([]);
+            expect(node.status).toBe('idle');
+            expect(node.logs).toEqual([]);
+            expect(node.events).toEqual([]);
+            expect(node.stateSnapshot).toBeNull();
+        });
+    });
+    describe('PRD Section 3.2: WorkflowStatus Type', () => {
+        it('should support all 5 status values', async () => {
+            const validStatuses = ['idle', 'running', 'completed', 'failed', 'cancelled'];
+            class TestWorkflow extends Workflow {
+                async run() {
+                    for (const status of validStatuses) {
+                        this.setStatus(status);
+                        expect(this.status).toBe(status);
+                        expect(this.node.status).toBe(status);
+                    }
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+        });
+    });
+    describe('PRD Section 4.1: LogEntry Interface', () => {
+        it('should create log entries with all required properties', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    this.logger.info('Test message', { key: 'value' });
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+            const log = workflow.node.logs[0];
+            expect(log).toHaveProperty('id');
+            expect(log).toHaveProperty('workflowId');
+            expect(log).toHaveProperty('timestamp');
+            expect(log).toHaveProperty('level');
+            expect(log).toHaveProperty('message');
+            expect(log).toHaveProperty('data');
+        });
+        it('should support all 4 log levels', async () => {
+            const levels = ['debug', 'info', 'warn', 'error'];
+            class TestWorkflow extends Workflow {
+                async run() {
+                    this.logger.debug('debug msg');
+                    this.logger.info('info msg');
+                    this.logger.warn('warn msg');
+                    this.logger.error('error msg');
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+            expect(workflow.node.logs.length).toBe(4);
+            workflow.node.logs.forEach((log, i) => {
+                expect(log.level).toBe(levels[i]);
+            });
+        });
+    });
+    describe('PRD Section 4.2: WorkflowEvent Types', () => {
+        it('should emit stepStart event', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _testStep_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _testStep_decorators = [Step()];
+                        __esDecorate(this, null, _testStep_decorators, { kind: "method", name: "testStep", static: false, private: false, access: { has: obj => "testStep" in obj, get: obj => obj.testStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async testStep() {
+                        return 'done';
+                    }
+                    async run() {
+                        return this.testStep();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const events = [];
+            workflow.addObserver({
+                onLog: () => { },
+                onEvent: (e) => events.push(e),
+                onStateUpdated: () => { },
+                onTreeChanged: () => { },
+            });
+            await workflow.run();
+            const stepStart = events.find(e => e.type === 'stepStart');
+            expect(stepStart).toBeDefined();
+            if (stepStart?.type === 'stepStart') {
+                expect(stepStart.node).toBeDefined();
+                expect(stepStart.step).toBe('testStep');
+            }
+        });
+        it('should emit stepEnd event with duration', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _testStep_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _testStep_decorators = [Step()];
+                        __esDecorate(this, null, _testStep_decorators, { kind: "method", name: "testStep", static: false, private: false, access: { has: obj => "testStep" in obj, get: obj => obj.testStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async testStep() {
+                        return 'done';
+                    }
+                    async run() {
+                        return this.testStep();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const events = [];
+            workflow.addObserver({
+                onLog: () => { },
+                onEvent: (e) => events.push(e),
+                onStateUpdated: () => { },
+                onTreeChanged: () => { },
+            });
+            await workflow.run();
+            const stepEnd = events.find(e => e.type === 'stepEnd');
+            expect(stepEnd).toBeDefined();
+            if (stepEnd?.type === 'stepEnd') {
+                expect(stepEnd.node).toBeDefined();
+                expect(stepEnd.step).toBe('testStep');
+                expect(typeof stepEnd.duration).toBe('number');
+                expect(stepEnd.duration).toBeGreaterThanOrEqual(0);
+            }
+        });
+        it('should emit taskStart and taskEnd events', async () => {
+            class ChildWorkflow extends Workflow {
+                async run() {
+                    return 'child';
+                }
+            }
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChild_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChild_decorators = [Task()];
+                        __esDecorate(this, null, _spawnChild_decorators, { kind: "method", name: "spawnChild", static: false, private: false, access: { has: obj => "spawnChild" in obj, get: obj => obj.spawnChild }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChild() {
+                        return new ChildWorkflow('Child', this);
+                    }
+                    async run() {
+                        return this.spawnChild();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new ParentWorkflow();
+            const events = [];
+            workflow.addObserver({
+                onLog: () => { },
+                onEvent: (e) => events.push(e),
+                onStateUpdated: () => { },
+                onTreeChanged: () => { },
+            });
+            await workflow.run();
+            const taskStart = events.find(e => e.type === 'taskStart');
+            expect(taskStart).toBeDefined();
+            if (taskStart?.type === 'taskStart') {
+                expect(taskStart.task).toBe('spawnChild');
+            }
+            const taskEnd = events.find(e => e.type === 'taskEnd');
+            expect(taskEnd).toBeDefined();
+            if (taskEnd?.type === 'taskEnd') {
+                expect(taskEnd.task).toBe('spawnChild');
+            }
+        });
+    });
+    describe('PRD Section 5.1: WorkflowError Interface', () => {
+        it('should include all required fields in WorkflowError', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _testField_decorators;
+                let _testField_initializers = [];
+                let _testField_extraInitializers = [];
+                let _failingStep_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _testField_decorators = [ObservedState()];
+                        _failingStep_decorators = [Step()];
+                        __esDecorate(this, null, _failingStep_decorators, { kind: "method", name: "failingStep", static: false, private: false, access: { has: obj => "failingStep" in obj, get: obj => obj.failingStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        __esDecorate(null, null, _testField_decorators, { kind: "field", name: "testField", static: false, private: false, access: { has: obj => "testField" in obj, get: obj => obj.testField, set: (obj, value) => { obj.testField = value; } }, metadata: _metadata }, _testField_initializers, _testField_extraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    testField = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _testField_initializers, 'test-value'));
+                    async failingStep() {
+                        this.logger.info('About to fail');
+                        throw new Error('Test error');
+                    }
+                    async run() {
+                        try {
+                            await this.failingStep();
+                        }
+                        catch (err) {
+                            // Expected
+                        }
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _testField_extraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            let capturedError;
+            workflow.addObserver({
+                onLog: () => { },
+                onEvent: (e) => {
+                    if (e.type === 'error') {
+                        capturedError = e.error;
+                    }
+                },
+                onStateUpdated: () => { },
+                onTreeChanged: () => { },
+            });
+            await workflow.run();
+            expect(capturedError).toBeDefined();
+            expect(capturedError).toHaveProperty('message', 'Test error');
+            expect(capturedError).toHaveProperty('original');
+            expect(capturedError).toHaveProperty('workflowId');
+            expect(capturedError).toHaveProperty('stack');
+            expect(capturedError).toHaveProperty('state');
+            expect(capturedError).toHaveProperty('logs');
+            expect(Array.isArray(capturedError?.logs)).toBe(true);
+        });
+    });
+    describe('PRD Section 8.1: @Step Decorator Options', () => {
+        it('should support custom step name', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _someMethod_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _someMethod_decorators = [Step({ name: 'CustomStepName' })];
+                        __esDecorate(this, null, _someMethod_decorators, { kind: "method", name: "someMethod", static: false, private: false, access: { has: obj => "someMethod" in obj, get: obj => obj.someMethod }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async someMethod() {
+                        return 'done';
+                    }
+                    async run() {
+                        return this.someMethod();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const events = [];
+            workflow.addObserver({
+                onLog: () => { },
+                onEvent: (e) => events.push(e),
+                onStateUpdated: () => { },
+                onTreeChanged: () => { },
+            });
+            await workflow.run();
+            const stepStart = events.find(e => e.type === 'stepStart');
+            if (stepStart?.type === 'stepStart') {
+                expect(stepStart.step).toBe('CustomStepName');
+            }
+        });
+        it('should snapshot state when requested', async () => {
+            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, 42));
+                    async testStep() {
+                        this.counter = 100;
+                        return 'done';
+                    }
+                    async run() {
+                        return this.testStep();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _counter_extraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            await workflow.run();
+            expect(workflow.node.stateSnapshot).not.toBeNull();
+            expect(workflow.node.stateSnapshot?.counter).toBe(100);
+        });
+        it('should log start when requested', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _testStep_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _testStep_decorators = [Step({ logStart: 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);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async testStep() {
+                        return 'done';
+                    }
+                    async run() {
+                        return this.testStep();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            await workflow.run();
+            const hasStartLog = workflow.node.logs.some(l => l.message.includes('STEP START'));
+            expect(hasStartLog).toBe(true);
+        });
+        it('should log finish when requested', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _testStep_decorators;
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _testStep_decorators = [Step({ logFinish: 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);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async testStep() {
+                        return 'done';
+                    }
+                    async run() {
+                        return this.testStep();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            await workflow.run();
+            const hasEndLog = workflow.node.logs.some(l => l.message.includes('STEP END'));
+            expect(hasEndLog).toBe(true);
+        });
+    });
+    describe('PRD Section 8.2: @Task Decorator', () => {
+        it('should attach single child workflow', async () => {
+            class ChildWorkflow extends Workflow {
+                async run() {
+                    return 'child';
+                }
+            }
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChild_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChild_decorators = [Task()];
+                        __esDecorate(this, null, _spawnChild_decorators, { kind: "method", name: "spawnChild", static: false, private: false, access: { has: obj => "spawnChild" in obj, get: obj => obj.spawnChild }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChild() {
+                        return new ChildWorkflow('Child', this);
+                    }
+                    async run() {
+                        return this.spawnChild();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new ParentWorkflow();
+            await workflow.run();
+            expect(workflow.children.length).toBe(1);
+            expect(workflow.children[0].node.name).toBe('Child');
+        });
+        it('should attach multiple child workflows', async () => {
+            class ChildWorkflow extends Workflow {
+                async run() {
+                    return 'child';
+                }
+            }
+            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()];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        return [
+                            new ChildWorkflow('Child1', this),
+                            new ChildWorkflow('Child2', this),
+                            new ChildWorkflow('Child3', this),
+                        ];
+                    }
+                    async run() {
+                        return this.spawnChildren();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new ParentWorkflow();
+            await workflow.run();
+            expect(workflow.children.length).toBe(3);
+        });
+        it('should run workflows concurrently when concurrent: true', async () => {
+            let executionOrder = [];
+            class ChildWorkflow extends Workflow {
+                constructor(name, parent) {
+                    super(name, parent);
+                }
+                async run() {
+                    // Add a small delay
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                    executionOrder.push(this.node.name);
+                }
+            }
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChildren_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChildren_decorators = [Task({ concurrent: true })];
+                        __esDecorate(this, null, _spawnChildren_decorators, { kind: "method", name: "spawnChildren", static: false, private: false, access: { has: obj => "spawnChildren" in obj, get: obj => obj.spawnChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChildren() {
+                        return [
+                            new ChildWorkflow('Child1', this),
+                            new ChildWorkflow('Child2', this),
+                            new ChildWorkflow('Child3', this),
+                        ];
+                    }
+                    async run() {
+                        return this.spawnChildren();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new ParentWorkflow();
+            await workflow.run();
+            // All children should have been executed
+            expect(executionOrder.length).toBe(3);
+            // With concurrent execution, we can't guarantee order, but all should be present
+            expect(executionOrder).toContain('Child1');
+            expect(executionOrder).toContain('Child2');
+            expect(executionOrder).toContain('Child3');
+        });
+    });
+    describe('PRD Section 8.3: @ObservedState Decorator', () => {
+        it('should include marked fields in state snapshots', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _observedField_decorators;
+                let _observedField_initializers = [];
+                let _observedField_extraInitializers = [];
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _observedField_decorators = [ObservedState()];
+                        __esDecorate(null, null, _observedField_decorators, { kind: "field", name: "observedField", static: false, private: false, access: { has: obj => "observedField" in obj, get: obj => obj.observedField, set: (obj, value) => { obj.observedField = value; } }, metadata: _metadata }, _observedField_initializers, _observedField_extraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    observedField = __runInitializers(this, _observedField_initializers, 'observed');
+                    unobservedField = (__runInitializers(this, _observedField_extraInitializers), 'not-observed');
+                    async run() {
+                        this.snapshotState();
+                        return this.node.stateSnapshot;
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const snapshot = await workflow.run();
+            expect(snapshot).toHaveProperty('observedField', 'observed');
+            expect(snapshot).not.toHaveProperty('unobservedField');
+        });
+        it('should redact fields with redact: true', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _password_decorators;
+                let _password_initializers = [];
+                let _password_extraInitializers = [];
+                let _username_decorators;
+                let _username_initializers = [];
+                let _username_extraInitializers = [];
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _password_decorators = [ObservedState({ redact: true })];
+                        _username_decorators = [ObservedState()];
+                        __esDecorate(null, null, _password_decorators, { kind: "field", name: "password", static: false, private: false, access: { has: obj => "password" in obj, get: obj => obj.password, set: (obj, value) => { obj.password = value; } }, metadata: _metadata }, _password_initializers, _password_extraInitializers);
+                        __esDecorate(null, null, _username_decorators, { kind: "field", name: "username", static: false, private: false, access: { has: obj => "username" in obj, get: obj => obj.username, set: (obj, value) => { obj.username = value; } }, metadata: _metadata }, _username_initializers, _username_extraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    password = __runInitializers(this, _password_initializers, 'secret123');
+                    username = (__runInitializers(this, _password_extraInitializers), __runInitializers(this, _username_initializers, 'alice'));
+                    async run() {
+                        this.snapshotState();
+                        return this.node.stateSnapshot;
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _username_extraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const snapshot = await workflow.run();
+            expect(snapshot?.password).toBe('***');
+            expect(snapshot?.username).toBe('alice');
+        });
+        it('should hide fields with hidden: true', async () => {
+            let TestWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _internalState_decorators;
+                let _internalState_initializers = [];
+                let _internalState_extraInitializers = [];
+                let _publicState_decorators;
+                let _publicState_initializers = [];
+                let _publicState_extraInitializers = [];
+                return class TestWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _internalState_decorators = [ObservedState({ hidden: true })];
+                        _publicState_decorators = [ObservedState()];
+                        __esDecorate(null, null, _internalState_decorators, { kind: "field", name: "internalState", static: false, private: false, access: { has: obj => "internalState" in obj, get: obj => obj.internalState, set: (obj, value) => { obj.internalState = value; } }, metadata: _metadata }, _internalState_initializers, _internalState_extraInitializers);
+                        __esDecorate(null, null, _publicState_decorators, { kind: "field", name: "publicState", static: false, private: false, access: { has: obj => "publicState" in obj, get: obj => obj.publicState, set: (obj, value) => { obj.publicState = value; } }, metadata: _metadata }, _publicState_initializers, _publicState_extraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    internalState = __runInitializers(this, _internalState_initializers, 'internal');
+                    publicState = (__runInitializers(this, _internalState_extraInitializers), __runInitializers(this, _publicState_initializers, 'public'));
+                    async run() {
+                        this.snapshotState();
+                        return this.node.stateSnapshot;
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _publicState_extraInitializers);
+                    }
+                };
+            })();
+            const workflow = new TestWorkflow();
+            const snapshot = await workflow.run();
+            expect(snapshot).not.toHaveProperty('internalState');
+            expect(snapshot).toHaveProperty('publicState', 'public');
+        });
+    });
+    describe('PRD Section 11: Tree Debugger API', () => {
+        it('should implement getTree() method', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            const workflow = new TestWorkflow();
+            const debuggerInstance = new WorkflowTreeDebugger(workflow);
+            const tree = debuggerInstance.getTree();
+            expect(tree).toBeDefined();
+            expect(tree.id).toBe(workflow.id);
+        });
+        it('should implement getNode(id) method', async () => {
+            class ChildWorkflow extends Workflow {
+                async run() {
+                    return 'child';
+                }
+            }
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _spawnChild_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _spawnChild_decorators = [Task()];
+                        __esDecorate(this, null, _spawnChild_decorators, { kind: "method", name: "spawnChild", static: false, private: false, access: { has: obj => "spawnChild" in obj, get: obj => obj.spawnChild }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async spawnChild() {
+                        return new ChildWorkflow('Child', this);
+                    }
+                    async run() {
+                        return this.spawnChild();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new ParentWorkflow();
+            const debuggerInstance = new WorkflowTreeDebugger(workflow);
+            await workflow.run();
+            const childNode = debuggerInstance.getNode(workflow.children[0].id);
+            expect(childNode).toBeDefined();
+            expect(childNode?.name).toBe('Child');
+        });
+        it('should provide events Observable', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            const workflow = new TestWorkflow();
+            const debuggerInstance = new WorkflowTreeDebugger(workflow);
+            expect(debuggerInstance.events).toBeDefined();
+            expect(debuggerInstance.events.subscribe).toBeDefined();
+        });
+        it('should implement toTreeString() method', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            const workflow = new TestWorkflow();
+            const debuggerInstance = new WorkflowTreeDebugger(workflow);
+            const treeString = debuggerInstance.toTreeString();
+            expect(typeof treeString).toBe('string');
+            expect(treeString.length).toBeGreaterThan(0);
+        });
+        it('should implement toLogString() method', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    this.logger.info('Test log message');
+                }
+            }
+            const workflow = new TestWorkflow();
+            const debuggerInstance = new WorkflowTreeDebugger(workflow);
+            await workflow.run();
+            const logString = debuggerInstance.toLogString();
+            expect(typeof logString).toBe('string');
+            expect(logString).toContain('Test log message');
+        });
+    });
+    describe('PRD Section 12.2: Workflow Base Class', () => {
+        it('should have id, parent, children, and status properties', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    return 'done';
+                }
+            }
+            const workflow = new TestWorkflow();
+            expect(workflow.id).toBeDefined();
+            expect(workflow.parent).toBeDefined();
+            expect(workflow.children).toBeDefined();
+            expect(workflow.status).toBeDefined();
+        });
+        it('should have attachChild method', async () => {
+            class ChildWorkflow extends Workflow {
+                async run() {
+                    return 'child';
+                }
+            }
+            class ParentWorkflow extends Workflow {
+                async run() {
+                    const child = new ChildWorkflow('Child', this);
+                    expect(workflow.children.length).toBe(1);
+                }
+            }
+            const workflow = new ParentWorkflow();
+            await workflow.run();
+        });
+        it('should have snapshotState method', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    this.snapshotState();
+                    expect(this.node.stateSnapshot).not.toBeNull();
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+        });
+        it('should have setStatus method', async () => {
+            class TestWorkflow extends Workflow {
+                async run() {
+                    this.setStatus('running');
+                    expect(this.status).toBe('running');
+                    expect(this.node.status).toBe('running');
+                }
+            }
+            const workflow = new TestWorkflow();
+            await workflow.run();
+        });
+    });
+    describe('PRD: Perfect 1:1 Tree Mirror Requirement', () => {
+        it('should maintain perfect tree structure in logs and events', async () => {
+            let ChildWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _childStep_decorators;
+                return class ChildWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _childStep_decorators = [Step()];
+                        __esDecorate(this, null, _childStep_decorators, { kind: "method", name: "childStep", static: false, private: false, access: { has: obj => "childStep" in obj, get: obj => obj.childStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                    }
+                    async childStep() {
+                        this.logger.info('Child step executed');
+                        return 'child-step-done';
+                    }
+                    async run() {
+                        return this.childStep();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            let ParentWorkflow = (() => {
+                let _classSuper = Workflow;
+                let _instanceExtraInitializers = [];
+                let _parentStep_decorators;
+                let _spawnChild_decorators;
+                return class ParentWorkflow extends _classSuper {
+                    static {
+                        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                        _parentStep_decorators = [Step()];
+                        _spawnChild_decorators = [Task()];
+                        __esDecorate(this, null, _parentStep_decorators, { kind: "method", name: "parentStep", static: false, private: false, access: { has: obj => "parentStep" in obj, get: obj => obj.parentStep }, metadata: _metadata }, null, _instanceExtraInitializers);
+                        __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 parentStep() {
+                        this.logger.info('Parent step executed');
+                        return 'parent-step-done';
+                    }
+                    async spawnChild() {
+                        return new ChildWorkflow('Child', this);
+                    }
+                    async run() {
+                        await this.parentStep();
+                        await this.spawnChild();
+                        await this.children[0].run();
+                    }
+                    constructor() {
+                        super(...arguments);
+                        __runInitializers(this, _instanceExtraInitializers);
+                    }
+                };
+            })();
+            const workflow = new ParentWorkflow();
+            await workflow.run();
+            // Parent should have 1 child
+            expect(workflow.children.length).toBe(1);
+            expect(workflow.children[0].node.name).toBe('Child');
+            // Parent logs should exist
+            expect(workflow.node.logs.length).toBeGreaterThan(0);
+            // Parent events should exist
+            expect(workflow.node.events.length).toBeGreaterThan(0);
+            // Child should have logs
+            expect(workflow.children[0].node.logs.length).toBeGreaterThan(0);
+            // Child should have events
+            expect(workflow.children[0].node.events.length).toBeGreaterThan(0);
+        });
+    });
+});
+//# sourceMappingURL=prd-compliance.test.js.map