functions: with error check should check the error twice

process.go

@@ -303,12 +303,17 @@ func (pf Processor[T]) WithoutErrors(errs ...error) Processor[T] {
 // error (any error), the processor propagates that error, rather than
 // running the underying processor. Useful for injecting an abort into
 // an existing pipleine or chain.
+//
+// The error future is called before running the underlying processor,
+// to short circuit the operation, and also a second time when
+// processor has returned in case an error has occurred during the
+// operation of the processor.
 func (pf Processor[T]) WithErrorCheck(ef Future[error]) Processor[T] {
 	return func(ctx context.Context, in T) error {
 		if err := ef(); err != nil {
 			return err
 		}
-		return pf(ctx, in)
+		return ers.Join(pf(ctx, in), ef())
 	}
 }
 

producer.go

@@ -215,7 +215,7 @@ func (pf Producer[T]) CheckForce() (T, bool)               { o, e := pf.Wait();
 // original producer returns.
 func (pf Producer[T]) Launch(ctx context.Context) Producer[T] {
 	eh, ef := HF.ErrorCollector()
-	pipe := Blocking(make(chan T, 2))
+	pipe := Blocking(make(chan T, 1))
 	pipe.Send().Processor().
 		ReadAll(pf).
 		Operation(eh).
@@ -235,9 +235,12 @@ func (pf Producer[T]) WithErrorCheck(ef Future[error]) Producer[T] {
 		if err := ef(); err != nil {
 			return zero, err
 		}
-		return pf.Resolve(ctx)
+		out, err := pf.Resolve(ctx)
+		if err = ers.Join(err, ef()); err != nil {
+			return zero, err
+		}
+		return out, nil
 	}
-
 }
 
 // Once returns a producer that only executes ones, and caches the

worker.go

@@ -367,12 +367,17 @@ func (wf Worker) PostHook(op func()) Worker {
 // error (any error), the worker propagates that error, rather than
 // running the underying producer. Useful for injecting an abort into
 // an existing pipleine or chain.
+//
+// The error future is called before running the underlying worker,
+// to short circuit the operation, and also a second time when
+// worker has returned in case an error has occurred during the
+// operation of the worker.
 func (wf Worker) WithErrorCheck(ef Future[error]) Worker {
 	return func(ctx context.Context) error {
 		if err := ef(); err != nil {
 			return err
 		}
-		return wf.Run(ctx)
+		return ers.Join(wf.Run(ctx), ef())
 	}
 }