diff --git a/server/swimos_agent/src/agent_lifecycle/item_event/map/mod.rs b/server/swimos_agent/src/agent_lifecycle/item_event/map/mod.rs
index 87926fe0c..e9fc97b10 100644
--- a/server/swimos_agent/src/agent_lifecycle/item_event/map/mod.rs
+++ b/server/swimos_agent/src/agent_lifecycle/item_event/map/mod.rs
@@ -12,10 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::cmp::Ordering;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::marker::PhantomData;
-use std::{cmp::Ordering, collections::HashMap};
 
 use frunk::{Coprod, Coproduct};
 use futures::future::Either;
@@ -30,58 +30,52 @@ use crate::lanes::map::{
         on_update::{OnUpdate, OnUpdateShared},
         MapLaneLifecycle,
     },
-    MapLane, MapLaneEvent,
+    MapLaneEvent,
 };
-use crate::stores::MapStore;
+use crate::map_storage::MapOpsWithEntry;
 
 use super::{HLeaf, HTree, ItemEvent, ItemEventShared};
 
 #[cfg(test)]
 mod tests;
 
-pub type MapLeaf<Context, K, V, LC> = MapBranch<Context, K, V, LC, HLeaf, HLeaf>;
-pub type MapBranch<Context, K, V, LC, L, R> = MapLikeBranch<Context, K, V, MapLane<K, V>, LC, L, R>;
-
-pub type MapStoreLeaf<Context, K, V, LC> = MapStoreBranch<Context, K, V, LC, HLeaf, HLeaf>;
-pub type MapStoreBranch<Context, K, V, LC, L, R> =
-    MapLikeBranch<Context, K, V, MapStore<K, V>, LC, L, R>;
-
-pub type MapLifecycleHandler<'a, Context, K, V, LC> = Coprod!(
-    <LC as OnUpdate<K, V, Context>>::OnUpdateHandler<'a>,
-    <LC as OnRemove<K, V, Context>>::OnRemoveHandler<'a>,
-    <LC as OnClear<K, V, Context>>::OnClearHandler<'a>,
+pub type MapLifecycleHandler<'a, Context, K, V, M, LC> = Coprod!(
+    <LC as OnUpdate<K, V, M, Context>>::OnUpdateHandler<'a>,
+    <LC as OnRemove<K, V, M, Context>>::OnRemoveHandler<'a>,
+    <LC as OnClear<M, Context>>::OnClearHandler<'a>,
 );
 
-pub type MapLifecycleHandlerShared<'a, Context, Shared, K, V, LC> = Coprod!(
-    <LC as OnUpdateShared<K, V, Context, Shared>>::OnUpdateHandler<'a>,
-    <LC as OnRemoveShared<K, V, Context, Shared>>::OnRemoveHandler<'a>,
-    <LC as OnClearShared<K, V, Context, Shared>>::OnClearHandler<'a>,
+pub type MapLifecycleHandlerShared<'a, Context, Shared, K, V, M, LC> = Coprod!(
+    <LC as OnUpdateShared<K, V, M, Context, Shared>>::OnUpdateHandler<'a>,
+    <LC as OnRemoveShared<K, V, M, Context, Shared>>::OnRemoveHandler<'a>,
+    <LC as OnClearShared<M, Context, Shared>>::OnClearHandler<'a>,
 );
 
-type MapBranchHandler<'a, Context, K, V, LC, L, R> = Either<
+type MapBranchHandler<'a, Context, K, V, M, LC, L, R> = Either<
     <L as ItemEvent<Context>>::ItemEventHandler<'a>,
     Either<
-        MapLifecycleHandler<'a, Context, K, V, LC>,
+        MapLifecycleHandler<'a, Context, K, V, M, LC>,
         <R as ItemEvent<Context>>::ItemEventHandler<'a>,
     >,
 >;
 
-type MapBranchHandlerShared<'a, Context, Shared, K, V, LC, L, R> = Either<
+type MapBranchHandlerShared<'a, Context, Shared, K, V, M, LC, L, R> = Either<
     <L as ItemEventShared<Context, Shared>>::ItemEventHandler<'a>,
     Either<
-        MapLifecycleHandlerShared<'a, Context, Shared, K, V, LC>,
+        MapLifecycleHandlerShared<'a, Context, Shared, K, V, M, LC>,
         <R as ItemEventShared<Context, Shared>>::ItemEventHandler<'a>,
     >,
 >;
 
-fn map_handler<'a, Context, K, V, LC>(
-    event: MapLaneEvent<K, V>,
+fn map_handler<'a, Context, K, V, M, LC>(
+    event: MapLaneEvent<K, V, M>,
     lifecycle: &'a LC,
-    map: &HashMap<K, V>,
-) -> MapLifecycleHandler<'a, Context, K, V, LC>
+    map: &M,
+) -> MapLifecycleHandler<'a, Context, K, V, M, LC>
 where
     K: Hash + Eq,
-    LC: MapLaneLifecycle<K, V, Context>,
+    LC: MapLaneLifecycle<K, V, M, Context>,
+    M: MapOpsWithEntry<K, V, K>,
 {
     match event {
         MapLaneEvent::Update(k, old) => {
@@ -97,16 +91,17 @@ where
     }
 }
 
-fn map_handler_shared<'a, Context, Shared, K, V, LC>(
+fn map_handler_shared<'a, Context, Shared, K, V, M, LC>(
     shared: &'a Shared,
     handler_context: HandlerContext<Context>,
-    event: MapLaneEvent<K, V>,
+    event: MapLaneEvent<K, V, M>,
     lifecycle: &'a LC,
-    map: &HashMap<K, V>,
-) -> MapLifecycleHandlerShared<'a, Context, Shared, K, V, LC>
+    map: &M,
+) -> MapLifecycleHandlerShared<'a, Context, Shared, K, V, M, LC>
 where
     K: Hash + Eq,
-    LC: MapLaneLifecycleShared<K, V, Context, Shared>,
+    LC: MapLaneLifecycleShared<K, V, M, Context, Shared>,
+    M: MapOpsWithEntry<K, V, K>,
 {
     match event {
         MapLaneEvent::Update(k, old) => {
@@ -126,10 +121,10 @@ where
     }
 }
 
-type KeyValue<K, V> = fn((K, V)) -> (K, V);
+type MapKeyValue<M, K, V> = fn((&M, K, V)) -> (K, V);
 /// Map lane lifecycle as a branch node of an [`HTree`].
-pub struct MapLikeBranch<Context, K, V, Item, LC, L, R> {
-    _type: PhantomData<KeyValue<K, V>>,
+pub struct MapLikeBranch<Context, K, V, M, Item, LC, L, R> {
+    _type: PhantomData<MapKeyValue<M, K, V>>,
     label: &'static str,
     projection: fn(&Context) -> &Item,
     lifecycle: LC,
@@ -137,8 +132,8 @@ pub struct MapLikeBranch<Context, K, V, Item, LC, L, R> {
     right: R,
 }
 
-impl<Context, K, V, Item, LC: Clone, L: Clone, R: Clone> Clone
-    for MapLikeBranch<Context, K, V, Item, LC, L, R>
+impl<Context, K, V, M, Item, LC: Clone, L: Clone, R: Clone> Clone
+    for MapLikeBranch<Context, K, V, M, Item, LC, L, R>
 {
     fn clone(&self) -> Self {
         Self {
@@ -152,15 +147,15 @@ impl<Context, K, V, Item, LC: Clone, L: Clone, R: Clone> Clone
     }
 }
 
-impl<Context, K, V, Item, LC, L: HTree, R: HTree> HTree
-    for MapLikeBranch<Context, K, V, Item, LC, L, R>
+impl<Context, K, V, M, Item, LC, L: HTree, R: HTree> HTree
+    for MapLikeBranch<Context, K, V, M, Item, LC, L, R>
 {
     fn label(&self) -> Option<&'static str> {
         Some(self.label)
     }
 }
 
-impl<Context, K, V, Item, LC, L, R> Debug for MapLikeBranch<Context, K, V, Item, LC, L, R>
+impl<Context, K, V, M, Item, LC, L, R> Debug for MapLikeBranch<Context, K, V, M, Item, LC, L, R>
 where
     LC: Debug,
     L: Debug,
@@ -177,13 +172,13 @@ where
     }
 }
 
-impl<Context, K, V, Item, LC> MapLikeBranch<Context, K, V, Item, LC, HLeaf, HLeaf> {
+impl<Context, K, V, M, Item, LC> MapLikeBranch<Context, K, V, M, Item, LC, HLeaf, HLeaf> {
     pub fn leaf(label: &'static str, projection: fn(&Context) -> &Item, lifecycle: LC) -> Self {
         MapLikeBranch::new(label, projection, lifecycle, HLeaf, HLeaf)
     }
 }
 
-impl<Context, K, V, Item, LC, L, R> MapLikeBranch<Context, K, V, Item, LC, L, R>
+impl<Context, K, V, M, Item, LC, L, R> MapLikeBranch<Context, K, V, M, Item, LC, L, R>
 where
     L: HTree,
     R: HTree,
@@ -212,16 +207,17 @@ where
     }
 }
 
-impl<Context, K, V, Item, LC, L, R> ItemEvent<Context>
-    for MapLikeBranch<Context, K, V, Item, LC, L, R>
+impl<Context, K, V, M, Item, LC, L, R> ItemEvent<Context>
+    for MapLikeBranch<Context, K, V, M, Item, LC, L, R>
 where
     K: Clone + Eq + Hash,
-    Item: MapItem<K, V>,
-    LC: MapLaneLifecycle<K, V, Context>,
+    Item: MapItem<K, V, M>,
+    LC: MapLaneLifecycle<K, V, M, Context>,
     L: HTree + ItemEvent<Context>,
     R: HTree + ItemEvent<Context>,
+    M: MapOpsWithEntry<K, V, K>,
 {
-    type ItemEventHandler<'a> = MapBranchHandler<'a, Context, K, V, LC, L, R>
+    type ItemEventHandler<'a> = MapBranchHandler<'a, Context, K, V, M, LC, L, R>
     where
         Self: 'a;
 
@@ -253,16 +249,17 @@ where
     }
 }
 
-impl<Context, Shared, K, V, Item, LC, L, R> ItemEventShared<Context, Shared>
-    for MapLikeBranch<Context, K, V, Item, LC, L, R>
+impl<Context, Shared, K, V, M, Item, LC, L, R> ItemEventShared<Context, Shared>
+    for MapLikeBranch<Context, K, V, M, Item, LC, L, R>
 where
     K: Clone + Eq + Hash,
-    Item: MapItem<K, V>,
-    LC: MapLaneLifecycleShared<K, V, Context, Shared>,
+    Item: MapItem<K, V, M>,
+    LC: MapLaneLifecycleShared<K, V, M, Context, Shared>,
     L: HTree + ItemEventShared<Context, Shared>,
     R: HTree + ItemEventShared<Context, Shared>,
+    M: MapOpsWithEntry<K, V, K>,
 {
-    type ItemEventHandler<'a> = MapBranchHandlerShared<'a, Context, Shared, K, V, LC, L, R>
+    type ItemEventHandler<'a> = MapBranchHandlerShared<'a, Context, Shared, K, V, M, LC, L, R>
     where
         Self: 'a,
         Shared: 'a;
diff --git a/server/swimos_agent/src/agent_lifecycle/item_event/map/tests.rs b/server/swimos_agent/src/agent_lifecycle/item_event/map/tests.rs
index ac89becfc..978309bcd 100644
--- a/server/swimos_agent/src/agent_lifecycle/item_event/map/tests.rs
+++ b/server/swimos_agent/src/agent_lifecycle/item_event/map/tests.rs
@@ -20,7 +20,7 @@ use swimos_model::Text;
 use swimos_utilities::routing::RouteUri;
 
 use crate::{
-    agent_lifecycle::item_event::{tests::run_handler, HLeaf, ItemEvent, MapBranch, MapLeaf},
+    agent_lifecycle::item_event::{tests::run_handler, HLeaf, ItemEvent},
     event_handler::{ActionContext, HandlerAction, StepResult},
     lanes::map::{
         lifecycle::{on_clear::OnClear, on_remove::OnRemove, on_update::OnUpdate},
@@ -29,6 +29,12 @@ use crate::{
     meta::AgentMetadata,
 };
 
+use super::MapLikeBranch;
+
+type MapLeaf<Context, K, V, M, LC> = MapBranch<Context, K, V, M, LC, HLeaf, HLeaf>;
+type MapBranch<Context, K, V, M, LC, L, R> =
+    MapLikeBranch<Context, K, V, M, MapLane<K, V, M>, LC, L, R>;
+
 struct TestAgent {
     first: MapLane<i32, i32>,
     second: MapLane<i32, Text>,
@@ -248,7 +254,7 @@ impl<K, V> FakeLifecycle<K, V> {
     }
 }
 
-impl<K, V> OnUpdate<K, V, TestAgent> for FakeLifecycle<K, V>
+impl<K, V> OnUpdate<K, V, HashMap<K, V>, TestAgent> for FakeLifecycle<K, V>
 where
     K: Clone + Send + 'static,
     V: Clone + Send + 'static,
@@ -268,7 +274,7 @@ where
     }
 }
 
-impl<K, V> OnRemove<K, V, TestAgent> for FakeLifecycle<K, V>
+impl<K, V> OnRemove<K, V, HashMap<K, V>, TestAgent> for FakeLifecycle<K, V>
 where
     K: Clone + Send + 'static,
     V: Clone + Send + 'static,
@@ -287,7 +293,7 @@ where
     }
 }
 
-impl<K, V> OnClear<K, V, TestAgent> for FakeLifecycle<K, V>
+impl<K, V> OnClear<HashMap<K, V>, TestAgent> for FakeLifecycle<K, V>
 where
     K: Clone + Send + 'static,
     V: Clone + Send + 'static,
diff --git a/server/swimos_agent/src/agent_lifecycle/item_event/mod.rs b/server/swimos_agent/src/agent_lifecycle/item_event/mod.rs
index 1963840d6..0ac0d2396 100644
--- a/server/swimos_agent/src/agent_lifecycle/item_event/mod.rs
+++ b/server/swimos_agent/src/agent_lifecycle/item_event/mod.rs
@@ -42,10 +42,7 @@ pub use demand_map::{
     DemandMapBranch, DemandMapLeaf, DemandMapLifecycleHandler, DemandMapLifecycleHandlerShared,
 };
 pub use http::{HttpBranch, HttpLeaf};
-pub use map::{
-    MapBranch, MapLeaf, MapLifecycleHandler, MapLifecycleHandlerShared, MapLikeBranch,
-    MapStoreBranch, MapStoreLeaf,
-};
+pub use map::{MapLifecycleHandler, MapLifecycleHandlerShared, MapLikeBranch};
 pub use value::{
     ValueBranch, ValueLeaf, ValueLifecycleHandler, ValueLifecycleHandlerShared, ValueLikeBranch,
     ValueStoreBranch, ValueStoreLeaf,
diff --git a/server/swimos_agent/src/agent_lifecycle/utility/mod.rs b/server/swimos_agent/src/agent_lifecycle/utility/mod.rs
index 2b0f3005e..e60144578 100644
--- a/server/swimos_agent/src/agent_lifecycle/utility/mod.rs
+++ b/server/swimos_agent/src/agent_lifecycle/utility/mod.rs
@@ -234,13 +234,13 @@ impl<Agent: AgentDescription + 'static> HandlerContext<Agent> {
     ) -> impl HandlerAction<Agent, Completion = U> + Send + 'a
     where
         Agent: 'static,
-        Item: InspectableMapLikeItem<K, V> + 'static,
+        Item: InspectableMapLikeItem<K, V, B> + 'static,
         K: Send + Clone + Eq + Hash + 'static,
         V: Borrow<B> + 'static,
         B: ?Sized + 'static,
         F: FnOnce(Option<&B>) -> U + Send + 'a,
     {
-        Item::with_entry_handler::<Agent, F, B, U>(item, key, f)
+        Item::with_entry_handler::<Agent, F, U>(item, key, f)
     }
 
     /// Create an event handler that will transform the value in an entry of a map lane or store of the agent.
@@ -326,12 +326,12 @@ impl<Agent: AgentDescription + 'static> HandlerContext<Agent> {
     ///
     /// #Arguments
     /// * `item` - Projection to the map-like item.
-    pub fn get_map<Item, K, V>(
+    pub fn get_map<Item, K, V, M>(
         &self,
         item: fn(&Agent) -> &Item,
-    ) -> impl HandlerAction<Agent, Completion = HashMap<K, V>> + Send + 'static
+    ) -> impl HandlerAction<Agent, Completion = M> + Send + 'static
     where
-        Item: MapLikeItem<K, V>,
+        Item: MapLikeItem<K, V, M>,
         K: Send + Clone + Eq + Hash + 'static,
         V: Send + Clone + 'static,
     {
diff --git a/server/swimos_agent/src/agent_model/init/mod.rs b/server/swimos_agent/src/agent_model/init/mod.rs
index 17857df34..79db51d48 100644
--- a/server/swimos_agent/src/agent_model/init/mod.rs
+++ b/server/swimos_agent/src/agent_model/init/mod.rs
@@ -33,6 +33,7 @@ use tokio_util::codec::{Decoder, FramedRead, FramedWrite};
 
 use crate::item::{MapItem, ValueItem};
 use crate::lanes::{MapLane, ValueLane};
+use crate::map_storage::MapOps;
 use crate::stores::value::ValueStore;
 use crate::stores::MapStore;
 
@@ -163,23 +164,23 @@ impl<Agent, T> ValueStoreInitializer<Agent, T> {
 }
 
 /// [`ItemInitializer`] to construct the state of a map lane.
-pub struct MapLaneInitializer<Agent, K, V> {
-    projection: fn(&Agent) -> &MapLane<K, V>,
+pub struct MapLaneInitializer<Agent, K, V, M = HashMap<K, V>> {
+    projection: fn(&Agent) -> &MapLane<K, V, M>,
 }
 
-impl<Agent, K, V> MapLaneInitializer<Agent, K, V> {
-    pub fn new(projection: fn(&Agent) -> &MapLane<K, V>) -> Self {
+impl<Agent, K, V, M> MapLaneInitializer<Agent, K, V, M> {
+    pub fn new(projection: fn(&Agent) -> &MapLane<K, V, M>) -> Self {
         MapLaneInitializer { projection }
     }
 }
 
 /// [`ItemInitializer`] to construct the state of a map store.
-pub struct MapStoreInitializer<Agent, K, V> {
-    projection: fn(&Agent) -> &MapStore<K, V>,
+pub struct MapStoreInitializer<Agent, K, V, M = HashMap<K, V>> {
+    projection: fn(&Agent) -> &MapStore<K, V, M>,
 }
 
-impl<Agent, K, V> MapStoreInitializer<Agent, K, V> {
-    pub fn new(projection: fn(&Agent) -> &MapStore<K, V>) -> Self {
+impl<Agent, K, V, M> MapStoreInitializer<Agent, K, V, M> {
+    pub fn new(projection: fn(&Agent) -> &MapStore<K, V, M>) -> Self {
         MapStoreInitializer { projection }
     }
 }
@@ -238,7 +239,7 @@ where
     }
 }
 
-async fn map_like_init<Agent, Item, K, V, F>(
+async fn map_like_init<Agent, Item, K, V, M, F>(
     mut stream: BoxStream<'_, Result<MapMessage<BytesMut, BytesMut>, FrameIoError>>,
     projection: F,
 ) -> Result<InitFn<Agent>, FrameIoError>
@@ -246,8 +247,9 @@ where
     Agent: 'static,
     K: Eq + Hash + Ord + Clone + RecognizerReadable + Send + 'static,
     V: RecognizerReadable + Send + 'static,
-    Item: MapItem<K, V> + 'static,
+    Item: MapItem<K, V, M> + 'static,
     F: Fn(&Agent) -> &Item + Send + 'static,
+    M: MapOps<K, V>,
 {
     let mut key_decoder = RecognizerDecoder::new(K::make_recognizer());
     let mut value_decoder = RecognizerDecoder::new(V::make_recognizer());
@@ -293,20 +295,20 @@ where
             }
         }
     }
-    let map_init = map.into_iter().collect::<HashMap<_, _>>();
-    let f = move |agent: &Agent| projection(agent).init(map_init);
+    let f = move |agent: &Agent| projection(agent).init(M::from_entries(map));
     let f_init: InitFn<Agent> = Box::new(f);
     Ok(f_init)
 }
 
-impl<Agent, K, V> ItemInitializer<Agent, MapMessage<BytesMut, BytesMut>>
-    for MapLaneInitializer<Agent, K, V>
+impl<Agent, K, V, M> ItemInitializer<Agent, MapMessage<BytesMut, BytesMut>>
+    for MapLaneInitializer<Agent, K, V, M>
 where
     Agent: 'static,
     K: RecognizerReadable + Hash + Eq + Ord + Clone + Send + 'static,
     K::Rec: Send,
     V: RecognizerReadable + Send + 'static,
     V::Rec: Send,
+    M: MapOps<K, V> + 'static,
 {
     fn initialize(
         self: Box<Self>,
@@ -317,14 +319,15 @@ where
     }
 }
 
-impl<Agent, K, V> ItemInitializer<Agent, MapMessage<BytesMut, BytesMut>>
-    for MapStoreInitializer<Agent, K, V>
+impl<Agent, K, V, M> ItemInitializer<Agent, MapMessage<BytesMut, BytesMut>>
+    for MapStoreInitializer<Agent, K, V, M>
 where
     Agent: 'static,
     K: RecognizerReadable + Hash + Eq + Ord + Clone + Send + 'static,
     K::Rec: Send,
     V: RecognizerReadable + Send + 'static,
     V::Rec: Send,
+    M: MapOps<K, V> + 'static,
 {
     fn initialize(
         self: Box<Self>,
diff --git a/server/swimos_agent/src/downlink_lifecycle/map/on_remove.rs b/server/swimos_agent/src/downlink_lifecycle/map/on_remove.rs
index eda2ab407..b824e5c9a 100644
--- a/server/swimos_agent/src/downlink_lifecycle/map/on_remove.rs
+++ b/server/swimos_agent/src/downlink_lifecycle/map/on_remove.rs
@@ -119,9 +119,9 @@ where
 
 impl<K, V, Context, Shared, F> OnDownlinkRemoveShared<K, V, Context, Shared> for FnHandler<F>
 where
-    F: for<'a> MapRemoveFn<'a, Context, Shared, K, V> + Send,
+    F: for<'a> MapRemoveFn<'a, Context, Shared, K, V, HashMap<K, V>> + Send,
 {
-    type OnRemoveHandler<'a> = <F as MapRemoveFn<'a, Context, Shared, K, V>>::Handler
+    type OnRemoveHandler<'a> = <F as MapRemoveFn<'a, Context, Shared, K, V, HashMap<K, V>>>::Handler
     where
         Self: 'a,
         Shared: 'a;
diff --git a/server/swimos_agent/src/downlink_lifecycle/map/on_update.rs b/server/swimos_agent/src/downlink_lifecycle/map/on_update.rs
index ceaef0bd6..3e84ea4cc 100644
--- a/server/swimos_agent/src/downlink_lifecycle/map/on_update.rs
+++ b/server/swimos_agent/src/downlink_lifecycle/map/on_update.rs
@@ -192,9 +192,9 @@ where
 
 impl<K, V, Context, Shared, F> OnDownlinkUpdateShared<K, V, Context, Shared> for FnHandler<F>
 where
-    F: for<'a> MapUpdateFn<'a, Context, Shared, K, V> + Send,
+    F: for<'a> MapUpdateFn<'a, Context, Shared, K, V, HashMap<K, V>> + Send,
 {
-    type OnUpdateHandler<'a> = <F as MapUpdateFn<'a, Context, Shared, K, V>>::Handler
+    type OnUpdateHandler<'a> = <F as MapUpdateFn<'a, Context, Shared, K, V, HashMap<K, V>>>::Handler
     where
         Self: 'a,
         Shared: 'a;
@@ -218,9 +218,9 @@ impl<B, K, V, Context, Shared, F> OnDownlinkUpdateShared<K, V, Context, Shared>
 where
     B: ?Sized,
     V: Borrow<B>,
-    F: for<'a> MapUpdateBorrowFn<'a, Context, Shared, K, V, B> + Send,
+    F: for<'a> MapUpdateBorrowFn<'a, Context, Shared, K, V, HashMap<K, V>, B> + Send,
 {
-    type OnUpdateHandler<'a> = <F as MapUpdateBorrowFn<'a, Context, Shared, K, V, B>>::Handler
+    type OnUpdateHandler<'a> = <F as MapUpdateBorrowFn<'a, Context, Shared, K, V, HashMap<K, V>, B>>::Handler
     where
         Self: 'a,
         Shared: 'a;
diff --git a/server/swimos_agent/src/event_handler/handler_fn.rs b/server/swimos_agent/src/event_handler/handler_fn.rs
index 85fce1754..4fa337ae6 100644
--- a/server/swimos_agent/src/event_handler/handler_fn.rs
+++ b/server/swimos_agent/src/event_handler/handler_fn.rs
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashMap;
-
 use crate::{
     agent_lifecycle::HandlerContext,
     lanes::http::{lifecycle::HttpRequestContext, Response, UnitResponse},
@@ -199,23 +197,23 @@ where
     }
 }
 
-pub trait MapRemoveFn<'a, Context, Shared, K, V> {
+pub trait MapRemoveFn<'a, Context, Shared, K, V, M> {
     type Handler: EventHandler<Context> + 'a;
 
     fn make_handler(
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: V,
     ) -> Self::Handler;
 }
 
-impl<'a, Context, Shared, K, V, F, H> MapRemoveFn<'a, Context, Shared, K, V> for F
+impl<'a, Context, Shared, K, V, M, F, H> MapRemoveFn<'a, Context, Shared, K, V, M> for F
 where
     H: EventHandler<Context> + 'a,
-    F: Fn(&'a Shared, HandlerContext<Context>, &HashMap<K, V>, K, V) -> H + 'a,
+    F: Fn(&'a Shared, HandlerContext<Context>, &M, K, V) -> H + 'a,
     Shared: 'a,
 {
     type Handler = H;
@@ -224,7 +222,7 @@ where
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: V,
     ) -> Self::Handler {
@@ -232,24 +230,24 @@ where
     }
 }
 
-pub trait MapUpdateFn<'a, Context, Shared, K, V> {
+pub trait MapUpdateFn<'a, Context, Shared, K, V, M> {
     type Handler: EventHandler<Context> + 'a;
 
     fn make_handler(
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: Option<V>,
         new_value: &V,
     ) -> Self::Handler;
 }
 
-impl<'a, Context, Shared, K, V, F, H> MapUpdateFn<'a, Context, Shared, K, V> for F
+impl<'a, Context, Shared, K, V, M, F, H> MapUpdateFn<'a, Context, Shared, K, V, M> for F
 where
     H: EventHandler<Context> + 'a,
-    F: Fn(&'a Shared, HandlerContext<Context>, &HashMap<K, V>, K, Option<V>, &V) -> H + 'a,
+    F: Fn(&'a Shared, HandlerContext<Context>, &M, K, Option<V>, &V) -> H + 'a,
     Shared: 'a,
 {
     type Handler = H;
@@ -258,7 +256,7 @@ where
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: Option<V>,
         new_value: &V,
@@ -267,25 +265,25 @@ where
     }
 }
 
-pub trait MapUpdateBorrowFn<'a, Context, Shared, K, V, B: ?Sized> {
+pub trait MapUpdateBorrowFn<'a, Context, Shared, K, V, M, B: ?Sized> {
     type Handler: EventHandler<Context> + 'a;
 
     fn make_handler(
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: Option<V>,
         new_value: &B,
     ) -> Self::Handler;
 }
 
-impl<'a, Context, Shared, K, V, B, F, H> MapUpdateBorrowFn<'a, Context, Shared, K, V, B> for F
+impl<'a, Context, Shared, K, V, M, B, F, H> MapUpdateBorrowFn<'a, Context, Shared, K, V, M, B> for F
 where
     B: ?Sized,
     H: EventHandler<Context> + 'a,
-    F: Fn(&'a Shared, HandlerContext<Context>, &HashMap<K, V>, K, Option<V>, &B) -> H + 'a,
+    F: Fn(&'a Shared, HandlerContext<Context>, &M, K, Option<V>, &B) -> H + 'a,
     Shared: 'a,
 {
     type Handler = H;
@@ -294,7 +292,7 @@ where
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: Option<V>,
         new_value: &B,
diff --git a/server/swimos_agent/src/event_queue/mod.rs b/server/swimos_agent/src/event_queue/mod.rs
index af75d068d..ed9beba22 100644
--- a/server/swimos_agent/src/event_queue/mod.rs
+++ b/server/swimos_agent/src/event_queue/mod.rs
@@ -18,7 +18,7 @@ use std::hash::Hash;
 use swimos_agent_protocol::MapOperation;
 use swimos_agent_protocol::StoreResponse;
 
-use crate::map_storage::MapEventQueue;
+use crate::map_storage::{MapEventQueue, MapOps};
 
 /// Keeps track of what changes to the state of the map need to be reported as events.
 #[derive(Debug)]
@@ -119,9 +119,14 @@ where
     type Output<'a> = StoreResponse<MapOperation<K, &'a V>>
     where
         Self: 'a,
+        K: 'a,
         V: 'a;
 
-    fn pop<'a>(&mut self, content: &'a HashMap<K, V>) -> Option<Self::Output<'a>> {
+    fn pop<'a, M>(&mut self, content: &'a M) -> Option<Self::Output<'a>>
+    where
+        K: 'a,
+        M: MapOps<K, V>,
+    {
         loop {
             let action = EventQueue::pop(self)?;
             if let Some(op) = to_operation(content, action) {
@@ -133,9 +138,9 @@ where
 
 pub type Action<K> = MapOperation<K, ()>;
 
-pub fn to_operation<K, V>(content: &HashMap<K, V>, action: Action<K>) -> Option<MapOperation<K, &V>>
+pub fn to_operation<K, V, M>(content: &M, action: Action<K>) -> Option<MapOperation<K, &V>>
 where
-    K: Eq + Hash + Clone,
+    M: MapOps<K, V>,
 {
     match action {
         MapOperation::Update { key, .. } => content
diff --git a/server/swimos_agent/src/item.rs b/server/swimos_agent/src/item.rs
index 64974a080..1ef94b06b 100644
--- a/server/swimos_agent/src/item.rs
+++ b/server/swimos_agent/src/item.rs
@@ -35,19 +35,19 @@ pub trait ValueItem<T>: AgentItem {
     fn init(&self, value: T);
 }
 
-pub trait MapItem<K, V>: AgentItem {
-    fn init(&self, map: HashMap<K, V>);
+pub trait MapItem<K, V, M = HashMap<K, V>>: AgentItem {
+    fn init(&self, map: M);
 
     fn read_with_prev<F, R>(&self, f: F) -> R
     where
-        F: FnOnce(Option<MapLaneEvent<K, V>>, &HashMap<K, V>) -> R;
+        F: FnOnce(Option<MapLaneEvent<K, V, M>>, &M) -> R;
 }
 
-pub trait MapLikeItem<K, V> {
+pub trait MapLikeItem<K, V, M = HashMap<K, V>> {
     type GetHandler<C>: HandlerAction<C, Completion = Option<V>> + Send + 'static
     where
         C: AgentDescription + 'static;
-    type GetMapHandler<C>: HandlerAction<C, Completion = HashMap<K, V>> + Send + 'static
+    type GetMapHandler<C>: HandlerAction<C, Completion = M> + Send + 'static
     where
         C: AgentDescription + 'static;
 
@@ -61,25 +61,21 @@ pub trait MapLikeItem<K, V> {
     ) -> Self::GetMapHandler<C>;
 }
 
-pub trait InspectableMapLikeItem<K, V> {
-    type WithEntryHandler<'a, C, F, B, U>: HandlerAction<C, Completion = U> + Send + 'a
+pub trait InspectableMapLikeItem<K, V: Borrow<B>, B: ?Sized + 'static> {
+    type WithEntryHandler<'a, C, F, U>: HandlerAction<C, Completion = U> + Send + 'a
     where
         Self: 'static,
         C: AgentDescription + 'a,
-        B: ?Sized + 'static,
-        V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U + Send + 'a;
 
-    fn with_entry_handler<'a, C, F, B, U>(
+    fn with_entry_handler<'a, C, F, U>(
         projection: fn(&C) -> &Self,
         key: K,
         f: F,
-    ) -> Self::WithEntryHandler<'a, C, F, B, U>
+    ) -> Self::WithEntryHandler<'a, C, F, U>
     where
         Self: 'static,
         C: AgentDescription + 'a,
-        B: ?Sized + 'static,
-        V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U + Send + 'a;
 }
 
diff --git a/server/swimos_agent/src/lanes/join/map/mod.rs b/server/swimos_agent/src/lanes/join/map/mod.rs
index 132f82e13..b1d315a26 100644
--- a/server/swimos_agent/src/lanes/join/map/mod.rs
+++ b/server/swimos_agent/src/lanes/join/map/mod.rs
@@ -882,30 +882,27 @@ where
     }
 }
 
-impl<L, K, V> InspectableMapLikeItem<K, V> for JoinMapLane<L, K, V>
+impl<L, K, V, B> InspectableMapLikeItem<K, V, B> for JoinMapLane<L, K, V>
 where
     L: Send + 'static,
     K: Clone + Eq + Hash + Send + 'static,
-    V: Send + 'static,
+    V: Borrow<B> + Send + 'static,
+    B: ?Sized + 'static,
 {
-    type WithEntryHandler<'a, C, F, B, U> = JoinMapLaneWithEntry<C, L, K, V, F, B>
+    type WithEntryHandler<'a, C, F, U> = JoinMapLaneWithEntry<C, L, K, V, F, B>
     where
         Self: 'static,
         C: AgentDescription + 'a,
-        B: ?Sized + 'static,
-        V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U + Send + 'a;
 
-    fn with_entry_handler<'a, C, F, B, U>(
+    fn with_entry_handler<'a, C, F, U>(
         projection: fn(&C) -> &Self,
         key: K,
         f: F,
-    ) -> Self::WithEntryHandler<'a, C, F, B, U>
+    ) -> Self::WithEntryHandler<'a, C, F, U>
     where
         Self: 'static,
         C: AgentDescription + 'a,
-        B: ?Sized + 'static,
-        V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U + Send + 'a,
     {
         JoinMapLaneWithEntry::new(projection, key, f)
diff --git a/server/swimos_agent/src/lanes/join/value/mod.rs b/server/swimos_agent/src/lanes/join/value/mod.rs
index af66c2de2..f014ca443 100644
--- a/server/swimos_agent/src/lanes/join/value/mod.rs
+++ b/server/swimos_agent/src/lanes/join/value/mod.rs
@@ -656,29 +656,26 @@ where
     }
 }
 
-impl<K, V> InspectableMapLikeItem<K, V> for JoinValueLane<K, V>
+impl<K, V, B> InspectableMapLikeItem<K, V, B> for JoinValueLane<K, V>
 where
     K: Clone + Eq + Hash + Send + 'static,
-    V: Send + 'static,
+    V: Borrow<B> + Send + 'static,
+    B: ?Sized + 'static,
 {
-    type WithEntryHandler<'a, C, F, B, U> = JoinValueLaneWithEntry<C, K, V, F, B>
+    type WithEntryHandler<'a, C, F, U> = JoinValueLaneWithEntry<C, K, V, F, B>
     where
         Self: 'static,
         C: AgentDescription + 'a,
-        B: ?Sized + 'static,
-        V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U + Send + 'a;
 
-    fn with_entry_handler<'a, C, F, B, U>(
+    fn with_entry_handler<'a, C, F, U>(
         projection: fn(&C) -> &Self,
         key: K,
         f: F,
-    ) -> Self::WithEntryHandler<'a, C, F, B, U>
+    ) -> Self::WithEntryHandler<'a, C, F, U>
     where
         Self: 'static,
         C: AgentDescription + 'a,
-        B: ?Sized + 'static,
-        V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U + Send + 'a,
     {
         JoinValueLaneWithEntry::new(projection, key, f)
diff --git a/server/swimos_agent/src/lanes/map/event.rs b/server/swimos_agent/src/lanes/map/event.rs
index 0cb4a50b8..b08589483 100644
--- a/server/swimos_agent/src/lanes/map/event.rs
+++ b/server/swimos_agent/src/lanes/map/event.rs
@@ -17,16 +17,17 @@ use std::hash::Hash;
 
 /// Enumeration of the possible inputs to a map lane event handler.
 #[derive(Debug, Clone)]
-pub enum MapLaneEvent<K, V> {
-    Clear(HashMap<K, V>),
+pub enum MapLaneEvent<K, V, M = HashMap<K, V>> {
+    Clear(M),
     Update(K, Option<V>),
     Remove(K, V),
 }
 
-impl<K, V> PartialEq for MapLaneEvent<K, V>
+impl<K, V, M> PartialEq for MapLaneEvent<K, V, M>
 where
     K: Eq + Hash,
     V: PartialEq,
+    M: PartialEq,
 {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
@@ -38,10 +39,11 @@ where
     }
 }
 
-impl<K, V> Eq for MapLaneEvent<K, V>
+impl<K, V, M> Eq for MapLaneEvent<K, V, M>
 where
     K: Eq + Hash,
     V: Eq,
+    M: Eq,
 {
     fn assert_receiver_is_total_eq(&self) {}
 }
diff --git a/server/swimos_agent/src/lanes/map/lifecycle/mod.rs b/server/swimos_agent/src/lanes/map/lifecycle/mod.rs
index 00ec012cc..281fc39ec 100644
--- a/server/swimos_agent/src/lanes/map/lifecycle/mod.rs
+++ b/server/swimos_agent/src/lanes/map/lifecycle/mod.rs
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{borrow::Borrow, collections::HashMap, marker::PhantomData};
+use std::{borrow::Borrow, marker::PhantomData};
 
 use swimos_utilities::handlers::{BorrowHandler, FnHandler, NoHandler};
 
@@ -34,35 +34,40 @@ pub mod on_update;
 /// * `K` - The type of the map keys.
 /// * `V` - The type of the map values.
 /// * `Context` - The context within which the event handlers execute (providing access to the agent lanes).
-pub trait MapLaneLifecycle<K, V, Context>:
-    OnUpdate<K, V, Context> + OnRemove<K, V, Context> + OnClear<K, V, Context>
+pub trait MapLaneLifecycle<K, V, M, Context>:
+    OnUpdate<K, V, M, Context> + OnRemove<K, V, M, Context> + OnClear<M, Context>
 {
 }
 
-impl<K, V, Context, L> MapLaneLifecycle<K, V, Context> for L where
-    L: OnUpdate<K, V, Context> + OnRemove<K, V, Context> + OnClear<K, V, Context>
+impl<K, V, M, Context, L> MapLaneLifecycle<K, V, M, Context> for L where
+    L: OnUpdate<K, V, M, Context> + OnRemove<K, V, M, Context> + OnClear<M, Context>
 {
 }
 
-pub trait MapLaneLifecycleShared<K, V, Context, Shared>:
-    OnUpdateShared<K, V, Context, Shared>
-    + OnRemoveShared<K, V, Context, Shared>
-    + OnClearShared<K, V, Context, Shared>
+pub trait MapLaneLifecycleShared<K, V, M, Context, Shared>:
+    OnUpdateShared<K, V, M, Context, Shared>
+    + OnRemoveShared<K, V, M, Context, Shared>
+    + OnClearShared<M, Context, Shared>
 {
 }
 
-impl<L, K, V, Context, Shared> MapLaneLifecycleShared<K, V, Context, Shared> for L where
-    L: OnUpdateShared<K, V, Context, Shared>
-        + OnRemoveShared<K, V, Context, Shared>
-        + OnClearShared<K, V, Context, Shared>
+impl<L, K, V, M, Context, Shared> MapLaneLifecycleShared<K, V, M, Context, Shared> for L where
+    L: OnUpdateShared<K, V, M, Context, Shared>
+        + OnRemoveShared<K, V, M, Context, Shared>
+        + OnClearShared<M, Context, Shared>
 {
 }
 
+type LifecycleType<Context, Shared, K, V, M> = fn(Context, Shared, K, V, M);
+
 /// A lifecycle for a map lane with some shared state (shard with other lifecycles in the same agent).
 ///
 /// # Type Parameters
 /// * `Context` - The context for the event handlers (providing access to the agent lanes).
 /// * `Shared` - The shared state to which the lifecycle has access.
+/// * `K` - The key type of the map.
+/// * `V` - The value type of the map.
+/// * `M` - The map type (for example `HashMap<K, V>`).
 /// * `FUpd` - The `on_update` event handler.
 /// * `FRem` - The `on_remove` event handler.
 /// * `FClr` - The `on_clear` event handler.
@@ -71,18 +76,19 @@ pub struct StatefulMapLaneLifecycle<
     Shared,
     K,
     V,
+    M,
     FUpd = NoHandler,
     FRem = NoHandler,
     FClr = NoHandler,
 > {
-    _value_type: PhantomData<fn(Context, Shared, K, V)>,
+    _value_type: PhantomData<LifecycleType<Context, Shared, K, V, M>>,
     on_update: FUpd,
     on_remove: FRem,
     on_clear: FClr,
 }
 
-impl<Context, Shared, K, V, FUpd: Clone, FRem: Clone, FClr: Clone> Clone
-    for StatefulMapLaneLifecycle<Context, Shared, K, V, FUpd, FRem, FClr>
+impl<Context, Shared, K, V, M, FUpd: Clone, FRem: Clone, FClr: Clone> Clone
+    for StatefulMapLaneLifecycle<Context, Shared, K, V, M, FUpd, FRem, FClr>
 {
     fn clone(&self) -> Self {
         Self {
@@ -94,7 +100,7 @@ impl<Context, Shared, K, V, FUpd: Clone, FRem: Clone, FClr: Clone> Clone
     }
 }
 
-impl<Context, Shared, K, V> Default for StatefulMapLaneLifecycle<Context, Shared, K, V> {
+impl<Context, Shared, K, V, M> Default for StatefulMapLaneLifecycle<Context, Shared, K, V, M> {
     fn default() -> Self {
         Self {
             _value_type: Default::default(),
@@ -105,17 +111,17 @@ impl<Context, Shared, K, V> Default for StatefulMapLaneLifecycle<Context, Shared
     }
 }
 
-impl<Context, Shared, K, V, FUpd, FRem, FClr>
-    StatefulMapLaneLifecycle<Context, Shared, K, V, FUpd, FRem, FClr>
+impl<Context, Shared, K, V, M, FUpd, FRem, FClr>
+    StatefulMapLaneLifecycle<Context, Shared, K, V, M, FUpd, FRem, FClr>
 {
     pub fn on_update<F, B>(
         self,
         f: F,
-    ) -> StatefulMapLaneLifecycle<Context, Shared, K, V, BorrowHandler<F, B>, FRem, FClr>
+    ) -> StatefulMapLaneLifecycle<Context, Shared, K, V, M, BorrowHandler<F, B>, FRem, FClr>
     where
         B: ?Sized,
         V: Borrow<B>,
-        BorrowHandler<F, B>: for<'a> OnUpdateShared<K, V, Context, Shared>,
+        BorrowHandler<F, B>: for<'a> OnUpdateShared<K, V, M, Context, Shared>,
     {
         StatefulMapLaneLifecycle {
             _value_type: PhantomData,
@@ -128,9 +134,9 @@ impl<Context, Shared, K, V, FUpd, FRem, FClr>
     pub fn on_remove<F>(
         self,
         f: F,
-    ) -> StatefulMapLaneLifecycle<Context, Shared, K, V, FUpd, FnHandler<F>, FClr>
+    ) -> StatefulMapLaneLifecycle<Context, Shared, K, V, M, FUpd, FnHandler<F>, FClr>
     where
-        FnHandler<F>: OnRemoveShared<K, V, Context, Shared>,
+        FnHandler<F>: OnRemoveShared<K, V, M, Context, Shared>,
     {
         StatefulMapLaneLifecycle {
             _value_type: PhantomData,
@@ -143,9 +149,9 @@ impl<Context, Shared, K, V, FUpd, FRem, FClr>
     pub fn on_clear<F>(
         self,
         f: F,
-    ) -> StatefulMapLaneLifecycle<Context, Shared, K, V, FUpd, FRem, FnHandler<F>>
+    ) -> StatefulMapLaneLifecycle<Context, Shared, K, V, M, FUpd, FRem, FnHandler<F>>
     where
-        FnHandler<F>: OnClearShared<K, V, Context, Shared>,
+        FnHandler<F>: OnClearShared<M, Context, Shared>,
     {
         StatefulMapLaneLifecycle {
             _value_type: PhantomData,
@@ -156,10 +162,10 @@ impl<Context, Shared, K, V, FUpd, FRem, FClr>
     }
 }
 
-impl<K, V, Context, Shared, FUpd, FRem, FClr> OnUpdateShared<K, V, Context, Shared>
-    for StatefulMapLaneLifecycle<Context, Shared, K, V, FUpd, FRem, FClr>
+impl<K, V, M, Context, Shared, FUpd, FRem, FClr> OnUpdateShared<K, V, M, Context, Shared>
+    for StatefulMapLaneLifecycle<Context, Shared, K, V, M, FUpd, FRem, FClr>
 where
-    FUpd: OnUpdateShared<K, V, Context, Shared>,
+    FUpd: OnUpdateShared<K, V, M, Context, Shared>,
     FRem: Send,
     FClr: Send,
 {
@@ -172,7 +178,7 @@ where
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: Option<V>,
         new_value: &V,
@@ -182,11 +188,11 @@ where
     }
 }
 
-impl<K, V, Context, Shared, FUpd, FRem, FClr> OnRemoveShared<K, V, Context, Shared>
-    for StatefulMapLaneLifecycle<Context, Shared, K, V, FUpd, FRem, FClr>
+impl<K, V, M, Context, Shared, FUpd, FRem, FClr> OnRemoveShared<K, V, M, Context, Shared>
+    for StatefulMapLaneLifecycle<Context, Shared, K, V, M, FUpd, FRem, FClr>
 where
     FUpd: Send,
-    FRem: OnRemoveShared<K, V, Context, Shared>,
+    FRem: OnRemoveShared<K, V, M, Context, Shared>,
     FClr: Send,
 {
     type OnRemoveHandler<'a> = FRem::OnRemoveHandler<'a>
@@ -198,7 +204,7 @@ where
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: V,
     ) -> Self::OnRemoveHandler<'a> {
@@ -207,12 +213,12 @@ where
     }
 }
 
-impl<K, V, Context, Shared, FUpd, FRem, FClr> OnClearShared<K, V, Context, Shared>
-    for StatefulMapLaneLifecycle<Context, Shared, K, V, FUpd, FRem, FClr>
+impl<K, V, M, Context, Shared, FUpd, FRem, FClr> OnClearShared<M, Context, Shared>
+    for StatefulMapLaneLifecycle<Context, Shared, K, V, M, FUpd, FRem, FClr>
 where
     FUpd: Send,
     FRem: Send,
-    FClr: OnClearShared<K, V, Context, Shared>,
+    FClr: OnClearShared<M, Context, Shared>,
 {
     type OnClearHandler<'a> = FClr::OnClearHandler<'a>
     where
@@ -223,7 +229,7 @@ where
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        before: HashMap<K, V>,
+        before: M,
     ) -> Self::OnClearHandler<'a> {
         self.on_clear.on_clear(shared, handler_context, before)
     }
diff --git a/server/swimos_agent/src/lanes/map/lifecycle/on_clear.rs b/server/swimos_agent/src/lanes/map/lifecycle/on_clear.rs
index 11438d511..58bfd977b 100644
--- a/server/swimos_agent/src/lanes/map/lifecycle/on_clear.rs
+++ b/server/swimos_agent/src/lanes/map/lifecycle/on_clear.rs
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashMap;
-
 use swimos_utilities::handlers::{FnHandler, NoHandler};
 
 use crate::{
@@ -22,19 +20,19 @@ use crate::{
 };
 
 /// Lifecycle event for the `on_clear` event of a map lane.
-pub trait OnClear<K, V, Context>: Send {
+pub trait OnClear<M, Context>: Send {
     type OnClearHandler<'a>: EventHandler<Context> + 'a
     where
         Self: 'a;
 
     /// # Arguments
     /// * `before` - The contents of the map before it was cleared.
-    fn on_clear(&self, before: HashMap<K, V>) -> Self::OnClearHandler<'_>;
+    fn on_clear(&self, before: M) -> Self::OnClearHandler<'_>;
 }
 
 /// Lifecycle event for the `on_clear` event of a map lane where the event handler
 /// has shared state with other handlers for the same agent.
-pub trait OnClearShared<K, V, Context, Shared>: Send {
+pub trait OnClearShared<M, Context, Shared>: Send {
     type OnClearHandler<'a>: EventHandler<Context> + 'a
     where
         Self: 'a,
@@ -48,21 +46,21 @@ pub trait OnClearShared<K, V, Context, Shared>: Send {
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        before: HashMap<K, V>,
+        before: M,
     ) -> Self::OnClearHandler<'a>;
 }
 
-impl<K, V, Context> OnClear<K, V, Context> for NoHandler {
+impl<M, Context> OnClear<M, Context> for NoHandler {
     type OnClearHandler<'a> = UnitHandler
     where
         Self: 'a;
 
-    fn on_clear(&self, _before: HashMap<K, V>) -> Self::OnClearHandler<'_> {
+    fn on_clear(&self, _before: M) -> Self::OnClearHandler<'_> {
         UnitHandler::default()
     }
 }
 
-impl<K, V, Context, Shared> OnClearShared<K, V, Context, Shared> for NoHandler {
+impl<M, Context, Shared> OnClearShared<M, Context, Shared> for NoHandler {
     type OnClearHandler<'a> = UnitHandler
     where
         Self: 'a,
@@ -72,32 +70,32 @@ impl<K, V, Context, Shared> OnClearShared<K, V, Context, Shared> for NoHandler {
         &'a self,
         _shared: &'a Shared,
         _handler_context: HandlerContext<Context>,
-        _before: HashMap<K, V>,
+        _before: M,
     ) -> Self::OnClearHandler<'a> {
         UnitHandler::default()
     }
 }
 
-impl<K, V, Context, F, H> OnClear<K, V, Context> for FnHandler<F>
+impl<M, Context, F, H> OnClear<M, Context> for FnHandler<F>
 where
-    F: Fn(HashMap<K, V>) -> H + Send,
+    F: Fn(M) -> H + Send,
     H: EventHandler<Context> + 'static,
 {
     type OnClearHandler<'a> = H
     where
         Self: 'a;
 
-    fn on_clear(&self, before: HashMap<K, V>) -> Self::OnClearHandler<'_> {
+    fn on_clear(&self, before: M) -> Self::OnClearHandler<'_> {
         let FnHandler(f) = self;
         f(before)
     }
 }
 
-impl<K, V, Context, Shared, F> OnClearShared<K, V, Context, Shared> for FnHandler<F>
+impl<M, Context, Shared, F> OnClearShared<M, Context, Shared> for FnHandler<F>
 where
-    F: for<'a> TakeFn<'a, Context, Shared, HashMap<K, V>> + Send,
+    F: for<'a> TakeFn<'a, Context, Shared, M> + Send,
 {
-    type OnClearHandler<'a> = <F as TakeFn<'a, Context, Shared, HashMap<K, V>>>::Handler
+    type OnClearHandler<'a> = <F as TakeFn<'a, Context, Shared, M>>::Handler
     where
         Self: 'a,
         Shared: 'a;
@@ -106,7 +104,7 @@ where
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        before: HashMap<K, V>,
+        before: M,
     ) -> Self::OnClearHandler<'a> {
         let FnHandler(f) = self;
         f.make_handler(shared, handler_context, before)
diff --git a/server/swimos_agent/src/lanes/map/lifecycle/on_remove.rs b/server/swimos_agent/src/lanes/map/lifecycle/on_remove.rs
index dc06090b1..f32993d6f 100644
--- a/server/swimos_agent/src/lanes/map/lifecycle/on_remove.rs
+++ b/server/swimos_agent/src/lanes/map/lifecycle/on_remove.rs
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashMap;
-
 use swimos_utilities::handlers::{FnHandler, NoHandler};
 
 use crate::{
@@ -22,7 +20,7 @@ use crate::{
 };
 
 /// Lifecycle event for the `on_remove` event of a map lane.
-pub trait OnRemove<K, V, Context>: Send {
+pub trait OnRemove<K, V, M, Context>: Send {
     type OnRemoveHandler<'a>: EventHandler<Context> + 'a
     where
         Self: 'a;
@@ -31,17 +29,12 @@ pub trait OnRemove<K, V, Context>: Send {
     /// * `map` - The current contents of the map.
     /// * `key` - The key that was removed.
     /// * `prev_value` - The value that was removed.
-    fn on_remove<'a>(
-        &'a self,
-        map: &HashMap<K, V>,
-        key: K,
-        prev_value: V,
-    ) -> Self::OnRemoveHandler<'a>;
+    fn on_remove<'a>(&'a self, map: &M, key: K, prev_value: V) -> Self::OnRemoveHandler<'a>;
 }
 
 /// Lifecycle event for the `on_remove` event of a map lane where the event handler
 /// has shared state with other handlers for the same agent.
-pub trait OnRemoveShared<K, V, Context, Shared>: Send {
+pub trait OnRemoveShared<K, V, M, Context, Shared>: Send {
     type OnRemoveHandler<'a>: EventHandler<Context> + 'a
     where
         Self: 'a,
@@ -57,28 +50,23 @@ pub trait OnRemoveShared<K, V, Context, Shared>: Send {
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: V,
     ) -> Self::OnRemoveHandler<'a>;
 }
 
-impl<K, V, Context> OnRemove<K, V, Context> for NoHandler {
+impl<K, V, M, Context> OnRemove<K, V, M, Context> for NoHandler {
     type OnRemoveHandler<'a> = UnitHandler
     where
         Self: 'a;
 
-    fn on_remove<'a>(
-        &'a self,
-        _map: &HashMap<K, V>,
-        _key: K,
-        _prev_value: V,
-    ) -> Self::OnRemoveHandler<'a> {
+    fn on_remove<'a>(&'a self, _map: &M, _key: K, _prev_value: V) -> Self::OnRemoveHandler<'a> {
         UnitHandler::default()
     }
 }
 
-impl<K, V, Context, Shared> OnRemoveShared<K, V, Context, Shared> for NoHandler {
+impl<K, V, M, Context, Shared> OnRemoveShared<K, V, M, Context, Shared> for NoHandler {
     type OnRemoveHandler<'a> = UnitHandler
     where
         Self: 'a,
@@ -88,7 +76,7 @@ impl<K, V, Context, Shared> OnRemoveShared<K, V, Context, Shared> for NoHandler
         &'a self,
         _shared: &'a Shared,
         _handler_context: HandlerContext<Context>,
-        _map: &HashMap<K, V>,
+        _map: &M,
         _key: K,
         _prev_value: V,
     ) -> Self::OnRemoveHandler<'a> {
@@ -96,31 +84,26 @@ impl<K, V, Context, Shared> OnRemoveShared<K, V, Context, Shared> for NoHandler
     }
 }
 
-impl<K, V, Context, F, H> OnRemove<K, V, Context> for FnHandler<F>
+impl<K, V, M, Context, F, H> OnRemove<K, V, M, Context> for FnHandler<F>
 where
-    F: Fn(&HashMap<K, V>, K, V) -> H + Send,
+    F: Fn(&M, K, V) -> H + Send,
     H: EventHandler<Context> + 'static,
 {
     type OnRemoveHandler<'a> = H
     where
         Self: 'a;
 
-    fn on_remove<'a>(
-        &'a self,
-        map: &HashMap<K, V>,
-        key: K,
-        prev_value: V,
-    ) -> Self::OnRemoveHandler<'a> {
+    fn on_remove<'a>(&'a self, map: &M, key: K, prev_value: V) -> Self::OnRemoveHandler<'a> {
         let FnHandler(f) = self;
         f(map, key, prev_value)
     }
 }
 
-impl<K, V, Context, Shared, F> OnRemoveShared<K, V, Context, Shared> for FnHandler<F>
+impl<K, V, M, Context, Shared, F> OnRemoveShared<K, V, M, Context, Shared> for FnHandler<F>
 where
-    F: for<'a> MapRemoveFn<'a, Context, Shared, K, V> + Send,
+    F: for<'a> MapRemoveFn<'a, Context, Shared, K, V, M> + Send,
 {
-    type OnRemoveHandler<'a> = <F as MapRemoveFn<'a, Context, Shared, K, V>>::Handler
+    type OnRemoveHandler<'a> = <F as MapRemoveFn<'a, Context, Shared, K, V, M>>::Handler
     where
         Self: 'a,
         Shared: 'a;
@@ -129,7 +112,7 @@ where
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: V,
     ) -> Self::OnRemoveHandler<'a> {
diff --git a/server/swimos_agent/src/lanes/map/lifecycle/on_update.rs b/server/swimos_agent/src/lanes/map/lifecycle/on_update.rs
index f6ea55505..761b44903 100644
--- a/server/swimos_agent/src/lanes/map/lifecycle/on_update.rs
+++ b/server/swimos_agent/src/lanes/map/lifecycle/on_update.rs
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{borrow::Borrow, collections::HashMap};
+use std::borrow::Borrow;
 
 use swimos_utilities::handlers::{BorrowHandler, FnHandler, NoHandler};
 
@@ -22,7 +22,7 @@ use crate::{
 };
 
 /// Lifecycle event for the `on_update` event of a map lane.
-pub trait OnUpdate<K, V, Context>: Send {
+pub trait OnUpdate<K, V, M, Context>: Send {
     type OnUpdateHandler<'a>: EventHandler<Context> + 'a
     where
         Self: 'a;
@@ -34,7 +34,7 @@ pub trait OnUpdate<K, V, Context>: Send {
     /// * `new_value` - The updated value.
     fn on_update<'a>(
         &'a self,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: Option<V>,
         new_value: &V,
@@ -43,7 +43,7 @@ pub trait OnUpdate<K, V, Context>: Send {
 
 /// Lifecycle event for the `on_update` event of a map lane where the event handler
 /// has shared state with other handlers for the same agent.
-pub trait OnUpdateShared<K, V, Context, Shared>: Send {
+pub trait OnUpdateShared<K, V, M, Context, Shared>: Send {
     type OnUpdateHandler<'a>: EventHandler<Context> + 'a
     where
         Self: 'a,
@@ -60,21 +60,21 @@ pub trait OnUpdateShared<K, V, Context, Shared>: Send {
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: Option<V>,
         new_value: &V,
     ) -> Self::OnUpdateHandler<'a>;
 }
 
-impl<K, V, Context> OnUpdate<K, V, Context> for NoHandler {
+impl<K, V, M, Context> OnUpdate<K, V, M, Context> for NoHandler {
     type OnUpdateHandler<'a> = UnitHandler
     where
         Self: 'a;
 
     fn on_update<'a>(
         &'a self,
-        _map: &HashMap<K, V>,
+        _map: &M,
         _key: K,
         _prev_value: Option<V>,
         _new_value: &V,
@@ -83,7 +83,7 @@ impl<K, V, Context> OnUpdate<K, V, Context> for NoHandler {
     }
 }
 
-impl<K, V, Context, Shared> OnUpdateShared<K, V, Context, Shared> for NoHandler {
+impl<K, V, M, Context, Shared> OnUpdateShared<K, V, M, Context, Shared> for NoHandler {
     type OnUpdateHandler<'a> = UnitHandler
     where
         Self: 'a,
@@ -93,7 +93,7 @@ impl<K, V, Context, Shared> OnUpdateShared<K, V, Context, Shared> for NoHandler
         &'a self,
         _shared: &'a Shared,
         _handler_context: HandlerContext<Context>,
-        _map: &HashMap<K, V>,
+        _map: &M,
         _key: K,
         _prev_value: Option<V>,
         _new_value: &V,
@@ -102,9 +102,9 @@ impl<K, V, Context, Shared> OnUpdateShared<K, V, Context, Shared> for NoHandler
     }
 }
 
-impl<K, V, Context, F, H> OnUpdate<K, V, Context> for FnHandler<F>
+impl<K, V, M, Context, F, H> OnUpdate<K, V, M, Context> for FnHandler<F>
 where
-    F: Fn(&HashMap<K, V>, K, Option<V>, &V) -> H + Send,
+    F: Fn(&M, K, Option<V>, &V) -> H + Send,
     H: EventHandler<Context> + 'static,
 {
     type OnUpdateHandler<'a> = H
@@ -113,7 +113,7 @@ where
 
     fn on_update<'a>(
         &'a self,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: Option<V>,
         new_value: &V,
@@ -123,11 +123,11 @@ where
     }
 }
 
-impl<K, V, Context, Shared, F> OnUpdateShared<K, V, Context, Shared> for FnHandler<F>
+impl<K, V, M, Context, Shared, F> OnUpdateShared<K, V, M, Context, Shared> for FnHandler<F>
 where
-    F: for<'a> MapUpdateFn<'a, Context, Shared, K, V> + Send,
+    F: for<'a> MapUpdateFn<'a, Context, Shared, K, V, M> + Send,
 {
-    type OnUpdateHandler<'a> = <F as MapUpdateFn<'a, Context, Shared, K, V>>::Handler
+    type OnUpdateHandler<'a> = <F as MapUpdateFn<'a, Context, Shared, K, V, M>>::Handler
     where
         Self: 'a,
         Shared: 'a;
@@ -136,7 +136,7 @@ where
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: Option<V>,
         new_value: &V,
@@ -146,11 +146,11 @@ where
     }
 }
 
-impl<K, V, B, Context, F, H> OnUpdate<K, V, Context> for BorrowHandler<F, B>
+impl<K, V, M, B, Context, F, H> OnUpdate<K, V, M, Context> for BorrowHandler<F, B>
 where
     B: ?Sized,
     V: Borrow<B>,
-    F: Fn(&HashMap<K, V>, K, Option<V>, &B) -> H + Send,
+    F: Fn(&M, K, Option<V>, &B) -> H + Send,
     H: EventHandler<Context> + 'static,
 {
     type OnUpdateHandler<'a> = H
@@ -159,7 +159,7 @@ where
 
     fn on_update<'a>(
         &'a self,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: Option<V>,
         new_value: &V,
@@ -169,13 +169,14 @@ where
     }
 }
 
-impl<K, V, B, Context, Shared, F> OnUpdateShared<K, V, Context, Shared> for BorrowHandler<F, B>
+impl<K, V, M, B, Context, Shared, F> OnUpdateShared<K, V, M, Context, Shared>
+    for BorrowHandler<F, B>
 where
     B: ?Sized,
     V: Borrow<B>,
-    F: for<'a> MapUpdateBorrowFn<'a, Context, Shared, K, V, B> + Send,
+    F: for<'a> MapUpdateBorrowFn<'a, Context, Shared, K, V, M, B> + Send,
 {
-    type OnUpdateHandler<'a> = <F as MapUpdateBorrowFn<'a, Context, Shared, K, V, B>>::Handler
+    type OnUpdateHandler<'a> = <F as MapUpdateBorrowFn<'a, Context, Shared, K, V, M, B>>::Handler
     where
         Self: 'a,
         Shared: 'a;
@@ -184,7 +185,7 @@ where
         &'a self,
         shared: &'a Shared,
         handler_context: HandlerContext<Context>,
-        map: &HashMap<K, V>,
+        map: &M,
         key: K,
         prev_value: Option<V>,
         new_value: &V,
diff --git a/server/swimos_agent/src/lanes/map/mod.rs b/server/swimos_agent/src/lanes/map/mod.rs
index 328960d5b..19ca8c392 100644
--- a/server/swimos_agent/src/lanes/map/mod.rs
+++ b/server/swimos_agent/src/lanes/map/mod.rs
@@ -43,7 +43,7 @@ use crate::{
         HandlerTrans, Modification, StepResult,
     },
     item::{AgentItem, InspectableMapLikeItem, MapItem, MapLikeItem, MutableMapLikeItem},
-    map_storage::{MapStoreInner, TransformEntryResult},
+    map_storage::{MapOps, MapOpsWithEntry, MapStoreInner, TransformEntryResult},
     meta::AgentMetadata,
 };
 
@@ -53,26 +53,23 @@ pub use event::MapLaneEvent;
 
 use super::{LaneItem, ProjTransform};
 
-type Inner<K, V> = MapStoreInner<K, V, WriteQueues<K>>;
+type Inner<K, V, M> = MapStoreInner<K, V, WriteQueues<K>, M>;
 
 /// Model of a value lane. This maintains a sate consisting of a hash-map from keys to values. It generates an
 /// event whenever the map is updated (updating the value for a key, removing a key or clearing the map).
-///
-/// TODO: This could be parameterized over the type of the hash (and potentially over the kind of the map,
-/// potentially allowing a choice between hash and ordered maps).
 #[derive(Debug)]
-pub struct MapLane<K, V> {
+pub struct MapLane<K, V, M = HashMap<K, V>> {
     id: u64,
-    inner: RefCell<Inner<K, V>>,
+    inner: RefCell<Inner<K, V, M>>,
 }
 
 assert_impl_all!(MapLane<(), ()>: Send);
 
-impl<K, V> MapLane<K, V> {
+impl<K, V, M> MapLane<K, V, M> {
     /// # Arguments
     /// * `id` - The ID of the lane. This should be unique within an agent.
     /// * `init` - The initial contents of the map.
-    pub fn new(id: u64, init: HashMap<K, V>) -> Self {
+    pub fn new(id: u64, init: M) -> Self {
         MapLane {
             id,
             inner: RefCell::new(Inner::new(init)),
@@ -80,31 +77,33 @@ impl<K, V> MapLane<K, V> {
     }
 }
 
-impl<K, V> AgentItem for MapLane<K, V> {
+impl<K, V, M> AgentItem for MapLane<K, V, M> {
     fn id(&self) -> u64 {
         self.id
     }
 }
 
-impl<K, V> MapItem<K, V> for MapLane<K, V>
+impl<K, V, M> MapItem<K, V, M> for MapLane<K, V, M>
 where
     K: Eq + Hash + Clone,
+    M: MapOps<K, V>,
 {
-    fn init(&self, map: HashMap<K, V>) {
+    fn init(&self, map: M) {
         self.inner.borrow_mut().init(map)
     }
 
     fn read_with_prev<F, R>(&self, f: F) -> R
     where
-        F: FnOnce(Option<MapLaneEvent<K, V>>, &HashMap<K, V>) -> R,
+        F: FnOnce(Option<MapLaneEvent<K, V, M>>, &M) -> R,
     {
         self.inner.borrow_mut().read_with_prev(f)
     }
 }
 
-impl<K, V> MapLane<K, V>
+impl<K, V, M> MapLane<K, V, M>
 where
     K: Clone + Eq + Hash,
+    M: MapOps<K, V>,
 {
     /// Update the value associated with a key.
     pub(crate) fn update(&self, key: K, value: V) {
@@ -135,6 +134,7 @@ where
         K: Borrow<Q>,
         Q: Hash + Eq,
         F: FnOnce(Option<&V>) -> R,
+        M: MapOpsWithEntry<K, V, Q>,
     {
         self.inner.borrow().with_entry(key, f)
     }
@@ -142,7 +142,7 @@ where
     /// Read the complete state of the map.
     pub fn get_map<F, R>(&self, f: F) -> R
     where
-        F: FnOnce(&HashMap<K, V>) -> R,
+        F: FnOnce(&M) -> R,
     {
         self.inner.borrow().get_map(f)
     }
@@ -154,15 +154,13 @@ where
     }
 }
 
-impl<K, V> MapLane<K, V>
-where
-    K: Eq + Hash,
-{
+impl<K, V, M> MapLane<K, V, M> {
     pub fn with_entry<F, B, U>(&self, key: &K, f: F) -> U
     where
         B: ?Sized,
         V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U,
+        M: MapOpsWithEntry<K, V, K>,
     {
         self.inner.borrow().with_entry(key, f)
     }
@@ -170,10 +168,11 @@ where
 
 const INFALLIBLE_SER: &str = "Serializing lane responses to recon should be infallible.";
 
-impl<K, V> LaneItem for MapLane<K, V>
+impl<K, V, M> LaneItem for MapLane<K, V, M>
 where
     K: Clone + Eq + Hash + StructuralWritable,
     V: StructuralWritable,
+    M: MapOps<K, V>,
 {
     fn write_to_buffer(&self, buffer: &mut BytesMut) -> WriteResult {
         let mut encoder = MapLaneResponseEncoder::default();
@@ -192,13 +191,13 @@ where
 }
 
 ///  An [event handler](crate::event_handler::EventHandler)`] that will update the value of an entry in the map.
-pub struct MapLaneUpdate<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>,
+pub struct MapLaneUpdate<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>,
     key_value: Option<(K, V)>,
 }
 
-impl<C, K, V> MapLaneUpdate<C, K, V> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>, key: K, value: V) -> Self {
+impl<C, K, V, M> MapLaneUpdate<C, K, V, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>, key: K, value: V) -> Self {
         MapLaneUpdate {
             projection,
             key_value: Some((key, value)),
@@ -206,10 +205,11 @@ impl<C, K, V> MapLaneUpdate<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapLaneUpdate<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapLaneUpdate<C, K, V, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -251,13 +251,13 @@ where
 }
 
 ///  An [event handler](crate::event_handler::EventHandler)`] that will remove an entry from the map.
-pub struct MapLaneRemove<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>,
+pub struct MapLaneRemove<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>,
     key: Option<K>,
 }
 
-impl<C, K, V> MapLaneRemove<C, K, V> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>, key: K) -> Self {
+impl<C, K, V, M> MapLaneRemove<C, K, V, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>, key: K) -> Self {
         MapLaneRemove {
             projection,
             key: Some(key),
@@ -265,10 +265,11 @@ impl<C, K, V> MapLaneRemove<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapLaneRemove<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapLaneRemove<C, K, V, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -304,13 +305,13 @@ where
 }
 
 ///  An [event handler](crate::event_handler::EventHandler)`] that will clear the map.
-pub struct MapLaneClear<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>,
+pub struct MapLaneClear<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>,
     done: bool,
 }
 
-impl<C, K, V> MapLaneClear<C, K, V> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>) -> Self {
+impl<C, K, V, M> MapLaneClear<C, K, V, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>) -> Self {
         MapLaneClear {
             projection,
             done: false,
@@ -318,10 +319,11 @@ impl<C, K, V> MapLaneClear<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapLaneClear<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapLaneClear<C, K, V, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -358,14 +360,14 @@ where
 }
 
 ///  An [event handler](crate::event_handler::EventHandler)`] that will get an entry from the map.
-pub struct MapLaneGet<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>,
+pub struct MapLaneGet<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>,
     key: K,
     done: bool,
 }
 
-impl<C, K, V> MapLaneGet<C, K, V> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>, key: K) -> Self {
+impl<C, K, V, M> MapLaneGet<C, K, V, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>, key: K) -> Self {
         MapLaneGet {
             projection,
             key,
@@ -374,11 +376,12 @@ impl<C, K, V> MapLaneGet<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapLaneGet<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapLaneGet<C, K, V, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
     V: Clone,
+    M: MapOpsWithEntry<K, V, K>,
 {
     type Completion = Option<V>;
 
@@ -414,13 +417,13 @@ where
 }
 
 ///  An [event handler](crate::event_handler::EventHandler)`] that will read the entire state of a map lane.
-pub struct MapLaneGetMap<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>,
+pub struct MapLaneGetMap<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>,
     done: bool,
 }
 
-impl<C, K, V> MapLaneGetMap<C, K, V> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>) -> Self {
+impl<C, K, V, M> MapLaneGetMap<C, K, V, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>) -> Self {
         MapLaneGetMap {
             projection,
             done: false,
@@ -428,13 +431,14 @@ impl<C, K, V> MapLaneGetMap<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapLaneGetMap<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapLaneGetMap<C, K, V, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
     V: Clone,
+    M: MapOps<K, V> + Clone,
 {
-    type Completion = HashMap<K, V>;
+    type Completion = M;
 
     fn step(
         &mut self,
@@ -463,13 +467,35 @@ where
     }
 }
 
-impl<C, K, V, F, B, U> HandlerAction<C> for MapLaneWithEntry<C, K, V, F, B>
+///  An [event handler](crate::event_handler::EventHandler)`] that will alter an entry in the map.
+pub struct MapLaneWithEntry<C, K, V, F, B: ?Sized, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>,
+    key_and_f: Option<(K, F)>,
+    _type: PhantomData<fn(&B)>,
+}
+
+impl<C, K, V, F, B: ?Sized, M> MapLaneWithEntry<C, K, V, F, B, M> {
+    /// #Arguments
+    /// * `projection` - Projection from the agent context to the lane.
+    /// * `key` - Key of the entry.
+    /// * `f` - The closure to apply to the entry.
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>, key: K, f: F) -> Self {
+        MapLaneWithEntry {
+            projection,
+            key_and_f: Some((key, f)),
+            _type: PhantomData,
+        }
+    }
+}
+
+impl<C, K, V, F, B, U, M> HandlerAction<C> for MapLaneWithEntry<C, K, V, F, B, M>
 where
     C: AgentDescription,
     K: Eq + Hash,
     B: ?Sized,
     V: Borrow<B>,
     F: FnOnce(Option<&B>) -> U,
+    M: MapOpsWithEntry<K, V, K>,
 {
     type Completion = U;
 
@@ -504,35 +530,14 @@ where
     }
 }
 
-///  An [event handler](crate::event_handler::EventHandler)`] that will alter an entry in the map.
-pub struct MapLaneWithEntry<C, K, V, F, B: ?Sized> {
-    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>,
-    key_and_f: Option<(K, F)>,
-    _type: PhantomData<fn(&B)>,
-}
-
-impl<C, K, V, F, B: ?Sized> MapLaneWithEntry<C, K, V, F, B> {
-    /// #Arguments
-    /// * `projection` - Projection from the agent context to the lane.
-    /// * `key` - Key of the entry.
-    /// * `f` - The closure to apply to the entry.
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>, key: K, f: F) -> Self {
-        MapLaneWithEntry {
-            projection,
-            key_and_f: Some((key, f)),
-            _type: PhantomData,
-        }
-    }
-}
-
 ///  An [event handler](crate::event_handler::EventHandler)`] that will request a sync from the lane.
-pub struct MapLaneSync<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>,
+pub struct MapLaneSync<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>,
     id: Option<Uuid>,
 }
 
-impl<C, K, V> MapLaneSync<C, K, V> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>, id: Uuid) -> Self {
+impl<C, K, V, M> MapLaneSync<C, K, V, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>, id: Uuid) -> Self {
         MapLaneSync {
             projection,
             id: Some(id),
@@ -540,10 +545,11 @@ impl<C, K, V> MapLaneSync<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapLaneSync<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapLaneSync<C, K, V, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -578,15 +584,15 @@ where
     }
 }
 
-type MapLaneHandler<C, K, V> = Coprod!(
-    MapLaneUpdate<C, K, V>,
-    MapLaneRemove<C, K, V>,
-    MapLaneClear<C, K, V>,
-    MapLaneDropOrTake<C, K, V>,
+type MapLaneHandler<C, K, V, M = HashMap<K, V>> = Coprod!(
+    MapLaneUpdate<C, K, V, M>,
+    MapLaneRemove<C, K, V, M>,
+    MapLaneClear<C, K, V, M>,
+    MapLaneDropOrTake<C, K, V, M>,
 );
 
-impl<C, K, V> HandlerTrans<MapMessage<K, V>> for ProjTransform<C, MapLane<K, V>> {
-    type Out = MapLaneHandler<C, K, V>;
+impl<C, K, V, M> HandlerTrans<MapMessage<K, V>> for ProjTransform<C, MapLane<K, V, M>> {
+    type Out = MapLaneHandler<C, K, V, M>;
 
     fn transform(self, input: MapMessage<K, V>) -> Self::Out {
         let ProjTransform { projection } = self;
@@ -697,31 +703,32 @@ where
     }
 }
 
-pub type DecodeAndApply<C, K, V> =
-    AndThen<DecodeMapMessage<K, V>, MapLaneHandler<C, K, V>, ProjTransform<C, MapLane<K, V>>>;
+pub type DecodeAndApply<C, K, V, M = HashMap<K, V>> =
+    AndThen<DecodeMapMessage<K, V>, MapLaneHandler<C, K, V, M>, ProjTransform<C, MapLane<K, V, M>>>;
 
 /// Create an event handler that will decode an incoming map message and apply the value into a map lane.
-pub fn decode_and_apply<C, K, V>(
+pub fn decode_and_apply<C, K, V, M>(
     message: MapMessage<BytesMut, BytesMut>,
-    projection: fn(&C) -> &MapLane<K, V>,
-) -> DecodeAndApply<C, K, V>
+    projection: fn(&C) -> &MapLane<K, V, M>,
+) -> DecodeAndApply<C, K, V, M>
 where
     C: AgentDescription,
     K: Form + Clone + Eq + Hash,
     V: RecognizerReadable,
+    M: MapOps<K, V>,
 {
     let decode: DecodeMapMessage<K, V> = DecodeMapMessage::new(message);
     decode.and_then(ProjTransform::new(projection))
 }
 
 /// An (event handler)[`crate::event_handler::EventHandler`] that will alter an entry in the map.
-pub struct MapLaneTransformEntry<C, K, V, F> {
-    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>,
+pub struct MapLaneTransformEntry<C, K, V, F, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>,
     key_and_f: Option<(K, F)>,
 }
 
-impl<C, K, V, F> MapLaneTransformEntry<C, K, V, F> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>, key: K, f: F) -> Self {
+impl<C, K, V, F, M> MapLaneTransformEntry<C, K, V, F, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>, key: K, f: F) -> Self {
         MapLaneTransformEntry {
             projection,
             key_and_f: Some((key, f)),
@@ -729,11 +736,12 @@ impl<C, K, V, F> MapLaneTransformEntry<C, K, V, F> {
     }
 }
 
-impl<C, K, V, F> HandlerAction<C> for MapLaneTransformEntry<C, K, V, F>
+impl<C, K, V, F, M> HandlerAction<C> for MapLaneTransformEntry<C, K, V, F, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
     F: FnOnce(Option<&V>) -> Option<V>,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -778,12 +786,13 @@ where
     }
 }
 
-impl<K, V> MapLikeItem<K, V> for MapLane<K, V>
+impl<K, V, M> MapLikeItem<K, V, M> for MapLane<K, V, M>
 where
     K: Clone + Eq + Hash + Send + 'static,
     V: Clone + 'static,
+    M: MapOpsWithEntry<K, V, K> + Clone + 'static,
 {
-    type GetHandler<C> = MapLaneGet<C, K, V>
+    type GetHandler<C> = MapLaneGet<C, K, V, M>
     where
         C: AgentDescription + 'static;
 
@@ -794,7 +803,7 @@ where
         MapLaneGet::new(projection, key)
     }
 
-    type GetMapHandler<C> = MapLaneGetMap<C, K, V>
+    type GetMapHandler<C> = MapLaneGetMap<C, K, V, M>
     where
         C: AgentDescription + 'static;
 
@@ -805,49 +814,48 @@ where
     }
 }
 
-impl<K, V> InspectableMapLikeItem<K, V> for MapLane<K, V>
+impl<K, V, B, M> InspectableMapLikeItem<K, V, B> for MapLane<K, V, M>
 where
     K: Eq + Hash + Send + 'static,
-    V: 'static,
+    V: Borrow<B> + 'static,
+    B: ?Sized + 'static,
+    M: MapOpsWithEntry<K, V, K>,
 {
-    type WithEntryHandler<'a, C, F, B, U> = MapLaneWithEntry<C, K, V, F, B>
+    type WithEntryHandler<'a, C, F, U> = MapLaneWithEntry<C, K, V, F, B, M>
     where
         Self: 'static,
         C: AgentDescription + 'a,
-        B: ?Sized +'static,
-        V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U + Send + 'a;
 
-    fn with_entry_handler<'a, C, F, B, U>(
+    fn with_entry_handler<'a, C, F, U>(
         projection: fn(&C) -> &Self,
         key: K,
         f: F,
-    ) -> Self::WithEntryHandler<'a, C, F, B, U>
+    ) -> Self::WithEntryHandler<'a, C, F, U>
     where
         Self: 'static,
         C: AgentDescription + 'a,
-        B: ?Sized + 'static,
-        V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U + Send + 'a,
     {
         MapLaneWithEntry::new(projection, key, f)
     }
 }
 
-impl<K, V> MutableMapLikeItem<K, V> for MapLane<K, V>
+impl<K, V, M> MutableMapLikeItem<K, V> for MapLane<K, V, M>
 where
     K: Clone + Eq + Hash + Send + 'static,
     V: Send + 'static,
+    M: MapOps<K, V> + 'static,
 {
-    type UpdateHandler<C> = MapLaneUpdate<C, K, V>
+    type UpdateHandler<C> = MapLaneUpdate<C, K, V, M>
     where
         C: AgentDescription + 'static;
 
-    type RemoveHandler<C> = MapLaneRemove<C, K, V>
+    type RemoveHandler<C> = MapLaneRemove<C, K, V, M>
     where
         C: AgentDescription + 'static;
 
-    type ClearHandler<C> = MapLaneClear<C, K, V>
+    type ClearHandler<C> = MapLaneClear<C, K, V, M>
     where
         C: AgentDescription + 'static;
 
@@ -872,7 +880,7 @@ where
         MapLaneClear::new(projection)
     }
 
-    type TransformEntryHandler<'a, C, F> = MapLaneTransformEntry<C, K, V, F>
+    type TransformEntryHandler<'a, C, F> = MapLaneTransformEntry<C, K, V, F, M>
     where
         Self: 'static,
         C: AgentDescription + 'a,
@@ -920,11 +928,12 @@ impl<C, K, V, F> MapLaneSelectUpdate<C, K, V, F> {
     }
 }
 
-impl<C, K, V, F> HandlerAction<C> for MapLaneSelectUpdate<C, K, V, F>
+impl<C, K, V, F, M> HandlerAction<C> for MapLaneSelectUpdate<C, K, V, F>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
-    F: SelectorFn<C, Target = MapLane<K, V>>,
+    F: SelectorFn<C, Target = MapLane<K, V, M>>,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -1003,10 +1012,11 @@ impl<C, K, V, F> MapLaneSelectRemove<C, K, V, F> {
     }
 }
 
-impl<C, K, V, F> HandlerAction<C> for MapLaneSelectRemove<C, K, V, F>
+impl<C, K, V, F, M> HandlerAction<C> for MapLaneSelectRemove<C, K, V, F>
 where
     K: Clone + Eq + Hash,
-    F: SelectorFn<C, Target = MapLane<K, V>>,
+    F: SelectorFn<C, Target = MapLane<K, V, M>>,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -1078,11 +1088,12 @@ impl<C, K, V, F> MapLaneSelectClear<C, K, V, F> {
     }
 }
 
-impl<C, K, V, F> HandlerAction<C> for MapLaneSelectClear<C, K, V, F>
+impl<C, K, V, F, M> HandlerAction<C> for MapLaneSelectClear<C, K, V, F>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
-    F: SelectorFn<C, Target = MapLane<K, V>>,
+    F: SelectorFn<C, Target = MapLane<K, V, M>>,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -1140,12 +1151,13 @@ pub enum DecodeAndSelectApply<C, K, V, F> {
     Done,
 }
 
-impl<C, K, V, F> HandlerAction<C> for DecodeAndSelectApply<C, K, V, F>
+impl<C, K, V, F, M> HandlerAction<C> for DecodeAndSelectApply<C, K, V, F>
 where
     C: AgentDescription,
     K: Form + Clone + Eq + Hash,
     V: RecognizerReadable,
-    F: SelectorFn<C, Target = MapLane<K, V>>,
+    F: SelectorFn<C, Target = MapLane<K, V, M>>,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -1267,14 +1279,15 @@ where
 }
 
 /// Create an event handler that will decode an incoming map message and apply the value into a map lane.
-pub fn decode_and_select_apply<C, K, V, F>(
+pub fn decode_and_select_apply<C, K, V, M, F>(
     message: MapMessage<BytesMut, BytesMut>,
     projection: F,
 ) -> DecodeAndSelectApply<C, K, V, F>
 where
     K: Clone + Eq + Hash + RecognizerReadable,
     V: RecognizerReadable,
-    F: SelectorFn<C, Target = MapLane<K, V>>,
+    F: SelectorFn<C, Target = MapLane<K, V, M>>,
+    M: MapOps<K, V>,
 {
     let decode: DecodeMapMessage<K, V> = DecodeMapMessage::new(message);
     DecodeAndSelectApply::Decoding(decode, projection)
@@ -1301,11 +1314,12 @@ impl<C, K, V, F> MapLaneSelectSync<C, K, V, F> {
     }
 }
 
-impl<C, K, V, F> HandlerAction<C> for MapLaneSelectSync<C, K, V, F>
+impl<C, K, V, F, M> HandlerAction<C> for MapLaneSelectSync<C, K, V, F>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
-    F: SelectorFn<C, Target = MapLane<K, V>>,
+    F: SelectorFn<C, Target = MapLane<K, V, M>>,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -1347,14 +1361,14 @@ where
     }
 }
 
-struct MapLaneRemoveMultiple<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>,
+struct MapLaneRemoveMultiple<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>,
     keys: Option<VecDeque<K>>,
-    current: Option<MapLaneRemove<C, K, V>>,
+    current: Option<MapLaneRemove<C, K, V, M>>,
 }
 
-impl<C, K, V> MapLaneRemoveMultiple<C, K, V> {
-    fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>, keys: VecDeque<K>) -> Self {
+impl<C, K, V, M> MapLaneRemoveMultiple<C, K, V, M> {
+    fn new(projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>, keys: VecDeque<K>) -> Self {
         MapLaneRemoveMultiple {
             projection,
             keys: Some(keys),
@@ -1363,10 +1377,11 @@ impl<C, K, V> MapLaneRemoveMultiple<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapLaneRemoveMultiple<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapLaneRemoveMultiple<C, K, V, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -1424,23 +1439,23 @@ enum DropOrTake {
     Take,
 }
 
-enum DropOrTakeState<C, K, V> {
+enum DropOrTakeState<C, K, V, M> {
     Init,
-    Removing(MapLaneRemoveMultiple<C, K, V>),
+    Removing(MapLaneRemoveMultiple<C, K, V, M>),
 }
 
 /// An [event handler](crate::event_handler::EventHandler)`] that will either retain or drop the first `n` elements
 /// from a map (ordering the keys by the ordering of their Recon model representations).
-pub struct MapLaneDropOrTake<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>,
+pub struct MapLaneDropOrTake<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>,
     kind: DropOrTake,
     number: u64,
-    state: DropOrTakeState<C, K, V>,
+    state: DropOrTakeState<C, K, V, M>,
 }
 
-impl<C, K, V> MapLaneDropOrTake<C, K, V> {
+impl<C, K, V, M> MapLaneDropOrTake<C, K, V, M> {
     fn new(
-        projection: for<'a> fn(&'a C) -> &'a MapLane<K, V>,
+        projection: for<'a> fn(&'a C) -> &'a MapLane<K, V, M>,
         kind: DropOrTake,
         number: u64,
     ) -> Self {
@@ -1453,38 +1468,37 @@ impl<C, K, V> MapLaneDropOrTake<C, K, V> {
     }
 }
 
-fn drop_or_take<K, V>(map: &HashMap<K, V>, kind: DropOrTake, number: usize) -> VecDeque<K>
+fn drop_or_take<K, V, M>(map: &M, kind: DropOrTake, number: usize) -> VecDeque<K>
 where
     K: StructuralWritable + Clone + Eq + Hash,
+    M: MapOps<K, V>,
+{
+    if M::ORDERED_KEYS {
+        to_deque(kind, number, map.keys())
+    } else {
+        let mut keys_with_recon = map.keys().map(|k| (k.structure(), k)).collect::<Vec<_>>();
+        keys_with_recon.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
+        let it = keys_with_recon.into_iter().map(|(_, k)| k);
+        to_deque(kind, number, it)
+    }
+}
+
+fn to_deque<'a, I, K>(kind: DropOrTake, number: usize, it: I) -> VecDeque<K>
+where
+    K: Clone + 'a,
+    I: Iterator<Item = &'a K>,
 {
-    let mut keys_with_recon = map.keys().map(|k| (k.structure(), k)).collect::<Vec<_>>();
-    keys_with_recon.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
-    let mut to_remove: VecDeque<K> = VecDeque::new();
     match kind {
-        DropOrTake::Drop => {
-            to_remove.extend(
-                keys_with_recon
-                    .into_iter()
-                    .take(number)
-                    .map(|(_, k1)| k1.clone()),
-            );
-        }
-        DropOrTake::Take => {
-            to_remove.extend(
-                keys_with_recon
-                    .into_iter()
-                    .skip(number)
-                    .map(|(_, k1)| k1.clone()),
-            );
-        }
+        DropOrTake::Drop => it.take(number).cloned().collect(),
+        DropOrTake::Take => it.skip(number).cloned().collect(),
     }
-    to_remove
 }
 
-impl<C, K, V> HandlerAction<C> for MapLaneDropOrTake<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapLaneDropOrTake<C, K, V, M>
 where
     C: AgentDescription,
     K: StructuralWritable + Clone + Eq + Hash,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -1561,10 +1575,11 @@ impl<C, K, V, F> MapLaneSelectRemoveMultiple<C, K, V, F> {
     }
 }
 
-impl<C, K, V, F> HandlerAction<C> for MapLaneSelectRemoveMultiple<C, K, V, F>
+impl<C, K, V, F, M> HandlerAction<C> for MapLaneSelectRemoveMultiple<C, K, V, F>
 where
     K: Clone + Eq + Hash,
-    F: SelectorFn<C, Target = MapLane<K, V>>,
+    F: SelectorFn<C, Target = MapLane<K, V, M>>,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -1635,11 +1650,12 @@ impl<C, K, V, F> MapLaneSelectDropOrTake<C, K, V, F> {
     }
 }
 
-impl<C, K, V, F> HandlerAction<C> for MapLaneSelectDropOrTake<C, K, V, F>
+impl<C, K, V, F, M> HandlerAction<C> for MapLaneSelectDropOrTake<C, K, V, F>
 where
     C: AgentDescription,
     K: StructuralWritable + Clone + Eq + Hash,
-    F: SelectorFn<C, Target = MapLane<K, V>>,
+    F: SelectorFn<C, Target = MapLane<K, V, M>>,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
diff --git a/server/swimos_agent/src/lanes/map/tests.rs b/server/swimos_agent/src/lanes/map/tests.rs
index 12947d368..81ffa0190 100644
--- a/server/swimos_agent/src/lanes/map/tests.rs
+++ b/server/swimos_agent/src/lanes/map/tests.rs
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use std::borrow::Cow;
-use std::collections::{HashMap, VecDeque};
+use std::collections::{BTreeMap, HashMap, VecDeque};
 use std::fmt::Debug;
 
 use bytes::BytesMut;
@@ -1122,35 +1122,75 @@ fn drop_take_choose_keys() {
         .collect::<HashMap<_, _>>();
 
     assert_eq!(
-        drop_or_take(&map, super::DropOrTake::Drop, 2),
+        drop_or_take(&map, DropOrTake::Drop, 2),
         VecDeque::from(vec![1, 2])
     );
     assert_eq!(
-        drop_or_take(&map, super::DropOrTake::Take, 3),
+        drop_or_take(&map, DropOrTake::Take, 3),
         VecDeque::from(vec![4])
     );
     assert_eq!(
-        drop_or_take(&map, super::DropOrTake::Drop, 4),
+        drop_or_take(&map, DropOrTake::Drop, 4),
         VecDeque::from(vec![1, 2, 3, 4])
     );
     assert_eq!(
-        drop_or_take(&map, super::DropOrTake::Take, 4),
+        drop_or_take(&map, DropOrTake::Take, 4),
         VecDeque::from(vec![])
     );
     assert_eq!(
-        drop_or_take(&map, super::DropOrTake::Drop, 10),
+        drop_or_take(&map, DropOrTake::Drop, 10),
         VecDeque::from(vec![1, 2, 3, 4])
     );
     assert_eq!(
-        drop_or_take(&map, super::DropOrTake::Take, 10),
+        drop_or_take(&map, DropOrTake::Take, 10),
         VecDeque::from(vec![])
     );
     assert_eq!(
-        drop_or_take(&map, super::DropOrTake::Drop, 0),
+        drop_or_take(&map, DropOrTake::Drop, 0),
         VecDeque::from(vec![])
     );
     assert_eq!(
-        drop_or_take(&map, super::DropOrTake::Take, 0),
+        drop_or_take(&map, DropOrTake::Take, 0),
+        VecDeque::from(vec![1, 2, 3, 4])
+    );
+}
+
+#[test]
+fn drop_take_choose_keys_ordered() {
+    let map = [(1, 2), (2, 4), (3, 6), (4, 8)]
+        .into_iter()
+        .collect::<BTreeMap<_, _>>();
+
+    assert_eq!(
+        drop_or_take(&map, DropOrTake::Drop, 2),
+        VecDeque::from(vec![1, 2])
+    );
+    assert_eq!(
+        drop_or_take(&map, DropOrTake::Take, 3),
+        VecDeque::from(vec![4])
+    );
+    assert_eq!(
+        drop_or_take(&map, DropOrTake::Drop, 4),
+        VecDeque::from(vec![1, 2, 3, 4])
+    );
+    assert_eq!(
+        drop_or_take(&map, DropOrTake::Take, 4),
+        VecDeque::from(vec![])
+    );
+    assert_eq!(
+        drop_or_take(&map, DropOrTake::Drop, 10),
+        VecDeque::from(vec![1, 2, 3, 4])
+    );
+    assert_eq!(
+        drop_or_take(&map, DropOrTake::Take, 10),
+        VecDeque::from(vec![])
+    );
+    assert_eq!(
+        drop_or_take(&map, DropOrTake::Drop, 0),
+        VecDeque::from(vec![])
+    );
+    assert_eq!(
+        drop_or_take(&map, DropOrTake::Take, 0),
         VecDeque::from(vec![1, 2, 3, 4])
     );
 }
diff --git a/server/swimos_agent/src/lanes/queues/mod.rs b/server/swimos_agent/src/lanes/queues/mod.rs
index b4d3351de..658eb99db 100644
--- a/server/swimos_agent/src/lanes/queues/mod.rs
+++ b/server/swimos_agent/src/lanes/queues/mod.rs
@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::{HashMap, VecDeque};
+use std::collections::VecDeque;
 use std::hash::Hash;
 
 use swimos_agent_protocol::{LaneResponse, MapOperation};
 use uuid::Uuid;
 
 use crate::event_queue::{to_operation, EventQueue};
-use crate::map_storage::MapEventQueue;
+use crate::map_storage::{MapEventQueue, MapOps};
 
 /// For a sync operation on a map lane, keeps track of which keys are synced for a given remote.
 #[derive(Debug)]
@@ -202,7 +202,11 @@ where
         self.push_operation(action)
     }
 
-    fn pop<'a>(&mut self, content: &'a HashMap<K, V>) -> Option<Self::Output<'a>> {
+    fn pop<'a, M>(&mut self, content: &'a M) -> Option<Self::Output<'a>>
+    where
+        K: 'a,
+        M: MapOps<K, V>,
+    {
         loop {
             match WriteQueues::pop(self)? {
                 ToWrite::Event(action) => {
diff --git a/server/swimos_agent/src/lib.rs b/server/swimos_agent/src/lib.rs
index 035d8b5c1..181f5e252 100644
--- a/server/swimos_agent/src/lib.rs
+++ b/server/swimos_agent/src/lib.rs
@@ -82,6 +82,9 @@ pub use item::AgentItem;
 #[doc(hidden)]
 pub use meta::AgentMetadata;
 
+#[doc(hidden)]
+pub use map_storage::MapBacking;
+
 #[doc(hidden)]
 pub mod model {
     pub use swimos_agent_protocol::{MapMessage, MapOperation};
diff --git a/server/swimos_agent/src/map_storage/mod.rs b/server/swimos_agent/src/map_storage/mod.rs
index 411580c84..dfc3bd514 100644
--- a/server/swimos_agent/src/map_storage/mod.rs
+++ b/server/swimos_agent/src/map_storage/mod.rs
@@ -12,7 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{borrow::Borrow, collections::HashMap, hash::Hash};
+use std::{
+    borrow::Borrow,
+    collections::{BTreeMap, HashMap},
+    hash::{BuildHasher, Hash},
+    ops::Index,
+};
 
 use swimos_agent_protocol::MapOperation;
 
@@ -20,9 +25,9 @@ use crate::lanes::map::MapLaneEvent;
 
 /// Common backing store used by both map stores and map lanes.
 #[derive(Debug)]
-pub struct MapStoreInner<K, V, Q> {
-    content: HashMap<K, V>,
-    previous: Option<MapLaneEvent<K, V>>,
+pub struct MapStoreInner<K, V, Q, M = HashMap<K, V>> {
+    content: M,
+    previous: Option<MapLaneEvent<K, V, M>>,
     queue: Q,
 }
 
@@ -37,11 +42,14 @@ pub trait MapEventQueue<K, V>: Default {
 
     fn push(&mut self, action: MapOperation<K, ()>);
 
-    fn pop<'a>(&mut self, content: &'a HashMap<K, V>) -> Option<Self::Output<'a>>;
+    fn pop<'a, M>(&mut self, content: &'a M) -> Option<Self::Output<'a>>
+    where
+        K: 'a,
+        M: MapOps<K, V>;
 }
 
-impl<K, V, Q: Default> MapStoreInner<K, V, Q> {
-    pub fn new(content: HashMap<K, V>) -> Self {
+impl<K, V, Q: Default, M> MapStoreInner<K, V, Q, M> {
+    pub fn new(content: M) -> Self {
         MapStoreInner {
             content,
             previous: Default::default(),
@@ -56,15 +64,217 @@ pub enum TransformEntryResult {
     Remove,
 }
 
-impl<K, V, Q> MapStoreInner<K, V, Q>
+impl<K, V, Q, M> MapStoreInner<K, V, Q, M> {
+    pub fn init(&mut self, map: M) {
+        self.content = map;
+    }
+}
+
+impl<K, V, Q, M> MapStoreInner<K, V, Q, M>
 where
-    K: Eq + Hash + Clone,
     Q: MapEventQueue<K, V>,
+    M: MapOps<K, V>,
 {
-    pub fn init(&mut self, map: HashMap<K, V>) {
-        self.content = map;
+    pub fn queue(&mut self) -> &mut Q {
+        &mut self.queue
+    }
+
+    pub fn pop_operation(&mut self) -> Option<Q::Output<'_>> {
+        let MapStoreInner { content, queue, .. } = self;
+        queue.pop(content)
+    }
+}
+
+pub trait MapBacking {
+    type KeyType;
+    type ValueType;
+}
+
+/// Operations that a map implementation (e.g. [`HashMap`], [`BTreeMap`]) must support to be
+/// used as a backing store for a [`MapStoreInner`] (which underlies all map stores and map lanes).
+pub trait MapOps<K, V>: MapBacking<KeyType = K, ValueType = V> {
+    /// Attempt to get the value associated with a key.
+    ///
+    /// # Arguments
+    /// * `key` - The key.
+    fn get(&self, key: &K) -> Option<&V>;
+
+    /// Insert a new entry into the map. If such an entry already existed, the old value
+    /// will be returned.
+    ///
+    /// # Arguments
+    /// * `key` - The key.
+    /// * `value` - The new value.
+    fn insert(&mut self, key: K, value: V) -> Option<V>;
+
+    /// Remove an entry from the map. If the entry existed, it's previous value will be returned.
+    /// # Arguments
+    /// * `key` - The key of the entry to remove.
+    fn remove(&mut self, key: &K) -> Option<V>;
+
+    /// Clear the map, returning the previous contents.
+    fn take(&mut self) -> Self;
+
+    /// Get an iterator over the keys of the map. If [`MapOps::ORDERED_KEYS`] is true, this must
+    /// return the keys in their intrinsic order (which must be consistent with the order of their
+    /// Recon representation, if the key type implements [`swimos_form::Form`]).
+    fn keys<'a>(&'a self) -> impl Iterator<Item = &'a K>
+    where
+        K: 'a;
+
+    /// If this is true, the keys returned by [`MapOps::keys`] will be in order.
+    const ORDERED_KEYS: bool;
+
+    /// Build an instance of the map from an iterator of key-value pairs.
+    ///
+    /// # Arguments
+    /// * `it` - The key value pairs to insert into the map.
+    fn from_entries<I>(it: I) -> Self
+    where
+        I: IntoIterator<Item = (K, V)>;
+}
+
+/// Extension to [`MapOps`] that allows entries of the map to be inspected with a borrowed form
+/// of the key.
+pub trait MapOpsWithEntry<K, V, BK: ?Sized>:
+    MapOps<K, V> + for<'a> Index<&'a BK, Output = V>
+{
+    /// Compute a value based on an entry of the map.
+    ///
+    /// # Arguments
+    /// * `key` - Borrowed form of the key.
+    /// * `f` - A function to apply to a borrow of the value associated with the key.
+    fn with_item<BV: ?Sized, F, R>(&self, key: &BK, f: F) -> R
+    where
+        V: Borrow<BV>,
+        F: FnOnce(Option<&BV>) -> R;
+}
+
+impl<K, V, S> MapBacking for HashMap<K, V, S> {
+    type KeyType = K;
+
+    type ValueType = V;
+}
+
+impl<K, V, S> MapOps<K, V> for HashMap<K, V, S>
+where
+    K: Hash + Eq,
+    S: BuildHasher + Default,
+{
+    fn get(&self, key: &K) -> Option<&V> {
+        HashMap::get(self, key)
+    }
+
+    fn insert(&mut self, key: K, value: V) -> Option<V> {
+        HashMap::insert(self, key, value)
+    }
+
+    fn remove(&mut self, key: &K) -> Option<V> {
+        HashMap::remove(self, key)
     }
 
+    fn take(&mut self) -> Self {
+        std::mem::take(self)
+    }
+
+    fn keys<'a>(&'a self) -> impl Iterator<Item = &'a K>
+    where
+        K: 'a,
+    {
+        HashMap::keys(self)
+    }
+
+    fn from_entries<I>(it: I) -> Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+    {
+        it.into_iter().collect()
+    }
+
+    const ORDERED_KEYS: bool = false;
+}
+
+impl<K, V> MapBacking for BTreeMap<K, V> {
+    type KeyType = K;
+
+    type ValueType = V;
+}
+
+impl<K, V> MapOps<K, V> for BTreeMap<K, V>
+where
+    K: Ord,
+{
+    fn get(&self, key: &K) -> Option<&V> {
+        BTreeMap::get(self, key)
+    }
+
+    fn insert(&mut self, key: K, value: V) -> Option<V> {
+        BTreeMap::insert(self, key, value)
+    }
+
+    fn remove(&mut self, key: &K) -> Option<V> {
+        BTreeMap::remove(self, key)
+    }
+
+    fn take(&mut self) -> Self {
+        std::mem::take(self)
+    }
+
+    fn keys<'a>(&'a self) -> impl Iterator<Item = &'a K>
+    where
+        K: 'a,
+    {
+        BTreeMap::keys(self)
+    }
+
+    fn from_entries<I>(it: I) -> Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+    {
+        it.into_iter().collect()
+    }
+
+    const ORDERED_KEYS: bool = true;
+}
+
+impl<K, V, BK> MapOpsWithEntry<K, V, BK> for HashMap<K, V>
+where
+    K: Borrow<BK>,
+    BK: ?Sized,
+    K: Hash + Eq,
+    BK: Hash + Eq,
+{
+    fn with_item<BV: ?Sized, F, R>(&self, key: &BK, f: F) -> R
+    where
+        V: Borrow<BV>,
+        F: FnOnce(Option<&BV>) -> R,
+    {
+        f(self.get(key).map(Borrow::borrow))
+    }
+}
+
+impl<K, V, BK> MapOpsWithEntry<K, V, BK> for BTreeMap<K, V>
+where
+    K: Borrow<BK>,
+    BK: ?Sized,
+    K: Ord,
+    BK: Ord,
+{
+    fn with_item<BV: ?Sized, F, R>(&self, key: &BK, f: F) -> R
+    where
+        V: Borrow<BV>,
+        F: FnOnce(Option<&BV>) -> R,
+    {
+        f(self.get(key).map(Borrow::borrow))
+    }
+}
+
+impl<K, V, Q, M> MapStoreInner<K, V, Q, M>
+where
+    K: Clone,
+    Q: MapEventQueue<K, V>,
+    M: MapOps<K, V>,
+{
     pub fn update(&mut self, key: K, value: V) {
         let MapStoreInner {
             content,
@@ -123,20 +333,26 @@ where
             queue.push(MapOperation::Remove { key: key.clone() });
         }
     }
+}
 
+impl<K, V, Q, M> MapStoreInner<K, V, Q, M>
+where
+    Q: MapEventQueue<K, V>,
+    M: MapOps<K, V>,
+{
     pub fn clear(&mut self) {
         let MapStoreInner {
             content,
             previous,
             queue,
         } = self;
-        *previous = Some(MapLaneEvent::Clear(std::mem::take(content)));
+        *previous = Some(MapLaneEvent::Clear(content.take()));
         queue.push(MapOperation::Clear);
     }
 
     pub fn get_map<F, R>(&self, f: F) -> R
     where
-        F: FnOnce(&HashMap<K, V>) -> R,
+        F: FnOnce(&M) -> R,
     {
         let MapStoreInner { content, .. } = self;
         f(content)
@@ -144,38 +360,26 @@ where
 
     pub fn read_with_prev<F, R>(&mut self, f: F) -> R
     where
-        F: FnOnce(Option<MapLaneEvent<K, V>>, &HashMap<K, V>) -> R,
+        F: FnOnce(Option<MapLaneEvent<K, V, M>>, &M) -> R,
     {
         let MapStoreInner {
             content, previous, ..
         } = self;
         f(previous.take(), content)
     }
-
-    pub fn queue(&mut self) -> &mut Q {
-        &mut self.queue
-    }
-
-    pub fn pop_operation(&mut self) -> Option<Q::Output<'_>> {
-        let MapStoreInner { content, queue, .. } = self;
-        queue.pop(content)
-    }
 }
 
-impl<K, V, Q> MapStoreInner<K, V, Q>
-where
-    K: Eq + Hash,
-{
-    pub fn with_entry<B1, B2, F, R>(&self, key: &B1, f: F) -> R
+impl<K, V, Q, M> MapStoreInner<K, V, Q, M> {
+    pub fn with_entry<BK, BV, F, R>(&self, key: &BK, f: F) -> R
     where
-        B1: ?Sized,
-        B2: ?Sized,
-        K: Borrow<B1>,
-        V: Borrow<B2>,
-        B1: Hash + Eq,
-        F: FnOnce(Option<&B2>) -> R,
+        BK: ?Sized,
+        BV: ?Sized,
+        K: Borrow<BK>,
+        V: Borrow<BV>,
+        F: FnOnce(Option<&BV>) -> R,
+        M: MapOpsWithEntry<K, V, BK>,
     {
         let MapStoreInner { content, .. } = self;
-        f(content.get(key).map(Borrow::borrow))
+        MapOpsWithEntry::with_item(content, key, f)
     }
 }
diff --git a/server/swimos_agent/src/stores/map/mod.rs b/server/swimos_agent/src/stores/map/mod.rs
index c1cd97b15..0ccc6669b 100644
--- a/server/swimos_agent/src/stores/map/mod.rs
+++ b/server/swimos_agent/src/stores/map/mod.rs
@@ -29,7 +29,8 @@ use crate::agent_model::{AgentDescription, WriteResult};
 use crate::event_handler::{ActionContext, HandlerAction, Modification, StepResult};
 use crate::event_queue::EventQueue;
 use crate::item::{AgentItem, InspectableMapLikeItem, MapItem, MapLikeItem, MutableMapLikeItem};
-use crate::map_storage::{MapStoreInner, TransformEntryResult};
+use crate::lanes::map::MapLaneEvent;
+use crate::map_storage::{MapOps, MapOpsWithEntry, MapStoreInner, TransformEntryResult};
 use crate::meta::AgentMetadata;
 
 use super::StoreItem;
@@ -37,24 +38,24 @@ use super::StoreItem;
 #[cfg(test)]
 mod tests;
 
-type Inner<K, V> = MapStoreInner<K, V, EventQueue<K, ()>>;
+type Inner<K, V, M> = MapStoreInner<K, V, EventQueue<K, ()>, M>;
 
 /// Adding a [`MapStore`] to an agent provides additional state that is not exposed as a lane.
 /// If persistence is enabled (and the store is not marked as transient) the state of the store
 /// will be persisted in the same way as the state of a lane.
 #[derive(Debug)]
-pub struct MapStore<K, V> {
+pub struct MapStore<K, V, M = HashMap<K, V>> {
     id: u64,
-    inner: RefCell<Inner<K, V>>,
+    inner: RefCell<Inner<K, V, M>>,
 }
 
 assert_impl_all!(MapStore<(), ()>: Send);
 
-impl<K, V> MapStore<K, V> {
+impl<K, V, M> MapStore<K, V, M> {
     /// # Arguments
     /// * `id` - The ID of the store. This should be unique within an agent.
     /// * `init` - The initial contents of the map.
-    pub fn new(id: u64, init: HashMap<K, V>) -> Self {
+    pub fn new(id: u64, init: M) -> Self {
         MapStore {
             id,
             inner: RefCell::new(Inner::new(init)),
@@ -62,31 +63,33 @@ impl<K, V> MapStore<K, V> {
     }
 }
 
-impl<K, V> AgentItem for MapStore<K, V> {
+impl<K, V, M> AgentItem for MapStore<K, V, M> {
     fn id(&self) -> u64 {
         self.id
     }
 }
 
-impl<K, V> MapItem<K, V> for MapStore<K, V>
+impl<K, V, M> MapItem<K, V, M> for MapStore<K, V, M>
 where
-    K: Eq + Hash + Clone,
+    K: Hash + Eq + Clone,
+    M: MapOps<K, V>,
 {
-    fn init(&self, map: HashMap<K, V>) {
+    fn init(&self, map: M) {
         self.inner.borrow_mut().init(map)
     }
 
     fn read_with_prev<F, R>(&self, f: F) -> R
     where
-        F: FnOnce(Option<crate::lanes::map::MapLaneEvent<K, V>>, &HashMap<K, V>) -> R,
+        F: FnOnce(Option<MapLaneEvent<K, V, M>>, &M) -> R,
     {
         self.inner.borrow_mut().read_with_prev(f)
     }
 }
 
-impl<K, V> MapStore<K, V>
+impl<K, V, M> MapStore<K, V, M>
 where
     K: Clone + Eq + Hash,
+    M: MapOps<K, V>,
 {
     /// Update the value associated with a key.
     pub fn update(&self, key: K, value: V) {
@@ -111,37 +114,36 @@ where
         self.inner.borrow_mut().clear()
     }
 
-    /// Read a value from the map, if it exists.
-    pub fn get<Q, F, R>(&self, key: &Q, f: F) -> R
+    /// Read the complete state of the map.
+    pub fn get_map<F, R>(&self, f: F) -> R
     where
-        K: Borrow<Q> + Eq + Hash,
-        Q: Eq + Hash,
-        F: FnOnce(Option<&V>) -> R,
+        F: FnOnce(&M) -> R,
     {
-        self.inner.borrow().with_entry(key, f)
+        self.inner.borrow().get_map(f)
     }
+}
 
-    /// Read the complete state of the map.
-    pub fn get_map<F, R>(&self, f: F) -> R
+impl<K, V, M> MapStore<K, V, M> {
+    /// Read a value from the map, if it exists.
+    pub fn get<Q, F, R>(&self, key: &Q, f: F) -> R
     where
-        F: FnOnce(&HashMap<K, V>) -> R,
+        K: Borrow<Q>,
+        F: FnOnce(Option<&V>) -> R,
+        M: MapOpsWithEntry<K, V, Q>,
     {
-        self.inner.borrow().get_map(f)
+        self.inner.borrow().with_entry(key, f)
     }
 }
 
-impl<K, V> MapStore<K, V>
-where
-    K: Eq + Hash,
-{
+impl<K, V, M> MapStore<K, V, M> {
     pub fn with_entry<F, B1, B2, U>(&self, key: &B1, f: F) -> U
     where
         B1: ?Sized,
         B2: ?Sized,
         K: Borrow<B1>,
-        B1: Eq + Hash,
         V: Borrow<B2>,
         F: FnOnce(Option<&B2>) -> U,
+        M: MapOpsWithEntry<K, V, B1>,
     {
         self.inner.borrow().with_entry(key, f)
     }
@@ -149,10 +151,11 @@ where
 
 const INFALLIBLE_SER: &str = "Serializing store responses to recon should be infallible.";
 
-impl<K, V> StoreItem for MapStore<K, V>
+impl<K, V, M> StoreItem for MapStore<K, V, M>
 where
     K: Clone + Eq + Hash + StructuralWritable + 'static,
     V: StructuralWritable + 'static,
+    M: MapOps<K, V>,
 {
     fn write_to_buffer(&self, buffer: &mut BytesMut) -> WriteResult {
         let mut encoder = MapStoreResponseEncoder::default();
@@ -171,13 +174,13 @@ where
 }
 
 ///  An [event handler](crate::event_handler::EventHandler)`] that will update the value of an entry in the map.
-pub struct MapStoreUpdate<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>,
+pub struct MapStoreUpdate<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>,
     key_value: Option<(K, V)>,
 }
 
-impl<C, K, V> MapStoreUpdate<C, K, V> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>, key: K, value: V) -> Self {
+impl<C, K, V, M> MapStoreUpdate<C, K, V, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>, key: K, value: V) -> Self {
         MapStoreUpdate {
             projection,
             key_value: Some((key, value)),
@@ -185,10 +188,11 @@ impl<C, K, V> MapStoreUpdate<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapStoreUpdate<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapStoreUpdate<C, K, V, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -230,13 +234,13 @@ where
 }
 
 ///  An [event handler](crate::event_handler::EventHandler)`] that will remove an entry from the map.
-pub struct MapStoreRemove<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>,
+pub struct MapStoreRemove<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>,
     key: Option<K>,
 }
 
-impl<C, K, V> MapStoreRemove<C, K, V> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>, key: K) -> Self {
+impl<C, K, V, M> MapStoreRemove<C, K, V, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>, key: K) -> Self {
         MapStoreRemove {
             projection,
             key: Some(key),
@@ -244,10 +248,11 @@ impl<C, K, V> MapStoreRemove<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapStoreRemove<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapStoreRemove<C, K, V, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -283,13 +288,13 @@ where
 }
 
 ///  An [event handler](crate::event_handler::EventHandler)`] that will clear the map.
-pub struct MapStoreClear<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>,
+pub struct MapStoreClear<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>,
     done: bool,
 }
 
-impl<C, K, V> MapStoreClear<C, K, V> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>) -> Self {
+impl<C, K, V, M> MapStoreClear<C, K, V, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>) -> Self {
         MapStoreClear {
             projection,
             done: false,
@@ -297,10 +302,11 @@ impl<C, K, V> MapStoreClear<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapStoreClear<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapStoreClear<C, K, V, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -337,14 +343,14 @@ where
 }
 
 ///  An [event handler](crate::event_handler::EventHandler)`] that will get an entry from the map.
-pub struct MapStoreGet<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>,
+pub struct MapStoreGet<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>,
     key: K,
     done: bool,
 }
 
-impl<C, K, V> MapStoreGet<C, K, V> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>, key: K) -> Self {
+impl<C, K, V, M> MapStoreGet<C, K, V, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>, key: K) -> Self {
         MapStoreGet {
             projection,
             key,
@@ -353,11 +359,11 @@ impl<C, K, V> MapStoreGet<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapStoreGet<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapStoreGet<C, K, V, M>
 where
     C: AgentDescription,
-    K: Clone + Eq + Hash,
     V: Clone,
+    M: MapOpsWithEntry<K, V, K>,
 {
     type Completion = Option<V>;
 
@@ -375,7 +381,7 @@ where
         if !*done {
             *done = true;
             let store = projection(context);
-            StepResult::done(store.get(key, |v| v.cloned()))
+            StepResult::done(MapStore::get(store, key, |v| v.cloned()))
         } else {
             StepResult::after_done()
         }
@@ -393,13 +399,13 @@ where
 }
 
 ///  An [event handler](crate::event_handler::EventHandler)`] that will read the entire state of a map store.
-pub struct MapStoreGetMap<C, K, V> {
-    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>,
+pub struct MapStoreGetMap<C, K, V, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>,
     done: bool,
 }
 
-impl<C, K, V> MapStoreGetMap<C, K, V> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>) -> Self {
+impl<C, K, V, M> MapStoreGetMap<C, K, V, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>) -> Self {
         MapStoreGetMap {
             projection,
             done: false,
@@ -407,13 +413,14 @@ impl<C, K, V> MapStoreGetMap<C, K, V> {
     }
 }
 
-impl<C, K, V> HandlerAction<C> for MapStoreGetMap<C, K, V>
+impl<C, K, V, M> HandlerAction<C> for MapStoreGetMap<C, K, V, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
     V: Clone,
+    M: MapOps<K, V> + Clone,
 {
-    type Completion = HashMap<K, V>;
+    type Completion = M;
 
     fn step(
         &mut self,
@@ -443,13 +450,13 @@ where
 }
 
 ///  An [event handler](crate::event_handler::EventHandler)`] that may alter an entry in the map.
-pub struct MapStoreTransformEntry<C, K, V, F> {
-    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>,
+pub struct MapStoreTransformEntry<C, K, V, F, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>,
     key_and_f: Option<(K, F)>,
 }
 
-impl<C, K, V, F> MapStoreTransformEntry<C, K, V, F> {
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>, key: K, f: F) -> Self {
+impl<C, K, V, F, M> MapStoreTransformEntry<C, K, V, F, M> {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>, key: K, f: F) -> Self {
         MapStoreTransformEntry {
             projection,
             key_and_f: Some((key, f)),
@@ -457,11 +464,12 @@ impl<C, K, V, F> MapStoreTransformEntry<C, K, V, F> {
     }
 }
 
-impl<C, K, V, F> HandlerAction<C> for MapStoreTransformEntry<C, K, V, F>
+impl<C, K, V, F, M> HandlerAction<C> for MapStoreTransformEntry<C, K, V, F, M>
 where
     C: AgentDescription,
     K: Clone + Eq + Hash,
     F: FnOnce(Option<&V>) -> Option<V>,
+    M: MapOps<K, V>,
 {
     type Completion = ();
 
@@ -511,18 +519,18 @@ where
 
 /// A [handler action][`HandlerAction`] that will produce a value by applying a closure to a reference to
 /// and entry in the store.
-pub struct MapStoreWithEntry<C, K, V, F, B: ?Sized> {
-    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>,
+pub struct MapStoreWithEntry<C, K, V, F, B: ?Sized, M = HashMap<K, V>> {
+    projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>,
     key_and_f: Option<(K, F)>,
     _type: PhantomData<fn(&B)>,
 }
 
-impl<C, K, V, F, B: ?Sized> MapStoreWithEntry<C, K, V, F, B> {
+impl<C, K, V, F, B: ?Sized, M> MapStoreWithEntry<C, K, V, F, B, M> {
     /// #Arguments
     /// * `projection` - Projection from the agent context to the store.
     /// * `key` - Key of the entry.
     /// * `f` - The closure to apply to the entry.
-    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V>, key: K, f: F) -> Self {
+    pub fn new(projection: for<'a> fn(&'a C) -> &'a MapStore<K, V, M>, key: K, f: F) -> Self {
         MapStoreWithEntry {
             projection,
             key_and_f: Some((key, f)),
@@ -531,13 +539,13 @@ impl<C, K, V, F, B: ?Sized> MapStoreWithEntry<C, K, V, F, B> {
     }
 }
 
-impl<C, K, V, F, B, U> HandlerAction<C> for MapStoreWithEntry<C, K, V, F, B>
+impl<C, K, V, F, B, U, M> HandlerAction<C> for MapStoreWithEntry<C, K, V, F, B, M>
 where
     C: AgentDescription,
-    K: Eq + Hash,
     B: ?Sized,
     V: Borrow<B>,
     F: FnOnce(Option<&B>) -> U,
+    M: MapOpsWithEntry<K, V, K>,
 {
     type Completion = U;
 
@@ -571,12 +579,13 @@ where
             .finish()
     }
 }
-impl<K, V> MapLikeItem<K, V> for MapStore<K, V>
+impl<K, V, M> MapLikeItem<K, V, M> for MapStore<K, V, M>
 where
     K: Clone + Eq + Hash + Send + 'static,
     V: Clone + 'static,
+    M: MapOpsWithEntry<K, V, K> + Clone + 'static,
 {
-    type GetHandler<C> = MapStoreGet<C, K, V>
+    type GetHandler<C> = MapStoreGet<C, K, V, M>
     where
         C: AgentDescription + 'static;
 
@@ -587,7 +596,7 @@ where
         MapStoreGet::new(projection, key)
     }
 
-    type GetMapHandler<C> = MapStoreGetMap<C, K, V>
+    type GetMapHandler<C> = MapStoreGetMap<C, K, V, M>
     where
         C: AgentDescription + 'static;
 
@@ -598,49 +607,48 @@ where
     }
 }
 
-impl<K, V> InspectableMapLikeItem<K, V> for MapStore<K, V>
+impl<K, V, M, B> InspectableMapLikeItem<K, V, B> for MapStore<K, V, M>
 where
-    K: Eq + Hash + Send + 'static,
-    V: 'static,
+    K: Send + 'static,
+    V: Borrow<B> + 'static,
+    B: ?Sized + 'static,
+    M: MapOpsWithEntry<K, V, K>,
 {
-    type WithEntryHandler<'a, C, F, B, U> = MapStoreWithEntry<C, K, V, F, B>
+    type WithEntryHandler<'a, C, F, U> = MapStoreWithEntry<C, K, V, F, B, M>
     where
         Self: 'static,
         C: AgentDescription + 'a,
-        B: ?Sized +'static,
-        V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U + Send + 'a;
 
-    fn with_entry_handler<'a, C, F, B, U>(
+    fn with_entry_handler<'a, C, F, U>(
         projection: fn(&C) -> &Self,
         key: K,
         f: F,
-    ) -> Self::WithEntryHandler<'a, C, F, B, U>
+    ) -> Self::WithEntryHandler<'a, C, F, U>
     where
         Self: 'static,
         C: AgentDescription + 'a,
-        B: ?Sized + 'static,
-        V: Borrow<B>,
         F: FnOnce(Option<&B>) -> U + Send + 'a,
     {
         MapStoreWithEntry::new(projection, key, f)
     }
 }
 
-impl<K, V> MutableMapLikeItem<K, V> for MapStore<K, V>
+impl<K, V, M> MutableMapLikeItem<K, V> for MapStore<K, V, M>
 where
     K: Clone + Eq + Hash + Send + 'static,
     V: Send + 'static,
+    M: MapOps<K, V> + 'static,
 {
-    type UpdateHandler<C> = MapStoreUpdate<C, K, V>
+    type UpdateHandler<C> = MapStoreUpdate<C, K, V, M>
     where
         C: AgentDescription + 'static;
 
-    type RemoveHandler<C> = MapStoreRemove<C, K, V>
+    type RemoveHandler<C> = MapStoreRemove<C, K, V, M>
     where
         C: AgentDescription + 'static;
 
-    type ClearHandler<C> = MapStoreClear<C, K, V>
+    type ClearHandler<C> = MapStoreClear<C, K, V, M>
     where
         C: AgentDescription + 'static;
 
@@ -665,7 +673,7 @@ where
         MapStoreClear::new(projection)
     }
 
-    type TransformEntryHandler<'a, C, F> = MapStoreTransformEntry<C, K, V, F>
+    type TransformEntryHandler<'a, C, F> = MapStoreTransformEntry<C, K, V, F, M>
     where
         Self: 'static,
         C: AgentDescription + 'a,
diff --git a/server/swimos_agent/src/tests.rs b/server/swimos_agent/src/tests.rs
index 5a4ecef2b..d51016d49 100644
--- a/server/swimos_agent/src/tests.rs
+++ b/server/swimos_agent/src/tests.rs
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashSet;
+use std::collections::{BTreeMap, HashSet};
 use std::hash::Hash;
 use std::{collections::HashMap, sync::Arc};
 
@@ -2276,3 +2276,296 @@ fn on_delete_handler() {
         ow => panic!("Events not as expected: {:?}", ow),
     }
 }
+
+#[derive(AgentLaneModel)]
+#[agent(root(crate))]
+struct OrderedMapsAgent {
+    lane: MapLane<i32, u64, BTreeMap<i32, u64>>,
+    store: MapStore<i32, u64, BTreeMap<i32, u64>>,
+}
+
+const OV1: u64 = 8374749;
+const OV2: u64 = 128374747;
+
+impl OrderedMapsAgent {
+    fn with_data() -> Self {
+        let content = init_ordered();
+        OrderedMapsAgent {
+            lane: MapLane::new(0, content.clone()),
+            store: MapStore::new(1, content),
+        }
+    }
+}
+
+fn init_ordered() -> BTreeMap<i32, u64> {
+    let mut content = BTreeMap::new();
+    content.insert(K1, OV1);
+    content.insert(K2, OV2);
+    content
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum OrderedMapEvent {
+    Clear(BTreeMap<i32, u64>),
+    Remove(BTreeMap<i32, u64>, i32, u64),
+    Update(BTreeMap<i32, u64>, i32, Option<u64>),
+}
+
+#[derive(Default, Debug, Clone)]
+struct OrderedMapLifecycle {
+    events: Arc<Mutex<Vec<OrderedMapEvent>>>,
+}
+
+impl OrderedMapLifecycle {
+    fn push(&self, event: OrderedMapEvent) {
+        self.events.lock().push(event)
+    }
+
+    fn take(&self) -> Vec<OrderedMapEvent> {
+        let mut guard = self.events.lock();
+        std::mem::take(&mut *guard)
+    }
+}
+
+#[test]
+fn on_update_handler_lane_ordered() {
+    #[derive(Default, Clone)]
+    struct TestLifecycle(OrderedMapLifecycle);
+
+    #[lifecycle(OrderedMapsAgent, agent_root(crate))]
+    impl TestLifecycle {
+        #[on_update(lane)]
+        fn my_on_update(
+            &self,
+            context: HandlerContext<OrderedMapsAgent>,
+            map: &BTreeMap<i32, u64>,
+            key: i32,
+            prev: Option<u64>,
+            _new_value: &u64,
+        ) -> impl EventHandler<OrderedMapsAgent> + '_ {
+            let map_state = map.clone();
+            context.effect(move || {
+                self.0.push(OrderedMapEvent::Update(map_state, key, prev));
+            })
+        }
+    }
+
+    let agent = OrderedMapsAgent::default();
+    let template = TestLifecycle::default();
+
+    let lifecycle = template.clone().into_lifecycle();
+
+    let v = 657383;
+    agent.lane.update(K2, v);
+    let handler = lifecycle
+        .item_event(&agent, "lane")
+        .expect("Expected handler for lane.");
+    run_handler(&agent, handler);
+
+    let events = template.0.take();
+
+    let mut expected_map = BTreeMap::new();
+    expected_map.insert(K2, v);
+    assert_eq!(
+        events,
+        vec![OrderedMapEvent::Update(expected_map, K2, None)]
+    );
+}
+
+#[test]
+fn on_update_handler_store_ordered() {
+    #[derive(Default, Clone)]
+    struct TestLifecycle(OrderedMapLifecycle);
+
+    #[lifecycle(OrderedMapsAgent, agent_root(crate))]
+    impl TestLifecycle {
+        #[on_update(store)]
+        fn my_on_update(
+            &self,
+            context: HandlerContext<OrderedMapsAgent>,
+            map: &BTreeMap<i32, u64>,
+            key: i32,
+            prev: Option<u64>,
+            _new_value: &u64,
+        ) -> impl EventHandler<OrderedMapsAgent> + '_ {
+            let map_state = map.clone();
+            context.effect(move || {
+                self.0.push(OrderedMapEvent::Update(map_state, key, prev));
+            })
+        }
+    }
+
+    let agent = OrderedMapsAgent::default();
+    let template = TestLifecycle::default();
+
+    let lifecycle = template.clone().into_lifecycle();
+
+    let v = 93747;
+    agent.store.update(K2, v);
+    let handler = lifecycle
+        .item_event(&agent, "store")
+        .expect("Expected handler for lane.");
+    run_handler(&agent, handler);
+
+    let events = template.0.take();
+
+    let mut expected_map = BTreeMap::new();
+    expected_map.insert(K2, v);
+    assert_eq!(
+        events,
+        vec![OrderedMapEvent::Update(expected_map, K2, None)]
+    );
+}
+
+#[test]
+fn on_remove_handler_lane_ordered() {
+    #[derive(Default, Clone)]
+    struct TestLifecycle(OrderedMapLifecycle);
+
+    #[lifecycle(OrderedMapsAgent, agent_root(crate))]
+    impl TestLifecycle {
+        #[on_remove(lane)]
+        fn my_on_remove(
+            &self,
+            context: HandlerContext<OrderedMapsAgent>,
+            map: &BTreeMap<i32, u64>,
+            key: i32,
+            prev: u64,
+        ) -> impl EventHandler<OrderedMapsAgent> + '_ {
+            let map_state = map.clone();
+            context.effect(move || {
+                self.0.push(OrderedMapEvent::Remove(map_state, key, prev));
+            })
+        }
+    }
+
+    let agent = OrderedMapsAgent::with_data();
+    let template = TestLifecycle::default();
+
+    let lifecycle = template.clone().into_lifecycle();
+
+    agent.lane.remove(&K2);
+    let handler = lifecycle
+        .item_event(&agent, "lane")
+        .expect("Expected handler for lane.");
+    run_handler(&agent, handler);
+
+    let events = template.0.take();
+
+    let mut expected_map = BTreeMap::new();
+    expected_map.insert(K1, OV1);
+    assert_eq!(events, vec![OrderedMapEvent::Remove(expected_map, K2, OV2)]);
+}
+
+#[test]
+fn on_remove_handler_store_ordered() {
+    #[derive(Default, Clone)]
+    struct TestLifecycle(OrderedMapLifecycle);
+
+    #[lifecycle(OrderedMapsAgent, agent_root(crate))]
+    impl TestLifecycle {
+        #[on_remove(store)]
+        fn my_on_remove(
+            &self,
+            context: HandlerContext<OrderedMapsAgent>,
+            map: &BTreeMap<i32, u64>,
+            key: i32,
+            prev: u64,
+        ) -> impl EventHandler<OrderedMapsAgent> + '_ {
+            let map_state = map.clone();
+            context.effect(move || {
+                self.0.push(OrderedMapEvent::Remove(map_state, key, prev));
+            })
+        }
+    }
+
+    let agent = OrderedMapsAgent::with_data();
+    let template = TestLifecycle::default();
+
+    let lifecycle = template.clone().into_lifecycle();
+
+    agent.store.remove(&K2);
+    let handler = lifecycle
+        .item_event(&agent, "store")
+        .expect("Expected handler for lane.");
+    run_handler(&agent, handler);
+
+    let events = template.0.take();
+
+    let mut expected_map = BTreeMap::new();
+    expected_map.insert(K1, OV1);
+    expected_map.insert(K1, OV1);
+    assert_eq!(events, vec![OrderedMapEvent::Remove(expected_map, K2, OV2)]);
+}
+
+#[test]
+fn on_clear_handler_lane_ordered() {
+    #[derive(Default, Clone)]
+    struct TestLifecycle(OrderedMapLifecycle);
+
+    #[lifecycle(OrderedMapsAgent, agent_root(crate))]
+    impl TestLifecycle {
+        #[on_clear(lane)]
+        fn my_on_clear(
+            &self,
+            context: HandlerContext<OrderedMapsAgent>,
+            map: BTreeMap<i32, u64>,
+        ) -> impl EventHandler<OrderedMapsAgent> + '_ {
+            context.effect(move || {
+                self.0.push(OrderedMapEvent::Clear(map));
+            })
+        }
+    }
+
+    let agent = OrderedMapsAgent::with_data();
+    let template = TestLifecycle::default();
+
+    let lifecycle = template.clone().into_lifecycle();
+
+    agent.lane.clear();
+    let handler = lifecycle
+        .item_event(&agent, "lane")
+        .expect("Expected handler for lane.");
+    run_handler(&agent, handler);
+
+    let events = template.0.take();
+
+    let expected_map = init_ordered();
+    assert_eq!(events, vec![OrderedMapEvent::Clear(expected_map)]);
+}
+
+#[test]
+fn on_clear_handler_store_ordered() {
+    #[derive(Default, Clone)]
+    struct TestLifecycle(OrderedMapLifecycle);
+
+    #[lifecycle(OrderedMapsAgent, agent_root(crate))]
+    impl TestLifecycle {
+        #[on_clear(store)]
+        fn my_on_clear(
+            &self,
+            context: HandlerContext<OrderedMapsAgent>,
+            map: BTreeMap<i32, u64>,
+        ) -> impl EventHandler<OrderedMapsAgent> + '_ {
+            context.effect(move || {
+                self.0.push(OrderedMapEvent::Clear(map));
+            })
+        }
+    }
+
+    let agent = OrderedMapsAgent::with_data();
+    let template = TestLifecycle::default();
+
+    let lifecycle = template.clone().into_lifecycle();
+
+    agent.store.clear();
+    let handler = lifecycle
+        .item_event(&agent, "store")
+        .expect("Expected handler for lane.");
+    run_handler(&agent, handler);
+
+    let events = template.0.take();
+
+    let expected_map = init_ordered();
+    assert_eq!(events, vec![OrderedMapEvent::Clear(expected_map)]);
+}
diff --git a/server/swimos_agent_derive/src/agent_lifecycle/mod.rs b/server/swimos_agent_derive/src/agent_lifecycle/mod.rs
index 0ed5ff38b..2cad981af 100644
--- a/server/swimos_agent_derive/src/agent_lifecycle/mod.rs
+++ b/server/swimos_agent_derive/src/agent_lifecycle/mod.rs
@@ -170,7 +170,7 @@ impl<'a> LaneLifecycleBuilder<'a> {
                 ..
             }) => {
                 let mut builder: syn::Expr = parse_quote! {
-                    <#root::lanes::map::lifecycle::StatefulMapLaneLifecycle::<#agent_type, #lifecycle_type, _, _> as ::core::default::Default>::default()
+                    <#root::lanes::map::lifecycle::StatefulMapLaneLifecycle::<#agent_type, #lifecycle_type, _, _, _> as ::core::default::Default>::default()
                 };
                 if let Some(handler) = on_update {
                     builder = parse_quote! {
diff --git a/server/swimos_agent_derive/src/agent_lifecycle/model.rs b/server/swimos_agent_derive/src/agent_lifecycle/model.rs
index 0f02c3322..103a0f0eb 100644
--- a/server/swimos_agent_derive/src/agent_lifecycle/model.rs
+++ b/server/swimos_agent_derive/src/agent_lifecycle/model.rs
@@ -347,42 +347,33 @@ fn validate_method_as<'a>(
                     Validation::valid(acc)
                 })
             }
-            HandlerKind::Update => Validation::join(
-                acc,
-                validate_typed_sig(sig, 4, true).and_then(|t| hash_map_type_params(sig, t)),
-            )
-            .and_then(|(mut acc, (k, v))| {
-                for target in targets {
-                    if let Err(e) = acc.add_on_update(target, k, v, &sig.ident) {
-                        return Validation::Validated(acc, Errors::of(e));
+            HandlerKind::Update => Validation::join(acc, validate_typed_sig(sig, 4, true))
+                .and_then(|(mut acc, map_t)| {
+                    for target in targets {
+                        if let Err(e) = acc.add_on_update(target, map_t, &sig.ident) {
+                            return Validation::Validated(acc, Errors::of(e));
+                        }
                     }
-                }
-                Validation::valid(acc)
-            }),
-            HandlerKind::Remove => Validation::join(
-                acc,
-                validate_typed_sig(sig, 3, true).and_then(|t| hash_map_type_params(sig, t)),
-            )
-            .and_then(|(mut acc, (k, v))| {
-                for target in targets {
-                    if let Err(e) = acc.add_on_remove(target, k, v, &sig.ident) {
-                        return Validation::Validated(acc, Errors::of(e));
+                    Validation::valid(acc)
+                }),
+            HandlerKind::Remove => Validation::join(acc, validate_typed_sig(sig, 3, true))
+                .and_then(|(mut acc, map_t)| {
+                    for target in targets {
+                        if let Err(e) = acc.add_on_remove(target, map_t, &sig.ident) {
+                            return Validation::Validated(acc, Errors::of(e));
+                        }
                     }
-                }
-                Validation::valid(acc)
-            }),
-            HandlerKind::Clear => Validation::join(
-                acc,
-                validate_typed_sig(sig, 1, false).and_then(|t| hash_map_type_params(sig, t)),
-            )
-            .and_then(|(mut acc, (k, v))| {
-                for target in targets {
-                    if let Err(e) = acc.add_on_clear(target, k, v, &sig.ident) {
-                        return Validation::Validated(acc, Errors::of(e));
+                    Validation::valid(acc)
+                }),
+            HandlerKind::Clear => Validation::join(acc, validate_typed_sig(sig, 1, false))
+                .and_then(|(mut acc, map_t)| {
+                    for target in targets {
+                        if let Err(e) = acc.add_on_clear(target, map_t, &sig.ident) {
+                            return Validation::Validated(acc, Errors::of(e));
+                        }
                     }
-                }
-                Validation::valid(acc)
-            }),
+                    Validation::valid(acc)
+                }),
             HandlerKind::JoinMap => Validation::join(acc, validate_join_map_lifecycle_sig(sig))
                 .and_then(|(mut acc, (_l, k, v))| {
                     for target in targets {
@@ -847,36 +838,11 @@ fn peel_ref_type<'a>(
     }
 }
 
-const HASH_MAP: &str = "HashMap";
 const OPTION: &str = "Option";
 const HASH_SET: &str = "HashSet";
 const RESPONSE: &str = "Response";
 const UNIT_RESPONSE: &str = "UnitResponse";
 
-fn hash_map_type_params<'a>(
-    sig: &Signature,
-    map_type: &'a Type,
-) -> Validation<(&'a Type, &'a Type), Errors<syn::Error>> {
-    match map_type {
-        Type::Path(TypePath { qself: None, path }) => match path.segments.last() {
-            Some(PathSegment {
-                ident,
-                arguments:
-                    PathArguments::AngleBracketed(AngleBracketedGenericArguments { args, .. }),
-            }) if ident == HASH_MAP && (args.len() == 2 || args.len() == 3) => {
-                match (&args[0], &args[1]) {
-                    (GenericArgument::Type(key_type), GenericArgument::Type(value_type)) => {
-                        Validation::valid((key_type, value_type))
-                    }
-                    _ => Validation::fail(syn::Error::new_spanned(sig, BAD_SIGNATURE)),
-                }
-            }
-            _ => Validation::fail(syn::Error::new_spanned(sig, BAD_SIGNATURE)),
-        },
-        _ => Validation::fail(syn::Error::new_spanned(sig, BAD_SIGNATURE)),
-    }
-}
-
 fn extract_option_type_param<'a>(
     sig: &Signature,
     parameterized: &'a Type,
@@ -1545,8 +1511,7 @@ impl<'a> AgentLifecycleDescriptorBuilder<'a> {
     pub fn add_on_update(
         &mut self,
         name: String,
-        key_type: &'a Type,
-        value_type: &'a Type,
+        map_type: &'a Type,
         method: &'a Ident,
     ) -> Result<(), syn::Error> {
         let AgentLifecycleDescriptorBuilder {
@@ -1585,9 +1550,8 @@ impl<'a> AgentLifecycleDescriptorBuilder<'a> {
                 method,
                 format!("Lane '{}' has both map and HTTP lane event handlers.", name),
             )),
-            Some(ItemLifecycle::Map(desc)) => desc.add_on_update(key_type, value_type, method),
+            Some(ItemLifecycle::Map(desc)) => desc.add_on_update(map_type, method),
             _ => {
-                let map_type = (key_type, value_type);
                 lane_lifecycles.insert(
                     name.clone(),
                     ItemLifecycle::Map(MapLifecycleDescriptor::new_on_update(
@@ -1602,8 +1566,7 @@ impl<'a> AgentLifecycleDescriptorBuilder<'a> {
     pub fn add_on_remove(
         &mut self,
         name: String,
-        key_type: &'a Type,
-        value_type: &'a Type,
+        map_type: &'a Type,
         method: &'a Ident,
     ) -> Result<(), syn::Error> {
         let AgentLifecycleDescriptorBuilder {
@@ -1642,9 +1605,8 @@ impl<'a> AgentLifecycleDescriptorBuilder<'a> {
                 method,
                 format!("Lane '{}' has both map and HTTP lane event handlers.", name),
             )),
-            Some(ItemLifecycle::Map(desc)) => desc.add_on_remove(key_type, value_type, method),
+            Some(ItemLifecycle::Map(desc)) => desc.add_on_remove(map_type, method),
             _ => {
-                let map_type = (key_type, value_type);
                 lane_lifecycles.insert(
                     name.clone(),
                     ItemLifecycle::Map(MapLifecycleDescriptor::new_on_remove(
@@ -1659,8 +1621,7 @@ impl<'a> AgentLifecycleDescriptorBuilder<'a> {
     pub fn add_on_clear(
         &mut self,
         name: String,
-        key_type: &'a Type,
-        value_type: &'a Type,
+        map_type: &'a Type,
         method: &'a Ident,
     ) -> Result<(), syn::Error> {
         let AgentLifecycleDescriptorBuilder {
@@ -1699,9 +1660,8 @@ impl<'a> AgentLifecycleDescriptorBuilder<'a> {
                 method,
                 format!("Lane '{}' has both map and HTTP lane event handlers.", name),
             )),
-            Some(ItemLifecycle::Map(desc)) => desc.add_on_clear(key_type, value_type, method),
+            Some(ItemLifecycle::Map(desc)) => desc.add_on_clear(map_type, method),
             _ => {
-                let map_type = (key_type, value_type);
                 lane_lifecycles.insert(
                     name.clone(),
                     ItemLifecycle::Map(MapLifecycleDescriptor::new_on_clear(
@@ -2214,10 +2174,29 @@ pub enum JoinLifecycle<'a> {
     JoinValue(&'a Ident),
 }
 
+#[derive(Hash, PartialEq, Eq)]
+pub enum MapType<'a> {
+    Combined(&'a Type),
+    Extracted(&'a Type, &'a Type),
+}
+
+impl<'a> From<&'a Type> for MapType<'a> {
+    fn from(t: &'a Type) -> Self {
+        MapType::Combined(t)
+    }
+}
+
+impl<'a> From<(&'a Type, &'a Type)> for MapType<'a> {
+    fn from(kv: (&'a Type, &'a Type)) -> Self {
+        let (k, v) = kv;
+        MapType::Extracted(k, v)
+    }
+}
+
 pub struct MapLifecycleDescriptor<'a> {
-    name: String,                                          //The name of the lane.
-    primary_lane_type: (&'a Type, &'a Type),               //First observed type of the lane.
-    alternative_lane_types: HashSet<(&'a Type, &'a Type)>, //Further types observed for the lane.
+    name: String,                                 //The name of the lane.
+    primary_lane_type: MapType<'a>,               //First observed type of the lane.
+    alternative_lane_types: HashSet<MapType<'a>>, //Further types observed for the lane.
     pub on_update: Option<&'a Ident>,
     pub on_remove: Option<&'a Ident>,
     pub on_clear: Option<&'a Ident>,
@@ -2335,14 +2314,10 @@ impl<'a> HttpLifecycleDescriptor<'a> {
 }
 
 impl<'a> MapLifecycleDescriptor<'a> {
-    pub fn new_on_update(
-        name: String,
-        map_type: (&'a Type, &'a Type),
-        on_update: &'a Ident,
-    ) -> Self {
+    pub fn new_on_update(name: String, map_type: &'a Type, on_update: &'a Ident) -> Self {
         MapLifecycleDescriptor {
             name,
-            primary_lane_type: map_type,
+            primary_lane_type: MapType::from(map_type),
             alternative_lane_types: Default::default(),
             on_update: Some(on_update),
             on_remove: None,
@@ -2351,14 +2326,10 @@ impl<'a> MapLifecycleDescriptor<'a> {
         }
     }
 
-    pub fn new_on_remove(
-        name: String,
-        map_type: (&'a Type, &'a Type),
-        on_remove: &'a Ident,
-    ) -> Self {
+    pub fn new_on_remove(name: String, map_type: &'a Type, on_remove: &'a Ident) -> Self {
         MapLifecycleDescriptor {
             name,
-            primary_lane_type: map_type,
+            primary_lane_type: MapType::from(map_type),
             alternative_lane_types: Default::default(),
             on_update: None,
             on_remove: Some(on_remove),
@@ -2367,10 +2338,10 @@ impl<'a> MapLifecycleDescriptor<'a> {
         }
     }
 
-    pub fn new_on_clear(name: String, map_type: (&'a Type, &'a Type), on_clear: &'a Ident) -> Self {
+    pub fn new_on_clear(name: String, map_type: &'a Type, on_clear: &'a Ident) -> Self {
         MapLifecycleDescriptor {
             name,
-            primary_lane_type: map_type,
+            primary_lane_type: MapType::from(map_type),
             alternative_lane_types: Default::default(),
             on_update: None,
             on_remove: None,
@@ -2386,7 +2357,7 @@ impl<'a> MapLifecycleDescriptor<'a> {
     ) -> Self {
         MapLifecycleDescriptor {
             name,
-            primary_lane_type: map_type,
+            primary_lane_type: MapType::from(map_type),
             alternative_lane_types: Default::default(),
             on_update: None,
             on_remove: None,
@@ -2402,7 +2373,7 @@ impl<'a> MapLifecycleDescriptor<'a> {
     ) -> Self {
         MapLifecycleDescriptor {
             name,
-            primary_lane_type: map_type,
+            primary_lane_type: MapType::from(map_type),
             alternative_lane_types: Default::default(),
             on_update: None,
             on_remove: None,
@@ -2413,8 +2384,7 @@ impl<'a> MapLifecycleDescriptor<'a> {
 
     pub fn add_on_update(
         &mut self,
-        key_type: &'a Type,
-        value_type: &'a Type,
+        map_type: &'a Type,
         method: &'a Ident,
     ) -> Result<(), syn::Error> {
         let MapLifecycleDescriptor {
@@ -2424,15 +2394,15 @@ impl<'a> MapLifecycleDescriptor<'a> {
             on_update,
             ..
         } = self;
-        let map_type = (key_type, value_type);
         if on_update.is_some() {
             Err(syn::Error::new_spanned(
                 method,
                 format!("Duplicate on_update handler for '{}'.", name),
             ))
         } else {
-            if map_type != *primary_lane_type {
-                alternative_lane_types.insert(map_type);
+            let map_t = MapType::from(map_type);
+            if map_t != *primary_lane_type {
+                alternative_lane_types.insert(map_t);
             }
             *on_update = Some(method);
             Ok(())
@@ -2441,8 +2411,7 @@ impl<'a> MapLifecycleDescriptor<'a> {
 
     pub fn add_on_remove(
         &mut self,
-        key_type: &'a Type,
-        value_type: &'a Type,
+        map_type: &'a Type,
         method: &'a Ident,
     ) -> Result<(), syn::Error> {
         let MapLifecycleDescriptor {
@@ -2452,15 +2421,15 @@ impl<'a> MapLifecycleDescriptor<'a> {
             on_remove,
             ..
         } = self;
-        let map_type = (key_type, value_type);
         if on_remove.is_some() {
             Err(syn::Error::new_spanned(
                 method,
                 format!("Duplicate on_remove handler for '{}'.", name),
             ))
         } else {
-            if map_type != *primary_lane_type {
-                alternative_lane_types.insert(map_type);
+            let map_t = MapType::from(map_type);
+            if map_t != *primary_lane_type {
+                alternative_lane_types.insert(map_t);
             }
             *on_remove = Some(method);
             Ok(())
@@ -2469,8 +2438,7 @@ impl<'a> MapLifecycleDescriptor<'a> {
 
     pub fn add_on_clear(
         &mut self,
-        key_type: &'a Type,
-        value_type: &'a Type,
+        map_type: &'a Type,
         method: &'a Ident,
     ) -> Result<(), syn::Error> {
         let MapLifecycleDescriptor {
@@ -2480,15 +2448,15 @@ impl<'a> MapLifecycleDescriptor<'a> {
             on_clear,
             ..
         } = self;
-        let map_type = (key_type, value_type);
         if on_clear.is_some() {
             Err(syn::Error::new_spanned(
                 method,
                 format!("Duplicate on_clear handler for '{}'.", name),
             ))
         } else {
-            if map_type != *primary_lane_type {
-                alternative_lane_types.insert(map_type);
+            let map_t = MapType::from(map_type);
+            if map_t != *primary_lane_type {
+                alternative_lane_types.insert(map_t);
             }
             *on_clear = Some(method);
             Ok(())
@@ -2512,8 +2480,9 @@ impl<'a> MapLifecycleDescriptor<'a> {
         match join_lifecycle {
             JoinLifecycle::None => {
                 *join_lifecycle = JoinLifecycle::JoinValue(method);
-                if map_type != *primary_lane_type {
-                    alternative_lane_types.insert(map_type);
+                let map_t = MapType::from(map_type);
+                if map_t != *primary_lane_type {
+                    alternative_lane_types.insert(map_t);
                 }
                 Ok(())
             }
@@ -2541,8 +2510,9 @@ impl<'a> MapLifecycleDescriptor<'a> {
         match join_lifecycle {
             JoinLifecycle::None => {
                 *join_lifecycle = JoinLifecycle::JoinMap(method);
-                if map_type != *primary_lane_type {
-                    alternative_lane_types.insert(map_type);
+                let map_t = MapType::from(map_type);
+                if map_t != *primary_lane_type {
+                    alternative_lane_types.insert(map_t);
                 }
                 Ok(())
             }
diff --git a/server/swimos_agent_derive/src/lane_model_derive/mod.rs b/server/swimos_agent_derive/src/lane_model_derive/mod.rs
index b116dca0f..d29ef8412 100644
--- a/server/swimos_agent_derive/src/lane_model_derive/mod.rs
+++ b/server/swimos_agent_derive/src/lane_model_derive/mod.rs
@@ -345,7 +345,7 @@ impl<'a> OrdinalWarpLaneModel<'a> {
     pub fn map_like(&self) -> bool {
         matches!(
             &self.model.kind,
-            WarpLaneSpec::Map(_, _)
+            WarpLaneSpec::Map(_, _, _)
                 | WarpLaneSpec::DemandMap(_, _)
                 | WarpLaneSpec::JoinValue(_, _)
                 | WarpLaneSpec::JoinMap(_, _, _)
@@ -391,7 +391,7 @@ impl<'a> OrdinalItemModel<'a> {
 
     fn category(&self) -> ItemCategory {
         match &self.model.kind {
-            ItemSpec::Map(_, _, _)
+            ItemSpec::Map(_, _, _, _)
             | ItemSpec::JoinValue(_, _)
             | ItemSpec::JoinMap(_, _, _)
             | ItemSpec::DemandMap(_, _) => ItemCategory::MapLike,
@@ -430,10 +430,10 @@ impl<'a> FieldInitializer<'a> {
             ItemSpec::Value(ItemKind::Store, _) => {
                 quote!(#name: #root::stores::ValueStore::new(#ordinal, ::core::default::Default::default()))
             }
-            ItemSpec::Map(ItemKind::Lane, _, _) => {
+            ItemSpec::Map(ItemKind::Lane, _, _, _) => {
                 quote!(#name: #root::lanes::MapLane::new(#ordinal, ::core::default::Default::default()))
             }
-            ItemSpec::Map(ItemKind::Store, _, _) => {
+            ItemSpec::Map(ItemKind::Store, _, _, _) => {
                 quote!(#name: #root::stores::MapStore::new(#ordinal, ::core::default::Default::default()))
             }
             ItemSpec::JoinValue(_, _) => {
@@ -470,8 +470,12 @@ impl<'a> HandlerType<'a> {
             WarpLaneSpec::Value(t) => {
                 quote!(#root::lanes::value::DecodeAndSet<#agent_name, #t>)
             }
-            WarpLaneSpec::Map(k, v) => {
-                quote!(#root::lanes::map::DecodeAndApply<#agent_name, #k, #v>)
+            WarpLaneSpec::Map(k, v, m) => {
+                if let Some(map_t) = m {
+                    quote!(#root::lanes::map::DecodeAndApply<#agent_name, #k, #v, #map_t>)
+                } else {
+                    quote!(#root::lanes::map::DecodeAndApply<#agent_name, #k, #v>)
+                }
             }
             WarpLaneSpec::Demand(_)
             | WarpLaneSpec::DemandMap(_, _)
@@ -503,8 +507,12 @@ impl<'a> SyncHandlerType<'a> {
             WarpLaneSpec::Value(t) => {
                 quote!(#root::lanes::value::ValueLaneSync<#agent_name, #t>)
             }
-            WarpLaneSpec::Map(k, v) => {
-                quote!(#root::lanes::map::MapLaneSync<#agent_name, #k, #v>)
+            WarpLaneSpec::Map(k, v, m) => {
+                if let Some(map_t) = m {
+                    quote!(#root::lanes::map::MapLaneSync<#agent_name, #k, #v, #map_t>)
+                } else {
+                    quote!(#root::lanes::map::MapLaneSync<#agent_name, #k, #v>)
+                }
             }
             WarpLaneSpec::JoinValue(k, v) => {
                 quote!(#root::lanes::join_value::JoinValueLaneSync<#agent_name, #k, #v>)
@@ -568,8 +576,12 @@ impl<'a> WarpLaneHandlerMatch<'a> {
             WarpLaneSpec::Value(ty) => {
                 quote!(#root::lanes::value::decode_and_set::<#agent_name, #ty>(body, |agent: &#agent_name| &agent.#name))
             }
-            WarpLaneSpec::Map(k, v) => {
-                quote!(#root::lanes::map::decode_and_apply::<#agent_name, #k, #v>(body, |agent: &#agent_name| &agent.#name))
+            WarpLaneSpec::Map(k, v, m) => {
+                if let Some(map_t) = m {
+                    quote!(#root::lanes::map::decode_and_apply::<#agent_name, #k, #v, #map_t>(body, |agent: &#agent_name| &agent.#name))
+                } else {
+                    quote!(#root::lanes::map::decode_and_apply::<#agent_name, #k, #v, _>(body, |agent: &#agent_name| &agent.#name))
+                }
             }
             WarpLaneSpec::Demand(_)
             | WarpLaneSpec::DemandMap(_, _)
@@ -672,8 +684,12 @@ impl<'a> SyncHandlerMatch<'a> {
             WarpLaneSpec::Value(ty) => {
                 quote!(#root::lanes::value::ValueLaneSync::<#agent_name, #ty>::new(|agent: &#agent_name| &agent.#name, id))
             }
-            WarpLaneSpec::Map(k, v) => {
-                quote!(#root::lanes::map::MapLaneSync::<#agent_name, #k, #v>::new(|agent: &#agent_name| &agent.#name, id))
+            WarpLaneSpec::Map(k, v, m) => {
+                if let Some(map_t) = m {
+                    quote!(#root::lanes::map::MapLaneSync::<#agent_name, #k, #v, #map_t>::new(|agent: &#agent_name| &agent.#name, id))
+                } else {
+                    quote!(#root::lanes::map::MapLaneSync::<#agent_name, #k, #v>::new(|agent: &#agent_name| &agent.#name, id))
+                }
             }
             WarpLaneSpec::JoinValue(k, v) => {
                 quote!(#root::lanes::join_value::JoinValueLaneSync::<#agent_name, #k, #v>::new(|agent: &#agent_name| &agent.#name, id))
@@ -764,7 +780,7 @@ struct MapItemInitMatch<'a> {
 impl<'a> MapItemInitMatch<'a> {
     pub fn new(item: &OrdinalItemModel<'a>) -> Self {
         let init_kind = match &item.model.kind {
-            ItemSpec::Map(ItemKind::Lane, _, _) => InitKind::MapLane,
+            ItemSpec::Map(ItemKind::Lane, _, _, _) => InitKind::MapLane,
             _ => InitKind::MapStore,
         };
         MapItemInitMatch {
@@ -822,10 +838,10 @@ impl<'a> LaneSpecInsert<'a> {
             ItemSpec::Value(ItemKind::Store, _) => {
                 quote!(#root::agent_model::ItemDescriptor::Store { kind: #root::agent_model::StoreKind::Value, flags: #flags })
             }
-            ItemSpec::Map(ItemKind::Lane, _, _) => {
+            ItemSpec::Map(ItemKind::Lane, _, _, _) => {
                 quote!(#root::agent_model::ItemDescriptor::WarpLane { kind: #root::agent_model::WarpLaneKind::Map, flags: #flags })
             }
-            ItemSpec::Map(ItemKind::Store, _, _) => {
+            ItemSpec::Map(ItemKind::Store, _, _, _) => {
                 quote!(#root::agent_model::ItemDescriptor::Store { kind: #root::agent_model::StoreKind::Map, flags: #flags })
             }
             ItemSpec::JoinValue(_, _) => {
diff --git a/server/swimos_agent_derive/src/lane_model_derive/model.rs b/server/swimos_agent_derive/src/lane_model_derive/model.rs
index b6e5e1976..53b82f185 100644
--- a/server/swimos_agent_derive/src/lane_model_derive/model.rs
+++ b/server/swimos_agent_derive/src/lane_model_derive/model.rs
@@ -101,7 +101,7 @@ pub enum ItemSpec<'a> {
     Demand(&'a Type),
     DemandMap(&'a Type, &'a Type),
     Value(ItemKind, &'a Type),
-    Map(ItemKind, &'a Type, &'a Type),
+    Map(ItemKind, &'a Type, &'a Type, Option<&'a Type>),
     Supply(&'a Type),
     JoinValue(&'a Type, &'a Type),
     JoinMap(&'a Type, &'a Type, &'a Type),
@@ -115,7 +115,7 @@ impl<'a> ItemSpec<'a> {
             ItemSpec::Demand(t) => Some(WarpLaneSpec::Demand(t)),
             ItemSpec::DemandMap(k, v) => Some(WarpLaneSpec::DemandMap(k, v)),
             ItemSpec::Value(ItemKind::Lane, t) => Some(WarpLaneSpec::Value(t)),
-            ItemSpec::Map(ItemKind::Lane, k, v) => Some(WarpLaneSpec::Map(k, v)),
+            ItemSpec::Map(ItemKind::Lane, k, v, m) => Some(WarpLaneSpec::Map(k, v, *m)),
             ItemSpec::JoinValue(k, v) => Some(WarpLaneSpec::JoinValue(k, v)),
             ItemSpec::JoinMap(l, k, v) => Some(WarpLaneSpec::JoinMap(l, k, v)),
             ItemSpec::Supply(t) => Some(WarpLaneSpec::Supply(t)),
@@ -134,7 +134,7 @@ impl<'a> ItemSpec<'a> {
     pub fn item_kind(&self) -> ItemKind {
         match self {
             ItemSpec::Value(k, _) => *k,
-            ItemSpec::Map(k, _, _) => *k,
+            ItemSpec::Map(k, _, _, _) => *k,
             ItemSpec::Command(_) => ItemKind::Lane,
             ItemSpec::JoinValue(_, _) => ItemKind::Lane,
             ItemSpec::JoinMap(_, _, _) => ItemKind::Lane,
@@ -154,7 +154,7 @@ pub enum WarpLaneSpec<'a> {
     DemandMap(&'a Type, &'a Type),
     Value(&'a Type),
     Supply(&'a Type),
-    Map(&'a Type, &'a Type),
+    Map(&'a Type, &'a Type, Option<&'a Type>),
     JoinValue(&'a Type, &'a Type),
     JoinMap(&'a Type, &'a Type, &'a Type),
 }
@@ -423,19 +423,19 @@ fn extract_lane_model(field: &Field) -> Validation<ItemModel<'_>, Errors<syn::Er
                             )),
                             Err(e) => Validation::fail(Errors::of(e)),
                         },
-                        MAP_LANE_NAME => match two_params(arguments) {
-                            Ok((param1, param2)) => Validation::valid(ItemModel::new(
+                        MAP_LANE_NAME => match two_plus_one_params(arguments) {
+                            Ok((param1, param2, param3)) => Validation::valid(ItemModel::new(
                                 fld_name,
-                                ItemSpec::Map(ItemKind::Lane, param1, param2),
+                                ItemSpec::Map(ItemKind::Lane, param1, param2, param3),
                                 lane_flags,
                                 transform,
                             )),
                             Err(e) => Validation::fail(Errors::of(e)),
                         },
-                        MAP_STORE_NAME => match two_params(arguments) {
-                            Ok((param1, param2)) => Validation::valid(ItemModel::new(
+                        MAP_STORE_NAME => match two_plus_one_params(arguments) {
+                            Ok((param1, param2, param3)) => Validation::valid(ItemModel::new(
                                 fld_name,
-                                ItemSpec::Map(ItemKind::Store, param1, param2),
+                                ItemSpec::Map(ItemKind::Store, param1, param2, param3),
                                 lane_flags,
                                 transform,
                             )),
@@ -571,14 +571,34 @@ fn http_params(args: &PathArguments, simple: bool) -> Result<HttpLaneSpec<'_>, s
 }
 
 fn two_params(args: &PathArguments) -> Result<(&Type, &Type), syn::Error> {
-    extract_params::<2>(args).map(|[p1, p2]| (p1, p2))
+    let maybe_params = extract_params::<2>(args)?;
+    maybe_params
+        .ok_or_else(|| syn::Error::new_spanned(args, BAD_PARAMS))
+        .map(|[p1, p2]| (p1, p2))
 }
 
 fn three_params(args: &PathArguments) -> Result<(&Type, &Type, &Type), syn::Error> {
-    extract_params::<3>(args).map(|[p1, p2, p3]| (p1, p2, p3))
+    let maybe_params = extract_params::<3>(args)?;
+    maybe_params
+        .ok_or_else(|| syn::Error::new_spanned(args, BAD_PARAMS))
+        .map(|[p1, p2, p3]| (p1, p2, p3))
 }
 
-fn extract_params<const N: usize>(args: &PathArguments) -> Result<[&Type; N], syn::Error> {
+fn two_plus_one_params(args: &PathArguments) -> Result<(&Type, &Type, Option<&Type>), syn::Error> {
+    let params = extract_params_vec(args)?;
+    match <[&Type; 2]>::try_from(params) {
+        Ok([p1, p2]) => Ok((p1, p2, None)),
+        Err(params) => {
+            if let Ok([p1, p2, p3]) = <[&Type; 3]>::try_from(params) {
+                Ok((p1, p2, Some(p3)))
+            } else {
+                Err(syn::Error::new_spanned(args, BAD_PARAMS))
+            }
+        }
+    }
+}
+
+fn extract_params_vec(args: &PathArguments) -> Result<Vec<&Type>, syn::Error> {
     if let PathArguments::AngleBracketed(AngleBracketedGenericArguments { args, .. }) = args {
         let mut good = vec![];
         let it = args.iter();
@@ -589,10 +609,13 @@ fn extract_params<const N: usize>(args: &PathArguments) -> Result<[&Type; N], sy
                 return Err(syn::Error::new_spanned(args, BAD_PARAMS));
             }
         }
-        Ok(good
-            .try_into()
-            .map_err(|_| syn::Error::new_spanned(args, BAD_PARAMS))?)
+        Ok(good)
     } else {
         Err(syn::Error::new_spanned(args, BAD_PARAMS))
     }
 }
+
+fn extract_params<const N: usize>(args: &PathArguments) -> Result<Option<[&Type; N]>, syn::Error> {
+    let params = extract_params_vec(args)?;
+    Ok(<[&Type; N]>::try_from(params).ok())
+}
diff --git a/swimos/tests/deriveagentlanemodel.rs b/swimos/tests/deriveagentlanemodel.rs
index fac3a1355..ce72d55a4 100644
--- a/swimos/tests/deriveagentlanemodel.rs
+++ b/swimos/tests/deriveagentlanemodel.rs
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use std::fmt::Write;
 
 use swimos::agent::agent_model::ItemFlags;
@@ -844,3 +844,43 @@ fn agent_level_transient_flag() {
         transient_store(3, "fourth", StoreKind::Value),
     ]);
 }
+
+#[test]
+fn map_lane_explicit_backing() {
+    #[derive(AgentLaneModel)]
+    struct MapLaneExplicit {
+        lane: MapLane<i32, String, HashMap<i32, String>>,
+    }
+
+    check_agent::<MapLaneExplicit>(vec![persistent_lane(0, "lane", WarpLaneKind::Map)]);
+}
+
+#[test]
+fn map_store_explicit_backing() {
+    #[derive(AgentLaneModel)]
+    struct MapStoreExplicit {
+        store: MapStore<i32, String, HashMap<i32, String>>,
+    }
+
+    check_agent::<MapStoreExplicit>(vec![persistent_store(0, "store", StoreKind::Map)]);
+}
+
+#[test]
+fn map_lane_ordered_map() {
+    #[derive(AgentLaneModel)]
+    struct MapLaneOrdered {
+        lane: MapLane<i32, String, BTreeMap<i32, String>>,
+    }
+
+    check_agent::<MapLaneOrdered>(vec![persistent_lane(0, "lane", WarpLaneKind::Map)]);
+}
+
+#[test]
+fn map_store_ordered_map() {
+    #[derive(AgentLaneModel)]
+    struct MapStoreOrdered {
+        store: MapStore<i32, String, BTreeMap<i32, String>>,
+    }
+
+    check_agent::<MapStoreOrdered>(vec![persistent_store(0, "store", StoreKind::Map)]);
+}