automerge-rb 0.1.1

data/vendor/automerge-rust/automerge/src/automerge.rs

@@ -0,0 +1,2071 @@
+use std::cmp::Ordering;
+use std::collections::{BTreeSet, HashSet};
+use std::env;
+use std::fmt::Debug;
+use std::num::NonZeroU64;
+use std::ops::RangeBounds;
+
+use itertools::Itertools;
+
+pub(crate) use crate::op_set2::change::ChangeCollector;
+pub(crate) use crate::op_set2::types::ScalarValue;
+pub(crate) use crate::op_set2::{
+    ChangeMetadata, KeyRef, OpQuery, OpQueryTerm, OpSet, OpType, Parents,
+};
+pub(crate) use crate::read::ReadDoc;
+
+use crate::change_graph::ChangeGraph;
+use crate::change_queue::ChangeQueue;
+use crate::cursor::{CursorPosition, MoveCursor, OpCursor};
+use crate::exid::ExId;
+use crate::iter::{DiffIter, DocIter, Keys, ListRange, MapRange, Spans, Values};
+use crate::marks::{Mark, MarkAccumulator, MarkSet};
+use crate::patches::{Patch, PatchLog};
+use crate::storage::{self, change, load, Bundle, CompressConfig, Document, VerificationMode};
+use crate::transaction::{
+    self, CommitOptions, Failure, OwnedTransaction, Success, Transactable, Transaction,
+    TransactionArgs,
+};
+
+use crate::clock::{Clock, ClockRange};
+use crate::hydrate;
+use crate::types::{ActorId, ChangeHash, ObjId, ObjMeta, OpId, SequenceType, TextEncoding, Value};
+use crate::{AutomergeError, Change, Cursor, ObjType, Prop};
+
+pub(crate) mod current_state;
+
+// FIXME
+//#[cfg(test)]
+//mod tests;
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) enum Actor {
+    Unused(ActorId),
+    Cached(usize),
+}
+
+impl Actor {
+    fn remove_actor(&mut self, index: usize, actors: &[ActorId]) {
+        if let Actor::Cached(idx) = self {
+            match (*idx).cmp(&index) {
+                Ordering::Equal => *self = Actor::Unused(actors[index].clone()),
+                Ordering::Greater => *idx -= 1,
+                Ordering::Less => (),
+            }
+        }
+    }
+
+    fn rewrite_with_new_actor(&mut self, index: usize) {
+        if let Actor::Cached(idx) = self {
+            if *idx >= index {
+                *idx += 1;
+            }
+        }
+    }
+}
+
+/// What to do when loading a document partially succeeds
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OnPartialLoad {
+    /// Ignore the error and return the loaded changes
+    Ignore,
+    /// Fail the entire load
+    Error,
+}
+
+/// Whether to convert [`ScalarValue::Str`]s in the loaded document to [`ObjType::Text`]
+#[derive(Debug)]
+pub enum StringMigration {
+    /// Don't convert anything
+    NoMigration,
+    /// Convert all strings to text
+    ConvertToText,
+}
+
+#[derive(Debug)]
+pub struct LoadOptions<'a> {
+    on_partial_load: OnPartialLoad,
+    verification_mode: VerificationMode,
+    string_migration: StringMigration,
+    patch_log: Option<&'a mut PatchLog>,
+    text_encoding: TextEncoding,
+}
+
+impl<'a> LoadOptions<'a> {
+    pub fn new() -> LoadOptions<'static> {
+        LoadOptions::default()
+    }
+
+    /// What to do when loading a document partially succeeds
+    ///
+    /// The default is [`OnPartialLoad::Error`]
+    pub fn on_partial_load(self, on_partial_load: OnPartialLoad) -> Self {
+        Self {
+            on_partial_load,
+            ..self
+        }
+    }
+
+    /// Whether to verify the head hashes after loading
+    ///
+    /// The default is [`VerificationMode::Check`]
+    pub fn verification_mode(self, verification_mode: VerificationMode) -> Self {
+        Self {
+            verification_mode,
+            ..self
+        }
+    }
+
+    /// A [`PatchLog`] to log the changes required to materialize the current state of the
+    ///
+    /// The default is to not log patches
+    pub fn patch_log(self, patch_log: &'a mut PatchLog) -> Self {
+        Self {
+            patch_log: Some(patch_log),
+            ..self
+        }
+    }
+
+    /// Whether to convert [`ScalarValue::Str`]s in the loaded document to [`ObjType::Text`]
+    ///
+    /// Until version 2.1.0 of the javascript library strings (as in, the native string of the JS
+    /// runtime) were represented in the document as [`ScalarValue::Str`] and there was a special
+    /// JS class called `Text` which users were expected to use for [`ObjType::Text`]. In `2.1.0`
+    /// we changed this so that native strings were represented as [`ObjType::Text`] and
+    /// [`ScalarValue::Str`] was represented as a special `RawString` class. This means
+    /// that upgrading the application code to use the new API would require either
+    ///
+    /// a) Maintaining two code paths in the application to deal with both `string` and `RawString`
+    ///    types
+    /// b) Writing a migration script to convert all `RawString` types to `string`
+    ///
+    /// The latter is logic which is the same for all applications so we implement it in the
+    /// library for convenience. The way this works is that after loading the document we iterate
+    /// through all visible [`ScalarValue::Str`] values and emit a change which creates a new
+    /// [`ObjType::Text`] at the same path with the same content.
+    pub fn migrate_strings(self, migration: StringMigration) -> Self {
+        Self {
+            string_migration: migration,
+            ..self
+        }
+    }
+
+    pub fn text_encoding(self, text_encoding: TextEncoding) -> Self {
+        Self {
+            text_encoding,
+            ..self
+        }
+    }
+}
+
+impl std::default::Default for LoadOptions<'static> {
+    fn default() -> Self {
+        Self {
+            on_partial_load: OnPartialLoad::Error,
+            verification_mode: VerificationMode::Check,
+            patch_log: None,
+            string_migration: StringMigration::NoMigration,
+            text_encoding: TextEncoding::platform_default(),
+        }
+    }
+}
+
+/// An automerge document which does not manage transactions for you.
+///
+/// ## Creating, loading, merging and forking documents
+///
+/// A new document can be created with [`Self::new()`], which will create a document with a random
+/// [`ActorId`]. Existing documents can be loaded with [`Self::load()`], or [`Self::load_with()`].
+///
+/// If you have two documents and you want to merge the changes from one into the other you can use
+/// [`Self::merge()`] or [`Self::merge_and_log_patches()`].
+///
+/// If you have a document you want to split into two concurrent threads of execution you can use
+/// [`Self::fork()`]. If you want to split a document from ealier in its history you can use
+/// [`Self::fork_at()`].
+///
+/// ## Reading values
+///
+/// [`Self`] implements [`ReadDoc`], which provides methods for reading values from the document.
+///
+/// ## Modifying a document (Transactions)
+///
+/// [`Automerge`] provides an interface for viewing and modifying automerge documents which does
+/// not manage transactions for you. To create changes you use either [`Automerge::transaction()`] or
+/// [`Automerge::transact()`] (or the `_with` variants).
+///
+/// ## Sync
+///
+/// This type implements [`crate::sync::SyncDoc`]
+///
+#[derive(Debug, Clone)]
+pub struct Automerge {
+    /// The list of unapplied changes that are not causally ready.
+    pub(crate) queue: ChangeQueue,
+    /// Graph of changes
+    pub(crate) change_graph: ChangeGraph,
+    /// Current dependencies of this document (heads hashes).
+    deps: HashSet<ChangeHash>,
+    /// The set of operations that form this document.
+    pub(crate) ops: OpSet,
+    /// The current actor.
+    actor: Actor,
+}
+
+impl Automerge {
+    /// Create a new document with a random actor id.
+    pub fn new() -> Self {
+        Automerge {
+            queue: ChangeQueue::new(),
+            change_graph: ChangeGraph::new(0),
+            ops: OpSet::new(TextEncoding::platform_default()),
+            deps: Default::default(),
+            actor: Actor::Unused(ActorId::random()),
+        }
+    }
+
+    /// Overwrite the keys of the root object with the values from `value`
+    ///
+    /// This is useful to initialize an empty document with a large initial
+    /// value. Note that existing keys which are not in `value` are left as is
+    pub fn init_from_hydrate(&mut self, value: &crate::hydrate::Map) -> Result<(), AutomergeError> {
+        let mut tx = self.transaction();
+        tx.batch_init_root_map(value)?;
+        tx.commit();
+        Ok(())
+    }
+
+    pub fn new_with_encoding(encoding: TextEncoding) -> Self {
+        Automerge {
+            queue: ChangeQueue::new(),
+            change_graph: ChangeGraph::new(0),
+            ops: OpSet::new(encoding),
+            deps: Default::default(),
+            actor: Actor::Unused(ActorId::random()),
+        }
+    }
+
+    pub(crate) fn from_parts(ops: OpSet, change_graph: ChangeGraph) -> Self {
+        let deps = change_graph.heads().collect();
+        let mut doc = Automerge {
+            queue: ChangeQueue::new(),
+            change_graph,
+            ops,
+            deps,
+            actor: Actor::Unused(ActorId::random()),
+        };
+        doc.remove_unused_actors(false);
+        doc
+    }
+
+    pub(crate) fn ops_mut(&mut self) -> &mut OpSet {
+        &mut self.ops
+    }
+
+    pub(crate) fn ops(&self) -> &OpSet {
+        &self.ops
+    }
+
+    pub(crate) fn changes(&self) -> &ChangeGraph {
+        &self.change_graph
+    }
+
+    /// Whether this document has any operations
+    pub fn is_empty(&self) -> bool {
+        self.change_graph.is_empty() && self.queue.is_empty()
+    }
+
+    pub(crate) fn actor_id(&self) -> &ActorId {
+        match &self.actor {
+            Actor::Unused(id) => id,
+            Actor::Cached(idx) => self.ops.get_actor(*idx),
+        }
+    }
+
+    /// Set the actor id for this document.
+    pub fn with_actor(mut self, actor: ActorId) -> Self {
+        self.set_actor(actor);
+        self
+    }
+
+    /// Set the actor id for this document.
+    pub fn set_actor(&mut self, actor: ActorId) -> &mut Self {
+        match self.ops.actors.binary_search(&actor) {
+            Ok(idx) => self.actor = Actor::Cached(idx),
+            Err(_) => self.actor = Actor::Unused(actor),
+        }
+        self
+    }
+
+    /// Get the current actor id of this document.
+    pub fn get_actor(&self) -> &ActorId {
+        match &self.actor {
+            Actor::Unused(actor) => actor,
+            Actor::Cached(index) => self.ops.get_actor(*index),
+        }
+    }
+
+    pub(crate) fn remove_actor(&mut self, actor: usize) {
+        self.actor.remove_actor(actor, &self.ops.actors);
+        self.ops.remove_actor(actor);
+        self.change_graph.remove_actor(actor);
+    }
+
+    pub(crate) fn assert_no_unused_actors(&self, panic: bool) {
+        if self.ops.actors.len() != self.change_graph.actor_ids().count() {
+            let unused = self.change_graph.unused_actors().collect::<Vec<_>>();
+            log!("AUTOMERGE :: unused actor found when none expected");
+            log!(" :: ops={}", self.ops.actors.len());
+            log!(" :: graph={}", self.change_graph.all_actor_ids().count());
+            log!(" :: unused={:?}", unused);
+            log!(" :: actors={:?}", self.ops.actors);
+            assert!(!panic);
+        }
+    }
+
+    pub(crate) fn remove_unused_actors(&mut self, panic: bool) {
+        if panic {
+            self.assert_no_unused_actors(cfg!(debug_assertions));
+        }
+
+        // remove the offending actors
+        while let Some(idx) = self.change_graph.unused_actors().last() {
+            self.remove_actor(idx);
+        }
+    }
+
+    fn get_or_create_actor_index(&mut self) -> usize {
+        match &self.actor {
+            Actor::Unused(actor) => {
+                let index = self.put_actor(actor.clone());
+                self.actor = Actor::Cached(index);
+                index
+            }
+            Actor::Cached(index) => *index,
+        }
+    }
+
+    fn get_actor_index(&self) -> Option<usize> {
+        match &self.actor {
+            Actor::Unused(_) => None,
+            Actor::Cached(index) => Some(*index),
+        }
+    }
+
+    /// Start a transaction.
+    pub fn transaction(&mut self) -> Transaction<'_> {
+        let args = self.transaction_args(None);
+        Transaction::new(self, args, PatchLog::inactive())
+            .expect("inactive patch log should not mismatch")
+    }
+
+    /// Start a transaction which records changes in a [`PatchLog`]
+    ///
+    /// Returns [`PatchLogMismatch`](crate::PatchLogMismatch) if `patch_log` does not belong to
+    /// this document. This probably means a patch log created for one document was reused with
+    /// another document.
+    pub fn transaction_log_patches(
+        &mut self,
+        patch_log: PatchLog,
+    ) -> Result<Transaction<'_>, crate::PatchLogMismatch> {
+        let args = self.transaction_args(None);
+        Transaction::new(self, args, patch_log)
+    }
+
+    /// Start a transaction isolated at a given heads
+    ///
+    /// Returns [`PatchLogMismatch`](crate::PatchLogMismatch) if `patch_log` does not belong to
+    /// this document. This probably means a patch log created for one document was reused with
+    /// another document.
+    pub fn transaction_at(
+        &mut self,
+        patch_log: PatchLog,
+        heads: &[ChangeHash],
+    ) -> Result<Transaction<'_>, crate::PatchLogMismatch> {
+        let args = self.transaction_args(Some(heads));
+        Transaction::new(self, args, patch_log)
+    }
+
+    /// Start a transaction that owns the document, consuming `self`.
+    ///
+    /// This is useful when the transaction must be `'static` (e.g. storing across an FFI
+    /// boundary or in a struct that requires `'static`). The document is returned when the
+    /// transaction is committed or rolled back.
+    ///
+    /// # Arguments
+    /// * `patch_log` - An optional [`PatchLog`] to log the changes in this transaction to
+    /// * `heads` - An optional set of heads to isolate this transaction at, or `None` to use the
+    ///   current heads of the document
+    ///
+    /// Returns [`PatchLogMismatch`](crate::PatchLogMismatch) if `patch_log` does not belong to
+    /// this document. This probably means a patch log created for one document was reused with
+    /// another document.
+    pub fn into_transaction(
+        self,
+        patch_log: Option<PatchLog>,
+        heads: Option<&[ChangeHash]>,
+    ) -> Result<OwnedTransaction, crate::PatchLogMismatch> {
+        OwnedTransaction::new(self, patch_log, heads)
+    }
+
+    pub(crate) fn transaction_args(&mut self, heads: Option<&[ChangeHash]>) -> TransactionArgs {
+        let actor_index;
+        let seq;
+        let mut deps;
+        let scope;
+        match heads {
+            Some(heads) => {
+                deps = heads.to_vec();
+                let isolation = self.isolate_actor(heads);
+                actor_index = isolation.actor_index;
+                seq = isolation.seq;
+                scope = Some(isolation.clock);
+            }
+            None => {
+                actor_index = self.get_or_create_actor_index();
+                seq = self.change_graph.seq_for_actor(actor_index) + 1;
+                deps = self.get_heads();
+                scope = None;
+                if seq > 1 {
+                    let last_hash = self.get_hash(actor_index, seq - 1).unwrap();
+                    if !deps.contains(&last_hash) {
+                        deps.push(last_hash);
+                    }
+                }
+            }
+        }
+
+        // SAFETY: this unwrap is safe as we always add 1
+        let start_op = NonZeroU64::new(self.change_graph.max_op() + 1).unwrap();
+        let checkpoint = self.ops.save_checkpoint();
+        TransactionArgs {
+            actor_index,
+            seq,
+            start_op,
+            deps,
+            checkpoint,
+            scope,
+        }
+    }
+
+    /// Run a transaction on this document in a closure, automatically handling commit or rollback
+    /// afterwards.
+    pub fn transact<F, O, E>(&mut self, f: F) -> transaction::Result<O, E>
+    where
+        F: FnOnce(&mut Transaction<'_>) -> Result<O, E>,
+    {
+        self.transact_with_impl(None::<&dyn Fn(&O) -> CommitOptions>, f)
+    }
+
+    /// Like [`Self::transact()`] but with a function for generating the commit options.
+    pub fn transact_with<F, O, E, C>(&mut self, c: C, f: F) -> transaction::Result<O, E>
+    where
+        F: FnOnce(&mut Transaction<'_>) -> Result<O, E>,
+        C: FnOnce(&O) -> CommitOptions,
+    {
+        // FIXME
+        self.transact_with_impl(Some(c), f)
+    }
+
+    fn transact_with_impl<F, O, E, C>(&mut self, c: Option<C>, f: F) -> transaction::Result<O, E>
+    where
+        F: FnOnce(&mut Transaction<'_>) -> Result<O, E>,
+        C: FnOnce(&O) -> CommitOptions,
+    {
+        let mut tx = self.transaction();
+        let result = f(&mut tx);
+        match result {
+            Ok(result) => {
+                let (hash, patch_log) = if let Some(c) = c {
+                    let commit_options = c(&result);
+                    tx.commit_with(commit_options)
+                } else {
+                    tx.commit()
+                };
+                Ok(Success {
+                    result,
+                    hash,
+                    patch_log,
+                })
+            }
+            Err(error) => Err(Failure {
+                error,
+                cancelled: tx.rollback(),
+            }),
+        }
+    }
+
+    /// Run a transaction on this document in a closure, collecting patches, automatically handling commit or rollback
+    /// afterwards.
+    ///
+    /// The collected patches are available in the return value of [`Transaction::commit()`]
+    pub fn transact_and_log_patches<F, O, E>(&mut self, f: F) -> transaction::Result<O, E>
+    where
+        F: FnOnce(&mut Transaction<'_>) -> Result<O, E>,
+    {
+        self.transact_and_log_patches_with_impl(None::<&dyn Fn(&O) -> CommitOptions>, f)
+    }
+
+    /// Like [`Self::transact_and_log_patches()`] but with a function for generating the commit options
+    pub fn transact_and_log_patches_with<F, O, E, C>(
+        &mut self,
+        c: C,
+        f: F,
+    ) -> transaction::Result<O, E>
+    where
+        F: FnOnce(&mut Transaction<'_>) -> Result<O, E>,
+        C: FnOnce(&O) -> CommitOptions,
+    {
+        self.transact_and_log_patches_with_impl(Some(c), f)
+    }
+
+    fn transact_and_log_patches_with_impl<F, O, E, C>(
+        &mut self,
+        c: Option<C>,
+        f: F,
+    ) -> transaction::Result<O, E>
+    where
+        F: FnOnce(&mut Transaction<'_>) -> Result<O, E>,
+        C: FnOnce(&O) -> CommitOptions,
+    {
+        let mut tx = self
+            .transaction_log_patches(PatchLog::active())
+            .expect("new patch log should not mismatch");
+        let result = f(&mut tx);
+        match result {
+            Ok(result) => {
+                let (hash, history) = if let Some(c) = c {
+                    let commit_options = c(&result);
+                    tx.commit_with(commit_options)
+                } else {
+                    tx.commit()
+                };
+                Ok(Success {
+                    result,
+                    hash,
+                    patch_log: history,
+                })
+            }
+            Err(error) => Err(Failure {
+                error,
+                cancelled: tx.rollback(),
+            }),
+        }
+    }
+
+    /// Generate an empty change
+    ///
+    /// The main reason to do this is if you want to create a "merge commit", which is a change
+    /// that has all the current heads of the document as dependencies.
+    pub fn empty_commit(&mut self, opts: CommitOptions) -> ChangeHash {
+        let args = self.transaction_args(None);
+        Transaction::empty(self, args, opts)
+    }
+
+    /// Fork this document at the current point for use by a different actor.
+    ///
+    /// This will create a new actor ID for the forked document
+    pub fn fork(&self) -> Self {
+        let mut f = self.clone();
+        f.set_actor(ActorId::random());
+        f
+    }
+
+    /// Fork this document at the given heads
+    ///
+    /// This will create a new actor ID for the forked document
+    pub fn fork_at(&self, heads: &[ChangeHash]) -> Result<Self, AutomergeError> {
+        let mut seen = heads.iter().cloned().collect::<HashSet<_>>();
+        let mut heads = heads.to_vec();
+        let mut hashes = vec![];
+        while let Some(hash) = heads.pop() {
+            if !self.change_graph.has_change(&hash) {
+                return Err(AutomergeError::InvalidHash(hash));
+            }
+            for dep in self.change_graph.deps_for_hash(&hash) {
+                if !seen.contains(&dep) {
+                    heads.push(dep);
+                }
+            }
+            hashes.push(hash);
+            seen.insert(hash);
+        }
+        let mut f = Self::new();
+        f.set_actor(ActorId::random());
+        let changes = self.get_changes_by_hashes(hashes.into_iter().rev())?;
+        f.apply_changes(changes)?;
+        Ok(f)
+    }
+
+    pub(crate) fn get_changes_by_hashes<I>(&self, hashes: I) -> Result<Vec<Change>, AutomergeError>
+    where
+        I: IntoIterator<Item = ChangeHash>,
+    {
+        ChangeCollector::for_hashes(&self.ops, &self.change_graph, hashes)
+    }
+
+    pub(crate) fn exid_to_opid(&self, id: &ExId) -> Result<OpId, AutomergeError> {
+        match id {
+            ExId::Root => Ok(OpId::new(0, 0)),
+            ExId::Id(ctr, actor, idx) => {
+                let opid = if self.ops.get_actor_safe(*idx) == Some(actor) {
+                    OpId::new(*ctr, *idx)
+                } else if let Some(backup_idx) = self.ops.lookup_actor(actor) {
+                    OpId::new(*ctr, backup_idx)
+                } else {
+                    return Err(AutomergeError::InvalidObjId(id.to_string()));
+                };
+                Ok(opid)
+            }
+        }
+    }
+
+    pub(crate) fn get_obj_meta(&self, id: ObjId) -> Result<ObjMeta, AutomergeError> {
+        if id.is_root() {
+            Ok(ObjMeta::root())
+        } else if let Some(typ) = self.ops.object_type(&id) {
+            Ok(ObjMeta { id, typ })
+        } else {
+            Err(AutomergeError::NotAnObject)
+        }
+    }
+
+    pub(crate) fn op_cursor_to_opid(
+        &self,
+        cursor: &OpCursor,
+        clock: Option<&Clock>,
+    ) -> Result<OpId, AutomergeError> {
+        if let Some(idx) = self.ops.lookup_actor(&cursor.actor) {
+            let opid = OpId::new(cursor.ctr, idx);
+            match clock {
+                Some(clock) if !clock.covers(&opid) => {
+                    Err(AutomergeError::InvalidCursor(Cursor::Op(cursor.clone())))
+                }
+                _ => Ok(opid),
+            }
+        } else {
+            Err(AutomergeError::InvalidCursor(Cursor::Op(cursor.clone())))
+        }
+    }
+
+    pub(crate) fn exid_to_obj(&self, id: &ExId) -> Result<ObjMeta, AutomergeError> {
+        let opid = self.exid_to_opid(id)?;
+        let obj = ObjId(opid);
+        self.get_obj_meta(obj)
+    }
+
+    pub(crate) fn id_to_exid(&self, id: OpId) -> ExId {
+        self.ops.id_to_exid(id)
+    }
+
+    pub fn diff_opset(&self, other: &Self) -> Result<(), AutomergeError> {
+        let (ops_meta1, ops_out1) = self.ops.export();
+        let (ops_meta2, ops_out2) = other.ops.export();
+        if ops_meta1 != ops_meta2 {
+            let specs: std::collections::BTreeSet<_> = ops_meta1
+                .0
+                .iter()
+                .chain(ops_meta2.0.iter())
+                .map(|c| c.spec())
+                .collect();
+            for s in specs {
+                let d1 = ops_meta1
+                    .0
+                    .iter()
+                    .find(|c| c.spec() == s)
+                    .map(|c| c.data())
+                    .unwrap_or(0..0);
+                let d2 = ops_meta2
+                    .0
+                    .iter()
+                    .find(|c| c.spec() == s)
+                    .map(|c| c.data())
+                    .unwrap_or(0..0);
+                let d1 = &ops_out1[d1];
+                let d2 = &ops_out2[d2];
+                if d1 != d2 {
+                    log!(" s={:?}|{:?} ", s.id(), s.col_type());
+                    log!(" {:?} ", d1);
+                    log!(" {:?} ", d2);
+                    OpSet::decode(s, d1);
+                    OpSet::decode(s, d2);
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Load a document.
+    pub fn load(data: &[u8]) -> Result<Self, AutomergeError> {
+        Self::load_with_options(data, Default::default())
+    }
+
+    /// Load a document without verifying the head hashes
+    ///
+    /// This is useful for debugging as it allows you to examine a corrupted document.
+    pub fn load_unverified_heads(data: &[u8]) -> Result<Self, AutomergeError> {
+        Self::load_with_options(
+            data,
+            LoadOptions {
+                verification_mode: VerificationMode::DontCheck,
+                ..Default::default()
+            },
+        )
+    }
+
+    /// Load a document, with options
+    ///
+    /// # Arguments
+    /// * `data` - The data to load
+    /// * `on_error` - What to do if the document is only partially loaded. This can happen if some
+    ///                prefix of `data` contains valid data.
+    /// * `mode` - Whether to verify the head hashes after loading
+    /// * `patch_log` - A [`PatchLog`] to log the changes required to materialize the current state of
+    ///                 the document once loaded
+    #[deprecated(since = "0.5.2", note = "Use `load_with_options` instead")]
+    #[tracing::instrument(skip(data), err)]
+    pub fn load_with(
+        data: &[u8],
+        on_error: OnPartialLoad,
+        mode: VerificationMode,
+        patch_log: &mut PatchLog,
+    ) -> Result<Self, AutomergeError> {
+        Self::load_with_options(
+            data,
+            LoadOptions::new()
+                .on_partial_load(on_error)
+                .verification_mode(mode)
+                .patch_log(patch_log),
+        )
+    }
+
+    /// Load a document, with options
+    ///
+    /// # Arguments
+    /// * `data` - The data to load
+    /// * `options` - The options to use when loading
+    #[tracing::instrument(skip(data), err)]
+    pub fn load_with_options(
+        data: &[u8],
+        options: LoadOptions<'_>,
+    ) -> Result<Self, AutomergeError> {
+        if data.is_empty() {
+            tracing::trace!("no data, initializing empty document");
+            return Ok(Self::new());
+        }
+        tracing::trace!("loading first chunk");
+        let (remaining, first_chunk) = storage::Chunk::parse(storage::parse::Input::new(data))
+            .map_err(|e| load::Error::Parse(Box::new(e)))?;
+        if !first_chunk.checksum_valid() {
+            return Err(load::Error::BadChecksum.into());
+        }
+
+        let mut changes = vec![];
+        let mut first_chunk_was_doc = false;
+        let mut am = match first_chunk {
+            storage::Chunk::Document(d) => {
+                tracing::trace!("first chunk is document chunk, inflating");
+                first_chunk_was_doc = true;
+                d.reconstruct(options.verification_mode, options.text_encoding)
+                    .map_err(|e| load::Error::InflateDocument(Box::new(e)))?
+            }
+            storage::Chunk::Change(stored_change) => {
+                tracing::trace!("first chunk is change chunk");
+                changes.push(
+                    Change::new_from_unverified(stored_change.into_owned(), None)
+                        .map_err(|e| load::Error::InvalidChangeColumns(Box::new(e)))?,
+                );
+                Self::new()
+            }
+            storage::Chunk::Bundle(bundle) => {
+                tracing::trace!("first chunk is change chunk");
+                let bundle = Bundle::new_from_unverified(bundle.into_owned())
+                    .map_err(|e| load::Error::InvalidBundleColumn(Box::new(e)))?;
+                let bundle_changes = bundle
+                    .to_changes()
+                    .map_err(|e| load::Error::InvalidBundleChange(Box::new(e)))?;
+                changes.extend(bundle_changes);
+                Self::new()
+            }
+            storage::Chunk::CompressedChange(stored_change, compressed) => {
+                tracing::trace!("first chunk is compressed change");
+                changes.push(
+                    Change::new_from_unverified(
+                        stored_change.into_owned(),
+                        Some(compressed.into_owned()),
+                    )
+                    .map_err(|e| load::Error::InvalidChangeColumns(Box::new(e)))?,
+                );
+                Self::new()
+            }
+        };
+        tracing::trace!("loading change chunks");
+        match load::load_changes(remaining.reset(), options.text_encoding, &am.change_graph) {
+            load::LoadedChanges::Complete(c) => {
+                am.apply_changes(changes.into_iter().chain(c))?;
+                // Only allow missing deps if the first chunk was a document chunk
+                // See https://github.com/automerge/automerge/pull/599#issuecomment-1549667472
+                if !am.queue.is_empty()
+                    && !first_chunk_was_doc
+                    && options.on_partial_load == OnPartialLoad::Error
+                {
+                    return Err(AutomergeError::MissingDeps);
+                }
+            }
+            load::LoadedChanges::Partial { error, .. } => {
+                if options.on_partial_load == OnPartialLoad::Error {
+                    return Err(error.into());
+                }
+            }
+        }
+        if let StringMigration::ConvertToText = options.string_migration {
+            am.convert_scalar_strings_to_text()?;
+        }
+        if let Some(patch_log) = options.patch_log {
+            if patch_log.is_active() {
+                am.log_current_state(ObjMeta::root(), patch_log, true);
+            }
+        }
+        Ok(am)
+    }
+
+    /// Create the patches from a [`PatchLog`]
+    ///
+    /// See the documentation for [`PatchLog`] for more details on this
+    pub fn make_patches(&self, patch_log: &mut PatchLog) -> Vec<Patch> {
+        patch_log.make_patches(self)
+    }
+
+    /// Get a set of [`Patch`]es which materialize the current state of the document
+    ///
+    /// This is a convienence method for [`doc.diff(&[], current_heads)`][diff]
+    ///
+    /// [diff]: Self::diff()
+    pub fn current_state(&self) -> Vec<Patch> {
+        let mut patch_log = PatchLog::active();
+        self.log_current_state(ObjMeta::root(), &mut patch_log, true);
+        patch_log.make_patches(self)
+    }
+
+    /// Load an incremental save of a document.
+    ///
+    /// Unlike [`Self::load()`] this imports changes into an existing document. It will work with
+    /// both the output of [`Self::save()`] and [`Self::save_after()`]
+    ///
+    /// The return value is the number of ops which were applied, this is not useful and will
+    /// change in future.
+    pub fn load_incremental(&mut self, data: &[u8]) -> Result<usize, AutomergeError> {
+        self.load_incremental_log_patches(data, &mut PatchLog::inactive())
+    }
+
+    /// Like [`Self::load_incremental()`] but log the changes to the current state of the document
+    /// to [`PatchLog`]
+    pub fn load_incremental_log_patches(
+        &mut self,
+        data: &[u8],
+        patch_log: &mut PatchLog,
+    ) -> Result<usize, AutomergeError> {
+        if self.is_empty() {
+            let mut doc = Self::load_with_options(
+                data,
+                LoadOptions::new()
+                    .on_partial_load(OnPartialLoad::Ignore)
+                    .verification_mode(VerificationMode::Check),
+            )?;
+            doc = doc.with_actor(self.actor_id().clone());
+            if patch_log.is_active() {
+                doc.log_current_state(ObjMeta::root(), patch_log, true);
+            }
+            *self = doc;
+            return Ok(self.ops.len());
+        }
+        let changes = match load::load_changes(
+            storage::parse::Input::new(data),
+            self.text_encoding(),
+            &self.change_graph,
+        ) {
+            load::LoadedChanges::Complete(c) => c,
+            load::LoadedChanges::Partial { error, loaded, .. } => {
+                tracing::warn!(successful_chunks=loaded.len(), err=?error, "partial load");
+                loaded
+            }
+        };
+        let start = self.ops.len();
+        self.apply_changes_log_patches(changes, patch_log)?;
+        let delta = self.ops.len() - start;
+        Ok(delta)
+    }
+
+    pub(crate) fn log_current_state(
+        &self,
+        obj: ObjMeta,
+        patch_log: &mut PatchLog,
+        recursive: bool,
+    ) {
+        let clock = ClockRange::default();
+        let path_map = DiffIter::log(self, obj, clock, patch_log, recursive);
+        patch_log.path_hint(path_map);
+    }
+
+    fn seq_for_actor(&self, actor: &ActorId) -> u64 {
+        self.ops
+            .lookup_actor(actor)
+            .map(|idx| self.change_graph.seq_for_actor(idx))
+            .unwrap_or(0)
+    }
+
+    pub(crate) fn has_actor_seq(&self, change: &Change) -> bool {
+        self.seq_for_actor(change.actor_id()) >= change.seq()
+    }
+
+    /// Apply changes to this document.
+    ///
+    /// This is idempotent in the sense that if a change has already been applied it will be
+    /// ignored.
+    pub fn apply_changes(
+        &mut self,
+        changes: impl IntoIterator<Item = Change> + Clone,
+    ) -> Result<(), AutomergeError> {
+        self.apply_changes_log_patches(changes, &mut PatchLog::inactive())
+    }
+
+    /// Like [`Self::apply_changes()`] but log the resulting changes to the current state of the
+    /// document to `patch_log`
+    pub fn apply_changes_log_patches<I: IntoIterator<Item = Change> + Clone>(
+        &mut self,
+        changes: I,
+        patch_log: &mut PatchLog,
+    ) -> Result<(), AutomergeError> {
+        self.apply_changes_batch_log_patches(changes, patch_log)
+    }
+
+    /// Takes all the changes in `other` which are not in `self` and applies them
+    pub fn merge(&mut self, other: &mut Self) -> Result<Vec<ChangeHash>, AutomergeError> {
+        self.merge_and_log_patches(other, &mut PatchLog::inactive())
+    }
+
+    /// Takes all the changes in `other` which are not in `self` and applies them whilst logging
+    /// the resulting changes to the current state of the document to `patch_log`
+    pub fn merge_and_log_patches(
+        &mut self,
+        other: &mut Self,
+        patch_log: &mut PatchLog,
+    ) -> Result<Vec<ChangeHash>, AutomergeError> {
+        // TODO: Make this fallible and figure out how to do this transactionally
+        let changes = self.get_changes_added(other);
+        tracing::trace!(changes=?changes.iter().map(|c| c.hash()).collect::<Vec<_>>(), "merging new changes");
+        self.apply_changes_log_patches(changes, patch_log)?;
+        Ok(self.get_heads())
+    }
+
+    /// EXPERIMENTAL: Write the set of changes in `hashes` to a "bundle"
+    ///
+    /// A "bundle" is a compact representation of a set of changes which uses
+    /// the same compression tricks as the document encoding we use in
+    /// [`Automerge::save`].
+    ///
+    /// This is an experimental API, the bundle format is still subject to change
+    /// and so should not be used in production just yet.
+    pub fn bundle<I>(&self, hashes: I) -> Result<Bundle, AutomergeError>
+    where
+        I: IntoIterator<Item = ChangeHash>,
+    {
+        Bundle::for_hashes(&self.ops, &self.change_graph, hashes)
+    }
+
+    /// Save the entirety of this document in a compact form.
+    pub fn save_with_options(&self, options: SaveOptions) -> Vec<u8> {
+        self.assert_no_unused_actors(true);
+
+        let doc = Document::new(&self.ops, &self.change_graph, options.compress());
+        let mut bytes = doc.into_bytes();
+
+        if options.retain_orphans {
+            for orphaned in self.queue.iter() {
+                bytes.extend(orphaned.raw_bytes());
+            }
+        }
+        bytes
+    }
+
+    #[cfg(test)]
+    pub fn debug_cmp(&self, other: &Self) {
+        self.ops.debug_cmp(&other.ops);
+    }
+
+    /// Save the entirety of this document in a compact form.
+    pub fn save(&self) -> Vec<u8> {
+        self.save_with_options(SaveOptions::default())
+    }
+
+    /// Save the document and attempt to load it before returning - slow!
+    pub fn save_and_verify(&self) -> Result<Vec<u8>, AutomergeError> {
+        let bytes = self.save();
+        Self::load(&bytes)?;
+        Ok(bytes)
+    }
+
+    /// Save this document, but don't run it through `DEFLATE` afterwards
+    pub fn save_nocompress(&self) -> Vec<u8> {
+        self.save_with_options(SaveOptions {
+            deflate: false,
+            ..Default::default()
+        })
+    }
+
+    /// Save the changes since the given heads
+    ///
+    /// The output of this will not be a compressed document format, but a series of individual
+    /// changes. This is useful if you know you have only made a small change since the last
+    /// [`Self::save()`] and you want to immediately send it somewhere (e.g. you've inserted a
+    /// single character in a text object).
+    pub fn save_after(&self, heads: &[ChangeHash]) -> Vec<u8> {
+        let changes = self.get_changes(heads);
+        let mut bytes = vec![];
+        for c in changes {
+            bytes.extend(c.raw_bytes());
+        }
+        bytes
+    }
+
+    /// Filter the changes down to those that are not transitive dependencies of the heads.
+    ///
+    /// Thus a graph with these heads has not seen the remaining changes.
+    pub(crate) fn filter_changes(
+        &self,
+        heads: &[ChangeHash],
+        changes: &mut BTreeSet<ChangeHash>,
+    ) -> Result<(), AutomergeError> {
+        let heads = heads
+            .iter()
+            .filter(|hash| self.has_change(hash))
+            .copied()
+            .collect::<Vec<_>>();
+
+        self.change_graph.remove_ancestors(changes, &heads);
+
+        Ok(())
+    }
+
+    /// Get the last change this actor made to the document.
+    pub fn get_last_local_change(&self) -> Option<Change> {
+        let actor = self.get_actor_index()?;
+        let seq = self.change_graph.seq_for_actor(actor);
+        let hash = self.change_graph.get_hash_for_actor_seq(actor, seq).ok()?;
+        self.get_change_by_hash(&hash)
+    }
+
+    pub(crate) fn clock_range(&self, before: &[ChangeHash], after: &[ChangeHash]) -> ClockRange {
+        let before = self.clock_at(before);
+        let after = self.clock_at(after);
+        ClockRange::Diff(before, after)
+    }
+
+    pub(crate) fn clock_at(&self, heads: &[ChangeHash]) -> Clock {
+        self.change_graph.clock_for_heads(heads)
+    }
+
+    fn get_isolated_actor_index(&mut self, level: usize) -> usize {
+        if level == 0 {
+            self.get_or_create_actor_index()
+        } else {
+            let base_actor = self.get_actor();
+            let new_actor = base_actor.with_concurrency(level);
+            self.put_actor(new_actor)
+        }
+    }
+
+    pub(crate) fn isolate_actor(&mut self, heads: &[ChangeHash]) -> Isolation {
+        let mut actor_index = self.get_isolated_actor_index(0);
+        let mut clock = self.clock_at(heads);
+
+        for i in 1.. {
+            let max_op = self.change_graph.max_op_for_actor(actor_index);
+            if max_op == 0 || clock.covers(&OpId::new(max_op, actor_index)) {
+                clock.isolate(actor_index);
+                break;
+            }
+            actor_index = self.get_isolated_actor_index(i);
+            clock = self.clock_at(heads); // need to recompute the clock b/c the actor indexes may have changed
+        }
+
+        let seq = self.change_graph.seq_for_actor(actor_index) + 1;
+
+        Isolation {
+            actor_index,
+            seq,
+            clock,
+        }
+    }
+
+    fn get_hash(&self, actor: usize, seq: u64) -> Result<ChangeHash, AutomergeError> {
+        self.change_graph.get_hash_for_actor_seq(actor, seq)
+    }
+
+    pub(crate) fn update_history(&mut self, change: &Change) {
+        self.update_deps(change);
+
+        let actor_index = self
+            .ops
+            .actors
+            .binary_search(change.actor_id())
+            .expect("Change's actor not already in the document");
+
+        self.change_graph
+            .add_change(change, actor_index)
+            .expect("Change's deps should already be in the document");
+    }
+
+    fn insert_actor(&mut self, index: usize, actor: ActorId) -> usize {
+        self.ops.insert_actor(index, actor);
+        self.change_graph.insert_actor(index);
+        self.actor.rewrite_with_new_actor(index);
+        index
+    }
+    pub(crate) fn put_actor_ref(&mut self, actor: &ActorId) -> usize {
+        match self.ops.actors.binary_search(actor) {
+            Ok(idx) => idx,
+            Err(idx) => self.insert_actor(idx, actor.clone()),
+        }
+    }
+
+    pub(crate) fn put_actor(&mut self, actor: ActorId) -> usize {
+        match self.ops.actors.binary_search(&actor) {
+            Ok(idx) => idx,
+            Err(idx) => self.insert_actor(idx, actor),
+        }
+    }
+
+    fn update_deps(&mut self, change: &Change) {
+        for d in change.deps() {
+            self.deps.remove(d);
+        }
+        self.deps.insert(change.hash());
+    }
+
+    #[doc(hidden)]
+    pub fn import(&self, s: &str) -> Result<(ExId, ObjType), AutomergeError> {
+        let obj = self.import_obj(s)?;
+        if obj == ExId::Root {
+            Ok((ExId::Root, ObjType::Map))
+        } else {
+            let obj_type = self
+                .object_type(&obj)
+                .map_err(|_| AutomergeError::InvalidObjId(s.to_owned()))?;
+            Ok((obj, obj_type))
+        }
+    }
+
+    #[doc(hidden)]
+    pub fn import_obj(&self, s: &str) -> Result<ExId, AutomergeError> {
+        if s == "_root" {
+            Ok(ExId::Root)
+        } else {
+            let n = s
+                .find('@')
+                .ok_or_else(|| AutomergeError::InvalidObjIdFormat(s.to_owned()))?;
+            let counter = s[0..n]
+                .parse()
+                .map_err(|_| AutomergeError::InvalidObjIdFormat(s.to_owned()))?;
+            let actor = ActorId::from(hex::decode(&s[(n + 1)..]).unwrap());
+            let actor = self
+                .ops
+                .lookup_actor(&actor)
+                .ok_or_else(|| AutomergeError::InvalidObjId(s.to_owned()))?;
+            let obj = ExId::Id(counter, self.ops.get_actor(actor).clone(), actor);
+            Ok(obj)
+        }
+    }
+
+    pub fn dump(&self) {
+        /*
+                log!(
+                    "  {:12} {:3} {:12} {:12} {:12} {:12} {:12}",
+                    "id",
+                    "ins",
+                    "obj",
+                    "key",
+                    "value",
+                    "pred",
+                    "succ"
+                );
+        */
+        self.ops.dump();
+        /*
+                for op in self.ops.iter() {
+                    let id = self.to_short_string(op.id);
+                    let obj = self.to_short_string(op.obj);
+                    let key = match op.key {
+                        KeyRef::Map(n) => n.to_owned(),
+                        KeyRef::Seq(n) => self.to_short_string(n),
+                    };
+                    let value: String = match op.op_type() {
+                        OpType::Put(value) => format!("{}", value),
+                        OpType::Make(obj) => format!("make({})", obj),
+                        OpType::Increment(obj) => format!("inc({})", obj),
+                        OpType::Delete => format!("del{}", 0),
+                        OpType::MarkBegin(_, MarkData { name, value }) => {
+                            format!("mark({},{})", name, value)
+                        }
+                        OpType::MarkEnd(_) => "/mark".to_string(),
+                    };
+                    //let pred: Vec<_> = op.pred().map(|id| self.to_short_string(id)).collect();
+                    let succ: Vec<_> = op.succ().map(|id| self.to_short_string(id)).collect();
+                    let insert = match op.insert {
+                        true => "t",
+                        false => "f",
+                    };
+                    log!(
+                        //"  {:12} {:3} {:12} {:12} {:12} {:12?} {:12?}",
+                        "  {:12} {:3} {:12} {:12} {:12} {:12?}",
+                        id,
+                        insert,
+                        obj,
+                        key,
+                        value,
+                        //pred,
+                        succ
+                    );
+                }
+        */
+    }
+
+    /// Create patches representing the change in the current state of the document between the
+    /// `before` and `after` heads.  If the arguments are reverse it will observe the same changes
+    /// in the opposite order.
+    pub fn diff(&self, before_heads: &[ChangeHash], after_heads: &[ChangeHash]) -> Vec<Patch> {
+        let clock = self.clock_range(before_heads, after_heads);
+        let mut patch_log = PatchLog::active();
+        DiffIter::log(self, ObjMeta::root(), clock, &mut patch_log, true);
+        patch_log.heads = Some(after_heads.to_vec());
+        patch_log.make_patches(self)
+    }
+
+    /// Create patches representing the change in the current state of an object
+    /// in the document between the `before_heads` and `after_heads` heads. If
+    /// the arguments are reverse it will observe the same changes in the
+    /// opposite order.
+    ///
+    /// # Arguments
+    ///
+    /// * `obj` - The object to start the diff at.
+    /// * `before_heads` - heads from [`Self::get_heads()`] at beginning point
+    ///   in the documents history
+    /// * `after_heads` - heads from [`Self::get_heads()`] at ending point in
+    ///   the documents history.
+    /// * `recursive` - if false, do not also diff child objects
+    ///
+    /// Note: `before_heads` and `after_heads` do not have to be chronological.
+    /// Document state can move backward.
+    pub fn diff_obj(
+        &self,
+        obj: &ExId,
+        before_heads: &[ChangeHash],
+        after_heads: &[ChangeHash],
+        recursive: bool,
+    ) -> Result<Vec<Patch>, AutomergeError> {
+        let obj = self.exid_to_obj(obj.as_ref())?;
+        let clock = self.clock_range(before_heads, after_heads);
+        let mut patch_log = PatchLog::active();
+        DiffIter::log(self, obj, clock, &mut patch_log, recursive);
+        patch_log.heads = Some(after_heads.to_vec());
+        Ok(patch_log.make_patches(self))
+    }
+
+    /// Get the heads of this document.
+    pub fn get_heads(&self) -> Vec<ChangeHash> {
+        let mut deps: Vec<_> = self.deps.iter().copied().collect();
+        deps.sort_unstable();
+        deps
+    }
+
+    pub fn get_changes(&self, have_deps: &[ChangeHash]) -> Vec<Change> {
+        ChangeCollector::exclude_hashes(&self.ops, &self.change_graph, have_deps)
+    }
+
+    pub fn get_changes_meta(&self, have_deps: &[ChangeHash]) -> Vec<ChangeMetadata<'_>> {
+        ChangeCollector::exclude_hashes_meta(&self.ops, &self.change_graph, have_deps)
+    }
+
+    pub fn get_change_meta_by_hash(&self, hash: &ChangeHash) -> Option<ChangeMetadata<'_>> {
+        ChangeCollector::meta_for_hashes(&self.ops, &self.change_graph, [*hash])
+            .ok()?
+            .pop()
+    }
+
+    /// Get changes in `other` that are not in `self`
+    pub fn get_changes_added(&self, other: &Self) -> Vec<Change> {
+        // Depth-first traversal from the heads through the dependency graph,
+        // until we reach a change that is already present in other
+        let mut stack: Vec<_> = other.get_heads();
+        tracing::trace!(their_heads=?stack, "finding changes to merge");
+        let mut seen_hashes = HashSet::new();
+        let mut added_change_hashes = Vec::new();
+        while let Some(hash) = stack.pop() {
+            if !seen_hashes.contains(&hash) && !self.has_change(&hash) {
+                seen_hashes.insert(hash);
+                added_change_hashes.push(hash);
+                stack.extend(other.change_graph.deps_for_hash(&hash));
+            }
+        }
+        // Return those changes in the reverse of the order in which the depth-first search
+        // found them. This is not necessarily a topological sort, but should usually be close.
+        added_change_hashes.reverse();
+
+        // safe to unwrap here b/c added_changes all came from the change_graph
+        other.get_changes_by_hashes(added_change_hashes).unwrap()
+    }
+
+    /// Get the hash of the change that contains the given `opid`.
+    ///
+    /// Returns [`None`] if the `opid`:
+    /// - is the root object id
+    /// - does not exist in this document
+    pub fn hash_for_opid(&self, exid: &ExId) -> Option<ChangeHash> {
+        match exid {
+            ExId::Root => None,
+            ExId::Id(..) => {
+                let opid = self.exid_to_opid(exid).ok()?;
+                self.change_graph.opid_to_hash(opid)
+            }
+        }
+    }
+
+    fn calculate_marks(
+        &self,
+        obj: &ExId,
+        clock: Option<Clock>,
+    ) -> Result<Vec<Mark>, AutomergeError> {
+        let obj = self.exid_to_obj(obj.as_ref())?;
+        let mut top_ops = self
+            .ops()
+            .iter_obj(&obj.id)
+            .visible_slow(clock)
+            .top_ops()
+            .marks();
+
+        let Some(seq_type) = obj.typ.as_sequence_type() else {
+            // Really we should return an error here but we don't in order to stay
+            // compatibile with older implementations
+            return Ok(Vec::new());
+        };
+
+        let mut index = 0;
+        let mut acc = MarkAccumulator::default();
+        let mut last_marks = None;
+        let mut mark_len = 0;
+        let mut mark_index = 0;
+        while let Some(o) = top_ops.next() {
+            let marks = top_ops.get_marks();
+            let len = o.width(seq_type, self.text_encoding());
+            if last_marks.as_ref() != marks {
+                match last_marks.as_ref() {
+                    Some(m) if mark_len > 0 => acc.add(mark_index, mark_len, m),
+                    _ => (),
+                }
+                last_marks = marks.cloned();
+                mark_index = index;
+                mark_len = 0;
+            }
+            mark_len += len;
+            index += len;
+        }
+        match last_marks.as_ref() {
+            Some(m) if mark_len > 0 => acc.add(mark_index, mark_len, m),
+            _ => (),
+        }
+        Ok(acc.into_iter_no_unmark().collect())
+    }
+
+    pub fn hydrate(&self, heads: Option<&[ChangeHash]>) -> hydrate::Value {
+        let clock = heads.map(|heads| self.clock_at(heads));
+        self.hydrate_map(&ObjId::root(), clock.as_ref())
+    }
+
+    pub(crate) fn hydrate_obj(
+        &self,
+        obj: &crate::ObjId,
+        heads: Option<&[ChangeHash]>,
+    ) -> Result<hydrate::Value, AutomergeError> {
+        let obj = self.exid_to_obj(obj)?;
+        let clock = heads.map(|heads| self.clock_at(heads));
+        Ok(match obj.typ {
+            ObjType::Map | ObjType::Table => self.hydrate_map(&obj.id, clock.as_ref()),
+            ObjType::List => self.hydrate_list(&obj.id, clock.as_ref()),
+            ObjType::Text => self.hydrate_text(&obj.id, clock.as_ref()),
+        })
+    }
+
+    pub(crate) fn parents_for(
+        &self,
+        obj: &ExId,
+        clock: Option<Clock>,
+    ) -> Result<Parents<'_>, AutomergeError> {
+        let obj = self.exid_to_obj(obj)?;
+        // FIXME - now that we have blocks a correct text_rep is relevent
+        Ok(self.ops.parents(obj.id, clock))
+    }
+
+    pub(crate) fn keys_for(&self, obj: &ExId, clock: Option<Clock>) -> Keys<'_> {
+        self.exid_to_obj(obj)
+            .ok()
+            .map(|obj| self.ops.keys(&obj.id, clock))
+            .unwrap_or_default()
+    }
+
+    pub(crate) fn iter_for(&self, obj: &ExId, clock: Option<Clock>) -> DocIter<'_> {
+        self.exid_to_obj(obj)
+            .ok()
+            .map(|obj| DocIter::new(self, obj, clock))
+            .unwrap_or_else(|| DocIter::empty(self.text_encoding()))
+    }
+
+    pub(crate) fn map_range_for<'a, R: RangeBounds<String> + 'a>(
+        &'a self,
+        obj: &ExId,
+        range: R,
+        clock: Option<Clock>,
+    ) -> MapRange<'a> {
+        self.exid_to_obj(obj)
+            .ok()
+            .map(|obj| self.ops.map_range(&obj.id, range, clock))
+            .unwrap_or_default()
+    }
+
+    pub(crate) fn list_range_for<R: RangeBounds<usize>>(
+        &self,
+        obj: &ExId,
+        range: R,
+        clock: Option<Clock>,
+    ) -> ListRange<'_> {
+        self.exid_to_obj(obj)
+            .ok()
+            .map(|obj| self.ops.list_range(&obj.id, range, clock))
+            .unwrap_or_default()
+    }
+
+    pub(crate) fn values_for(&self, obj: &ExId, clock: Option<Clock>) -> Values<'_> {
+        self.exid_to_obj(obj)
+            .ok()
+            .map(|obj| Values::new(&self.ops, self.ops.top_ops(&obj.id, clock.clone()), clock))
+            .unwrap_or_default()
+    }
+
+    pub(crate) fn length_for(&self, obj: &ExId, clock: Option<Clock>) -> usize {
+        // FIXME - is doc.length() for a text always the string length?
+        self.exid_to_obj(obj)
+            .map(|obj| self.ops.seq_length(&obj.id, self.text_encoding(), clock))
+            .unwrap_or(0)
+    }
+
+    pub(crate) fn text_for(
+        &self,
+        obj: &ExId,
+        clock: Option<Clock>,
+    ) -> Result<String, AutomergeError> {
+        let obj = self.exid_to_obj(obj)?;
+        Ok(self.ops.text(&obj.id, clock))
+    }
+
+    pub(crate) fn spans_for(
+        &self,
+        obj: &ExId,
+        clock: Option<Clock>,
+    ) -> Result<Spans<'_>, AutomergeError> {
+        let obj = self.exid_to_obj(obj)?;
+        Ok(Spans::new(self.ops.spans(&obj.id, clock)))
+    }
+
+    pub(crate) fn get_cursor_for(
+        &self,
+        obj: &ExId,
+        position: CursorPosition,
+        clock: Option<Clock>,
+        move_cursor: MoveCursor,
+    ) -> Result<Cursor, AutomergeError> {
+        let obj = self.exid_to_obj(obj)?;
+        let Some(seq_type) = obj.typ.as_sequence_type() else {
+            return Err(AutomergeError::InvalidOp(obj.typ));
+        };
+        match position {
+            CursorPosition::Start => Ok(Cursor::Start),
+            CursorPosition::End => Ok(Cursor::End),
+            CursorPosition::Index(i) => {
+                let found = self
+                    .ops
+                    .seek_ops_by_index(&obj.id, i, seq_type, clock.as_ref());
+
+                if let Some(op) = found.ops.last() {
+                    Ok(Cursor::Op(OpCursor::new(op.id, &self.ops, move_cursor)))
+                } else {
+                    Err(AutomergeError::InvalidIndex(i))
+                }
+            }
+        }
+    }
+
+    pub(crate) fn get_cursor_position_for(
+        &self,
+        obj: &ExId,
+        cursor: &Cursor,
+        clock: Option<Clock>,
+    ) -> Result<usize, AutomergeError> {
+        match cursor {
+            Cursor::Start => Ok(0),
+            Cursor::End => Ok(self.length_for(obj, clock)),
+            Cursor::Op(op) => {
+                let obj_meta = self.exid_to_obj(obj)?;
+
+                let Some(seq_type) = obj_meta.typ.as_sequence_type() else {
+                    return Err(AutomergeError::InvalidCursor(cursor.clone()));
+                };
+
+                let opid = self.op_cursor_to_opid(op, clock.as_ref())?;
+
+                let found = self
+                    .ops
+                    .seek_list_opid(&obj_meta.id, opid, seq_type, clock.as_ref())
+                    .ok_or_else(|| AutomergeError::InvalidCursor(cursor.clone()))?;
+
+                match op.move_cursor {
+                    // `MoveCursor::After` mimics the original behavior of cursors.
+                    //
+                    // The original behavior was to just return the `FoundOpId::index` found by
+                    // `OpSetInternal::seek_list_opid()`.
+                    //
+                    // This index always corresponds to the:
+                    // - index of the item itself (if it's visible at `clock`)
+                    // - next index of visible item that **was also visible at the time of cursor creation**
+                    //   (if the item is not visible at `clock`).
+                    // - or `sequence.length` if none of the next items are visible at `clock`.
+                    MoveCursor::After => Ok(found.index),
+                    MoveCursor::Before => {
+                        // `MoveCursor::Before` behaves like `MoveCursor::After` but in the opposite direction:
+                        //
+                        // - if the item is visible at `clock`, just return its index
+                        // - if the item isn't visible at `clock`, find the index of the **previous** item
+                        //   that's visible at `clock` that was also visible at the time of cursor creation.
+                        // - if none of the previous items are visible (or the index of the original item is 0),
+                        //   our index is `0`.
+                        if found.visible || found.index == 0 {
+                            Ok(found.index)
+                        } else {
+                            // FIXME: this should probably be an `OpSet` query
+                            // also this implementation is likely very inefficient
+
+                            // current implementation walks upwards through `key` of op pointed to by cursor
+                            // and checks if `key` is visible by using `seek_list_opid()`.
+
+                            let mut key = found
+                                .op.key.elemid()
+                                .expect("failed to retrieve initial cursor op key for MoveCursor::Before")
+                                .0;
+
+                            loop {
+                                let f = self.ops.seek_list_opid(
+                                    &obj_meta.id,
+                                    key,
+                                    seq_type,
+                                    clock.as_ref(),
+                                );
+
+                                match f {
+                                    Some(f) => {
+                                        if f.visible {
+                                            return Ok(f.index);
+                                        }
+
+                                        key = f
+                                            .op
+                                            .key
+                                            .elemid()
+                                            .expect(
+                                                "failed to retrieve op key in MoveCursor::Before",
+                                            )
+                                            .0;
+                                    }
+                                    // reached when we've gone before the beginning of the sequence
+                                    None => break Ok(0),
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    pub(crate) fn marks_for(
+        &self,
+        obj: &ExId,
+        clock: Option<Clock>,
+    ) -> Result<Vec<Mark>, AutomergeError> {
+        self.calculate_marks(obj, clock)
+    }
+
+    pub(crate) fn get_for(
+        &self,
+        obj: &ExId,
+        prop: Prop,
+        clock: Option<Clock>,
+    ) -> Result<Option<(Value<'_>, ExId)>, AutomergeError> {
+        let obj = self.exid_to_obj(obj)?;
+        let op = match (obj.typ, prop) {
+            (ObjType::Map | ObjType::Table, Prop::Map(key)) => self
+                .ops
+                .seek_ops_by_map_key(&obj.id, &key, clock.as_ref())
+                .ops
+                .into_iter()
+                .next_back()
+                .map(|op| op.tagged_value(self.ops())),
+            (ObjType::List | ObjType::Text, Prop::Seq(i)) => {
+                let seq_type = obj
+                    .typ
+                    .as_sequence_type()
+                    .expect("list and text must have a sequence type");
+                self.ops
+                    .seek_ops_by_index(&obj.id, i, seq_type, clock.as_ref())
+                    .ops
+                    .into_iter()
+                    .next_back()
+                    .map(|op| op.tagged_value(self.ops()))
+            }
+            _ => return Err(AutomergeError::InvalidOp(obj.typ)),
+        };
+        Ok(op)
+    }
+
+    pub(crate) fn get_all_for<O: AsRef<ExId>, P: Into<Prop>>(
+        &self,
+        obj: O,
+        prop: P,
+        clock: Option<Clock>,
+    ) -> Result<Vec<(Value<'_>, ExId)>, AutomergeError> {
+        let prop = prop.into();
+        let obj = self.exid_to_obj(obj.as_ref())?;
+        let values = match (obj.typ, prop) {
+            (ObjType::Map | ObjType::Table, Prop::Map(key)) => self
+                .ops
+                .seek_ops_by_map_key(&obj.id, &key, clock.as_ref())
+                .ops
+                .into_iter()
+                .map(|op| op.tagged_value(self.ops()))
+                .collect::<Vec<_>>(),
+            (ObjType::List | ObjType::Text, Prop::Seq(i)) => {
+                let seq_type = obj
+                    .typ
+                    .as_sequence_type()
+                    .expect("list and text must have a sequence type");
+                self.ops
+                    .seek_ops_by_index(&obj.id, i, seq_type, clock.as_ref())
+                    .ops
+                    .into_iter()
+                    .map(|op| op.tagged_value(self.ops()))
+                    .collect::<Vec<_>>()
+            }
+            _ => return Err(AutomergeError::InvalidOp(obj.typ)),
+        };
+        // this is a test to make sure opid and exid are always sorting the same way
+        assert_eq!(
+            values.iter().map(|v| &v.1).collect::<Vec<_>>(),
+            values.iter().map(|v| &v.1).sorted().collect::<Vec<_>>()
+        );
+        Ok(values)
+    }
+
+    pub(crate) fn get_marks_for<O: AsRef<ExId>>(
+        &self,
+        obj: O,
+        index: usize,
+        clock: Option<Clock>,
+    ) -> Result<MarkSet, AutomergeError> {
+        let obj = self.exid_to_obj(obj.as_ref())?;
+        let mut iter = self
+            .ops
+            .iter_obj(&obj.id)
+            .visible_slow(clock)
+            .top_ops()
+            .marks();
+        iter.nth(index);
+        match iter.get_marks() {
+            Some(arc) => Ok(arc.as_ref().clone().without_unmarks()),
+            None => Ok(MarkSet::default()),
+        }
+    }
+
+    fn convert_scalar_strings_to_text(&mut self) -> Result<(), AutomergeError> {
+        struct Conversion {
+            obj_id: ExId,
+            prop: Prop,
+            text: smol_str::SmolStr,
+        }
+        let mut to_convert = Vec::new();
+        for (obj, ops) in self.ops.iter_objs() {
+            match obj.typ {
+                ObjType::Map | ObjType::List => {
+                    for op in ops.visible_slow(None) {
+                        //if !op.visible() {
+                        //    continue;
+                        //}
+                        if let OpType::Put(ScalarValue::Str(s)) = op.op_type() {
+                            let prop = match op.key {
+                                KeyRef::Map(prop) => Prop::Map(prop.into()),
+                                KeyRef::Seq(_) => {
+                                    let Some(found) = self.ops.seek_list_opid(
+                                        &obj.id,
+                                        op.id,
+                                        SequenceType::List,
+                                        None,
+                                    ) else {
+                                        continue;
+                                    };
+                                    Prop::Seq(found.index)
+                                }
+                            };
+                            to_convert.push(Conversion {
+                                obj_id: self.ops.id_to_exid(obj.id.0),
+                                prop,
+                                text: smol_str::SmolStr::from(s),
+                            })
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        if !to_convert.is_empty() {
+            let mut tx = self.transaction();
+            for Conversion { obj_id, prop, text } in to_convert {
+                let text_id = tx.put_object(obj_id, prop, ObjType::Text)?;
+                tx.splice_text(&text_id, 0, 0, &text)?;
+            }
+            tx.commit();
+        }
+
+        Ok(())
+    }
+
+    /// Whether the peer represented by `other` has all the changes we have
+    pub fn has_our_changes(&self, other: &crate::sync::State) -> bool {
+        other.shared_heads == self.get_heads()
+    }
+
+    pub(crate) fn has_change(&self, head: &ChangeHash) -> bool {
+        self.change_graph.has_change(head)
+    }
+
+    pub fn text_encoding(&self) -> TextEncoding {
+        self.ops.text_encoding
+    }
+}
+
+impl ReadDoc for Automerge {
+    fn parents<O: AsRef<ExId>>(&self, obj: O) -> Result<Parents<'_>, AutomergeError> {
+        self.parents_for(obj.as_ref(), None)
+    }
+
+    fn parents_at<O: AsRef<ExId>>(
+        &self,
+        obj: O,
+        heads: &[ChangeHash],
+    ) -> Result<Parents<'_>, AutomergeError> {
+        let clock = self.clock_at(heads);
+        self.parents_for(obj.as_ref(), Some(clock))
+    }
+
+    fn keys<O: AsRef<ExId>>(&self, obj: O) -> Keys<'_> {
+        self.keys_for(obj.as_ref(), None)
+    }
+
+    fn keys_at<O: AsRef<ExId>>(&self, obj: O, heads: &[ChangeHash]) -> Keys<'_> {
+        let clock = self.clock_at(heads);
+        self.keys_for(obj.as_ref(), Some(clock))
+    }
+
+    fn iter_at<O: AsRef<ExId>>(&self, obj: O, heads: Option<&[ChangeHash]>) -> DocIter<'_> {
+        //let obj = self.exid_to_obj(obj.as_ref()).unwrap();
+        let clock = heads.map(|heads| self.clock_at(heads));
+        self.iter_for(obj.as_ref(), clock)
+    }
+
+    fn map_range<'a, O: AsRef<ExId>, R: RangeBounds<String> + 'a>(
+        &'a self,
+        obj: O,
+        range: R,
+    ) -> MapRange<'a> {
+        self.map_range_for(obj.as_ref(), range, None)
+    }
+
+    fn map_range_at<'a, O: AsRef<ExId>, R: RangeBounds<String> + 'a>(
+        &'a self,
+        obj: O,
+        range: R,
+        heads: &[ChangeHash],
+    ) -> MapRange<'a> {
+        let clock = self.clock_at(heads);
+        self.map_range_for(obj.as_ref(), range, Some(clock))
+    }
+
+    fn list_range<O: AsRef<ExId>, R: RangeBounds<usize>>(&self, obj: O, range: R) -> ListRange<'_> {
+        self.list_range_for(obj.as_ref(), range, None)
+    }
+
+    fn list_range_at<O: AsRef<ExId>, R: RangeBounds<usize>>(
+        &self,
+        obj: O,
+        range: R,
+        heads: &[ChangeHash],
+    ) -> ListRange<'_> {
+        let clock = self.clock_at(heads);
+        self.list_range_for(obj.as_ref(), range, Some(clock))
+    }
+
+    fn values<O: AsRef<ExId>>(&self, obj: O) -> Values<'_> {
+        self.values_for(obj.as_ref(), None)
+    }
+
+    fn values_at<O: AsRef<ExId>>(&self, obj: O, heads: &[ChangeHash]) -> Values<'_> {
+        let clock = self.clock_at(heads);
+        self.values_for(obj.as_ref(), Some(clock))
+    }
+
+    fn length<O: AsRef<ExId>>(&self, obj: O) -> usize {
+        self.length_for(obj.as_ref(), None)
+    }
+
+    fn length_at<O: AsRef<ExId>>(&self, obj: O, heads: &[ChangeHash]) -> usize {
+        let clock = self.clock_at(heads);
+        self.length_for(obj.as_ref(), Some(clock))
+    }
+
+    fn text<O: AsRef<ExId>>(&self, obj: O) -> Result<String, AutomergeError> {
+        self.text_for(obj.as_ref(), None)
+    }
+
+    fn spans<O: AsRef<ExId>>(&self, obj: O) -> Result<Spans<'_>, AutomergeError> {
+        self.spans_for(obj.as_ref(), None)
+    }
+
+    fn spans_at<O: AsRef<ExId>>(
+        &self,
+        obj: O,
+        heads: &[ChangeHash],
+    ) -> Result<Spans<'_>, AutomergeError> {
+        let clock = self.clock_at(heads);
+        self.spans_for(obj.as_ref(), Some(clock))
+    }
+
+    fn get_cursor<O: AsRef<ExId>, I: Into<CursorPosition>>(
+        &self,
+        obj: O,
+        position: I,
+        at: Option<&[ChangeHash]>,
+    ) -> Result<Cursor, AutomergeError> {
+        let clock = at.map(|heads| self.clock_at(heads));
+        self.get_cursor_for(obj.as_ref(), position.into(), clock, MoveCursor::After)
+    }
+
+    fn get_cursor_moving<O: AsRef<ExId>, I: Into<CursorPosition>>(
+        &self,
+        obj: O,
+        position: I,
+        at: Option<&[ChangeHash]>,
+        move_cursor: MoveCursor,
+    ) -> Result<Cursor, AutomergeError> {
+        let clock = at.map(|heads| self.clock_at(heads));
+        self.get_cursor_for(obj.as_ref(), position.into(), clock, move_cursor)
+    }
+
+    fn get_cursor_position<O: AsRef<ExId>>(
+        &self,
+        obj: O,
+        cursor: &Cursor,
+        at: Option<&[ChangeHash]>,
+    ) -> Result<usize, AutomergeError> {
+        let clock = at.map(|heads| self.clock_at(heads));
+        self.get_cursor_position_for(obj.as_ref(), cursor, clock)
+    }
+
+    fn text_at<O: AsRef<ExId>>(
+        &self,
+        obj: O,
+        heads: &[ChangeHash],
+    ) -> Result<String, AutomergeError> {
+        let clock = self.clock_at(heads);
+        self.text_for(obj.as_ref(), Some(clock))
+    }
+
+    fn marks<O: AsRef<ExId>>(&self, obj: O) -> Result<Vec<Mark>, AutomergeError> {
+        self.marks_for(obj.as_ref(), None)
+    }
+
+    fn marks_at<O: AsRef<ExId>>(
+        &self,
+        obj: O,
+        heads: &[ChangeHash],
+    ) -> Result<Vec<Mark>, AutomergeError> {
+        let clock = self.clock_at(heads);
+        self.marks_for(obj.as_ref(), Some(clock))
+    }
+
+    fn hydrate<O: AsRef<ExId>>(
+        &self,
+        obj: O,
+        heads: Option<&[ChangeHash]>,
+    ) -> Result<hydrate::Value, AutomergeError> {
+        let obj = self.exid_to_obj(obj.as_ref())?;
+        let clock = heads.map(|h| self.clock_at(h));
+        Ok(match obj.typ {
+            ObjType::List => self.hydrate_list(&obj.id, clock.as_ref()),
+            ObjType::Text => self.hydrate_text(&obj.id, clock.as_ref()),
+            _ => self.hydrate_map(&obj.id, clock.as_ref()),
+        })
+    }
+
+    fn get_marks<O: AsRef<ExId>>(
+        &self,
+        obj: O,
+        index: usize,
+        heads: Option<&[ChangeHash]>,
+    ) -> Result<MarkSet, AutomergeError> {
+        let clock = heads.map(|h| self.clock_at(h));
+        self.get_marks_for(obj.as_ref(), index, clock)
+    }
+
+    fn get<O: AsRef<ExId>, P: Into<Prop>>(
+        &self,
+        obj: O,
+        prop: P,
+    ) -> Result<Option<(Value<'_>, ExId)>, AutomergeError> {
+        self.get_for(obj.as_ref(), prop.into(), None)
+    }
+
+    fn get_at<O: AsRef<ExId>, P: Into<Prop>>(
+        &self,
+        obj: O,
+        prop: P,
+        heads: &[ChangeHash],
+    ) -> Result<Option<(Value<'_>, ExId)>, AutomergeError> {
+        let clock = Some(self.clock_at(heads));
+        self.get_for(obj.as_ref(), prop.into(), clock)
+    }
+
+    fn get_all<O: AsRef<ExId>, P: Into<Prop>>(
+        &self,
+        obj: O,
+        prop: P,
+    ) -> Result<Vec<(Value<'_>, ExId)>, AutomergeError> {
+        self.get_all_for(obj.as_ref(), prop.into(), None)
+    }
+
+    fn get_all_at<O: AsRef<ExId>, P: Into<Prop>>(
+        &self,
+        obj: O,
+        prop: P,
+        heads: &[ChangeHash],
+    ) -> Result<Vec<(Value<'_>, ExId)>, AutomergeError> {
+        let clock = Some(self.clock_at(heads));
+        self.get_all_for(obj.as_ref(), prop.into(), clock)
+    }
+
+    fn object_type<O: AsRef<ExId>>(&self, obj: O) -> Result<ObjType, AutomergeError> {
+        let obj = obj.as_ref();
+        let opid = self.exid_to_opid(obj)?;
+        let typ = self.ops.object_type(&ObjId(opid));
+        typ.ok_or_else(|| AutomergeError::InvalidObjId(obj.to_string()))
+    }
+
+    #[inline(never)]
+    fn get_missing_deps(&self, heads: &[ChangeHash]) -> Vec<ChangeHash> {
+        let mut missing = HashSet::new();
+
+        for head in self.queue.iter().flat_map(|change| change.deps()) {
+            if !self.has_change(head) {
+                missing.insert(head);
+            }
+        }
+
+        for head in heads {
+            if !self.has_change(head) {
+                missing.insert(head);
+            }
+        }
+
+        let mut missing = missing
+            .into_iter()
+            .filter(|hash| !self.queue.has_hash(hash))
+            .copied()
+            .collect::<Vec<_>>();
+        missing.sort();
+        missing
+    }
+
+    fn get_change_by_hash(&self, hash: &ChangeHash) -> Option<Change> {
+        ChangeCollector::for_hashes(&self.ops, &self.change_graph, [*hash])
+            .ok()?
+            .pop()
+    }
+
+    fn stats(&self) -> crate::read::Stats {
+        let num_changes = self.change_graph.len() as u64;
+        let num_ops = self.ops.len() as u64;
+        let num_actors = self.ops.actors.len() as u64;
+        let cargo_package_name = env!("CARGO_PKG_NAME");
+        let cargo_package_version = env!("CARGO_PKG_VERSION");
+        let rustc_version = env!("CARGO_PKG_RUST_VERSION");
+        crate::read::Stats {
+            num_changes,
+            num_ops,
+            num_actors,
+            cargo_package_name,
+            cargo_package_version,
+            rustc_version,
+        }
+    }
+
+    fn text_encoding(&self) -> TextEncoding {
+        self.ops.text_encoding
+    }
+}
+
+impl Default for Automerge {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Options to pass to [`Automerge::save_with_options()`] and [`crate::AutoCommit::save_with_options()`]
+#[derive(Debug)]
+pub struct SaveOptions {
+    /// Whether to apply DEFLATE compression to the RLE encoded columns in the document
+    pub deflate: bool,
+    /// Whether to save changes which we do not have the dependencies for
+    pub retain_orphans: bool,
+}
+
+impl SaveOptions {
+    fn compress(&self) -> CompressConfig {
+        if self.deflate {
+            CompressConfig::Threshold(change::DEFLATE_MIN_SIZE)
+        } else {
+            CompressConfig::None
+        }
+    }
+}
+
+impl std::default::Default for SaveOptions {
+    fn default() -> Self {
+        Self {
+            deflate: true,
+            retain_orphans: true,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Isolation {
+    actor_index: usize,
+    seq: u64,
+    clock: Clock,
+}