diff --git a/src/atomic.rs b/src/atomic.rs
index 63218eb..e588810 100644
--- a/src/atomic.rs
+++ b/src/atomic.rs
@@ -56,19 +56,19 @@ pub trait Atomic: AtomicModeParse {
     fn a_extend(self, tail: &[u8]) -> AParseResult<Self>;
 }
 
-fn _parse_slice<A: AtomicModeParse>(slice: &[u8]) -> AParseResult<A> {
+fn _parse_slice<A: Atomic>(slice: &[u8]) -> AParseResult<A> {
     let mut deserializer = SliceDeserializer::from(slice);
-    let atomic = A::seal(A::ma_deserialize(&mut deserializer)?);
+    let atomic = A::a_deserialize(&mut deserializer)?;
     let tail = deserializer.read_all();
     if tail.is_empty() {
         Ok(atomic)
     } else {
-        A::xseal(A::ma_extend(A::prepare(atomic), tail))
+        atomic.a_extend(tail)
     }
 }
 
 /// Extension trait to provide method-like utilities associated with [Atomic]s.
-pub trait AtomicExt: AtomicModeParse {
+pub trait AtomicExt: Atomic {
     /// Static equivalent of [`FactoryExt::parse_slice`].
     ///
     /// [`FactoryExt::parse_slice`]: crate::rcore::FactoryExt::parse_slice
diff --git a/src/mode.rs b/src/mode.rs
index 42027ef..bd4b071 100644
--- a/src/mode.rs
+++ b/src/mode.rs
@@ -29,8 +29,6 @@ pub use self::stream::{Stream, StreamExt, StreamResultExt};
 /// See [`ModeResult`].
 pub type ParseSuccess<M, A, I> = <M as Mode>::ParseSuccess<A, I>;
 
-pub type ParseSealed<M, A> = <M as Mode>::ParseSealed<A>;
-
 /// [`Mode`] equivalent of [`ParseResult`] for extension.
 ///
 /// [`ParseResult`]: crate::rcore::ParseResult
@@ -61,9 +59,6 @@ pub trait Mode {
     /// (`I`, usually [`Stream`]).
     type ParseSuccess<A, I>;
 
-    /// Parse success with parser discarded.
-    type ParseSealed<A>;
-
     /// Result of extending the value, failing sometimes or always.
     type ExtensionResult<A, E>;
 
@@ -145,9 +140,6 @@ pub trait ParseMode {
 /// [`ParseMode`] equivalent of [`ParseSuccess`].
 pub type ParseSuccessP<F, A, I> = ParseSuccess<<F as ParseMode>::Mode, A, I>;
 
-/// [`ParseMode`] equivalent of [`ParseSealed`].
-pub type ParseSealedP<F, A> = ParseSealed<<F as ParseMode>::Mode, A>;
-
 /// [`ParseMode`] equivalent of [`ExtensionResult`].
 pub type ExtensionResultP<F, A, E> = ExtensionResult<<F as ParseMode>::Mode, A, E>;
 
diff --git a/src/mode/inlining.rs b/src/mode/inlining.rs
index b064d81..a691e53 100644
--- a/src/mode/inlining.rs
+++ b/src/mode/inlining.rs
@@ -10,9 +10,6 @@ impl Mode for InliningMode {
     /// Keeps the parser.
     type ParseSuccess<A, I> = (A, I);
 
-    /// Keep value as is.
-    type ParseSealed<A> = A;
-
     /// Always fails.
     type ExtensionResult<A, E> = E;
 
diff --git a/src/mode/regular.rs b/src/mode/regular.rs
index 934cb61..74919ad 100644
--- a/src/mode/regular.rs
+++ b/src/mode/regular.rs
@@ -10,9 +10,6 @@ impl Mode for RegularMode {
     /// Discards the parser.
     type ParseSuccess<A, I> = A;
 
-    /// Keep value as is.
-    type ParseSealed<A> = A;
-
     /// Tries to extend the value.
     type ExtensionResult<A, E> = Result<A, E>;
 
diff --git a/src/rcore.rs b/src/rcore.rs
index 3ff4a11..0a17b18 100644
--- a/src/rcore.rs
+++ b/src/rcore.rs
@@ -136,7 +136,7 @@ pub type ParseError<'a, Ctx, F> = <F as FactoryBase<'a, Ctx>>::ParseError;
 pub type ParseErrorA<'a, Ctx, A> = ParseError<'a, Ctx, Fctr<'a, Ctx, A>>;
 
 /// Extension trait for factories.
-pub trait FactoryExt<'a, Ctx: Context<'a>>: FactoryModeParse<'a, Ctx> {
+pub trait FactoryExt<'a, Ctx: Context<'a>>: FactoryParse<'a, Ctx> {
     /// Parse the object from a slice.
     fn parse_slice(
         &self,
diff --git a/src/rcore/addresses.rs b/src/rcore/addresses.rs
index 7bf3ce1..1b69f55 100644
--- a/src/rcore/addresses.rs
+++ b/src/rcore/addresses.rs
@@ -55,26 +55,26 @@ pub(super) trait InliningAddresses<E>: Stream {
 
 impl<E, D: ?Sized + Stream> InliningAddresses<E> for D {}
 
-fn _parse_slice<'a, Ctx: Context<'a>, F: FactoryModeParse<'a, Ctx>>(
+fn _parse_slice<'a, Ctx: Context<'a>, F: FactoryParse<'a, Ctx>>(
     factory: &F,
     slice: &[u8],
     resolver: &Rc<dyn Resolver<'a, Ctx>>,
 ) -> ParseResult<'a, Ctx, F> {
     let mut deserializer = SliceDeserializer::from(slice);
-    let mentionable = F::seal(factory.mdeserialize(&mut DeCtxT {
+    let mentionable = factory.deserialize(&mut DeCtxT {
         deserializer: &mut deserializer,
         resolver,
         addresses: &mut Addresses::start(),
-    } as &mut dyn DeCtx<'a, Ctx>)?);
+    } as &mut dyn DeCtx<'a, Ctx>)?;
     let tail = deserializer.read_all();
     if tail.is_empty() {
         Ok(mentionable)
     } else {
-        F::xseal(factory.mextend(F::prepare(mentionable), tail))
+        factory.extend(mentionable, tail)
     }
 }
 
-impl<'a, Ctx: Context<'a>, F: FactoryModeParse<'a, Ctx>> FactoryExt<'a, Ctx> for F {
+impl<'a, Ctx: Context<'a>, F: FactoryParse<'a, Ctx>> FactoryExt<'a, Ctx> for F {
     fn parse_slice(
         &self,
         slice: &[u8],