yrb-lite 0.1.0.beta6 → 0.1.0.beta7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9553ad44479cc56e9ccd2645017c8ebf3dba79a0d5905651396b5f397ca1ad6a
-  data.tar.gz: 8c81c7a844a50def1af8b4a2cdbb1bbf95f576077976b7cc6fc4aef740173164
+  metadata.gz: ea20d7a00b104460b01812d463df581b45042d63491ff1e5494acd478fa2047b
+  data.tar.gz: 731010497572899b225ff36fd792e635738d05bad0f41640a4f991af56540d3e
 SHA512:
-  metadata.gz: 0db8acba6f12e4f9f9289cb80b7d2aa4870ed2c26f090eea1529fd19fa1a1b07c6731ec36097c96a47735f5f6abbf91f592701512250487acf053edd734eb771
-  data.tar.gz: d5c4e9e3a98f16735b150c76c68e5e7b584c329f554edf12c3949d4104e5b9a06c31fe9d3082bc2f510f67f17fa0ea9402d373ad926320c2f96eb2af744f60a1
+  metadata.gz: 83682aa86e7753b9270274051e0b9850c41e35559817cbae981debe68de53d4b1cd56cff5b21b0d63b411e87ab550cd7ffc11c0ec0c3005845e02e5af145d078
+  data.tar.gz: 282965720af81ee289feb0f555ff828fd593ba24f869054a7792f420c61ba03c87168b963adb6259e143b103c398e70855365d48c1f4cd6a7e693ae8491026b9

data/ext/yrb_lite/src/lib.rs

@@ -5,13 +5,11 @@ use std::sync::Mutex;
 use yrs::sync::{Awareness, DefaultProtocol, Message, Protocol, SyncMessage};
 use yrs::updates::decoder::Decode;
 use yrs::updates::encoder::{Encode, Encoder, EncoderV1};
-use yrs::{ClientID, Doc, ReadTxn, Transact};
+use yrs::{Doc, ReadTxn, Transact};
 
 mod protocol;
 use protocol::{
-    awareness_client_ids_in, classify_message, doc_has_pending, merged_doc_update,
-    update_advances_doc, update_is_ready, validate_frame_client_ids,
-    validate_state_vector_client_ids, validate_update_client_ids,
+    classify_message, doc_has_pending, merged_doc_update, update_advances_doc, update_is_ready,
 };
 
 /// Wrapper around yrs Doc.
@@ -131,9 +129,9 @@ fn copy_bytes(s: RString) -> Vec<u8> {
 }
 
 /// Build a `YrbLite::Error` (the gem's own error class, defined in `init`) so
-/// native decode/apply/validation failures surface as a project-specific error
-/// rather than a generic RuntimeError. Falls back to RuntimeError only if the
-/// class somehow can't be resolved.
+/// native decode/apply failures surface as a project-specific error rather than
+/// a generic RuntimeError. Falls back to RuntimeError only if the class somehow
+/// can't be resolved.
 fn yrb_error(msg: String) -> Error {
     let ruby = Ruby::get().unwrap();
     let class = ruby
@@ -142,26 +140,10 @@ fn yrb_error(msg: String) -> Error {
     Error::new(class, msg)
 }
 
-/// Yjs/lib0 client IDs must be JS-safe integers (<= 2^53 - 1). Above that they
-/// round or collide when crossing the JS/Yjs boundary, and a client-id collision
-/// corrupts a CRDT. Explicit (Ruby-supplied) IDs are validated here; the random
-/// default IDs that yrs generates are already in range.
-const MAX_SAFE_CLIENT_ID: u64 = (1 << 53) - 1;
-
-/// Pure predicate (no Ruby), so the boundary is unit-testable without a VM.
-pub(crate) fn is_safe_client_id(id: u64) -> bool {
-    id <= MAX_SAFE_CLIENT_ID
-}
-
-fn validate_client_id(id: u64) -> Result<u64, Error> {
-    if !is_safe_client_id(id) {
-        return Err(yrb_error(format!(
-            "client_id {id} exceeds the maximum safe integer ({MAX_SAFE_CLIENT_ID} = 2^53 - 1); \
-             Yjs client IDs must be JS-safe integers to avoid collisions"
-        )));
-    }
-    Ok(id)
-}
+// CLIENT IDs ARE NOT VALIDATED -- whoever supplies the id (the app via
+// `Doc.new(id)` / `Awareness.new(id)`, or a remote peer over the wire) is
+// responsible for keeping it JS-safe (<= 2^53 - 1). See the protocol.rs header
+// for why (and `ClientID::try_new`, proposed upstream, for strict rejection).
 
 // ============================================================================
 // Doc Implementation
@@ -173,23 +155,20 @@ impl RbDoc {
         let doc = if args.is_empty() {
             Doc::new()
         } else {
-            let client_id = validate_client_id(TryConvert::try_convert(args[0])?)?;
+            let client_id: u64 = TryConvert::try_convert(args[0])?;
             Doc::with_client_id(client_id)
         };
         Ok(RbDoc(doc))
     }
 
-    /// Get the client ID
     fn client_id(&self) -> u64 {
         self.0.client_id().get()
     }
 
-    /// Get the document GUID
     fn guid(&self) -> String {
         self.0.guid().to_string()
     }
 
-    /// Get the current state vector encoded as bytes
     fn encode_state_vector(&self) -> RString {
         let doc = &self.0;
         let sv = nogvl(move || {
@@ -220,12 +199,10 @@ impl RbDoc {
         Ok(binary_string(&update))
     }
 
-    /// Apply a V1 update to the document
     fn apply_update(&self, update: RString) -> Result<(), Error> {
         let update_bytes = copy_bytes(update);
         let doc = &self.0;
         nogvl(move || -> Result<(), String> {
-            validate_update_client_ids(&update_bytes)?;
             let update = yrs::Update::decode_v1(&update_bytes).map_err(|e| e.to_string())?;
             let mut txn = doc.transact_mut();
             txn.apply_update(update).map_err(|e| e.to_string())
@@ -274,7 +251,6 @@ impl RbDoc {
         let sv_data = copy_bytes(sv_bytes);
         let doc = &self.0;
         let encoded = nogvl(move || -> Result<Vec<u8>, String> {
-            validate_state_vector_client_ids(&sv_data)?;
             let sv = yrs::StateVector::decode_v1(&sv_data).map_err(|e| e.to_string())?;
             let txn = doc.transact();
             let update = txn.encode_state_as_update_v1(&sv);
@@ -292,7 +268,6 @@ impl RbDoc {
 
         let (msg_type, sync_type, response) =
             nogvl(move || -> Result<(u8, u8, Vec<u8>), String> {
-                validate_frame_client_ids(&data_bytes)?;
                 let msg = Message::decode_v1(&data_bytes).map_err(|e| e.to_string())?;
 
                 match msg {
@@ -350,19 +325,17 @@ impl RbAwareness {
         let awareness = if args.is_empty() {
             Awareness::new(Doc::new())
         } else {
-            let client_id = validate_client_id(TryConvert::try_convert(args[0])?)?;
+            let client_id: u64 = TryConvert::try_convert(args[0])?;
             Awareness::new(Doc::with_client_id(client_id))
         };
         Ok(RbAwareness(Mutex::new(awareness)))
     }
 
-    /// Get the client ID of the underlying document
     fn client_id(&self) -> u64 {
         let awareness = &self.0;
         nogvl(move || awareness.lock().unwrap().doc().client_id().get())
     }
 
-    /// Get the document GUID
     fn guid(&self) -> String {
         let awareness = &self.0;
         nogvl(move || awareness.lock().unwrap().doc().guid().to_string())
@@ -406,7 +379,6 @@ impl RbAwareness {
         let awareness = &self.0;
 
         let encoded = nogvl(move || -> Result<Vec<u8>, String> {
-            validate_frame_client_ids(&data_bytes)?;
             let mut awareness = awareness.lock().unwrap();
             let protocol = DefaultProtocol;
             let responses = protocol
@@ -428,18 +400,12 @@ impl RbAwareness {
     }
 
     /// Encode an update message for broadcasting changes to peers.
-    fn encode_update(&self, update: RString) -> Result<RString, Error> {
+    fn encode_update(&self, update: RString) -> RString {
         let update_bytes = copy_bytes(update);
-        nogvl({
-            let update_bytes = update_bytes.clone();
-            move || validate_update_client_ids(&update_bytes)
-        })
-        .map_err(yrb_error)?;
         let msg = Message::Sync(SyncMessage::Update(update_bytes));
-        Ok(binary_string(&msg.encode_v1()))
+        binary_string(&msg.encode_v1())
     }
 
-    /// Get the current state vector encoded as bytes
     fn encode_state_vector(&self) -> RString {
         let awareness = &self.0;
         let sv = nogvl(move || {
@@ -517,12 +483,10 @@ impl RbAwareness {
         Ok(binary_string(&encoded))
     }
 
-    /// Apply a raw update to the underlying document
     fn apply_update(&self, update: RString) -> Result<(), Error> {
         let update_bytes = copy_bytes(update);
         let awareness = &self.0;
         nogvl(move || -> Result<(), String> {
-            validate_update_client_ids(&update_bytes)?;
             let update = yrs::Update::decode_v1(&update_bytes).map_err(|e| e.to_string())?;
             let doc = awareness.lock().unwrap().doc().clone();
             let mut txn = doc.transact_mut();
@@ -566,16 +530,6 @@ impl RbAwareness {
         })
     }
 
-    /// Decode the awareness client IDs referenced by a protocol message
-    /// (which may pack several sub-messages together). Sync sub-messages are
-    /// ignored. The ActionCable layer uses this to learn which presence
-    /// states arrived on a connection, so it can clear them when that
-    /// connection closes.
-    fn awareness_client_ids(&self, data: RString) -> Result<Vec<u64>, Error> {
-        let data_bytes = copy_bytes(data);
-        nogvl(move || awareness_client_ids_in(&data_bytes)).map_err(yrb_error)
-    }
-
     /// Classify a frame for safe routing and relay. Returns a code only when
     /// the frame is exactly one well-formed message that consumes the whole
     /// buffer, so a malformed, truncated, multi-message, or trailing-garbage
@@ -594,46 +548,13 @@ impl RbAwareness {
     /// Extract the document-update delta carried by a protocol message: the
     /// payloads of any Update or SyncStep2 sub-messages, merged into a single
     /// update. Returns nil if the message carries no document change (for
-    /// instance a SyncStep1 request or an awareness update). The strict audit
-    /// path records this exact delta before applying it.
+    /// instance a SyncStep1 request or an awareness update). The store-backed
+    /// path records this exact delta before relaying it.
     fn update_from_message(&self, data: RString) -> Result<Option<RString>, Error> {
         let data_bytes = copy_bytes(data);
         let merged = nogvl(move || merged_doc_update(&data_bytes)).map_err(yrb_error)?;
         Ok(merged.map(|b| binary_string(&b)))
     }
-
-    /// Mark the given clients as disconnected and return an awareness protocol
-    /// message (null-state, bumped clock) announcing their removal to peers.
-    /// Only clients currently known to this Awareness are removed; unknown
-    /// IDs are skipped (so we never broadcast phantom removals). Returns an
-    /// empty string when nothing was removed.
-    fn remove_clients(&self, client_ids: Vec<u64>) -> Result<RString, Error> {
-        let client_ids = client_ids
-            .into_iter()
-            .map(validate_client_id)
-            .collect::<Result<Vec<_>, _>>()?;
-        let awareness = &self.0;
-        let encoded = nogvl(move || -> Result<Vec<u8>, String> {
-            let mut awareness = awareness.lock().unwrap();
-            let mut removed = Vec::new();
-            for id in client_ids {
-                let cid = ClientID::new(id);
-                if awareness.meta(cid).is_some() {
-                    awareness.remove_state(cid);
-                    removed.push(cid);
-                }
-            }
-            if removed.is_empty() {
-                return Ok(Vec::new());
-            }
-            let update = awareness
-                .update_with_clients(removed)
-                .map_err(|e| e.to_string())?;
-            Ok(Message::Awareness(update).encode_v1())
-        })
-        .map_err(yrb_error)?;
-        Ok(binary_string(&encoded))
-    }
 }
 
 // ============================================================================
@@ -707,11 +628,6 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
         "encode_awareness_update",
         method!(RbAwareness::encode_awareness_update, 0),
     )?;
-    awareness_class.define_method(
-        "awareness_client_ids",
-        method!(RbAwareness::awareness_client_ids, 1),
-    )?;
-    awareness_class.define_method("remove_clients", method!(RbAwareness::remove_clients, 1))?;
     awareness_class.define_method(
         "update_from_message",
         method!(RbAwareness::update_from_message, 1),

data/ext/yrb_lite/src/protocol.rs

@@ -1,219 +1,18 @@
-// Pure protocol helpers: no Ruby, no GVL, no `unsafe`. Everything here operates
-// on plain byte slices and `yrs` types, so it's unit-tested directly (see the
-// `tests` module below) without a Ruby VM. The Ruby-facing wrappers in lib.rs
-// copy bytes out of Ruby strings and call into these under `nogvl`.
-use crate::is_safe_client_id;
-use std::sync::Arc;
-use yrs::encoding::read::{Cursor, Error as ReadError, Read};
-use yrs::sync::protocol::{
-    MessageReader, MSG_AUTH, MSG_AWARENESS, MSG_QUERY_AWARENESS, MSG_SYNC, MSG_SYNC_STEP_1,
-    MSG_SYNC_STEP_2, MSG_SYNC_UPDATE, PERMISSION_DENIED,
-};
+// Pure rust protocol helpers (ie, no Ruby interop).
+//
+// CLIENT IDs ARE NOT VALIDATED HERE -- on purpose. We deliberately don't police it -- every
+// legitimate peer (browser Yjs, and yrs's own `ClientID::random`) already emits
+// 53-bit ids, so it's the client's responsibility not to send a bad one, and we
+// don't want to own that logic.
+use yrs::encoding::read::{Cursor, Read};
+use yrs::sync::protocol::MessageReader;
 use yrs::sync::{Message, SyncMessage};
-use yrs::updates::decoder::{Decode, Decoder, DecoderV1};
-use yrs::{Any, ClientID, Doc, ReadTxn, Transact, ID};
-
-fn unsafe_client_id_error(id: u64) -> ReadError {
-    ReadError::Custom(format!(
-        "client_id {id} exceeds the maximum safe integer (2^53 - 1); \
-         Yjs client IDs must be JS-safe integers to avoid collisions"
-    ))
-}
-
-fn checked_client_id(id: u64) -> Result<ClientID, ReadError> {
-    if !is_safe_client_id(id) {
-        return Err(unsafe_client_id_error(id));
-    }
-    Ok(ClientID::new(id))
-}
-
-fn validate_raw_client_id(id: u64) -> Result<(), ReadError> {
-    if !is_safe_client_id(id) {
-        return Err(unsafe_client_id_error(id));
-    }
-    Ok(())
-}
-
-struct CheckedDecoderV1<'a> {
-    cursor: Cursor<'a>,
-}
-
-impl<'a> CheckedDecoderV1<'a> {
-    fn new(cursor: Cursor<'a>) -> Self {
-        CheckedDecoderV1 { cursor }
-    }
-
-    fn read_id(&mut self) -> Result<ID, ReadError> {
-        let client: u64 = self.read_var()?;
-        validate_raw_client_id(client)?;
-        let clock = self.read_var()?;
-        Ok(ID::new(ClientID::new(client), clock))
-    }
-}
-
-impl<'a> Read for CheckedDecoderV1<'a> {
-    #[inline]
-    fn read_u8(&mut self) -> Result<u8, ReadError> {
-        self.cursor.read_u8()
-    }
-
-    #[inline]
-    fn read_exact(&mut self, len: usize) -> Result<&[u8], ReadError> {
-        self.cursor.read_exact(len)
-    }
-}
-
-impl<'a> Decoder for CheckedDecoderV1<'a> {
-    #[inline]
-    fn reset_ds_cur_val(&mut self) {}
-
-    #[inline]
-    fn read_ds_clock(&mut self) -> Result<u32, ReadError> {
-        self.read_var()
-    }
-
-    #[inline]
-    fn read_ds_len(&mut self) -> Result<u32, ReadError> {
-        self.read_var()
-    }
-
-    #[inline]
-    fn read_left_id(&mut self) -> Result<ID, ReadError> {
-        self.read_id()
-    }
-
-    #[inline]
-    fn read_right_id(&mut self) -> Result<ID, ReadError> {
-        self.read_id()
-    }
-
-    #[inline]
-    fn read_client(&mut self) -> Result<ClientID, ReadError> {
-        let client: u64 = self.cursor.read_var()?;
-        checked_client_id(client)
-    }
-
-    #[inline]
-    fn read_info(&mut self) -> Result<u8, ReadError> {
-        self.cursor.read_u8()
-    }
-
-    #[inline]
-    fn read_parent_info(&mut self) -> Result<bool, ReadError> {
-        let info: u32 = self.cursor.read_var()?;
-        Ok(info == 1)
-    }
-
-    #[inline]
-    fn read_type_ref(&mut self) -> Result<u8, ReadError> {
-        self.cursor.read_u8()
-    }
-
-    #[inline]
-    fn read_len(&mut self) -> Result<u32, ReadError> {
-        self.read_var()
-    }
-
-    #[inline]
-    fn read_any(&mut self) -> Result<Any, ReadError> {
-        Any::decode(self)
-    }
-
-    #[inline]
-    fn read_json(&mut self) -> Result<Any, ReadError> {
-        let src = self.read_string()?;
-        Any::from_json(src)
-    }
-
-    #[inline]
-    fn read_key(&mut self) -> Result<Arc<str>, ReadError> {
-        let str: Arc<str> = self.read_string()?.into();
-        Ok(str)
-    }
-
-    #[inline]
-    fn read_to_end(&mut self) -> Result<&[u8], ReadError> {
-        Ok(&self.cursor.buf[self.cursor.next..])
-    }
-}
-
-pub(crate) fn validate_state_vector_client_ids(bytes: &[u8]) -> Result<(), String> {
-    let mut cursor = Cursor::new(bytes);
-    let len: u32 = cursor.read_var().map_err(|e| e.to_string())?;
-    for _ in 0..len {
-        let client: u64 = cursor.read_var().map_err(|e| e.to_string())?;
-        validate_raw_client_id(client).map_err(|e| e.to_string())?;
-        let _: u32 = cursor.read_var().map_err(|e| e.to_string())?;
-    }
-    if cursor.has_content() {
-        return Err("state vector has trailing bytes".to_string());
-    }
-    Ok(())
-}
-
-pub(crate) fn validate_update_client_ids(update_bytes: &[u8]) -> Result<(), String> {
-    let mut decoder = CheckedDecoderV1::new(Cursor::new(update_bytes));
-    yrs::Update::decode(&mut decoder).map_err(|e| e.to_string())?;
-    if decoder.cursor.has_content() {
-        return Err("update has trailing bytes".to_string());
-    }
-    Ok(())
-}
-
-fn validate_awareness_update_client_ids(bytes: &[u8]) -> Result<(), String> {
-    let mut cursor = Cursor::new(bytes);
-    let len: u32 = cursor.read_var().map_err(|e| e.to_string())?;
-    for _ in 0..len {
-        let client: u64 = cursor.read_var().map_err(|e| e.to_string())?;
-        validate_raw_client_id(client).map_err(|e| e.to_string())?;
-        let _: u32 = cursor.read_var().map_err(|e| e.to_string())?;
-        let _ = cursor.read_string().map_err(|e| e.to_string())?;
-    }
-    if cursor.has_content() {
-        return Err("awareness update has trailing bytes".to_string());
-    }
-    Ok(())
-}
-
-pub(crate) fn validate_frame_client_ids(bytes: &[u8]) -> Result<(), String> {
-    let mut cursor = Cursor::new(bytes);
-    while cursor.has_content() {
-        let tag: u8 = cursor.read_var().map_err(|e| e.to_string())?;
-        match tag {
-            MSG_SYNC => {
-                let sync_tag: u8 = cursor.read_var().map_err(|e| e.to_string())?;
-                let payload = cursor.read_buf().map_err(|e| e.to_string())?;
-                match sync_tag {
-                    MSG_SYNC_STEP_1 => validate_state_vector_client_ids(payload)?,
-                    MSG_SYNC_STEP_2 | MSG_SYNC_UPDATE => validate_update_client_ids(payload)?,
-                    _ => return Err("unknown sync message type".to_string()),
-                }
-            }
-            MSG_AWARENESS => {
-                let payload = cursor.read_buf().map_err(|e| e.to_string())?;
-                validate_awareness_update_client_ids(payload)?;
-            }
-            MSG_AUTH => {
-                let permission: u8 = cursor.read_var().map_err(|e| e.to_string())?;
-                if permission == PERMISSION_DENIED {
-                    let _ = cursor.read_string().map_err(|e| e.to_string())?;
-                }
-            }
-            MSG_QUERY_AWARENESS => {}
-            _ => {
-                let _ = cursor.read_buf().map_err(|e| e.to_string())?;
-            }
-        }
-    }
-    Ok(())
-}
+use yrs::updates::decoder::{Decode, DecoderV1};
+use yrs::{Doc, ReadTxn, Transact};
 
 /// Classify a frame: a non-zero code only for exactly one well-formed message
 /// that consumes the whole buffer (see `RbAwareness::message_kind` for codes).
 pub(crate) fn classify_message(bytes: &[u8]) -> u8 {
-    if validate_frame_client_ids(bytes).is_err() {
-        return 0;
-    }
     let mut decoder = DecoderV1::new(Cursor::new(bytes));
     let msg = match Message::decode(&mut decoder) {
         Ok(msg) => msg,
@@ -236,7 +35,6 @@ pub(crate) fn classify_message(bytes: &[u8]) -> u8 {
 /// frame into one update, or `None` if the frame carries no document change
 /// (a request, an awareness update, or a no-op handshake SyncStep2).
 pub(crate) fn merged_doc_update(bytes: &[u8]) -> Result<Option<Vec<u8>>, String> {
-    validate_frame_client_ids(bytes)?;
     let mut decoder = DecoderV1::new(Cursor::new(bytes));
     let mut updates: Vec<Vec<u8>> = Vec::new();
     for msg in MessageReader::new(&mut decoder) {
@@ -268,26 +66,12 @@ pub(crate) fn merged_doc_update(bytes: &[u8]) -> Result<Option<Vec<u8>>, String>
     Ok(Some(merged))
 }
 
-/// Collect the awareness client IDs referenced by a frame's awareness messages.
-pub(crate) fn awareness_client_ids_in(bytes: &[u8]) -> Result<Vec<u64>, String> {
-    validate_frame_client_ids(bytes)?;
-    let mut decoder = DecoderV1::new(Cursor::new(bytes));
-    let mut ids = Vec::new();
-    for msg in MessageReader::new(&mut decoder) {
-        if let Message::Awareness(update) = msg.map_err(|e| e.to_string())? {
-            ids.extend(update.clients.keys().map(|c| c.get()));
-        }
-    }
-    Ok(ids)
-}
-
 /// True if applying `update_bytes` to `doc` would integrate cleanly: every
 /// dependency the update references is already present (the doc's state vector
 /// covers the update's lower bound). A pure read; does not mutate the doc.
 /// When false, applying it would park a pending struct -- the signal that an
 /// earlier, causally-prior update is missing.
 pub(crate) fn update_is_ready(doc: &Doc, update_bytes: &[u8]) -> Result<bool, String> {
-    validate_update_client_ids(update_bytes)?;
     let update = yrs::Update::decode_v1(update_bytes).map_err(|e| e.to_string())?;
     Ok(doc.transact().state_vector() >= update.state_vector_lower())
 }
@@ -309,7 +93,6 @@ pub(crate) fn update_is_ready(doc: &Doc, update_bytes: &[u8]) -> Result<bool, St
 /// double-record a pure-delete retry, but it NEVER drops a real deletion, which
 /// is the safe direction. Assumes the update is already causally ready.
 pub(crate) fn update_advances_doc(doc: &Doc, update_bytes: &[u8]) -> Result<bool, String> {
-    validate_update_client_ids(update_bytes)?;
     let update = yrs::Update::decode_v1(update_bytes).map_err(|e| e.to_string())?;
     if !update.delete_set().is_empty() {
         return Ok(true); // can't cheaply prove a delete is a duplicate; record it
@@ -342,10 +125,8 @@ pub(crate) fn doc_has_pending(doc: &Doc) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::is_safe_client_id;
-    use yrs::encoding::write::Write;
     use yrs::sync::Awareness;
-    use yrs::updates::encoder::{Encode, Encoder, EncoderV1};
+    use yrs::updates::encoder::Encode;
     use yrs::Text;
 
     fn text_update(content: &str) -> Vec<u8> {
@@ -374,42 +155,6 @@ mod tests {
         Message::Awareness(awareness.update().unwrap()).encode_v1()
     }
 
-    fn unsafe_struct_client_update() -> Vec<u8> {
-        let mut update = EncoderV1::new();
-        update.write_var(1u32); // client count
-        update.write_var(0u32); // block count for this client
-        update.write_var(1u64 << 53); // unsafe client id
-        update.write_var(0u32); // clock
-        update.write_var(0u32); // delete-set client count
-        update.to_vec()
-    }
-
-    fn unsafe_awareness_frame() -> Vec<u8> {
-        let mut payload = EncoderV1::new();
-        payload.write_var(1u32); // client count
-        payload.write_var(1u64 << 53); // unsafe client id
-        payload.write_var(1u32); // clock
-        payload.write_string("{}");
-
-        let mut frame = EncoderV1::new();
-        frame.write_var(MSG_AWARENESS);
-        frame.write_buf(payload.to_vec());
-        frame.to_vec()
-    }
-
-    fn unsafe_step1_frame() -> Vec<u8> {
-        let mut sv = EncoderV1::new();
-        sv.write_var(1u32); // state-vector entry count
-        sv.write_var(1u64 << 53); // unsafe client id
-        sv.write_var(0u32); // clock
-
-        let mut frame = EncoderV1::new();
-        frame.write_var(MSG_SYNC);
-        frame.write_var(MSG_SYNC_STEP_1);
-        frame.write_buf(sv.to_vec());
-        frame.to_vec()
-    }
-
     #[test]
     fn classify_accepts_clean_single_messages() {
         assert_eq!(classify_message(&step1_frame()), 1);
@@ -500,51 +245,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn client_id_safe_integer_boundary() {
-        assert!(is_safe_client_id(0), "zero is fine");
-        assert!(
-            is_safe_client_id((1 << 53) - 1),
-            "2^53 - 1 is the max safe id"
-        );
-        assert!(!is_safe_client_id(1 << 53), "2^53 is unsafe");
-        assert!(!is_safe_client_id(1 << 63), "2^63 is unsafe");
-        assert!(!is_safe_client_id(u64::MAX), "u64::MAX is unsafe");
-    }
-
-    #[test]
-    fn wire_client_id_validation_rejects_unsafe_sync_update_clients() {
-        let update = unsafe_struct_client_update();
-        assert!(
-            validate_update_client_ids(&update).is_err(),
-            "raw unsafe update client id is rejected before yrs can mask it"
-        );
-
-        let frame = Message::Sync(SyncMessage::Update(update)).encode_v1();
-        assert_eq!(
-            classify_message(&frame),
-            0,
-            "unsafe sync frame is not relayable"
-        );
-        assert!(merged_doc_update(&frame).is_err());
-    }
-
-    #[test]
-    fn wire_client_id_validation_rejects_unsafe_awareness_and_step1_clients() {
-        assert!(
-            validate_frame_client_ids(&unsafe_awareness_frame()).is_err(),
-            "raw unsafe awareness client id is rejected"
-        );
-        assert_eq!(classify_message(&unsafe_awareness_frame()), 0);
-        assert!(awareness_client_ids_in(&unsafe_awareness_frame()).is_err());
-
-        assert!(
-            validate_frame_client_ids(&unsafe_step1_frame()).is_err(),
-            "raw unsafe state-vector client id is rejected"
-        );
-        assert_eq!(classify_message(&unsafe_step1_frame()), 0);
-    }
-
     #[test]
     fn merged_doc_update_extracts_and_skips_no_ops() {
         // A document update yields a delta that reconstructs the content.
@@ -582,18 +282,6 @@ mod tests {
         assert!(yrs::Update::decode_v1(&merged).is_ok());
     }
 
-    #[test]
-    fn awareness_client_ids_are_collected() {
-        assert_eq!(
-            awareness_client_ids_in(&awareness_frame(111)).unwrap(),
-            vec![111]
-        );
-        // A document frame has no awareness client ids.
-        assert!(awareness_client_ids_in(&update_frame("x"))
-            .unwrap()
-            .is_empty());
-    }
-
     #[test]
     fn update_readiness_and_pending_detect_a_causal_gap() {
         // Three sequential single-char inserts from one client: A, then B, then

data/lib/yrb_lite/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module YrbLite
-  VERSION = "0.1.0.beta6"
+  VERSION = "0.1.0.beta7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yrb-lite
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta6
+  version: 0.1.0.beta7
 platform: ruby
 authors:
 - JP Camara