diff --git a/src/data.cpp b/src/data.cpp
index 4486fdf..089fc1f 100644
--- a/src/data.cpp
+++ b/src/data.cpp
@@ -18,10 +18,6 @@ NoField::NoField()
 
 NoField::~NoField() {}
 
-NoConvert::NoConvert()
-    :std::runtime_error ("No conversion defined")
-{}
-
 NoConvert::~NoConvert() {}
 
 LookupError::LookupError(const std::string& msg)
@@ -457,8 +453,6 @@ void Value::copyOut(void *ptr, StoreType type) const
             src.copyOut(ptr, type);
             return;
 
-        } else {
-            throw NoConvert();
         }
 
         break;
@@ -467,7 +461,7 @@ void Value::copyOut(void *ptr, StoreType type) const
         break;
     }
 
-    throw NoConvert();
+    throw NoConvert(SB()<<"Can't extract "<<this->type()<<" as "<<type);
 }
 
 bool Value::tryCopyOut(void *ptr, StoreType type) const
@@ -513,14 +507,14 @@ void Value::copyIn(const void *ptr, StoreType type)
 
     switch(store->code) {
     case StoreType::Real: {
-        if(!copyInScalar(store->as<double>(), ptr, type)) throw NoConvert();
+        if(!copyInScalar(store->as<double>(), ptr, type)) throw NoConvert(SB()<<"Unable to assign "<<desc->code<<" with "<<type);
         // truncate as if assigned to narrower type
         if(desc->code==TypeCode::Float32)
             store->as<double>() = float(store->as<double>());
         break;
     }
     case StoreType::Integer: {
-        if(!copyInScalar(store->as<int64_t>(), ptr, type)) throw NoConvert();
+        if(!copyInScalar(store->as<int64_t>(), ptr, type)) throw NoConvert(SB()<<"Unable to assign "<<desc->code<<" with "<<type);
         // truncate as if assigned to narrower type
         int64_t orig = store->as<int64_t>();
         switch(desc->code.code) {
@@ -534,7 +528,7 @@ void Value::copyIn(const void *ptr, StoreType type)
         break;
     }
     case StoreType::UInteger: {
-        if(!copyInScalar(store->as<uint64_t>(), ptr, type)) throw NoConvert();
+        if(!copyInScalar(store->as<uint64_t>(), ptr, type)) throw NoConvert(SB()<<"Unable to assign "<<desc->code<<" with "<<type);
         // truncate as if assigned to narrower type
         int64_t orig = store->as<int64_t>();
         switch(desc->code.code) {
@@ -559,7 +553,7 @@ void Value::copyIn(const void *ptr, StoreType type)
             else if("false"==*reinterpret_cast<const std::string*>(ptr)) { dest = false; break; }
             // fall through
         default:
-            throw NoConvert();
+            throw NoConvert(SB()<<"Unable to assign "<<desc->code<<" with "<<type);
         }
         break;
     }
@@ -573,7 +567,7 @@ void Value::copyIn(const void *ptr, StoreType type)
         case StoreType::Real:     dest = SB()<<*reinterpret_cast<const double*>(ptr); break;
         case StoreType::Bool:     dest = (*reinterpret_cast<const bool*>(ptr)) ? "true" : "false"; break;
         default:
-            throw NoConvert();
+            throw NoConvert(SB()<<"Unable to assign "<<desc->code<<" with "<<type);
         }
         break;
     }
@@ -594,7 +588,7 @@ void Value::copyIn(const void *ptr, StoreType type)
                     // enforce member type for Struct[] and Union[]
                     for(auto& val : tsrc) {
                         if(val.desc && val.desc!=desc->members.data()) {
-                            throw NoConvert();
+                            throw NoConvert(SB()<<"Unable to assign "<<desc->code<<" with "<<type);
                         }
                     }
                 }
@@ -606,12 +600,12 @@ void Value::copyIn(const void *ptr, StoreType type)
 
             } else {
                 // TODO: alloc and convert
-                throw NoConvert();
+                throw NoConvert(SB()<<"Unable to assign "<<desc->code<<" with "<<type);
             }
             break;
         }
         default:
-            throw NoConvert();
+            throw NoConvert(SB()<<"Unable to assign "<<desc->code<<" with "<<type);
         }
         break;
     }
@@ -633,7 +627,7 @@ void Value::copyIn(const void *ptr, StoreType type)
                 break;
             }
         }
-        throw NoConvert();
+        throw NoConvert(SB()<<"Unable to assign "<<desc->code<<" with "<<type);
     case StoreType::Null:
         if(type==StoreType::Compound) {
             auto& src = *reinterpret_cast<const Value*>(ptr);
@@ -663,7 +657,7 @@ void Value::copyIn(const void *ptr, StoreType type)
                 return;
             }
         }
-        throw NoConvert();
+        throw NoConvert(SB()<<"Unable to assign "<<desc->code<<" with "<<type);
     }
 
     mark();
diff --git a/src/pvxs/data.h b/src/pvxs/data.h
index 647f74e..3bb711c 100644
--- a/src/pvxs/data.h
+++ b/src/pvxs/data.h
@@ -37,6 +37,9 @@ enum struct StoreType : uint8_t {
     Array,    //!< shared_array<const void>
 };
 
+PVXS_API
+std::ostream& operator<<(std::ostream& strm, StoreType c);
+
 constexpr struct unselect_t {} unselect;
 
 namespace impl {
@@ -450,7 +453,7 @@ struct PVXS_API NoField : public std::runtime_error
 //! Thrown when a Value can not be converted to the requested type
 struct PVXS_API NoConvert : public std::runtime_error
 {
-    explicit NoConvert();
+    NoConvert(const std::string& msg) : std::runtime_error(msg) {}
     virtual ~NoConvert();
 };
 
@@ -521,7 +524,7 @@ public:
     //! Use to allocate members for an array of Struct and array of Union
     Value allocMember();
 
-    //! Does this Value actual reference some underlying storage
+    //! Does this Value actually reference some underlying storage
     inline bool valid() const { return desc; }
     inline explicit operator bool() const { return desc; }
 
@@ -581,6 +584,9 @@ public:
      * - std::string
      * - Value
      * - shared_array<const void>
+     *
+     * @throws NoField !this->valid()
+     * @throws NoConvert if the field value can not be coerced to type T
      */
     template<typename T>
     inline T as() const {
diff --git a/src/type.cpp b/src/type.cpp
index ba08f00..6574d2b 100644
--- a/src/type.cpp
+++ b/src/type.cpp
@@ -12,6 +12,24 @@
 
 namespace pvxs {
 
+std::ostream& operator<<(std::ostream& strm, StoreType c)
+{
+    const char* name = "<\?\?\?>";
+    switch(c) {
+#define CASE(CODE) case StoreType::CODE: name = #CODE; break
+    CASE(Null);
+    CASE(Bool);
+    CASE(Real);
+    CASE(Integer);
+    CASE(UInteger);
+    CASE(String);
+    CASE(Compound);
+    CASE(Array);
+#undef CASE
+    }
+    return strm<<name;
+}
+
 struct Member::Helper {
     static
     void node_validate(const Member* parent, const std::string& id, TypeCode code);
diff --git a/src/util.cpp b/src/util.cpp
index 1193858..cf4de91 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -386,30 +386,51 @@ namespace pvxs {namespace impl {
 template<>
 double parseTo<double>(const std::string& s) {
     size_t idx=0, L=s.size();
-    double ret = std::stod(s, &idx);
+    double ret;
+    try {
+        ret = std::stod(s, &idx);
+    }catch(std::invalid_argument& e) {
+        throw NoConvert(SB()<<"Invalid input : \""<<escape(s)<<"\"");
+    }catch(std::out_of_range& e) {
+        throw NoConvert(SB()<<"Out of range : \""<<escape(s)<<"\"");
+    }
     for(; idx<L && isspace(s[idx]); idx++) {}
     if(idx<L)
-        throw std::invalid_argument(SB()<<"Extraneous charactors after double: \""<<escape(s)<<"\"");
+        NoConvert(SB()<<"Extraneous characters after double: \""<<escape(s)<<"\"");
     return ret;
 }
 
 template<>
 uint64_t parseTo<uint64_t>(const std::string& s) {
     size_t idx=0, L=s.size();
-    unsigned long long ret = std::stoull(s, &idx, 0);
+    unsigned long long ret;
+    try {
+        ret = std::stoull(s, &idx, 0);
+    }catch(std::invalid_argument& e) {
+        throw NoConvert(SB()<<"Invalid input : \""<<escape(s)<<"\"");
+    }catch(std::out_of_range& e) {
+        throw NoConvert(SB()<<"Out of range : \""<<escape(s)<<"\"");
+    }
     for(; idx<L && isspace(s[idx]); idx++) {}
     if(idx<L)
-        throw std::invalid_argument(SB()<<"Extraneous charactors after integer: \""<<escape(s)<<"\"");
+        throw NoConvert(SB()<<"Extraneous characters after integer: \""<<escape(s)<<"\"");
     return ret;
 }
 
 template<>
 int64_t parseTo<int64_t>(const std::string& s) {
     size_t idx=0, L=s.size();
-    long long ret = std::stoll(s, &idx, 0);
+    long long ret;
+    try {
+        ret = std::stoll(s, &idx, 0);
+    }catch(std::invalid_argument& e) {
+        throw NoConvert(SB()<<"Invalid input : \""<<escape(s)<<"\"");
+    }catch(std::out_of_range& e) {
+        throw NoConvert(SB()<<"Out of range : \""<<escape(s)<<"\"");
+    }
     for(; idx<L && isspace(s[idx]); idx++) {}
     if(idx<L)
-        throw std::invalid_argument(SB()<<"Extraneous charactors after unsigned: \""<<escape(s)<<"\"");
+        throw NoConvert(SB()<<"Extraneous characters after unsigned: \""<<escape(s)<<"\"");
     return ret;
 }
 
diff --git a/test/testdata.cpp b/test/testdata.cpp
index 6c8c24d..c88b96d 100644
--- a/test/testdata.cpp
+++ b/test/testdata.cpp
@@ -87,7 +87,7 @@ void testAssignUnion()
 
     testFalse(val["->"].valid());
 
-    testThrows<std::invalid_argument>([&val](){
+    testThrows<NoConvert>([&val](){
         val["->u16"] = "hello";
     });