diff --git a/Event/EventPacker/include/Event/PackedCaloAdc.h b/Event/EventPacker/include/Event/PackedCaloAdc.h
index 946688de6e6e46fcc88e43e5f56b5c779e81530a..450237dd149dc0368a0e7af0311780f8a842ee51 100644
--- a/Event/EventPacker/include/Event/PackedCaloAdc.h
+++ b/Event/EventPacker/include/Event/PackedCaloAdc.h
@@ -107,7 +107,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedCaloAdcs&, CaloAdcs& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedCaloAdcs&, CaloAdcs& );
 
   private:
     /// Data packing version
@@ -146,7 +146,7 @@ namespace LHCb {
     }
 
     /// Unpack Calo ADCs
-    void unpack( const PackedDataVector& padc, DataVector& adcs ) const;
+    StatusCode unpack( const PackedDataVector& padc, DataVector& adcs ) const;
 
     /// Compare two Calo ADCs to check the packing -> unpacking performance
     StatusCode check( const Data* dataA, const Data* dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedCaloCluster.h b/Event/EventPacker/include/Event/PackedCaloCluster.h
index 7d78dd51f7074aa87db233e601c2e4760cd5791d..9f3372ba57e09e097023c4e39b6393f4173cb596 100644
--- a/Event/EventPacker/include/Event/PackedCaloCluster.h
+++ b/Event/EventPacker/include/Event/PackedCaloCluster.h
@@ -153,7 +153,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedCaloClusters&, CaloClusters& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedCaloClusters&, CaloClusters& );
 
   private:
     /// Data packing version
@@ -203,7 +203,7 @@ namespace LHCb {
     }
 
     /// Unpack Calo Clusters
-    void unpack( const PackedDataVector& pclus, DataVector& cluss ) const;
+    StatusCode unpack( const PackedDataVector& pclus, DataVector& cluss ) const;
 
     /// Compare two Calo Clusters to check the packing -> unpacking performance
     StatusCode check( const Data* dataA, const Data* dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedCaloDigit.h b/Event/EventPacker/include/Event/PackedCaloDigit.h
index 490f826264ef79b1f65d2f4ea7ef749aae126370..af51ca9574895843c3079d822781aaa937b6ba50 100644
--- a/Event/EventPacker/include/Event/PackedCaloDigit.h
+++ b/Event/EventPacker/include/Event/PackedCaloDigit.h
@@ -108,7 +108,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedCaloDigits&, CaloDigits& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedCaloDigits&, CaloDigits& );
 
   private:
     /// Data packing version
@@ -146,7 +146,7 @@ namespace LHCb {
     }
 
     /// Unpack Calo Digits
-    void unpack( const PackedDataVector& pdig, DataVector& digs ) const;
+    StatusCode unpack( const PackedDataVector& pdig, DataVector& digs ) const;
 
     /// Compare two Calo Clusters to check the packing -> unpacking performance
     StatusCode check( const Data* dataA, const Data* dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedCaloHypo.h b/Event/EventPacker/include/Event/PackedCaloHypo.h
index 9fc6ca5027a39393e8fe9d06167cd674a1701cfe..0af5c783e0c70ad1c9571d5ca324480b6cfd73b5 100644
--- a/Event/EventPacker/include/Event/PackedCaloHypo.h
+++ b/Event/EventPacker/include/Event/PackedCaloHypo.h
@@ -131,7 +131,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedCaloHypos&, CaloHypos& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedCaloHypos&, CaloHypos& );
 
   private:
     std::vector<PackedCaloHypo> m_vect;
@@ -186,7 +186,7 @@ namespace LHCb {
     }
 
     /// Unpack CaloHypos
-    void unpack( const PackedDataVector& phypos, DataVector& hypos ) const;
+    StatusCode unpack( const PackedDataVector& phypos, DataVector& hypos ) const;
 
     /// Compare two hypos
     StatusCode check( const Data* dataA, const Data* dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedFlavourTag.h b/Event/EventPacker/include/Event/PackedFlavourTag.h
index e53720d52bf1187b86dc63d83b639a449143d1c0..58071213566c9e056c31bb447b0719f7725b3632 100644
--- a/Event/EventPacker/include/Event/PackedFlavourTag.h
+++ b/Event/EventPacker/include/Event/PackedFlavourTag.h
@@ -167,7 +167,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedFlavourTags&, FlavourTags& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedFlavourTags&, FlavourTags& );
 
   private:
     /// Data packing version (not used as yet, but for any future schema evolution)
@@ -215,10 +215,10 @@ namespace LHCb {
     }
 
     /// Unpack FlavourTags
-    void unpack( const PackedDataVector& pfts, DataVector& fts ) const;
+    StatusCode unpack( const PackedDataVector& pfts, DataVector& fts ) const;
 
     /// Unpack a single FlavourTag
-    void unpack( const PackedData& pft, Data& ft, const PackedDataVector& pfts, DataVector& fts ) const;
+    StatusCode unpack( const PackedData& pft, Data& ft, const PackedDataVector& pfts, DataVector& fts ) const;
 
     /// Compare two FlavourTags to check the packing -> unpacking performance
     StatusCode check( const Data* dataA, const Data* dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedMCCaloHit.h b/Event/EventPacker/include/Event/PackedMCCaloHit.h
index b863fb9356f14728bcb13601739b870a60f9015d..b3c7a50d1ab9f97169682256aa93482464624e46 100644
--- a/Event/EventPacker/include/Event/PackedMCCaloHit.h
+++ b/Event/EventPacker/include/Event/PackedMCCaloHit.h
@@ -109,7 +109,7 @@ namespace LHCb {
     void pack( const DataVector& hits, PackedDataVector& phits ) const;
 
     /// Unpack MCCaloHits
-    void unpack( const PackedDataVector& phits, DataVector& hits ) const;
+    StatusCode unpack( const PackedDataVector& phits, DataVector& hits ) const;
 
     /// Compare two MCCaloHits to check the packing -> unpacking performance
     StatusCode check( const DataVector& dataA, const DataVector& dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedMCHit.h b/Event/EventPacker/include/Event/PackedMCHit.h
index fd3bb4bc51cac86e7412d5926c36e0d418b39a9b..6528089583156a0915712c8f079d38354cd09013 100644
--- a/Event/EventPacker/include/Event/PackedMCHit.h
+++ b/Event/EventPacker/include/Event/PackedMCHit.h
@@ -121,7 +121,7 @@ namespace LHCb {
     void pack( const DataVector& hits, PackedDataVector& phits ) const;
 
     /// Unpack MCHits
-    void unpack( const PackedDataVector& phits, DataVector& hits ) const;
+    StatusCode unpack( const PackedDataVector& phits, DataVector& hits ) const;
 
     /// Compare two MCHits to check the packing -> unpacking performance
     StatusCode check( const DataVector& dataA, const DataVector& dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedMCRichDigitSummary.h b/Event/EventPacker/include/Event/PackedMCRichDigitSummary.h
index 96b03daddd445b7fc80b2c7b7b675a7b3a00f004..198754eca91e997863907e98b70c268f445ab23a 100644
--- a/Event/EventPacker/include/Event/PackedMCRichDigitSummary.h
+++ b/Event/EventPacker/include/Event/PackedMCRichDigitSummary.h
@@ -103,7 +103,7 @@ namespace LHCb {
     void pack( const DataVector& hits, PackedDataVector& phits ) const;
 
     /// Unpack MCRichDigitSummarys
-    void unpack( const PackedDataVector& phits, DataVector& hits ) const;
+    StatusCode unpack( const PackedDataVector& phits, DataVector& hits ) const;
 
     /// Compare two MCRichDigitSummarys to check the packing -> unpacking performance
     StatusCode check( const DataVector& dataA, const DataVector& dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedMCRichHit.h b/Event/EventPacker/include/Event/PackedMCRichHit.h
index a4b45dc0a204c61e5e5507923dc60fa830d8d127..e21b6fc17f92f30802c0b756e4c80591127f485b 100644
--- a/Event/EventPacker/include/Event/PackedMCRichHit.h
+++ b/Event/EventPacker/include/Event/PackedMCRichHit.h
@@ -106,7 +106,7 @@ namespace LHCb {
     void pack( const DataVector& hits, PackedDataVector& phits ) const;
 
     /// Unpack MCRichHits
-    void unpack( const PackedDataVector& phits, DataVector& hits ) const;
+    StatusCode unpack( const PackedDataVector& phits, DataVector& hits ) const;
 
     /// Compare two MCRichHits to check the packing -> unpacking performance
     StatusCode check( const DataVector& dataA, const DataVector& dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedMCRichOpticalPhoton.h b/Event/EventPacker/include/Event/PackedMCRichOpticalPhoton.h
index 737e20cf0c9f35c77956c5fac135ed019d7bf35a..abbf4fe358b58849d975cad2707e95bd3546b543 100644
--- a/Event/EventPacker/include/Event/PackedMCRichOpticalPhoton.h
+++ b/Event/EventPacker/include/Event/PackedMCRichOpticalPhoton.h
@@ -115,7 +115,7 @@ namespace LHCb {
     void pack( const DataVector& phots, PackedDataVector& pphots ) const;
 
     /// Unpack an MCRichOpticalPhoton
-    void unpack( const PackedDataVector& pphots, DataVector& phots ) const;
+    StatusCode unpack( const PackedDataVector& pphots, DataVector& phots ) const;
 
     /// Compare two MCRichHits to check the packing -> unpacking performance
     StatusCode check( const DataVector& dataA, const DataVector& dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedMCRichSegment.h b/Event/EventPacker/include/Event/PackedMCRichSegment.h
index 9de56754226f58e5f47b9033675796b4d7c99c1c..0cb86ddaca11eaf1ef7b0828e8a4074817a02bc1 100644
--- a/Event/EventPacker/include/Event/PackedMCRichSegment.h
+++ b/Event/EventPacker/include/Event/PackedMCRichSegment.h
@@ -108,7 +108,7 @@ namespace LHCb {
     void pack( const DataVector& segs, PackedDataVector& psegs ) const;
 
     /// Unpack an MCRichSegment
-    void unpack( const PackedDataVector& psegs, DataVector& segs ) const;
+    StatusCode unpack( const PackedDataVector& psegs, DataVector& segs ) const;
 
     /// Compare two MCRichHits to check the packing -> unpacking performance
     StatusCode check( const DataVector& dataA, const DataVector& dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedMCRichTrack.h b/Event/EventPacker/include/Event/PackedMCRichTrack.h
index d3a85f816aaaaf5ace807c2af1a5cfcb87154b7a..0463293f379db409c1a2be4753e4ff6803fa0d83 100644
--- a/Event/EventPacker/include/Event/PackedMCRichTrack.h
+++ b/Event/EventPacker/include/Event/PackedMCRichTrack.h
@@ -105,7 +105,7 @@ namespace LHCb {
     void pack( const DataVector& tracks, PackedDataVector& ptracks ) const;
 
     /// Unpack MCRichTracks
-    void unpack( const PackedDataVector& ptracks, DataVector& tracks ) const;
+    StatusCode unpack( const PackedDataVector& ptracks, DataVector& tracks ) const;
 
     /// Compare two MCRichHits to check the packing -> unpacking performance
     StatusCode check( const DataVector& dataA, const DataVector& dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedMuonPID.h b/Event/EventPacker/include/Event/PackedMuonPID.h
index 5fa64179ac73e74666d143e8cd189ce9d3ff4595..6913901487a540e5ae4950eb61af873510c99ef6 100644
--- a/Event/EventPacker/include/Event/PackedMuonPID.h
+++ b/Event/EventPacker/include/Event/PackedMuonPID.h
@@ -120,7 +120,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedMuonPIDs&, MuonPIDs& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedMuonPIDs&, MuonPIDs& );
 
   private:
     /// Data packing version
@@ -159,10 +159,10 @@ namespace LHCb {
     }
 
     /// Unpack a single MuonPID
-    void unpack( const PackedData& ppid, Data& pid, const PackedDataVector& ppids, DataVector& pids ) const;
+    StatusCode unpack( const PackedData& ppid, Data& pid, const PackedDataVector& ppids, DataVector& pids ) const;
 
     /// Unpack MuonPIDs
-    void unpack( const PackedDataVector& ppids, DataVector& pids ) const;
+    StatusCode unpack( const PackedDataVector& ppids, DataVector& pids ) const;
 
     /// Compare two MuonPIDs to check the packing -> unpacking performance
     StatusCode check( const Data* dataA, const Data* dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedPartToRelatedInfoRelation.h b/Event/EventPacker/include/Event/PackedPartToRelatedInfoRelation.h
index c991a98fa8c5de60d8a7928af541fcf700a54836..f5a4570ab7b3b00393ca53bbe9abb253b47698ef 100644
--- a/Event/EventPacker/include/Event/PackedPartToRelatedInfoRelation.h
+++ b/Event/EventPacker/include/Event/PackedPartToRelatedInfoRelation.h
@@ -135,8 +135,8 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedRelatedInfoRelations&,
-                        Relation1D<Particle, RelatedInfoMap>& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedRelatedInfoRelations&,
+                              Relation1D<Particle, RelatedInfoMap>& );
 
   private:
     /// Data packing version (not used as yet, but for any future schema evolution)
@@ -174,10 +174,10 @@ namespace LHCb {
     void pack( const DataVector& rels, PackedDataVector& prels ) const;
 
     /// Unpack the relations
-    void unpack( const PackedDataVector& prels, DataVector& rels, const std::string& location = "" ) const;
+    StatusCode unpack( const PackedDataVector& prels, DataVector& rels, const std::string& location = "" ) const;
 
     /// Unpack the relations
-    void unpack( const LHCb::PackedRelatedInfoMap& pmap, const PackedDataVector& prels, DataVector& rels ) const;
+    StatusCode unpack( const LHCb::PackedRelatedInfoMap& pmap, const PackedDataVector& prels, DataVector& rels ) const;
 
     /// Compare two sets of relations to check the packing -> unpacking performance
     StatusCode check( const DataVector& dataA, const DataVector& dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedParticle.h b/Event/EventPacker/include/Event/PackedParticle.h
index 3167fd13df03ec431e18a4f8a6c339903cb92e01..92e58ec3a3f8bdd4ac4167c814dea5ab6456561f 100644
--- a/Event/EventPacker/include/Event/PackedParticle.h
+++ b/Event/EventPacker/include/Event/PackedParticle.h
@@ -163,7 +163,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedParticles&, Particles& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedParticles&, Particles& );
 
   private:
     /// Data packing version
@@ -207,14 +207,14 @@ namespace LHCb {
     }
 
     /// Unpack Particles
-    void unpack( const PackedDataVector& pparts, DataVector& parts ) const;
+    StatusCode unpack( const PackedDataVector& pparts, DataVector& parts ) const;
 
     /// Unpack Particles
     DataVector unpack( const PackedDataVector& pparts ) const;
 
     /// Unpack a single Particle
-    void unpack( const PackedData& ppart, Data& part, const PackedDataVector& pparts, DataVector& parts,
-                 LHCb::Packer::Carry& ) const;
+    StatusCode unpack( const PackedData& ppart, Data& part, const PackedDataVector& pparts, DataVector& parts,
+                       LHCb::Packer::Carry& ) const;
 
     /// Compare two Particles to check the packing -> unpacking performance
     StatusCode check( const Data* dataA, const Data* dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedProtoParticle.h b/Event/EventPacker/include/Event/PackedProtoParticle.h
index 1e6f78fc995d1b5a6fd727e5438076c4af3856dc..8d72ce038233ca7f8132f5c3c1525a6c081efdee 100644
--- a/Event/EventPacker/include/Event/PackedProtoParticle.h
+++ b/Event/EventPacker/include/Event/PackedProtoParticle.h
@@ -120,7 +120,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedProtoParticles&, ProtoParticles& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedProtoParticles&, ProtoParticles& );
 
   private:
     std::vector<PackedProtoParticle> m_vect;
@@ -163,12 +163,12 @@ namespace LHCb {
     }
 
     /// Unpack ProtoParticles
-    void unpack( const PackedDataVector& pprotos, DataVector& protos ) const;
+    StatusCode unpack( const PackedDataVector& pprotos, DataVector& protos ) const;
 
     /// Unpack a single ProtoParticle -- this only works if `unpack` is called walking sequentially through the vector,
     /// without skipping any entries
-    void unpack( const PackedData& pproto, Data& proto, const PackedDataVector& pprotos, DataVector& protos,
-                 LHCb::Packer::Carry& carry ) const;
+    StatusCode unpack( const PackedData& pproto, Data& proto, const PackedDataVector& pprotos, DataVector& protos,
+                       LHCb::Packer::Carry& carry ) const;
 
     /// Compare two ProtoParticles to check the packing -> unpacking performance
     StatusCode check( const Data* dataA, const Data* dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedRecSummary.h b/Event/EventPacker/include/Event/PackedRecSummary.h
index 55a582770077df09f9e798c5d1d8ea32578bd195..693b711d337539c557c11de1db66b3534d6267b0 100644
--- a/Event/EventPacker/include/Event/PackedRecSummary.h
+++ b/Event/EventPacker/include/Event/PackedRecSummary.h
@@ -84,7 +84,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedRecSummary&, RecSummary& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedRecSummary&, RecSummary& );
 
   private:
     /// Data packing version
@@ -112,7 +112,7 @@ namespace LHCb {
     void pack( const DataVector& hits, PackedDataVector& phits ) const;
 
     /// Unpack RecSummary
-    void unpack( const PackedDataVector& phits, DataVector& hits ) const;
+    StatusCode unpack( const PackedDataVector& phits, DataVector& hits ) const;
 
     /// Compare two RecSummarys to check the packing -> unpacking performance
     StatusCode check( const DataVector& dataA, const DataVector& dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedRecVertex.h b/Event/EventPacker/include/Event/PackedRecVertex.h
index 0f5754cca9d1e17ca38b65f750265661a415bdde..7f5f6f6e57e7527196b78ac38432f3f8df7bd01b 100644
--- a/Event/EventPacker/include/Event/PackedRecVertex.h
+++ b/Event/EventPacker/include/Event/PackedRecVertex.h
@@ -146,7 +146,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedRecVertices&, RecVertices& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedRecVertices&, RecVertices& );
 
   private:
     std::vector<PackedRecVertex>     m_vect;
@@ -186,10 +186,10 @@ namespace LHCb {
     }
 
     /// Unpack a Vertex
-    void unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts, DataVector& verts ) const;
+    StatusCode unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts, DataVector& verts ) const;
 
     /// Unpack Vertices
-    void unpack( const PackedDataVector& pverts, DataVector& verts ) const;
+    StatusCode unpack( const PackedDataVector& pverts, DataVector& verts ) const;
 
     auto& packTrackRefs( bool b ) {
       m_packTrackRefs = b;
diff --git a/Event/EventPacker/include/Event/PackedRichPID.h b/Event/EventPacker/include/Event/PackedRichPID.h
index b32f7d778f29e0a5169c98331e3cbc99fbe082f3..eb7f618b839251e89eb43dd8f69f4b087fa77d16 100644
--- a/Event/EventPacker/include/Event/PackedRichPID.h
+++ b/Event/EventPacker/include/Event/PackedRichPID.h
@@ -123,7 +123,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedRichPIDs&, RichPIDs& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedRichPIDs&, RichPIDs& );
 
   private:
     /// Data packing version
@@ -163,10 +163,10 @@ namespace LHCb {
     }
 
     /// Unpack a single RichPID
-    void unpack( const PackedData& ppid, Data& pid, const PackedDataVector& ppids, DataVector& pids ) const;
+    StatusCode unpack( const PackedData& ppid, Data& pid, const PackedDataVector& ppids, DataVector& pids ) const;
 
     /// Unpack RichPIDs
-    void unpack( const PackedDataVector& ppids, DataVector& pids ) const;
+    StatusCode unpack( const PackedDataVector& ppids, DataVector& pids ) const;
 
     /// Compare two MuonPIDs to check the packing -> unpacking performance
     StatusCode check( const Data* dataA, const Data* dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedTrack.h b/Event/EventPacker/include/Event/PackedTrack.h
index 3436a8f1d4d3ffbb5cfcfb31509d4e7c15736399..c2027511b7dae585a421f9f8049cb48f0e6515ef 100644
--- a/Event/EventPacker/include/Event/PackedTrack.h
+++ b/Event/EventPacker/include/Event/PackedTrack.h
@@ -201,7 +201,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedTracks&, Tracks& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedTracks&, Tracks& );
 
   private:
     std::vector<PackedTrack>                           m_vect;
@@ -245,10 +245,11 @@ namespace LHCb {
     }
 
     /// Unpack a single Track
-    void unpack( const PackedData& ptrack, Data& track, const PackedDataVector& ptracks, DataVector& tracks ) const;
+    StatusCode unpack( const PackedData& ptrack, Data& track, const PackedDataVector& ptracks,
+                       DataVector& tracks ) const;
 
     /// Unpack Tracks
-    void unpack( const PackedDataVector& ptracks, DataVector& tracks ) const;
+    StatusCode unpack( const PackedDataVector& ptracks, DataVector& tracks ) const;
 
     /// Compare two Tracks to check the packing -> unpacking performance
     StatusCode check( const Data* dataA, const Data* dataB ) const;
diff --git a/Event/EventPacker/include/Event/PackedTwoProngVertex.h b/Event/EventPacker/include/Event/PackedTwoProngVertex.h
index 77e0843d68c03071194dc353b88f6dbfb148c63f..49d72a5418843507b25fd4d758c0bad1f6f44cfb 100644
--- a/Event/EventPacker/include/Event/PackedTwoProngVertex.h
+++ b/Event/EventPacker/include/Event/PackedTwoProngVertex.h
@@ -161,7 +161,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedTwoProngVertices&, TwoProngVertices& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedTwoProngVertices&, TwoProngVertices& );
 
   private:
     std::vector<PackedTwoProngVertex> m_vect;
@@ -193,10 +193,10 @@ namespace LHCb {
     }
 
     /// Unpack a TwoProngVertex
-    void unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts, DataVector& verts ) const;
+    StatusCode unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts, DataVector& verts ) const;
 
     /// Unpack TwoProngVertices
-    void unpack( const PackedDataVector& pverts, DataVector& verts ) const;
+    StatusCode unpack( const PackedDataVector& pverts, DataVector& verts ) const;
 
     /// Unpack TwoProngVertices
     DataVector unpack( const PackedDataVector& pverts ) const;
diff --git a/Event/EventPacker/include/Event/PackedVertex.h b/Event/EventPacker/include/Event/PackedVertex.h
index a7fd69cfd88696999ba008211132091d776c204a..c8ce0eb2f74513ee5694414a0173b9483f8928b9 100644
--- a/Event/EventPacker/include/Event/PackedVertex.h
+++ b/Event/EventPacker/include/Event/PackedVertex.h
@@ -157,7 +157,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedVertices&, Vertices& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedVertices&, Vertices& );
 
   private:
     /// Data packing version
@@ -201,10 +201,10 @@ namespace LHCb {
     }
 
     /// Unpack a Vertex
-    void unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts, DataVector& verts ) const;
+    StatusCode unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts, DataVector& verts ) const;
 
     /// Unpack Vertices
-    void unpack( const PackedDataVector& pverts, DataVector& verts ) const;
+    StatusCode unpack( const PackedDataVector& pverts, DataVector& verts ) const;
 
     /// Unpack Vertices
     DataVector unpack( const PackedDataVector& pverts ) const;
diff --git a/Event/EventPacker/include/Event/PackedWeightsVector.h b/Event/EventPacker/include/Event/PackedWeightsVector.h
index ba0e20826e4ad35ba7dccf34f0fe1082880f36fc..0251bc3ff5e9df88e9f27184f6378f1180b272b7 100644
--- a/Event/EventPacker/include/Event/PackedWeightsVector.h
+++ b/Event/EventPacker/include/Event/PackedWeightsVector.h
@@ -130,7 +130,7 @@ namespace LHCb {
     }
 
     // perform unpacking
-    friend void unpack( Gaudi::Algorithm const*, const PackedWeightsVector&, WeightsVectors& );
+    friend StatusCode unpack( Gaudi::Algorithm const*, const PackedWeightsVector&, WeightsVectors& );
 
   private:
     /// Data packing version (not used as yet, but for any future schema evolution)
@@ -186,7 +186,7 @@ namespace LHCb {
     }
 
     /// Unpack Data
-    void unpack( const PackedDataVector& pweightsV, DataVector& weightsV ) const;
+    StatusCode unpack( const PackedDataVector& pweightsV, DataVector& weightsV ) const;
 
     /// Compare two WeightsVectors to check the packing -> unpacking performance
     StatusCode check( const Data* dataA, const Data* dataB ) const;
diff --git a/Event/EventPacker/src/component/BufferUnpackerBaseAlg.cpp b/Event/EventPacker/src/component/BufferUnpackerBaseAlg.cpp
index 6258fa474d9f445188b73c70c2afafdb0616a4ae..de175324d6a7ee6dccefee850bc4c5a8856bb4dd 100644
--- a/Event/EventPacker/src/component/BufferUnpackerBaseAlg.cpp
+++ b/Event/EventPacker/src/component/BufferUnpackerBaseAlg.cpp
@@ -16,6 +16,7 @@ using namespace LHCb::Hlt::PackedData;
 
 namespace {
 
+#if 0
   class PTMap {
     // TODO: keep track of the names of all transient types for this packed type
     struct Item {
@@ -37,20 +38,7 @@ namespace {
     auto begin() const { return m.begin(); }
     auto end() const { return m.end(); }
   };
-
-  template <typename... DataVector>
-  void show_duplicates() {
-    std::cerr << "WARNING: detected the presence of non-unique persistent class IDs:\n";
-    PTMap m;
-    ( m.append<packed_representation<DataVector>, DataVector>(), ... );
-    for ( const auto& [k, v] : m ) {
-      if ( v.transient.size() == 1 ) continue;
-      std::cerr << "  " << k << " ";
-      for ( const auto& t : v.transient ) std::cerr << t << " ";
-      std::cerr << '\n';
-    }
-    // throw std::logic_error("non-unique persistent class IDs");
-  }
+#endif
 
   template <typename DataVector>
   Expected<std::pair<std::string, DataObject const*>> resolveObject( PackedDataInBuffer& buffer,
@@ -70,15 +58,14 @@ namespace {
   template <typename... DataVector>
   struct Create_t {
     auto operator()() const {
-      std::map<CLID, LoaderFn_t> loaders;
+      std::multimap<CLID, LoaderFn_t> loaders;
       ( loaders.emplace( packed_representation<DataVector>::classID(), &resolveObject<DataVector> ), ... );
-      if ( loaders.size() != sizeof...( DataVector ) ) show_duplicates<DataVector...>();
+      if ( loaders.size() != sizeof...( DataVector ) ) throw std::logic_error( "Failure filling unpacking map" );
       return loaders;
     }
   };
 } // namespace
 
 namespace LHCb::Hlt::PackedData {
-
-  const std::map<CLID, LoaderFn_t> Loader::s_map = expand_t<Create_t>{}();
+  const std::multimap<CLID, LoaderFn_t> Loader::s_map = expand_t<Create_t>{}();
 }
diff --git a/Event/EventPacker/src/component/BufferUnpackerBaseAlg.h b/Event/EventPacker/src/component/BufferUnpackerBaseAlg.h
index 3bb339b75ce4690d59f55c68c3712e847f415b48..494796f52e016dd5cdd58ee1150689ed01751045 100644
--- a/Event/EventPacker/src/component/BufferUnpackerBaseAlg.h
+++ b/Event/EventPacker/src/component/BufferUnpackerBaseAlg.h
@@ -131,7 +131,7 @@ namespace LHCb::Hlt::PackedData {
       }
     };
 
-    static const std::map<CLID, LoaderFn_t>       s_map;
+    static const std::multimap<CLID, LoaderFn_t>  s_map;
     Gaudi::Algorithm const*                       m_algo     = nullptr;
     LHCb::Hlt::PackedData::MappedInBuffers const* m_buffers  = nullptr;
     Counters*                                     m_counters = nullptr;
@@ -139,12 +139,19 @@ namespace LHCb::Hlt::PackedData {
 
     Expected<std::pair<std::string, DataObject const*>> load( ReadBuffer& readBuffer ) {
       ObjectHeader header{readBuffer};
-      auto         i = s_map.find( header.classID );
-      if ( i == s_map.end() ) return Unexpected{ErrorCode::NO_LOADER_FOR_CLID};
-      auto r = std::invoke( i->second, readBuffer, header, *this );
+      // note: there _may_ be multiple loaders for the same packed clid. So we just go down the
+      //       list until we succeed...
+      auto [b, e] = s_map.equal_range( header.classID );
+      auto r      = std::accumulate(
+          b, e, Expected<std::pair<std::string, DataObject const*>>{Unexpected{ErrorCode::NO_LOADER_FOR_CLID}},
+          [&]( auto r, const auto& i ) { return r ? r : std::invoke( i.second, readBuffer, header, *this ); } );
       if ( msgLevel( MSG::DEBUG ) ) {
-        debug() << "Unpacked linked location  " << r->first << " (CLID=" << header.classID
-                << " locationID=" << header.locationID << ") "
+        if ( r ) {
+          debug() << "Unpacked linked location  " << r->first;
+        } else {
+          debug() << "Failed unpacking: " << r.error();
+        }
+        debug() << " (CLID=" << header.classID << " locationID=" << header.locationID << ") "
                 << "   " << header.storedSize << " were stored!"
                 << " and " << header.linkLocationIDs.size() << " links were stored!" << endmsg;
       }
@@ -258,13 +265,11 @@ namespace LHCb::Hlt::PackedData {
     }
   };
 
-  template <typename DataVector>
-  Expected<std::unique_ptr<DataVector>> restoreObject( PackedDataInBuffer& buffer, ObjectHeader const& header,
-                                                       Loader& loader ) {
-    using PackedDataVector = LHCb::Packers::Traits::packed_representation<DataVector>;
+  template <typename PackedDataVector>
+  Expected< DataPacking::Buffer::RegistryWrapper<PackedDataVector> > restorePackedData( PackedDataInBuffer& buffer, ObjectHeader const& header, Loader& loader ) {
     if ( header.classID != PackedDataVector::classID() ) return Unexpected{ErrorCode::INCONSISTENT_PACKED_CLID};
 
-    // Sadly the pack structure expects data with valid Registry and LinkMgr. To be improved
+    // The unpacking code expects data with valid Registry and LinkMgr. So it must be wrapped
     auto pdata      = DataPacking::Buffer::RegistryWrapper<PackedDataVector>( "DummyPacked" );
     auto nBytesRead = buffer.load( *pdata );
     if ( loader.msgLevel( MSG::DEBUG ) ) {
@@ -278,18 +283,24 @@ namespace LHCb::Hlt::PackedData {
                        << loader.decoder()( header.locationID ).value_or( fmt::format( " ID {}", header.locationID ) )
                        << endmsg;
     }
-    if ( auto sc = loader.resolveLinks( *pdata, header ); sc.isFailure() )
-      return Unexpected{sc}; // we may want to continue here, and have the unpacker deal with this...
+    if ( auto sc = loader.resolveLinks( *pdata, header ); sc.isFailure() ) return Unexpected{sc};
+    return pdata;
+  }
+
+  template <typename DataVector>
+  Expected<std::unique_ptr<DataVector>> restoreObject( PackedDataInBuffer& buffer, ObjectHeader const& header,
+                                                       Loader& loader ) {
+    const auto pdata = restorePackedData<LHCb::Packers::Traits::packed_representation<DataVector>>( buffer, header, loader );
+    if (!pdata) return Unexpected{pdata.error()};
     auto data = std::make_unique<DataVector>();
-    data->setVersion( pdata->version() );
-    unpack( loader, *pdata, *data );
+    data->setVersion( (*pdata)->version() );
+    if ( auto sc = unpack( loader, **pdata, *data ); sc.isFailure() ) { return Unexpected{sc}; }
     return data;
   }
 
   template <typename DataVector>
   Expected<std::unique_ptr<DataVector>> restoreObject( PackedDataInBuffer const& buffer, Loader& loader ) {
-    auto readBuffer =
-        ReadBuffer{buffer}; // TODO: allow for emphemeral 'view' for reading without copying just to update 'pos'
+    auto readBuffer = ReadBuffer{buffer}; // TODO: allow for emphemeral 'view' for reading without copying just to update 'pos'
     return restoreObject<DataVector>( readBuffer, ObjectHeader{readBuffer}, loader );
   }
 
diff --git a/Event/EventPacker/src/component/MCPackers.cpp b/Event/EventPacker/src/component/MCPackers.cpp
index 6b43bef13d59e55a20a1ad01fb10686ad3baa959..cc79f3c93ecf9377e46f7c79242c0847d1de7dce 100644
--- a/Event/EventPacker/src/component/MCPackers.cpp
+++ b/Event/EventPacker/src/component/MCPackers.cpp
@@ -97,7 +97,7 @@ namespace DataPacking {
       // give same version as original
       unpacked->setVersion( data->version() );
       // unpack
-      m_packer.unpack( *pdata, *unpacked );
+      m_packer.unpack( *pdata, *unpacked ).ignore();
       // run checks
       m_packer.check( *data, *unpacked ).ignore();
       // clean up after checks
diff --git a/Event/EventPacker/src/component/RelationPackers.cpp b/Event/EventPacker/src/component/RelationPackers.cpp
index 573befe66c6058bba03f069f3ac43e0b2efe5b1e..a1475fa198e5c84016bed6bbd712189ae1cf9f84 100644
--- a/Event/EventPacker/src/component/RelationPackers.cpp
+++ b/Event/EventPacker/src/component/RelationPackers.cpp
@@ -35,8 +35,8 @@ namespace LHCb::Packers {
     pcont.last = prels.data().size();
   }
 
-  void P2InfoRelation::unpack( const PackedRelatedInfoRelations&     prels,
-                               Relation1D<Particle, RelatedInfoMap>& rels ) const {
+  StatusCode P2InfoRelation::unpack( const PackedRelatedInfoRelations&     prels,
+                                     Relation1D<Particle, RelatedInfoMap>& rels ) const {
     auto resolver = details::Resolver{prels.linkMgr()};
     for ( const auto& prel : prels.containers() ) {
       for ( const auto& rel : LHCb::Packer::subrange( prels.relations(), prel.first, prel.last ) ) {
@@ -61,6 +61,7 @@ namespace LHCb::Packers {
     }
     if ( resolver.hasErrors() ) resolver.dump( parent().warning() );
     rels.i_sort();
+    return StatusCode::SUCCESS; // TODO: return error if resolver.hasError()
   }
 
   void P2IntRelation::pack( const Relation1D<LHCb::Particle, int>& rels, PackedRelations& prels ) const {
@@ -89,7 +90,7 @@ namespace LHCb::Packers {
     prel.end = prels.sources().size();
   }
 
-  void P2IntRelation::unpack( const PackedRelations& prels, Relation1D<LHCb::Particle, int>& rels ) const {
+  StatusCode P2IntRelation::unpack( const PackedRelations& prels, Relation1D<LHCb::Particle, int>& rels ) const {
     auto resolver = details::Resolver{prels.linkMgr()};
     for ( const auto& prel : prels.data() ) {
       for ( int kk = prel.start; kk < prel.end; ++kk ) {
@@ -112,6 +113,7 @@ namespace LHCb::Packers {
     }
     if ( resolver.hasErrors() ) resolver.dump( parent().warning() );
     rels.i_sort();
+    return StatusCode::SUCCESS; // TODO: check resolver.hasErrors()
   }
 
 } // namespace LHCb::Packers
@@ -119,22 +121,24 @@ namespace LHCb::Packers {
 namespace LHCb {
 
   // known unpacking transformations
-  void unpack( Gaudi::Algorithm const* parent, PackedWeightedRelations const& in,
-               RelationWeighted1D<ProtoParticle, MCParticle, double>& out ) {
-    Packers::WeightedRelation<ProtoParticle, MCParticle>{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, PackedWeightedRelations const& in,
+                     RelationWeighted1D<ProtoParticle, MCParticle, double>& out ) {
+    return Packers::WeightedRelation<ProtoParticle, MCParticle>{parent}.unpack( in, out );
   }
-  void unpack( Gaudi::Algorithm const* parent, PackedRelatedInfoRelations const& in,
-               Relation1D<Particle, RelatedInfoMap>& out ) {
-    Packers::P2InfoRelation{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, PackedRelatedInfoRelations const& in,
+                     Relation1D<Particle, RelatedInfoMap>& out ) {
+    return Packers::P2InfoRelation{parent}.unpack( in, out );
   }
-  void unpack( Gaudi::Algorithm const* parent, PackedRelations const& in, Relation1D<Particle, VertexBase>& out ) {
-    Packers::ParticleRelation<VertexBase>{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, PackedRelations const& in,
+                     Relation1D<Particle, VertexBase>& out ) {
+    return Packers::ParticleRelation<VertexBase>{parent}.unpack( in, out );
   }
-  void unpack( Gaudi::Algorithm const* parent, PackedRelations const& in, Relation1D<Particle, MCParticle>& out ) {
-    Packers::ParticleRelation<MCParticle>{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, PackedRelations const& in,
+                     Relation1D<Particle, MCParticle>& out ) {
+    return Packers::ParticleRelation<MCParticle>{parent}.unpack( in, out );
   }
-  void unpack( Gaudi::Algorithm const* parent, PackedRelations const& in, Relation1D<Particle, int>& out ) {
-    Packers::P2IntRelation{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, PackedRelations const& in, Relation1D<Particle, int>& out ) {
+    return Packers::P2IntRelation{parent}.unpack( in, out );
   }
 
 } // namespace LHCb
diff --git a/Event/EventPacker/src/component/RelationPackers.h b/Event/EventPacker/src/component/RelationPackers.h
index b8de5d4ed0a380c6401852dbabc3847efaa473a1..e018d2f61e301ee3c5803b3957f53d3548bb5b7c 100644
--- a/Event/EventPacker/src/component/RelationPackers.h
+++ b/Event/EventPacker/src/component/RelationPackers.h
@@ -81,7 +81,7 @@ namespace LHCb::Packers {
           return tl::unexpected{Packers::ErrorCode::CONTAINER_NOT_FOUND};
         }
         auto const* container = dynamic_cast<T const*>( link->object() );
-        if ( !container ) return tl::unexpected{Packers::ErrorCode::WRONG_CONTAINER_TYPE};
+        if ( !container ) return tl::unexpected{Packers::ErrorCode::WRONG_CONTAINER_TYPE}; /// THIS IS WHAT GOES WRONG
         auto const* obj = container->object( key );
         if ( !obj ) {
           ++missing_key( id );
@@ -118,7 +118,7 @@ namespace LHCb::Packers {
 
     // Relations between two containers
     template <typename RELATION, typename PRELATION, typename ALGORITHM>
-    void unpack2d( RELATION& rels, const PRELATION& prels, ALGORITHM const& parent ) {
+    StatusCode unpack2d( RELATION& rels, const PRELATION& prels, ALGORITHM const& parent ) {
 
       auto resolver = details::Resolver{prels.linkMgr()};
       for ( const auto& prel : prels.data() ) {
@@ -162,9 +162,10 @@ namespace LHCb::Packers {
                            << " rels size " << rels.relations().size() << endmsg;
           }
         }
-        if ( resolver.hasErrors() ) resolver.dump( parent.warning() );
       }
+      if ( resolver.hasErrors() ) resolver.dump( parent.warning() );
       rels.i_sort();
+      return StatusCode::SUCCESS; // TODO: pick up any errors from resolver!!!!
     }
 
   } // namespace details
@@ -182,7 +183,9 @@ namespace LHCb::Packers {
       if constexpr ( std::is_same_v<To, LHCb::MCParticle> ) return "P2MCPRelations";
     }
 
-    void unpack( const PackedDataVector& pdata, DataVector& data ) const { details::unpack2d( data, pdata, parent() ); }
+    StatusCode unpack( const PackedDataVector& pdata, DataVector& data ) const {
+      return details::unpack2d( data, pdata, parent() );
+    }
 
     template <typename Range>
     StatusCode check( const Range& dataA, const DataVector& dataB ) const {
@@ -259,7 +262,7 @@ namespace LHCb::Packers {
     using DataVector       = LHCb::Relation1D<LHCb::Particle, int>;
     static const char* propertyName() { return "P2IntRelations"; }
 
-    void unpack( const PackedDataVector& prels, DataVector& rels ) const;
+    StatusCode unpack( const PackedDataVector& prels, DataVector& rels ) const;
 
     template <typename Range>
     StatusCode check( const Range& dataA, const DataVector& dataB ) const {
@@ -313,7 +316,9 @@ namespace LHCb::Packers {
       }
     }
 
-    void unpack( const PackedDataVector& pdata, DataVector& data ) const { details::unpack2d( data, pdata, parent() ); }
+    StatusCode unpack( const PackedDataVector& pdata, DataVector& data ) const {
+      return details::unpack2d( data, pdata, parent() );
+    }
 
     template <typename Range>
     StatusCode check( const Range& dataA, const DataVector& dataB ) const {
@@ -401,7 +406,7 @@ namespace LHCb::Packers {
     using PackedDataVector = LHCb::PackedRelatedInfoRelations;
     static const char* propertyName() { return "P2InfoRelations"; }
 
-    void unpack( const PackedDataVector& prels, DataVector& rels ) const;
+    StatusCode unpack( const PackedDataVector& prels, DataVector& rels ) const;
 
     template <typename Range>
     StatusCode check( const Range& dataA, const DataVector& dataB ) const {
@@ -451,7 +456,7 @@ namespace LHCb::Packers {
 
     SharedObjectsContainer( Gaudi::Algorithm const* p ) : PackerBase( p ) {}
 
-    void unpack( const PackedDataVector& src, DataVector& tgt ) const {
+    StatusCode unpack( const PackedDataVector& src, DataVector& tgt ) const {
       auto resolver = details::Resolver{src.linkMgr()};
       for ( const auto& i : src ) {
         auto f = resolver.object<typename ValueType::Container>( i );
@@ -463,6 +468,8 @@ namespace LHCb::Packers {
         tgt.insert( f.value() );
       }
       if ( resolver.hasErrors() ) resolver.dump( parent().warning() );
+      // TODO: Propage resolver error!!!
+      return StatusCode::SUCCESS;
     }
 
     template <typename Range>
@@ -490,18 +497,19 @@ namespace LHCb::Packers {
 
 namespace LHCb {
 
-  // known unpacking transformations
-  void unpack( Gaudi::Algorithm const*, PackedWeightedRelations const&,
-               RelationWeighted1D<ProtoParticle, MCParticle, double>& );
-  void unpack( Gaudi::Algorithm const*, PackedRelatedInfoRelations const&, Relation1D<Particle, RelatedInfoMap>& );
-  void unpack( Gaudi::Algorithm const*, PackedRelations const&, Relation1D<Particle, VertexBase>& );
-  void unpack( Gaudi::Algorithm const*, PackedRelations const&, Relation1D<Particle, MCParticle>& );
-  void unpack( Gaudi::Algorithm const*, PackedRelations const&, Relation1D<Particle, int>& );
+  // known unpacking transformations -- need to return StatusCode here!!!
+  StatusCode unpack( Gaudi::Algorithm const*, PackedWeightedRelations const&,
+                     RelationWeighted1D<ProtoParticle, MCParticle, double>& );
+  StatusCode unpack( Gaudi::Algorithm const*, PackedRelatedInfoRelations const&,
+                     Relation1D<Particle, RelatedInfoMap>& );
+  StatusCode unpack( Gaudi::Algorithm const*, PackedRelations const&, Relation1D<Particle, VertexBase>& );
+  StatusCode unpack( Gaudi::Algorithm const*, PackedRelations const&, Relation1D<Particle, MCParticle>& );
+  StatusCode unpack( Gaudi::Algorithm const*, PackedRelations const&, Relation1D<Particle, int>& );
 
   template <typename T>
-  void unpack( Gaudi::Algorithm const* parent, PackedSharedObjectsContainer<T> const& in,
-               ::SharedObjectsContainer<T>& out ) {
-    Packers::SharedObjectsContainer<T>{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, PackedSharedObjectsContainer<T> const& in,
+                     ::SharedObjectsContainer<T>& out ) {
+    return Packers::SharedObjectsContainer<T>{parent}.unpack( in, out );
   }
 
 } // namespace LHCb
diff --git a/Event/EventPacker/src/component/SelectivePacker.cpp b/Event/EventPacker/src/component/SelectivePacker.cpp
index 11840171a504329bb24d3ee32338d6596aad4ce2..596db9d81e2cd1f32cf061ffcb136f96c5caf25e 100644
--- a/Event/EventPacker/src/component/SelectivePacker.cpp
+++ b/Event/EventPacker/src/component/SelectivePacker.cpp
@@ -345,7 +345,11 @@ namespace LHCb {
           ->registerObject( fmt::format( "{}_PackingCheck", identifier( range ) ), unpacked )
           .ignore();
       unpacked->setVersion( pdata.version() );
-      unpack( &packer.parent(), pdata, *unpacked );
+      unpack( &packer.parent(), pdata, *unpacked )
+          .orElse( [&] {
+            packer.parent().warning() << "Error unpacking during checking :" << identifier( range ) << endmsg;
+          } )
+          .ignore();
 
       // checker
       const DataPacking::DataChecks ch( packer.parent() );
diff --git a/Event/EventPacker/src/component/UnpackProtoParticle.cpp b/Event/EventPacker/src/component/UnpackProtoParticle.cpp
index af25039d31a2b0084b785311d9c94e1d1776df0b..ec595d8622be1dc910aac0afe524d58eb32d06be 100644
--- a/Event/EventPacker/src/component/UnpackProtoParticle.cpp
+++ b/Event/EventPacker/src/component/UnpackProtoParticle.cpp
@@ -17,7 +17,7 @@
 #include "Interfaces/IProtoParticleTool.h"
 #include "LHCbAlgs/Consumer.h"
 
-namespace LHCb {
+namespace LHCb::Obsolete {
 
   /**
    *  Unpack a protoparticle container
@@ -38,32 +38,31 @@ namespace LHCb {
                    pSvcLocator,
                    {KeyValue{"InputName", PackedProtoParticleLocation::Charged},
                     KeyValue{"StandardGeometryTop", LHCb::standard_geometry_top}}} {}
-    void operator()( PackedProtoParticles const&, DetectorElement const& ) const override;
 
-    DataObjectWriteHandle<ProtoParticles> m_protos{this, "OutputName", ProtoParticleLocation::Charged};
+    void operator()( LHCb::PackedProtoParticles const& dst, DetectorElement const& lhcb ) const override {
+      if ( msgLevel( MSG::DEBUG ) )
+        debug() << "Found " << dst.data().size() << " PackedProtoParticles at " << inputLocation<PackedProtoParticles>()
+                << endmsg;
 
-    ToolHandleArray<Rec::Interfaces::IProtoParticles> m_addInfo{this, "AddInfo", {}};
-  };
+      // NOTE: the output container _must be on the TES_ prior to passing it to the
+      //      unpacker, as otherwise filling the references to other objects does
+      //      not work
+      auto* newProtoParticles = m_protos.put( std::make_unique<ProtoParticles>() );
 
-} // namespace LHCb
+      // unpack
+      ProtoParticlePacker{this}.unpack( dst, *newProtoParticles ).ignore();
 
-DECLARE_COMPONENT_WITH_ID( LHCb::UnpackProtoParticle, "UnpackProtoParticle" )
+      if ( msgLevel( MSG::DEBUG ) )
+        debug() << "Created " << newProtoParticles->size() << " ProtoParticles at " << m_protos.fullKey() << endmsg;
 
-void LHCb::UnpackProtoParticle::operator()( LHCb::PackedProtoParticles const& dst, DetectorElement const& lhcb ) const {
-  if ( msgLevel( MSG::DEBUG ) )
-    debug() << "Found " << dst.data().size() << " PackedProtoParticles at " << inputLocation<PackedProtoParticles>()
-            << endmsg;
+      for ( auto& addInfo : m_addInfo ) ( *addInfo )( *newProtoParticles, *lhcb.geometry() ).ignore();
+    }
 
-  // NOTE: the output container _must be on the TES_ prior to passing it to the
-  //      unpacker, as otherwise filling the references to other objects does
-  //      not work
-  auto* newProtoParticles = m_protos.put( std::make_unique<ProtoParticles>() );
+    DataObjectWriteHandle<ProtoParticles> m_protos{this, "OutputName", ProtoParticleLocation::Charged};
 
-  // unpack
-  ProtoParticlePacker{this}.unpack( dst, *newProtoParticles );
+    ToolHandleArray<Rec::Interfaces::IProtoParticles> m_addInfo{this, "AddInfo", {}};
+  };
 
-  if ( msgLevel( MSG::DEBUG ) )
-    debug() << "Created " << newProtoParticles->size() << " ProtoParticles at " << m_protos.fullKey() << endmsg;
+  DECLARE_COMPONENT_WITH_ID( UnpackProtoParticle, "UnpackProtoParticle" )
 
-  for ( auto& addInfo : m_addInfo ) ( *addInfo )( *newProtoParticles, *lhcb.geometry() ).ignore();
-}
+} // namespace LHCb::Obsolete
diff --git a/Event/EventPacker/src/component/UnpackRecVertex.cpp b/Event/EventPacker/src/component/UnpackRecVertex.cpp
index c4f0c45b9c22e577216993e66febc95a5562fbb2..f407c6b7687c36caf64e77e1cbdafe2dc0edda5c 100644
--- a/Event/EventPacker/src/component/UnpackRecVertex.cpp
+++ b/Event/EventPacker/src/component/UnpackRecVertex.cpp
@@ -16,7 +16,7 @@
 #include "Gaudi/Accumulators.h"
 #include "LHCbAlgs/Consumer.h"
 
-namespace LHCb {
+namespace LHCb::Obsolete {
 
   /**
    *  Unpack a PackedRecVertex container to RecVertices.
@@ -33,7 +33,25 @@ namespace LHCb {
     UnpackRecVertex( std::string const& name, ISvcLocator* pSvcLocator )
         : Consumer( name, pSvcLocator, KeyValue{"InputName", PackedRecVertexLocation::Primary} ) {}
 
-    void operator()( PackedRecVertices const& ) const override;
+    void operator()( LHCb::PackedRecVertices const& dst ) const override {
+      if ( (int)dst.version() < 2 ) {
+        // We can't unpack the weights vector because it lives in a seperate
+        // location for < v2 packed vertices; this means fully supporting all
+        // vertices would require an 'optional' data dependency which the Gaudi
+        // HiveDataBroker doesn't support
+        ++m_oldVersion;
+      }
+
+      if ( msgLevel( MSG::DEBUG ) ) debug() << "Size of PackedRecVertices = " << dst.data().size() << endmsg;
+
+      auto*                 newRecVertices = m_output.put( std::make_unique<RecVertices>() );
+      const RecVertexPacker rvPacker( this );
+      for ( const auto& src : dst.data() ) {
+        auto* vert = new RecVertex();
+        newRecVertices->insert( vert, src.key );
+        rvPacker.unpack( src, *vert, dst, *newRecVertices ).ignore();
+      }
+    }
 
     DataObjectWriteHandle<RecVertices> m_output{this, "OutputName", RecVertexLocation::Primary};
 
@@ -41,26 +59,6 @@ namespace LHCb {
         this, "PackedRecVertex version < 2 not fully supported; associated weights vector will not be unpacked", 10};
   };
 
-} // namespace LHCb
-
-DECLARE_COMPONENT_WITH_ID( LHCb::UnpackRecVertex, "UnpackRecVertex" )
-
-void LHCb::UnpackRecVertex::operator()( LHCb::PackedRecVertices const& dst ) const {
-  if ( (int)dst.version() < 2 ) {
-    // We can't unpack the weights vector because it lives in a seperate
-    // location for < v2 packed vertices; this means fully supporting all
-    // vertices would require an 'optional' data dependency which the Gaudi
-    // HiveDataBroker doesn't support
-    ++m_oldVersion;
-  }
-
-  if ( msgLevel( MSG::DEBUG ) ) debug() << "Size of PackedRecVertices = " << dst.data().size() << endmsg;
+  DECLARE_COMPONENT_WITH_ID( UnpackRecVertex, "UnpackRecVertex" )
 
-  auto*                 newRecVertices = m_output.put( std::make_unique<RecVertices>() );
-  const RecVertexPacker rvPacker( this );
-  for ( const auto& src : dst.data() ) {
-    auto* vert = new RecVertex();
-    newRecVertices->insert( vert, src.key );
-    rvPacker.unpack( src, *vert, dst, *newRecVertices );
-  }
-}
+} // namespace LHCb::Obsolete
diff --git a/Event/EventPacker/src/component/UnpackerBaseAlg.h b/Event/EventPacker/src/component/UnpackerBaseAlg.h
index dab61673fe70ae1a790a1426a92ce0507ade40b1..cf822414cebd63918d5775e7055cfe150e0fd7ce 100644
--- a/Event/EventPacker/src/component/UnpackerBaseAlg.h
+++ b/Event/EventPacker/src/component/UnpackerBaseAlg.h
@@ -54,7 +54,7 @@ namespace DataPacking {
 
     data->setVersion( pdata->version() );
     // Fill unpacked data
-    PACKER{this}.unpack( *pdata, *data );
+    PACKER{this}.unpack( *pdata, *data ).ignore();
     if ( this->msgLevel( MSG::DEBUG ) ) {
       this->debug() << "Created " << data->size() << " data objects at " << m_data.fullKey() << endmsg;
       this->debug() << " Packed Data Version    = " << (unsigned int)pdata->version() << endmsg;
diff --git a/Event/EventPacker/src/lib/PackedCaloAdc.cpp b/Event/EventPacker/src/lib/PackedCaloAdc.cpp
index 6a6987a94d928899b7d5175e69f242779d4c1591..8ed7f5ede79af0f0f701ebfe4e333643134ac4c5 100644
--- a/Event/EventPacker/src/lib/PackedCaloAdc.cpp
+++ b/Event/EventPacker/src/lib/PackedCaloAdc.cpp
@@ -22,8 +22,8 @@ void CaloAdcPacker::pack( const Data& adc, PackedData& padc, PackedDataVector& p
   padc.adc = adc.adc();
 }
 
-void CaloAdcPacker::unpack( const PackedDataVector& padcs, DataVector& adcs ) const {
-  if ( !isSupportedVer( padcs.packingVersion() ) ) return;
+StatusCode CaloAdcPacker::unpack( const PackedDataVector& padcs, DataVector& adcs ) const {
+  if ( !isSupportedVer( padcs.packingVersion() ) ) return StatusCode::FAILURE;
   adcs.reserve( padcs.data().size() );
   for ( const auto& padc : padcs.data() ) {
     // make and save new adc container, with original key
@@ -32,6 +32,7 @@ void CaloAdcPacker::unpack( const PackedDataVector& padcs, DataVector& adcs ) co
     // general
     adc->setAdc( padc.adc );
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode CaloAdcPacker::check( const Data* dataA, const Data* dataB ) const {
@@ -63,7 +64,7 @@ StatusCode CaloAdcPacker::check( const Data* dataA, const Data* dataB ) const {
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const PackedCaloAdcs& in, CaloAdcs& out ) {
-    CaloAdcPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const PackedCaloAdcs& in, CaloAdcs& out ) {
+    return CaloAdcPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedCaloCluster.cpp b/Event/EventPacker/src/lib/PackedCaloCluster.cpp
index 14efbfdeff82ae6ade0e0e30ab8d9225213fb362..9313d1da0e4069e7e4a7d883eca33d33da8d2b6d 100644
--- a/Event/EventPacker/src/lib/PackedCaloCluster.cpp
+++ b/Event/EventPacker/src/lib/PackedCaloCluster.cpp
@@ -70,8 +70,8 @@ void CaloClusterPacker::pack( const Data& clu, PackedData& pclu, PackedDataVecto
   pclu.lastEntry = pclus.entries().size();
 }
 
-void CaloClusterPacker::unpack( const PackedDataVector& pclus, DataVector& clus ) const {
-  if ( !isSupportedVer( pclus.packingVersion() ) ) return;
+StatusCode CaloClusterPacker::unpack( const PackedDataVector& pclus, DataVector& clus ) const {
+  if ( !isSupportedVer( pclus.packingVersion() ) ) return StatusCode::FAILURE;
   clus.reserve( pclus.data().size() );
   for ( const auto& pclu : pclus.data() ) {
     // make and save new clUster container, with original key
@@ -132,6 +132,7 @@ void CaloClusterPacker::unpack( const PackedDataVector& pclus, DataVector& clus
       ent.setFraction( StandardPacker::fraction( pEnt.fraction ) );
     }
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode CaloClusterPacker::check( const Data* dataA, const Data* dataB ) const {
@@ -216,8 +217,8 @@ StatusCode CaloClusterPacker::check( const Data* dataA, const Data* dataB ) cons
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const CaloClusterPacker::PackedDataVector& in,
-               CaloClusterPacker::DataVector& out ) {
-    CaloClusterPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const CaloClusterPacker::PackedDataVector& in,
+                     CaloClusterPacker::DataVector& out ) {
+    return CaloClusterPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedCaloDigit.cpp b/Event/EventPacker/src/lib/PackedCaloDigit.cpp
index 6daa890764c45ec8ba019eba73ebb849c56e4505..00d5af01d636ebaec76369fd052bae4e11ac72d6 100644
--- a/Event/EventPacker/src/lib/PackedCaloDigit.cpp
+++ b/Event/EventPacker/src/lib/PackedCaloDigit.cpp
@@ -27,8 +27,8 @@ void CaloDigitPacker::pack( const Data& dig, PackedData& pdig, PackedDataVector&
   }
 }
 
-void CaloDigitPacker::unpack( const PackedDataVector& pdigs, DataVector& digs ) const {
-  if ( !isSupportedVer( pdigs.packingVersion() ) ) return;
+StatusCode CaloDigitPacker::unpack( const PackedDataVector& pdigs, DataVector& digs ) const {
+  if ( !isSupportedVer( pdigs.packingVersion() ) ) return StatusCode::FAILURE;
   digs.reserve( pdigs.data().size() );
   for ( const auto& pdig : pdigs.data() ) {
     // make and save new digit container, with original key
@@ -37,6 +37,7 @@ void CaloDigitPacker::unpack( const PackedDataVector& pdigs, DataVector& digs )
     // general
     dig->setE( StandardPacker::energy( pdig.e ) );
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode CaloDigitPacker::check( const Data* dataA, const Data* dataB ) const {
@@ -67,8 +68,8 @@ StatusCode CaloDigitPacker::check( const Data* dataA, const Data* dataB ) const
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const CaloDigitPacker::PackedDataVector& in,
-               CaloDigitPacker::DataVector& out ) {
-    CaloDigitPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const CaloDigitPacker::PackedDataVector& in,
+                     CaloDigitPacker::DataVector& out ) {
+    return CaloDigitPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedCaloHypo.cpp b/Event/EventPacker/src/lib/PackedCaloHypo.cpp
index 2ea640561e0b62f7b524b0941b77fcfe4e178a10..f9fd11441ae937a997c0808ef342f21ab6364ff0 100644
--- a/Event/EventPacker/src/lib/PackedCaloHypo.cpp
+++ b/Event/EventPacker/src/lib/PackedCaloHypo.cpp
@@ -114,11 +114,11 @@ void CaloHypoPacker::pack( const Data& H, PackedData& pH, PackedDataVector& phyp
   pH.lastHypo = phypos.refs().size();
 }
 
-void CaloHypoPacker::unpack( const PackedDataVector& phypos, DataVector& hypos ) const {
+StatusCode CaloHypoPacker::unpack( const PackedDataVector& phypos, DataVector& hypos ) const {
 
   // packing version
   const auto ver = phypos.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE;
 
   hypos.reserve( phypos.data().size() );
 
@@ -189,6 +189,7 @@ void CaloHypoPacker::unpack( const PackedDataVector& phypos, DataVector& hypos )
     }
 
   } // loop over hypos
+  return StatusCode::SUCCESS;
 }
 
 StatusCode CaloHypoPacker::check( const Data* oHypo, const Data* tHypo ) const {
@@ -291,8 +292,8 @@ StatusCode CaloHypoPacker::check( const Data* oHypo, const Data* tHypo ) const {
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const CaloHypoPacker::PackedDataVector& in,
-               CaloHypoPacker::DataVector& out ) {
-    CaloHypoPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const CaloHypoPacker::PackedDataVector& in,
+                     CaloHypoPacker::DataVector& out ) {
+    return CaloHypoPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedFlavourTag.cpp b/Event/EventPacker/src/lib/PackedFlavourTag.cpp
index 554a22b1ec0c96906664b982137cded020e7a346..96dc6bce078a19f5fdf3227602ef8ad9058b1609 100644
--- a/Event/EventPacker/src/lib/PackedFlavourTag.cpp
+++ b/Event/EventPacker/src/lib/PackedFlavourTag.cpp
@@ -64,10 +64,12 @@ void FlavourTagPacker::pack( const Data& ft, PackedData& pft, PackedDataVector&
   pft.lastTagger = pfts.taggers().size();
 }
 
-void FlavourTagPacker::unpack( const PackedData& pft, Data& ft, const PackedDataVector& pfts, DataVector& fts ) const {
+StatusCode FlavourTagPacker::unpack( const PackedData& pft, Data& ft, const PackedDataVector& pfts,
+                                     DataVector& fts ) const {
 
   const auto ver = pfts.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) )
+    return StatusCode::FAILURE; // TODO: move to component, and define a dedicated error code
 
   // Decision
   ft.setDecision( pft.decision );
@@ -89,7 +91,7 @@ void FlavourTagPacker::unpack( const PackedData& pft, Data& ft, const PackedData
   }
 
   // Taggers
-  std::vector<LHCb::Tagger>& taggers = *( const_cast<std::vector<LHCb::Tagger>*>( &ft.taggers() ) );
+  auto& taggers = ft.taggers();
   taggers.reserve( pft.lastTagger - pft.firstTagger );
   for ( const auto& ptagger : Packer::subrange( pfts.taggers(), pft.firstTagger, pft.lastTagger ) ) {
 
@@ -117,22 +119,27 @@ void FlavourTagPacker::unpack( const PackedData& pft, Data& ft, const PackedData
       tagger.setCharge( StandardPacker::fraction( ptagger.charge ) );
     }
   }
+  return StatusCode::SUCCESS;
 }
 
-void FlavourTagPacker::unpack( const PackedDataVector& pfts, DataVector& fts ) const {
+StatusCode FlavourTagPacker::unpack( const PackedDataVector& pfts, DataVector& fts ) const {
+
   const auto ver = pfts.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE; // TODO: define dedicated error code
 
   fts.reserve( pfts.data().size() );
 
+  StatusCode sc = StatusCode::SUCCESS;
   for ( const auto& pft : pfts.data() ) {
     // make and save new pid in container
     auto* ft = new Data();
     fts.insert( ft, pft.key );
 
     // Fill data from packed object
-    unpack( pft, *ft, pfts, fts );
+    auto sc2 = unpack( pft, *ft, pfts, fts );
+    if ( sc.isSuccess() ) sc = sc2; // latch onto the first error, but unpack everything...
   }
+  return sc;
 }
 
 StatusCode FlavourTagPacker::check( const Data* dataA, const Data* dataB ) const {
@@ -198,9 +205,9 @@ StatusCode FlavourTagPacker::check( const Data* dataA, const Data* dataB ) const
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const FlavourTagPacker::PackedDataVector& in,
-               FlavourTagPacker::DataVector& out ) {
-    FlavourTagPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const FlavourTagPacker::PackedDataVector& in,
+                     FlavourTagPacker::DataVector& out ) {
+    return FlavourTagPacker{parent}.unpack( in, out );
   }
 
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedMCCaloHit.cpp b/Event/EventPacker/src/lib/PackedMCCaloHit.cpp
index 54806994cdc30e5301057185a27d3f81be3e9857..d3ad4bb2d837d4dc52b99cb07444b64553eda87b 100644
--- a/Event/EventPacker/src/lib/PackedMCCaloHit.cpp
+++ b/Event/EventPacker/src/lib/PackedMCCaloHit.cpp
@@ -31,9 +31,9 @@ void MCCaloHitPacker::pack( const DataVector& hits, PackedDataVector& phits ) co
   }
 }
 
-void MCCaloHitPacker::unpack( const PackedDataVector& phits, DataVector& hits ) const {
+StatusCode MCCaloHitPacker::unpack( const PackedDataVector& phits, DataVector& hits ) const {
   const auto ver = phits.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE;
   hits.reserve( phits.data().size() );
   for ( const auto& phit : phits.data() ) {
     // make and save new hit in container
@@ -53,6 +53,7 @@ void MCCaloHitPacker::unpack( const PackedDataVector& phits, DataVector& hits )
       }
     }
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode MCCaloHitPacker::check( const DataVector& dataA, const DataVector& dataB ) const {
diff --git a/Event/EventPacker/src/lib/PackedMCHit.cpp b/Event/EventPacker/src/lib/PackedMCHit.cpp
index e829a7bad882fe9e14fe68acacdfe6946af18285..357d93da106e1f15a0e70854051d692e618c1a99 100644
--- a/Event/EventPacker/src/lib/PackedMCHit.cpp
+++ b/Event/EventPacker/src/lib/PackedMCHit.cpp
@@ -39,9 +39,9 @@ void MCHitPacker::pack( const DataVector& hits, PackedDataVector& phits ) const
   }
 }
 
-void MCHitPacker::unpack( const PackedDataVector& phits, DataVector& hits ) const {
+StatusCode MCHitPacker::unpack( const PackedDataVector& phits, DataVector& hits ) const {
   const auto ver = phits.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE; // TODO: define dedicated error code
   hits.reserve( phits.data().size() );
   for ( const auto& phit : phits.data() ) {
     // make and save new hit in container
@@ -67,6 +67,7 @@ void MCHitPacker::unpack( const PackedDataVector& phits, DataVector& hits ) cons
       }
     }
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode MCHitPacker::check( const DataVector& dataA, const DataVector& dataB ) const {
diff --git a/Event/EventPacker/src/lib/PackedMCRichDigitSummary.cpp b/Event/EventPacker/src/lib/PackedMCRichDigitSummary.cpp
index e7d1476e7ec2840ab16f9b8694caa716e3702024..e25d28b9124491095bdc3cd466e5afebe91bc0b8 100644
--- a/Event/EventPacker/src/lib/PackedMCRichDigitSummary.cpp
+++ b/Event/EventPacker/src/lib/PackedMCRichDigitSummary.cpp
@@ -31,9 +31,9 @@ void MCRichDigitSummaryPacker::pack( const DataVector& sums, PackedDataVector& p
   }
 }
 
-void MCRichDigitSummaryPacker::unpack( const PackedDataVector& psums, DataVector& sums ) const {
+StatusCode MCRichDigitSummaryPacker::unpack( const PackedDataVector& psums, DataVector& sums ) const {
   const auto ver = psums.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE; // TODO: define dedicated error code
   sums.reserve( psums.data().size() );
   for ( const auto& psum : psums.data() ) {
     // make and save new sum in container
@@ -52,6 +52,7 @@ void MCRichDigitSummaryPacker::unpack( const PackedDataVector& psums, DataVector
       }
     }
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode MCRichDigitSummaryPacker::check( const DataVector& dataA, const DataVector& dataB ) const {
diff --git a/Event/EventPacker/src/lib/PackedMCRichHit.cpp b/Event/EventPacker/src/lib/PackedMCRichHit.cpp
index 5887b64e31f076d250b0758c464f18d7791a27f9..ec4ffb1c76d6130a9a0836f7443f043557b4c8c7 100644
--- a/Event/EventPacker/src/lib/PackedMCRichHit.cpp
+++ b/Event/EventPacker/src/lib/PackedMCRichHit.cpp
@@ -34,9 +34,9 @@ void MCRichHitPacker::pack( const DataVector& hits, PackedDataVector& phits ) co
   }
 }
 
-void MCRichHitPacker::unpack( const PackedDataVector& phits, DataVector& hits ) const {
+StatusCode MCRichHitPacker::unpack( const PackedDataVector& phits, DataVector& hits ) const {
   const auto ver = phits.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE; // TODO: define dedicate error code
   hits.reserve( phits.data().size() );
   for ( const auto& phit : phits.data() ) {
     // make and save new hit in container
@@ -59,6 +59,7 @@ void MCRichHitPacker::unpack( const PackedDataVector& phits, DataVector& hits )
       }
     }
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode MCRichHitPacker::check( const DataVector& dataA, const DataVector& dataB ) const {
diff --git a/Event/EventPacker/src/lib/PackedMCRichOpticalPhoton.cpp b/Event/EventPacker/src/lib/PackedMCRichOpticalPhoton.cpp
index 4d7d6e59964ea1e8a1f3eaa8155910300edf4da9..3c03b6754b0f282c35a9c56df86f455a6333a5b4 100644
--- a/Event/EventPacker/src/lib/PackedMCRichOpticalPhoton.cpp
+++ b/Event/EventPacker/src/lib/PackedMCRichOpticalPhoton.cpp
@@ -65,10 +65,10 @@ void MCRichOpticalPhotonPacker::pack( const DataVector& phots, PackedDataVector&
   }
 }
 
-void MCRichOpticalPhotonPacker::unpack( const PackedDataVector& pphots, DataVector& phots ) const {
+StatusCode MCRichOpticalPhotonPacker::unpack( const PackedDataVector& pphots, DataVector& phots ) const {
 
   const auto ver = pphots.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE; // TODO: define dedicated error category
   phots.reserve( pphots.data().size() );
   for ( const auto& pphot : pphots.data() ) {
     auto* phot = new Data();
@@ -117,6 +117,7 @@ void MCRichOpticalPhotonPacker::unpack( const PackedDataVector& pphots, DataVect
       }
     }
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode MCRichOpticalPhotonPacker::check( const DataVector& dataA, const DataVector& dataB ) const {
diff --git a/Event/EventPacker/src/lib/PackedMCRichSegment.cpp b/Event/EventPacker/src/lib/PackedMCRichSegment.cpp
index 321047d6fa7b19ea01c6f96f64a393b5eb1e1060..0e5d761a7551495e813ce93aa2890c83700338b6 100644
--- a/Event/EventPacker/src/lib/PackedMCRichSegment.cpp
+++ b/Event/EventPacker/src/lib/PackedMCRichSegment.cpp
@@ -67,9 +67,9 @@ void MCRichSegmentPacker::pack( const DataVector& segs, PackedDataVector& psegs
   }
 }
 
-void MCRichSegmentPacker::unpack( const PackedDataVector& psegs, DataVector& segs ) const {
+StatusCode MCRichSegmentPacker::unpack( const PackedDataVector& psegs, DataVector& segs ) const {
   const auto ver = psegs.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE;
   segs.reserve( psegs.data().size() );
   for ( const auto& pseg : psegs.data() ) {
     auto* seg = new Data();
@@ -127,6 +127,7 @@ void MCRichSegmentPacker::unpack( const PackedDataVector& psegs, DataVector& seg
       }
     }
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode MCRichSegmentPacker::check( const DataVector& dataA, const DataVector& dataB ) const {
diff --git a/Event/EventPacker/src/lib/PackedMCRichTrack.cpp b/Event/EventPacker/src/lib/PackedMCRichTrack.cpp
index 2b6360ef9b1325bf1465a75ffda78296d0d4e34f..557c6184e2d7e90cb4f081091c7ee3df3a127a64 100644
--- a/Event/EventPacker/src/lib/PackedMCRichTrack.cpp
+++ b/Event/EventPacker/src/lib/PackedMCRichTrack.cpp
@@ -35,9 +35,9 @@ void MCRichTrackPacker::pack( const DataVector& tracks, PackedDataVector& ptrack
   }
 }
 
-void MCRichTrackPacker::unpack( const PackedDataVector& ptracks, DataVector& tracks ) const {
+StatusCode MCRichTrackPacker::unpack( const PackedDataVector& ptracks, DataVector& tracks ) const {
   const auto ver = ptracks.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE;
   tracks.reserve( ptracks.data().size() );
   for ( const auto& ptrack : ptracks.data() ) {
     // make and save new hit in container
@@ -64,6 +64,7 @@ void MCRichTrackPacker::unpack( const PackedDataVector& ptracks, DataVector& tra
       }
     }
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode MCRichTrackPacker::check( const DataVector& dataA, const DataVector& dataB ) const {
diff --git a/Event/EventPacker/src/lib/PackedMuonPID.cpp b/Event/EventPacker/src/lib/PackedMuonPID.cpp
index bb71dad95c9ba428e6a02475caf742ad3d877719..fa7f577f8f4b8ead3ecc2eb0aff4a291823e2805 100644
--- a/Event/EventPacker/src/lib/PackedMuonPID.cpp
+++ b/Event/EventPacker/src/lib/PackedMuonPID.cpp
@@ -42,9 +42,10 @@ void MuonPIDPacker::pack( const Data& pid, PackedData& ppid, PackedDataVector& p
   }
 }
 
-void MuonPIDPacker::unpack( const PackedData& ppid, Data& pid, const PackedDataVector& ppids, DataVector& pids ) const {
+StatusCode MuonPIDPacker::unpack( const PackedData& ppid, Data& pid, const PackedDataVector& ppids,
+                                  DataVector& pids ) const {
   const auto ver = ppids.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE;
   pid.setMuonLLMu( StandardPacker::deltaLL( ppid.MuonLLMu ) );
   pid.setMuonLLBg( StandardPacker::deltaLL( ppid.MuonLLBg ) );
   if ( ver > 2 ) {
@@ -78,12 +79,14 @@ void MuonPIDPacker::unpack( const PackedData& ppid, Data& pid, const PackedDataV
       parent().error() << "Corrupt MuonPID MuTrack SmartRef detected." << endmsg;
     }
   }
+  return StatusCode::SUCCESS;
 }
 
-void MuonPIDPacker::unpack( const PackedDataVector& ppids, DataVector& pids ) const {
+StatusCode MuonPIDPacker::unpack( const PackedDataVector& ppids, DataVector& pids ) const {
   const auto ver = ppids.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE;
   pids.reserve( ppids.data().size() );
+  StatusCode sc = StatusCode::SUCCESS;
   for ( const auto& ppid : ppids.data() ) {
     // make and save new pid in container
     auto* pid = new Data();
@@ -93,8 +96,10 @@ void MuonPIDPacker::unpack( const PackedDataVector& ppids, DataVector& pids ) co
       pids.insert( pid, ppid.key );
     }
     // Fill data from packed object
-    unpack( ppid, *pid, ppids, pids );
+    auto sc2 = unpack( ppid, *pid, ppids, pids );
+    if ( sc.isSuccess() ) sc = sc2;
   }
+  return sc;
 }
 
 StatusCode MuonPIDPacker::check( const Data* dataA, const Data* dataB ) const {
@@ -135,8 +140,8 @@ StatusCode MuonPIDPacker::check( const Data* dataA, const Data* dataB ) const {
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const MuonPIDPacker::PackedDataVector& in,
-               MuonPIDPacker::DataVector& out ) {
-    MuonPIDPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const MuonPIDPacker::PackedDataVector& in,
+                     MuonPIDPacker::DataVector& out ) {
+    return MuonPIDPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedPartToRelatedInfoRelation.cpp b/Event/EventPacker/src/lib/PackedPartToRelatedInfoRelation.cpp
index 713c852d5a17757e1585bbdfc198dc1a09bdcfa6..bb48f624096782e8eca03a9c65d49da84ef59277 100644
--- a/Event/EventPacker/src/lib/PackedPartToRelatedInfoRelation.cpp
+++ b/Event/EventPacker/src/lib/PackedPartToRelatedInfoRelation.cpp
@@ -44,14 +44,18 @@ void RelatedInfoRelationsPacker::pack( const DataVector& rels, PackedDataVector&
   }
 }
 
-void RelatedInfoRelationsPacker::unpack( const PackedDataVector& prels, DataVector& rels,
-                                         const std::string& location ) const {
+StatusCode RelatedInfoRelationsPacker::unpack( const PackedDataVector& prels, DataVector& rels,
+                                               const std::string& location ) const {
   const auto ver = prels.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE; // TODO: define dedicated error category
 
   // If location is empty, unpacked everything
+  StatusCode sc = StatusCode::SUCCESS;
   if ( location.empty() ) {
-    for ( const auto& rel : prels.relations() ) { unpack( rel, prels, rels ); }
+    for ( const auto& rel : prels.relations() ) {
+      auto sc2 = unpack( rel, prels, rels );
+      if ( sc.isSuccess() ) sc = sc2;
+    }
   } else {
     // loop over containers
     for ( const auto& cont : prels.containers() ) {
@@ -61,47 +65,56 @@ void RelatedInfoRelationsPacker::unpack( const PackedDataVector& prels, DataVect
       // if name matches, unpack
       if ( containerName == location ) {
         // Loop over the relations saved at this container location and unpack
-        for ( auto kk : Packer::subrange( prels.relations(), cont.first, cont.last ) ) { unpack( kk, prels, rels ); }
+        for ( auto kk : Packer::subrange( prels.relations(), cont.first, cont.last ) ) {
+          auto sc2 = unpack( kk, prels, rels );
+          if ( sc.isSuccess() ) sc = sc2;
+        }
       }
     }
   }
+  return sc;
 }
 
-void RelatedInfoRelationsPacker::unpack( const LHCb::PackedRelatedInfoMap& pmap, const PackedDataVector& prels,
-                                         DataVector& rels ) const {
+StatusCode RelatedInfoRelationsPacker::unpack( const LHCb::PackedRelatedInfoMap& pmap, const PackedDataVector& prels,
+                                               DataVector& rels ) const {
   const auto ver = prels.packingVersion();
-  if ( isSupportedVer( ver ) ) {
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE;
+
+  // reconstruct the particle SmartRef and its container
+  int srcLink( 0 ), srcKey( 0 );
+  StandardPacker::indexAndKey64( pmap.reference, srcLink, srcKey );
+
+  // Load the particles container
+  auto*                  linkMgr      = prels.linkMgr();
+  const auto*            link         = ( linkMgr ? linkMgr->link( srcLink ) : nullptr );
+  const auto&            srcName      = ( link ? link->path() : "" );
+  LHCb::Particles const* srcContainer = nullptr;
+  if ( !srcName.empty() ) {
+    DataObject* fp = nullptr;
+    parent().evtSvc()->retrieveObject( srcName, fp ).ignore();
+    srcContainer = dynamic_cast<LHCb::Particles*>( fp );
+  }
+  if ( !srcContainer ) {
+    parent().error() << "Failed to load container '" + srcName + "'" << endmsg;
+    return StatusCode::FAILURE;
+  }
 
-    // reconstruct the particle SmartRef and its container
-    int srcLink( 0 ), srcKey( 0 );
-    StandardPacker::indexAndKey64( pmap.reference, srcLink, srcKey );
-
-    // Load the particles container
-    auto*                  linkMgr      = prels.linkMgr();
-    const auto*            link         = ( linkMgr ? linkMgr->link( srcLink ) : nullptr );
-    const auto&            srcName      = ( link ? link->path() : "" );
-    LHCb::Particles const* srcContainer = nullptr;
-    if ( !srcName.empty() ) {
-      DataObject* fp = nullptr;
-      parent().evtSvc()->retrieveObject( srcName, fp ).ignore();
-      srcContainer = static_cast<LHCb::Particles*>( fp );
-    }
-    if ( !srcContainer ) {
-      parent().error() << "Failed to load container '" + srcName + "'" << endmsg;
-    } else {
-      // Get the source object
-      auto* from = srcContainer->object( srcKey );
-      if ( from ) {
-        // Recreate the RelatedInfoMap
-        TO to;
-        to.reserve( pmap.last - pmap.first );
-        for ( const auto& jj : Packer::subrange( prels.info(), pmap.first, pmap.last ) ) { to.insert( jj ); }
-        // Save the relation
-        auto sc = rels.relate( from, to );
-        if ( !sc ) { parent().error() << "Problem forming relation" << endmsg; }
-      }
+  // Get the source object
+  auto* from = srcContainer->object( srcKey );
+  if ( from ) {
+    // Recreate the RelatedInfoMap
+    TO to;
+    to.reserve( pmap.last - pmap.first );
+    for ( const auto& jj : Packer::subrange( prels.info(), pmap.first, pmap.last ) ) { to.insert( jj ); }
+    // Save the relation
+    auto sc = rels.relate( from, to );
+    if ( !sc ) {
+      parent().error() << "Problem forming relation" << endmsg;
+      return sc;
     }
   }
+
+  return StatusCode::SUCCESS; // TODO: latch on to any failure
 }
 
 StatusCode RelatedInfoRelationsPacker::check( const DataVector& dataA, const DataVector& dataB ) const {
@@ -146,8 +159,8 @@ StatusCode RelatedInfoRelationsPacker::check( const DataVector& dataA, const Dat
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const PackedRelatedInfoRelations& in,
-               Relation1D<Particle, RelatedInfoMap>& out ) {
-    RelatedInfoRelationsPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const PackedRelatedInfoRelations& in,
+                     Relation1D<Particle, RelatedInfoMap>& out ) {
+    return RelatedInfoRelationsPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedParticle.cpp b/Event/EventPacker/src/lib/PackedParticle.cpp
index 0b3a974e3a2a2c25ee87658c27f01707fc24f316..8bb38906c9d6ec34e7a04d921091143b2ad46d33 100644
--- a/Event/EventPacker/src/lib/PackedParticle.cpp
+++ b/Event/EventPacker/src/lib/PackedParticle.cpp
@@ -129,8 +129,8 @@ void ParticlePacker::pack( const Data& part, PackedData& ppart, PackedDataVector
   ppart.lastDaughter = pparts.daughters().size();
 }
 
-void ParticlePacker::unpack( const PackedData& ppart, Data& part, const PackedDataVector& pparts, DataVector& parts,
-                             LHCb::Packer::Carry& with_carry ) const {
+StatusCode ParticlePacker::unpack( const PackedData& ppart, Data& part, const PackedDataVector& pparts,
+                                   DataVector& parts, LHCb::Packer::Carry& with_carry ) const {
   if ( 0 != pparts.packingVersion() && 1 != pparts.packingVersion() ) {
     throw GaudiException( fmt::format( "Unknown packed data version {}", (int)pparts.packingVersion() ),
                           "ParticlePacker", StatusCode::FAILURE );
@@ -241,12 +241,14 @@ void ParticlePacker::unpack( const PackedData& ppart, Data& part, const PackedDa
       parent().error() << "Corrupt Particle Daughter Particle SmartRef found" << endmsg;
     }
   }
+  return StatusCode::SUCCESS;
 }
 
-void ParticlePacker::unpack( const PackedDataVector& pparts, DataVector& parts ) const {
+StatusCode ParticlePacker::unpack( const PackedDataVector& pparts, DataVector& parts ) const {
   parts.reserve( pparts.data().size() );
   parts.setVersion( pparts.version() );
   LHCb::Packer::Carry carry{};
+  StatusCode          sc = StatusCode::SUCCESS;
   for ( const auto& ppart : pparts.data() ) {
     // make and save new pid in container
     auto* part = new Data();
@@ -254,9 +256,11 @@ void ParticlePacker::unpack( const PackedDataVector& pparts, DataVector& parts )
     StandardPacker::indexAndKey64( ppart.key, linkID, key );
     parts.insert( part, ppart.key );
     // Fill data from packed object
-    unpack( ppart, *part, pparts, parts, carry );
+    auto sc2 = unpack( ppart, *part, pparts, parts, carry );
+    if ( sc.isSuccess() ) sc = sc2;
     parent().debug() << " number of daughters " << part->daughters().size() << endmsg;
   }
+  return sc;
 }
 
 ParticlePacker::DataVector ParticlePacker::unpack( const PackedDataVector& pparts ) const {
@@ -274,7 +278,7 @@ ParticlePacker::DataVector ParticlePacker::unpack( const PackedDataVector& ppart
     StandardPacker::indexAndKey64( ppart.key, linkID, key );
     parts.insert( part, key );
     // Fill data from packed object
-    unpack( ppart, *part, pparts, parts, carry );
+    unpack( ppart, *part, pparts, parts, carry ).ignore();
   }
   return parts;
 }
@@ -374,7 +378,7 @@ StatusCode ParticlePacker::check( const Data* dataA, const Data* dataB ) const {
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const PackedParticles& in, Particles& out ) {
-    ParticlePacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const PackedParticles& in, Particles& out ) {
+    return ParticlePacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedProtoParticle.cpp b/Event/EventPacker/src/lib/PackedProtoParticle.cpp
index c3865fb098937c7bcb05a5d5bd8ec74cac4c7ea0..8e1bf5f677848287beda922c05c21183e528c791 100644
--- a/Event/EventPacker/src/lib/PackedProtoParticle.cpp
+++ b/Event/EventPacker/src/lib/PackedProtoParticle.cpp
@@ -93,12 +93,12 @@ void ProtoParticlePacker::pack( const Data& proto, PackedData& pproto, PackedDat
   pproto.lastExtra = pprotos.extras().size();
 }
 
-void ProtoParticlePacker::unpack( const PackedData& pproto, Data& proto, const PackedDataVector& pprotos,
-                                  DataVector& protos, LHCb::Packer::Carry& with_carry ) const {
+StatusCode ProtoParticlePacker::unpack( const PackedData& pproto, Data& proto, const PackedDataVector& pprotos,
+                                        DataVector& protos, LHCb::Packer::Carry& with_carry ) const {
   // packing version
   const auto ver = pprotos.packingVersion();
 
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE;
 
   int hintID( 0 ), key( 0 );
 
@@ -158,25 +158,29 @@ void ProtoParticlePacker::unpack( const PackedData& pproto, Data& proto, const P
                      proto.richPID()->particleDeltaLL( Rich::Muon ) );
     }
   }
+  return StatusCode::SUCCESS;
 }
 
-void ProtoParticlePacker::unpack( const PackedDataVector& pprotos, DataVector& protos ) const {
+StatusCode ProtoParticlePacker::unpack( const PackedDataVector& pprotos, DataVector& protos ) const {
   protos.reserve( pprotos.data().size() );
   parent().debug() << "version " << (int)pprotos.version() << endmsg;
   parent().debug() << "packing version " << (int)pprotos.packingVersion() << endmsg;
 
+  StatusCode          sc = StatusCode::SUCCESS;
   LHCb::Packer::Carry carry{};
   for ( const auto& pproto : pprotos.data() ) {
     auto* part = new LHCb::ProtoParticle();
     protos.insert( part, pproto.key );
 
-    unpack( pproto, *part, pprotos, protos, carry );
+    auto sc2 = unpack( pproto, *part, pprotos, protos, carry );
+    if ( sc.isSuccess() ) sc = sc2;
   }
   if ( carry ) {
     parent().warning() << "overflow detected while unpacking protoparticle extrainfo -- I _hope_ the correction for "
                           "this worked properly... good luck!!!"
                        << endmsg;
   }
+  return sc;
 }
 
 StatusCode ProtoParticlePacker::check( const Data* dataA, const Data* dataB ) const {
@@ -243,8 +247,8 @@ StatusCode ProtoParticlePacker::check( const Data* dataA, const Data* dataB ) co
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const ProtoParticlePacker::PackedDataVector& in,
-               ProtoParticlePacker::DataVector& out ) {
-    ProtoParticlePacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const ProtoParticlePacker::PackedDataVector& in,
+                     ProtoParticlePacker::DataVector& out ) {
+    return ProtoParticlePacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedRecSummary.cpp b/Event/EventPacker/src/lib/PackedRecSummary.cpp
index a52b3b5b93bb7677551c29cd1e53a2e96ac84300..c5973ce047ccda2178c86d50f9ab71d874a1c6a1 100644
--- a/Event/EventPacker/src/lib/PackedRecSummary.cpp
+++ b/Event/EventPacker/src/lib/PackedRecSummary.cpp
@@ -25,11 +25,12 @@ void RecSummaryPacker::pack( const DataVector& sums, PackedDataVector& psums ) c
   }
 }
 
-void RecSummaryPacker::unpack( const PackedDataVector& psums, DataVector& sums ) const {
+StatusCode RecSummaryPacker::unpack( const PackedDataVector& psums, DataVector& sums ) const {
   sums.reserve( psums.data().size() / 2 );
   for ( unsigned int i = 0; i < psums.data().size() / 2; i++ ) {
     sums.addInfo( psums.data()[2 * i], psums.data()[2 * i + 1] );
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode RecSummaryPacker::check( const DataVector& dataA, const DataVector& dataB ) const {
@@ -37,8 +38,8 @@ StatusCode RecSummaryPacker::check( const DataVector& dataA, const DataVector& d
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const RecSummaryPacker::PackedDataVector& in,
-               RecSummaryPacker::DataVector& out ) {
-    RecSummaryPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const RecSummaryPacker::PackedDataVector& in,
+                     RecSummaryPacker::DataVector& out ) {
+    return RecSummaryPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedRecVertex.cpp b/Event/EventPacker/src/lib/PackedRecVertex.cpp
index d733066cc15624374acfe5db427026f00d11c7ff..db94e6133639f6d7645d46ab82ef0cdc11608466 100644
--- a/Event/EventPacker/src/lib/PackedRecVertex.cpp
+++ b/Event/EventPacker/src/lib/PackedRecVertex.cpp
@@ -82,10 +82,10 @@ void RecVertexPacker::pack( const Data& vert, PackedData& pvert, PackedDataVecto
   pvert.lastInfo = pverts.extras().size();
 }
 
-void RecVertexPacker::unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts,
-                              DataVector& verts ) const {
+StatusCode RecVertexPacker::unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts,
+                                    DataVector& verts ) const {
   const auto ver = pverts.version();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::SUCCESS; // TODO: defined dedicated error code
 
   vert.setTechnique( static_cast<LHCb::RecVertex::RecVertexType>( pvert.technique ) );
   vert.setChi2AndDoF( StandardPacker::fltPacked( pvert.chi2 ), pvert.nDoF );
@@ -125,19 +125,24 @@ void RecVertexPacker::unpack( const PackedData& pvert, Data& vert, const PackedD
   for ( const auto& [k, v] : LHCb::Packer::subrange( pverts.extras(), pvert.firstInfo, pvert.lastInfo ) ) {
     vert.addInfo( k, StandardPacker::fltPacked( v ) );
   }
+
+  return StatusCode::SUCCESS;
 }
 
-void RecVertexPacker::unpack( const PackedDataVector& pverts, DataVector& verts ) const {
+StatusCode RecVertexPacker::unpack( const PackedDataVector& pverts, DataVector& verts ) const {
   verts.reserve( pverts.data().size() );
 
+  StatusCode sc = StatusCode::SUCCESS;
   for ( const auto& pvert : pverts.data() ) {
     // make and save new pid in container
     auto* vert = new Data();
     verts.insert( vert, pvert.key );
 
     // Fill data from packed object
-    unpack( pvert, *vert, pverts, verts );
+    auto sc2 = unpack( pvert, *vert, pverts, verts );
+    if ( sc.isSuccess() ) sc = sc2;
   }
+  return sc;
 }
 
 StatusCode RecVertexPacker::check( const Data* dataA, const Data* dataB ) const {
@@ -179,7 +184,7 @@ StatusCode RecVertexPacker::check( const Data* dataA, const Data* dataB ) const
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const PackedRecVertices& in, RecVertices& out ) {
-    RecVertexPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const PackedRecVertices& in, RecVertices& out ) {
+    return RecVertexPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedRichPID.cpp b/Event/EventPacker/src/lib/PackedRichPID.cpp
index 397474c39a695450c553c92cb80ccc432692a61e..b2a2b861ddea061bef402a8bde83c2b3823bc496 100644
--- a/Event/EventPacker/src/lib/PackedRichPID.cpp
+++ b/Event/EventPacker/src/lib/PackedRichPID.cpp
@@ -33,9 +33,10 @@ void RichPIDPacker::pack( const Data& pid, PackedData& ppid, PackedDataVector& p
   }
 }
 
-void RichPIDPacker::unpack( const PackedData& ppid, Data& pid, const PackedDataVector& ppids, DataVector& pids ) const {
+StatusCode RichPIDPacker::unpack( const PackedData& ppid, Data& pid, const PackedDataVector& ppids,
+                                  DataVector& pids ) const {
   const auto ver = ppids.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE; // TODO: define dedicated error code
   pid.setPidResultCode( ppid.pidResultCode );
   pid.setParticleDeltaLL( Rich::Electron, (float)StandardPacker::deltaLL( ppid.dllEl ) );
   pid.setParticleDeltaLL( Rich::Muon, (float)StandardPacker::deltaLL( ppid.dllMu ) );
@@ -63,12 +64,14 @@ void RichPIDPacker::unpack( const PackedData& ppid, Data& pid, const PackedDataV
   // the fact the numerical value of the Below Threshold enum changed when Deuteron
   // was added.
   if ( ver < 4 && Rich::Deuteron == pid.bestParticleID() ) { pid.setBestParticleID( Rich::BelowThreshold ); }
+  return StatusCode::SUCCESS;
 }
 
-void RichPIDPacker::unpack( const PackedDataVector& ppids, DataVector& pids ) const {
+StatusCode RichPIDPacker::unpack( const PackedDataVector& ppids, DataVector& pids ) const {
   const auto ver = ppids.packingVersion();
-  if ( !isSupportedVer( ver ) ) return;
+  if ( !isSupportedVer( ver ) ) return StatusCode::FAILURE; // TODO: define dedicated status code
   pids.reserve( ppids.data().size() );
+  StatusCode sc = StatusCode::SUCCESS;
   for ( const auto& ppid : ppids.data() ) {
     // make and save new pid in container
     auto* pid = new Data();
@@ -79,7 +82,8 @@ void RichPIDPacker::unpack( const PackedDataVector& ppids, DataVector& pids ) co
       pids.add( pid );
     }
     // Fill data from packed object
-    unpack( ppid, *pid, ppids, pids );
+    auto sc2 = unpack( ppid, *pid, ppids, pids );
+    if ( sc.isSuccess() ) sc = sc2;
   }
   // Check for 'RichFuture' bug where original RichPID version was not
   // properly propagated to the packed data objects
@@ -94,6 +98,7 @@ void RichPIDPacker::unpack( const PackedDataVector& ppids, DataVector& pids ) co
     // reset to V2
     pids.setVersion( 2 );
   }
+  return sc;
 }
 
 StatusCode RichPIDPacker::check( const Data* dataA, const Data* dataB ) const {
@@ -133,8 +138,8 @@ StatusCode RichPIDPacker::check( const Data* dataA, const Data* dataB ) const {
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const RichPIDPacker::PackedDataVector& in,
-               RichPIDPacker::DataVector& out ) {
-    RichPIDPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const RichPIDPacker::PackedDataVector& in,
+                     RichPIDPacker::DataVector& out ) {
+    return RichPIDPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedTrack.cpp b/Event/EventPacker/src/lib/PackedTrack.cpp
index 232a20dde754e6807f8bc98ff39f2df869ff932f..add2a058e8ab618262090f3af215be9bc431dcdd 100644
--- a/Event/EventPacker/src/lib/PackedTrack.cpp
+++ b/Event/EventPacker/src/lib/PackedTrack.cpp
@@ -135,15 +135,15 @@ void TrackPacker::convertState( const LHCb::State& state, PackedDataVector& ptra
   newState.cov_43 = StandardPacker::fraction( state.covariance()( 4, 3 ), err[4] * err[3] );
 }
 
-void TrackPacker::unpack( const PackedData& ptrack, Data& track, const PackedDataVector& ptracks,
-                          DataVector& /* tracks */ ) const {
+StatusCode TrackPacker::unpack( const PackedData& ptrack, Data& track, const PackedDataVector& ptracks,
+                                DataVector& /* tracks */ ) const {
 
   // check packing version
   const auto pver = getUnPackingVersion( ptracks );
-  if ( !isSupportedVer( pver ) ) { return; }
+  if ( !isSupportedVer( pver ) ) return StatusCode::FAILURE; // TODO: define dedicated error code
 
   if ( parent().msgLevel( MSG::DEBUG ) ) {
-    parent().debug() << "unpack : PackingVer=" << (int)pver << " DataVer=" << (int)ptracks.version() << endmsg;
+    // parent().debug() << "unpack : PackingVer=" << (int)pver << " DataVer=" << (int)ptracks.version() << endmsg;
   }
 
   // Try and detect changes that require the cached wrap IDs to be reset.
@@ -195,22 +195,29 @@ void TrackPacker::unpack( const PackedData& ptrack, Data& track, const PackedDat
                       // Fixup channelIDtype for old (<6) data
                       // Adapts to https://gitlab.cern.ch/lhcb/LHCb/-/merge_requests/3226
                       enum class OLD_channelIDtype { Velo = 1, TT, IT, OT, Rich, Calo, Muon, VP, FT = 10, UT, HC };
-                      const auto dtype = (int)id.detectorType();
-                      if ( (int)OLD_channelIDtype::VP == dtype ) {
+                      switch ( (int)id.detectorType() ) {
+                      case (int)OLD_channelIDtype::VP:
                         id.setDetectorType( LHCb::LHCbID::channelIDtype::VP );
-                      } else if ( (int)OLD_channelIDtype::UT == dtype ) {
+                        break;
+                      case (int)OLD_channelIDtype::UT:
                         id.setDetectorType( LHCb::LHCbID::channelIDtype::UT );
-                      } else if ( (int)OLD_channelIDtype::FT == dtype ) {
+                        break;
+                      case (int)OLD_channelIDtype::FT:
                         id.setDetectorType( LHCb::LHCbID::channelIDtype::FT );
-                      } else if ( (int)OLD_channelIDtype::Rich == dtype ) {
+                        break;
+                      case (int)OLD_channelIDtype::Rich:
                         id.setDetectorType( LHCb::LHCbID::channelIDtype::Rich );
-                      } else if ( (int)OLD_channelIDtype::Calo == dtype ) {
+                        break;
+                      case (int)OLD_channelIDtype::Calo:
                         id.setDetectorType( LHCb::LHCbID::channelIDtype::Calo );
-                      } else if ( (int)OLD_channelIDtype::Muon == dtype ) {
+                        break;
+                      case (int)OLD_channelIDtype::Muon:
                         id.setDetectorType( LHCb::LHCbID::channelIDtype::Muon );
-                      } else {
+                        break;
+                      default:
                         // For sub-systems no longer defined ..
                         id.setDetectorType( LHCb::LHCbID::channelIDtype::UNDEFINED );
+                        break;
                       }
                     }
                     return id;
@@ -289,13 +296,14 @@ void TrackPacker::unpack( const PackedData& ptrack, Data& track, const PackedDat
     track.eraseInfo( LHCb::Track::AdditionalInfo::nPRVeloRZExpect );
     track.eraseInfo( LHCb::Track::AdditionalInfo::nPRVelo3DExpect );
   }
+  return StatusCode::SUCCESS;
 }
 
-void TrackPacker::unpack( const PackedDataVector& ptracks, DataVector& tracks ) const {
+StatusCode TrackPacker::unpack( const PackedDataVector& ptracks, DataVector& tracks ) const {
 
   // Check version
   const auto pver = getUnPackingVersion( ptracks );
-  if ( !isSupportedVer( pver ) ) { return; }
+  if ( !isSupportedVer( pver ) ) return StatusCode::FAILURE;
 
   // reserve the required size
   tracks.reserve( ptracks.data().size() );
@@ -304,12 +312,15 @@ void TrackPacker::unpack( const PackedDataVector& ptracks, DataVector& tracks )
   resetWrappingCounts();
 
   // unpack
+  StatusCode sc = StatusCode::SUCCESS;
   for ( const auto& ptrack : ptracks.data() ) {
     auto* track = new LHCb::Track();
     // parent().debug() << "Unpacked Track key=" << ptrack.key << endmsg;
     tracks.insert( track, ptrack.key );
-    unpack( ptrack, *track, ptracks, tracks );
+    auto sc2 = unpack( ptrack, *track, ptracks, tracks );
+    if ( sc.isSuccess() ) sc = sc2;
   }
+  return sc;
 }
 
 void TrackPacker::convertState( const LHCb::PackedState& pSta, LHCb::Track& tra ) const {
@@ -518,7 +529,8 @@ void TrackPacker::compareStates( const LHCb::State& oSta, const LHCb::State& tSt
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const TrackPacker::PackedDataVector& in, TrackPacker::DataVector& out ) {
-    TrackPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const TrackPacker::PackedDataVector& in,
+                     TrackPacker::DataVector& out ) {
+    return TrackPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedTwoProngVertex.cpp b/Event/EventPacker/src/lib/PackedTwoProngVertex.cpp
index 8042edef090bc50cf15370e8cc37e3e1b637d1c8..6aa947421a7d37542065c554f58431c71770affd 100644
--- a/Event/EventPacker/src/lib/PackedTwoProngVertex.cpp
+++ b/Event/EventPacker/src/lib/PackedTwoProngVertex.cpp
@@ -127,9 +127,9 @@ void TwoProngVertexPacker::pack( const Data& vert, PackedData& pvert, PackedData
   pvert.lastInfo = pverts.extras().size();
 }
 
-void TwoProngVertexPacker::unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts,
-                                   DataVector& verts ) const {
-  if ( !isSupportedVer( pverts.packingVersion() ) ) return;
+StatusCode TwoProngVertexPacker::unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts,
+                                         DataVector& verts ) const {
+  if ( !isSupportedVer( pverts.packingVersion() ) ) return StatusCode::FAILURE; // TODO: return dedicated error code
   const auto pVer = pverts.packingVersion();
 
   vert.setTechnique( (RecVertex::RecVertexType)pvert.technique );
@@ -237,19 +237,24 @@ void TwoProngVertexPacker::unpack( const PackedData& pvert, Data& vert, const Pa
   std::vector<ParticleID> pids;
   for ( auto i : Packer::subrange( pverts.refs(), pvert.firstPid, pvert.lastPid ) ) pids.emplace_back( i );
   vert.setCompatiblePIDs( pids );
+
+  return StatusCode::SUCCESS;
 }
 
-void TwoProngVertexPacker::unpack( const PackedDataVector& pverts, DataVector& verts ) const {
+StatusCode TwoProngVertexPacker::unpack( const PackedDataVector& pverts, DataVector& verts ) const {
   verts.reserve( pverts.data().size() );
 
+  StatusCode sc = StatusCode::SUCCESS;
   for ( const auto& pvert : pverts.data() ) {
     // make and save new pid in container
     auto* vert = new Data();
     verts.insert( vert, pvert.key );
 
     // Fill data from packed object
-    unpack( pvert, *vert, pverts, verts );
+    auto sc2 = unpack( pvert, *vert, pverts, verts );
+    if ( sc.isSuccess() ) sc = sc2;
   }
+  return sc;
 }
 
 TwoProngVertexPacker::DataVector TwoProngVertexPacker::unpack( const PackedDataVector& pverts ) const {
@@ -266,7 +271,7 @@ TwoProngVertexPacker::DataVector TwoProngVertexPacker::unpack( const PackedDataV
     verts.insert( vert, key );
 
     // Fill data from packed object
-    unpack( pvert, *vert, pverts, verts );
+    unpack( pvert, *vert, pverts, verts ).ignore();
   }
   return verts;
 }
@@ -311,7 +316,7 @@ StatusCode TwoProngVertexPacker::check( const Data* dataA, const Data* dataB ) c
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const PackedTwoProngVertices& in, TwoProngVertices& out ) {
-    TwoProngVertexPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const PackedTwoProngVertices& in, TwoProngVertices& out ) {
+    return TwoProngVertexPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedVertex.cpp b/Event/EventPacker/src/lib/PackedVertex.cpp
index 04ff1a1d395cde6bd87fd4fd07b1ef723e969da6..78bc50285c2cefea7542db959b528f4ea68780b1 100644
--- a/Event/EventPacker/src/lib/PackedVertex.cpp
+++ b/Event/EventPacker/src/lib/PackedVertex.cpp
@@ -58,9 +58,9 @@ void VertexPacker::pack( const Data& vert, PackedData& pvert, PackedDataVector&
   pvert.lastInfo = pverts.extras().size();
 }
 
-void VertexPacker::unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts,
-                           DataVector& verts ) const {
-  if ( !isSupportedVer( pverts.packingVersion() ) ) return;
+StatusCode VertexPacker::unpack( const PackedData& pvert, Data& vert, const PackedDataVector& pverts,
+                                 DataVector& verts ) const {
+  if ( !isSupportedVer( pverts.packingVersion() ) ) return StatusCode::FAILURE; // TODO define dedicated error code
   // technique
   vert.setTechnique( static_cast<Vertex::CreationMethod>( pvert.technique ) );
   vert.setChi2AndDoF( StandardPacker::fltPacked( pvert.chi2 ), pvert.nDoF );
@@ -93,19 +93,23 @@ void VertexPacker::unpack( const PackedData& pvert, Data& vert, const PackedData
   for ( const auto& [k, v] : Packer::subrange( pverts.extras(), pvert.firstInfo, pvert.lastInfo ) ) {
     vert.addInfo( k, StandardPacker::fltPacked( v ) );
   }
+  return StatusCode::SUCCESS;
 }
 
-void VertexPacker::unpack( const PackedDataVector& pverts, DataVector& verts ) const {
+StatusCode VertexPacker::unpack( const PackedDataVector& pverts, DataVector& verts ) const {
   verts.reserve( pverts.data().size() );
 
+  StatusCode sc = StatusCode::SUCCESS;
   for ( const auto& pvert : pverts.data() ) {
     // make and save new pid in container
     auto* vert = new Data();
     verts.insert( vert, pvert.key );
 
     // Fill data from packed object
-    unpack( pvert, *vert, pverts, verts );
+    auto sc2 = unpack( pvert, *vert, pverts, verts );
+    if ( sc.isSuccess() ) sc = sc2;
   }
+  return sc;
 }
 
 VertexPacker::DataVector VertexPacker::unpack( const PackedDataVector& pverts ) const {
@@ -122,7 +126,7 @@ VertexPacker::DataVector VertexPacker::unpack( const PackedDataVector& pverts )
     verts.insert( vert, key );
 
     // Fill data from packed object
-    unpack( pvert, *vert, pverts, verts );
+    unpack( pvert, *vert, pverts, verts ).ignore();
   }
   return verts;
 }
@@ -167,8 +171,8 @@ StatusCode VertexPacker::check( const Data* dataA, const Data* dataB ) const {
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const VertexPacker::PackedDataVector& in,
-               VertexPacker::DataVector& out ) {
-    VertexPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const VertexPacker::PackedDataVector& in,
+                     VertexPacker::DataVector& out ) {
+    return VertexPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb
diff --git a/Event/EventPacker/src/lib/PackedWeightsVector.cpp b/Event/EventPacker/src/lib/PackedWeightsVector.cpp
index 4e75330d78ac6be45d080c86e72b05d9f118d385..13d02add32390f1c11edf7f515002d12fbdf52f6 100644
--- a/Event/EventPacker/src/lib/PackedWeightsVector.cpp
+++ b/Event/EventPacker/src/lib/PackedWeightsVector.cpp
@@ -14,9 +14,9 @@
 
 using namespace LHCb;
 
-void WeightsVectorPacker::unpack( const PackedDataVector& pweightsV, DataVector& weightsV ) const {
+StatusCode WeightsVectorPacker::unpack( const PackedDataVector& pweightsV, DataVector& weightsV ) const {
   const auto pVer = pweightsV.packingVersion();
-  if ( !isSupportedVer( pVer ) ) return;
+  if ( !isSupportedVer( pVer ) ) return StatusCode::FAILURE;
   weightsV.reserve( pweightsV.data().size() );
   for ( const PackedData& pweights : pweightsV.data() ) {
 
@@ -35,6 +35,7 @@ void WeightsVectorPacker::unpack( const PackedDataVector& pweightsV, DataVector&
       weightsV.insert( weights, pweights.pvKey );
     }
   }
+  return StatusCode::SUCCESS;
 }
 
 StatusCode WeightsVectorPacker::check( const Data* dataA, const Data* dataB ) const {
@@ -68,7 +69,7 @@ StatusCode WeightsVectorPacker::check( const Data* dataA, const Data* dataB ) co
 }
 
 namespace LHCb {
-  void unpack( Gaudi::Algorithm const* parent, const PackedWeightsVector& in, WeightsVectors& out ) {
-    WeightsVectorPacker{parent}.unpack( in, out );
+  StatusCode unpack( Gaudi::Algorithm const* parent, const PackedWeightsVector& in, WeightsVectors& out ) {
+    return WeightsVectorPacker{parent}.unpack( in, out );
   }
 } // namespace LHCb