yrby 0.6.1 → 0.7.1

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.
 ///
@@ -297,13 +297,13 @@ impl RbDoc {
                 match msg {
                     Message::Sync(sync_msg) => match sync_msg {
                         SyncMessage::SyncStep1(sv) => {
-                            // Respond with SyncStep2 carrying only *integrated*
-                            // state. Never hand a peer un-integrable pending
-                            // structs: the peer would park the same pending
-                            // forever and the state-vector/content mismatch drives
-                            // endless resync traffic. (integrated_update is a no-op
-                            // fast path when nothing is pending.)
-                            let update = integrated_update(doc, &sv)?;
+                            // Respond with SyncStep2 carrying the doc's full
+                            // state, pending included, matching Y.js's
+                            // encodeStateAsUpdate. A peer parks a pending
+                            // struct exactly as this doc does and heals it
+                            // when the missing dependency arrives.
+                            let txn = doc.transact();
+                            let update = txn.encode_state_as_update_v1(&sv);
                             let response = Message::Sync(SyncMessage::SyncStep2(update));
                             Ok((0, 0, response.encode_v1()))
                         }

data/ext/yrby/src/protocol.rs

@@ -135,6 +135,27 @@ pub(crate) fn update_advances_doc(doc: &Doc, update_bytes: &[u8]) -> Result<bool
     let update = yrs::Update::decode_v1(update_bytes).map_err(|e| e.to_string())?;
     let has_deletes = !update.delete_set().is_empty();
 
+    // A merged update can hide an internal gap behind a Skip block, and
+    // blocks past the gap can still integrate (yrs plants a Skip hole in the
+    // store) when their origins don't need the missing range. That moves
+    // neither the doc's public state vector (yrs caps it at the first hole)
+    // nor pending: invisible to every comparison below, so genuinely novel
+    // content would report "doesn't advance": applied, acked, but never
+    // recorded or broadcast. The update's own state_vector() caps at its
+    // first Skip the same way, so any insertion past a non-zero cap reveals
+    // such a gap: conservatively report it as advancing (record it; a
+    // duplicate in the log is harmless, dropped content is not). Standard
+    // Yjs providers never emit these frames (a client's own updates and
+    // diffs are gap-free), so this guards crafted or pathologically merged
+    // input, not a hot path.
+    let capped = update.state_vector();
+    for (client, ranges) in update.insertions(true).iter() {
+        let cap = capped.get(client);
+        if cap > 0 && ranges.iter().any(|range| range.end > cap) {
+            return Ok(true);
+        }
+    }
+
     // Fast path: blocks beyond the doc's state vector are content the doc
     // lacks — the update advances, no probe needed. The common case (a novel
     // edit) exits here; only retries and ambiguous diffs pay for the probe.
@@ -663,6 +684,48 @@ mod tests {
         );
     }
 
+    #[test]
+    fn a_gappy_update_with_novel_post_hole_content_advances() {
+        // A merged update hiding an internal gap behind a Skip, whose
+        // post-hole blocks integrate anyway (their origins don't need the
+        // missing range). Integration plants a Skip hole, so neither the
+        // public state vector nor pending moves, before the hidden-gap
+        // check, the probe comparison reported genuinely novel content as
+        // "doesn't advance": update_ready? accepted it, the doc applied it,
+        // but it was never recorded or broadcast. Unreachable through
+        // standard Yjs providers (a client's own updates and diffs are
+        // gap-free); this is a crafted/hostile frame shape.
+        let a = Doc::new();
+        let t1 = a.get_or_insert_text("one");
+        t1.insert(&mut a.transact_mut(), 0, "first");
+        let u1 = a
+            .transact()
+            .encode_state_as_update_v1(&yrs::StateVector::default());
+        t1.insert(&mut a.transact_mut(), 5, " second"); // the future hole
+        let sv2 = a.transact().state_vector();
+        // Novel content on a DIFFERENT root: no dependency on the hole.
+        let t3 = a.get_or_insert_text("two");
+        t3.insert(&mut a.transact_mut(), 0, "third");
+        let u3 = a.transact().encode_state_as_update_v1(&sv2);
+
+        let server = Doc::new();
+        server
+            .transact_mut()
+            .apply_update(yrs::Update::decode_v1(&u1).unwrap())
+            .unwrap();
+        // The crafted frame: u1 + u3 merged, u2's range an internal Skip.
+        let gappy = yrs::merge_updates_v1([&u1, &u3]).unwrap();
+
+        assert!(
+            update_is_ready(&server, &gappy).unwrap(),
+            "sanity: the sync flow would accept and apply this frame"
+        );
+        assert!(
+            update_advances_doc(&server, &gappy).unwrap(),
+            "novel content hiding behind a Skip must be recorded, not dropped"
+        );
+    }
+
     // Build a causal gap: `first` inserts "a", `dependent` inserts "b" after it,
     // so `dependent` alone parks as pending on a doc that lacks `first`.
     fn gap_pair() -> (Vec<u8>, Vec<u8>) {

data/lib/generators/yrby/install/templates/document_channel.rb

@@ -29,7 +29,7 @@ class DocumentChannel < ApplicationCable::Channel
   # Everyone is denied until you fill this in. Wire it to your app's auth:
   # identify current_user on the cable connection, then check they may read
   # and write this document. Don't lean on on_change raising for access
-  # control — that path exists for store failures.
+  # control; that path exists for store failures.
   def authorized?(_document_key)
     false
   end

data/lib/generators/yrby/tables/tables_generator.rb

@@ -5,15 +5,15 @@ require "rails/generators/active_record"
 
 module Yrby
   module Generators
-    # `bin/rails generate yrby:tables` — the migration for the gem-owned
+    # `bin/rails generate yrby:tables`: the migration for the gem-owned
     # document models (Y::Document + Y::DocumentUpdate). Invoked by
     # yrby:install, and by other gems building on the same storage.
     #
     # Template notes (kept here, not in the emitted migration): state is
-    # 4.gigabytes - 1 (longblob on MySQL — a compacted snapshot is the whole
+    # 4.gigabytes - 1 (longblob on MySQL; a compacted snapshot is the whole
     # document; a 16 MB cap would break compaction) and payload is
     # 16.megabytes - 1 (one update can carry a big paste or a client's
-    # accumulated offline edits — the 64 KB default blob is too small).
+    # accumulated offline edits; the 64 KB default blob is too small).
     # The partial unique index's WHERE only keeps
     # key-only rows out of the index: uniqueness holds without it, since
     # unique indexes treat NULLs as distinct on every supported database,