obj =
  someMethod: -> # ... 
 
do new flow(
  context: obj
  blocks: [
    # If context is specified last argument is always a flow instance 
    (cb) ->
      @ == obj # true 
      cb() # It's callback 
    (cb) ->
      do (cb_multi = cb.multi()) -> # multi is also available 
        setImmediate -> cb_multi()
    (err, results, cb) -> # ... 
    'someMethod' # calls method from context 
    (err, cb) -> # other callback 
  ]
)

f = flow.define( -> )
 
f.exec()  # removed. no one used i think 
f()       # keep it simple 

flow.exec(
  ->
    multi = @multi
    ... ->
      func multi() # wrong 
 
  ->
    state = @
    ... ->
      func state.multi() # ok 
)

nt = proccess.nextTick
it 'should preserve results order', (cb) ->
  run = []
  flow.exec(
    ->
      do (cb = @multi()) -> nt -> nt -> run.push 1; cb 1
      # this will be ready first: 
      do (cb = @multi()) -> nt ->       run.push 2; cb 2
    (err, results)->
      assert.deepEqual run, [2, 1]
      assert.deepEqual (x[0] for x in results), [1, 2]
      @()
    cb
  )

flow.exec(
  -> @ null, 'test'
  (arg) ->
    # strips first (error) arguments for usual callbacks 
    assert.equal arg, 'test'
    setImmediate => @ 'error'
  -> # this won't run 
).error (err) ->
  # this will run 
  # resume flow with @()