Are circular tapes exciting? A Brainfuck derivative

Let's define a simple Brainfuck-like programming language.
It has a two-directional tape of cells, and each cell holds one bit.
All bits are initially 0.
There is a moving head on the tape, initially at position 0.
A program is a string over the characters &lt;&gt;01!, executed from left to right, with the following semantics:


&lt; moves the head one step to the left.
&gt; moves the head one step to the right.
0 puts 0 in the current cell.
1 puts 1 in the current cell.
! flips the current cell.


There are no loops, so a program of n characters terminates after exactly n steps.
A program is boring if all cells contain 0 at the end of execution, and exciting if there is at least one 1.
Note that the size of the tape is not specified, so depending on the implementation, it may be two-way infinite or circular.

An example program

Consider the program 1&gt;&gt;&gt;!&lt;&lt;&lt;&lt;0&gt;!&gt;&gt;&gt;!.
On an infinite tape, execution proceeds as follows:

     v
00000000000000  Put 1
     v
00000100000000  Move by &gt;&gt;&gt;
        v
00000100000000  Flip
        v
00000100100000  Move by &lt;&lt;&lt;&lt;
    v
00000100100000  Put 0
    v
00000100100000  Move by &gt;
     v
00000100100000  Flip
     v
00000000100000  Move by &gt;&gt;&gt;
        v
00000000100000  Flip
        v
00000000000000


At the end, all cells are 0, so this program is boring.
Now, let's run the same program on a circular tape of length 4.

v
0000  Put 1
v
1000  Move by &gt;&gt;&gt;
   v
1000  Flip
   v
1001  Move by &lt;&lt;&lt;&lt; (wrapping around at the edge)
   v
1001  Put 0
   v
1000  Move by &gt; (wrapping back)
v
1000  Flip
v
0000  Move by &gt;&gt;&gt;
   v
0000  Flip
   v
0001


This time, there is a cell with value 1, so the program is exciting!
We see that whether a program is boring or exciting depends on the size of the tape.

The task

Your input is a non-empty string over &lt;&gt;01! that represents a program in the above programming language.
An array of characters is also an acceptable input format.
The program is guaranteed to be boring when run on an infinite tape.
Your output shall be the list of tape lengths on which the program is exciting.
Note that you only need to test the program on tapes that are shorter than the program length.

The solution with the lowest byte count in each language is the winner.
Standard code-golf rules apply.

Test cases

&gt; : []
110 : []
1&gt;0&lt;! : [1]
0&gt;&gt;1&gt;0&lt;&lt;&gt;! : [1]
1&gt;&gt;&gt;!&lt;&lt;&lt;&lt;0&gt;!&gt;&gt;&gt;! : [2, 4]
!&lt;!&lt;&gt;&lt;&lt;0&gt;!&gt;!&lt;&gt;&lt;1!&gt;&gt;0 : [2]
&gt;&gt;!&gt;&gt;&lt;&gt;001&gt;0&lt;1!&lt;&lt;!&gt;&lt; : [1, 2, 3]
1!&gt;&lt;&lt;!&lt;&lt;&lt;!!100&gt;&lt;&gt;&gt;&gt;! : [1, 3]
!!1&gt;!&gt;11!1&gt;&gt;0&lt;1!0&lt;!&lt;1&gt;&lt;!0&lt;!&lt;0&gt; : [3, 4]
&lt;&gt;&lt;&lt;&gt;&gt;!&lt;!!&lt;&lt;&lt;!0!!!&gt;&lt;&lt;&gt;0&gt;&gt;&gt;&gt;!&gt;&gt; : [1, 2, 4]
0&gt;&gt;&gt;&lt;!&lt;1&gt;&lt;&lt;&lt;0&gt;!&gt;&gt;!&lt;&lt;!!00&gt;!&lt;&gt;!0 : [3]
0000!!!!&gt;&lt;1&lt;&gt;&lt;&gt;&gt;0&lt;1&gt;&lt;&lt;&gt;&lt;&lt;&gt;&gt;!&lt;&lt; : []
!&gt;!&gt;!&gt;!&gt;!&gt;1&gt;!&gt;0&lt;!&lt;!&lt;!&lt;0&lt;!&lt;0&lt;!&lt;!&lt;!&lt;1&gt;!&gt;0&lt;&lt;! : [1, 2, 5, 7]
&lt;!!&gt;!!&gt;&lt;&lt;1&lt;&gt;&gt;&gt;!0&gt;&gt;&gt;0!&lt;!&gt;1!&lt;1!!&gt;&lt;&lt;&gt;&gt;&lt;0&lt;&lt;!&gt;&gt;&lt;&lt;!&lt;&lt;!&gt;&lt; : [1, 2, 4, 5]
!&gt;1&lt;&lt;11&lt;1&gt;!&gt;!1!&gt;&gt;&gt;0!!&gt;!&gt;&lt;!!00&lt;&gt;&lt;&lt;&lt;0&lt;&lt;&gt;0&lt;&lt;!&lt;&lt;&lt;&gt;&gt;!!&gt; : [1, 2, 3, 5, 6]
Haskell, 119 bytes

t#'&lt;'=last t:init t
(h:t)#c|c&lt;'#'=1-h:t|c&gt;'='=t++[h]|1&lt;2=read[c]:t
f p=[n|n&lt;-[1..length p],sum(foldl(#)(0&lt;$[1..n])p)&gt;0]


Try it online!

Function # is the interpreter for a single command c. The whole program p is run by folding # with the starting tape into p. f executes p for every tape and keeps those where the sum of the cells is at least 1.