yrby 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7e0200b53061315ddc075bbd337a5d9ead543f99617cac94d53180242a80bbd
-  data.tar.gz: 956ec491daabcafc73009e40df573e9c01e5b7587be9d3001d32a7b0a4092f01
+  metadata.gz: 80931cbbabc08011f5f8ac78dfcf92e648feaf39ef8338ba7abb77bd575bb231
+  data.tar.gz: 340e157cea8aeee6ab5013ca43571e74a8f01f514ee8172aad81e14c10cf55b6
 SHA512:
-  metadata.gz: afae1336b4e184f1ecf1d878202023123cee10fa7ea47642c7f6f2b7d48eee7201f2b2198aed217b08434228904178bddaf3d46058e6da7b5b27ad7450a0ef87
-  data.tar.gz: 48a7bd917201e4df0858a08ce0d1eab132fc160a507dc88bfcd1c390cae9a0a8b11a9132894e5f91889f946f69e4366455fb8257e0165c9f1d82da4c367547ed
+  metadata.gz: fe5ba9524856f360def8b53a942bc8142017cb87254344aaeab9b90d4006471d3f480db5c527e4563f031ebc25d9c504c3070d306308676e10f11127ac6695c7
+  data.tar.gz: ef2cf7df98eced8c39ad5059ff12d3dfbdd8fc6dbd22c949163cc074d1710add09b9c4adb9d4c4ca24fa957f1b5983578c9f38623a80b0a4172027da4505a3a9

data/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project aims
 to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.1] - 2026-08-19
+
+### Fixed
+
+- `Y::ProseMirror` and `Y::Tiptap` keep marks shared by adjacent text
+  runs open across them, the way ProseMirror's own serializer does:
+  bold then bold-italic renders as `<strong>a<em>b</em></strong>`, not
+  as two sibling `<strong>` wraps. A mark whose attributes differ
+  between runs never merges. Found by the new cross-renderer
+  verification, which checks the renderers against a live Tiptap
+  editor, `@tiptap/html`'s static `generateHTML`, `tiptap-php`,
+  Lexical's `$generateHtmlFromNodes`, and Payload CMS's
+  `convertLexicalToHTML` on a shared corpus.
+
 ## [0.7.0] - 2026-08-11
 
 ### Added

data/Cargo.lock

@@ -227,6 +227,15 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
+[[package]]
+name = "lexical-yjs-html"
+version = "0.1.1"
+dependencies = [
+ "serde_json",
+ "yjs-html-core",
+ "yrs",
+]
+
 [[package]]
 name = "libc"
 version = "0.2.180"
@@ -337,6 +346,15 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "prosemirror-yjs-html"
+version = "0.1.2"
+dependencies = [
+ "serde_json",
+ "yjs-html-core",
+ "yrs",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.43"
@@ -608,18 +626,26 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
+[[package]]
+name = "yjs-html-core"
+version = "0.1.1"
+dependencies = [
+ "serde_json",
+ "yrs",
+]
+
 [[package]]
 name = "yrby"
 version = "0.1.0"
 dependencies = [
+ "lexical-yjs-html",
  "magnus",
+ "prosemirror-yjs-html",
  "rb-sys",
  "rb-sys-env 0.1.2",
  "serde_json",
+ "yjs-html-core",
  "yrs",
- "yrs-html-core",
- "yrs-lexical-html",
- "yrs-prosemirror-html",
 ]
 
 [[package]]
@@ -640,32 +666,6 @@ dependencies = [
  "thiserror",
 ]
 
-[[package]]
-name = "yrs-html-core"
-version = "0.1.0"
-dependencies = [
- "serde_json",
- "yrs",
-]
-
-[[package]]
-name = "yrs-lexical-html"
-version = "0.1.0"
-dependencies = [
- "serde_json",
- "yrs",
- "yrs-html-core",
-]
-
-[[package]]
-name = "yrs-prosemirror-html"
-version = "0.1.0"
-dependencies = [
- "serde_json",
- "yrs",
- "yrs-html-core",
-]
-
 [[package]]
 name = "zmij"
 version = "1.0.14"

data/ext/yrby/Cargo.toml

@@ -14,9 +14,9 @@ magnus = "0.8"
 rb-sys = "0.9"
 yrs = { version = "0.27", features = ["sync"] }
 serde_json = "1.0"
-yrs-html-core = { path = "crates/html-core" }
-yrs-lexical-html = { path = "crates/lexical-html" }
-yrs-prosemirror-html = { path = "crates/prosemirror-html" }
+yjs-html-core = { path = "crates/html-core" }
+lexical-yjs-html = { path = "crates/lexical-html" }
+prosemirror-yjs-html = { path = "crates/prosemirror-html" }
 
 [dev-dependencies]
 rb-sys-env = "0.1"

data/ext/yrby/crates/html-core/Cargo.toml

@@ -1,14 +1,15 @@
 [package]
-name = "yrs-html-core"
-description = "Internal core for the yrs-*-html renderer crates; depend on those instead"
+name = "yjs-html-core"
+description = "Internal core for the lexical-yjs-html and prosemirror-yjs-html renderer crates; depend on those instead"
 repository = "https://github.com/jpcamara/yrby"
 readme = "README.md"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 rust-version = "1.85"
 authors = ["JP Camara <johnpcamara@gmail.com>"]
 license = "MIT"
-publish = false
+keywords = ["yjs", "crdt", "yrs", "html", "rendering"]
+categories = ["text-processing", "web-programming"]
 
 [dependencies]
 yrs = { version = "0.27", features = ["sync"] }

data/ext/yrby/crates/html-core/src/lib.rs

@@ -196,11 +196,7 @@ pub fn resolve_parts<F: Fn(&str) -> Option<String>>(
             }
         }
     }
-    if out.is_empty() {
-        None
-    } else {
-        Some(out)
-    }
+    if out.is_empty() { None } else { Some(out) }
 }
 
 /// An attribute reference on a node: rules say `:kind`; Lexical stores its own
@@ -384,7 +380,7 @@ fn parse_node_rule(name: &str, spec: &serde_json::Value) -> Result<NodeRule, Str
         Some(other) => {
             return Err(format!(
                 "rule for {name:?}: unknown content kind {other:?} (blocks|inline|none)"
-            ))
+            ));
         }
     };
     if spec
@@ -431,7 +427,7 @@ fn parse_attrs(
         Some(_) => {
             return Err(format!(
                 "rule for {name:?}: attrs must be an array of [name, template] pairs"
-            ))
+            ));
         }
     };
     for entry in entries {

data/ext/yrby/crates/lexical-html/Cargo.toml

@@ -1,16 +1,17 @@
 [package]
-name = "yrs-lexical-html"
+name = "lexical-yjs-html"
 description = "Render Lexical-shaped yrs documents to HTML, no browser or Node required"
 repository = "https://github.com/jpcamara/yrby"
 readme = "README.md"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 rust-version = "1.85"
 authors = ["JP Camara <johnpcamara@gmail.com>"]
 license = "MIT"
-publish = false
+keywords = ["yjs", "crdt", "lexical", "html", "yrs"]
+categories = ["text-processing", "web-programming"]
 
 [dependencies]
 yrs = { version = "0.27", features = ["sync"] }
 serde_json = "1.0"
-yrs-html-core = { path = "../html-core" }
+yjs-html-core = { path = "../html-core", version = "0.1.1" }

data/ext/yrby/crates/lexical-html/src/lib.rs

@@ -39,7 +39,7 @@
 //! with the unwrapped span. Case-transform format bits are never rendered
 //! (their text-transform style is outside the sanitize whitelist).
 //!
-//! Custom nodes: rules are registered by `__type` (see `yrs-html-core`) and
+//! Custom nodes: rules are registered by `__type` (see `yjs-html-core`) and
 //! consulted before the built-in arms, so they extend the schema or override
 //! a built-in. Declarative rules render here; callback rules emit
 //! `Segment::Deferred` for the caller to fill in after the render.
@@ -50,8 +50,8 @@
 mod readme_examples {}
 
 // The full rules surface, re-exported: depend on this crate alone;
-// yrs-html-core is an internal implementation crate.
-pub use yrs_html_core::*;
+// yjs-html-core is an internal implementation crate.
+pub use yjs_html_core::*;
 use yrs::types::text::YChange;
 use yrs::{
     Any, GetString, Map, Out, ReadTxn, Text, Xml, XmlElementRef, XmlFragment, XmlFragmentRef,
@@ -130,7 +130,7 @@ pub fn render_segments<T: ReadTxn>(
 /// callback rules, segments always flatten.
 pub fn render<T: ReadTxn>(txn: &T, fragment: &XmlFragmentRef) -> Option<String> {
     render_segments(txn, fragment, &Rules::empty()).map(|segs| {
-        yrs_html_core::flatten(segs)
+        yjs_html_core::flatten(segs)
             .into_html()
             .expect("no callback rules registered")
     })
@@ -773,11 +773,7 @@ fn lexxy_style(style: &str) -> Option<String> {
             css.push(';');
         }
     }
-    if css.is_empty() {
-        None
-    } else {
-        Some(css)
-    }
+    if css.is_empty() { None } else { Some(css) }
 }
 
 /// `link` / `autolink`: Lexxy's sanitize keeps only `href` and `title`
@@ -1301,7 +1297,7 @@ mod tests {
         let txn = doc.transact();
         let frag = txn.get_xml_fragment("root").unwrap();
         let segs = render_segments(&txn, &frag, &rules).unwrap();
-        let html = yrs_html_core::flatten(segs).into_html().unwrap();
+        let html = yjs_html_core::flatten(segs).into_html().unwrap();
         assert_eq!(
             html,
             "<p><a class=\"app-link\" href=\"https://x.example\">site</a>\

data/ext/yrby/crates/prosemirror-html/Cargo.toml

@@ -1,16 +1,17 @@
 [package]
-name = "yrs-prosemirror-html"
+name = "prosemirror-yjs-html"
 description = "Render ProseMirror-shaped yrs documents to HTML, no browser or Node required"
 repository = "https://github.com/jpcamara/yrby"
 readme = "README.md"
-version = "0.1.0"
+version = "0.1.2"
 edition = "2024"
 rust-version = "1.85"
 authors = ["JP Camara <johnpcamara@gmail.com>"]
 license = "MIT"
-publish = false
+keywords = ["yjs", "crdt", "prosemirror", "tiptap", "html"]
+categories = ["text-processing", "web-programming"]
 
 [dependencies]
 yrs = { version = "0.27", features = ["sync"] }
 serde_json = "1.0"
-yrs-html-core = { path = "../html-core" }
+yjs-html-core = { path = "../html-core", version = "0.1.1" }

data/ext/yrby/crates/prosemirror-html/src/lib.rs

@@ -42,10 +42,10 @@
 mod readme_examples {}
 
 // The full rules surface, re-exported: depend on this crate alone;
-// yrs-html-core is an internal implementation crate.
-pub use yrs_html_core::*;
-use yrs::types::text::YChange;
+// yjs-html-core is an internal implementation crate.
+pub use yjs_html_core::*;
 use yrs::types::Attrs;
+use yrs::types::text::YChange;
 use yrs::{
     Any, GetString, Out, ReadTxn, Text, Xml, XmlElementRef, XmlFragment, XmlFragmentRef, XmlOut,
     XmlTextRef,
@@ -105,7 +105,7 @@ pub fn render_segments<T: ReadTxn>(
 /// callback rules, segments always flatten.
 pub fn render<T: ReadTxn>(txn: &T, fragment: &XmlFragmentRef) -> Option<String> {
     render_segments(txn, fragment, &Rules::empty()).map(|segs| {
-        yrs_html_core::flatten(segs)
+        yjs_html_core::flatten(segs)
             .into_html()
             .expect("no callback rules registered")
     })
@@ -605,102 +605,120 @@ fn render_rule_inline<T: ReadTxn>(
     em.push('>');
 }
 
-/// Emit each formatted run of a Y.XmlText.
+/// Emit the formatted runs of a Y.XmlText, keeping marks shared by
+/// adjacent runs open across them: `bold` then `bold italic` renders as
+/// `<strong>a<em>b</em></strong>`, the way the editor's DOM serializer
+/// keeps an active mark open into the next run, not as two sibling
+/// `<strong>` wraps. Sharing is by identical opening tag, so a mark whose
+/// attributes differ between runs (a different href, a different style)
+/// never merges.
 fn render_text_runs<T: ReadTxn>(txn: &T, t: &XmlTextRef, em: &mut Emitter, rules: &Rules) {
+    let mut open: Vec<(String, String)> = Vec::new();
     for d in t.diff(txn, YChange::identity) {
         if let Out::Any(Any::String(s)) = &d.insert {
-            em.push_str(&render_run(s, d.attributes.as_deref(), rules));
+            let stack = run_stack(d.attributes.as_deref(), rules);
+            let shared = open
+                .iter()
+                .zip(stack.iter())
+                .take_while(|(a, b)| a == b)
+                .count();
+            for (_, close) in open.split_off(shared).into_iter().rev() {
+                em.push_str(&close);
+            }
+            for (open_tag, _) in &stack[shared..] {
+                em.push_str(open_tag);
+            }
+            open = stack;
+            em.push_str(&escape_text(s));
         }
     }
+    for (_, close) in open.into_iter().rev() {
+        em.push_str(&close);
+    }
 }
 
-/// Wrap one text run in its marks, nesting innermost-first:
-/// subscript/superscript, highlight, underline, strike, italic, bold, a
-/// textStyle span, then link on the outside. `code` renders alone among the
-/// formatting marks (Tiptap's Code mark excludes them all), but a link still
-/// wraps it — Tiptap can't produce code+link, prosemirror-schema-basic can,
-/// and dropping the link would lose the href.
-///
-/// A registered mark rule claims its stored name from the built-in wraps
-/// (overriding it) and wraps outside everything; multiple custom marks nest
-/// alphabetically by name, so output is deterministic regardless of
-/// registration order. Overriding replaces only the markup: a claimed
-/// `code` still excludes the other formatting marks, and a claimed
-/// formatting mark stays excluded from a code run.
-fn render_run(text: &str, marks: Option<&Attrs>, rules: &Rules) -> String {
-    let mut html = escape_text(text);
+/// The run's mark wrappers as (open tag, close tag) pairs, outermost
+/// first: registered custom marks (reverse-alphabetical, so the last name
+/// alphabetically is outermost), link, the textStyle span, then bold,
+/// italic, strike, underline, highlight, and innermost
+/// subscript/superscript — or `code` alone in their place.
+fn run_stack(marks: Option<&Attrs>, rules: &Rules) -> Vec<(String, String)> {
     let Some(marks) = marks else {
-        return html;
+        return Vec::new();
     };
+    // Innermost first, reversed at the end.
+    let mut stack: Vec<(String, String)> = Vec::new();
+    let tag = |t: &str| (format!("<{t}>"), format!("</{t}>"));
     if has(marks, &["code"], rules) {
-        html = wrap(html, "code");
+        stack.push(tag("code"));
     } else if !marks.contains_key("code") {
         // (A claimed `code` lands here too — on the run, but skipped by the
-        // else-if: the rule replaces the wrap, via wrap_custom_marks below,
+        // else-if: the rule replaces the wrap, via the custom marks below,
         // and code's exclusivity over the other formatting marks holds.)
         if has(marks, &["subscript", "sub"], rules) {
-            html = wrap(html, "sub");
+            stack.push(tag("sub"));
         } else if has(marks, &["superscript", "sup"], rules) {
-            html = wrap(html, "sup");
+            stack.push(tag("sup"));
         }
         if has(marks, &["highlight"], rules) {
-            html = wrap(html, "mark");
+            stack.push(tag("mark"));
         }
         if has(marks, &["underline", "u"], rules) {
-            html = wrap(html, "u");
+            stack.push(tag("u"));
         }
         if has(marks, &["strike", "s"], rules) {
-            html = wrap(html, "s");
+            stack.push(tag("s"));
         }
         if has(marks, &["italic", "em"], rules) {
-            html = wrap(html, "em");
+            stack.push(tag("em"));
         }
         if has(marks, &["bold", "strong"], rules) {
-            html = wrap(html, "strong");
+            stack.push(tag("strong"));
         }
         if !rules.marks.contains_key("textStyle") {
             if let Some(Any::Map(style)) = marks.get("textStyle") {
                 let css = text_style_css(style);
                 if !css.is_empty() {
-                    html = format!("<span style=\"{}\">{html}</span>", escape_attr(&css));
+                    stack.push((
+                        format!("<span style=\"{}\">", escape_attr(&css)),
+                        "</span>".to_string(),
+                    ));
                 }
             }
         }
     }
     if !rules.marks.contains_key("link") {
         if let Some(Any::Map(link)) = marks.get("link") {
-            html = wrap_link(html, link);
+            stack.push((link_open(link), "</a>".to_string()));
         }
     }
     if !rules.marks.is_empty() {
-        html = wrap_custom_marks(html, marks, rules);
-    }
-    html
-}
-
-/// Apply the run's registered custom marks, outermost of everything. A code
-/// run keeps its exclusivity under overrides too: only the `code` and `link`
-/// claims themselves may wrap it, matching what the built-in wraps allow —
-/// otherwise overriding a formatting mark would change which marks render on
-/// a code run, not just their markup.
-fn wrap_custom_marks(html: String, marks: &Attrs, rules: &Rules) -> String {
-    let code = marks.contains_key("code");
-    let mut names: Vec<&str> = rules
-        .marks
-        .keys()
-        .map(String::as_str)
-        .filter(|name| marks.contains_key(*name))
-        .filter(|name| !code || matches!(*name, "code" | "link"))
-        .collect();
-    names.sort_unstable();
-    let mut html = html;
-    for name in names {
-        html = wrap_custom_mark(html, &rules.marks[name], marks.get(name));
+        let code = marks.contains_key("code");
+        let mut names: Vec<&str> = rules
+            .marks
+            .keys()
+            .map(String::as_str)
+            .filter(|name| marks.contains_key(*name))
+            .filter(|name| !code || matches!(*name, "code" | "link"))
+            .collect();
+        names.sort_unstable();
+        for name in names {
+            let rule = &rules.marks[name];
+            stack.push((
+                custom_mark_open(rule, marks.get(name)),
+                format!("</{}>", rule.tag),
+            ));
+        }
     }
-    html
+    stack.reverse();
+    stack
 }
 
-fn wrap_custom_mark(inner: String, rule: &MarkRule, value: Option<&Any>) -> String {
+/// The opening tag for a registered custom mark. Custom marks sit outside
+/// everything; a code run keeps its exclusivity under overrides too: only
+/// the `code` and `link` claims themselves may wrap it, matching what the
+/// built-in wraps allow.
+fn custom_mark_open(rule: &MarkRule, value: Option<&Any>) -> String {
     let mut out = String::from("<");
     out.push_str(&rule.tag);
     for (attr, parts) in &rule.attrs {
@@ -709,14 +727,10 @@ fn wrap_custom_mark(inner: String, rule: &MarkRule, value: Option<&Any>) -> Stri
             out.push_str(attr);
             out.push_str("=\"");
             out.push_str(&escape_attr(&v));
-            out.push('"');
+            out.push('\"');
         }
     }
     out.push('>');
-    out.push_str(&inner);
-    out.push_str("</");
-    out.push_str(&rule.tag);
-    out.push('>');
     out
 }
 
@@ -790,7 +804,7 @@ fn hex_to_rgb(value: &str) -> Option<String> {
 
 /// `<a>` with Tiptap's attribute order (target, rel, class, href, title),
 /// skipping any that are absent or null.
-fn wrap_link(inner: String, link: &std::collections::HashMap<String, Any>) -> String {
+fn link_open(link: &std::collections::HashMap<String, Any>) -> String {
     let mut out = String::from("<a");
     for key in ["target", "rel", "class", "href", "title"] {
         if let Some(Any::String(v)) = link.get(key) {
@@ -802,8 +816,6 @@ fn wrap_link(inner: String, link: &std::collections::HashMap<String, Any>) -> St
         }
     }
     out.push('>');
-    out.push_str(&inner);
-    out.push_str("</a>");
     out
 }
 
@@ -822,10 +834,6 @@ fn render_image<T: ReadTxn>(txn: &T, e: &XmlElementRef, em: &mut Emitter) {
     em.push('>');
 }
 
-fn wrap(inner: String, tag: &str) -> String {
-    format!("<{tag}>{inner}</{tag}>")
-}
-
 /// A mark is present and not claimed by a registered rule for that stored
 /// name (a rule overrides the built-in wrap).
 fn has(marks: &Attrs, keys: &[&str], rules: &Rules) -> bool {
@@ -903,10 +911,44 @@ mod tests {
         a
     }
 
+    /// Single-run rendering for the mark unit tests: the run's full
+    /// open/close stack around the escaped text.
+    fn render_run(text: &str, marks: Option<&Attrs>, rules: &Rules) -> String {
+        let stack = run_stack(marks, rules);
+        let mut html: String = stack.iter().map(|(open, _)| open.as_str()).collect();
+        html.push_str(&escape_text(text));
+        for (_, close) in stack.iter().rev() {
+            html.push_str(close);
+        }
+        html
+    }
+
     fn run(text: &str, marks: Option<&Attrs>) -> String {
         render_run(text, marks, &Rules::empty())
     }
 
+    #[test]
+    fn adjacent_runs_share_their_common_outer_marks() {
+        use yrs::{Text, XmlFragment};
+        let doc = Doc::new();
+        let f = doc.get_or_insert_xml_fragment("default");
+        let mut txn = doc.transact_mut();
+        let p = f.insert(&mut txn, 0, XmlElementPrelim::empty("paragraph"));
+        let t = p.insert(&mut txn, 0, XmlTextPrelim::new(""));
+        let bold = marks(&["bold"]);
+        let bold_em = marks(&["bold", "italic"]);
+        t.insert_with_attributes(&mut txn, 0, "nested ", bold.clone());
+        t.insert_with_attributes(&mut txn, 7, "deep", bold_em);
+        t.insert_with_attributes(&mut txn, 11, " tail", bold);
+        drop(txn);
+        let txn = doc.transact();
+        assert_eq!(
+            render(&txn, &f).unwrap(),
+            "<p><strong>nested <em>deep</em> tail</strong></p>",
+            "shared outer marks stay open across adjacent runs"
+        );
+    }
+
     /// Core rendering of the captured Tiptap document, pinned as a golden
     /// (`.core.html`). The task list renders through the unknown-container
     /// fallback here (unwrapped children); the external truth — byte parity
@@ -1236,7 +1278,7 @@ mod tests {
         let txn = doc.transact();
         let segs = render_segments(&txn, &frag, &rules).unwrap();
         assert_eq!(
-            yrs_html_core::flatten(segs).into_html().unwrap(),
+            yjs_html_core::flatten(segs).into_html().unwrap(),
             "<aside class=\"callout callout--warning\"><div class=\"para\">careful</div></aside>"
         );
     }
@@ -1294,7 +1336,7 @@ mod tests {
         }
         let txn = doc.transact();
         let map = collect_node_types(&txn, &frag).unwrap();
-        let json = yrs_html_core::type_map_json(&map, |ty| {
+        let json = yjs_html_core::type_map_json(&map, |ty| {
             if is_builtin(ty) {
                 Some("builtin")
             } else {

data/ext/yrby/src/lib.rs

@@ -9,14 +9,14 @@ use yrs::{Doc, GetString, ReadTxn, Transact};
 
 mod protocol;
 mod read;
+use lexical_yjs_html as lexical_html;
+use prosemirror_yjs_html as prosemirror_html;
 use protocol::{
     classify_message, has_pending, integrated_update, merged_doc_update, update_advances_doc,
     update_is_ready,
 };
 use render_rules::{Rules, Segment};
-pub(crate) use yrs_html_core as render_rules;
-use yrs_lexical_html as lexical_html;
-use yrs_prosemirror_html as prosemirror_html;
+pub(crate) use yjs_html_core as render_rules;
 
 /// Wrapper around yrs Doc.
 ///

data/lib/y/version.rb

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

data/lib/y.rb

@@ -20,5 +20,5 @@ require_relative "y/decoder"
 module Y
   # Doc, Error, and the protocol module functions are defined in the Rust
   # extension. The ActionCable integration (Y::ActionCable::Sync) lives in the
-  # separate `yrby-actioncable` gem; require "y/action_cable".
+  # `yrby-rails` gem; require "y/action_cable".
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yrby
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - JP Camara