diff --git a/macros/src/buffer.rs b/macros/src/buffer.rs
index d10d8711..4d716948 100644
--- a/macros/src/buffer.rs
+++ b/macros/src/buffer.rs
@@ -57,7 +57,7 @@ pub(crate) fn impl_joined_value(input_struct: &ItemStruct) -> Result<TokenStream
     let impl_joined = impl_joined(&buffer_struct, &input_struct, &field_ident)?;
 
     let gen = quote! {
-        impl #impl_generics ::bevy_impulse::JoinedValue for #struct_ident #ty_generics #where_clause {
+        impl #impl_generics ::bevy_impulse::Joined for #struct_ident #ty_generics #where_clause {
             type Buffers = #buffer_struct_ident #ty_generics;
         }
 
@@ -122,7 +122,7 @@ pub(crate) fn impl_buffer_key_map(input_struct: &ItemStruct) -> Result<TokenStre
     let impl_accessed = impl_accessed(&buffer_struct, &input_struct, &field_ident, &field_type)?;
 
     let gen = quote! {
-        impl #impl_generics ::bevy_impulse::BufferKeyMap for #struct_ident #ty_generics #where_clause {
+        impl #impl_generics ::bevy_impulse::Accessor for #struct_ident #ty_generics #where_clause {
             type Buffers = #buffer_struct_ident #ty_generics;
         }
 
@@ -413,8 +413,8 @@ fn impl_buffer_map_layout(
 }
 
 /// Params:
-///   joined_struct: The struct to implement `Joined`.
-///   item_struct: The associated `Item` type to use for the `Joined` implementation.
+///   joined_struct: The struct to implement `Joining`.
+///   item_struct: The associated `Item` type to use for the `Joining` implementation.
 fn impl_joined(
     joined_struct: &ItemStruct,
     item_struct: &ItemStruct,
@@ -425,7 +425,7 @@ fn impl_joined(
     let (impl_generics, ty_generics, where_clause) = item_struct.generics.split_for_impl();
 
     Ok(quote! {
-        impl #impl_generics ::bevy_impulse::Joined for #struct_ident #ty_generics #where_clause {
+        impl #impl_generics ::bevy_impulse::Joining for #struct_ident #ty_generics #where_clause {
             type Item = #item_struct_ident #ty_generics;
 
             fn pull(&self, session: ::bevy_impulse::re_exports::Entity, world: &mut ::bevy_impulse::re_exports::World) -> Result<Self::Item, ::bevy_impulse::OperationError> {
@@ -452,7 +452,7 @@ fn impl_accessed(
     let (impl_generics, ty_generics, where_clause) = key_struct.generics.split_for_impl();
 
     Ok(quote! {
-        impl #impl_generics ::bevy_impulse::Accessed for #struct_ident #ty_generics #where_clause {
+        impl #impl_generics ::bevy_impulse::Accessing for #struct_ident #ty_generics #where_clause {
             type Key = #key_struct_ident #ty_generics;
 
             fn add_accessor(
@@ -461,7 +461,7 @@ fn impl_accessed(
                 world: &mut ::bevy_impulse::re_exports::World,
             ) -> ::bevy_impulse::OperationResult {
                 #(
-                    ::bevy_impulse::Accessed::add_accessor(&self.#field_ident, accessor, world)?;
+                    ::bevy_impulse::Accessing::add_accessor(&self.#field_ident, accessor, world)?;
                 )*
                 Ok(())
             }
diff --git a/macros/src/lib.rs b/macros/src/lib.rs
index d63b8913..58873049 100644
--- a/macros/src/lib.rs
+++ b/macros/src/lib.rs
@@ -65,7 +65,7 @@ pub fn delivery_label_macro(item: TokenStream) -> TokenStream {
 /// The result error is the compiler error message to be displayed.
 type Result<T> = std::result::Result<T, String>;
 
-#[proc_macro_derive(JoinedValue, attributes(joined))]
+#[proc_macro_derive(Joined, attributes(joined))]
 pub fn derive_joined_value(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as ItemStruct);
     match impl_joined_value(&input) {
@@ -77,7 +77,7 @@ pub fn derive_joined_value(input: TokenStream) -> TokenStream {
     }
 }
 
-#[proc_macro_derive(BufferKeyMap, attributes(key))]
+#[proc_macro_derive(Accessor, attributes(key))]
 pub fn derive_buffer_key_map(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as ItemStruct);
     match impl_buffer_key_map(&input) {
diff --git a/src/buffer.rs b/src/buffer.rs
index 77baf5f1..1d33c28d 100644
--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -46,8 +46,8 @@ pub use buffer_map::*;
 mod buffer_storage;
 pub(crate) use buffer_storage::*;
 
-mod buffered;
-pub use buffered::*;
+mod buffering;
+pub use buffering::*;
 
 mod bufferable;
 pub use bufferable::*;
diff --git a/src/buffer/any_buffer.rs b/src/buffer/any_buffer.rs
index a7a4f2d2..3038c3a6 100644
--- a/src/buffer/any_buffer.rs
+++ b/src/buffer/any_buffer.rs
@@ -34,9 +34,9 @@ use thiserror::Error as ThisError;
 use smallvec::SmallVec;
 
 use crate::{
-    add_listener_to_source, Accessed, Buffer, BufferAccessMut, BufferAccessors, BufferError,
+    add_listener_to_source, Accessing, Buffer, BufferAccessMut, BufferAccessors, BufferError,
     BufferKey, BufferKeyBuilder, BufferKeyLifecycle, BufferKeyTag, BufferLocation, BufferStorage,
-    Bufferable, Buffered, Builder, DrainBuffer, Gate, GateState, InspectBuffer, Joined,
+    Bufferable, Buffering, Builder, DrainBuffer, Gate, GateState, InspectBuffer, Joining,
     ManageBuffer, NotifyBufferUpdate, OperationError, OperationResult, OperationRoster, OrBroken,
 };
 
@@ -1035,7 +1035,7 @@ impl Bufferable for AnyBuffer {
     }
 }
 
-impl Buffered for AnyBuffer {
+impl Buffering for AnyBuffer {
     fn verify_scope(&self, scope: Entity) {
         assert_eq!(scope, self.scope());
     }
@@ -1069,7 +1069,7 @@ impl Buffered for AnyBuffer {
     }
 }
 
-impl Joined for AnyBuffer {
+impl Joining for AnyBuffer {
     type Item = AnyMessageBox;
     fn pull(&self, session: Entity, world: &mut World) -> Result<Self::Item, OperationError> {
         let mut buffer_mut = world.get_entity_mut(self.id()).or_broken()?;
@@ -1077,7 +1077,7 @@ impl Joined for AnyBuffer {
     }
 }
 
-impl Accessed for AnyBuffer {
+impl Accessing for AnyBuffer {
     type Key = AnyBufferKey;
     fn add_accessor(&self, accessor: Entity, world: &mut World) -> OperationResult {
         world
diff --git a/src/buffer/buffer_map.rs b/src/buffer/buffer_map.rs
index 173ec1af..50a1d78a 100644
--- a/src/buffer/buffer_map.rs
+++ b/src/buffer/buffer_map.rs
@@ -24,12 +24,12 @@ use smallvec::SmallVec;
 use bevy_ecs::prelude::{Entity, World};
 
 use crate::{
-    add_listener_to_source, Accessed, AnyBuffer, AnyBufferKey, AnyMessageBox, AsAnyBuffer, Buffer,
-    BufferKeyBuilder, BufferKeyLifecycle, Bufferable, Buffered, Builder, Chain, Gate, GateState,
-    Joined, Node, OperationError, OperationResult, OperationRoster,
+    add_listener_to_source, Accessing, AnyBuffer, AnyBufferKey, AnyMessageBox, AsAnyBuffer, Buffer,
+    BufferKeyBuilder, BufferKeyLifecycle, Bufferable, Buffering, Builder, Chain, Gate, GateState,
+    Joining, Node, OperationError, OperationResult, OperationRoster,
 };
 
-pub use bevy_impulse_derive::{BufferKeyMap, JoinedValue};
+pub use bevy_impulse_derive::{Accessor, Joined};
 
 /// Uniquely identify a buffer within a buffer map, either by name or by an
 /// index value.
@@ -199,18 +199,18 @@ pub struct BufferIncompatibility {
 
 /// This trait can be implemented on structs that represent a layout of buffers.
 /// You do not normally have to implement this yourself. Instead you should
-/// `#[derive(JoinedValue)]` on a struct that you want a join operation to
+/// `#[derive(Joined)]` on a struct that you want a join operation to
 /// produce.
 pub trait BufferMapLayout: Sized + Clone + 'static + Send + Sync {
     /// Try to convert a generic [`BufferMap`] into this specific layout.
     fn try_from_buffer_map(buffers: &BufferMap) -> Result<Self, IncompatibleLayout>;
 }
 
-/// This trait helps auto-generated buffer map structs to implement the Buffered
+/// This trait helps auto-generated buffer map structs to implement the Buffering
 /// trait.
 pub trait BufferMapStruct: Sized + Clone + 'static + Send + Sync {
     /// Produce a list of the buffers that exist in this layout. Implementing
-    /// this function alone is sufficient to implement the entire [`Buffered`] trait.
+    /// this function alone is sufficient to implement the entire [`Buffering`] trait.
     fn buffer_list(&self) -> SmallVec<[AnyBuffer; 8]>;
 }
 
@@ -222,7 +222,7 @@ impl<T: BufferMapStruct> Bufferable for T {
     }
 }
 
-impl<T: BufferMapStruct> Buffered for T {
+impl<T: BufferMapStruct> Buffering for T {
     fn verify_scope(&self, scope: Entity) {
         for buffer in self.buffer_list() {
             assert_eq!(buffer.scope(), scope);
@@ -288,12 +288,12 @@ impl<T: BufferMapStruct> Buffered for T {
 /// Each field in this struct needs to have the trait bounds `'static + Send + Sync`.
 ///
 /// This does not generally need to be implemented explicitly. Instead you should
-/// use `#[derive(JoinedValue)]`:
+/// use `#[derive(Joined)]`:
 ///
 /// ```
 /// use bevy_impulse::prelude::*;
 ///
-/// #[derive(JoinedValue)]
+/// #[derive(Joined)]
 /// struct SomeValues {
 ///     integer: i64,
 ///     string: String,
@@ -312,7 +312,7 @@ impl<T: BufferMapStruct> Buffered for T {
 /// ```
 /// # use bevy_impulse::prelude::*;
 ///
-/// #[derive(JoinedValue)]
+/// #[derive(Joined)]
 /// #[joined(buffers_struct_name = SomeBuffers)]
 /// struct SomeValues {
 ///     integer: i64,
@@ -322,14 +322,14 @@ impl<T: BufferMapStruct> Buffered for T {
 ///
 /// By default each field of the generated buffers struct will have a type of
 /// [`Buffer<T>`], but you can override this using `#[joined(buffer = ...)]`
-/// to specify a special buffer type. For example if your `JoinedValue` struct
+/// to specify a special buffer type. For example if your `Joined` struct
 /// contains an [`AnyMessageBox`] then by default the macro will use `Buffer<AnyMessageBox>`,
 /// but you probably really want it to have an [`AnyBuffer`]:
 ///
 /// ```
 /// # use bevy_impulse::prelude::*;
 ///
-/// #[derive(JoinedValue)]
+/// #[derive(Joined)]
 /// struct SomeValues {
 ///     integer: i64,
 ///     string: String,
@@ -342,11 +342,11 @@ impl<T: BufferMapStruct> Buffered for T {
 ///
 /// [1]: crate::Builder::join
 /// [2]: crate::Builder::try_join
-pub trait JoinedValue: 'static + Send + Sync + Sized {
+pub trait Joined: 'static + Send + Sync + Sized {
     /// This associated type must represent a buffer map layout that implements
-    /// the [`Joined`] trait. The message type yielded by [`Joined`] for this
-    /// associated type must match the [`JoinedValue`] type.
-    type Buffers: 'static + BufferMapLayout + Joined<Item = Self> + Send + Sync;
+    /// the [`Joining`] trait. The message type yielded by [`Joining`] for this
+    /// associated type must match the [`Joined`] type.
+    type Buffers: 'static + BufferMapLayout + Joining<Item = Self> + Send + Sync;
 
     /// Used by [`Builder::try_join`]
     fn try_join_from<'w, 's, 'a, 'b>(
@@ -366,12 +366,12 @@ pub trait JoinedValue: 'static + Send + Sync + Sized {
 ///
 /// This does not generally need to be implemented explicitly. Instead you should
 /// define a struct where all fields are buffer keys and then apply
-/// `#[derive(BufferKeyMap)]` to it, e.g.:
+/// `#[derive(Accessor)]` to it, e.g.:
 ///
 /// ```
 /// use bevy_impulse::prelude::*;
 ///
-/// #[derive(Clone, BufferKeyMap)]
+/// #[derive(Clone, Accessor)]
 /// struct SomeKeys {
 ///     integer: BufferKey<i64>,
 ///     string: BufferKey<String>,
@@ -386,7 +386,7 @@ pub trait JoinedValue: 'static + Send + Sync + Sized {
 /// ```
 /// # use bevy_impulse::prelude::*;
 ///
-/// #[derive(Clone, BufferKeyMap)]
+/// #[derive(Clone, Accessor)]
 /// #[key(buffers_struct_name = SomeBuffers)]
 /// struct SomeKeys {
 ///     integer: BufferKey<i64>,
@@ -399,8 +399,8 @@ pub trait JoinedValue: 'static + Send + Sync + Sized {
 /// [2]: crate::Builder::create_buffer_access
 /// [3]: crate::Builder::try_listen
 /// [4]: crate::Builder::try_create_buffer_access
-pub trait BufferKeyMap: 'static + Send + Sync + Sized + Clone {
-    type Buffers: 'static + BufferMapLayout + Accessed<Key = Self> + Send + Sync;
+pub trait Accessor: 'static + Send + Sync + Sized + Clone {
+    type Buffers: 'static + BufferMapLayout + Accessing<Key = Self> + Send + Sync;
 
     fn try_listen_from<'w, 's, 'a, 'b>(
         buffers: &BufferMap,
@@ -431,7 +431,7 @@ impl BufferMapStruct for BufferMap {
     }
 }
 
-impl Joined for BufferMap {
+impl Joining for BufferMap {
     type Item = HashMap<BufferIdentifier<'static>, AnyMessageBox>;
 
     fn pull(&self, session: Entity, world: &mut World) -> Result<Self::Item, OperationError> {
@@ -444,11 +444,11 @@ impl Joined for BufferMap {
     }
 }
 
-impl JoinedValue for HashMap<BufferIdentifier<'static>, AnyMessageBox> {
+impl Joined for HashMap<BufferIdentifier<'static>, AnyMessageBox> {
     type Buffers = BufferMap;
 }
 
-impl Accessed for BufferMap {
+impl Accessing for BufferMap {
     type Key = HashMap<BufferIdentifier<'static>, AnyBufferKey>;
 
     fn create_key(&self, builder: &BufferKeyBuilder) -> Self::Key {
@@ -489,7 +489,7 @@ impl Accessed for BufferMap {
     }
 }
 
-impl<T: 'static + Send + Sync> JoinedValue for Vec<T> {
+impl<T: 'static + Send + Sync> Joined for Vec<T> {
     type Buffers = Vec<Buffer<T>>;
 }
 
@@ -508,7 +508,7 @@ impl<B: 'static + Send + Sync + AsAnyBuffer + Clone> BufferMapLayout for Vec<B>
     }
 }
 
-impl<T: 'static + Send + Sync, const N: usize> JoinedValue for SmallVec<[T; N]> {
+impl<T: 'static + Send + Sync, const N: usize> Joined for SmallVec<[T; N]> {
     type Buffers = SmallVec<[Buffer<T>; N]>;
 }
 
@@ -533,7 +533,7 @@ impl<B: 'static + Send + Sync + AsAnyBuffer + Clone, const N: usize> BufferMapLa
 mod tests {
     use crate::{prelude::*, testing::*, AddBufferToMap, BufferMap};
 
-    #[derive(JoinedValue)]
+    #[derive(Joined)]
     struct TestJoinedValue<T: Send + Sync + 'static + Clone> {
         integer: i64,
         float: f64,
@@ -640,7 +640,7 @@ mod tests {
         assert!(context.no_unhandled_errors());
     }
 
-    #[derive(Clone, JoinedValue)]
+    #[derive(Clone, Joined)]
     #[joined(buffers_struct_name = FooBuffers)]
     struct TestDeriveWithConfig {}
 
@@ -655,7 +655,7 @@ mod tests {
         u: U,
     }
 
-    #[derive(JoinedValue)]
+    #[derive(Joined)]
     #[joined(buffers_struct_name = MultiGenericBuffers)]
     struct JoinedMultiGenericValue<T: 'static + Send + Sync, U: 'static + Send + Sync> {
         #[joined(buffer = Buffer<MultiGenericValue<T, U>>)]
@@ -714,7 +714,7 @@ mod tests {
 
     /// We create this struct just to verify that it is able to compile despite
     /// NonCopyBuffer not being copyable.
-    #[derive(JoinedValue)]
+    #[derive(Joined)]
     #[allow(unused)]
     struct JoinedValueForNonCopyBuffer {
         #[joined(buffer = NonCopyBuffer<String>, noncopy_buffer)]
@@ -722,7 +722,7 @@ mod tests {
         _b: u32,
     }
 
-    #[derive(Clone, BufferKeyMap)]
+    #[derive(Clone, Accessor)]
     #[key(buffers_struct_name = TestKeysBuffers)]
     struct TestKeys<T: 'static + Send + Sync + Clone> {
         integer: BufferKey<i64>,
@@ -836,7 +836,7 @@ mod tests {
     /// This macro is a manual implementation of the join operation that uses
     /// the buffer listening mechanism. There isn't any reason to reimplement
     /// join here except so we can test that listening is working correctly for
-    /// BufferKeyMap.
+    /// Accessor.
     fn join_via_listen(
         In(keys): In<TestKeys<&'static str>>,
         world: &mut World,
diff --git a/src/buffer/bufferable.rs b/src/buffer/bufferable.rs
index 9b2a1549..daf55738 100644
--- a/src/buffer/bufferable.rs
+++ b/src/buffer/bufferable.rs
@@ -19,15 +19,15 @@ use bevy_utils::all_tuples;
 use smallvec::SmallVec;
 
 use crate::{
-    Accessed, AddOperation, Buffer, BufferSettings, Buffered, Builder, Chain, CloneFromBuffer,
-    Join, Joined, Output, UnusedTarget,
+    Accessing, AddOperation, Buffer, BufferSettings, Buffering, Builder, Chain, CloneFromBuffer,
+    Join, Joining, Output, UnusedTarget,
 };
 
-pub type BufferKeys<B> = <<B as Bufferable>::BufferType as Accessed>::Key;
-pub type JoinedItem<B> = <<B as Bufferable>::BufferType as Joined>::Item;
+pub type BufferKeys<B> = <<B as Bufferable>::BufferType as Accessing>::Key;
+pub type JoinedItem<B> = <<B as Bufferable>::BufferType as Joining>::Item;
 
 pub trait Bufferable {
-    type BufferType: Buffered;
+    type BufferType: Buffering;
 
     /// Convert these bufferable workflow elements into buffers if they are not
     /// buffers already.
@@ -74,7 +74,7 @@ pub trait Joinable: Bufferable {
 impl<B> Joinable for B
 where
     B: Bufferable,
-    B::BufferType: Joined,
+    B::BufferType: Joining,
 {
     type Item = JoinedItem<B>;
 
@@ -112,7 +112,7 @@ pub trait Accessible: Bufferable {
 impl<B> Accessible for B
 where
     B: Bufferable,
-    B::BufferType: Accessed,
+    B::BufferType: Accessing,
 {
     type Keys = BufferKeys<Self>;
 
@@ -160,7 +160,7 @@ impl<T: Bufferable> Bufferable for Vec<T> {
 }
 
 pub trait IterBufferable {
-    type BufferElement: Buffered + Joined;
+    type BufferElement: Buffering + Joining;
 
     /// Convert an iterable collection of bufferable workflow elements into
     /// buffers if they are not buffers already.
@@ -177,11 +177,11 @@ pub trait IterBufferable {
     fn join_vec<'w, 's, 'a, 'b, const N: usize>(
         self,
         builder: &'b mut Builder<'w, 's, 'a>,
-    ) -> Chain<'w, 's, 'a, 'b, SmallVec<[<Self::BufferElement as Joined>::Item; N]>>
+    ) -> Chain<'w, 's, 'a, 'b, SmallVec<[<Self::BufferElement as Joining>::Item; N]>>
     where
         Self: Sized,
         Self::BufferElement: 'static + Send + Sync,
-        <Self::BufferElement as Joined>::Item: 'static + Send + Sync,
+        <Self::BufferElement as Joining>::Item: 'static + Send + Sync,
     {
         let buffers = self.into_buffer_vec::<N>(builder);
         let join = builder.commands.spawn(()).id();
@@ -200,7 +200,7 @@ impl<T> IterBufferable for T
 where
     T: IntoIterator,
     T::Item: Bufferable,
-    <T::Item as Bufferable>::BufferType: Joined,
+    <T::Item as Bufferable>::BufferType: Joining,
 {
     type BufferElement = <T::Item as Bufferable>::BufferType;
 
diff --git a/src/buffer/buffered.rs b/src/buffer/buffering.rs
similarity index 94%
rename from src/buffer/buffered.rs
rename to src/buffer/buffering.rs
index 8f6912d0..81eea5f1 100644
--- a/src/buffer/buffered.rs
+++ b/src/buffer/buffering.rs
@@ -29,7 +29,7 @@ use crate::{
     ScopeSettings, SingleInputStorage, UnusedTarget,
 };
 
-pub trait Buffered: 'static + Send + Sync + Clone {
+pub trait Buffering: 'static + Send + Sync + Clone {
     fn verify_scope(&self, scope: Entity);
 
     fn buffered_count(&self, session: Entity, world: &World) -> Result<usize, OperationError>;
@@ -49,7 +49,7 @@ pub trait Buffered: 'static + Send + Sync + Clone {
     fn ensure_active_session(&self, session: Entity, world: &mut World) -> OperationResult;
 }
 
-pub trait Joined: Buffered {
+pub trait Joining: Buffering {
     type Item: 'static + Send + Sync;
     fn pull(&self, session: Entity, world: &mut World) -> Result<Self::Item, OperationError>;
 
@@ -58,7 +58,7 @@ pub trait Joined: Buffered {
     /// and join them into a tuple that gets sent to the target.
     ///
     /// If you need a more general way to get access to one or more buffers,
-    /// use [`listen`](Accessed::listen) instead.
+    /// use [`listen`](Accessing::listen) instead.
     fn join<'w, 's, 'a, 'b>(
         self,
         builder: &'b mut Builder<'w, 's, 'a>,
@@ -78,7 +78,7 @@ pub trait Joined: Buffered {
     }
 }
 
-pub trait Accessed: Buffered {
+pub trait Accessing: Buffering {
     type Key: 'static + Send + Sync + Clone;
     fn add_accessor(&self, accessor: Entity, world: &mut World) -> OperationResult;
     fn create_key(&self, builder: &BufferKeyBuilder) -> Self::Key;
@@ -91,7 +91,7 @@ pub trait Accessed: Buffered {
     /// operates on those buffers.
     ///
     /// For an operation that simply joins the contents of two or more outputs
-    /// or buffers, use [`join`](Joined::join) instead.
+    /// or buffers, use [`join`](Joining::join) instead.
     fn listen<'w, 's, 'a, 'b>(
         self,
         builder: &'b mut Builder<'w, 's, 'a>,
@@ -203,7 +203,7 @@ pub trait Accessed: Buffered {
     }
 }
 
-impl<T: 'static + Send + Sync> Buffered for Buffer<T> {
+impl<T: 'static + Send + Sync> Buffering for Buffer<T> {
     fn verify_scope(&self, scope: Entity) {
         assert_eq!(scope, self.scope());
     }
@@ -242,7 +242,7 @@ impl<T: 'static + Send + Sync> Buffered for Buffer<T> {
     }
 }
 
-impl<T: 'static + Send + Sync> Joined for Buffer<T> {
+impl<T: 'static + Send + Sync> Joining for Buffer<T> {
     type Item = T;
     fn pull(&self, session: Entity, world: &mut World) -> Result<Self::Item, OperationError> {
         world
@@ -252,7 +252,7 @@ impl<T: 'static + Send + Sync> Joined for Buffer<T> {
     }
 }
 
-impl<T: 'static + Send + Sync> Accessed for Buffer<T> {
+impl<T: 'static + Send + Sync> Accessing for Buffer<T> {
     type Key = BufferKey<T>;
     fn add_accessor(&self, accessor: Entity, world: &mut World) -> OperationResult {
         world
@@ -275,7 +275,7 @@ impl<T: 'static + Send + Sync> Accessed for Buffer<T> {
     }
 }
 
-impl<T: 'static + Send + Sync + Clone> Buffered for CloneFromBuffer<T> {
+impl<T: 'static + Send + Sync + Clone> Buffering for CloneFromBuffer<T> {
     fn verify_scope(&self, scope: Entity) {
         assert_eq!(scope, self.scope());
     }
@@ -313,7 +313,7 @@ impl<T: 'static + Send + Sync + Clone> Buffered for CloneFromBuffer<T> {
     }
 }
 
-impl<T: 'static + Send + Sync + Clone> Joined for CloneFromBuffer<T> {
+impl<T: 'static + Send + Sync + Clone> Joining for CloneFromBuffer<T> {
     type Item = T;
     fn pull(&self, session: Entity, world: &mut World) -> Result<Self::Item, OperationError> {
         world
@@ -324,7 +324,7 @@ impl<T: 'static + Send + Sync + Clone> Joined for CloneFromBuffer<T> {
     }
 }
 
-impl<T: 'static + Send + Sync + Clone> Accessed for CloneFromBuffer<T> {
+impl<T: 'static + Send + Sync + Clone> Accessing for CloneFromBuffer<T> {
     type Key = BufferKey<T>;
     fn add_accessor(&self, accessor: Entity, world: &mut World) -> OperationResult {
         world
@@ -350,7 +350,7 @@ impl<T: 'static + Send + Sync + Clone> Accessed for CloneFromBuffer<T> {
 macro_rules! impl_buffered_for_tuple {
     ($(($T:ident, $K:ident)),*) => {
         #[allow(non_snake_case)]
-        impl<$($T: Buffered),*> Buffered for ($($T,)*)
+        impl<$($T: Buffering),*> Buffering for ($($T,)*)
         {
             fn verify_scope(&self, scope: Entity) {
                 let ($($T,)*) = self;
@@ -421,7 +421,7 @@ macro_rules! impl_buffered_for_tuple {
         }
 
         #[allow(non_snake_case)]
-        impl<$($T: Joined),*> Joined for ($($T,)*)
+        impl<$($T: Joining),*> Joining for ($($T,)*)
         {
             type Item = ($($T::Item),*);
             fn pull(
@@ -437,7 +437,7 @@ macro_rules! impl_buffered_for_tuple {
         }
 
         #[allow(non_snake_case)]
-        impl<$($T: Accessed),*> Accessed for ($($T,)*)
+        impl<$($T: Accessing),*> Accessing for ($($T,)*)
         {
             type Key = ($($T::Key), *);
             fn add_accessor(
@@ -479,11 +479,11 @@ macro_rules! impl_buffered_for_tuple {
     }
 }
 
-// Implements the `Buffered` trait for all tuples between size 2 and 12
-// (inclusive) made of types that implement `Buffered`
+// Implements the `Buffering` trait for all tuples between size 2 and 12
+// (inclusive) made of types that implement `Buffering`
 all_tuples!(impl_buffered_for_tuple, 2, 12, T, K);
 
-impl<T: Buffered, const N: usize> Buffered for [T; N] {
+impl<T: Buffering, const N: usize> Buffering for [T; N] {
     fn verify_scope(&self, scope: Entity) {
         for buffer in self.iter() {
             buffer.verify_scope(scope);
@@ -535,7 +535,7 @@ impl<T: Buffered, const N: usize> Buffered for [T; N] {
     }
 }
 
-impl<T: Joined, const N: usize> Joined for [T; N] {
+impl<T: Joining, const N: usize> Joining for [T; N] {
     // TODO(@mxgrey) We may be able to use [T::Item; N] here instead of SmallVec
     // when try_map is stabilized: https://github.com/rust-lang/rust/issues/79711
     type Item = SmallVec<[T::Item; N]>;
@@ -546,7 +546,7 @@ impl<T: Joined, const N: usize> Joined for [T; N] {
     }
 }
 
-impl<T: Accessed, const N: usize> Accessed for [T; N] {
+impl<T: Accessing, const N: usize> Accessing for [T; N] {
     type Key = SmallVec<[T::Key; N]>;
     fn add_accessor(&self, accessor: Entity, world: &mut World) -> OperationResult {
         for buffer in self {
@@ -582,7 +582,7 @@ impl<T: Accessed, const N: usize> Accessed for [T; N] {
     }
 }
 
-impl<T: Buffered, const N: usize> Buffered for SmallVec<[T; N]> {
+impl<T: Buffering, const N: usize> Buffering for SmallVec<[T; N]> {
     fn verify_scope(&self, scope: Entity) {
         for buffer in self.iter() {
             buffer.verify_scope(scope);
@@ -634,7 +634,7 @@ impl<T: Buffered, const N: usize> Buffered for SmallVec<[T; N]> {
     }
 }
 
-impl<T: Joined, const N: usize> Joined for SmallVec<[T; N]> {
+impl<T: Joining, const N: usize> Joining for SmallVec<[T; N]> {
     type Item = SmallVec<[T::Item; N]>;
     fn pull(&self, session: Entity, world: &mut World) -> Result<Self::Item, OperationError> {
         self.iter()
@@ -643,7 +643,7 @@ impl<T: Joined, const N: usize> Joined for SmallVec<[T; N]> {
     }
 }
 
-impl<T: Accessed, const N: usize> Accessed for SmallVec<[T; N]> {
+impl<T: Accessing, const N: usize> Accessing for SmallVec<[T; N]> {
     type Key = SmallVec<[T::Key; N]>;
     fn add_accessor(&self, accessor: Entity, world: &mut World) -> OperationResult {
         for buffer in self {
@@ -679,7 +679,7 @@ impl<T: Accessed, const N: usize> Accessed for SmallVec<[T; N]> {
     }
 }
 
-impl<B: Buffered> Buffered for Vec<B> {
+impl<B: Buffering> Buffering for Vec<B> {
     fn verify_scope(&self, scope: Entity) {
         for buffer in self {
             buffer.verify_scope(scope);
@@ -731,7 +731,7 @@ impl<B: Buffered> Buffered for Vec<B> {
     }
 }
 
-impl<B: Joined> Joined for Vec<B> {
+impl<B: Joining> Joining for Vec<B> {
     type Item = Vec<B::Item>;
     fn pull(&self, session: Entity, world: &mut World) -> Result<Self::Item, OperationError> {
         self.iter()
@@ -740,7 +740,7 @@ impl<B: Joined> Joined for Vec<B> {
     }
 }
 
-impl<B: Accessed> Accessed for Vec<B> {
+impl<B: Accessing> Accessing for Vec<B> {
     type Key = Vec<B::Key>;
     fn add_accessor(&self, accessor: Entity, world: &mut World) -> OperationResult {
         for buffer in self {
diff --git a/src/buffer/json_buffer.rs b/src/buffer/json_buffer.rs
index 80d768c4..9a9a5879 100644
--- a/src/buffer/json_buffer.rs
+++ b/src/buffer/json_buffer.rs
@@ -36,11 +36,11 @@ pub use serde_json::Value as JsonMessage;
 use smallvec::SmallVec;
 
 use crate::{
-    add_listener_to_source, Accessed, AnyBuffer, AnyBufferAccessInterface, AnyBufferKey, AnyRange,
+    add_listener_to_source, Accessing, AnyBuffer, AnyBufferAccessInterface, AnyBufferKey, AnyRange,
     AsAnyBuffer, Buffer, BufferAccessMut, BufferAccessors, BufferError, BufferIdentifier,
     BufferKey, BufferKeyBuilder, BufferKeyLifecycle, BufferKeyTag, BufferLocation, BufferMap,
-    BufferMapLayout, BufferMapStruct, BufferStorage, Bufferable, Buffered, Builder, DrainBuffer,
-    Gate, GateState, IncompatibleLayout, InspectBuffer, Joined, JoinedValue, ManageBuffer,
+    BufferMapLayout, BufferMapStruct, BufferStorage, Bufferable, Buffering, Builder, DrainBuffer,
+    Gate, GateState, IncompatibleLayout, InspectBuffer, Joined, Joining, ManageBuffer,
     NotifyBufferUpdate, OperationError, OperationResult, OrBroken,
 };
 
@@ -988,7 +988,7 @@ impl Bufferable for JsonBuffer {
     }
 }
 
-impl Buffered for JsonBuffer {
+impl Buffering for JsonBuffer {
     fn verify_scope(&self, scope: Entity) {
         assert_eq!(scope, self.scope());
     }
@@ -1022,7 +1022,7 @@ impl Buffered for JsonBuffer {
     }
 }
 
-impl Joined for JsonBuffer {
+impl Joining for JsonBuffer {
     type Item = JsonMessage;
     fn pull(&self, session: Entity, world: &mut World) -> Result<Self::Item, OperationError> {
         let mut buffer_mut = world.get_entity_mut(self.id()).or_broken()?;
@@ -1030,7 +1030,7 @@ impl Joined for JsonBuffer {
     }
 }
 
-impl Accessed for JsonBuffer {
+impl Accessing for JsonBuffer {
     type Key = JsonBufferKey;
     fn add_accessor(&self, accessor: Entity, world: &mut World) -> OperationResult {
         world
@@ -1056,7 +1056,7 @@ impl Accessed for JsonBuffer {
     }
 }
 
-impl JoinedValue for serde_json::Map<String, JsonMessage> {
+impl Joined for serde_json::Map<String, JsonMessage> {
     type Buffers = HashMap<String, JsonBuffer>;
 }
 
@@ -1092,7 +1092,7 @@ impl BufferMapStruct for HashMap<String, JsonBuffer> {
     }
 }
 
-impl Joined for HashMap<String, JsonBuffer> {
+impl Joining for HashMap<String, JsonBuffer> {
     type Item = serde_json::Map<String, JsonMessage>;
     fn pull(&self, session: Entity, world: &mut World) -> Result<Self::Item, OperationError> {
         self.iter()
@@ -1411,7 +1411,7 @@ mod tests {
         assert!(context.no_unhandled_errors());
     }
 
-    #[derive(Clone, JoinedValue)]
+    #[derive(Clone, Joined)]
     #[joined(buffers_struct_name = TestJoinedValueJsonBuffers)]
     struct TestJoinedValueJson {
         integer: i64,
@@ -1582,9 +1582,9 @@ mod tests {
         assert_eq!(values[3], serde_json::to_value(TestMessage::new()).unwrap());
     }
 
-    // We define this struct just to make sure the BufferKeyMap macro successfully
+    // We define this struct just to make sure the Accessor macro successfully
     // compiles with JsonBufferKey.
-    #[derive(Clone, BufferKeyMap)]
+    #[derive(Clone, Accessor)]
     #[allow(unused)]
     struct TestJsonKeyMap {
         integer: BufferKey<i64>,
diff --git a/src/builder.rs b/src/builder.rs
index ba38568e..45727868 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -22,10 +22,10 @@ use std::future::Future;
 use smallvec::SmallVec;
 
 use crate::{
-    Accessed, Accessible, AddOperation, AsMap, Buffer, BufferKeyMap, BufferKeys, BufferLocation,
-    BufferMap, BufferSettings, Bufferable, Buffered, Chain, Collect, ForkClone, ForkCloneOutput,
+    Accessible, Accessing, Accessor, AddOperation, AsMap, Buffer, BufferKeys, BufferLocation,
+    BufferMap, BufferSettings, Bufferable, Buffering, Chain, Collect, ForkClone, ForkCloneOutput,
     ForkTargetStorage, Gate, GateRequest, IncompatibleLayout, Injection, InputSlot, IntoAsyncMap,
-    IntoBlockingMap, Joinable, JoinedValue, Node, OperateBuffer, OperateDynamicGate, OperateScope,
+    IntoBlockingMap, Joinable, Joined, Node, OperateBuffer, OperateDynamicGate, OperateScope,
     OperateSplit, OperateStaticGate, Output, Provider, RequestOfMap, ResponseOfMap, Scope,
     ScopeEndpoints, ScopeSettings, ScopeSettingsStorage, Sendish, Service, SplitOutputs,
     Splittable, StreamPack, StreamTargetMap, StreamsOfMap, Trim, TrimBranch, UnusedTarget,
@@ -237,11 +237,11 @@ impl<'w, 's, 'a> Builder<'w, 's, 'a> {
     }
 
     /// Try joining a map of buffers into a single value.
-    pub fn try_join<'b, Joined: JoinedValue>(
+    pub fn try_join<'b, J: Joined>(
         &'b mut self,
         buffers: &BufferMap,
-    ) -> Result<Chain<'w, 's, 'a, 'b, Joined>, IncompatibleLayout> {
-        Joined::try_join_from(buffers, self)
+    ) -> Result<Chain<'w, 's, 'a, 'b, J>, IncompatibleLayout> {
+        J::try_join_from(buffers, self)
     }
 
     /// Alternative way of calling [`Accessible::listen`].
@@ -250,7 +250,7 @@ impl<'w, 's, 'a> Builder<'w, 's, 'a> {
     }
 
     /// Try listening to a map of buffers.
-    pub fn try_listen<'b, Keys: BufferKeyMap>(
+    pub fn try_listen<'b, Keys: Accessor>(
         &'b mut self,
         buffers: &BufferMap,
     ) -> Result<Chain<'w, 's, 'a, 'b, Keys>, IncompatibleLayout> {
@@ -269,7 +269,7 @@ impl<'w, 's, 'a> Builder<'w, 's, 'a> {
         buffers: B,
     ) -> Node<T, (T, BufferKeys<B>)>
     where
-        B::BufferType: Accessed,
+        B::BufferType: Accessing,
         T: 'static + Send + Sync,
     {
         let buffers = buffers.into_buffer(self);
@@ -279,7 +279,7 @@ impl<'w, 's, 'a> Builder<'w, 's, 'a> {
     /// Try to create access to some buffers. Same as [`Self::create_buffer_access`]
     /// except it will return an error if the buffers in the [`BufferMap`] are not
     /// compatible with the keys that are being asked for.
-    pub fn try_create_buffer_access<T, Keys: BufferKeyMap>(
+    pub fn try_create_buffer_access<T, Keys: Accessor>(
         &mut self,
         buffers: &BufferMap,
     ) -> Result<Node<T, (T, Keys)>, IncompatibleLayout>
@@ -393,7 +393,7 @@ impl<'w, 's, 'a> Builder<'w, 's, 'a> {
         build: impl FnOnce(Scope<BufferKeys<B>, (), ()>, &mut Builder) -> Settings,
     ) where
         B: Bufferable,
-        B::BufferType: Accessed,
+        B::BufferType: Accessing,
         Settings: Into<ScopeSettings>,
     {
         from_buffers.into_buffer(self).on_cleanup(self, build);
@@ -418,7 +418,7 @@ impl<'w, 's, 'a> Builder<'w, 's, 'a> {
         build: impl FnOnce(Scope<BufferKeys<B>, (), ()>, &mut Builder) -> Settings,
     ) where
         B: Bufferable,
-        B::BufferType: Accessed,
+        B::BufferType: Accessing,
         Settings: Into<ScopeSettings>,
     {
         from_buffers.into_buffer(self).on_cancel(self, build);
@@ -437,7 +437,7 @@ impl<'w, 's, 'a> Builder<'w, 's, 'a> {
         build: impl FnOnce(Scope<BufferKeys<B>, (), ()>, &mut Builder) -> Settings,
     ) where
         B: Bufferable,
-        B::BufferType: Accessed,
+        B::BufferType: Accessing,
         Settings: Into<ScopeSettings>,
     {
         from_buffers.into_buffer(self).on_terminate(self, build);
@@ -453,7 +453,7 @@ impl<'w, 's, 'a> Builder<'w, 's, 'a> {
         build: impl FnOnce(Scope<BufferKeys<B>, (), ()>, &mut Builder) -> Settings,
     ) where
         B: Bufferable,
-        B::BufferType: Accessed,
+        B::BufferType: Accessing,
         Settings: Into<ScopeSettings>,
     {
         from_buffers
diff --git a/src/chain.rs b/src/chain.rs
index 218ed243..fbdee9f6 100644
--- a/src/chain.rs
+++ b/src/chain.rs
@@ -24,12 +24,12 @@ use smallvec::SmallVec;
 use std::error::Error;
 
 use crate::{
-    make_option_branching, make_result_branching, Accessed, AddOperation, AsMap, Buffer, BufferKey,
-    BufferKeys, Bufferable, Buffered, Builder, Collect, CreateCancelFilter, CreateDisposalFilter,
-    ForkTargetStorage, Gate, GateRequest, InputSlot, IntoAsyncMap, IntoBlockingCallback,
-    IntoBlockingMap, Node, Noop, OperateBufferAccess, OperateDynamicGate, OperateSplit,
-    OperateStaticGate, Output, ProvideOnce, Provider, Scope, ScopeSettings, Sendish, Service,
-    Spread, StreamOf, StreamPack, StreamTargetMap, Trim, TrimBranch, UnusedTarget,
+    make_option_branching, make_result_branching, Accessing, AddOperation, AsMap, Buffer,
+    BufferKey, BufferKeys, Bufferable, Buffering, Builder, Collect, CreateCancelFilter,
+    CreateDisposalFilter, ForkTargetStorage, Gate, GateRequest, InputSlot, IntoAsyncMap,
+    IntoBlockingCallback, IntoBlockingMap, Node, Noop, OperateBufferAccess, OperateDynamicGate,
+    OperateSplit, OperateStaticGate, Output, ProvideOnce, Provider, Scope, ScopeSettings, Sendish,
+    Service, Spread, StreamOf, StreamPack, StreamTargetMap, Trim, TrimBranch, UnusedTarget,
 };
 
 pub mod fork_clone_builder;
@@ -302,7 +302,7 @@ impl<'w, 's, 'a, 'b, T: 'static + Send + Sync> Chain<'w, 's, 'a, 'b, T> {
     pub fn with_access<B>(self, buffers: B) -> Chain<'w, 's, 'a, 'b, (T, BufferKeys<B>)>
     where
         B: Bufferable,
-        B::BufferType: Accessed,
+        B::BufferType: Accessing,
     {
         let buffers = buffers.into_buffer(self.builder);
         buffers.verify_scope(self.builder.scope);
@@ -323,7 +323,7 @@ impl<'w, 's, 'a, 'b, T: 'static + Send + Sync> Chain<'w, 's, 'a, 'b, T> {
     pub fn then_access<B>(self, buffers: B) -> Chain<'w, 's, 'a, 'b, BufferKeys<B>>
     where
         B: Bufferable,
-        B::BufferType: Accessed,
+        B::BufferType: Accessing,
     {
         self.with_access(buffers).map_block(|(_, key)| key)
     }
diff --git a/src/lib.rs b/src/lib.rs
index 47213e8c..ceab07f2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -340,10 +340,10 @@ impl Plugin for ImpulsePlugin {
 pub mod prelude {
     pub use crate::{
         buffer::{
-            Accessible, AnyBuffer, AnyBufferKey, AnyBufferMut, AnyBufferWorldAccess, AnyMessageBox,
-            AsAnyBuffer, Buffer, BufferAccess, BufferAccessMut, BufferKey, BufferKeyMap, BufferMap,
-            BufferMapLayout, BufferSettings, BufferWorldAccess, Bufferable, Buffered,
-            IncompatibleLayout, IterBufferable, Joinable, JoinedValue, RetentionPolicy,
+            Accessible, Accessor, AnyBuffer, AnyBufferKey, AnyBufferMut, AnyBufferWorldAccess,
+            AnyMessageBox, AsAnyBuffer, Buffer, BufferAccess, BufferAccessMut, BufferKey,
+            BufferMap, BufferMapLayout, BufferSettings, BufferWorldAccess, Bufferable, Buffering,
+            IncompatibleLayout, IterBufferable, Joinable, Joined, RetentionPolicy,
         },
         builder::Builder,
         callback::{AsCallback, Callback, IntoAsyncCallback, IntoBlockingCallback},
diff --git a/src/operation/cleanup.rs b/src/operation/cleanup.rs
index 6c11c72b..8bac864e 100644
--- a/src/operation/cleanup.rs
+++ b/src/operation/cleanup.rs
@@ -16,7 +16,7 @@
 */
 
 use crate::{
-    Accessed, BufferAccessStorage, ManageDisposal, ManageInput, MiscellaneousFailure,
+    Accessing, BufferAccessStorage, ManageDisposal, ManageInput, MiscellaneousFailure,
     OperationError, OperationResult, OperationRoster, OrBroken, ScopeStorage, UnhandledErrors,
 };
 
@@ -98,7 +98,7 @@ impl<'a> OperationCleanup<'a> {
 
     pub fn cleanup_buffer_access<B>(&mut self) -> OperationResult
     where
-        B: Accessed + 'static + Send + Sync,
+        B: Accessing + 'static + Send + Sync,
         B::Key: 'static + Send + Sync,
     {
         let scope = self
diff --git a/src/operation/join.rs b/src/operation/join.rs
index 3bd8bafd..314e64b8 100644
--- a/src/operation/join.rs
+++ b/src/operation/join.rs
@@ -18,7 +18,7 @@
 use bevy_ecs::prelude::{Component, Entity};
 
 use crate::{
-    FunnelInputStorage, Input, InputBundle, Joined, ManageInput, Operation, OperationCleanup,
+    FunnelInputStorage, Input, InputBundle, Joining, ManageInput, Operation, OperationCleanup,
     OperationError, OperationReachability, OperationRequest, OperationResult, OperationSetup,
     OrBroken, ReachabilityResult, SingleInputStorage, SingleTargetStorage,
 };
@@ -37,7 +37,7 @@ impl<Buffers> Join<Buffers> {
 #[derive(Component)]
 struct BufferStorage<Buffers>(Buffers);
 
-impl<Buffers: Joined + 'static + Send + Sync> Operation for Join<Buffers>
+impl<Buffers: Joining + 'static + Send + Sync> Operation for Join<Buffers>
 where
     Buffers::Item: 'static + Send + Sync,
 {
diff --git a/src/operation/listen.rs b/src/operation/listen.rs
index 85561c2a..378fe9f5 100644
--- a/src/operation/listen.rs
+++ b/src/operation/listen.rs
@@ -18,7 +18,7 @@
 use bevy_ecs::prelude::Entity;
 
 use crate::{
-    buffer_key_usage, get_access_keys, Accessed, BufferAccessStorage, BufferKeyUsage,
+    buffer_key_usage, get_access_keys, Accessing, BufferAccessStorage, BufferKeyUsage,
     FunnelInputStorage, Input, InputBundle, ManageInput, Operation, OperationCleanup,
     OperationReachability, OperationRequest, OperationResult, OperationSetup, OrBroken,
     ReachabilityResult, SingleInputStorage, SingleTargetStorage,
@@ -37,7 +37,7 @@ impl<B> Listen<B> {
 
 impl<B> Operation for Listen<B>
 where
-    B: Accessed + 'static + Send + Sync,
+    B: Accessing + 'static + Send + Sync,
     B::Key: 'static + Send + Sync,
 {
     fn setup(self, OperationSetup { source, world }: OperationSetup) -> OperationResult {
diff --git a/src/operation/operate_buffer_access.rs b/src/operation/operate_buffer_access.rs
index c4cf0cb3..07208410 100644
--- a/src/operation/operate_buffer_access.rs
+++ b/src/operation/operate_buffer_access.rs
@@ -25,7 +25,7 @@ use std::{
 use smallvec::SmallVec;
 
 use crate::{
-    Accessed, BufferKeyBuilder, ChannelQueue, Input, InputBundle, ManageInput, Operation,
+    Accessing, BufferKeyBuilder, ChannelQueue, Input, InputBundle, ManageInput, Operation,
     OperationCleanup, OperationError, OperationReachability, OperationRequest, OperationResult,
     OperationSetup, OrBroken, ReachabilityResult, ScopeStorage, SingleInputStorage,
     SingleTargetStorage,
@@ -34,7 +34,7 @@ use crate::{
 pub(crate) struct OperateBufferAccess<T, B>
 where
     T: 'static + Send + Sync,
-    B: Accessed,
+    B: Accessing,
 {
     buffers: B,
     target: Entity,
@@ -44,7 +44,7 @@ where
 impl<T, B> OperateBufferAccess<T, B>
 where
     T: 'static + Send + Sync,
-    B: Accessed,
+    B: Accessing,
 {
     pub(crate) fn new(buffers: B, target: Entity) -> Self {
         Self {
@@ -59,12 +59,12 @@ where
 pub struct BufferKeyUsage(pub(crate) fn(Entity, Entity, &World) -> ReachabilityResult);
 
 #[derive(Component)]
-pub(crate) struct BufferAccessStorage<B: Accessed> {
+pub(crate) struct BufferAccessStorage<B: Accessing> {
     pub(crate) buffers: B,
     pub(crate) keys: HashMap<Entity, B::Key>,
 }
 
-impl<B: Accessed> BufferAccessStorage<B> {
+impl<B: Accessing> BufferAccessStorage<B> {
     pub(crate) fn new(buffers: B) -> Self {
         Self {
             buffers,
@@ -76,7 +76,7 @@ impl<B: Accessed> BufferAccessStorage<B> {
 impl<T, B> Operation for OperateBufferAccess<T, B>
 where
     T: 'static + Send + Sync,
-    B: Accessed + 'static + Send + Sync,
+    B: Accessing + 'static + Send + Sync,
     B::Key: 'static + Send + Sync,
 {
     fn setup(self, OperationSetup { source, world }: OperationSetup) -> OperationResult {
@@ -138,7 +138,7 @@ pub(crate) fn get_access_keys<B>(
     world: &mut World,
 ) -> Result<B::Key, OperationError>
 where
-    B: Accessed + 'static + Send + Sync,
+    B: Accessing + 'static + Send + Sync,
     B::Key: 'static + Send + Sync,
 {
     let scope = world.get::<ScopeStorage>(source).or_broken()?.get();
@@ -180,7 +180,7 @@ pub(crate) fn buffer_key_usage<B>(
     world: &World,
 ) -> ReachabilityResult
 where
-    B: Accessed + 'static + Send + Sync,
+    B: Accessing + 'static + Send + Sync,
     B::Key: 'static + Send + Sync,
 {
     let key = world
diff --git a/src/operation/operate_gate.rs b/src/operation/operate_gate.rs
index 9a677e37..0a45d449 100644
--- a/src/operation/operate_gate.rs
+++ b/src/operation/operate_gate.rs
@@ -18,7 +18,7 @@
 use bevy_ecs::prelude::{Component, Entity};
 
 use crate::{
-    emit_disposal, Buffered, Disposal, Gate, GateRequest, Input, InputBundle, ManageInput,
+    emit_disposal, Buffering, Disposal, Gate, GateRequest, Input, InputBundle, ManageInput,
     Operation, OperationCleanup, OperationReachability, OperationRequest, OperationResult,
     OperationSetup, OrBroken, ReachabilityResult, SingleInputStorage, SingleTargetStorage,
 };
@@ -48,7 +48,7 @@ impl<B, T> OperateDynamicGate<T, B> {
 impl<T, B> Operation for OperateDynamicGate<T, B>
 where
     T: 'static + Send + Sync,
-    B: Buffered + 'static + Send + Sync,
+    B: Buffering + 'static + Send + Sync,
 {
     fn setup(self, OperationSetup { source, world }: OperationSetup) -> OperationResult {
         world
@@ -144,7 +144,7 @@ impl<T, B> OperateStaticGate<T, B> {
 
 impl<T, B> Operation for OperateStaticGate<T, B>
 where
-    B: Buffered + 'static + Send + Sync,
+    B: Buffering + 'static + Send + Sync,
     T: 'static + Send + Sync,
 {
     fn setup(self, OperationSetup { source, world }: OperationSetup) -> OperationResult {
diff --git a/src/operation/scope.rs b/src/operation/scope.rs
index deb46cf1..f757653b 100644
--- a/src/operation/scope.rs
+++ b/src/operation/scope.rs
@@ -16,7 +16,7 @@
 */
 
 use crate::{
-    check_reachability, execute_operation, is_downstream_of, Accessed, AddOperation, Blocker,
+    check_reachability, execute_operation, is_downstream_of, Accessing, AddOperation, Blocker,
     BufferKeyBuilder, Cancel, Cancellable, Cancellation, Cleanup, CleanupContents, ClearBufferFn,
     CollectMarker, DisposalListener, DisposalUpdate, FinalizeCleanup, FinalizeCleanupRequest,
     Input, InputBundle, InspectDisposals, ManageCancellation, ManageInput, Operation,
@@ -1124,7 +1124,7 @@ impl<B> BeginCleanupWorkflow<B> {
 
 impl<B> Operation for BeginCleanupWorkflow<B>
 where
-    B: Accessed + 'static + Send + Sync,
+    B: Accessing + 'static + Send + Sync,
     B::Key: 'static + Send + Sync,
 {
     fn setup(self, OperationSetup { source, world }: OperationSetup) -> OperationResult {
diff --git a/src/testing.rs b/src/testing.rs
index 2982eb91..f7ba4664 100644
--- a/src/testing.rs
+++ b/src/testing.rs
@@ -32,10 +32,10 @@ pub use std::time::{Duration, Instant};
 use smallvec::SmallVec;
 
 use crate::{
-    flush_impulses, Accessed, AddContinuousServicesExt, AnyBuffer, AsAnyBuffer, AsyncServiceInput,
-    BlockingMap, BlockingServiceInput, Buffer, BufferKey, BufferKeyLifecycle, Bufferable, Buffered,
-    Builder, ContinuousQuery, ContinuousQueueView, ContinuousService, FlushParameters,
-    GetBufferedSessionsFn, Joined, OperationError, OperationResult, OperationRoster, Promise,
+    flush_impulses, Accessing, AddContinuousServicesExt, AnyBuffer, AsAnyBuffer, AsyncServiceInput,
+    BlockingMap, BlockingServiceInput, Buffer, BufferKey, BufferKeyLifecycle, Bufferable,
+    Buffering, Builder, ContinuousQuery, ContinuousQueueView, ContinuousService, FlushParameters,
+    GetBufferedSessionsFn, Joining, OperationError, OperationResult, OperationRoster, Promise,
     RunCommandsOnWorldExt, Scope, Service, SpawnWorkflowExt, StreamOf, StreamPack, UnhandledErrors,
     WorkflowSettings,
 };
@@ -524,7 +524,7 @@ impl<T: 'static + Send + Sync> Bufferable for NonCopyBuffer<T> {
     }
 }
 
-impl<T: 'static + Send + Sync> Buffered for NonCopyBuffer<T> {
+impl<T: 'static + Send + Sync> Buffering for NonCopyBuffer<T> {
     fn add_listener(&self, listener: Entity, world: &mut World) -> OperationResult {
         self.inner.add_listener(listener, world)
     }
@@ -556,14 +556,14 @@ impl<T: 'static + Send + Sync> Buffered for NonCopyBuffer<T> {
     }
 }
 
-impl<T: 'static + Send + Sync> Joined for NonCopyBuffer<T> {
+impl<T: 'static + Send + Sync> Joining for NonCopyBuffer<T> {
     type Item = T;
     fn pull(&self, session: Entity, world: &mut World) -> Result<Self::Item, OperationError> {
         self.inner.pull(session, world)
     }
 }
 
-impl<T: 'static + Send + Sync> Accessed for NonCopyBuffer<T> {
+impl<T: 'static + Send + Sync> Accessing for NonCopyBuffer<T> {
     type Key = BufferKey<T>;
     fn add_accessor(&self, accessor: Entity, world: &mut World) -> OperationResult {
         self.inner.add_accessor(accessor, world)