https://github.com/toeverything/y-octo/blob/main/y-octo/yrs-is-unsafe/README.md#L16:~:text=release/yrs%2Dmem-,The%20source%20codes%3A,-mem_usage.rs

--->>>

https://github.com/toeverything/y-octo/blob/6d3c131f2df7295c54358f4bd9af23ea8e422615/y-octo/yrs-is-unsafe/README.md#L62:~:text=release/yrs%2Dmem-,The%20source%20codes%3A,-mem_usage.rs

Currently, the following code causes undefined behavior.

    #[test]
    fn test_inner_mut() {
        let five = Somr::new(5);
        fn add(a: &Somr<i32>, b: &Somr<i32>) {
            a.get_mut().map(|x| *x += *b.get().unwrap()).unwrap();
        }

        add(&five, &five);
        assert_eq!(five.get().copied().unwrap(), 10);
    }

The original fn get_mut(&self) -> Option<&mut T> is error-prone, as the compiler cannot prevent programmers from creating multiple mut ref to the same element. Making it unsafe could reduce the scope that needs to be audited.

• [x] map code clean #21
• [x] narrow Item::{left/right} type from Node to Somr<Item> #24
• [x] refactor map implementation #26
• [ ] make Item::Content inner easier to share, especially for Value::Read (perf)
• [ ] standardize Value::read(Content) for type content reading (perf/correctness)
• [ ] try separate map/list into branches (mem reduce)
• [ ] Wrapper Client/Clock in transparent struct for better custom logic and typecheck
• [ ] Update consumes [u8] instead of Vec<u8>

In yjs, sub doc is loaded in the following way:

let doc = new Y.Doc()
console.log('init main doc');

doc.on('subdocs', ({ loaded }) => {
  loaded.forEach(subdoc => {
    console.log('init subdoc provider');
    new SomethingProvider(subdoc.guid, subdoc)
  })
})

let subDoc = doc.getMap("map").get("some_sub_doc")
subDoc.on('synced', () => {
  console.log('synced');
  // when doc synced by provider, we can get sub doc's data
})
console.log('loading');
subDoc.load()

// exec workflow:
// init main doc -> loading -> init subdoc provider -> synced

In y-octo, we have implemented the parsing of sub doc identifiers in ydoc, this means that to add subdoc support to y-octo, what we need to do is:

• provide an API to allow doc to know its own synchronization status
• provide an API, pass in a doc instance, and use external implementation to load the doc binary from anywhere and apply update
• maintain a thread-safe weak reference to a subdoc instance inside doc

ybinary v1 is a binary format optimized for one-time network transmission.

It only supports overall reading and cannot know whether binary is damaged before the reading process goes wrong.

For specific analysis, please refer to this review:

https://github.com/toeverything/OctoBase/issues/383#issuecomment-1513577058

We need to design a binary format that supports partial reading and self-verification to store crdt state permanently and robustly

Currently we still use yrs as a baseline for binary compatible behavior, which increases testing complexity

I consider introducing a js runtime to provide the execution results of yjs as a reference benchmark during testing

It may be a convenient choice to directly use node to execute and output to stdio. Another option is to introduce quickjs or a similar streamlined js runtime, but this will increase compilation time and dependency complexity.

I will first investigate the feasibility of using nodejs to obtain execution results. This is the easiest way

### Tasks
- [x] https://github.com/toeverything/y-octo/pull/4
- [x] impl the function binding of node: #6
- [ ] test case for verify the data between yjs and y-octo-node #6

In the previous iteration, we have implemented most of lib0 and crdt logics:

• https://github.com/toeverything/OctoBase/issues/383
• https://github.com/toeverything/OctoBase/issues/403

We need to verify the correctness and consistency of it with yjs in our new Node.js sync server.