@rivetkit/engine 1.0.0 → 2.2.1-pr.4600.b74ff3b

package/packages/gasoline/src/history/cursor.rs

@@ -3,8 +3,8 @@ use std::cmp::Ordering;
 use super::{
 	History,
 	event::{
-		ActivityEvent, Event, EventData, EventType, LoopEvent, MessageSendEvent, SignalEvent,
-		SignalSendEvent, SleepEvent, SubWorkflowEvent,
+		ActivityEvent, Event, EventData, EventType, LoopEvent, MessageSendEvent, SignalSendEvent,
+		SignalsEvent, SleepEvent, SubWorkflowEvent,
 	},
 	location::{Coordinate, Location},
 	removed::Removed,
@@ -119,18 +119,7 @@ impl Cursor {
 
 	pub fn current_event(&self) -> Option<&Event> {
 		if let Some(branch) = self.events.get(&self.root_location) {
-			let event = branch.get(self.iter_idx);
-
-			// Empty events are considered `None`
-			if let Some(Event {
-				data: EventData::Empty,
-				..
-			}) = &event
-			{
-				None
-			} else {
-				event
-			}
+			branch.get(self.iter_idx)
 		} else {
 			None
 		}
@@ -183,320 +172,282 @@ impl Cursor {
 		Ok(())
 	}
 
-	/// Returns `Some` if the current event is being replayed.
 	pub fn compare_activity(
 		&self,
 		version: usize,
 		name: &str,
 	) -> WorkflowResult<HistoryResult<&ActivityEvent>> {
-		if let Some(event) = self.current_event() {
-			if version > event.version {
-				return Ok(HistoryResult::Insertion);
-			}
+		let Some(event) = self.current_event() else {
+			return Ok(HistoryResult::New);
+		};
 
-			if version < event.version {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} v{} at {}, found activity {:?} v{}",
-					event.data,
-					event.version,
-					self.current_location(),
-					name,
-					version,
-				)));
-			}
+		if version > event.version {
+			return Ok(HistoryResult::Insertion);
+		}
 
-			// Validate history is consistent
-			let EventData::Activity(activity) = &event.data else {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} at {}, found activity {:?}",
-					event.data,
-					self.current_location(),
-					name,
-				)));
-			};
+		if version < event.version {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} v{} at {}, found activity {:?} v{}",
+				event.data,
+				event.version,
+				self.current_location(),
+				name,
+				version,
+			)));
+		}
 
-			if &activity.name != name {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected activity {:?} at {}, found activity {:?}",
-					activity.name,
-					self.current_location(),
-					name,
-				)));
-			}
+		// Validate history is consistent
+		let EventData::Activity(activity) = &event.data else {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} at {}, found activity {:?}",
+				event.data,
+				self.current_location(),
+				name,
+			)));
+		};
 
-			Ok(HistoryResult::Event(activity))
-		} else {
-			Ok(HistoryResult::New)
+		if &activity.name != name {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected activity {:?} at {}, found activity {:?}",
+				activity.name,
+				self.current_location(),
+				name,
+			)));
 		}
+
+		Ok(HistoryResult::Event(activity))
 	}
 
-	/// Returns `Some` if the current event is being replayed.
 	pub fn compare_msg(
 		&self,
 		version: usize,
 		msg_name: &str,
 	) -> WorkflowResult<HistoryResult<&MessageSendEvent>> {
-		if let Some(event) = self.current_event() {
-			if version > event.version {
-				return Ok(HistoryResult::Insertion);
-			}
+		let Some(event) = self.current_event() else {
+			return Ok(HistoryResult::New);
+		};
 
-			if version < event.version {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} v{} at {}, found message send {:?} v{}",
-					event.data,
-					event.version,
-					self.current_location(),
-					msg_name,
-					version,
-				)));
-			}
+		if version > event.version {
+			return Ok(HistoryResult::Insertion);
+		}
 
-			// Validate history is consistent
-			let EventData::MessageSend(msg) = &event.data else {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} at {}, found message send {:?}",
-					event.data,
-					self.current_location(),
-					msg_name,
-				)));
-			};
+		if version < event.version {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} v{} at {}, found message send {:?} v{}",
+				event.data,
+				event.version,
+				self.current_location(),
+				msg_name,
+				version,
+			)));
+		}
 
-			if msg.name != msg_name {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} at {}, found message send {:?}",
-					event.data,
-					self.current_location(),
-					msg_name,
-				)));
-			}
+		// Validate history is consistent
+		let EventData::MessageSend(msg) = &event.data else {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} at {}, found message send {:?}",
+				event.data,
+				self.current_location(),
+				msg_name,
+			)));
+		};
 
-			Ok(HistoryResult::Event(msg))
-		} else {
-			Ok(HistoryResult::New)
+		if msg.name != msg_name {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} at {}, found message send {:?}",
+				event.data,
+				self.current_location(),
+				msg_name,
+			)));
 		}
+
+		Ok(HistoryResult::Event(msg))
 	}
 
-	/// Returns `Some` if the current event is being replayed.
 	pub fn compare_signal_send(
 		&self,
 		version: usize,
 		signal_name: &str,
 	) -> WorkflowResult<HistoryResult<&SignalSendEvent>> {
-		if let Some(event) = self.current_event() {
-			if version > event.version {
-				return Ok(HistoryResult::Insertion);
-			}
+		let Some(event) = self.current_event() else {
+			return Ok(HistoryResult::New);
+		};
 
-			if version < event.version {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} v{} at {}, found signal send {:?} v{}",
-					event.data,
-					event.version,
-					self.current_location(),
-					signal_name,
-					version,
-				)));
-			}
+		if version > event.version {
+			return Ok(HistoryResult::Insertion);
+		}
 
-			// Validate history is consistent
-			let EventData::SignalSend(signal) = &event.data else {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} at {}, found signal send {:?}",
-					event.data,
-					self.current_location(),
-					signal_name,
-				)));
-			};
+		if version < event.version {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} v{} at {}, found signal send {:?} v{}",
+				event.data,
+				event.version,
+				self.current_location(),
+				signal_name,
+				version,
+			)));
+		}
 
-			if signal.name != signal_name {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} at {}, found signal send {:?}",
-					event.data,
-					self.current_location(),
-					signal_name,
-				)));
-			}
+		// Validate history is consistent
+		let EventData::SignalSend(signal) = &event.data else {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} at {}, found signal send {:?}",
+				event.data,
+				self.current_location(),
+				signal_name,
+			)));
+		};
 
-			Ok(HistoryResult::Event(signal))
-		} else {
-			Ok(HistoryResult::New)
+		if signal.name != signal_name {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} at {}, found signal send {:?}",
+				event.data,
+				self.current_location(),
+				signal_name,
+			)));
 		}
+
+		Ok(HistoryResult::Event(signal))
 	}
 
-	/// Returns `Some` if the current event is being replayed.
 	pub fn compare_sub_workflow(
 		&self,
 		version: usize,
 		sub_workflow_name: &str,
 	) -> WorkflowResult<HistoryResult<&SubWorkflowEvent>> {
-		if let Some(event) = self.current_event() {
-			if version > event.version {
-				return Ok(HistoryResult::Insertion);
-			}
-
-			if version < event.version {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} v{} at {}, found sub workflow {:?} v{}",
-					event.data,
-					event.version,
-					self.current_location(),
-					sub_workflow_name,
-					version,
-				)));
-			}
-
-			// Validate history is consistent
-			let EventData::SubWorkflow(sub_workflow) = &event.data else {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} at {}, found sub workflow {:?}",
-					event.data,
-					self.current_location(),
-					sub_workflow_name,
-				)));
-			};
-
-			if sub_workflow.name != sub_workflow_name {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} at {}, found sub_workflow {:?}",
-					event.data,
-					self.current_location(),
-					sub_workflow_name,
-				)));
-			}
+		let Some(event) = self.current_event() else {
+			return Ok(HistoryResult::New);
+		};
 
-			Ok(HistoryResult::Event(sub_workflow))
-		} else {
-			Ok(HistoryResult::New)
+		if version > event.version {
+			return Ok(HistoryResult::Insertion);
 		}
-	}
-
-	/// Returns `Some` if the current event is being replayed.
-	pub fn compare_signal(&self, version: usize) -> WorkflowResult<HistoryResult<&SignalEvent>> {
-		if let Some(event) = self.current_event() {
-			if version > event.version {
-				return Ok(HistoryResult::Insertion);
-			}
 
-			if version < event.version {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} v{} at {}, found signal v{}",
-					event.data,
-					event.version,
-					self.current_location(),
-					version,
-				)));
-			}
+		if version < event.version {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} v{} at {}, found sub workflow {:?} v{}",
+				event.data,
+				event.version,
+				self.current_location(),
+				sub_workflow_name,
+				version,
+			)));
+		}
 
-			// Validate history is consistent
-			let EventData::Signal(signal) = &event.data else {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} at {}, found signal",
-					event.data,
-					self.current_location(),
-				)));
-			};
+		// Validate history is consistent
+		let EventData::SubWorkflow(sub_workflow) = &event.data else {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} at {}, found sub workflow {:?}",
+				event.data,
+				self.current_location(),
+				sub_workflow_name,
+			)));
+		};
 
-			Ok(HistoryResult::Event(signal))
-		} else {
-			Ok(HistoryResult::New)
+		if sub_workflow.name != sub_workflow_name {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} at {}, found sub_workflow {:?}",
+				event.data,
+				self.current_location(),
+				sub_workflow_name,
+			)));
 		}
+
+		Ok(HistoryResult::Event(sub_workflow))
 	}
 
-	/// Returns `Some` if the current event is being replayed.
 	pub fn compare_loop(&self, version: usize) -> WorkflowResult<HistoryResult<&LoopEvent>> {
-		if let Some(event) = self.current_event() {
-			if version > event.version {
-				return Ok(HistoryResult::Insertion);
-			}
-
-			if version < event.version {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} v{} at {}, found loop v{}",
-					event.data,
-					event.version,
-					self.current_location(),
-					version,
-				)));
-			}
+		let Some(event) = self.current_event() else {
+			return Ok(HistoryResult::New);
+		};
 
-			// Validate history is consistent
-			let EventData::Loop(loop_event) = &event.data else {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} at {}, found loop",
-					event.data,
-					self.current_location(),
-				)));
-			};
+		if version > event.version {
+			return Ok(HistoryResult::Insertion);
+		}
 
-			Ok(HistoryResult::Event(loop_event))
-		} else {
-			Ok(HistoryResult::New)
+		if version < event.version {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} v{} at {}, found loop v{}",
+				event.data,
+				event.version,
+				self.current_location(),
+				version,
+			)));
 		}
+
+		// Validate history is consistent
+		let EventData::Loop(loop_event) = &event.data else {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} at {}, found loop",
+				event.data,
+				self.current_location(),
+			)));
+		};
+
+		Ok(HistoryResult::Event(loop_event))
 	}
 
-	/// Returns `Some` if the current event is being replayed.
 	pub fn compare_sleep(&self, version: usize) -> WorkflowResult<HistoryResult<&SleepEvent>> {
-		if let Some(event) = self.current_event() {
-			if version > event.version {
-				return Ok(HistoryResult::Insertion);
-			}
-
-			if version < event.version {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} v{} at {}, found sleep v{}",
-					event.data,
-					event.version,
-					self.current_location(),
-					version,
-				)));
-			}
+		let Some(event) = self.current_event() else {
+			return Ok(HistoryResult::New);
+		};
 
-			// Validate history is consistent
-			let EventData::Sleep(sleep) = &event.data else {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} at {}, found sleep",
-					event.data,
-					self.current_location(),
-				)));
-			};
+		if version > event.version {
+			return Ok(HistoryResult::Insertion);
+		}
 
-			Ok(HistoryResult::Event(sleep))
-		} else {
-			Ok(HistoryResult::New)
+		if version < event.version {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} v{} at {}, found sleep v{}",
+				event.data,
+				event.version,
+				self.current_location(),
+				version,
+			)));
 		}
+
+		// Validate history is consistent
+		let EventData::Sleep(sleep) = &event.data else {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} at {}, found sleep",
+				event.data,
+				self.current_location(),
+			)));
+		};
+
+		Ok(HistoryResult::Event(sleep))
 	}
 
 	/// Returns `true` if the current event is being replayed.
 	pub fn compare_branch(&self, version: usize) -> WorkflowResult<HistoryResult<()>> {
-		if let Some(event) = self.current_event() {
-			if version > event.version {
-				return Ok(HistoryResult::Insertion);
-			}
-
-			if version < event.version {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} v{} at {}, found branch v{}",
-					event.data,
-					event.version,
-					self.current_location(),
-					version,
-				)));
-			}
+		let Some(event) = self.current_event() else {
+			return Ok(HistoryResult::New);
+		};
 
-			// Validate history is consistent
-			let EventData::Branch = &event.data else {
-				return Err(WorkflowError::HistoryDiverged(format!(
-					"expected {} at {}, found branch",
-					event.data,
-					self.current_location(),
-				)));
-			};
+		if version > event.version {
+			return Ok(HistoryResult::Insertion);
+		}
 
-			Ok(HistoryResult::Event(()))
-		} else {
-			Ok(HistoryResult::New)
+		if version < event.version {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} v{} at {}, found branch v{}",
+				event.data,
+				event.version,
+				self.current_location(),
+				version,
+			)));
 		}
+
+		// Validate history is consistent
+		let EventData::Branch = &event.data else {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} at {}, found branch",
+				event.data,
+				self.current_location(),
+			)));
+		};
+
+		Ok(HistoryResult::Event(()))
 	}
 
 	/// Returns `true` if the current event is being replayed.
@@ -524,86 +475,129 @@ impl Cursor {
 		}
 	}
 
-	/// Returns `true` if the current event is being replayed.
-	pub fn compare_removed<T: Removed>(&self) -> WorkflowResult<bool> {
-		if let Some(event) = self.current_event() {
-			// Validate history is consistent
-			let valid = if let EventData::Removed(removed) = &event.data {
-				removed.event_type == T::event_type() && removed.name.as_deref() == T::name()
-			} else {
-				match T::event_type() {
-					EventType::Activity => {
-						if let EventData::Activity(activity) = &event.data {
-							T::name().expect("bad impl") == activity.name
-						} else {
-							false
-						}
+	// Helper function for signal functionality
+	pub fn current_event_is_removed(&self) -> bool {
+		let Some(event) = self.current_event() else {
+			return false;
+		};
+
+		matches!(&event.data, EventData::Removed(_))
+	}
+
+	pub fn compare_removed<T: Removed>(&self) -> RemovedHistoryResult {
+		let Some(event) = self.current_event() else {
+			return RemovedHistoryResult::New;
+		};
+
+		// Validate history is consistent
+		let valid = if let EventData::Removed(removed) = &event.data {
+			removed.event_type == T::event_type() && removed.name.as_deref() == T::name()
+		} else {
+			match T::event_type() {
+				EventType::Activity => {
+					if let EventData::Activity(activity) = &event.data {
+						T::name().expect("bad impl") == activity.name
+					} else {
+						false
 					}
-					EventType::SignalSend => {
-						if let EventData::SignalSend(signal) = &event.data {
-							T::name().expect("bad impl") == signal.name
-						} else {
-							false
-						}
+				}
+				EventType::Signal => matches!(event.data, EventData::Signals(_)),
+				EventType::SignalSend => {
+					if let EventData::SignalSend(signal) = &event.data {
+						T::name().expect("bad impl") == signal.name
+					} else {
+						false
 					}
-					EventType::MessageSend => {
-						if let EventData::MessageSend(msg) = &event.data {
-							T::name().expect("bad impl") == msg.name
-						} else {
-							false
-						}
+				}
+				EventType::MessageSend => {
+					if let EventData::MessageSend(msg) = &event.data {
+						T::name().expect("bad impl") == msg.name
+					} else {
+						false
 					}
-					EventType::Signal => matches!(event.data, EventData::Signal(_)),
-					EventType::Loop => matches!(event.data, EventData::Loop(_)),
-					EventType::Sleep => matches!(event.data, EventData::Sleep(_)),
-					EventType::SubWorkflow => {
-						if let EventData::SubWorkflow(sub_workflow) = &event.data {
-							T::name().expect("bad impl") == sub_workflow.name
-						} else {
-							false
-						}
+				}
+				EventType::Loop => matches!(event.data, EventData::Loop(_)),
+				EventType::Sleep => matches!(event.data, EventData::Sleep(_)),
+				EventType::SubWorkflow => {
+					if let EventData::SubWorkflow(sub_workflow) = &event.data {
+						T::name().expect("bad impl") == sub_workflow.name
+					} else {
+						false
 					}
-					EventType::Branch => matches!(event.data, EventData::Branch),
-					_ => unreachable!("not implemented as a removable type"),
 				}
+				EventType::Branch => matches!(event.data, EventData::Branch),
+				EventType::Signals => matches!(event.data, EventData::Signals(_)),
+				EventType::Removed => unreachable!(),
+				EventType::VersionCheck => unreachable!("not implemented as a removable type"),
+			}
+		};
+
+		if valid {
+			RemovedHistoryResult::Skip
+		} else {
+			let msg = if let Some(name) = T::name() {
+				format!(
+					"expected {} at {}, found removed {} {name:?}",
+					event.data,
+					self.current_location(),
+					T::event_type(),
+				)
+			} else {
+				format!(
+					"expected {} at {}, found removed {}",
+					event.data,
+					self.current_location(),
+					T::event_type(),
+				)
 			};
 
-			if !valid {
-				let msg = if let Some(name) = T::name() {
-					format!(
-						"expected {} at {}, found removed {} {name:?}",
-						event.data,
-						self.current_location(),
-						T::event_type(),
-					)
-				} else {
-					format!(
-						"expected {} at {}, found removed {}",
-						event.data,
-						self.current_location(),
-						T::event_type(),
-					)
-				};
-
-				return Err(WorkflowError::HistoryDiverged(msg));
-			}
+			RemovedHistoryResult::Ignore(msg)
+		}
+	}
 
-			Ok(true)
+	pub fn compare_version_check(&self) -> WorkflowResult<CheckVersionHistoryResult> {
+		let Some(event) = self.current_event() else {
+			return Ok(CheckVersionHistoryResult::New);
+		};
+
+		// If the current event is a version check, return its inner version
+		if let EventData::VersionCheck(data) = &event.data {
+			Ok(CheckVersionHistoryResult::Event(data.inner_version))
 		} else {
-			Ok(false)
+			// Current event is not a version check, one must be inserted with the same version
+			Ok(CheckVersionHistoryResult::Insertion(event.version))
 		}
 	}
 
-	/// Returns `Some` if the current event is being replayed.
-	pub fn compare_version_check(&self) -> WorkflowResult<Option<(bool, usize)>> {
-		if let Some(event) = self.current_event() {
-			Ok(Some((
-				matches!(event.data, EventData::VersionCheck),
+	pub fn compare_signals(&self, version: usize) -> WorkflowResult<HistoryResult<&SignalsEvent>> {
+		let Some(event) = self.current_event() else {
+			return Ok(HistoryResult::New);
+		};
+
+		if version > event.version {
+			return Ok(HistoryResult::Insertion);
+		}
+
+		if version < event.version {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} v{} at {}, found signals v{}",
+				event.data,
 				event.version,
-			)))
-		} else {
-			Ok(None)
+				self.current_location(),
+				version,
+			)));
 		}
+
+		// Validate history is consistent
+		let EventData::Signals(signals) = &event.data else {
+			return Err(WorkflowError::HistoryDiverged(format!(
+				"expected {} at {}, found signals",
+				event.data,
+				self.current_location(),
+			)));
+		};
+
+		Ok(HistoryResult::Event(signals))
 	}
 }
 
@@ -629,6 +623,37 @@ impl<T> HistoryResult<T> {
 	}
 }
 
+pub enum RemovedHistoryResult {
+	/// No event for this location in history exists.
+	New,
+	/// An event for this location in history exists and matches the filter.
+	Skip,
+	/// An event for this location in history exists, but it does not match the removed filter.
+	Ignore(String),
+}
+
+pub enum CheckVersionHistoryResult {
+	/// A check version event for this location in history exists.
+	Event(usize),
+	/// An event for this location in history exists, but it is not a check version event. Therefore, an
+	/// insertion is required.
+	Insertion(usize),
+	/// No event for this location in history exists.
+	New,
+}
+
+impl CheckVersionHistoryResult {
+	/// Returns a history event thats equivalent to this one. Used to bypass ownership if its not
+	/// needed.
+	pub(crate) fn equivalent(&self) -> HistoryResult<()> {
+		match self {
+			CheckVersionHistoryResult::Event(_) => HistoryResult::Event(()),
+			CheckVersionHistoryResult::Insertion(_) => HistoryResult::Insertion,
+			CheckVersionHistoryResult::New => HistoryResult::New,
+		}
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use std::{collections::HashMap, sync::Arc};
@@ -658,12 +683,12 @@ mod tests {
 				Event {
 					coordinate: coord![2, 1],
 					version: 1,
-					data: EventData::VersionCheck,
+					data: EventData::Branch,
 				},
 				Event {
 					coordinate: coord![4],
 					version: 1,
-					data: EventData::VersionCheck,
+					data: EventData::Branch,
 				},
 			],
 		)]
@@ -697,12 +722,12 @@ mod tests {
 				Event {
 					coordinate: coord![2, 1],
 					version: 1,
-					data: EventData::VersionCheck,
+					data: EventData::Branch,
 				},
 				Event {
 					coordinate: coord![3],
 					version: 1,
-					data: EventData::VersionCheck,
+					data: EventData::Branch,
 				},
 			],
 		)]
@@ -730,12 +755,12 @@ mod tests {
 				Event {
 					coordinate: coord![2, 1],
 					version: 1,
-					data: EventData::VersionCheck,
+					data: EventData::Branch,
 				},
 				Event {
 					coordinate: coord![2, 2],
 					version: 1,
-					data: EventData::VersionCheck,
+					data: EventData::Branch,
 				},
 			],
 		)]
@@ -758,12 +783,12 @@ mod tests {
 				Event {
 					coordinate: coord![2, 1],
 					version: 1,
-					data: EventData::VersionCheck,
+					data: EventData::Branch,
 				},
 				Event {
 					coordinate: coord![2, 1, 1],
 					version: 1,
-					data: EventData::VersionCheck,
+					data: EventData::Branch,
 				},
 			],
 		)]
@@ -776,4 +801,79 @@ mod tests {
 		let new = cursor.current_location_for(&HistoryResult::<()>::Insertion);
 		assert_eq!(loc![coord![1], coord![2, 1, 0, 1]], new);
 	}
+
+	#[test]
+	fn holes_in_coordinates() {
+		let events = [(
+			loc![],
+			vec![
+				Event {
+					coordinate: coord![1],
+					version: 1,
+					data: EventData::Branch,
+				},
+				Event {
+					coordinate: coord![3],
+					version: 1,
+					data: EventData::Branch,
+				},
+				Event {
+					coordinate: coord![6],
+					version: 1,
+					data: EventData::Branch,
+				},
+			],
+		)]
+		.into_iter()
+		.collect::<HashMap<_, _>>();
+		let mut cursor = Cursor::new(Arc::new(events), Location::empty());
+
+		// First event should be at coordinate 1
+		assert_eq!(coord![1], cursor.current_coord());
+		cursor.update(&cursor.current_location_for(&HistoryResult::<()>::Event(())));
+
+		// Second event should be at coordinate 3 (with hole at 2)
+		assert_eq!(coord![3], cursor.current_coord());
+		cursor.update(&cursor.current_location_for(&HistoryResult::<()>::Event(())));
+
+		// Third event should be at coordinate 6 (with holes at 4, 5)
+		assert_eq!(coord![6], cursor.current_coord());
+		cursor.update(&cursor.current_location_for(&HistoryResult::<()>::Event(())));
+
+		// After all events, coords should continue from last event's coordinate
+		assert_eq!(coord![7], cursor.current_coord());
+	}
+
+	#[test]
+	fn holes_in_coordinates2() {
+		let events = [(
+			loc![],
+			vec![
+				Event {
+					coordinate: coord![1],
+					version: 1,
+					data: EventData::Branch,
+				},
+				Event {
+					coordinate: coord![3],
+					version: 1,
+					data: EventData::Branch,
+				},
+				Event {
+					coordinate: coord![6],
+					version: 1,
+					data: EventData::Branch,
+				},
+			],
+		)]
+		.into_iter()
+		.collect::<HashMap<_, _>>();
+
+		let mut cursor = Cursor::new(Arc::new(events), Location::empty());
+		cursor.update(&cursor.current_location_for(&HistoryResult::<()>::Event(())));
+
+		// Insert after coordinate 1, before coordinate 3
+		let new = cursor.current_location_for(&HistoryResult::<()>::Insertion);
+		assert_eq!(loc![coord![1, 1]], new);
+	}
 }