yrby 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc870d86089bc5373cbac29455b1b7818c4a710b4ca1c8c12eeee2939faa8758
-  data.tar.gz: 66c41fad450c8e71a23a166bc1f0e6a83def6bdcc94c79724bb63d7691a28f16
+  metadata.gz: b872650c1daa2696dc90e8f209b3dba702d7bb796f5af330550343a7e7397e51
+  data.tar.gz: 9070c8d98f2323f80ea60e79d59c307a47486465093c384182252136faab69d0
 SHA512:
-  metadata.gz: 0725a1a0966f516316041b3d46edcd946783802691d568ed139549fbc120515b809ca368784f23f522bad7e0a4f24abb46951985ff0935627b1733d2e3b47cd3
-  data.tar.gz: 6fcf5914510b36d10fe3bf344725cb151f945c57df95b692cdd5a4344ceeba2e81ed6455a0ec3b4071ae5a9c569de4bc0ae3bea9aa6b40b399594c296fb71a0b
+  metadata.gz: b3d3d9536640200254a1b66bba0e7a3090215ba8d25b614c9e7908d4ef3cec02f0a31115608c4f9b108636735a1eff42acd39b44519b6b03e0d362b66df73b29
+  data.tar.gz: f77e3b5693746f19a4707c5f2a3d31d2b45d83122fc6d5faf362c4a11b2b52b4f7b712f0433aee38bf5b8fee352d0bd9539012b5e74bc43fd81f6d73616a4974

data/CHANGELOG.md

@@ -6,6 +6,33 @@ to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.9.1] - 2026-11-08
+
+### Changed
+
+- yrby builds against yrs 0.28.1. An insert into a text no longer recounts
+  the UTF-16 length of each string before it, so appending to a long text
+  costs about the same at any length: 80k one-character appends took 2.5 s
+  and now take 48 ms.
+
+### Experimental
+
+- `Y::Doc#edit` returns the document's own writes and never a peer's. The
+  document keeps the update of every local transaction until an edit returns
+  it, merged into one, so a write made outside an edit, from another thread
+  or fiber, or in a block that raised comes with the next edit. Before this,
+  the edit returned everything the document gained while the block ran, so
+  an update applied from a peer meanwhile was sent again as the edit's own,
+  and a caller had to lock the document to keep them apart. Each edit takes
+  everything unsent at once, so the updates edits return have no gaps
+  between them. A peer's update doesn't wait for an edit.
+
+- `Y::Map#set_text(key, content = "")` stores a new `Y.Text` at a key and
+  returns its live `Y::Text`. `Y::Array#push_text(content = "")` and
+  `#insert_text(index, content = "")` do the same in a list. Before this,
+  Ruby could edit a nested `Y.Text` a browser made but couldn't make one,
+  so a server couldn't set up a form whose fields merge typing.
+
 ## yrby-client 0.7.1 - 2026-11-03
 
 ### Fixed

data/Cargo.lock

@@ -44,16 +44,14 @@ dependencies = [
 
 [[package]]
 name = "bindgen"
-version = "0.69.5"
+version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271383c67ccabffb7381723dea0672a673f292304fcb45c01cc648c7a8d58088"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
 dependencies = [
  "bitflags",
  "cexpr",
  "clang-sys",
  "itertools",
- "lazy_static",
- "lazycell",
  "proc-macro2",
  "quote",
  "regex",
@@ -221,12 +219,6 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
-[[package]]
-name = "lazycell"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
-
 [[package]]
 name = "lexical-yjs-html"
 version = "0.2.1"
@@ -366,18 +358,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.124"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c85c4188462601e2aa1469def389c17228566f82ea72f137ed096f21591bc489"
+checksum = "02faf625bb10ba893e3ae620f19c9fb1b5f8fcae0fe4eb86bb3f2230fad75edb"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.124"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "568068db4102230882e6d4ae8de6632e224ca75fe5970f6e026a04e91ed635d3"
+checksum = "05be6f9c86fe5482808162826f6c047d093b3670582296c770de1d94f8066694"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -461,9 +453,9 @@ checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "rustc-hash"
-version = "1.1.0"
+version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
 
 [[package]]
 name = "rustversion"
@@ -549,9 +541,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.15.1"
+version = "1.16.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+checksum = "d0d5d4b1981b8bbbb7aed204cae5726d683d5d6ac7e74ec54122ea28f315e7c8"
 
 [[package]]
 name = "syn"
@@ -672,9 +664,9 @@ dependencies = [
 
 [[package]]
 name = "yrs"
-version = "0.28.0"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52c70dc8beca8666c77612a96889106ca3cd65318609721f464624ff79685da9"
+checksum = "9f7716b4846f9fab489af2ed7ab31c4554f5fe6965ede2392b9cdfed0e5087ff"
 dependencies = [
  "arc-swap",
  "async-lock",

data/ext/yrby/Cargo.toml

@@ -12,7 +12,7 @@ crate-type = ["cdylib"]
 [dependencies]
 magnus = "0.8"
 rb-sys = "0.9"
-yrs = { version = "0.28", features = ["sync"] }
+yrs = { version = "0.28.1", features = ["sync"] }
 serde_json = "1.0"
 yjs-html-core = { path = "crates/html-core" }
 lexical-yjs-html = { path = "crates/lexical-html" }

data/ext/yrby/src/array.rs

@@ -14,14 +14,14 @@
 
 use magnus::{prelude::*, typed_data::Obj, Error, Ruby, Value};
 use yrs::branch::BranchID;
-use yrs::{Any, Array, ArrayRef, Doc, Transact};
+use yrs::{Any, Array, ArrayRef, Doc, TextPrelim, Transact};
 
 use crate::map::RbMap;
 use crate::nogvl;
 use crate::read::out_to_any;
 use crate::shared::{
-    any_to_ruby, element_index, guarded, identity, insert_index, resolve, ruby_to_invalue, to_in,
-    Child, ORIGIN,
+    any_to_ruby, element_index, identity, insert_index, resolve, ruby_to_invalue, to_in, write,
+    Child,
 };
 use crate::text::RbText;
 
@@ -162,29 +162,39 @@ impl RbArray {
         let ruby = Ruby::get().unwrap();
         let iv = ruby_to_invalue(&ruby, value)?;
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let a = resolve::<ArrayRef, _>(&txn, id).ok_or("array no longer exists")?;
-            let at = insert_index(index, a.len(&txn));
-            a.insert(&mut txn, at, to_in(iv));
+        write(doc, move |txn| {
+            let a = resolve::<ArrayRef, _>(txn, id).ok_or("array no longer exists")?;
+            let at = insert_index(index, a.len(txn));
+            a.insert(txn, at, to_in(iv));
             Ok(())
         })
     }
 
+    /// Insert a new `Y.Text` holding `content` at `index` (the same index
+    /// rules as `insert`) and return a live handle to it.
+    fn insert_text(&self, index: i64, content: String) -> Result<RbText, Error> {
+        let (doc, id) = (&self.doc, &self.id);
+        let text = write(doc, move |txn| {
+            let a = resolve::<ArrayRef, _>(txn, id).ok_or("array no longer exists")?;
+            let at = insert_index(index, a.len(txn));
+            Ok(identity(&a.insert(txn, at, TextPrelim::new(content))))
+        })?;
+        Ok(RbText::new(self.doc.clone(), text))
+    }
+
     /// Remove the element at `index`, returning its previous snapshot value.
     fn delete_at(&self, index: i64) -> Result<Value, Error> {
         let (doc, id) = (&self.doc, &self.id);
-        let prev: Option<Any> = guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let Some(a) = resolve::<ArrayRef, _>(&txn, id) else {
+        let prev: Option<Any> = write(doc, move |txn| {
+            let Some(a) = resolve::<ArrayRef, _>(txn, id) else {
                 return Ok(None);
             };
-            let Some(i) = element_index(index, a.len(&txn)) else {
+            let Some(i) = element_index(index, a.len(txn)) else {
                 return Ok(None);
             };
             // Convert before removing: a removed shared ref would dangle.
-            let prev = a.get(&txn, i).map(|v| out_to_any(&txn, &v));
-            a.remove(&mut txn, i);
+            let prev = a.get(txn, i).map(|v| out_to_any(txn, &v));
+            a.remove(txn, i);
             Ok(prev)
         })?;
         let ruby = Ruby::get().unwrap();
@@ -196,12 +206,11 @@ impl RbArray {
 
     fn clear(&self) -> Result<(), Error> {
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            if let Some(a) = resolve::<ArrayRef, _>(&txn, id) {
-                let len = a.len(&txn);
+        write(doc, move |txn| {
+            if let Some(a) = resolve::<ArrayRef, _>(txn, id) {
+                let len = a.len(txn);
                 if len > 0 {
-                    a.remove_range(&mut txn, 0, len);
+                    a.remove_range(txn, 0, len);
                 }
             }
             Ok(())
@@ -215,12 +224,11 @@ impl RbArray {
         let ruby = Ruby::get().unwrap();
         let iv = ruby_to_invalue(&ruby, value)?;
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let a = resolve::<ArrayRef, _>(&txn, id).ok_or("array no longer exists")?;
-            let i = element_index(index, a.len(&txn)).ok_or("index out of range")?;
-            a.remove(&mut txn, i);
-            a.insert(&mut txn, i, to_in(iv));
+        write(doc, move |txn| {
+            let a = resolve::<ArrayRef, _>(txn, id).ok_or("array no longer exists")?;
+            let i = element_index(index, a.len(txn)).ok_or("index out of range")?;
+            a.remove(txn, i);
+            a.insert(txn, i, to_in(iv));
             Ok(())
         })?;
         Ok(value)
@@ -246,6 +254,10 @@ pub fn define(ruby: &Ruby, module: magnus::RModule) -> Result<(), Error> {
     class.define_method("push", magnus::method!(RbArray::push, 1))?;
     class.define_method("<<", magnus::method!(RbArray::push, 1))?;
     class.define_method("insert", magnus::method!(RbArray::insert, 2))?;
+    class.define_method(
+        "native_insert_text",
+        magnus::method!(RbArray::insert_text, 2),
+    )?;
     class.define_method("delete_at", magnus::method!(RbArray::delete_at, 1))?;
     class.define_method("clear", magnus::method!(RbArray::clear, 0))?;
     class.define_method("size", magnus::method!(RbArray::size, 0))?;

data/ext/yrby/src/lib.rs

@@ -33,7 +33,49 @@ pub(crate) use yjs_html_core as render_rules;
 /// interior-mutability wrapper (RefCell and friends): every method opens and
 /// closes its transaction within a single call.
 #[magnus::wrap(class = "Y::Doc", free_immediately, size)]
-struct RbDoc(Doc);
+struct RbDoc(Doc, Unsent);
+
+/// The updates of this document's own transactions that no `Doc#edit` has
+/// returned yet. Every transaction but a peer's lands here when it commits,
+/// after yrs is done changing the document, whichever thread or fiber made
+/// it and whether or not an edit was running. So no local write is left out.
+/// They're merged only when an edit takes them, so until then the document
+/// holds the bytes of every local write.
+type Unsent = std::sync::Arc<std::sync::Mutex<Vec<Vec<u8>>>>;
+
+/// `Unsent`'s list. A push or a take holds it only briefly, so taking it
+/// with the GVL held never waits long.
+fn lock(unsent: &Unsent) -> std::sync::MutexGuard<'_, Vec<Vec<u8>>> {
+    unsent
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner())
+}
+
+/// How many updates `merge_unsent` merges at once.
+const MERGE_FAN_IN: usize = 16;
+
+/// The updates merged into one, a few at a time and then the results again.
+/// One merge of them all costs time quadratic in how many there are.
+fn merge_unsent(updates: &[Vec<u8>]) -> Result<Vec<u8>, String> {
+    let mut level: Vec<Vec<u8>> = match updates {
+        [update] => return Ok(update.clone()),
+        _ => merge_chunks(updates)?,
+    };
+    while level.len() > 1 {
+        level = merge_chunks(&level)?;
+    }
+    Ok(level.pop().unwrap_or_default())
+}
+
+fn merge_chunks(updates: &[Vec<u8>]) -> Result<Vec<Vec<u8>>, String> {
+    updates
+        .chunks(MERGE_FAN_IN)
+        .map(|chunk| match chunk {
+            [update] => Ok(update.clone()),
+            _ => yrs::merge_updates_v1(chunk).map_err(|e| e.to_string()),
+        })
+        .collect()
+}
 
 /// Compile-time proof that the wrapped Doc is thread-safe. If a future yrs
 /// upgrade makes Doc lose Send/Sync, this fails the build instead of silently
@@ -171,7 +213,17 @@ impl RbDoc {
             yrs::Options::with_client_id(yrs::block::ClientID::new(client_id))
         };
         options.offset_kind = yrs::OffsetKind::Utf16;
-        Ok(RbDoc(Doc::with_options(options)))
+        let doc = Doc::with_options(options);
+        let unsent = Unsent::default();
+        let sink = unsent.clone();
+        doc.observe_update_v1("yrby-unsent", move |txn, event| {
+            if shared::is_remote(txn.origin()) {
+                return;
+            }
+            lock(&sink).push(event.update.clone());
+        })
+        .map_err(|e| yrb_error(e.to_string()))?;
+        Ok(RbDoc(doc, unsent))
     }
 
     /// The id this document writes its own edits under. Presence for the same
@@ -312,7 +364,7 @@ impl RbDoc {
             // One transaction from the snapshot of the blocks to the commit,
             // under an origin of its own: another write can't change the
             // blocks in between, and its events don't count.
-            let key = shared::observer_key();
+            let key = shared::remote_key();
             let mut txn = doc.transact_mut_with(key.clone());
             let fragment = yrs::WriteTxn::get_or_insert_xml_fragment(&mut txn, root.as_str());
             let branch: &yrs::branch::Branch = fragment.as_ref();
@@ -398,30 +450,31 @@ impl RbDoc {
         Ok(id.map(|id| xml_text::handle(&self.0, id, root)))
     }
 
-    /// The document's state vector and delete set, encoded: where `Doc#edit`
-    /// starts.
-    fn snapshot(&self) -> Result<RString, Error> {
-        let doc = &self.0;
-        let snapshot = nogvl(move || doc.transact().snapshot().encode_v1())?;
-        Ok(binary_string(&snapshot))
+    /// Every update in `Unsent`, merged into one, or nil for none. Taking them
+    /// empties it, and writes made meanwhile wait for the next take. The
+    /// merge runs without the GVL. If it fails, or an interrupt comes back
+    /// with it (a signal trap can raise even where `Thread.handle_interrupt`
+    /// masks), the updates go back ahead of those writes.
+    fn take_unsent(&self) -> Result<Option<RString>, Error> {
+        let taken = std::mem::take(&mut *lock(&self.1));
+        if taken.is_empty() {
+            return Ok(None);
+        }
+        match nogvl(|| merge_unsent(&taken)).and_then(|merged| merged.map_err(yrb_error)) {
+            Ok(merged) => Ok(Some(binary_string(&merged))),
+            Err(error) => {
+                let mut unsent = lock(&self.1);
+                let since = std::mem::replace(&mut *unsent, taken);
+                unsent.extend(since);
+                Err(error)
+            }
+        }
     }
 
-    /// The update holding what the document gained since `snapshot`, or nil
-    /// when it is unchanged: what `Doc#edit` returns.
-    fn update_since(&self, snapshot: RString) -> Result<Option<RString>, Error> {
-        let bytes = copy_bytes(snapshot);
-        let doc = &self.0;
-        let update = nogvl(move || -> Result<Option<Vec<u8>>, String> {
-            let before = yrs::Snapshot::decode_v1(&bytes).map_err(|e| e.to_string())?;
-            let txn = doc.transact();
-            let now = txn.snapshot();
-            if now == before {
-                return Ok(None);
-            }
-            Ok(Some(changes_since(&txn, &before, &now)))
-        })?
-        .map_err(yrb_error)?;
-        Ok(update.map(|update| binary_string(&update)))
+    /// Put a taken update back ahead of anything written since, for the next
+    /// take to return again.
+    fn keep_unsent(&self, update: RString) {
+        lock(&self.1).insert(0, copy_bytes(update));
     }
 
     /// Encode state as update (optionally diffed against a state vector)
@@ -450,7 +503,7 @@ impl RbDoc {
         let doc = &self.0;
         nogvl(move || -> Result<(), String> {
             let update = yrs::Update::decode_v1(&update_bytes).map_err(|e| e.to_string())?;
-            let mut txn = doc.transact_mut();
+            let mut txn = doc.transact_mut_with(shared::REMOTE);
             txn.apply_update(update).map_err(|e| e.to_string())
         })?
         .map_err(yrb_error)
@@ -513,7 +566,7 @@ impl RbDoc {
                             // Apply the update
                             let update =
                                 yrs::Update::decode_v1(&update_bytes).map_err(|e| e.to_string())?;
-                            let mut txn = doc.transact_mut();
+                            let mut txn = doc.transact_mut_with(shared::REMOTE);
                             txn.apply_update(update).map_err(|e| e.to_string())?;
                             Ok((0, 1, Vec::new()))
                         }
@@ -521,7 +574,7 @@ impl RbDoc {
                             // Apply the update
                             let update =
                                 yrs::Update::decode_v1(&update_bytes).map_err(|e| e.to_string())?;
-                            let mut txn = doc.transact_mut();
+                            let mut txn = doc.transact_mut_with(shared::REMOTE);
                             txn.apply_update(update).map_err(|e| e.to_string())?;
                             Ok((0, 2, Vec::new()))
                         }
@@ -805,27 +858,6 @@ fn update_from_message(data: RString) -> Result<Option<RString>, Error> {
 // Module Initialization
 // ============================================================================
 
-/// The blocks added since `before`, and the deletions made since it.
-///
-/// An update since a state vector carries the whole delete set, every
-/// deletion the document has ever had, so a chunk streamed into a long-lived
-/// document would grow with its history. A v1 update is its blocks followed
-/// by its delete set, so this swaps that delete set for only the new
-/// deletions. If the bytes ever don't end with the delete set as expected, it
-/// keeps the whole update, which is bigger but still right.
-fn changes_since<T: ReadTxn>(txn: &T, before: &yrs::Snapshot, now: &yrs::Snapshot) -> Vec<u8> {
-    let full = txn.encode_state_as_update_v1(&before.state_map);
-    let all = now.delete_set.encode_v1();
-    match full.strip_suffix(all.as_slice()) {
-        Some(blocks) => {
-            let mut update = blocks.to_vec();
-            update.extend(now.delete_set.diff(&before.delete_set).encode_v1());
-            update
-        }
-        None => full,
-    }
-}
-
 /// A root's children in order: the document index each starts at and
 /// whether it is an `XmlText` block. Ordinals count only those, as
 /// `xml_text(n)` does; a divider or an image is a child but not a block.
@@ -1182,8 +1214,8 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     )?;
     doc_class.define_private_method("native_block_at", method!(RbDoc::block_at, 2))?;
     doc_class.define_private_method("native_find", method!(RbDoc::find, 2))?;
-    doc_class.define_private_method("native_snapshot", method!(RbDoc::snapshot, 0))?;
-    doc_class.define_private_method("native_update_since", method!(RbDoc::update_since, 1))?;
+    doc_class.define_private_method("native_take_unsent", method!(RbDoc::take_unsent, 0))?;
+    doc_class.define_private_method("native_keep_unsent", method!(RbDoc::keep_unsent, 1))?;
     doc_class.define_method("root_names", method!(RbDoc::root_names, 0))?;
     doc_class.define_method("read_text", method!(RbDoc::read_text, 1))?;
     doc_class.define_method("read_xml", method!(RbDoc::read_xml, 1))?;
@@ -1360,6 +1392,69 @@ mod tests {
         );
     }
 
+    fn take(doc: &RbDoc) -> Option<RString> {
+        doc.take_unsent().unwrap()
+    }
+
+    #[ruby_test]
+    fn local_writes_wait_to_be_taken_and_a_peers_never_do() {
+        let doc = new_doc();
+        push(&doc, "t", "mine");
+        let mine = take(&doc).expect("a local write waits");
+        assert!(take(&doc).is_none(), "taking empties it");
+
+        let peer = new_doc();
+        peer.apply_update(mine).unwrap();
+        peer.handle_sync_message(wrap_update(mine)).unwrap();
+        peer.apply_update_changes(mine, "root".into()).unwrap();
+        assert!(take(&peer).is_none(), "applied updates are a peer's");
+        assert_eq!(peer.read_text("t".into()).unwrap().as_deref(), Some("mine"));
+    }
+
+    #[ruby_test]
+    fn unsent_updates_merge_into_one_that_carries_them_all() {
+        let doc = new_doc();
+        for n in 0..300 {
+            push(&doc, "t", &n.to_string());
+        }
+        let fresh = new_doc();
+        fresh.apply_update(take(&doc).unwrap()).unwrap();
+        assert_eq!(
+            fresh.read_text("t".into()).unwrap(),
+            doc.read_text("t".into()).unwrap()
+        );
+        assert!(!fresh.pending().unwrap());
+    }
+
+    #[ruby_test]
+    fn a_kept_update_is_taken_again_with_what_came_after() {
+        let doc = new_doc();
+        push(&doc, "t", "inner");
+        doc.keep_unsent(take(&doc).unwrap());
+        push(&doc, "t", " outer");
+        let fresh = new_doc();
+        fresh.apply_update(take(&doc).unwrap()).unwrap();
+        assert_eq!(
+            fresh.read_text("t".into()).unwrap().as_deref(),
+            Some("inner outer")
+        );
+    }
+
+    #[ruby_test]
+    fn unsent_updates_stay_when_the_merge_fails() {
+        let doc = new_doc();
+        push(&doc, "t", "kept");
+        doc.1.lock().unwrap().push(vec![255]);
+        assert!(doc.take_unsent().is_err());
+        doc.1.lock().unwrap().pop();
+        let fresh = new_doc();
+        fresh.apply_update(take(&doc).unwrap()).unwrap();
+        assert_eq!(
+            fresh.read_text("t".into()).unwrap().as_deref(),
+            Some("kept")
+        );
+    }
+
     #[ruby_test]
     fn a_malformed_update_raises() {
         assert!(new_doc()
@@ -1439,54 +1534,6 @@ mod tests {
         assert!(peer.handle_sync_message(binary_string(&[9, 9])).is_err());
     }
 
-    #[ruby_test]
-    fn an_update_since_a_snapshot_holds_what_changed_after_it() {
-        let doc = new_doc();
-        push(&doc, "t", "before");
-        let snapshot = doc.snapshot().unwrap();
-        assert!(doc.update_since(snapshot).unwrap().is_none());
-        push(&doc, "t", " after");
-        let peer = new_doc();
-        peer.apply_update(doc.update_since(snapshot).unwrap().unwrap())
-            .unwrap();
-        assert!(
-            peer.pending().unwrap(),
-            "the update leaves out what came before"
-        );
-        peer.apply_update(update(&doc)).unwrap();
-        assert_eq!(
-            peer.read_text("t".into()).unwrap().as_deref(),
-            Some("before after")
-        );
-    }
-
-    #[ruby_test]
-    fn an_update_since_a_snapshot_carries_only_new_deletions() {
-        let doc = new_doc();
-        let text = doc.0.get_or_insert_text("t");
-        for _ in 0..200 {
-            push(&doc, "t", "xy");
-            let mut txn = doc.0.transact_mut();
-            let at = text.len(&txn) - 1;
-            text.remove_range(&mut txn, at, 1);
-        }
-        let snapshot = doc.snapshot().unwrap();
-        let peer = new_doc();
-        peer.apply_update(update(&doc)).unwrap();
-        text.remove_range(&mut doc.0.transact_mut(), 0, 1);
-        let chunk = doc.update_since(snapshot).unwrap().unwrap();
-        assert!(
-            copy_bytes(chunk).len() < 40,
-            "{} bytes",
-            copy_bytes(chunk).len()
-        );
-        peer.apply_update(chunk).unwrap();
-        assert_eq!(
-            peer.read_text("t".into()).unwrap(),
-            doc.read_text("t".into()).unwrap()
-        );
-    }
-
     #[ruby_test]
     fn apply_update_changes_reports_the_blocks_an_update_touched() {
         let doc = lexical_doc(&["one", "two", "three"]);

data/ext/yrby/src/map.rs

@@ -11,13 +11,13 @@
 
 use magnus::{prelude::*, typed_data::Obj, Error, Ruby, Value};
 use yrs::branch::BranchID;
-use yrs::{Any, Doc, Map, MapRef, Transact};
+use yrs::{Any, Doc, Map, MapRef, TextPrelim, Transact};
 
 use crate::array::RbArray;
 use crate::nogvl;
 use crate::read::out_to_any;
 use crate::shared::{
-    any_to_ruby, guarded, identity, key_to_string, resolve, ruby_to_invalue, to_in, Child, ORIGIN,
+    any_to_ruby, identity, key_to_string, resolve, ruby_to_invalue, to_in, write, Child,
 };
 use crate::text::RbText;
 
@@ -168,27 +168,38 @@ impl RbMap {
         let key = key_to_string(key)?;
         let iv = ruby_to_invalue(&ruby, value)?;
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let m = resolve::<MapRef, _>(&txn, id).ok_or("map no longer exists")?;
-            m.insert(&mut txn, key, to_in(iv));
+        write(doc, move |txn| {
+            let m = resolve::<MapRef, _>(txn, id).ok_or("map no longer exists")?;
+            m.insert(txn, key, to_in(iv));
             Ok(())
         })?;
         Ok(value)
     }
 
+    /// Store a new `Y.Text` holding `content` at `key`, replacing what was
+    /// there, and return a live handle to it. A text in a map is what lets
+    /// two people type in the same field and both keep their edit.
+    fn set_text(&self, key: Value, content: String) -> Result<RbText, Error> {
+        let key = key_to_string(key)?;
+        let (doc, id) = (&self.doc, &self.id);
+        let text = write(doc, move |txn| {
+            let m = resolve::<MapRef, _>(txn, id).ok_or("map no longer exists")?;
+            Ok(identity(&m.insert(txn, key, TextPrelim::new(content))))
+        })?;
+        Ok(RbText::new(self.doc.clone(), text))
+    }
+
     /// Remove `key`, returning its previous snapshot value (or `nil`).
     fn delete(&self, key: Value) -> Result<Value, Error> {
         let key = key_to_string(key)?;
         let (doc, id) = (&self.doc, &self.id);
-        let prev: Option<Any> = guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let Some(m) = resolve::<MapRef, _>(&txn, id) else {
+        let prev: Option<Any> = write(doc, move |txn| {
+            let Some(m) = resolve::<MapRef, _>(txn, id) else {
                 return Ok(None);
             };
             // Convert before removing (a removed shared ref would dangle).
-            let prev = m.get(&txn, &key).map(|v| out_to_any(&txn, &v));
-            m.remove(&mut txn, &key);
+            let prev = m.get(txn, &key).map(|v| out_to_any(txn, &v));
+            m.remove(txn, &key);
             Ok(prev)
         })?;
         let ruby = Ruby::get().unwrap();
@@ -200,10 +211,9 @@ impl RbMap {
 
     fn clear(&self) -> Result<(), Error> {
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            if let Some(m) = resolve::<MapRef, _>(&txn, id) {
-                m.clear(&mut txn);
+        write(doc, move |txn| {
+            if let Some(m) = resolve::<MapRef, _>(txn, id) {
+                m.clear(txn);
             }
             Ok(())
         })
@@ -227,6 +237,7 @@ pub fn define(ruby: &Ruby, module: magnus::RModule) -> Result<(), Error> {
     class.define_method("get_text", magnus::method!(RbMap::get_text, 1))?;
     class.define_method("[]=", magnus::method!(RbMap::set, 2))?;
     class.define_method("set", magnus::method!(RbMap::set, 2))?;
+    class.define_method("native_set_text", magnus::method!(RbMap::set_text, 2))?;
     class.define_method("delete", magnus::method!(RbMap::delete, 1))?;
     class.define_method("clear", magnus::method!(RbMap::clear, 0))?;
     class.define_method("key?", magnus::method!(RbMap::has_key, 1))?;

data/ext/yrby/src/shared.rs

@@ -24,26 +24,34 @@ use magnus::{
 use yrs::branch::{Branch, BranchID, BranchPtr};
 use yrs::types::text::YChange;
 use yrs::{
-    Any, Hook, In, IndexScope, MapPrelim, Number, Out, ReadTxn, SharedRef, StickyIndex, Text, Xml,
-    XmlOut, XmlTextRef,
+    Any, Doc, Hook, In, IndexScope, MapPrelim, Number, Out, ReadTxn, SharedRef, StickyIndex, Text,
+    Transact, TransactionMut, Xml, XmlOut, XmlTextRef,
 };
 
 use crate::{nogvl, yrb_error};
 
-/// The origin of every transaction a handle opens. `Doc#edit` returns only
-/// these, so an update applied from elsewhere while it runs stays out.
+/// The origin of every transaction a handle opens, all through `write`.
 pub const ORIGIN: &str = "yrby";
 
+/// What the origin of every transaction that applies a peer's update starts
+/// with. The document keeps every other transaction's update for `Doc#edit`.
+pub const REMOTE: &str = "yrby-remote";
+
+/// True when `origin` marks a transaction that applied a peer's update.
+pub fn is_remote(origin: Option<&yrs::Origin>) -> bool {
+    origin.is_some_and(|origin| origin.as_ref().starts_with(REMOTE.as_bytes()))
+}
+
 /// The largest integer a double represents exactly (2^53).
 const MAX_SAFE_INTEGER: u64 = 1 << 53;
 
-/// A key no other observer uses. yrs registers an observer under a key and
-/// removes it by that key, so two observers on one document need different
-/// ones.
-pub fn observer_key() -> yrs::Origin {
+/// An origin for a transaction that applies a peer's update, and a key no
+/// other observer uses: yrs registers an observer under a key and removes it
+/// by that key, so two observers on one document need different ones.
+pub fn remote_key() -> yrs::Origin {
     static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
-    NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
-        .into()
+    let n = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    format!("{REMOTE}:{n}").as_str().into()
 }
 
 /// The branch `id` names, if it exists and has not been deleted.
@@ -97,6 +105,17 @@ where
     .map_err(yrb_error)
 }
 
+/// Run `f` in a write transaction under `ORIGIN`, as `guarded` runs its
+/// closure. The document keeps the transaction's update for `Doc#edit` when
+/// it commits (see `RbDoc::new`).
+pub fn write<F, R>(doc: &Doc, f: F) -> Result<R, Error>
+where
+    F: FnOnce(&mut TransactionMut) -> Result<R, String> + Send,
+    R: Send,
+{
+    guarded(move || f(&mut doc.transact_mut_with(ORIGIN)))
+}
+
 // --- indexes ---
 
 /// What `insert(index, ...)` means in a sequence of `len`, as in Ruby: a

data/ext/yrby/src/text.rs

@@ -17,7 +17,7 @@ use yrs::{Assoc, Doc, GetString, IndexedSequence, StickyIndex, Text, TextRef, Tr
 use crate::nogvl;
 use crate::shared::{
     char_len, delete_span, end_or_units, guarded, identity, insert_index, resolve, to_chars,
-    to_units, Position, ORIGIN,
+    to_units, write, Position,
 };
 use crate::yrb_error;
 
@@ -84,11 +84,10 @@ impl RbText {
     /// appends). Clamped into range.
     fn insert_at(&self, index: i64, text: String) -> Result<(), Error> {
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let t = resolve::<TextRef, _>(&txn, id).ok_or("text no longer exists")?;
-            let at = end_or_units(&txn, &t, index);
-            t.insert(&mut txn, at, &text);
+        write(doc, move |txn| {
+            let t = resolve::<TextRef, _>(txn, id).ok_or("text no longer exists")?;
+            let at = end_or_units(txn, &t, index);
+            t.insert(txn, at, &text);
             Ok(())
         })
     }
@@ -137,13 +136,12 @@ impl RbText {
     /// negative index counts from the end, and the length stops at the end.
     fn delete(&self, index: i64, length: i64) -> Result<(), Error> {
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let t = resolve::<TextRef, _>(&txn, id).ok_or("text no longer exists")?;
-            if let Some((from, to)) = delete_span(index, length, char_len(&txn, &t)) {
-                let (from, to) = (to_units(&txn, &t, from), to_units(&txn, &t, to));
+        write(doc, move |txn| {
+            let t = resolve::<TextRef, _>(txn, id).ok_or("text no longer exists")?;
+            if let Some((from, to)) = delete_span(index, length, char_len(txn, &t)) {
+                let (from, to) = (to_units(txn, &t, from), to_units(txn, &t, to));
                 if to > from {
-                    t.remove_range(&mut txn, from, to - from);
+                    t.remove_range(txn, from, to - from);
                 }
             }
             Ok(())
@@ -152,12 +150,11 @@ impl RbText {
 
     fn clear(&self) -> Result<(), Error> {
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            if let Some(t) = resolve::<TextRef, _>(&txn, id) {
-                let len = t.len(&txn);
+        write(doc, move |txn| {
+            if let Some(t) = resolve::<TextRef, _>(txn, id) {
+                let len = t.len(txn);
                 if len > 0 {
-                    t.remove_range(&mut txn, 0, len);
+                    t.remove_range(txn, 0, len);
                 }
             }
             Ok(())

data/ext/yrby/src/xml_text.rs

@@ -23,8 +23,8 @@ use crate::nogvl;
 use crate::shared::{
     any_to_ruby, block_text, char_len, delete_span, element_index, embedded_xml_text_index,
     embedded_xml_texts, end_or_units, ends_with_xml_text, guarded, hash_pairs, identity,
-    insert_index, resolve, ruby_to_invalue, to_in, to_map_prelim, to_units, InValue, Position,
-    MAX_NESTING, ORIGIN,
+    insert_index, resolve, ruby_to_invalue, to_in, to_map_prelim, to_units, write, InValue,
+    Position, MAX_NESTING,
 };
 use crate::yrb_error;
 
@@ -166,10 +166,9 @@ impl RbXmlText {
         let ruby = Ruby::get().map_err(|e| yrb_error(e.to_string()))?;
         let iv = ruby_to_invalue(&ruby, value)?;
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let x = resolve::<XmlTextRef, _>(&txn, id).ok_or("the block no longer exists")?;
-            x.insert_attribute(&mut txn, key, to_in(iv));
+        write(doc, move |txn| {
+            let x = resolve::<XmlTextRef, _>(txn, id).ok_or("the block no longer exists")?;
+            x.insert_attribute(txn, key, to_in(iv));
             Ok(())
         })?;
         Ok(value)
@@ -180,11 +179,10 @@ impl RbXmlText {
     fn insert(&self, index: i64, chunk: String) -> Result<String, Error> {
         let (doc, id) = (&self.doc, &self.id);
         let text = chunk.clone();
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let x = resolve::<XmlTextRef, _>(&txn, id).ok_or("the block no longer exists")?;
-            let at = end_or_units(&txn, &x, index);
-            x.insert(&mut txn, at, &text);
+        write(doc, move |txn| {
+            let x = resolve::<XmlTextRef, _>(txn, id).ok_or("the block no longer exists")?;
+            let at = end_or_units(txn, &x, index);
+            x.insert(txn, at, &text);
             Ok(())
         })?;
         Ok(chunk)
@@ -198,16 +196,15 @@ impl RbXmlText {
         let ruby = Ruby::get().map_err(|e| yrb_error(e.to_string()))?;
         let iv = ruby_to_invalue(&ruby, value)?;
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let x = resolve::<XmlTextRef, _>(&txn, id).ok_or("the block no longer exists")?;
-            let at = to_units(&txn, &x, insert_index(index, char_len(&txn, &x)));
+        write(doc, move |txn| {
+            let x = resolve::<XmlTextRef, _>(txn, id).ok_or("the block no longer exists")?;
+            let at = to_units(txn, &x, insert_index(index, char_len(txn, &x)));
             match iv {
                 InValue::Map(entries) => {
-                    x.insert_embed(&mut txn, at, to_map_prelim(entries));
+                    x.insert_embed(txn, at, to_map_prelim(entries));
                 }
                 InValue::Any(a) => {
-                    x.insert_embed(&mut txn, at, a);
+                    x.insert_embed(txn, at, a);
                 }
             }
             Ok(())
@@ -263,13 +260,12 @@ impl RbXmlText {
     /// negative index counts from the end, and the length stops at the end.
     fn delete(&self, index: i64, length: i64) -> Result<(), Error> {
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let x = resolve::<XmlTextRef, _>(&txn, id).ok_or("the block no longer exists")?;
-            if let Some((from, to)) = delete_span(index, length, char_len(&txn, &x)) {
-                let (from, to) = (to_units(&txn, &x, from), to_units(&txn, &x, to));
+        write(doc, move |txn| {
+            let x = resolve::<XmlTextRef, _>(txn, id).ok_or("the block no longer exists")?;
+            if let Some((from, to)) = delete_span(index, length, char_len(txn, &x)) {
+                let (from, to) = (to_units(txn, &x, from), to_units(txn, &x, to));
                 if to > from {
-                    x.remove_range(&mut txn, from, to - from);
+                    x.remove_range(txn, from, to - from);
                 }
             }
             Ok(())
@@ -279,12 +275,11 @@ impl RbXmlText {
     /// Remove everything: markers, text, and embedded blocks.
     fn clear(&self) -> Result<(), Error> {
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let x = resolve::<XmlTextRef, _>(&txn, id).ok_or("the block no longer exists")?;
-            let len = x.len(&txn);
+        write(doc, move |txn| {
+            let x = resolve::<XmlTextRef, _>(txn, id).ok_or("the block no longer exists")?;
+            let len = x.len(txn);
             if len > 0 {
-                x.remove_range(&mut txn, 0, len);
+                x.remove_range(txn, 0, len);
             }
             Ok(())
         })
@@ -300,13 +295,12 @@ impl RbXmlText {
         let attributes = hash_pairs(&ruby, attributes)?;
         let content = Piece::read_all(&ruby, content, 0)?;
         let (doc, id) = (&self.doc, &self.id);
-        let block = guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let x = resolve::<XmlTextRef, _>(&txn, id).ok_or("the block no longer exists")?;
-            let count = embedded_xml_texts(&txn, &x).len() as u32;
+        let block = write(doc, move |txn| {
+            let x = resolve::<XmlTextRef, _>(txn, id).ok_or("the block no longer exists")?;
+            let count = embedded_xml_texts(txn, &x).len() as u32;
             let ordinal = insert_index(n, count);
-            let at = embedded_xml_text_index(&txn, &x, ordinal).unwrap_or_else(|| x.len(&txn));
-            let child = Piece::Block(attributes, content).write(&mut txn, &x, at);
+            let at = embedded_xml_text_index(txn, &x, ordinal).unwrap_or_else(|| x.len(txn));
+            let child = Piece::Block(attributes, content).write(txn, &x, at);
             // The block's identity, not the block: see `Child`.
             Ok(identity(&child.expect("a block piece writes a block")))
         })?;
@@ -331,19 +325,18 @@ impl RbXmlText {
         let ruby = Ruby::get().map_err(|e| yrb_error(e.to_string()))?;
         let content = Piece::read_all(&ruby, content, 0)?;
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let x = resolve::<XmlTextRef, _>(&txn, id).ok_or("the block no longer exists")?;
+        write(doc, move |txn| {
+            let x = resolve::<XmlTextRef, _>(txn, id).ok_or("the block no longer exists")?;
             if clear {
-                let len = x.len(&txn);
+                let len = x.len(txn);
                 if len > 0 {
-                    x.remove_range(&mut txn, 0, len);
+                    x.remove_range(txn, 0, len);
                 }
             }
-            let mut at = x.len(&txn);
+            let mut at = x.len(txn);
             for piece in content {
-                piece.write(&mut txn, &x, at);
-                at = x.len(&txn);
+                piece.write(txn, &x, at);
+                at = x.len(txn);
             }
             Ok(())
         })
@@ -358,15 +351,14 @@ impl RbXmlText {
         let ruby = Ruby::get().map_err(|e| yrb_error(e.to_string()))?;
         let marker = hash_pairs(&ruby, marker)?;
         let (doc, id) = (&rb_self.doc, &rb_self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let x = resolve::<XmlTextRef, _>(&txn, id).ok_or("the block no longer exists")?;
-            let mut at = x.len(&txn);
-            if at == 0 || ends_with_xml_text(&txn, &x) {
-                x.insert_embed(&mut txn, at, to_map_prelim(marker));
+        write(doc, move |txn| {
+            let x = resolve::<XmlTextRef, _>(txn, id).ok_or("the block no longer exists")?;
+            let mut at = x.len(txn);
+            if at == 0 || ends_with_xml_text(txn, &x) {
+                x.insert_embed(txn, at, to_map_prelim(marker));
                 at += 1;
             }
-            x.insert(&mut txn, at, &text);
+            x.insert(txn, at, &text);
             Ok(())
         })?;
         Ok(rb_self)
@@ -376,16 +368,15 @@ impl RbXmlText {
     /// last). Returns whether there was one.
     fn delete_xml_text(&self, n: i64) -> Result<bool, Error> {
         let (doc, id) = (&self.doc, &self.id);
-        guarded(move || {
-            let mut txn = doc.transact_mut_with(ORIGIN);
-            let x = resolve::<XmlTextRef, _>(&txn, id).ok_or("the block no longer exists")?;
-            let count = embedded_xml_texts(&txn, &x).len() as u32;
+        write(doc, move |txn| {
+            let x = resolve::<XmlTextRef, _>(txn, id).ok_or("the block no longer exists")?;
+            let count = embedded_xml_texts(txn, &x).len() as u32;
             let Some(at) =
-                element_index(n, count).and_then(|n| embedded_xml_text_index(&txn, &x, n))
+                element_index(n, count).and_then(|n| embedded_xml_text_index(txn, &x, n))
             else {
                 return Ok(false);
             };
-            x.remove_range(&mut txn, at, 1);
+            x.remove_range(txn, at, 1);
             Ok(true)
         })
     }

data/lib/y/array.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Y
+  # Inside module Y, `Array` is this class.
+  class Array
+    # Insert a new Y.Text holding `content` at `index` and return a live
+    # Y::Text for it. Indexes work as in `insert`: -1 appends.
+    def insert_text(index, content = "")
+      native_insert_text(index, content)
+    end
+
+    # Append a new Y.Text holding `content` and return a live Y::Text for it.
+    def push_text(content = "")
+      insert_text(-1, content)
+    end
+  end
+end

data/lib/y/collaborative/attribute.rb

@@ -43,7 +43,7 @@ module Y
       # Edits the document from Ruby the way a browser does: yields the
       # current document, records what the block changed, and broadcasts it so
       # open editors apply it. Returns the update, or nil when the block
-      # changed nothing.
+      # wrote nothing.
       #
       #   post.collaborative_document(:body).edit do |doc|
       #     Y::Lexxy.append_paragraph(doc, "Reviewed by ops.")

data/lib/y/doc.rb

@@ -4,17 +4,43 @@ module Y
   # Ruby-side conveniences over the native document.
   class Doc
     # Runs the block, which edits this document through handles, and returns
-    # the update its writes produced, or nil when the document didn't change.
-    # The document has the edit either way. The update is what a process
-    # saves and broadcasts, one call per chunk as it streams into a document.
+    # an update with every local write no edit has returned yet, or nil when
+    # there's nothing to send. The document has the writes either way. The
+    # update is what a process saves and broadcasts, one call per chunk as it
+    # streams into a document.
     #
-    # The update holds everything the document gained while the block ran,
-    # so a write another thread or peer made meanwhile is in it too. Applying
-    # an update twice changes nothing, so that only adds bytes.
+    # The document keeps every local write until an edit returns it, so none
+    # is left out: a write made outside an edit, from another thread or
+    # fiber, or in a block that raised comes with the next edit's update. An
+    # update applied from a peer is never in it, and doesn't wait for the
+    # block. Each edit takes everything unsent at once, so the updates edits
+    # return have no gaps between them. An edit inside another, including one
+    # in a fiber or thread the outer block starts, returns what it took and
+    # leaves it for the outer edit to return again. Once the outer edit
+    # returns, a thread it started edits on its own.
+    #
+    # So send every update an edit returns. An edit in a thread the block
+    # didn't start, such as a pool thread, isn't nested: it takes the outer
+    # block's writes too, and they're sent only if its update is.
+    #
+    # An exception raised as `edit` returns, such as a Thread#raise or a
+    # signal trap, loses the update the edit took. A caller that must send
+    # every update masks interrupts around `edit` and doesn't raise from a
+    # trap.
     def edit
-      before = native_snapshot
-      yield self
-      native_update_since(before)
+      # The edits running in this fiber, inherited by the fibers and threads
+      # their blocks start. Each is `[doc]` until it ends, then empty.
+      outer = (Fiber[:yrby_editing] || []).reject(&:empty?)
+      nested = outer.any? { |running| running.include?(self) }
+      running = [self]
+      Fiber[:yrby_editing] = [*outer, running]
+      begin
+        yield self
+      ensure
+        running.clear
+        Fiber[:yrby_editing] = outer
+      end
+      take_unsent(nested)
     end
 
     # The ordinal of the top-level block a position falls in, or nil at the
@@ -32,5 +58,22 @@ module Y
     def find(anchor)
       native_find(anchor.position, anchor.root)
     end
+
+    private
+
+    # An interrupt that arrives during the take is raised once the masked
+    # block ends, and the taken update goes back to the document first, for
+    # the next edit to return. A nested edit has already put it back.
+    def take_unsent(nested)
+      taken = nil
+      Thread.handle_interrupt(Object => :never) do
+        taken = native_take_unsent
+        native_keep_unsent(taken) if taken && nested
+      end
+      taken
+    rescue Exception # rubocop:disable Lint/RescueException -- an interrupt is any exception
+      native_keep_unsent(taken) if taken && !nested
+      raise
+    end
   end
 end

data/lib/y/map.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Y
+  class Map
+    # Store a new Y.Text holding `content` at `key`, replacing what was
+    # there, and return a live Y::Text for it. `map[key] = "..."` stores a
+    # plain string instead, and the last write to it wins.
+    def set_text(key, content = "")
+      native_set_text(key, content)
+    end
+  end
+end

data/lib/y/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Y
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 end

data/lib/y.rb

@@ -19,6 +19,8 @@ require_relative "y/lexical_markdown"
 require_relative "y/anchor"
 require_relative "y/xml_text"
 require_relative "y/text"
+require_relative "y/map"
+require_relative "y/array"
 require_relative "y/doc"
 require_relative "y/tiptap"
 require_relative "y/decoder"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yrby
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - JP Camara
@@ -103,6 +103,7 @@ files:
 - lib/generators/yrby/tables/templates/create_y_tables.rb
 - lib/y.rb
 - lib/y/anchor.rb
+- lib/y/array.rb
 - lib/y/collaborative.rb
 - lib/y/collaborative/attribute.rb
 - lib/y/collaborative/helper.rb
@@ -111,6 +112,7 @@ files:
 - lib/y/lexical_markdown.rb
 - lib/y/lexical_writer.rb
 - lib/y/lexxy.rb
+- lib/y/map.rb
 - lib/y/rendering.rb
 - lib/y/text.rb
 - lib/y/tiptap.rb