diff --git a/autosurgeon-derive/src/attrs.rs b/autosurgeon-derive/src/attrs.rs
index 09d8967..49aa077 100644
--- a/autosurgeon-derive/src/attrs.rs
+++ b/autosurgeon-derive/src/attrs.rs
@@ -118,11 +118,14 @@ impl ReconcileWith {
             Self::Module { module_name, .. } | Self::With { module_name, .. } => {
                 let k = syn::Lifetime::new("'k", Span::mixed_site());
                 Some(quote! {
-                    fn hydrate_key<#k, D: autosurgeon::ReadDoc>(
+                    fn hydrate_key<#k, D: ::autosurgeon::ReadDoc>(
                         doc: &D,
-                        obj: &automerge::ObjId,
-                        prop: autosurgeon::Prop<'_>,
-                    ) -> Result<autosurgeon::reconcile::LoadKey<Self::Key<#k>>, autosurgeon::ReconcileError> {
+                        obj: &::automerge::ObjId,
+                        prop: ::autosurgeon::Prop<'_>,
+                    ) -> ::std::result::Result<
+                        ::autosurgeon::reconcile::LoadKey<Self::Key<#k>>,
+                        ::autosurgeon::ReconcileError,
+                    > {
                         #module_name::hydrate_key(doc, obj, prop)
                     }
                 })
@@ -136,7 +139,7 @@ impl ReconcileWith {
             Self::Module { module_name, .. } | Self::With { module_name, .. } => {
                 let k = syn::Lifetime::new("'k", Span::mixed_site());
                 Some(quote! {
-                    fn key<#k>(&#k self) -> autosurgeon::reconcile::LoadKey<Self::Key<#k>> {
+                    fn key<#k>(&#k self) -> ::autosurgeon::reconcile::LoadKey<Self::Key<#k>> {
                         #module_name::key(#accessor)
                     }
                 })
diff --git a/autosurgeon-derive/src/hydrate.rs b/autosurgeon-derive/src/hydrate.rs
index 716b1dc..25c2426 100644
--- a/autosurgeon-derive/src/hydrate.rs
+++ b/autosurgeon-derive/src/hydrate.rs
@@ -43,7 +43,7 @@ pub fn derive_hydrate(input: proc_macro::TokenStream) -> proc_macro::TokenStream
 fn add_trait_bounds(mut generics: Generics) -> Generics {
     for param in &mut generics.params {
         if let GenericParam::Type(ref mut type_param) = *param {
-            type_param.bounds.push(parse_quote!(autosurgeon::Hydrate));
+            type_param.bounds.push(parse_quote!(::autosurgeon::Hydrate));
         }
     }
     generics
@@ -55,12 +55,12 @@ fn on_hydrate_with(input: &DeriveInput, hydrate_with: &TokenStream) -> TokenStre
     let name = &input.ident;
 
     quote! {
-        impl #impl_generics autosurgeon::Hydrate for #name #ty_generics #where_clause {
-            fn hydrate<'a, D: autosurgeon::ReadDoc>(
+        impl #impl_generics ::autosurgeon::Hydrate for #name #ty_generics #where_clause {
+            fn hydrate<'a, D: ::autosurgeon::ReadDoc>(
                 doc: &D,
-                obj: &automerge::ObjId,
-                prop: autosurgeon::Prop<'a>,
-            ) -> Result<Self, autosurgeon::HydrateError> {
+                obj: &::automerge::ObjId,
+                prop: ::autosurgeon::Prop<'a>,
+            ) -> ::std::result::Result<Self, ::autosurgeon::HydrateError> {
                 #hydrate_with(doc, obj, prop)
             }
         }
@@ -87,7 +87,7 @@ fn on_struct(
             let the_impl = gen_named_struct_impl(name, &fields);
 
             Ok(quote! {
-                impl #impl_generics autosurgeon::Hydrate for #name #ty_generics #where_clause {
+                impl #impl_generics ::autosurgeon::Hydrate for #name #ty_generics #where_clause {
                     #the_impl
                 }
             })
@@ -120,7 +120,7 @@ fn on_enum(
     let hydrate_map = named_fields.hydrate_map();
 
     Ok(quote! {
-        impl #impl_generics autosurgeon::Hydrate for #name #ty_generics
+        impl #impl_generics ::autosurgeon::Hydrate for #name #ty_generics
             #where_clause
         {
             #hydrate_string
@@ -154,7 +154,7 @@ impl<'a> EnumUnitFields<'a> {
         let ty = self.ty;
         let branches = self.fields.iter().map(|i| {
             let branch_name = i.to_string();
-            quote!(#branch_name => Ok(#ty::#i))
+            quote!(#branch_name => ::std::result::Result::Ok(#ty::#i))
         });
         quote!(#(#branches),*)
     }
@@ -174,14 +174,16 @@ impl<'a> EnumUnitFields<'a> {
 
             quote! {
                 fn hydrate_string(
-                    val: &'_ str
-                ) -> Result<Self, autosurgeon::HydrateError> {
+                    val: &'_ ::std::primitive::str
+                ) -> ::std::result::Result<Self, ::autosurgeon::HydrateError> {
                     match val {
                         #unit_branches,
-                        other => Err(autosurgeon::HydrateError::unexpected(
-                            #unit_error,
-                            other.to_string(),
-                        )),
+                        other => ::std::result::Result::Err(
+                            ::autosurgeon::HydrateError::unexpected(
+                                #unit_error,
+                                ::std::string::ToString::to_string(other),
+                            ),
+                        ),
                     }
                 }
             }
@@ -210,14 +212,14 @@ impl<'a> EnumAsMapFields<'a> {
         } else {
             let stanzas = self.variants.iter().map(|v| v.visitor_def(self.ty));
             quote! {
-                fn hydrate_map<D: autosurgeon::ReadDoc>(
+                fn hydrate_map<D: ::autosurgeon::ReadDoc>(
                     doc: &D,
-                    obj: &automerge::ObjId,
-                ) -> Result<Self, autosurgeon::HydrateError> {
+                    obj: &::automerge::ObjId,
+                ) -> ::std::result::Result<Self, ::autosurgeon::HydrateError> {
                     #(#stanzas)*
-                    Err(autosurgeon::HydrateError::unexpected(
+                    ::std::result::Result::Err(::autosurgeon::HydrateError::unexpected(
                         "A map with one key",
-                        "something else".to_string(),
+                        ::std::string::ToString::to_string("something else"),
                     ))
                 }
             }
@@ -232,9 +234,12 @@ fn gen_named_struct_impl(name: &syn::Ident, fields: &[named_field::NamedField])
     let field_initializers = fields.iter().map(|f| f.initializer());
 
     quote! {
-        fn hydrate_map<D: autosurgeon::ReadDoc>(doc: &D, #obj_ident: &automerge::ObjId) -> Result<Self, autosurgeon::HydrateError> {
+        fn hydrate_map<D: ::autosurgeon::ReadDoc>(
+            doc: &D,
+            #obj_ident: &::automerge::ObjId,
+        ) -> ::std::result::Result<Self, ::autosurgeon::HydrateError> {
             #(#field_hydrators)*
-            Ok(#name {
+            ::std::result::Result::Ok(#name {
                 #(#field_initializers),*
             })
         }
@@ -258,27 +263,27 @@ fn gen_newtype_struct_wrapper(
 
     if let Some(hydrate_with) = attrs.hydrate_with().map(|h| h.hydrate_with()) {
         Ok(quote! {
-            impl #impl_generics autosurgeon::hydrate::Hydrate for #ty #ty_generics #where_clause {
-                fn hydrate<'a, D: autosurgeon::ReadDoc>(
+            impl #impl_generics ::autosurgeon::hydrate::Hydrate for #ty #ty_generics #where_clause {
+                fn hydrate<'a, D: ::autosurgeon::ReadDoc>(
                     doc: &D,
-                    obj: &automerge::ObjId,
-                    prop: autosurgeon::Prop<'a>,
-                ) -> Result<Self, autosurgeon::HydrateError> {
+                    obj: &::automerge::ObjId,
+                    prop: ::autosurgeon::Prop<'a>,
+                ) -> ::std::result::Result<Self, ::autosurgeon::HydrateError> {
                     let inner = #hydrate_with(doc, obj, prop)?;
-                    Ok(#ty(inner))
+                    ::std::result::Result::Ok(#ty(inner))
                 }
             }
         })
     } else {
         Ok(quote! {
-            impl #impl_generics autosurgeon::hydrate::Hydrate for #ty #ty_generics #where_clause {
-                fn hydrate<'a, D: autosurgeon::ReadDoc>(
+            impl #impl_generics ::autosurgeon::hydrate::Hydrate for #ty #ty_generics #where_clause {
+                fn hydrate<'a, D: ::autosurgeon::ReadDoc>(
                     doc: &D,
-                    obj: &automerge::ObjId,
-                    prop: autosurgeon::Prop<'a>,
-                ) -> Result<Self, autosurgeon::HydrateError> {
+                    obj: &::automerge::ObjId,
+                    prop: ::autosurgeon::Prop<'a>,
+                ) -> ::std::result::Result<Self, ::autosurgeon::HydrateError> {
                     let inner = #inner_ty::hydrate(doc, obj, prop)?;
-                    Ok(#ty(inner))
+                    ::std::result::Result::Ok(#ty(inner))
                 }
             }
         })
@@ -305,10 +310,13 @@ fn gen_tuple_struct_wrapper(
     let field_initializers = fields.iter().map(|f| f.initializer());
 
     Ok(quote! {
-        impl #impl_generics autosurgeon::Hydrate for #name #ty_generics #where_clause {
-            fn hydrate_seq<D: autosurgeon::ReadDoc>(doc: &D, #obj_ident: &automerge::ObjId) -> Result<Self, autosurgeon::HydrateError> {
+        impl #impl_generics ::autosurgeon::Hydrate for #name #ty_generics #where_clause {
+            fn hydrate_seq<D: ::autosurgeon::ReadDoc>(
+                doc: &D,
+                #obj_ident: &::automerge::ObjId,
+            ) -> ::std::result::Result<Self, ::autosurgeon::HydrateError> {
                 #(#field_hydrators)*
-                Ok(#name (
+                ::std::result::Result::Ok(#name (
                     #(#field_initializers),*
                 ))
             }
diff --git a/autosurgeon-derive/src/hydrate/named_field.rs b/autosurgeon-derive/src/hydrate/named_field.rs
index c82d454..77e7874 100644
--- a/autosurgeon-derive/src/hydrate/named_field.rs
+++ b/autosurgeon-derive/src/hydrate/named_field.rs
@@ -29,12 +29,16 @@ impl<'a> NamedField<'a> {
         if let Some(hydrate_with) = self.attrs.hydrate_with() {
             let function_name = hydrate_with.hydrate_with();
             quote! {
-                let #name = #function_name(doc, &#obj_ident, #string_name.into())?;
+                let #name = #function_name(
+                    doc,
+                    &#obj_ident,
+                    ::std::convert::Into::into(#string_name),
+                )?;
             }
         } else {
             let span = self.field.span();
             quote_spanned! {span=>
-                let #name = autosurgeon::hydrate_prop(doc, &#obj_ident, #string_name)?;
+                let #name = ::autosurgeon::hydrate_prop(doc, &#obj_ident, #string_name)?;
             }
         }
     }
diff --git a/autosurgeon-derive/src/hydrate/newtype_field.rs b/autosurgeon-derive/src/hydrate/newtype_field.rs
index ab16b4d..ea0ceb2 100644
--- a/autosurgeon-derive/src/hydrate/newtype_field.rs
+++ b/autosurgeon-derive/src/hydrate/newtype_field.rs
@@ -24,12 +24,12 @@ impl<'a> NewtypeField<'a> {
         if let Some(hydrate_with) = self.attrs.hydrate_with() {
             let hydrate_func = hydrate_with.hydrate_with();
             quote! {
-                let #target = #hydrate_func(doc, obj, #prop_ident.into())?;
+                let #target = #hydrate_func(doc, obj, ::std::convert::Into::into(#prop_ident))?;
             }
         } else {
             let span = self.field.span();
             quote_spanned! {span=>
-                let #target = autosurgeon::hydrate_prop(doc, obj, #prop_ident)?;
+                let #target = ::autosurgeon::hydrate_prop(doc, obj, #prop_ident)?;
             }
         }
     }
diff --git a/autosurgeon-derive/src/hydrate/unnamed_field.rs b/autosurgeon-derive/src/hydrate/unnamed_field.rs
index 6b71f98..4c1fe3e 100644
--- a/autosurgeon-derive/src/hydrate/unnamed_field.rs
+++ b/autosurgeon-derive/src/hydrate/unnamed_field.rs
@@ -26,12 +26,12 @@ impl UnnamedField {
         if let Some(hydrate_with) = self.attrs.hydrate_with() {
             let function_name = hydrate_with.hydrate_with();
             quote! {
-                let #name = #function_name(doc, &#obj_ident, #idx.into())?;
+                let #name = #function_name(doc, &#obj_ident, ::std::convert::Into::into(#idx))?;
             }
         } else {
             let span = self.field.span();
             quote_spanned! {span=>
-                let #name = autosurgeon::hydrate_prop(doc, &#obj_ident, #idx)?;
+                let #name = ::autosurgeon::hydrate_prop(doc, &#obj_ident, #idx)?;
             }
         }
     }
diff --git a/autosurgeon-derive/src/hydrate/variant_fields.rs b/autosurgeon-derive/src/hydrate/variant_fields.rs
index fad4de7..1e3a52e 100644
--- a/autosurgeon-derive/src/hydrate/variant_fields.rs
+++ b/autosurgeon-derive/src/hydrate/variant_fields.rs
@@ -76,10 +76,10 @@ fn newtype_field_variant_stanza(
 
     let hydrator = field.hydrate_into(&name, &variant_name_str);
     quote! {
-        if doc.get(obj, #variant_name_str)?.is_some() {
+        if ::autosurgeon::ReadDoc::get(doc, obj, #variant_name_str)?.is_some() {
             #hydrator
-            //let #name = autosurgeon::hydrate_prop(doc, obj, #variant_name_str)?;
-            return Ok(#ty::#variant_name(#name))
+            //let #name = ::autosurgeon::hydrate_prop(doc, obj, #variant_name_str)?;
+            return ::std::result::Result::Ok(#ty::#variant_name(#name))
         }
     }
 }
@@ -97,10 +97,14 @@ fn named_field_variant_stanza(
     let field_initializers = fields.iter().map(|f| f.initializer());
 
     quote! {
-        if let Some((val, #obj_ident)) = doc.get(obj, #variant_name_str)? {
-            if matches!(val, automerge::Value::Object(automerge::ObjType::Map)) {
+        if let ::std::option::Option::Some((val, #obj_ident)) = ::autosurgeon::ReadDoc::get(
+            doc,
+            obj,
+            #variant_name_str,
+        )? {
+            if ::std::matches!(val, ::automerge::Value::Object(::automerge::ObjType::Map)) {
                 #(#field_hydrators)*
-                return Ok(#ty::#variant_name {
+                return ::std::result::Result::Ok(#ty::#variant_name {
                     #(#field_initializers),*
                 })
             }
@@ -121,10 +125,14 @@ fn unnamed_field_variant_stanza(
 
     let variant_name_str = variant_name.to_string();
     quote! {
-        if let Some((val, #obj_ident)) = doc.get(obj, #variant_name_str)? {
-            if matches!(val, automerge::Value::Object(automerge::ObjType::List)) {
+        if let ::std::option::Option::Some((val, #obj_ident)) = ::autosurgeon::ReadDoc::get(
+            doc,
+            obj,
+            #variant_name_str,
+        )? {
+            if ::std::matches!(val, ::automerge::Value::Object(::automerge::ObjType::List)) {
                 #(#hydrators)*
-                return Ok(#ty::#variant_name(#(#initializers),*))
+                return ::std::result::Result::Ok(#ty::#variant_name(#(#initializers),*))
             }
         }
     }
diff --git a/autosurgeon-derive/src/reconcile.rs b/autosurgeon-derive/src/reconcile.rs
index ab05d9f..1ede318 100644
--- a/autosurgeon-derive/src/reconcile.rs
+++ b/autosurgeon-derive/src/reconcile.rs
@@ -59,12 +59,15 @@ pub fn derive_reconcile(input: proc_macro::TokenStream) -> proc_macro::TokenStre
             let key_lifetime = syn::Lifetime::new("'k", Span::mixed_site());
             let key_type_def = key_type_def.unwrap_or_else(|| quote!());
             let key_type = key_type.unwrap_or(quote! {
-                type Key<#key_lifetime> = autosurgeon::reconcile::NoKey;
+                type Key<#key_lifetime> = ::autosurgeon::reconcile::NoKey;
             });
             let expanded = quote! {
-                impl #impl_generics autosurgeon::Reconcile for #name #ty_generics #where_clause {
+                impl #impl_generics ::autosurgeon::Reconcile for #name #ty_generics #where_clause {
                     #key_type
-                    fn reconcile<__R123: autosurgeon::Reconciler>(&self, mut #reconciler_ident: __R123) -> Result<(), __R123::Error> {
+                    fn reconcile<__R123: ::autosurgeon::Reconciler>(
+                        &self,
+                        mut #reconciler_ident: __R123,
+                    ) -> ::std::result::Result<(), __R123::Error> {
                         #the_impl
                     }
                     #hydrate_key
@@ -85,7 +88,9 @@ pub fn derive_reconcile(input: proc_macro::TokenStream) -> proc_macro::TokenStre
 fn add_trait_bounds(mut generics: Generics) -> Generics {
     for param in &mut generics.params {
         if let GenericParam::Type(ref mut type_param) = *param {
-            type_param.bounds.push(parse_quote!(autosurgeon::Reconcile));
+            type_param
+                .bounds
+                .push(parse_quote!(::autosurgeon::Reconcile));
         }
     }
     generics
@@ -128,7 +133,7 @@ fn reconcile_with_impl(
     let key_lifetime = syn::Lifetime::new("'k", Span::mixed_site());
     let key_type = match reconcile_with {
         attrs::ReconcileWith::Function { .. } => quote! {
-            type Key<#key_lifetime> = std::borrow::Cow<#key_lifetime, Self>;
+            type Key<#key_lifetime> = ::std::borrow::Cow<#key_lifetime, Self>;
         },
         attrs::ReconcileWith::Module { module_name, .. }
         | attrs::ReconcileWith::With { module_name, .. } => {
@@ -140,25 +145,38 @@ fn reconcile_with_impl(
     };
     let hydrate_key = match reconcile_with {
         attrs::ReconcileWith::Function { .. } => quote! {
-            fn hydrate_key<#key_lifetime, D: autosurgeon::ReadDoc>(
+            fn hydrate_key<#key_lifetime, D: ::autosurgeon::ReadDoc>(
                 doc: &D,
-                obj: &automerge::ObjId,
-                prop: autosurgeon::Prop<'_>,
-            ) -> Result<autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>>, autosurgeon::ReconcileError> {
-                use autosurgeon::{reconcile::LoadKey, hydrate::HydrateResultExt};
-                let key = autosurgeon::hydrate::hydrate_path(doc, obj, std::iter::once(prop)).strip_unexpected()?;
-                Ok(key.map(|k| LoadKey::Found(std::borrow::Cow::Owned(k))).unwrap_or(LoadKey::KeyNotFound))
+                obj: &::automerge::ObjId,
+                prop: ::autosurgeon::Prop<'_>,
+            ) -> ::std::result::Result<
+                ::autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>>,
+                ::autosurgeon::ReconcileError,
+            > {
+                let key = ::autosurgeon::hydrate::HydrateResultExt::strip_unexpected(
+                    ::autosurgeon::hydrate::hydrate_path(doc, obj, ::std::iter::once(prop)),
+                )?;
+                ::std::result::Result::Ok(
+                    key
+                        .map(|k| {
+                            ::autosurgeon::reconcile::LoadKey::Found(::std::borrow::Cow::Owned(k))
+                        })
+                        .unwrap_or(::autosurgeon::reconcile::LoadKey::KeyNotFound),
+                )
             }
         },
         attrs::ReconcileWith::Module { module_name, .. }
         | attrs::ReconcileWith::With { module_name, .. } => {
             let hydrate_key_ident = syn::Ident::new("hydrate_key", Span::mixed_site());
             quote! {
-                fn hydrate_key<#key_lifetime, D: autosurgeon::ReadDoc>(
+                fn hydrate_key<#key_lifetime, D: ::autosurgeon::ReadDoc>(
                     doc: &D,
-                    obj: &automerge::ObjId,
-                    prop: autosurgeon::Prop<'_>,
-                ) -> Result<autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>>, autosurgeon::ReconcileError> {
+                    obj: &::automerge::ObjId,
+                    prop: ::autosurgeon::Prop<'_>,
+                ) -> ::std::result::Result<
+                    ::autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>>,
+                    ::autosurgeon::ReconcileError,
+                > {
                     #module_name::#hydrate_key_ident(doc, obj, prop)
                 }
             }
@@ -166,15 +184,19 @@ fn reconcile_with_impl(
     };
     let get_key = match reconcile_with {
         attrs::ReconcileWith::Function { .. } => quote! {
-            fn key<#key_lifetime>(&#key_lifetime self) -> autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>> {
-                autosurgeon::reconcile::LoadKey::Found(std::borrow::Cow::Borrowed(self))
+            fn key<#key_lifetime>(
+                &#key_lifetime self,
+            ) -> ::autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>> {
+                ::autosurgeon::reconcile::LoadKey::Found(::std::borrow::Cow::Borrowed(self))
             }
         },
         attrs::ReconcileWith::Module { module_name, .. }
         | attrs::ReconcileWith::With { module_name, .. } => {
             let get_ident = syn::Ident::new("key", Span::mixed_site());
             quote! {
-                fn key<#key_lifetime>(&#key_lifetime self) -> autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>> {
+                fn key<#key_lifetime>(
+                    &#key_lifetime self,
+                ) -> ::autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>> {
                     #module_name::#get_ident(self)
                 }
             }
@@ -220,21 +242,27 @@ fn newtype_struct_impl(field: &syn::Field) -> Result<ReconcileImpl, error::Deriv
         Ok(ReconcileImpl {
             reconcile: quote_spanned!(field.span()=> self.0.reconcile(reconciler)),
             key_type: Some(quote! {
-                type Key<#key_lifetime> = <#field_ty as Reconcile>::Key<#key_lifetime>;
+                type Key<#key_lifetime> =
+                    <#field_ty as ::autosurgeon::Reconcile>::Key<#key_lifetime>;
             }),
             key_type_def: None,
             hydrate_key: Some(quote! {
-                fn hydrate_key<#key_lifetime, D: autosurgeon::ReadDoc>(
+                fn hydrate_key<#key_lifetime, D: ::autosurgeon::ReadDoc>(
                     doc: &D,
-                    obj: &automerge::ObjId,
-                    prop: autosurgeon::Prop<'_>,
-                ) -> Result<autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>>, autosurgeon::ReconcileError> {
-                    <#field_ty as autosurgeon::Reconcile>::hydrate_key(doc, obj, prop)
+                    obj: &::automerge::ObjId,
+                    prop: ::autosurgeon::Prop<'_>,
+                ) -> ::std::result::Result<
+                    ::autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>>,
+                    ::autosurgeon::ReconcileError,
+                > {
+                    <#field_ty as ::autosurgeon::Reconcile>::hydrate_key(doc, obj, prop)
                 }
             }),
             get_key: Some(quote! {
-                fn key<#key_lifetime>(&#key_lifetime self) -> autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>> {
-                    <#field_ty as autosurgeon::Reconcile>::key(&self.0)
+                fn key<#key_lifetime>(
+                    &#key_lifetime self,
+                ) -> ::autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>> {
+                    <#field_ty as ::autosurgeon::Reconcile>::key(&self.0)
                 }
             }),
         })
diff --git a/autosurgeon-derive/src/reconcile/enum_impl.rs b/autosurgeon-derive/src/reconcile/enum_impl.rs
index 2e6871c..889fc57 100644
--- a/autosurgeon-derive/src/reconcile/enum_impl.rs
+++ b/autosurgeon-derive/src/reconcile/enum_impl.rs
@@ -72,7 +72,7 @@ impl<'a> Variant<'a> {
             Self::Unit { name } => {
                 let name_string = name.to_string();
                 Ok(quote! {
-                    Self::#name => reconciler.str(#name_string)
+                    Self::#name => ::autosurgeon::Reconciler::str(&mut reconciler, #name_string)
                 })
             }
             Self::NewType {
@@ -85,35 +85,45 @@ impl<'a> Variant<'a> {
                 let reconciler = attrs.reconcile_with().map(|reconcile_with| {
                     quote! {
                         struct ___EnumNewtypeVisitor<'a>(&'a #ty);
-                        impl<'a> autosurgeon::Reconcile for ___EnumNewtypeVisitor<'a> {
+                        impl<'a> ::autosurgeon::Reconcile for ___EnumNewtypeVisitor<'a> {
                             type Key<'k> = #reconcile_with::Key<'a>;
-                            fn reconcile<R: autosurgeon::Reconciler>(&self, reconciler: R) -> Result<(), R::Error> {
+                            fn reconcile<R: ::autosurgeon::Reconciler>(
+                                &self,
+                                reconciler: R,
+                            ) -> ::std::result::Result<(), R::Error> {
                                 #reconcile_with::reconcile(self.0, reconciler)
                             }
-                            fn hydrate_key<'k, D: autosurgeon::ReadDoc>(
+                            fn hydrate_key<'k, D: ::autosurgeon::ReadDoc>(
                                 doc: &D,
-                                obj: &automerge::ObjId,
-                                prop: Prop<'_>,
-                            ) -> Result<autosurgeon::reconcile::LoadKey<Self::Key<'k>>, autosurgeon::ReconcileError> {
+                                obj: &::automerge::ObjId,
+                                prop: ::autosurgeon::Prop<'_>,
+                            ) -> ::std::result::Result<
+                                ::autosurgeon::reconcile::LoadKey<Self::Key<'k>>,
+                                ::autosurgeon::ReconcileError,
+                            > {
                                 #reconcile_with::hydrate_key(doc, obj, prop)
                             }
-                            fn key<'k>(&'k self) -> autosurgeon::reconcile::LoadKey<Self::Key<'k>> {
+                            fn key<'k>(
+                                &'k self,
+                            ) -> ::autosurgeon::reconcile::LoadKey<Self::Key<'k>> {
                                 #reconcile_with::key(self.0)
                             }
                         }
-                        m.retain(|k, _| k == #name_string)?;
-                        m.put(#name_string, ___EnumNewtypeVisitor(&v))?;
+                        ::autosurgeon::reconcile::MapReconciler::retain(&mut m, |k, _| k == #name_string)?;
+                        ::autosurgeon::reconcile::MapReconciler::put(&mut m, #name_string, ___EnumNewtypeVisitor(&v))?;
                     }
                 }).unwrap_or_else(|| quote! {
-                    m.retain(|k, _| k == #name_string)?;
-                    m.put(#name_string, v)?;
+                    ::autosurgeon::reconcile::MapReconciler::retain(
+                        &mut m,
+                        |k, _| k == #name_string,
+                    )?;
+                    ::autosurgeon::reconcile::MapReconciler::put(&mut m, #name_string, v)?;
                 });
                 Ok(quote! {
                      Self::#name(v) => {
-                        use autosurgeon::reconcile::MapReconciler;
-                        let mut m = #reconciler_ident.map()?;
+                        let mut m = ::autosurgeon::Reconciler::map(&mut #reconciler_ident)?;
                         #reconciler
-                        Ok(())
+                        ::std::result::Result::Ok(())
                     }
                 })
             }
@@ -150,42 +160,52 @@ impl<'a> EnumKeyInnerType<'a> {
         match self {
             Self::Unit => {
                 quote! {
-                    Self::#variant_name => autosurgeon::reconcile::LoadKey::Found(#key_type_name::#variant_name)
+                    Self::#variant_name => ::autosurgeon::reconcile::LoadKey::Found(
+                        #key_type_name::#variant_name,
+                    )
                 }
             }
             Self::NewType(k) => {
                 if let Some(reconcile_with) = k.attrs.reconcile_with() {
                     quote! {
-                        Self::#variant_name(inner) => #reconcile_with::key(inner).map(|k| #key_type_name::#variant_name(k))
+                        Self::#variant_name(inner) => {
+                            #reconcile_with::key(inner).map(|k| #key_type_name::#variant_name(k))
+                        }
                     }
                 } else {
                     let inner_ty = k.ty;
                     quote! {
-                        Self::#variant_name(inner) => <#inner_ty as Reconcile>::key(inner).map(|k| #key_type_name::#variant_name(k))
+                        Self::#variant_name(inner) => {
+                            <#inner_ty as ::autosurgeon::Reconcile>
+                                ::key(inner)
+                                .map(|k| #key_type_name::#variant_name(k))
+                        }
                     }
                 }
             }
             Self::Tuple(keyfield) => {
                 let before = (0..(keyfield.index())).map(|_| quote!("_"));
                 quote! {
-                    Self::#variant_name(#(#before)* v, ..) => autosurgeon::reconcile::LoadKey::Found(
-                        #key_type_name::#variant_name(std::borrow::Cow::Borrowed(v))
-                    )
+                    Self::#variant_name(#(#before)* v, ..) => {
+                        ::autosurgeon::reconcile::LoadKey::Found(
+                            #key_type_name::#variant_name(::std::borrow::Cow::Borrowed(v)),
+                        )
+                    }
                 }
             }
             Self::Struct(keyfield) => {
                 let fieldname = keyfield.name();
                 quote! {
-                    Self::#variant_name{#fieldname, ..} => autosurgeon::reconcile::LoadKey::Found(
-                        #key_type_name::#variant_name(std::borrow::Cow::Borrowed(#fieldname))
+                    Self::#variant_name{#fieldname, ..} => ::autosurgeon::reconcile::LoadKey::Found(
+                        #key_type_name::#variant_name(::std::borrow::Cow::Borrowed(#fieldname)),
                     )
                 }
             }
             Self::NoInnerKeyStruct => quote! {
-                Self::#variant_name{..} => autosurgeon::reconcile::LoadKey::NoKey
+                Self::#variant_name{..} => ::autosurgeon::reconcile::LoadKey::NoKey
             },
             Self::NoInnerKeyTuple => quote! {
-                Self::#variant_name(..) => autosurgeon::reconcile::LoadKey::NoKey
+                Self::#variant_name(..) => ::autosurgeon::reconcile::LoadKey::NoKey
             },
         }
     }
@@ -205,20 +225,20 @@ impl<'a> EnumKeyInnerType<'a> {
                 } else {
                     let inner = nt.ty;
                     quote! {
-                        #variant_name(<#inner as autosurgeon::Reconcile>::Key<#key_lifetime>)
+                        #variant_name(<#inner as ::autosurgeon::Reconcile>::Key<#key_lifetime>)
                     }
                 })
             }
             EnumKeyInnerType::Struct(keyfield) => {
                 let inner = keyfield.key_type();
                 Some(quote! {
-                    #variant_name(std::borrow::Cow<#key_lifetime, #inner>)
+                    #variant_name(::std::borrow::Cow<#key_lifetime, #inner>)
                 })
             }
             EnumKeyInnerType::Tuple(keyfield) => {
                 let inner = keyfield.key_type();
                 Some(quote! {
-                    #variant_name(std::borrow::Cow<#key_lifetime, #inner>)
+                    #variant_name(::std::borrow::Cow<#key_lifetime, #inner>)
                 })
             }
             EnumKeyInnerType::NoInnerKeyStruct | EnumKeyInnerType::NoInnerKeyTuple => None,
@@ -233,18 +253,34 @@ impl<'a> EnumKeyInnerType<'a> {
     ) -> TokenStream {
         match self {
             Self::Unit => quote! {
-                Ok(autosurgeon::reconcile::LoadKey::Found(#variant_name)),
+                ::std::result::Result::Ok(::autosurgeon::reconcile::LoadKey::Found(#variant_name)),
             },
             Self::NewType(t) => {
                 let prop = variant_name.to_string();
                 if let Some(reconcile_with) = t.attrs.reconcile_with() {
                     quote! {
-                        Ok(#reconcile_with::hydrate_key(doc, &#obj_id_ident, #prop.into())?.map(#key_type_name::#variant_name)),
+                        std::result::Result::Ok(
+                            #reconcile_with
+                                ::hydrate_key(
+                                    doc,
+                                    &#obj_id_ident,
+                                    ::std::convert::Into::into(#prop),
+                                )?
+                                .map(#key_type_name::#variant_name),
+                        ),
                     }
                 } else {
                     let t = t.ty;
                     quote! {
-                        Ok(<#t as autosurgeon::Reconcile>::hydrate_key(doc, &#obj_id_ident, #prop.into())?.map(#key_type_name::#variant_name)),
+                        std::result::Result::Ok(
+                            <#t as ::autosurgeon::Reconcile>
+                                ::hydrate_key(
+                                    doc,
+                                    &#obj_id_ident,
+                                    ::std::convert::Into::into(#prop),
+                                )?
+                                .map(#key_type_name::#variant_name),
+                        ),
                     }
                 }
             }
@@ -253,8 +289,13 @@ impl<'a> EnumKeyInnerType<'a> {
                 let key_prop = keyfield.prop();
                 quote! {
                     {
-                        let inner = autosurgeon::reconcile::hydrate_key(doc, &#obj_id_ident, #prop.into(), #key_prop.into())?;
-                        Ok(inner.map(#key_type_name::#variant_name))
+                        let inner = ::autosurgeon::reconcile::hydrate_key(
+                            doc,
+                            &#obj_id_ident,
+                            ::std::convert::Into::into(#prop),
+                            ::std::convert::Into::into(#key_prop),
+                        )?;
+                        ::std::result::Result::Ok(inner.map(#key_type_name::#variant_name))
                     },
                 }
             }
@@ -263,13 +304,20 @@ impl<'a> EnumKeyInnerType<'a> {
                 let key_prop = keyfield.prop();
                 quote! {
                     {
-                        let inner = autosurgeon::reconcile::hydrate_key(doc, &#obj_id_ident, #prop.into(), #key_prop.into())?;
-                        Ok(inner.map(#key_type_name::#variant_name))
+                        let inner = ::autosurgeon::reconcile::hydrate_key(
+                            doc,
+                            &#obj_id_ident,
+                            ::std::convert::Into::into(#prop),
+                            ::std::convert::Into::into(#key_prop),
+                        )?;
+                        ::std::result::Result::Ok(inner.map(#key_type_name::#variant_name))
                     },
                 }
             }
             Self::NoInnerKeyStruct | Self::NoInnerKeyTuple => {
-                quote!(Ok(autosurgeon::reconcile::LoadKey::NoKey),)
+                quote!(::std::result::Result::Ok(
+                    ::autosurgeon::reconcile::LoadKey::NoKey,
+                ),)
             }
         }
     }
@@ -315,7 +363,9 @@ impl<'a> EnumKeyVariant<'a> {
             let name_str = self.name.to_string();
             let variant_name = quote!(#outer_name::#name);
             Some(quote! {
-                #name_str => Ok(autosurgeon::reconcile::LoadKey::Found(#variant_name)),
+                #name_str => ::std::result::Result::Ok(
+                    ::autosurgeon::reconcile::LoadKey::Found(#variant_name),
+                ),
             })
         } else {
             None
@@ -435,7 +485,7 @@ impl<'a> EnumKey<'a> {
         };
         let span = Span::mixed_site();
         Some(quote_spanned! {span=>
-            #[derive(Clone, PartialEq)]
+            #[derive(::std::clone::Clone, ::std::cmp::PartialEq)]
             #[allow(clippy::derive_partial_eq_without_eq)]
             #vis enum #name_with_lifetime {
                 #(#variant_defs),*
@@ -451,7 +501,7 @@ impl<'a> EnumKey<'a> {
         let variant_match_arms = self.variants.iter().map(|v| v.get_key_match_arm(&name));
         let k = syn::Lifetime::new("'k", Span::mixed_site());
         Some(quote! {
-            fn key<#k>(&#k self) -> autosurgeon::reconcile::LoadKey<Self::Key<#k>> {
+            fn key<#k>(&#k self) -> ::autosurgeon::reconcile::LoadKey<Self::Key<#k>> {
                 match self {
                     #(#variant_match_arms),*
                 }
@@ -478,39 +528,55 @@ impl<'a> EnumKey<'a> {
             .filter_map(|v| v.unit_match_arm(&key_type_name));
         let k = syn::Lifetime::new("'k", Span::mixed_site());
         Some(quote! {
-            fn hydrate_key<#k, D: autosurgeon::ReadDoc>(
+            fn hydrate_key<#k, D: ::autosurgeon::ReadDoc>(
                 doc: &D,
-                obj: &automerge::ObjId,
-                prop: autosurgeon::Prop<'_>,
-            ) -> Result<autosurgeon::reconcile::LoadKey<Self::Key<#k>>, autosurgeon::ReconcileError> {
-                use automerge::{ObjType, ScalarValue, Value, transaction::Transactable};
-                let Some((outer_ty, #outer_id_ident)) = doc.get(obj, &prop)? else {
-                    return Ok(autosurgeon::reconcile::LoadKey::KeyNotFound)
+                obj: &::automerge::ObjId,
+                prop: ::autosurgeon::Prop<'_>,
+            ) -> ::std::result::Result<
+                ::autosurgeon::reconcile::LoadKey<Self::Key<#k>>,
+                ::autosurgeon::ReconcileError,
+            > {
+                let ::std::option::Option::Some((
+                    outer_ty,
+                    #outer_id_ident,
+                )) = ::autosurgeon::ReadDoc::get(doc, obj, &prop)?
+                else {
+                    return ::std::result::Result::Ok(::autosurgeon::reconcile::LoadKey::KeyNotFound)
                 };
                 match outer_ty {
-                    Value::Scalar(s) => match s.as_ref() {
-                        ScalarValue::Str(s) => {
+                    ::automerge::Value::Scalar(s) => match ::std::convert::AsRef::as_ref(&s) {
+                        ::automerge::ScalarValue::Str(s) => {
                             match s.as_str() {
                                 #(#unit_match_arms)*
-                                _ => Ok(autosurgeon::reconcile::LoadKey::KeyNotFound)
+                                _ => ::std::result::Result::Ok(
+                                    ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                                )
                             }
                         },
-                        _ => Ok(autosurgeon::reconcile::LoadKey::KeyNotFound)
+                        _ => ::std::result::Result::Ok(
+                            ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                        )
                     },
-                    Value::Object(ObjType::Map) => {
-                        let Some(automerge::iter::MapRangeItem {
+                    ::automerge::Value::Object(::automerge::ObjType::Map) => {
+                        let ::std::option::Option::Some(::automerge::iter::MapRangeItem {
                             key: discriminant_str,
                             ..
-                        }) = doc.map_range(&#outer_id_ident, ..).next()
+                        }) = ::autosurgeon::ReadDoc::map_range(doc, &#outer_id_ident, ..).next()
                         else {
-                            return Ok(autosurgeon::reconcile::LoadKey::KeyNotFound);
+                            return ::std::result::Result::Ok(
+                                ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                            );
                         };
                         match discriminant_str {
                             #(#non_unit_match_arms)*
-                            _ => Ok(autosurgeon::reconcile::LoadKey::KeyNotFound),
+                            _ => ::std::result::Result::Ok(
+                                ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                            ),
                         }
                     },
-                    _ => Ok(autosurgeon::reconcile::LoadKey::KeyNotFound)
+                    _ => ::std::result::Result::Ok(
+                        ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                    )
                 }
             }
         })
@@ -769,32 +835,34 @@ fn enum_with_fields_variant<F: VariantWithFields>(
     let mut generics = generics.clone();
     generics
         .params
-        .push(syn::parse_quote! {'__reconcile_visitor});
+        .push(syn::parse_quote!('__reconcile_visitor));
 
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
     let variant_matcher = variant.variant_matcher(name, matchers);
 
     Ok(quote! {
         #variant_matcher => {
-            use autosurgeon::reconcile::{Reconciler, MapReconciler};
             struct #visitor_name #ty_generics
             #where_clause
             {
                 #(#field_defs),*
             }
-            impl #impl_generics autosurgeon::Reconcile for #visitor_name #ty_generics {
-                type Key<'k> = autosurgeon::reconcile::NoKey;
-                fn reconcile<__R234: autosurgeon::Reconciler>(&self, mut #inner_reconciler_ident: __R234) -> Result<(), __R234::Error> {
+            impl #impl_generics ::autosurgeon::Reconcile for #visitor_name #ty_generics {
+                type Key<'k> = ::autosurgeon::reconcile::NoKey;
+                fn reconcile<__R234: ::autosurgeon::Reconciler>(
+                    &self,
+                    mut #inner_reconciler_ident: __R234,
+                ) -> ::std::result::Result<(), __R234::Error> {
                     #inner_reconcile
                 }
             }
             let v = #visitor_name {
                 #(#constructors),*
             };
-            let mut m = #reconciler_ident.map()?;
-            m.retain(|k, _| k == #variant_name_str)?;
-            m.put(#variant_name_str, v)?;
-            Ok(())
+            let mut m = ::autosurgeon::Reconciler::map(&mut #reconciler_ident)?;
+            ::autosurgeon::reconcile::MapReconciler::retain(&mut m, |k, _| k == #variant_name_str)?;
+            ::autosurgeon::reconcile::MapReconciler::put(&mut m, #variant_name_str, v)?;
+            ::std::result::Result::Ok(())
         }
     })
 }
diff --git a/autosurgeon-derive/src/reconcile/field_wrapper.rs b/autosurgeon-derive/src/reconcile/field_wrapper.rs
index 33be311..34fc610 100644
--- a/autosurgeon-derive/src/reconcile/field_wrapper.rs
+++ b/autosurgeon-derive/src/reconcile/field_wrapper.rs
@@ -8,22 +8,28 @@ pub(crate) fn nokey_wrapper<T: ToTokens>(
 ) -> TokenStream {
     quote! {
         struct #wrapper_tyname<'a>(&'a #ty);
-        impl<'a> autosurgeon::Reconcile for #wrapper_tyname<'a> {
-            type Key<'k> = autosurgeon::reconcile::NoKey;
+        impl<'a> ::autosurgeon::Reconcile for #wrapper_tyname<'a> {
+            type Key<'k> = ::autosurgeon::reconcile::NoKey;
 
-            fn reconcile<R: autosurgeon::Reconciler>(&self, reconciler: R) -> Result<(), R::Error> {
+            fn reconcile<R: ::autosurgeon::Reconciler>(
+                &self,
+                reconciler: R,
+            ) -> ::std::result::Result<(), R::Error> {
                 #func(self.0, reconciler)
             }
 
-            fn hydrate_key<'b, D: autosurgeon::ReadDoc>(
+            fn hydrate_key<'b, D: ::autosurgeon::ReadDoc>(
                 _doc: &D,
-                _obj: &automerge::ObjId,
-                _prop: autosurgeon::Prop<'_>,
-            ) -> Result<autosurgeon::reconcile::LoadKey<Self::Key<'b>>, autosurgeon::reconcile::ReconcileError> {
-                Ok(autosurgeon::reconcile::LoadKey::NoKey)
+                _obj: &::automerge::ObjId,
+                _prop: ::autosurgeon::Prop<'_>,
+            ) -> Result<
+                ::autosurgeon::reconcile::LoadKey<Self::Key<'b>>,
+                ::autosurgeon::reconcile::ReconcileError,
+            > {
+                ::std::result::Result::Ok(::autosurgeon::reconcile::LoadKey::NoKey)
             }
-            fn key<'b>(&'b self) -> autosurgeon::reconcile::LoadKey<Self::Key<'b>> {
-                autosurgeon::reconcile::LoadKey::NoKey
+            fn key<'b>(&'b self) -> ::autosurgeon::reconcile::LoadKey<Self::Key<'b>> {
+                ::autosurgeon::reconcile::LoadKey::NoKey
             }
         }
     }
@@ -36,21 +42,27 @@ pub(crate) fn with_key_wrapper(
 ) -> TokenStream {
     quote! {
         struct #wrapper_tyname<'a>(&'a #ty);
-        impl<'a> autosurgeon::Reconcile for #wrapper_tyname<'a> {
+        impl<'a> ::autosurgeon::Reconcile for #wrapper_tyname<'a> {
             type Key<'k> = #module_name::Key<'k>;
 
-            fn reconcile<R: autosurgeon::Reconciler>(&self, reconciler: R) -> Result<(), R::Error> {
+            fn reconcile<R: ::autosurgeon::Reconciler>(
+                &self,
+                reconciler: R,
+            ) -> ::std::result::Result<(), R::Error> {
                 #module_name::reconcile(self.0, reconciler)
             }
 
-            fn hydrate_key<'b, D: autosurgeon::ReadDoc>(
+            fn hydrate_key<'b, D: ::autosurgeon::ReadDoc>(
                 doc: &D,
-                obj: &automerge::ObjId,
-                prop: autosurgeon::Prop<'_>,
-            ) -> Result<autosurgeon::reconcile::LoadKey<Self::Key<'b>>, autosurgeon::reconcile::ReconcileError> {
+                obj: &::automerge::ObjId,
+                prop: ::autosurgeon::Prop<'_>,
+            ) -> ::std::result::Result<
+                ::autosurgeon::reconcile::LoadKey<Self::Key<'b>>,
+                ::autosurgeon::reconcile::ReconcileError,
+            > {
                 #module_name::hydrate_key(doc, obj, prop)
             }
-            fn key<'b>(&'b self) -> autosurgeon::reconcile::LoadKey<Self::Key<'b>> {
+            fn key<'b>(&'b self) -> ::autosurgeon::reconcile::LoadKey<Self::Key<'b>> {
                 #module_name::key(self.0)
             }
         }
diff --git a/autosurgeon-derive/src/reconcile/struct_impl.rs b/autosurgeon-derive/src/reconcile/struct_impl.rs
index a7833e6..2c837b5 100644
--- a/autosurgeon-derive/src/reconcile/struct_impl.rs
+++ b/autosurgeon-derive/src/reconcile/struct_impl.rs
@@ -55,24 +55,44 @@ pub(super) trait Field {
             None => (quote!(), quote!(&#accessor)),
         };
         let get = match reconciler_ty {
-            ReconcilerType::Map => quote_spanned!(self.span()=> #reconciler_ident.entry(#prop)),
-            ReconcilerType::Seq => quote_spanned!(self.span()=> #reconciler_ident.get(#prop)?),
+            ReconcilerType::Map => quote_spanned! {self.span()=>
+                ::autosurgeon::reconcile::MapReconciler::entry(&#reconciler_ident, #prop)
+            },
+            ReconcilerType::Seq => quote_spanned! {self.span()=>
+                ::autosurgeon::reconcile::SeqReconciler::get(&#reconciler_ident, #prop)?
+            },
         };
         let insert = match reconciler_ty {
-            ReconcilerType::Seq => {
-                quote_spanned!(self.span()=> #reconciler_ident.insert(#prop, #value)?;)
-            }
-            ReconcilerType::Map => {
-                quote_spanned!(self.span()=> #reconciler_ident.put(#prop, #value)?;)
-            }
+            ReconcilerType::Seq => quote_spanned! {self.span()=>
+                ::autosurgeon::reconcile::SeqReconciler::insert(
+                    &mut #reconciler_ident,
+                    #prop,
+                    #value,
+                )?;
+            },
+            ReconcilerType::Map => quote_spanned! {self.span()=>
+                ::autosurgeon::reconcile::MapReconciler::put(
+                    &mut #reconciler_ident,
+                    #prop,
+                    #value,
+                )?;
+            },
         };
         let update = match reconciler_ty {
-            ReconcilerType::Seq => {
-                quote_spanned!(self.span()=> #reconciler_ident.set(#prop, #value)?;)
-            }
-            ReconcilerType::Map => {
-                quote_spanned!(self.span()=> #reconciler_ident.put(#prop, #value)?;)
-            }
+            ReconcilerType::Seq => quote_spanned! {self.span()=>
+                ::autosurgeon::reconcile::SeqReconciler::set(
+                    &mut #reconciler_ident,
+                    #prop,
+                    #value,
+                )?;
+            },
+            ReconcilerType::Map => quote_spanned! {self.span()=>
+                ::autosurgeon::reconcile::MapReconciler::put(
+                    &mut #reconciler_ident,
+                    #prop,
+                    #value,
+                )?;
+            },
         };
         quote! {
 
@@ -276,7 +296,7 @@ impl<'a, F: Field + Clone> KeyField<'a, F> {
         let ty = &self.ty;
         let lifetime = syn::Lifetime::new("'k", Span::mixed_site());
         quote! {
-            type Key<#lifetime> = std::borrow::Cow<#lifetime, #ty>;
+            type Key<#lifetime> = ::std::borrow::Cow<#lifetime, #ty>;
         }
     }
 
@@ -290,46 +310,88 @@ impl<'a, F: Field + Clone> KeyField<'a, F> {
         if let Some(hydrate_with) = self.field.hydrate_with() {
             let hydrate_func = hydrate_with.hydrate_with();
             quote! {
-                fn hydrate_key<#key_lifetime, D: autosurgeon::ReadDoc>(
+                fn hydrate_key<#key_lifetime, D: ::autosurgeon::ReadDoc>(
                     doc: &D,
-                    obj: &automerge::ObjId,
-                    prop: autosurgeon::Prop<'_>,
-                ) -> Result<autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>>, autosurgeon::ReconcileError> {
-                    use automerge::{ObjType, transaction::Transactable};
-                    use autosurgeon::{Prop, reconcile::LoadKey, hydrate::HydrateResultExt};
-                    let Some(outer_type) = doc.object_type(&obj) else {
-                        return Ok(LoadKey::KeyNotFound)
+                    obj: &::automerge::ObjId,
+                    prop: ::autosurgeon::Prop<'_>,
+                ) -> ::std::result::Result<
+                    ::autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>>,
+                    ::autosurgeon::ReconcileError,
+                > {
+                    let ::std::option::Option::Some(outer_type) =
+                        ::autosurgeon::ReadDoc::object_type(doc, &obj)
+                    else {
+                        return ::std::result::Result::Ok(
+                            ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                        )
                     };
                     let maybe_inner = match (outer_type, prop) {
-                        (ObjType::Map | ObjType::Table, Prop::Key(k)) => {
-                            doc.get(&obj, k.as_ref())?
-                        },
-                        (ObjType::List | ObjType::Text, Prop::Index(i)) => {
-                            doc.get(&obj, i as usize)?
-                        },
-                        _ => return Ok(LoadKey::KeyNotFound),
+                        (
+                            ::automerge::ObjType::Map | ::automerge::ObjType::Table,
+                            ::autosurgeon::Prop::Key(k)
+                        ) => ::autosurgeon::ReadDoc::get(
+                            doc,
+                            &obj,
+                            ::std::convert::AsRef::as_ref(&k),
+                        )?,
+                        (
+                            ::automerge::ObjType::List | ::automerge::ObjType::Text,
+                            ::autosurgeon::Prop::Index(i)
+                        ) => ::autosurgeon::ReadDoc::get(doc, &obj, i as ::std::primitive::usize)?,
+                        _ => return ::std::result::Result::Ok(
+                            ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                        ),
                     };
-                    let Some((_, inner_obj)) = maybe_inner else {
-                        return Ok(LoadKey::KeyNotFound)
+                    let ::std::option::Option::Some((_, inner_obj)) = maybe_inner else {
+                        return ::std::result::Result::Ok(
+                            ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                        )
                     };
-                    let Some(inner_type) = doc.object_type(&inner_obj) else {
-                        return Ok(LoadKey::KeyNotFound)
+                    let ::std::option::Option::Some(inner_type) =
+                        ::autosurgeon::ReadDoc::object_type(doc, &inner_obj)
+                    else {
+                        return ::std::result::Result::Ok(
+                            ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                        )
                     };
-                    let inner_val = match (inner_type, Prop::from(#key_prop)) {
-                        (ObjType::Map | ObjType::Table, Prop::Key(k)) => {
-                            doc.get(&inner_obj, k.as_ref())?
-                        },
-                        (ObjType::List | ObjType::Text, Prop::Index(i)) => {
-                            doc.get(&inner_obj, i as usize)?
-                        },
-                        _ => return Ok(LoadKey::KeyNotFound),
+                    let inner_val = match (inner_type, ::autosurgeon::Prop::from(#key_prop)) {
+                        (
+                            ::automerge::ObjType::Map | ::automerge::ObjType::Table,
+                            ::autosurgeon::Prop::Key(k)
+                        ) => ::autosurgeon::ReadDoc::get(
+                            doc,
+                            &inner_obj,
+                            ::std::convert::AsRef::as_ref(&k),
+                        )?,
+                        (
+                            ::automerge::ObjType::List | ::automerge::ObjType::Text,
+                            ::autosurgeon::Prop::Index(i)
+                        ) => ::autosurgeon::ReadDoc::get(
+                            doc,
+                            &inner_obj,
+                            i as ::std::primitive::usize,
+                        )?,
+                        _ => return ::std::result::Result::Ok(
+                            ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                        ),
                     };
                     if inner_val.is_none() {
-                        return Ok(LoadKey::KeyNotFound)
+                        return ::std::result::Result::Ok(
+                            ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                        )
                     } else {
-                        match #hydrate_func(doc, &inner_obj, #key_prop.into()).map(Some).strip_unexpected()? {
-                            Some(k) => Ok(LoadKey::Found(std::borrow::Cow::Owned(k))),
-                            None => Ok(LoadKey::KeyNotFound),
+                        match ::autosurgeon::hydrate::HydrateResultExt::strip_unexpected(
+                            #hydrate_func(doc, &inner_obj, ::std::convert::Into::into(#key_prop))
+                                .map(::std::option::Option::Some),
+                        )? {
+                            ::std::option::Option::Some(k) => ::std::result::Result::Ok(
+                                ::autosurgeon::reconcile::LoadKey::Found(
+                                    ::std::borrow::Cow::Owned(k),
+                                ),
+                            ),
+                            ::std::option::Option::None => ::std::result::Result::Ok(
+                                ::autosurgeon::reconcile::LoadKey::KeyNotFound,
+                            ),
                         }
                     }
 
@@ -337,12 +399,20 @@ impl<'a, F: Field + Clone> KeyField<'a, F> {
             }
         } else {
             quote! {
-                fn hydrate_key<#key_lifetime, D: autosurgeon::ReadDoc>(
+                fn hydrate_key<#key_lifetime, D: ::autosurgeon::ReadDoc>(
                     doc: &D,
-                    obj: &automerge::ObjId,
-                    prop: autosurgeon::Prop<'_>,
-                ) -> Result<autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>>, autosurgeon::ReconcileError> {
-                    autosurgeon::reconcile::hydrate_key::<_, std::borrow::Cow<'_, _>>(doc, obj, prop.into(), #key_prop.into())
+                    obj: &::automerge::ObjId,
+                    prop: ::autosurgeon::Prop<'_>,
+                ) -> ::std::result::Result<
+                    ::autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>>,
+                    ::autosurgeon::ReconcileError,
+                > {
+                    ::autosurgeon::reconcile::hydrate_key::<_, ::std::borrow::Cow<'_, _>>(
+                        doc,
+                        obj,
+                        ::std::convert::Into::into(prop),
+                        ::std::convert::Into::into(#key_prop),
+                    )
                 }
             }
         }
@@ -357,8 +427,10 @@ impl<'a, F: Field + Clone> KeyField<'a, F> {
         let get_key = self.field.accessor();
         let key_lifetime = syn::Lifetime::new("'k", Span::mixed_site());
         quote! {
-            fn key<#key_lifetime>(&#key_lifetime self) -> autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>> {
-                autosurgeon::reconcile::LoadKey::Found(std::borrow::Cow::Borrowed(&#get_key))
+            fn key<#key_lifetime>(
+                &#key_lifetime self,
+            ) -> ::autosurgeon::reconcile::LoadKey<Self::Key<#key_lifetime>> {
+                ::autosurgeon::reconcile::LoadKey::Found(::std::borrow::Cow::Borrowed(&#get_key))
             }
         }
     }
@@ -417,10 +489,9 @@ pub(super) fn named_field_impl<'a, F: TryInto<NamedFields<'a>, Error = DeriveErr
     } = struct_impl(fields, &inner_reconciler_ident, ReconcilerType::Map)?;
 
     let the_impl = quote! {
-        use autosurgeon::reconcile::MapReconciler;
-        let mut #inner_reconciler_ident = #reconciler_ident.map()?;
+        let mut #inner_reconciler_ident = ::autosurgeon::Reconciler::map(&mut #reconciler_ident)?;
         #( #field_impls)*
-        Ok(())
+        ::std::result::Result::Ok(())
     };
 
     Ok(ReconcileImpl {
@@ -481,10 +552,9 @@ pub(super) fn tuple_struct_impl<
     } = struct_impl(fields, &seq_reconciler_ident, ReconcilerType::Seq)?;
 
     let the_impl = quote! {
-        use autosurgeon::reconcile::SeqReconciler;
-        let mut #seq_reconciler_ident = #reconciler_ident.seq()?;
+        let mut #seq_reconciler_ident = ::autosurgeon::Reconciler::seq(&mut #reconciler_ident)?;
         #( #field_impls)*
-        Ok(())
+        ::std::result::Result::Ok(())
     };
 
     Ok(ReconcileImpl {