windmill-components 1.558.3 → 1.596.0

package/package/components/flows/flowDiff.test.js

@@ -0,0 +1,1173 @@
+import { describe, it, expect } from 'vitest';
+import { buildFlowTimeline, hasInputSchemaChanged } from './flowDiff';
+import { createRawScriptModule, createIdentityModule, createForloopModule, createWhileloopModule, createBranchOneModule, createBranchAllModule, createFlow, createFlowWithSpecialModules, expectModuleOrder } from './flowDiff.testUtils';
+describe('buildFlowTimeline', () => {
+    describe('basic detection', () => {
+        it('returns empty actions for identical flows', () => {
+            const moduleA = createRawScriptModule('a', 'console.log("hello")');
+            const beforeFlow = createFlow([moduleA]);
+            const afterFlow = createFlow([moduleA]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(Object.keys(result.beforeActions)).toHaveLength(0);
+            expect(Object.keys(result.afterActions)).toHaveLength(0);
+        });
+        it('detects added module', () => {
+            const moduleA = createRawScriptModule('a', 'console.log("a")');
+            const moduleB = createRawScriptModule('b', 'console.log("b")');
+            const beforeFlow = createFlow([moduleA]);
+            const afterFlow = createFlow([moduleA, moduleB]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions).toEqual({});
+            expect(result.afterActions).toEqual({
+                b: { action: 'added', pending: false }
+            });
+        });
+        it('detects removed module', () => {
+            const moduleA = createRawScriptModule('a', 'console.log("a")');
+            const moduleB = createRawScriptModule('b', 'console.log("b")');
+            const beforeFlow = createFlow([moduleA, moduleB]);
+            const afterFlow = createFlow([moduleA]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions).toEqual({
+                b: { action: 'removed', pending: false }
+            });
+            // By default markRemovedAsShadowed is false, so removed modules show as 'removed' in afterActions
+            expect(result.afterActions).toEqual({
+                b: { action: 'removed', pending: false }
+            });
+        });
+        it('detects modified module (same type, different content)', () => {
+            const moduleBeforeA = createRawScriptModule('a', 'console.log("before")');
+            const moduleAfterA = createRawScriptModule('a', 'console.log("after")');
+            const beforeFlow = createFlow([moduleBeforeA]);
+            const afterFlow = createFlow([moduleAfterA]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions).toEqual({
+                a: { action: 'modified', pending: false }
+            });
+            expect(result.afterActions).toEqual({
+                a: { action: 'modified', pending: false }
+            });
+        });
+        it('treats type change as removed + added (not modified)', () => {
+            const moduleBeforeA = createRawScriptModule('a', 'console.log("script")');
+            const moduleAfterA = createIdentityModule('a');
+            const beforeFlow = createFlow([moduleBeforeA]);
+            const afterFlow = createFlow([moduleAfterA]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions).toEqual({
+                a: { action: 'removed', pending: false }
+            });
+            // The new module is 'added', and the old module is kept in mergedFlow
+            // with a prefixed ID 'old__a' and marked as 'removed'
+            expect(result.afterActions['a']).toEqual({ action: 'added', pending: false });
+            expect(result.afterActions['old__a']).toEqual({ action: 'removed', pending: false });
+        });
+    });
+    describe('options', () => {
+        it('markAsPending sets pending: true on all actions', () => {
+            const moduleA = createRawScriptModule('a', 'console.log("a")');
+            const moduleB = createRawScriptModule('b', 'console.log("b")');
+            const beforeFlow = createFlow([moduleA]);
+            const afterFlow = createFlow([moduleB]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow, {
+                markAsPending: true,
+                markRemovedAsShadowed: false
+            });
+            expect(result.beforeActions).toEqual({
+                a: { action: 'removed', pending: true }
+            });
+            expect(result.afterActions).toEqual({
+                a: { action: 'removed', pending: true },
+                b: { action: 'added', pending: true }
+            });
+        });
+        it('markRemovedAsShadowed: true shows removed as shadowed in afterActions', () => {
+            const moduleA = createRawScriptModule('a', 'console.log("a")');
+            const moduleB = createRawScriptModule('b', 'console.log("b")');
+            const beforeFlow = createFlow([moduleA, moduleB]);
+            const afterFlow = createFlow([moduleA]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow, {
+                markAsPending: false,
+                markRemovedAsShadowed: true
+            });
+            expect(result.beforeActions).toEqual({
+                b: { action: 'removed', pending: false }
+            });
+            expect(result.afterActions).toEqual({
+                b: { action: 'shadowed', pending: false }
+            });
+        });
+        it('markRemovedAsShadowed: false shows removed as removed in afterActions', () => {
+            const moduleA = createRawScriptModule('a', 'console.log("a")');
+            const moduleB = createRawScriptModule('b', 'console.log("b")');
+            const beforeFlow = createFlow([moduleA, moduleB]);
+            const afterFlow = createFlow([moduleA]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow, {
+                markAsPending: false,
+                markRemovedAsShadowed: false
+            });
+            expect(result.beforeActions).toEqual({
+                b: { action: 'removed', pending: false }
+            });
+            expect(result.afterActions).toEqual({
+                b: { action: 'removed', pending: false }
+            });
+        });
+    });
+    describe('mergedFlow', () => {
+        it('mergedFlow contains all modules from afterFlow', () => {
+            const moduleA = createRawScriptModule('a', 'console.log("a")');
+            const moduleB = createRawScriptModule('b', 'console.log("b")');
+            const beforeFlow = createFlow([moduleA]);
+            const afterFlow = createFlow([moduleA, moduleB]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['a', 'b']);
+        });
+        it('mergedFlow includes removed modules from beforeFlow', () => {
+            const moduleA = createRawScriptModule('a', 'console.log("a")');
+            const moduleB = createRawScriptModule('b', 'console.log("b")');
+            const beforeFlow = createFlow([moduleA, moduleB]);
+            const afterFlow = createFlow([moduleA]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['a', 'b']);
+        });
+    });
+    describe('edge cases', () => {
+        it('handles empty flows', () => {
+            const beforeFlow = createFlow([]);
+            const afterFlow = createFlow([]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(Object.keys(result.beforeActions)).toHaveLength(0);
+            expect(Object.keys(result.afterActions)).toHaveLength(0);
+            expect(result.mergedFlow.modules).toHaveLength(0);
+        });
+        it('handles flow with undefined modules', () => {
+            const beforeFlow = {};
+            const afterFlow = {};
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(Object.keys(result.beforeActions)).toHaveLength(0);
+            expect(Object.keys(result.afterActions)).toHaveLength(0);
+        });
+        it('handles multiple changes at once', () => {
+            const moduleA = createRawScriptModule('a', 'original');
+            const moduleB = createRawScriptModule('b', 'to be removed');
+            const moduleAModified = createRawScriptModule('a', 'modified');
+            const moduleC = createRawScriptModule('c', 'newly added');
+            const beforeFlow = createFlow([moduleA, moduleB]);
+            const afterFlow = createFlow([moduleAModified, moduleC]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // Module 'a' was modified
+            expect(result.beforeActions['a']).toEqual({ action: 'modified', pending: false });
+            expect(result.afterActions['a']).toEqual({ action: 'modified', pending: false });
+            // Module 'b' was removed
+            expect(result.beforeActions['b']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['b']).toEqual({ action: 'removed', pending: false });
+            // Module 'c' was added
+            expect(result.afterActions['c']).toEqual({ action: 'added', pending: false });
+        });
+    });
+    describe('forloop operations', () => {
+        it('detects added module inside forloop', () => {
+            const innerA = createRawScriptModule('inner_a', 'step a');
+            const innerB = createRawScriptModule('inner_b', 'step b');
+            const beforeLoop = createForloopModule('loop1', [innerA]);
+            const afterLoop = createForloopModule('loop1', [innerA, innerB]);
+            const beforeFlow = createFlow([beforeLoop]);
+            const afterFlow = createFlow([afterLoop]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['inner_b']).toEqual({ action: 'added', pending: false });
+            expect(result.beforeActions['inner_b']).toBeUndefined();
+            // Verify mergedFlow contains the loop with both modules in correct order
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['loop1']);
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'loop1');
+            expect(mergedLoop?.value.type).toBe('forloopflow');
+            const loopModules = (mergedLoop?.value).modules;
+            expectModuleOrder(loopModules, ['inner_a', 'inner_b']);
+        });
+        it('detects removed module from inside forloop', () => {
+            const innerA = createRawScriptModule('inner_a', 'step a');
+            const innerB = createRawScriptModule('inner_b', 'step b');
+            const beforeLoop = createForloopModule('loop1', [innerA, innerB]);
+            const afterLoop = createForloopModule('loop1', [innerA]);
+            const beforeFlow = createFlow([beforeLoop]);
+            const afterFlow = createFlow([afterLoop]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions['inner_b']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['inner_b']).toEqual({ action: 'removed', pending: false });
+            // Verify removed module is in mergedFlow inside the loop at correct position
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'loop1');
+            expect(mergedLoop?.value.type).toBe('forloopflow');
+            const loopModules = (mergedLoop?.value).modules;
+            expectModuleOrder(loopModules, ['inner_a', 'inner_b']);
+        });
+        it('detects modified module inside forloop', () => {
+            const innerBefore = createRawScriptModule('inner_a', 'original code');
+            const innerAfter = createRawScriptModule('inner_a', 'modified code');
+            const beforeLoop = createForloopModule('loop1', [innerBefore]);
+            const afterLoop = createForloopModule('loop1', [innerAfter]);
+            const beforeFlow = createFlow([beforeLoop]);
+            const afterFlow = createFlow([afterLoop]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions['inner_a']).toEqual({ action: 'modified', pending: false });
+            expect(result.afterActions['inner_a']).toEqual({ action: 'modified', pending: false });
+            // Verify mergedFlow contains the loop with the modified module
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['loop1']);
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'loop1');
+            const loopModules = (mergedLoop?.value).modules;
+            expectModuleOrder(loopModules, ['inner_a']);
+            // Verify the modified content is present (from afterFlow)
+            const innerModule = loopModules.find((m) => m.id === 'inner_a');
+            expect((innerModule?.value).content).toBe('modified code');
+        });
+        it('detects removal of entire forloop with nested children', () => {
+            const innerA = createRawScriptModule('inner_a', 'step a');
+            const innerB = createRawScriptModule('inner_b', 'step b');
+            const loop = createForloopModule('loop1', [innerA, innerB]);
+            const moduleC = createRawScriptModule('c', 'step c');
+            const beforeFlow = createFlow([loop, moduleC]);
+            const afterFlow = createFlow([moduleC]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // The loop itself and all nested modules should be marked as removed
+            expect(result.beforeActions['loop1']).toEqual({ action: 'removed', pending: false });
+            expect(result.beforeActions['inner_a']).toEqual({ action: 'removed', pending: false });
+            expect(result.beforeActions['inner_b']).toEqual({ action: 'removed', pending: false });
+            // Verify mergedFlow contains the removed loop with all nested children at correct positions
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['loop1', 'c']);
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'loop1');
+            expect(mergedLoop?.value.type).toBe('forloopflow');
+            const loopModules = (mergedLoop?.value).modules;
+            expectModuleOrder(loopModules, ['inner_a', 'inner_b']);
+        });
+        it('handles nested forloop inside forloop with changes at inner level', () => {
+            const deepInnerA = createRawScriptModule('deep_a', 'deep step');
+            const deepInnerB = createRawScriptModule('deep_b', 'new deep step');
+            const innerLoopBefore = createForloopModule('inner_loop', [deepInnerA]);
+            const innerLoopAfter = createForloopModule('inner_loop', [deepInnerA, deepInnerB]);
+            const outerLoopBefore = createForloopModule('outer_loop', [innerLoopBefore]);
+            const outerLoopAfter = createForloopModule('outer_loop', [innerLoopAfter]);
+            const beforeFlow = createFlow([outerLoopBefore]);
+            const afterFlow = createFlow([outerLoopAfter]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // The new nested module is detected as added
+            expect(result.afterActions['deep_b']).toEqual({ action: 'added', pending: false });
+            // Note: Container modules are marked as 'modified' because their nested content changed
+            // (deepEqual comparison includes nested modules array)
+            expect(result.beforeActions['outer_loop']).toEqual({ action: 'modified', pending: false });
+            expect(result.beforeActions['inner_loop']).toEqual({ action: 'modified', pending: false });
+            // Verify mergedFlow preserves the outer_loop → inner_loop → [deep_a, deep_b] structure
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['outer_loop']);
+            const mergedOuterLoop = result.mergedFlow.modules?.find((m) => m.id === 'outer_loop');
+            expect(mergedOuterLoop?.value.type).toBe('forloopflow');
+            const outerLoopModules = (mergedOuterLoop?.value).modules;
+            expectModuleOrder(outerLoopModules, ['inner_loop']);
+            const mergedInnerLoop = outerLoopModules.find((m) => m.id === 'inner_loop');
+            expect(mergedInnerLoop?.value.type).toBe('forloopflow');
+            const innerLoopModules = (mergedInnerLoop?.value).modules;
+            expectModuleOrder(innerLoopModules, ['deep_a', 'deep_b']);
+        });
+    });
+    describe('whileloop operations', () => {
+        it('detects changes inside whileloop', () => {
+            const innerA = createRawScriptModule('while_inner_a', 'step a');
+            const innerB = createRawScriptModule('while_inner_b', 'step b');
+            const beforeLoop = createWhileloopModule('while1', [innerA]);
+            const afterLoop = createWhileloopModule('while1', [innerA, innerB]);
+            const beforeFlow = createFlow([beforeLoop]);
+            const afterFlow = createFlow([afterLoop]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['while_inner_b']).toEqual({ action: 'added', pending: false });
+            // Verify mergedFlow contains the whileloop with both modules in correct order
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['while1']);
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'while1');
+            expect(mergedLoop?.value.type).toBe('whileloopflow');
+            const loopModules = (mergedLoop?.value).modules;
+            expectModuleOrder(loopModules, ['while_inner_a', 'while_inner_b']);
+        });
+        it('handles removal of module from whileloop and restores in mergedFlow', () => {
+            const innerA = createRawScriptModule('while_a', 'step a');
+            const innerB = createRawScriptModule('while_b', 'step b');
+            const beforeLoop = createWhileloopModule('while1', [innerA, innerB]);
+            const afterLoop = createWhileloopModule('while1', [innerA]);
+            const beforeFlow = createFlow([beforeLoop]);
+            const afterFlow = createFlow([afterLoop]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions['while_b']).toEqual({ action: 'removed', pending: false });
+            // Verify mergedFlow contains the removed module at correct position
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'while1');
+            const loopModules = (mergedLoop?.value).modules;
+            expectModuleOrder(loopModules, ['while_a', 'while_b']);
+        });
+    });
+    describe('branchone operations', () => {
+        it('detects added module in default branch', () => {
+            const defaultA = createRawScriptModule('default_a', 'default step a');
+            const defaultB = createRawScriptModule('default_b', 'default step b');
+            const beforeBranch = createBranchOneModule('branch1', [defaultA], []);
+            const afterBranch = createBranchOneModule('branch1', [defaultA, defaultB], []);
+            const beforeFlow = createFlow([beforeBranch]);
+            const afterFlow = createFlow([afterBranch]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['default_b']).toEqual({ action: 'added', pending: false });
+            // Verify mergedFlow.branch1.default contains both modules in correct order
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['branch1']);
+            const mergedBranch = result.mergedFlow.modules?.find((m) => m.id === 'branch1');
+            expect(mergedBranch?.value.type).toBe('branchone');
+            const defaultModules = (mergedBranch?.value).default;
+            expectModuleOrder(defaultModules, ['default_a', 'default_b']);
+        });
+        it('detects removed module from conditional branch', () => {
+            const branchModuleA = createRawScriptModule('branch_a', 'branch step a');
+            const branchModuleB = createRawScriptModule('branch_b', 'branch step b');
+            const beforeBranch = createBranchOneModule('branch1', [], [
+                { expr: 'true', modules: [branchModuleA, branchModuleB] }
+            ]);
+            const afterBranch = createBranchOneModule('branch1', [], [
+                { expr: 'true', modules: [branchModuleA] }
+            ]);
+            const beforeFlow = createFlow([beforeBranch]);
+            const afterFlow = createFlow([afterBranch]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions['branch_b']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['branch_b']).toEqual({ action: 'removed', pending: false });
+            // Verify mergedFlow.branch1.branches[0].modules contains the removed branch_b at correct position
+            const mergedBranch = result.mergedFlow.modules?.find((m) => m.id === 'branch1');
+            const branches = (mergedBranch?.value).branches;
+            expect(branches).toHaveLength(1);
+            expectModuleOrder(branches[0].modules, ['branch_a', 'branch_b']);
+        });
+        it('detects removal of entire conditional branch', () => {
+            const defaultModule = createRawScriptModule('default_mod', 'default');
+            const branch1ModuleA = createRawScriptModule('b1_a', 'branch 1 a');
+            const branch2ModuleA = createRawScriptModule('b2_a', 'branch 2 a');
+            const branch2ModuleB = createRawScriptModule('b2_b', 'branch 2 b');
+            const beforeBranch = createBranchOneModule('branch1', [defaultModule], [
+                { expr: 'x > 0', modules: [branch1ModuleA] },
+                { expr: 'x < 0', modules: [branch2ModuleA, branch2ModuleB] } // entire branch removed
+            ]);
+            const afterBranch = createBranchOneModule('branch1', [defaultModule], [
+                { expr: 'x > 0', modules: [branch1ModuleA] }
+            ]);
+            const beforeFlow = createFlow([beforeBranch]);
+            const afterFlow = createFlow([afterBranch]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // All modules from removed branch should be marked as removed
+            expect(result.beforeActions['b2_a']).toEqual({ action: 'removed', pending: false });
+            expect(result.beforeActions['b2_b']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['b2_a']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['b2_b']).toEqual({ action: 'removed', pending: false });
+            // Verify mergedFlow structure - should have 2 branches with removed modules restored
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['branch1']);
+            const mergedBranch = result.mergedFlow.modules?.find((m) => m.id === 'branch1');
+            const branchValue = mergedBranch?.value;
+            // Default branch unchanged
+            expectModuleOrder(branchValue.default, ['default_mod']);
+            // First branch unchanged
+            expectModuleOrder(branchValue.branches[0].modules, ['b1_a']);
+            // Second branch should be restored with its modules
+            expect(branchValue.branches).toHaveLength(2);
+            expectModuleOrder(branchValue.branches[1].modules, ['b2_a', 'b2_b']);
+        });
+        it('detects changes across multiple branches simultaneously', () => {
+            const defaultModule = createRawScriptModule('default_mod', 'default');
+            const branch1ModuleA = createRawScriptModule('b1_a', 'branch 1 a');
+            const branch1ModuleB = createRawScriptModule('b1_b', 'branch 1 b - new');
+            const branch2ModuleA = createRawScriptModule('b2_a', 'branch 2 a - original');
+            const branch2ModuleAModified = createRawScriptModule('b2_a', 'branch 2 a - modified');
+            const beforeBranch = createBranchOneModule('branch1', [defaultModule], [
+                { expr: 'x > 0', modules: [branch1ModuleA] },
+                { expr: 'x < 0', modules: [branch2ModuleA] }
+            ]);
+            const afterBranch = createBranchOneModule('branch1', [defaultModule], [
+                { expr: 'x > 0', modules: [branch1ModuleA, branch1ModuleB] },
+                { expr: 'x < 0', modules: [branch2ModuleAModified] }
+            ]);
+            const beforeFlow = createFlow([beforeBranch]);
+            const afterFlow = createFlow([afterBranch]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // branch1ModuleB was added
+            expect(result.afterActions['b1_b']).toEqual({ action: 'added', pending: false });
+            // branch2ModuleA was modified
+            expect(result.beforeActions['b2_a']).toEqual({ action: 'modified', pending: false });
+            expect(result.afterActions['b2_a']).toEqual({ action: 'modified', pending: false });
+            // Verify mergedFlow preserves structure with correct ordering
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['branch1']);
+            const mergedBranch = result.mergedFlow.modules?.find((m) => m.id === 'branch1');
+            const branchValue = mergedBranch?.value;
+            // Check default branch
+            expectModuleOrder(branchValue.default, ['default_mod']);
+            // Check first conditional branch (should have b1_a and b1_b in order)
+            expectModuleOrder(branchValue.branches[0].modules, ['b1_a', 'b1_b']);
+            // Check second conditional branch (should have modified b2_a)
+            expectModuleOrder(branchValue.branches[1].modules, ['b2_a']);
+            const b2aModule = branchValue.branches[1].modules.find((m) => m.id === 'b2_a');
+            expect((b2aModule?.value).content).toBe('branch 2 a - modified');
+        });
+        it('handles nested branch inside loop with changes', () => {
+            const branchInnerA = createRawScriptModule('nested_branch_a', 'nested a');
+            const branchInnerB = createRawScriptModule('nested_branch_b', 'nested b');
+            const beforeBranch = createBranchOneModule('inner_branch', [branchInnerA], []);
+            const afterBranch = createBranchOneModule('inner_branch', [branchInnerA, branchInnerB], []);
+            const beforeLoop = createForloopModule('outer_loop', [beforeBranch]);
+            const afterLoop = createForloopModule('outer_loop', [afterBranch]);
+            const beforeFlow = createFlow([beforeLoop]);
+            const afterFlow = createFlow([afterLoop]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['nested_branch_b']).toEqual({ action: 'added', pending: false });
+            // Verify mergedFlow.outer_loop.inner_branch.default contains added nested_branch_b at correct position
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['outer_loop']);
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'outer_loop');
+            const loopModules = (mergedLoop?.value).modules;
+            expectModuleOrder(loopModules, ['inner_branch']);
+            const mergedBranch = loopModules.find((m) => m.id === 'inner_branch');
+            const branchDefault = (mergedBranch?.value).default;
+            expectModuleOrder(branchDefault, ['nested_branch_a', 'nested_branch_b']);
+        });
+    });
+    describe('branchall operations', () => {
+        it('detects changes in parallel branches', () => {
+            const parallel1A = createRawScriptModule('p1_a', 'parallel 1 a');
+            const parallel2A = createRawScriptModule('p2_a', 'parallel 2 a');
+            const parallel2B = createRawScriptModule('p2_b', 'parallel 2 b - new');
+            const beforeBranchAll = createBranchAllModule('branchall1', [
+                { modules: [parallel1A] },
+                { modules: [parallel2A] }
+            ]);
+            const afterBranchAll = createBranchAllModule('branchall1', [
+                { modules: [parallel1A] },
+                { modules: [parallel2A, parallel2B] }
+            ]);
+            const beforeFlow = createFlow([beforeBranchAll]);
+            const afterFlow = createFlow([afterBranchAll]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['p2_b']).toEqual({ action: 'added', pending: false });
+            // Verify mergedFlow.branchall1.branches have correct module order
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['branchall1']);
+            const mergedBranchAll = result.mergedFlow.modules?.find((m) => m.id === 'branchall1');
+            expect(mergedBranchAll?.value.type).toBe('branchall');
+            const branches = (mergedBranchAll?.value).branches;
+            expect(branches).toHaveLength(2);
+            // First branch unchanged
+            expectModuleOrder(branches[0].modules, ['p1_a']);
+            // Second branch has added module in correct order
+            expectModuleOrder(branches[1].modules, ['p2_a', 'p2_b']);
+        });
+        it('detects removal of entire branchall with all nested modules', () => {
+            const parallel1A = createRawScriptModule('p1_a', 'parallel 1');
+            const parallel2A = createRawScriptModule('p2_a', 'parallel 2');
+            const branchAll = createBranchAllModule('branchall1', [
+                { modules: [parallel1A] },
+                { modules: [parallel2A] }
+            ]);
+            const moduleC = createRawScriptModule('c', 'step c');
+            const beforeFlow = createFlow([branchAll, moduleC]);
+            const afterFlow = createFlow([moduleC]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions['branchall1']).toEqual({ action: 'removed', pending: false });
+            expect(result.beforeActions['p1_a']).toEqual({ action: 'removed', pending: false });
+            expect(result.beforeActions['p2_a']).toEqual({ action: 'removed', pending: false });
+            // Verify mergedFlow contains the removed branchall with correct structure
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['branchall1', 'c']);
+            const mergedBranchAll = result.mergedFlow.modules?.find((m) => m.id === 'branchall1');
+            expect(mergedBranchAll?.value.type).toBe('branchall');
+            const branches = (mergedBranchAll?.value).branches;
+            expect(branches).toHaveLength(2);
+            expectModuleOrder(branches[0].modules, ['p1_a']);
+            expectModuleOrder(branches[1].modules, ['p2_a']);
+        });
+        it('handles removal from one parallel branch while adding to another', () => {
+            const parallel1A = createRawScriptModule('p1_a', 'parallel 1 a');
+            const parallel1B = createRawScriptModule('p1_b', 'parallel 1 b - to remove');
+            const parallel2A = createRawScriptModule('p2_a', 'parallel 2 a');
+            const parallel2B = createRawScriptModule('p2_b', 'parallel 2 b - new');
+            const beforeBranchAll = createBranchAllModule('branchall1', [
+                { modules: [parallel1A, parallel1B] },
+                { modules: [parallel2A] }
+            ]);
+            const afterBranchAll = createBranchAllModule('branchall1', [
+                { modules: [parallel1A] },
+                { modules: [parallel2A, parallel2B] }
+            ]);
+            const beforeFlow = createFlow([beforeBranchAll]);
+            const afterFlow = createFlow([afterBranchAll]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions['p1_b']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['p2_b']).toEqual({ action: 'added', pending: false });
+            // Verify mergedFlow.branchall1 has correct structure with all modules in order
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['branchall1']);
+            const mergedBranchAll = result.mergedFlow.modules?.find((m) => m.id === 'branchall1');
+            const branches = (mergedBranchAll?.value).branches;
+            expect(branches).toHaveLength(2);
+            // First branch should have both p1_a and removed p1_b restored in order
+            expectModuleOrder(branches[0].modules, ['p1_a', 'p1_b']);
+            // Second branch should have p2_a and added p2_b in order
+            expectModuleOrder(branches[1].modules, ['p2_a', 'p2_b']);
+        });
+    });
+    describe('deep nesting', () => {
+        it('handles loop inside branch inside loop with modifications at each level', () => {
+            // Structure: outerLoop -> branch -> innerLoop -> scripts
+            const deepScript1 = createRawScriptModule('deep1', 'deep script 1');
+            const deepScript2 = createRawScriptModule('deep2', 'deep script 2');
+            const deepScript3 = createRawScriptModule('deep3', 'deep script 3 - new');
+            const innerLoopBefore = createForloopModule('inner_loop', [deepScript1, deepScript2]);
+            const innerLoopAfter = createForloopModule('inner_loop', [deepScript1, deepScript3]);
+            const branchBefore = createBranchOneModule('mid_branch', [innerLoopBefore], []);
+            const branchAfter = createBranchOneModule('mid_branch', [innerLoopAfter], []);
+            const outerLoopBefore = createForloopModule('outer_loop', [branchBefore]);
+            const outerLoopAfter = createForloopModule('outer_loop', [branchAfter]);
+            const beforeFlow = createFlow([outerLoopBefore]);
+            const afterFlow = createFlow([outerLoopAfter]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // deep2 was removed
+            expect(result.beforeActions['deep2']).toEqual({ action: 'removed', pending: false });
+            // deep3 was added
+            expect(result.afterActions['deep3']).toEqual({ action: 'added', pending: false });
+            // Note: Container modules are marked as 'modified' because their nested content changed
+            // (deepEqual comparison includes nested modules array)
+            expect(result.beforeActions['outer_loop']).toEqual({ action: 'modified', pending: false });
+            expect(result.beforeActions['mid_branch']).toEqual({ action: 'modified', pending: false });
+            expect(result.beforeActions['inner_loop']).toEqual({ action: 'modified', pending: false });
+            // Verify full structure with correct ordering at each level
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['outer_loop']);
+            const mergedOuterLoop = result.mergedFlow.modules?.find((m) => m.id === 'outer_loop');
+            expect(mergedOuterLoop?.value.type).toBe('forloopflow');
+            const outerLoopModules = (mergedOuterLoop?.value).modules;
+            expectModuleOrder(outerLoopModules, ['mid_branch']);
+            const mergedMidBranch = outerLoopModules.find((m) => m.id === 'mid_branch');
+            expect(mergedMidBranch?.value.type).toBe('branchone');
+            const midBranchDefault = (mergedMidBranch?.value).default;
+            expectModuleOrder(midBranchDefault, ['inner_loop']);
+            const mergedInnerLoop = midBranchDefault.find((m) => m.id === 'inner_loop');
+            expect(mergedInnerLoop?.value.type).toBe('forloopflow');
+            const innerLoopModules = (mergedInnerLoop?.value).modules;
+            // deep1 is unchanged, deep2 was removed (but restored in mergedFlow), deep3 was added
+            expectModuleOrder(innerLoopModules, ['deep1', 'deep2', 'deep3']);
+        });
+        it('handles complex scenario with multiple nested structures and simultaneous changes', () => {
+            // Before: loop1 -> [scriptA, branch1 -> [scriptB, scriptC]]
+            // After:  loop1 -> [scriptA_modified, branch1 -> [scriptB, scriptD]]
+            const scriptA = createRawScriptModule('a', 'script a original');
+            const scriptAModified = createRawScriptModule('a', 'script a modified');
+            const scriptB = createRawScriptModule('b', 'script b');
+            const scriptC = createRawScriptModule('c', 'script c - to remove');
+            const scriptD = createRawScriptModule('d', 'script d - new');
+            const branchBefore = createBranchOneModule('branch1', [scriptB, scriptC], []);
+            const branchAfter = createBranchOneModule('branch1', [scriptB, scriptD], []);
+            const loopBefore = createForloopModule('loop1', [scriptA, branchBefore]);
+            const loopAfter = createForloopModule('loop1', [scriptAModified, branchAfter]);
+            const beforeFlow = createFlow([loopBefore]);
+            const afterFlow = createFlow([loopAfter]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // scriptA was modified
+            expect(result.beforeActions['a']).toEqual({ action: 'modified', pending: false });
+            expect(result.afterActions['a']).toEqual({ action: 'modified', pending: false });
+            // scriptC was removed
+            expect(result.beforeActions['c']).toEqual({ action: 'removed', pending: false });
+            // scriptD was added
+            expect(result.afterActions['d']).toEqual({ action: 'added', pending: false });
+            // scriptB unchanged
+            expect(result.beforeActions['b']).toBeUndefined();
+            expect(result.afterActions['b']).toBeUndefined();
+            // Verify mergedFlow structure with correct ordering
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['loop1']);
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'loop1');
+            const loopModules = (mergedLoop?.value).modules;
+            expectModuleOrder(loopModules, ['a', 'branch1']);
+            // Modified scriptA should be in mergedFlow with updated content
+            const mergedA = loopModules.find((m) => m.id === 'a');
+            expect((mergedA?.value).content).toBe('script a modified');
+            // Branch1 should contain scriptB, removed c, and added d in correct order
+            const mergedBranch = loopModules.find((m) => m.id === 'branch1');
+            const branchDefault = (mergedBranch?.value).default;
+            expectModuleOrder(branchDefault, ['b', 'c', 'd']);
+        });
+        it('preserves correct structure in mergedFlow for deeply nested removals', () => {
+            // Remove a script from inside a loop that is inside a branch
+            const deepScript = createRawScriptModule('deep', 'deep script to remove');
+            const keepScript = createRawScriptModule('keep', 'script to keep');
+            const innerLoopBefore = createForloopModule('inner_loop', [deepScript, keepScript]);
+            const innerLoopAfter = createForloopModule('inner_loop', [keepScript]);
+            const branchBefore = createBranchOneModule('branch', [innerLoopBefore], []);
+            const branchAfter = createBranchOneModule('branch', [innerLoopAfter], []);
+            const beforeFlow = createFlow([branchBefore]);
+            const afterFlow = createFlow([branchAfter]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // Navigate into the merged flow structure and verify correct ordering
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['branch']);
+            const mergedBranch = result.mergedFlow.modules?.find((m) => m.id === 'branch');
+            const branchDefault = (mergedBranch?.value).default;
+            expectModuleOrder(branchDefault, ['inner_loop']);
+            const mergedInnerLoop = branchDefault.find((m) => m.id === 'inner_loop');
+            const innerLoopModules = (mergedInnerLoop?.value).modules;
+            // Both modules should be present in the merged flow in correct order
+            expectModuleOrder(innerLoopModules, ['deep', 'keep']);
+        });
+        it('handles branchall inside branchone with nested changes', () => {
+            const scriptInParallel1 = createRawScriptModule('par1', 'parallel 1');
+            const scriptInParallel2 = createRawScriptModule('par2', 'parallel 2');
+            const scriptInParallel3 = createRawScriptModule('par3', 'parallel 3 - new');
+            const branchAllBefore = createBranchAllModule('parallel_section', [
+                { modules: [scriptInParallel1] },
+                { modules: [scriptInParallel2] }
+            ]);
+            const branchAllAfter = createBranchAllModule('parallel_section', [
+                { modules: [scriptInParallel1] },
+                { modules: [scriptInParallel2, scriptInParallel3] }
+            ]);
+            const branchOneBefore = createBranchOneModule('outer_branch', [branchAllBefore], [
+                { expr: 'x > 0', modules: [] }
+            ]);
+            const branchOneAfter = createBranchOneModule('outer_branch', [branchAllAfter], [
+                { expr: 'x > 0', modules: [] }
+            ]);
+            const beforeFlow = createFlow([branchOneBefore]);
+            const afterFlow = createFlow([branchOneAfter]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['par3']).toEqual({ action: 'added', pending: false });
+            // Other modules unchanged
+            expect(result.beforeActions['par1']).toBeUndefined();
+            expect(result.beforeActions['par2']).toBeUndefined();
+            // Verify full nested structure is preserved in mergedFlow with correct ordering
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['outer_branch']);
+            const mergedBranchOne = result.mergedFlow.modules?.find((m) => m.id === 'outer_branch');
+            expect(mergedBranchOne?.value.type).toBe('branchone');
+            const branchOneDefault = (mergedBranchOne?.value).default;
+            expectModuleOrder(branchOneDefault, ['parallel_section']);
+            const mergedBranchAll = branchOneDefault.find((m) => m.id === 'parallel_section');
+            expect(mergedBranchAll?.value.type).toBe('branchall');
+            const parallelBranches = (mergedBranchAll?.value).branches;
+            expect(parallelBranches).toHaveLength(2);
+            // First parallel branch has par1
+            expectModuleOrder(parallelBranches[0].modules, ['par1']);
+            // Second parallel branch has par2 and added par3 in correct order
+            expectModuleOrder(parallelBranches[1].modules, ['par2', 'par3']);
+        });
+    });
+    describe('special modules', () => {
+        it('detects added failure_module', () => {
+            const moduleA = createRawScriptModule('a', 'main step');
+            const failureModule = createRawScriptModule('failure', 'handle failure');
+            const beforeFlow = createFlowWithSpecialModules({ modules: [moduleA] });
+            const afterFlow = createFlowWithSpecialModules({
+                modules: [moduleA],
+                failure_module: failureModule
+            });
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['failure']).toEqual({ action: 'added', pending: false });
+            expect(result.beforeActions['failure']).toBeUndefined();
+            // Verify mergedFlow contains the failure_module
+            expect(result.mergedFlow.failure_module?.id).toBe('failure');
+        });
+        it('detects removed failure_module', () => {
+            const moduleA = createRawScriptModule('a', 'main step');
+            const failureModule = createRawScriptModule('failure', 'handle failure');
+            const beforeFlow = createFlowWithSpecialModules({
+                modules: [moduleA],
+                failure_module: failureModule
+            });
+            const afterFlow = createFlowWithSpecialModules({ modules: [moduleA] });
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions['failure']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['failure']).toEqual({ action: 'removed', pending: false });
+            // Verify mergedFlow contains the removed failure_module
+            expect(result.mergedFlow.failure_module?.id).toBe('failure');
+        });
+        it('detects modified failure_module', () => {
+            const moduleA = createRawScriptModule('a', 'main step');
+            const failureModuleBefore = createRawScriptModule('failure', 'handle failure v1');
+            const failureModuleAfter = createRawScriptModule('failure', 'handle failure v2');
+            const beforeFlow = createFlowWithSpecialModules({
+                modules: [moduleA],
+                failure_module: failureModuleBefore
+            });
+            const afterFlow = createFlowWithSpecialModules({
+                modules: [moduleA],
+                failure_module: failureModuleAfter
+            });
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions['failure']).toEqual({ action: 'modified', pending: false });
+            expect(result.afterActions['failure']).toEqual({ action: 'modified', pending: false });
+            // Verify mergedFlow contains the modified failure_module with new content
+            expect(result.mergedFlow.failure_module?.id).toBe('failure');
+            expect((result.mergedFlow.failure_module?.value).content).toBe('handle failure v2');
+        });
+        it('detects added preprocessor_module', () => {
+            const moduleA = createRawScriptModule('a', 'main step');
+            const preprocessorModule = createRawScriptModule('preprocessor', 'preprocess input');
+            const beforeFlow = createFlowWithSpecialModules({ modules: [moduleA] });
+            const afterFlow = createFlowWithSpecialModules({
+                modules: [moduleA],
+                preprocessor_module: preprocessorModule
+            });
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['preprocessor']).toEqual({ action: 'added', pending: false });
+            expect(result.beforeActions['preprocessor']).toBeUndefined();
+            // Verify mergedFlow contains the preprocessor_module
+            expect(result.mergedFlow.preprocessor_module?.id).toBe('preprocessor');
+        });
+        it('detects removed preprocessor_module', () => {
+            const moduleA = createRawScriptModule('a', 'main step');
+            const preprocessorModule = createRawScriptModule('preprocessor', 'preprocess input');
+            const beforeFlow = createFlowWithSpecialModules({
+                modules: [moduleA],
+                preprocessor_module: preprocessorModule
+            });
+            const afterFlow = createFlowWithSpecialModules({ modules: [moduleA] });
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions['preprocessor']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['preprocessor']).toEqual({ action: 'removed', pending: false });
+            // Verify mergedFlow contains the removed preprocessor_module
+            expect(result.mergedFlow.preprocessor_module?.id).toBe('preprocessor');
+        });
+        it('detects changes to both failure and preprocessor modules simultaneously', () => {
+            const moduleA = createRawScriptModule('a', 'main step');
+            const failureModuleBefore = createRawScriptModule('failure', 'handle failure v1');
+            const failureModuleAfter = createRawScriptModule('failure', 'handle failure v2');
+            const preprocessorModule = createRawScriptModule('preprocessor', 'preprocess input');
+            const beforeFlow = createFlowWithSpecialModules({
+                modules: [moduleA],
+                failure_module: failureModuleBefore,
+                preprocessor_module: preprocessorModule
+            });
+            const afterFlow = createFlowWithSpecialModules({
+                modules: [moduleA],
+                failure_module: failureModuleAfter
+                // preprocessor_module removed
+            });
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // failure_module was modified
+            expect(result.beforeActions['failure']).toEqual({ action: 'modified', pending: false });
+            expect(result.afterActions['failure']).toEqual({ action: 'modified', pending: false });
+            // preprocessor_module was removed
+            expect(result.beforeActions['preprocessor']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['preprocessor']).toEqual({ action: 'removed', pending: false });
+            // Verify mergedFlow structure
+            expect(result.mergedFlow.failure_module?.id).toBe('failure');
+            expect(result.mergedFlow.preprocessor_module?.id).toBe('preprocessor');
+        });
+    });
+    describe('branchall entire branch removal', () => {
+        it('detects removal of entire parallel branch from branchall', () => {
+            const parallel1A = createRawScriptModule('p1_a', 'parallel 1 a');
+            const parallel1B = createRawScriptModule('p1_b', 'parallel 1 b');
+            const parallel2A = createRawScriptModule('p2_a', 'parallel 2 a');
+            const beforeBranchAll = createBranchAllModule('branchall1', [
+                { modules: [parallel1A, parallel1B] },
+                { modules: [parallel2A] } // entire branch removed
+            ]);
+            const afterBranchAll = createBranchAllModule('branchall1', [
+                { modules: [parallel1A, parallel1B] }
+            ]);
+            const beforeFlow = createFlow([beforeBranchAll]);
+            const afterFlow = createFlow([afterBranchAll]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // Module from removed branch should be marked as removed
+            expect(result.beforeActions['p2_a']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['p2_a']).toEqual({ action: 'removed', pending: false });
+            // Modules from preserved branch should be unchanged
+            expect(result.beforeActions['p1_a']).toBeUndefined();
+            expect(result.beforeActions['p1_b']).toBeUndefined();
+            // Verify mergedFlow structure - should have 2 branches with removed modules restored
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['branchall1']);
+            const mergedBranchAll = result.mergedFlow.modules?.find((m) => m.id === 'branchall1');
+            const branches = (mergedBranchAll?.value).branches;
+            // First branch unchanged
+            expectModuleOrder(branches[0].modules, ['p1_a', 'p1_b']);
+            // Second branch should be restored with its module
+            expect(branches).toHaveLength(2);
+            expectModuleOrder(branches[1].modules, ['p2_a']);
+        });
+        it('detects removal of multiple parallel branches from branchall', () => {
+            const p1_a = createRawScriptModule('p1_a', 'parallel 1');
+            const p2_a = createRawScriptModule('p2_a', 'parallel 2');
+            const p3_a = createRawScriptModule('p3_a', 'parallel 3');
+            const beforeBranchAll = createBranchAllModule('branchall1', [
+                { modules: [p1_a] },
+                { modules: [p2_a] }, // removed
+                { modules: [p3_a] } // removed
+            ]);
+            const afterBranchAll = createBranchAllModule('branchall1', [{ modules: [p1_a] }]);
+            const beforeFlow = createFlow([beforeBranchAll]);
+            const afterFlow = createFlow([afterBranchAll]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // Modules from removed branches should be marked as removed
+            expect(result.beforeActions['p2_a']).toEqual({ action: 'removed', pending: false });
+            expect(result.beforeActions['p3_a']).toEqual({ action: 'removed', pending: false });
+            // Verify mergedFlow structure - should have 3 branches restored
+            const mergedBranchAll = result.mergedFlow.modules?.find((m) => m.id === 'branchall1');
+            const branches = (mergedBranchAll?.value).branches;
+            expect(branches).toHaveLength(3);
+            expectModuleOrder(branches[0].modules, ['p1_a']);
+            expectModuleOrder(branches[1].modules, ['p2_a']);
+            expectModuleOrder(branches[2].modules, ['p3_a']);
+        });
+    });
+    describe('hasInputSchemaChanged', () => {
+        it('returns false for identical schemas', () => {
+            const schema = {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    age: { type: 'number' }
+                }
+            };
+            const beforeFlow = { schema };
+            const afterFlow = { schema: JSON.parse(JSON.stringify(schema)) };
+            expect(hasInputSchemaChanged(beforeFlow, afterFlow)).toBe(false);
+        });
+        it('returns true for different schemas', () => {
+            const beforeFlow = {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' }
+                    }
+                }
+            };
+            const afterFlow = {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        email: { type: 'string' }
+                    }
+                }
+            };
+            expect(hasInputSchemaChanged(beforeFlow, afterFlow)).toBe(true);
+        });
+        it('returns false for undefined flows', () => {
+            expect(hasInputSchemaChanged(undefined, undefined)).toBe(false);
+            expect(hasInputSchemaChanged(undefined, { schema: {} })).toBe(false);
+            expect(hasInputSchemaChanged({ schema: {} }, undefined)).toBe(false);
+        });
+        it('returns true when schema is added', () => {
+            const beforeFlow = {};
+            const afterFlow = { schema: { type: 'object' } };
+            expect(hasInputSchemaChanged(beforeFlow, afterFlow)).toBe(true);
+        });
+        it('returns true when schema is removed', () => {
+            const beforeFlow = { schema: { type: 'object' } };
+            const afterFlow = {};
+            expect(hasInputSchemaChanged(beforeFlow, afterFlow)).toBe(true);
+        });
+        it('returns false for both empty schemas', () => {
+            const beforeFlow = { schema: {} };
+            const afterFlow = { schema: {} };
+            expect(hasInputSchemaChanged(beforeFlow, afterFlow)).toBe(false);
+        });
+    });
+    describe('multiple removed modules ordering', () => {
+        it('restores multiple removed modules in correct order', () => {
+            const moduleA = createRawScriptModule('a', 'first');
+            const moduleB = createRawScriptModule('b', 'second');
+            const moduleC = createRawScriptModule('c', 'third');
+            const moduleD = createRawScriptModule('d', 'fourth');
+            const moduleE = createRawScriptModule('e', 'fifth');
+            // Remove modules at beginning, middle, and end
+            const beforeFlow = createFlow([moduleA, moduleB, moduleC, moduleD, moduleE]);
+            const afterFlow = createFlow([moduleB, moduleD]); // Remove a, c, e
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // All removed modules should be marked as removed
+            expect(result.beforeActions['a']).toEqual({ action: 'removed', pending: false });
+            expect(result.beforeActions['c']).toEqual({ action: 'removed', pending: false });
+            expect(result.beforeActions['e']).toEqual({ action: 'removed', pending: false });
+            // Verify mergedFlow restores all modules in the original order
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['a', 'b', 'c', 'd', 'e']);
+        });
+        it('restores multiple removed modules inside a loop in correct order', () => {
+            const innerA = createRawScriptModule('inner_a', 'first');
+            const innerB = createRawScriptModule('inner_b', 'second');
+            const innerC = createRawScriptModule('inner_c', 'third');
+            const innerD = createRawScriptModule('inner_d', 'fourth');
+            const beforeLoop = createForloopModule('loop1', [innerA, innerB, innerC, innerD]);
+            const afterLoop = createForloopModule('loop1', [innerB]); // Remove a, c, d
+            const beforeFlow = createFlow([beforeLoop]);
+            const afterFlow = createFlow([afterLoop]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // All removed modules should be marked as removed
+            expect(result.beforeActions['inner_a']).toEqual({ action: 'removed', pending: false });
+            expect(result.beforeActions['inner_c']).toEqual({ action: 'removed', pending: false });
+            expect(result.beforeActions['inner_d']).toEqual({ action: 'removed', pending: false });
+            // Verify mergedFlow restores all modules in the original order inside the loop
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'loop1');
+            const loopModules = (mergedLoop?.value).modules;
+            expectModuleOrder(loopModules, ['inner_a', 'inner_b', 'inner_c', 'inner_d']);
+        });
+    });
+    describe('insert position tests', () => {
+        it('handles module added at beginning of list', () => {
+            const moduleA = createRawScriptModule('a', 'existing first');
+            const moduleB = createRawScriptModule('b', 'existing second');
+            const moduleNew = createRawScriptModule('new', 'new at beginning');
+            const beforeFlow = createFlow([moduleA, moduleB]);
+            const afterFlow = createFlow([moduleNew, moduleA, moduleB]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['new']).toEqual({ action: 'added', pending: false });
+            // Verify mergedFlow maintains correct order with new module at beginning
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['new', 'a', 'b']);
+        });
+        it('handles module added in middle of list', () => {
+            const moduleA = createRawScriptModule('a', 'first');
+            const moduleB = createRawScriptModule('b', 'second');
+            const moduleC = createRawScriptModule('c', 'third');
+            const moduleNew = createRawScriptModule('new', 'new in middle');
+            const beforeFlow = createFlow([moduleA, moduleB, moduleC]);
+            const afterFlow = createFlow([moduleA, moduleNew, moduleB, moduleC]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['new']).toEqual({ action: 'added', pending: false });
+            // Verify mergedFlow maintains correct order with new module in middle
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['a', 'new', 'b', 'c']);
+        });
+        it('handles module added at beginning inside a loop', () => {
+            const innerA = createRawScriptModule('inner_a', 'existing first');
+            const innerB = createRawScriptModule('inner_b', 'existing second');
+            const innerNew = createRawScriptModule('inner_new', 'new at beginning');
+            const beforeLoop = createForloopModule('loop1', [innerA, innerB]);
+            const afterLoop = createForloopModule('loop1', [innerNew, innerA, innerB]);
+            const beforeFlow = createFlow([beforeLoop]);
+            const afterFlow = createFlow([afterLoop]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['inner_new']).toEqual({ action: 'added', pending: false });
+            // Verify correct order inside the loop
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'loop1');
+            const loopModules = (mergedLoop?.value).modules;
+            expectModuleOrder(loopModules, ['inner_new', 'inner_a', 'inner_b']);
+        });
+        it('handles multiple modules added at different positions', () => {
+            const moduleA = createRawScriptModule('a', 'original a');
+            const moduleB = createRawScriptModule('b', 'original b');
+            const moduleNew1 = createRawScriptModule('new1', 'new at start');
+            const moduleNew2 = createRawScriptModule('new2', 'new in middle');
+            const moduleNew3 = createRawScriptModule('new3', 'new at end');
+            const beforeFlow = createFlow([moduleA, moduleB]);
+            const afterFlow = createFlow([moduleNew1, moduleA, moduleNew2, moduleB, moduleNew3]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['new1']).toEqual({ action: 'added', pending: false });
+            expect(result.afterActions['new2']).toEqual({ action: 'added', pending: false });
+            expect(result.afterActions['new3']).toEqual({ action: 'added', pending: false });
+            // Verify mergedFlow maintains correct order
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['new1', 'a', 'new2', 'b', 'new3']);
+        });
+    });
+    describe('empty containers', () => {
+        it('handles adding empty forloop', () => {
+            const moduleA = createRawScriptModule('a', 'step a');
+            const emptyLoop = createForloopModule('empty_loop', []);
+            const beforeFlow = createFlow([moduleA]);
+            const afterFlow = createFlow([moduleA, emptyLoop]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['empty_loop']).toEqual({ action: 'added', pending: false });
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['a', 'empty_loop']);
+            // Verify the empty loop has no modules
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'empty_loop');
+            expect((mergedLoop?.value).modules).toHaveLength(0);
+        });
+        it('handles removing empty forloop', () => {
+            const moduleA = createRawScriptModule('a', 'step a');
+            const emptyLoop = createForloopModule('empty_loop', []);
+            const beforeFlow = createFlow([moduleA, emptyLoop]);
+            const afterFlow = createFlow([moduleA]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions['empty_loop']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['empty_loop']).toEqual({ action: 'removed', pending: false });
+            // Verify the removed empty loop is in mergedFlow
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['a', 'empty_loop']);
+        });
+        it('handles adding empty branchone', () => {
+            const moduleA = createRawScriptModule('a', 'step a');
+            const emptyBranch = createBranchOneModule('empty_branch', [], []);
+            const beforeFlow = createFlow([moduleA]);
+            const afterFlow = createFlow([moduleA, emptyBranch]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.afterActions['empty_branch']).toEqual({ action: 'added', pending: false });
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['a', 'empty_branch']);
+            // Verify the empty branch has no modules in default or branches
+            const mergedBranch = result.mergedFlow.modules?.find((m) => m.id === 'empty_branch');
+            expect((mergedBranch?.value).default).toHaveLength(0);
+            expect((mergedBranch?.value).branches).toHaveLength(0);
+        });
+        it('handles removing empty branchone with empty default and branches', () => {
+            const moduleA = createRawScriptModule('a', 'step a');
+            const emptyBranch = createBranchOneModule('empty_branch', [], [{ expr: 'true', modules: [] }]);
+            const beforeFlow = createFlow([moduleA, emptyBranch]);
+            const afterFlow = createFlow([moduleA]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            expect(result.beforeActions['empty_branch']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['empty_branch']).toEqual({ action: 'removed', pending: false });
+            // Verify the removed empty branch is in mergedFlow with its structure
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['a', 'empty_branch']);
+            const mergedBranch = result.mergedFlow.modules?.find((m) => m.id === 'empty_branch');
+            expect((mergedBranch?.value).default).toHaveLength(0);
+            expect((mergedBranch?.value).branches).toHaveLength(1);
+        });
+    });
+    describe('container type changes', () => {
+        it('treats forloop to whileloop change as removed + added', () => {
+            const innerModule = createRawScriptModule('inner', 'inner step');
+            const forLoop = createForloopModule('loop1', [innerModule]);
+            const whileLoop = createWhileloopModule('loop1', [innerModule]);
+            const beforeFlow = createFlow([forLoop]);
+            const afterFlow = createFlow([whileLoop]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // The container itself should be treated as removed + added (type changed)
+            expect(result.beforeActions['loop1']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['loop1']).toEqual({ action: 'added', pending: false });
+            // Inner module's location type changes (forloop -> whileloop), so it's also treated as moved
+            expect(result.beforeActions['inner']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['inner']).toEqual({ action: 'added', pending: false });
+            // The old inner module should appear with prefix in the merged flow
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'loop1');
+            expect(mergedLoop).toBeDefined();
+            const loopModules = (mergedLoop?.value).modules;
+            // The whileloop contains 'inner' (new) and the old one gets prefixed
+            expect(loopModules.some((m) => m.id === 'inner')).toBe(true);
+        });
+        it('treats branchone to branchall change as removed + added', () => {
+            const innerModule = createRawScriptModule('inner', 'inner step');
+            const branchOne = createBranchOneModule('branch1', [innerModule], []);
+            const branchAll = createBranchAllModule('branch1', [{ modules: [innerModule] }]);
+            const beforeFlow = createFlow([branchOne]);
+            const afterFlow = createFlow([branchAll]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // The container itself should be treated as removed + added (type changed)
+            expect(result.beforeActions['branch1']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['branch1']).toEqual({ action: 'added', pending: false });
+            // Inner module's location type changes (branchone-default -> branchall-branch), so it's also treated as moved
+            expect(result.beforeActions['inner']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['inner']).toEqual({ action: 'added', pending: false });
+            // The new inner module should appear in the branchall
+            const mergedBranch = result.mergedFlow.modules?.find((m) => m.id === 'branch1');
+            expect(mergedBranch).toBeDefined();
+            const branchModules = (mergedBranch?.value).branches[0].modules;
+            expect(branchModules.some((m) => m.id === 'inner')).toBe(true);
+        });
+    });
+    describe('module movement', () => {
+        it('detects module moved from root to inside a loop', () => {
+            const moduleA = createRawScriptModule('a', 'step a');
+            const moduleB = createRawScriptModule('b', 'step b');
+            const emptyLoop = createForloopModule('loop1', []);
+            const loopWithB = createForloopModule('loop1', [moduleB]);
+            // Before: a, b, loop1(empty)
+            // After: a, loop1(b)
+            const beforeFlow = createFlow([moduleA, moduleB, emptyLoop]);
+            const afterFlow = createFlow([moduleA, loopWithB]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // Module b is in both flows but at different locations
+            // The implementation doesn't track "movement" - it sees b in both places
+            // The loop itself is modified because its modules changed
+            expect(result.beforeActions['loop1']).toEqual({ action: 'modified', pending: false });
+            expect(result.afterActions['loop1']).toEqual({ action: 'modified', pending: false });
+            // b is removed from root and added inside loop - implementation sees it as existing in both
+            // but since it's the same module ID, no action is recorded
+            // The mergedFlow should contain both the old position (at root) and the new position (in loop)
+            // This is handled by the duplicate ID logic - old__b prefix
+            const rootModuleIds = result.mergedFlow.modules?.map((m) => m.id) ?? [];
+            expect(rootModuleIds).toContain('a');
+            expect(rootModuleIds).toContain('loop1');
+            // The old 'b' at root level gets prefixed with 'old__'
+            expect(rootModuleIds).toContain('old__b');
+        });
+        it('detects module moved from one branch to another', () => {
+            const moduleA = createRawScriptModule('a', 'step a');
+            // Before: branch with 'a' in first conditional branch
+            const beforeBranch = createBranchOneModule('branch1', [], [
+                { expr: 'x > 0', modules: [moduleA] },
+                { expr: 'x < 0', modules: [] }
+            ]);
+            // After: branch with 'a' in second conditional branch
+            const afterBranch = createBranchOneModule('branch1', [], [
+                { expr: 'x > 0', modules: [] },
+                { expr: 'x < 0', modules: [moduleA] }
+            ]);
+            const beforeFlow = createFlow([beforeBranch]);
+            const afterFlow = createFlow([afterBranch]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // The branch container is modified
+            expect(result.beforeActions['branch1']).toEqual({ action: 'modified', pending: false });
+            expect(result.afterActions['branch1']).toEqual({ action: 'modified', pending: false });
+            // Module 'a' moved from branchIndex 0 to branchIndex 1, so it's treated as removed + added
+            expect(result.beforeActions['a']).toEqual({ action: 'removed', pending: false });
+            expect(result.afterActions['a']).toEqual({ action: 'added', pending: false });
+            // The old 'a' should appear with prefix in the first branch of mergedFlow
+            const mergedBranch = result.mergedFlow.modules?.find((m) => m.id === 'branch1');
+            expect(mergedBranch).toBeDefined();
+            const firstBranchModules = (mergedBranch?.value).branches[0].modules;
+            expect(firstBranchModules.some((m) => m.id === 'old__a')).toBe(true);
+            // The new 'a' should appear in the second branch
+            const secondBranchModules = (mergedBranch?.value).branches[1].modules;
+            expect(secondBranchModules.some((m) => m.id === 'a')).toBe(true);
+        });
+        it('detects module moved from loop to root', () => {
+            const moduleA = createRawScriptModule('a', 'step a');
+            const moduleB = createRawScriptModule('b', 'step b');
+            const loopWithA = createForloopModule('loop1', [moduleA]);
+            const emptyLoop = createForloopModule('loop1', []);
+            // Before: b, loop1(a)
+            // After: b, loop1(empty), a
+            const beforeFlow = createFlow([moduleB, loopWithA]);
+            const afterFlow = createFlow([moduleB, emptyLoop, moduleA]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // The loop is modified because its modules changed
+            expect(result.beforeActions['loop1']).toEqual({ action: 'modified', pending: false });
+            expect(result.afterActions['loop1']).toEqual({ action: 'modified', pending: false });
+            // Module 'a' exists in both flows, so no action recorded for it
+            // The mergedFlow should contain the old 'a' inside the loop (prefixed) and new 'a' at root
+            const rootModuleIds = result.mergedFlow.modules?.map((m) => m.id) ?? [];
+            expect(rootModuleIds).toContain('b');
+            expect(rootModuleIds).toContain('loop1');
+            expect(rootModuleIds).toContain('a');
+            // The old 'a' inside the loop gets prefixed
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'loop1');
+            const loopModuleIds = (mergedLoop?.value).modules.map((m) => m.id);
+            expect(loopModuleIds).toContain('old__a');
+        });
+    });
+    describe('module reordering', () => {
+        it('detects modules reordered at root level', () => {
+            const moduleA = createRawScriptModule('a', 'step a');
+            const moduleB = createRawScriptModule('b', 'step b');
+            const moduleC = createRawScriptModule('c', 'step c');
+            // Before: a, b, c
+            // After: c, a, b
+            const beforeFlow = createFlow([moduleA, moduleB, moduleC]);
+            const afterFlow = createFlow([moduleC, moduleA, moduleB]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // No modules were added, removed, or modified - just reordered
+            // The implementation doesn't detect reordering as a change
+            expect(result.beforeActions['a']).toBeUndefined();
+            expect(result.beforeActions['b']).toBeUndefined();
+            expect(result.beforeActions['c']).toBeUndefined();
+            expect(result.afterActions['a']).toBeUndefined();
+            expect(result.afterActions['b']).toBeUndefined();
+            expect(result.afterActions['c']).toBeUndefined();
+            // mergedFlow should reflect the afterFlow order
+            expectModuleOrder(result.mergedFlow.modules ?? [], ['c', 'a', 'b']);
+        });
+        it('detects modules reordered inside a loop', () => {
+            const innerA = createRawScriptModule('inner_a', 'inner a');
+            const innerB = createRawScriptModule('inner_b', 'inner b');
+            const innerC = createRawScriptModule('inner_c', 'inner c');
+            // Before: loop with [a, b, c]
+            // After: loop with [c, b, a]
+            const beforeLoop = createForloopModule('loop1', [innerA, innerB, innerC]);
+            const afterLoop = createForloopModule('loop1', [innerC, innerB, innerA]);
+            const beforeFlow = createFlow([beforeLoop]);
+            const afterFlow = createFlow([afterLoop]);
+            const result = buildFlowTimeline(beforeFlow, afterFlow);
+            // The loop is modified because its internal structure changed
+            // (deepEqual compares the modules array which includes order)
+            expect(result.beforeActions['loop1']).toEqual({ action: 'modified', pending: false });
+            expect(result.afterActions['loop1']).toEqual({ action: 'modified', pending: false });
+            // Individual modules are not marked as changed
+            expect(result.beforeActions['inner_a']).toBeUndefined();
+            expect(result.beforeActions['inner_b']).toBeUndefined();
+            expect(result.beforeActions['inner_c']).toBeUndefined();
+            // mergedFlow should reflect the afterFlow order inside the loop
+            const mergedLoop = result.mergedFlow.modules?.find((m) => m.id === 'loop1');
+            const loopModules = (mergedLoop?.value).modules;
+            expectModuleOrder(loopModules, ['inner_c', 'inner_b', 'inner_a']);
+        });
+    });
+});