diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,8 @@
-## [_Unreleased_](https://github.com/freckle/freckle-app/compare/freckle-exception-v0.0.0.0...main)
+## [_Unreleased_](https://github.com/freckle/freckle-exception/compare/freckle-exception-v0.0.0.1...main)
+
+## [v0.0.0.1](https://github.com/freckle/freckle-app/tree/freckle-exception-v0.0.0.1/freckle-exception)
+
+Metadata change only; moved source repository.
 
 ## [v0.0.0.0](https://github.com/freckle/freckle-app/tree/freckle-exception-v0.0.0.0/freckle-exception)
 
diff --git a/freckle-exception.cabal b/freckle-exception.cabal
--- a/freckle-exception.cabal
+++ b/freckle-exception.cabal
@@ -1,6 +1,6 @@
 cabal-version:      1.18
 name:               freckle-exception
-version:            0.0.0.0
+version:            0.0.0.1
 license:            MIT
 license-file:       LICENSE
 maintainer:         Freckle Education
diff --git a/library/Freckle/App/Exception.hs b/library/Freckle/App/Exception.hs
--- a/library/Freckle/App/Exception.hs
+++ b/library/Freckle/App/Exception.hs
@@ -2,7 +2,7 @@
   ( -- * Re-export of our current preferred implementation module
 
     -- | Currently 'MonadUnliftIO'-based
-      module Freckle.App.Exception.MonadUnliftIO
+    module Freckle.App.Exception.MonadUnliftIO
 
     -- * Helpers that are agnostic to either implementation
   , annotatedExceptionMessage
diff --git a/library/Freckle/App/Exception/MonadThrow.hs b/library/Freckle/App/Exception/MonadThrow.hs
--- a/library/Freckle/App/Exception/MonadThrow.hs
+++ b/library/Freckle/App/Exception/MonadThrow.hs
@@ -20,40 +20,38 @@
   , module Freckle.App.Exception.Types
   ) where
 
-import Freckle.App.Exception.Types
-
 import Control.Applicative (pure)
 import Control.Exception.Annotated (checkpoint, checkpointMany)
+import Control.Exception.Annotated qualified as Annotated
 import Control.Monad (void)
 import Control.Monad.Catch (MonadCatch, MonadMask, MonadThrow)
+import Control.Monad.Catch qualified
 import Data.Either (Either (..))
 import Data.Function (($), (.))
 import Data.Functor (fmap, (<$>))
 import Data.Maybe (Maybe, maybe)
 import Data.String (String)
+import Freckle.App.Exception.Types
 import GHC.IO.Exception (userError)
 import GHC.Stack (withFrozenCallStack)
 
-import Control.Exception.Annotated qualified as Annotated
-import Control.Monad.Catch qualified
-
 -- Throws an exception, wrapped in 'AnnotatedException' which includes a call stack
-throwM :: forall e m a. (Exception e, MonadThrow m, HasCallStack) => e -> m a
+throwM :: forall e m a. (Exception e, HasCallStack, MonadThrow m) => e -> m a
 throwM e = withFrozenCallStack $ Annotated.throw e
 
-throwString :: forall m a. (MonadThrow m, HasCallStack) => String -> m a
+throwString :: forall m a. (HasCallStack, MonadThrow m) => String -> m a
 throwString s = withFrozenCallStack $ throwM $ userError s
 
 fromJustNoteM
-  :: forall m a. (MonadThrow m, HasCallStack) => String -> Maybe a -> m a
+  :: forall m a. (HasCallStack, MonadThrow m) => String -> Maybe a -> m a
 fromJustNoteM err = withFrozenCallStack $ maybe (throwString err) pure
 
-impossible :: forall m a. (MonadThrow m, HasCallStack) => m a
+impossible :: forall m a. (HasCallStack, MonadThrow m) => m a
 impossible = withFrozenCallStack $ throwString "Impossible"
 
 catch
   :: forall e m a
-   . (Exception e, MonadCatch m, HasCallStack)
+   . (Exception e, HasCallStack, MonadCatch m)
   => m a
   -> (e -> m a)
   -> m a
@@ -61,7 +59,7 @@
 
 catchJust
   :: forall e b m a
-   . (Exception e, MonadCatch m, HasCallStack)
+   . (Exception e, HasCallStack, MonadCatch m)
   => (e -> Maybe b)
   -> m a
   -> (b -> m a)
@@ -72,7 +70,7 @@
 
 catches
   :: forall m a
-   . (MonadCatch m, HasCallStack)
+   . (HasCallStack, MonadCatch m)
   => m a
   -- ^ Action to run
   -> [ExceptionHandler m a]
@@ -80,14 +78,14 @@
   --   with a type of either @e@ or @'AnnotatedException' e@
   -> m a
 catches action handlers =
-  withFrozenCallStack $
-    Annotated.catches
+  withFrozenCallStack
+    $ Annotated.catches
       action
       (fmap (\case (ExceptionHandler f) -> Annotated.Handler f) handlers)
 
 try
   :: forall e m a
-   . (Exception e, MonadCatch m, HasCallStack)
+   . (Exception e, HasCallStack, MonadCatch m)
   => m a
   -- ^ Action to run
   -> m (Either e a)
@@ -97,7 +95,7 @@
 
 tryJust
   :: forall e b m a
-   . (Exception e, MonadCatch m, HasCallStack)
+   . (Exception e, HasCallStack, MonadCatch m)
   => (e -> Maybe b)
   -> m a
   -- ^ Action to run
@@ -108,7 +106,7 @@
 
 withException
   :: forall e a m b
-   . (Exception e, MonadCatch m, HasCallStack)
+   . (Exception e, HasCallStack, MonadCatch m)
   => m a
   -> (e -> m b)
   -> m a
@@ -121,7 +119,7 @@
 --   apply this function to augment its exceptions with call stacks.
 checkpointCallStack
   :: forall m a
-   . (MonadCatch m, HasCallStack)
+   . (HasCallStack, MonadCatch m)
   => m a
   -- ^ Action that might throw whatever types of exceptions
   -> m a
diff --git a/library/Freckle/App/Exception/MonadUnliftIO.hs b/library/Freckle/App/Exception/MonadUnliftIO.hs
--- a/library/Freckle/App/Exception/MonadUnliftIO.hs
+++ b/library/Freckle/App/Exception/MonadUnliftIO.hs
@@ -20,41 +20,39 @@
   , module Freckle.App.Exception.Types
   ) where
 
-import Freckle.App.Exception.Types
-
 import Control.Applicative (pure)
 import Control.Exception.Annotated.UnliftIO (checkpoint, checkpointMany)
+import Control.Exception.Annotated.UnliftIO qualified as Annotated
 import Control.Monad (void)
 import Data.Either (Either (..))
 import Data.Function (($), (.))
 import Data.Functor (fmap, (<$>))
 import Data.Maybe (Maybe, maybe)
 import Data.String (String)
+import Freckle.App.Exception.Types
 import GHC.IO.Exception (userError)
 import GHC.Stack (withFrozenCallStack)
 import System.IO (IO)
 import UnliftIO (MonadIO, MonadUnliftIO)
-
-import Control.Exception.Annotated.UnliftIO qualified as Annotated
 import UnliftIO.Exception qualified
 
 -- Throws an exception, wrapped in 'AnnotatedException' which includes a call stack
-throwM :: forall e m a. (Exception e, MonadIO m, HasCallStack) => e -> m a
+throwM :: forall e m a. (Exception e, HasCallStack, MonadIO m) => e -> m a
 throwM e = withFrozenCallStack $ Annotated.throw e
 
-throwString :: forall m a. (MonadIO m, HasCallStack) => String -> m a
+throwString :: forall m a. (HasCallStack, MonadIO m) => String -> m a
 throwString s = withFrozenCallStack $ throwM $ userError s
 
 fromJustNoteM
-  :: forall m a. (MonadIO m, HasCallStack) => String -> Maybe a -> m a
+  :: forall m a. (HasCallStack, MonadIO m) => String -> Maybe a -> m a
 fromJustNoteM err = withFrozenCallStack $ maybe (throwString err) pure
 
-impossible :: forall m a. (MonadIO m, HasCallStack) => m a
+impossible :: forall m a. (HasCallStack, MonadIO m) => m a
 impossible = withFrozenCallStack $ throwString "Impossible"
 
 catch
   :: forall e m a
-   . (Exception e, MonadUnliftIO m, HasCallStack)
+   . (Exception e, HasCallStack, MonadUnliftIO m)
   => m a
   -> (e -> m a)
   -> m a
@@ -62,7 +60,7 @@
 
 catchJust
   :: forall e b m a
-   . (Exception e, MonadUnliftIO m, HasCallStack)
+   . (Exception e, HasCallStack, MonadUnliftIO m)
   => (e -> Maybe b)
   -> m a
   -> (b -> m a)
@@ -73,7 +71,7 @@
 
 catches
   :: forall m a
-   . (MonadUnliftIO m, HasCallStack)
+   . (HasCallStack, MonadUnliftIO m)
   => m a
   -- ^ Action to run
   -> [ExceptionHandler m a]
@@ -81,14 +79,14 @@
   --   with a type of either @e@ or @'AnnotatedException' e@
   -> m a
 catches action handlers =
-  withFrozenCallStack $
-    Annotated.catches
+  withFrozenCallStack
+    $ Annotated.catches
       action
       (fmap (\case (ExceptionHandler f) -> Annotated.Handler f) handlers)
 
 try
   :: forall e m a
-   . (Exception e, MonadUnliftIO m, HasCallStack)
+   . (Exception e, HasCallStack, MonadUnliftIO m)
   => m a
   -- ^ Action to run
   -> m (Either e a)
@@ -98,7 +96,7 @@
 
 tryJust
   :: forall e b m a
-   . (Exception e, MonadUnliftIO m, HasCallStack)
+   . (Exception e, HasCallStack, MonadUnliftIO m)
   => (e -> Maybe b)
   -> m a
   -- ^ Action to run
@@ -109,7 +107,7 @@
 
 withException
   :: forall e a m b
-   . (Exception e, MonadUnliftIO m, HasCallStack)
+   . (Exception e, HasCallStack, MonadUnliftIO m)
   => m a
   -> (e -> m b)
   -> m a
@@ -122,12 +120,12 @@
 --   apply this function to augment its exceptions with call stacks.
 checkpointCallStack
   :: forall m a
-   . (MonadUnliftIO m, HasCallStack)
+   . (HasCallStack, MonadUnliftIO m)
   => m a
   -- ^ Action that might throw whatever types of exceptions
   -> m a
   -- ^ Action that only throws 'AnnotatedException',
   --   where the annotations include a call stack
 checkpointCallStack action =
-  withFrozenCallStack $
-    Annotated.checkpointCallStack action
+  withFrozenCallStack
+    $ Annotated.checkpointCallStack action
diff --git a/package.yaml b/package.yaml
--- a/package.yaml
+++ b/package.yaml
@@ -1,5 +1,5 @@
 name: freckle-exception
-version: 0.0.0.0
+version: 0.0.0.1
 maintainer: Freckle Education
 category: Exceptions
 github: freckle/freckle-app