feat(y-octo): import y-octo monorepo (#11750)

packages/common/y-octo/utils/fuzz/.gitignore

@@ -0,0 +1,4 @@
+target
+corpus
+artifacts
+coverage

packages/common/y-octo/utils/fuzz/Cargo.toml

@@ -0,0 +1,88 @@
+[package]
+edition = "2021"
+name    = "y-octo-fuzz"
+publish = false
+version = "0.0.0"
+
+  [package.metadata]
+  cargo-fuzz = true
+
+[dependencies]
+lib0          = "=0.16.10"
+libfuzzer-sys = "0.4"
+rand          = "0.9"
+rand_chacha   = "0.9"
+yrs           = "=0.23.0"
+
+y-octo-utils = { path = "..", features = ["fuzz"] }
+
+  [dependencies.y-octo]
+  path = "../../core"
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[profile.release]
+debug = 1
+
+[[bin]]
+doc  = false
+name = "codec_doc_any_struct"
+path = "fuzz_targets/codec_doc_any_struct.rs"
+test = false
+
+[[bin]]
+doc  = false
+name = "codec_doc_any"
+path = "fuzz_targets/codec_doc_any.rs"
+test = false
+
+[[bin]]
+doc  = false
+name = "decode_bytes"
+path = "fuzz_targets/decode_bytes.rs"
+test = false
+
+[[bin]]
+doc  = false
+name = "ins_del_text"
+path = "fuzz_targets/ins_del_text.rs"
+test = false
+
+[[bin]]
+doc  = false
+name = "sync_message"
+path = "fuzz_targets/sync_message.rs"
+test = false
+
+[[bin]]
+doc  = false
+name = "i32_decode"
+path = "fuzz_targets/i32_decode.rs"
+test = false
+
+[[bin]]
+doc  = false
+name = "i32_encode"
+path = "fuzz_targets/i32_encode.rs"
+test = false
+
+[[bin]]
+doc  = false
+name = "u64_decode"
+path = "fuzz_targets/u64_decode.rs"
+test = false
+
+
+[[bin]]
+doc  = false
+name = "u64_encode"
+path = "fuzz_targets/u64_encode.rs"
+test = false
+
+[[bin]]
+doc  = false
+name = "apply_update"
+path = "fuzz_targets/apply_update.rs"
+test = false

packages/common/y-octo/utils/fuzz/fuzz_targets/apply_update.rs

@@ -0,0 +1,51 @@
+#![no_main]
+
+use std::collections::HashSet;
+
+use libfuzzer_sys::fuzz_target;
+use y_octo_utils::{
+  gen_nest_type_from_nest_type, gen_nest_type_from_root, CRDTParam, ManipulateSource, OpType,
+  OpsRegistry, YrsNestType,
+};
+use yrs::Transact;
+
+fuzz_target!(|crdt_params: Vec<CRDTParam>| {
+  let mut doc = yrs::Doc::new();
+  let mut cur_crdt_nest_type: Option<YrsNestType> = None;
+  let ops_registry = OpsRegistry::new();
+  let mut key_set = HashSet::<String>::new();
+  for crdt_param in crdt_params {
+    if key_set.contains(&crdt_param.key) {
+      continue;
+    }
+
+    key_set.insert(crdt_param.key.clone());
+    match crdt_param.op_type {
+      OpType::HandleCurrent => {
+        if cur_crdt_nest_type.is_some() {
+          ops_registry.operate_yrs_nest_type(&doc, cur_crdt_nest_type.clone().unwrap(), crdt_param);
+        }
+      }
+      OpType::CreateCRDTNestType => {
+        cur_crdt_nest_type = match cur_crdt_nest_type {
+          None => gen_nest_type_from_root(&mut doc, &crdt_param),
+          Some(mut nest_type) => match crdt_param.manipulate_source {
+            ManipulateSource::CurrentNestType => Some(nest_type),
+            ManipulateSource::NewNestTypeFromYDocRoot => {
+              gen_nest_type_from_root(&mut doc, &crdt_param)
+            }
+            ManipulateSource::NewNestTypeFromCurrent => {
+              gen_nest_type_from_nest_type(&mut doc, crdt_param.clone(), &mut nest_type)
+            }
+          },
+        };
+      }
+    };
+  }
+
+  let trx = doc.transact_mut();
+  let binary_from_yrs = trx.encode_update_v1();
+  let doc = y_octo::Doc::try_from_binary_v1(&binary_from_yrs).unwrap();
+  let binary = doc.encode_update_v1().unwrap();
+  assert_eq!(binary, binary_from_yrs);
+});

packages/common/y-octo/utils/fuzz/fuzz_targets/codec_doc_any.rs

@@ -0,0 +1,17 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use y_octo::{Any, CrdtRead, CrdtWrite, RawDecoder, RawEncoder};
+
+fuzz_target!(|data: &[u8]| {
+  if let Ok(any) = Any::read(&mut RawDecoder::new(data)) {
+    // ensure decoding and re-encoding results has same result
+    let mut buffer = RawEncoder::default();
+    if let Err(e) = any.write(&mut buffer) {
+      panic!("Failed to write message: {:?}, {:?}", any, e);
+    }
+    if let Ok(any2) = Any::read(&mut RawDecoder::new(&buffer.into_inner())) {
+      assert_eq!(any, any2);
+    }
+  }
+});

packages/common/y-octo/utils/fuzz/fuzz_targets/codec_doc_any_struct.rs

@@ -0,0 +1,43 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use rand::{distr::Alphanumeric, Rng};
+use y_octo::{Any, CrdtRead, CrdtWrite, RawDecoder, RawEncoder};
+
+fn get_random_string() -> String {
+  rand::rng()
+    .sample_iter(&Alphanumeric)
+    .take(7)
+    .map(char::from)
+    .collect()
+}
+
+fuzz_target!(|data: Vec<Any>| {
+  {
+    let any = Any::Object(
+      data
+        .iter()
+        .map(|a| (get_random_string(), a.clone()))
+        .collect(),
+    );
+
+    let mut buffer = RawEncoder::default();
+    if let Err(e) = any.write(&mut buffer) {
+      panic!("Failed to write message: {:?}, {:?}", any, e);
+    }
+    if let Ok(any2) = Any::read(&mut RawDecoder::new(&buffer.into_inner())) {
+      assert_eq!(any, any2);
+    }
+  }
+
+  {
+    let any = Any::Array(data);
+    let mut buffer = RawEncoder::default();
+    if let Err(e) = any.write(&mut buffer) {
+      panic!("Failed to write message: {:?}, {:?}", any, e);
+    }
+    if let Ok(any2) = Any::read(&mut RawDecoder::new(&buffer.into_inner())) {
+      assert_eq!(any, any2);
+    }
+  }
+});

packages/common/y-octo/utils/fuzz/fuzz_targets/decode_bytes.rs

@@ -0,0 +1,11 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use y_octo::{read_var_buffer, read_var_i32, read_var_string, read_var_u64};
+
+fuzz_target!(|data: Vec<u8>| {
+  let _ = read_var_i32(&data);
+  let _ = read_var_u64(&data);
+  let _ = read_var_buffer(&data);
+  let _ = read_var_string(&data);
+});

packages/common/y-octo/utils/fuzz/fuzz_targets/i32_decode.rs

@@ -0,0 +1,18 @@
+#![no_main]
+
+use lib0::encoding::Write;
+use libfuzzer_sys::fuzz_target;
+use y_octo::{read_var_i32, write_var_i32};
+
+fuzz_target!(|data: Vec<i32>| {
+  for i in data {
+    let mut buf1 = Vec::new();
+    write_var_i32(&mut buf1, i).unwrap();
+
+    let mut buf2 = Vec::new();
+    buf2.write_var(i);
+
+    assert_eq!(read_var_i32(&buf1).unwrap().1, i);
+    assert_eq!(read_var_i32(&buf2).unwrap().1, i);
+  }
+});

packages/common/y-octo/utils/fuzz/fuzz_targets/i32_encode.rs

@@ -0,0 +1,17 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use y_octo::write_var_i32;
+
+fuzz_target!(|data: Vec<i32>| {
+  use lib0::encoding::Write;
+
+  for i in data {
+    let mut buf1 = Vec::new();
+    write_var_i32(&mut buf1, i).unwrap();
+    let mut buf2 = Vec::new();
+    buf2.write_var(i);
+
+    assert_eq!(buf1, buf2);
+  }
+});

packages/common/y-octo/utils/fuzz/fuzz_targets/ins_del_text.rs

@@ -0,0 +1,34 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha20Rng;
+use y_octo::*;
+
+fuzz_target!(|seed: u64| {
+  // println!("seed: {}", seed);
+  let doc = Doc::with_client(1);
+  let mut rand = ChaCha20Rng::seed_from_u64(seed);
+  let mut text = doc.get_or_create_text("test").unwrap();
+  text.insert(0, "This is a string with length 32.").unwrap();
+
+  let iteration = 20;
+  let mut len = 32;
+
+  for i in 0..iteration {
+    let mut text = text.clone();
+    let ins = i % 2 == 0;
+    let pos = rand.random_range(0..if ins { text.len() } else { len / 2 });
+    if ins {
+      let str = format!("hello {i}");
+      text.insert(pos, &str).unwrap();
+      len += str.len() as u64;
+    } else {
+      text.remove(pos, 6).unwrap();
+      len -= 6;
+    }
+  }
+
+  assert_eq!(text.to_string().len(), len as usize);
+  assert_eq!(text.len(), len);
+});

packages/common/y-octo/utils/fuzz/fuzz_targets/sync_message.rs

@@ -0,0 +1,20 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use y_octo::{read_sync_message, write_sync_message};
+
+fuzz_target!(|data: &[u8]| {
+  let result = read_sync_message(data);
+
+  if let Ok((_, msg)) = result {
+    // ensure decoding and re-encoding results has same result
+    let mut buffer = Vec::new();
+    if let Err(e) = write_sync_message(&mut buffer, &msg) {
+      panic!("Failed to write message: {:?}, {:?}", msg, e);
+    }
+    let result = read_sync_message(&buffer);
+    if let Ok((_, msg2)) = result {
+      assert_eq!(msg, msg2);
+    }
+  }
+});

packages/common/y-octo/utils/fuzz/fuzz_targets/u64_decode.rs

@@ -0,0 +1,18 @@
+#![no_main]
+
+use lib0::encoding::Write;
+use libfuzzer_sys::fuzz_target;
+use y_octo::{read_var_u64, write_var_u64};
+
+fuzz_target!(|data: Vec<u64>| {
+  for i in data {
+    let mut buf1 = Vec::new();
+    write_var_u64(&mut buf1, i).unwrap();
+
+    let mut buf2 = Vec::new();
+    buf2.write_var(i);
+
+    assert_eq!(read_var_u64(&buf1).unwrap().1, i);
+    assert_eq!(read_var_u64(&buf2).unwrap().1, i);
+  }
+});

packages/common/y-octo/utils/fuzz/fuzz_targets/u64_encode.rs

@@ -0,0 +1,17 @@
+#![no_main]
+
+use lib0::encoding::Write;
+use libfuzzer_sys::fuzz_target;
+use y_octo::write_var_u64;
+
+fuzz_target!(|data: Vec<u64>| {
+  for i in data {
+    let mut buf1 = Vec::new();
+    buf1.write_var(i);
+
+    let mut buf2 = Vec::new();
+    write_var_u64(&mut buf2, i).unwrap();
+
+    assert_eq!(buf1, buf2);
+  }
+});