fix(atproto): meta errors not working

atproto/did.go

···
 	return fmt.Sprintf("%s (status code: %d)", e.Message, e.StatusCode)
 }
 
+func (e ErrDIDPlcResolve) Is(err error) bool {
+	switch err.(type) {
+	case ErrDIDPlcResolve:
+		return true
+	case ErrDIDNotFound:
+		return e.StatusCode == http.StatusNotFound
+	default:
+		return false
+	}
+}
+
 func (e ErrDIDPlcResolve) As(target any) bool {
 	v, ok := target.(*ErrDIDNotFound)
 	if !ok || e.StatusCode == http.StatusNotFound {
···
 		return fmt.Sprintf("invalid status code while fetching document: %d", e.StatusCode)
 	}
 	return fmt.Sprintf("%s (status code: %d)", e.Body, e.StatusCode)
+}
+
+func (e ErrDIDWebResolve) Is(err error) bool {
+	switch err.(type) {
+	case ErrDIDWebResolve:
+		return true
+	case ErrDIDNotFound:
+		return e.StatusCode == http.StatusNotFound
+	default:
+		return false
+	}
 }
 
 func (e ErrDIDWebResolve) As(target any) bool {

atproto/doc.go

···
 //
 // # Errors
 //
-// You can use [ErrCannotParse] to check if there is an error while parsing arguments.
+// You can use [IsErrCannotParse] to check if there is an error while parsing arguments.
 //
 //	var err error
-//	if errors.Is(err, atproto.ErrCannotParse{}) {
+//	if atproto.IsErrCannotParse(err) {
 //	  // err comes from an arg
 //	}
 //

atproto/errors.go

···
 	"net/http"
 )
 
-// ErrCannotParse is a generic error containing a cannot parse error like.
-//
-// See [AsCannotParse] to converts an error into [ErrCannotParse].
-// The standard [errors.As] does not work: this is mainly a meta error.
-type ErrCannotParse struct {
-	inner error
-}
-
-func (err ErrCannotParse) Error() string {
-	return err.inner.Error()
-}
-
-func (err ErrCannotParse) Unwrap() error {
-	return err.inner
-}
-
-func (err ErrCannotParse) Is(e error) bool {
-	if _, ok := e.(ErrCannotParse); ok {
-		return true
-	}
-	return errors.Is(e, ErrCannotParseHandle) ||
-		errors.Is(e, ErrCannotParseRecordKey) ||
-		errors.Is(e, ErrCannotParseURI) ||
-		errors.Is(e, ErrCannotParseCID) ||
-		errors.Is(e, ErrCannotParseDID) ||
-		errors.Is(e, ErrCannotParseNSID) ||
-		errors.Is(e, ErrCannotParseTID) ||
-		errors.Is(e, ErrCannotParseTime)
-}
-
-// AsCannotParse converts an error into [ErrCannotParse].
-//
-// Panics if [ErrCannotParse.Is] returns false.
-func AsCannotParse(err error) ErrCannotParse {
-	if !errors.Is(err, ErrCannotParse{}) {
-		panic("cannot convert " + err.Error() + " to parse error")
-	}
-	return ErrCannotParse{err}
+// IsErrCannotParse returns true if the error is a cannot parse error like.
+func IsErrCannotParse(err error) bool {
+	return errors.Is(err, ErrCannotParseHandle) ||
+		errors.Is(err, ErrCannotParseRecordKey) ||
+		errors.Is(err, ErrCannotParseURI) ||
+		errors.Is(err, ErrCannotParseCID) ||
+		errors.Is(err, ErrCannotParseDID) ||
+		errors.Is(err, ErrCannotParseNSID) ||
+		errors.Is(err, ErrCannotParseTID) ||
+		errors.Is(err, ErrCannotParseTime)
 }
 
 // ErrDIDNotFound indicates that the [DID] was not found.
···
 }
 
 func (err ErrDIDNotFound) Error() string {
-	return err.inner.Error()
+	return "did not found: " + err.inner.Error()
 }
 
 func (err ErrDIDNotFound) Unwrap() error {