anchor.diff:                          do! Async.Sleep node.Config.pruneInterval
                   }
   
  +            let mutable deltaProcessors = 0
               let printer =
                   async {
                       while true do
                           do! Async.Sleep(1000)
  -                        printfn "active = %A / desired = %A / inactiveCnt=%d / inactive=%A / rasterizeTime=%f [seconds] / count: %d / working: %d" progress.activeNodeCount.Value progress.expectedNodeCount.Value inactive.Count inactiveSize (float progress.rasterizeTime.Value / float TimeSpan.TicksPerSecond) pool.Count workingSet.Count
  +                        printfn "workers: %d / active = %A / desired = %A / inactiveCnt=%d / inactive=%A / rasterizeTime=%f [seconds] / count: %d / working: %d" deltaProcessors progress.activeNodeCount.Value progress.expectedNodeCount.Value inactive.Count inactiveSize (float progress.rasterizeTime.Value / float TimeSpan.TicksPerSecond) pool.Count workingSet.Count
                           ()
                   }
   
   
               for i in 0..queueCount-1 do
  -                let deltaProcessing,info =  StepwiseQueueExection.runEffects deltas.[i] effect
  -                Async.StartAsTask(deltaProcessing, cancellationToken = cancel.Token) |> ignore
  +                let deltaProcessing,info =  StepwiseQueueExection.runEffects deltas.[i] effect removeFromWorkingSet
  +                let safeDeltas =
  +                    async {
  +                        deltaProcessors <- deltaProcessors + 1
  +                        try
  +                            try
  +                                return! deltaProcessing
  +                            with e -> Log.error "delta processor died!!!"
  +                        finally 
  +                            Log.warn "ending delta processing"
  +                            deltaProcessors <- deltaProcessors - 1
  +                    }
  +                Async.StartAsTask(safeDeltas, cancellationToken = cancel.Token) |> ignore
               
               if pruning then Async.StartAsTask(pruningTask, cancellationToken = cancel.Token) |> ignore
               Async.StartAsTask(printer, cancellationToken = cancel.Token) |> ignore
  
positive.code: 
          let removeFromWorkingSet n = 
              if node.Config.boundingBoxSurface.IsSome  then
                  lock workingSet (fun () -> 
                      transact (fun () -> workingSet.Remove n |> ignore)
                  )
  
  
negative.code:                                     let cts = new CancellationTokenSource()
                                      let s = f cts.Token v
                                      s,cts)
                                  if cts.Token.IsCancellationRequested then undo v
                                  else
                                      cts.Token.Register (fun () -> undo v) |> ignore
                                      match Stepwise.run cts.Token stepwise with
                                          | [] -> Log.line "cancelled something"
                                          | undoThings -> 
                                              cts.Token.Register(fun () -> List.iter (fun i -> i ()) undoThings) |> ignore
                              | Rem v ->
                                  match cache.TryRemove(v) with
                                      | (true,(stepwise,cts)) ->
  