anchor.diff:                          let s = getString data
                           if s =  magic then
                               let mvar = MVar.empty()
  -                            runningApp.AddViewer mvar
  -                            let t = runOuterChanges mvar runningApp |> Async.Ignore
  +                            instance.AddViewer mvar
  +                            let t = runOuterChanges mvar instance |> Async.Ignore
                               Async.Start(t,ct)
  -                            return! runElmLoop mvar runningApp
  +                            return! runElmLoop mvar instance
                           else 
                               return failwithf "initial handshake failed. Web should have said: %s" magic
                       | _ -> return! failwith "initial handshake failed (should have received text)"
               }
   
   
  -    let runPlain runningApp onMessage app : WebPart =
  -        path "/ws" >=> handShake (runView runningApp onMessage app)
  -
  -    let runApp mainPage runningApp onMessage app : WebPart =
  +    let runPlain instance onMessage app : WebPart =
  +        path "/ws" >=> handShake (runView instance onMessage app)
  +
  +    let runApp mainPage instance onMessage app : WebPart =
           choose [
  -            runPlain runningApp onMessage app
  +            runPlain instance onMessage app
               GET >=> choose [ 
                   path "/mainPage" >=> file mainPage
                   path "/mainPage" >=> OK (EmbeddedResources.extractPage mainPage)
  
positive.code:             Choice2Of2 (sprintf "could not parse: %s with: %s" s e.Message)
  
  
      let runView (runningApp : FablishInstance<_,_>) (onMessage : Callback<'model,'msg>) (app : App<_,_,_>) (webSocket : WebSocket) : HttpContext -> SocketOp<unit> =
  
          let writeString (s : string) =
              socket {
  
negative.code:              bindings = [ HttpBinding.mk HTTP address (Port.Parse port) ]
            }
  
          let instance = new FablishInstance<'model,'msg>(app.initial, env, app.update)
  
          let onMessage = 
              match onMessage with
                  | Some m -> m
                  | None -> (fun (model : 'model) msg -> app.update instance.Env model msg |> instance.EmitModel)
          
          let cts = new CancellationTokenSource()
          let listening,server = startWebServerAsync defaultConfig (runApp path instance onMessage app)
          
          let t = Async.StartAsTask(server,cancellationToken = cts.Token)
          listening |> Async.RunSynchronously |> printfn "[Fablish-suave] start stats: %A"
          {
               localUrl =  sprintf "http://localhost:%s/mainPage" port
               runningTask = t
               instance = instance
               shutdown  = fun () -> instance.Dispose(); cts.Cancel(); 
          }
  
  
  