yrby 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c53c83185ba046ddbcb6b232953af9aa2f52f883120aff8bb2fed8867f247df
-  data.tar.gz: 6a09a5541cca754d6ff838feb82838ce881d8fea144fed692031f7c957c9850b
+  metadata.gz: ba28bef094ec97908a5ce4b01a61aedbbbcd49585c88a47acfbcfe0dab02c5be
+  data.tar.gz: dae39a894e92836681c0aa73dc54201aecf1d3fa68eaac38496e420579d760b3
 SHA512:
-  metadata.gz: d44fb5bb2a723b6a0dcf7ac6fd3bc248bd58f1401fe2e62009a214148f4a7b1ef1586d0d25585b39d291667eff04d6c66e911c7cdb5dec4968a0f3192b70a85c
-  data.tar.gz: 74da78ebc395e44cbdc9f32dcc51a239b7ea312de24f5ac64ec47db41bc784b47a53425afc83b948d36c9bf1b11922a3f9f3aa6615dcbac72a77759abe046ccc
+  metadata.gz: de4dedd7b4eb4e14e343b83b20007587cd129cbc0f42ff03f21118043ebced3853b9a2e2c51e77688ba1b8665e058422e24d1cc18d7acfd85fd6c99e435b43b9
+  data.tar.gz: 93291be948f34edc50c98266e554bd41a2beb7f8e74b1aeab87b19dc41efed425603f0634cefd117f24077b7d4fecf967b3ff4e40614b2276f2ccb40e85b5dc6

data/CHANGELOG.md

@@ -4,7 +4,80 @@ 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).
 
-## [Unreleased]
+## [0.6.1] - 2026-08-04
+
+### Fixed
+
+- `Y::Lexxy` emits the attachment tag the node was created with instead of
+  a hardcoded `<action-text-attachment>`. Lexxy makes the tag configurable
+  (`Lexxy.configure`'s `attachmentTagName`, paired with
+  `ActionText::Attachment.tag_name` in Rails), and each attachment node
+  stores its tag, so a custom-tag app's rendered HTML now matches its
+  editor. A stored value that doesn't look like a tag name falls back to
+  the default; documents from before the tag was stored render unchanged.
+
+## [0.6.0] - 2026-07-11
+
+### Added
+
+- **Custom render rules for `Y::Lexical` and `Y::ProseMirror`.** Both
+  renderers now take a block registering rules per node type —
+  `rules.node "callout", tag: "aside"` for markup-as-data, a Ruby block for
+  logic — plus `nodes:`/`marks:` keywords as the equivalent data form, to
+  render node types the pinned schemas don't know or to override how a
+  built-in renders.
+  Declarative rules (`tag`/`attrs`/`text`/`contains`, with templates mixing
+  literals and attribute references) render natively at full speed. Callback
+  rules run a Ruby block per node, receiving its type, attributes,
+  already-rendered children, and `child_types` (its element/block children by
+  type — the structural facts behind gallery counts and nested-list classes).
+  The block runs after the document read has finished, never while the doc is
+  locked, so it can safely read or write the same doc. Blocks are proven
+  sufficient for whole schemas: the gem's own editor schemas (`Y::Lexxy`,
+  `Y::Tiptap`) ship through this API, and the fixture tests hold their
+  output byte-identical to a live editor's. With no callback rules the
+  render path is unchanged, byte for byte. See "Custom nodes and marks" in
+  the README.
+- **`Y::Lexical#node_types` / `Y::ProseMirror#node_types` — schema
+  discovery.** Ask a real document which node types it holds and what they
+  look like: counts, attribute names as stored, child types, whether text
+  runs appear, and whether a builtin or one of your rules already handles
+  each ("handled" nil marks what still needs a rule). Editors store names
+  you'd never guess; this is how you find them.
+- `Y::RenderRules.escape_text` / `escape_attr` — the exact escaping the
+  native renderers use, for blocks that build markup from stored values
+  (ERB's `html_escape` also rewrites apostrophes, which breaks byte parity
+  with editor output).
+
+### Changed
+
+- **Lexical rendering is now two classes: `Y::Lexical` (core Lexical) and
+  `Y::Lexxy` (core plus the Lexxy schema as render rules).** Stock Lexical
+  has no canonical serializer, so the editor-specific class carries the
+  editor's name — `Y::Lexxy.new(doc).to_html` is the byte-parity call for
+  Lexxy/Rails apps, and `Y::Lexical` is the base any other Lexical editor
+  extends with its own rules. The
+  native side renders core structure — paragraphs, headings, quotes, code,
+  lists, tables, links, the full text-format model. Lexxy's own node types
+  (attachments, galleries, `early_escape_code`, `horizontal_divider`) and its
+  decorations of core nodes (the table figure wrapper, header-cell styling,
+  the nested-list-item class) are rules applied beneath the app's, on the
+  same extension API — the gem's Lexxy support is the API's first consumer.
+  Output is unchanged: the fixture tests still hold `to_html` byte-identical
+  to a live editor's serialized value, now through the extension path. An
+  unknown Lexical container also degrades better: its block children render
+  without an invented wrapper instead of being dropped.
+- **ProseMirror rendering gets the same split: `Y::ProseMirror` (core
+  ProseMirror) and `Y::Tiptap` (core plus Tiptap's extension nodes as render
+  rules).** `Y::Tiptap.new(doc).to_html` is the byte-parity call for Tiptap
+  apps. The native side renders prosemirror-schema-basic plus the
+  prosemirror-tables family; Tiptap's extension nodes — task lists, mentions,
+  the details family — are `Y::Tiptap::NODES` rules. Marks stay native in the
+  base class: mark rendering (nesting order, `textStyle` CSS, `code`
+  exclusivity) runs through text-run machinery node rules don't reach, so
+  `Y::ProseMirror` still renders Tiptap's full mark set and `rules.mark`
+  overrides individual marks. Output through `Y::Tiptap` is unchanged, held
+  byte-identical to a live editor's `getHTML()` by the fixture tests.
 
 ## [0.5.0] - 2026-07-08
 

data/Cargo.lock

@@ -617,6 +617,9 @@ dependencies = [
  "rb-sys-env 0.1.2",
  "serde_json",
  "yrs",
+ "yrs-html-core",
+ "yrs-lexical-html",
+ "yrs-prosemirror-html",
 ]
 
 [[package]]
@@ -637,6 +640,32 @@ 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/README.md

@@ -5,14 +5,16 @@
 Collaborative editing for Rails, backed by [y-crdt](https://github.com/y-crdt/y-crdt)
 (the Rust library behind Y.js). Your Rails server speaks the y-websocket sync
 protocol directly, so there's no separate Node process hosting the Y.js
-documents.
+documents. Pronounced "yer-bee".
+
+![Two people typing on separate lines of the same document, each keystroke synced through a Rails server, seen from a third browser with labeled carets](docs/images/collab.gif)
 
 ```ruby
 class DocumentChannel < ApplicationCable::Channel
-  include Y::ActionCable::Sync
+  include Y::ActionCable
 
-  on_load   { |key|         MyStore.load(key) }
-  on_change { |key, update| MyStore.append(key, update) }
+  on_load   { |key|         Y::Document.load_state(key) }
+  on_change { |key, update| Y::Document.append(key, update) }
 
   def subscribed    = sync_subscribed(params[:id])
   def receive(data) = sync_receive(data, params[:id])
@@ -59,7 +61,7 @@ and `Doc#read_map` reconstruct it server-side, in Ruby.
 The surface is intentionally small, but the focus is durability, resiliency, delivery
 guarantees, correctness, and thread safety.
 
-Towards that goal, `yrby` adds capabilities that stand out even in the Yjs ecosystem:
+Towards that goal, `yrby` adds opinionated defaults on top of normal Yjs syncing:
 
 - Built-in update acknowledgement: the `ActionCableProvider` in `yrby-client` will continue to
   send updates until an ack is received from the server. [`yrby-actioncable`](https://rubygems.org/gems/yrby-actioncable)
@@ -101,8 +103,9 @@ Issues and PRs are welcome.
 # Core CRDT + protocol primitives:
 gem "yrby"
 
-# For the Rails/ActionCable server concern (Y::ActionCable::Sync):
-gem "yrby-actioncable"
+# For the Rails side (the sync channel, document models, the generator).
+# Formerly yrby-actioncable; that name stops at 0.3.1.
+gem "yrby-rails"
 ```
 
 Requires Ruby 3.4 or newer. The release workflow builds precompiled gems for
@@ -129,6 +132,27 @@ The rest of the dev setup, plus the demo, is in [CONTRIBUTING.md](CONTRIBUTING.m
   and the test/load suites.
 - [CHANGELOG.md](CHANGELOG.md) and [CONTRIBUTING.md](CONTRIBUTING.md).
 
+## Editors
+
+yrby syncs opaque Yjs updates, so it works with any editor that has a Yjs
+binding. The demo app runs four, and CI drives each one in real Chrome:
+concurrent typing with every keystroke accounted for, remote cursors,
+local-only undo, and byte parity between the server-side renderers and the
+editor's own serializer. Each page is a working integration to copy from:
+
+| Editor | Yjs binding | Demo code |
+|---|---|---|
+| [Tiptap](https://tiptap.dev) (v2) | `@tiptap/extension-collaboration` | [`app.js`](examples/actioncable-demo/frontend/src/app.js) |
+| [Lexxy](https://github.com/basecamp/lexxy) (Lexical) | [`lexxy-realtime`](https://www.npmjs.com/package/lexxy-realtime) | [`lexxy.js`](examples/actioncable-demo/frontend/src/lexxy.js) |
+| [Rhino Editor](https://github.com/KonnorRogers/rhino-editor) (Tiptap 3) | `@tiptap/extension-collaboration` + `-caret` | [`rhino.js`](examples/actioncable-demo/frontend/src/rhino.js) |
+| [CodeMirror 6](https://codemirror.net) | `y-codemirror.next` | [`codemirror.js`](examples/actioncable-demo/frontend/src/codemirror.js) |
+
+The demo also syncs plain Yjs shapes with no editor at all — a whiteboard
+on a `Y.Map`, a kanban board on a `Y.Array`, a co-filled form — over the
+same channel. The demo README's "Using this in your own app" section has
+the integration recipe, and its `NoteMaterializer` shows how to render a
+document to ActionText server-side with `Y::Tiptap` or `Y::Lexxy`.
+
 ## Usage
 
 ### Doc (Low-Level Document Sync)
@@ -188,18 +212,20 @@ guarantees keep serving safe:
 
 ### Rendering to HTML
 
-Two schema-pinned renderers turn a collaborative document into HTML on the
-server, with no Node process or headless editor: `Y::ProseMirror` for
-ProseMirror/Tiptap documents and `Y::Lexical` for
-[Lexxy](https://github.com/basecamp/lexxy) (Lexical) documents. Each returns
-`nil` for a root that belongs to the other schema.
+Schema-pinned renderers turn a collaborative document into HTML on the
+server, with no Node process or headless editor. Each is an editor-specific
+class (byte-for-byte with that editor's own serializer) built on a core base
+any other editor extends with rules: `Y::Tiptap` on `Y::ProseMirror` for
+ProseMirror documents, and `Y::Lexxy` (the
+[Lexxy](https://github.com/basecamp/lexxy) editor) on `Y::Lexical`. Each
+returns `nil` for a root that belongs to the other schema.
 
-#### `Y::ProseMirror`
+#### `Y::Tiptap` (and `Y::ProseMirror`, its base)
 
 ```ruby
-prosemirror = Y::ProseMirror.new(doc)
-prosemirror.to_html            # the "default" fragment (Tiptap's default root)
-prosemirror.to_html("content") # or another XML root
+tiptap = Y::Tiptap.new(doc)
+tiptap.to_html            # the "default" fragment (Tiptap's default root)
+tiptap.to_html("content") # or another XML root
 ```
 
 The output matches Tiptap's own `getHTML()`, checked byte-for-byte in the tests
@@ -214,17 +240,30 @@ tables, text styles (color, font family), and every text mark. A table renders
 as semantic `<table><tbody>`, without the column-width styling Tiptap's editor
 view adds.
 
-#### `Y::Lexical`
+The support is layered like the Lexical side: `Y::ProseMirror` covers core
+ProseMirror natively — prosemirror-schema-basic plus the prosemirror-tables
+family — and Tiptap's extension nodes (task lists, mentions, the details
+family) are `Y::Tiptap`'s rule set (`Y::Tiptap::NODES`), built on the
+extension API below. Marks stay in the base: mark rendering (nesting order,
+`textStyle` CSS, `code` exclusivity) runs through native text-run machinery
+that node rules don't reach, so `Y::ProseMirror` renders Tiptap's mark set
+as-is and `rules.mark` overrides individual marks.
+
+#### `Y::Lexxy` (and `Y::Lexical`, its base)
 
 ```ruby
-lexical = Y::Lexical.new(doc)
-lexical.to_html            # the "root" fragment (Lexical's default root name)
-lexical.to_html("notepad") # or another XML root
+lexxy = Y::Lexxy.new(doc)
+lexxy.to_html            # the "root" fragment (Lexical's default root name)
+lexxy.to_html("notepad") # or another XML root
 ```
 
 The HTML is identical to what a `lexxy-editor` submits to Rails (its `value`).
 The tests check this byte-for-byte against a document captured from a real
-editor.
+editor. Stock Lexical has no canonical serializer — every editor configures
+its own — so the editor-specific class carries the editor's name, and
+`Y::Lexical` is the core-Lexical base: paragraphs, headings, quotes, code,
+lists, tables, links, and the full text-format model, for any other Lexical
+editor to extend with rules.
 
 It handles the whole Lexxy 0.9.x node set: paragraphs, headings, every text
 format and their combinations, links, the four list types and nesting,
@@ -233,8 +272,178 @@ header cells, image galleries, and ActionText attachments (uploads and
 mentions both emit `<action-text-attachment>` elements that ActionText can
 re-render).
 
-In both renderers an unknown node keeps its content — text falls back to a
-plain paragraph rather than disappearing.
+Internally that support is layered: `Y::Lexical` covers core Lexical
+structure natively, and everything Lexxy adds — its node types (attachments,
+galleries) and its decorations of core nodes (the table wrapper, header-cell
+styling, nested-list classes) — is `Y::Lexxy`'s rule set
+(`Y::Lexxy::NODES`), built on the extension API below. The gem's own Lexxy
+support is the API's first consumer: an app rule for one of those types
+simply replaces it.
+
+In both renderers an unknown node keeps its content — text and nested blocks
+fall back to readable markup rather than disappearing.
+
+#### Custom nodes and marks
+
+The built-in schemas are pinned to what Tiptap and Lexxy ship, but apps add
+their own node types. Both renderers take rules for them. A rule is checked
+before the built-in schema, so it can add a node type or replace how a
+built-in renders.
+
+Rules register in a block — one `rules.node` call per type. A declarative
+rule is markup as data, rendered natively:
+
+```ruby
+tiptap = Y::Tiptap.new(doc) do |rules|
+  rules.node "callout", tag: "aside",
+                        attrs: { "class" => ["callout callout--", :kind] },
+                        contains: :blocks
+end
+```
+
+`tag` names the element. `attrs` values are templates: a string is a literal,
+a symbol reads that attribute off the node, an array concatenates both kinds;
+an attribute that resolves empty is left out. `text` (same template form)
+emits literal text content. `contains` declares what lives inside the node — `:inline` (formatted text,
+the default), `:blocks` (child block nodes — a container), or `:none` (a
+leaf). `void: true` skips the closing tag.
+
+You don't have to guess any of those names or shapes. Editors store types
+and attributes under names you'd never predict (Rhino's strike mark is
+`rhino-strike`; Lexical prefixes its own props `__`), so ask a real
+document instead — make one in your editor using your custom node, then:
+
+```ruby
+Y::Tiptap.new(doc).node_types
+# => { "callout"   => { "count" => 2, "attrs" => ["kind"],
+#                       "children" => ["paragraph"], "text" => false,
+#                       "handled" => nil },
+#      "paragraph" => { ..., "handled" => "builtin" } }
+```
+
+`handled` nil marks the types that still need a rule; `attrs` are the stored
+names your templates and blocks will read; `children` plus `text` is how you
+pick `contains:` (child block types → `:blocks`; text → `:inline`).
+
+When markup-as-data isn't enough, give the node a block:
+
+```ruby
+lexical = Y::Lexical.new(doc) do |rules|
+  rules.node "video_embed" do |node|
+    src = ERB::Util.html_escape(node.attrs["__src"])
+    %(<video controls src="#{src}"></video>)
+  end
+end
+```
+
+The block gets the node's type, its stored attributes, `node.content` — the
+children, already rendered to HTML — and `node.child_types`, the node's
+element/block children by type, in document order. `child_types` answers the
+structural questions attributes can't: how many images a gallery holds, or
+whether a list item carries a nested list. Whatever the block returns is
+spliced into the output as-is: it's trusted HTML, so escape any values you
+interpolate. To set the content mode for a callback, give the node both —
+`rules.node "embed", contains: :blocks do |node| ... end`.
+
+Callbacks never run while the document is locked. The render finishes first
+(inside one read transaction, GVL released), then the blocks run and their
+output is spliced in — so a callback can safely read or even write the same
+doc. With no callback rules, `to_html` skips the splicing entirely.
+
+Blocks are the escape hatch for everything the declarative form can't say,
+and they're proven sufficient: `Y::Lexxy` and `Y::Tiptap` are themselves
+built on this API (`lib/y/lexxy.rb`, `lib/y/tiptap.rb`) — simple nodes as
+declarative hashes, everything with logic as plain methods mapped by node
+type (a `Method` responds to `call` like any lambda) — and the fixture tests
+hold their output byte-identical to a live editor's.
+
+The ProseMirror side also takes custom marks:
+
+```ruby
+tiptap = Y::Tiptap.new(doc) do |rules|
+  rules.mark "comment", tag: "span", attrs: { "data-comment-id" => :id }
+end
+```
+
+Symbol refs resolve against the mark's own attributes. A custom mark wraps
+outside every built-in mark; several on one run nest alphabetically. A rule
+for a built-in mark name (`"bold"`) replaces its built-in tag.
+
+##### Worked examples
+
+A video-embed node from an app's Tiptap extension — a type the pinned schema
+has never heard of:
+
+```ruby
+tiptap = Y::Tiptap.new(doc) do |rules|
+  rules.node "videoEmbed" do |node|
+    src   = ERB::Util.html_escape(node.attrs["src"])
+    title = ERB::Util.html_escape(node.attrs["title"] || "Video")
+    %(<figure class="video"><iframe src="#{src}" title="#{title}" allowfullscreen></iframe></figure>)
+  end
+end
+```
+
+Resolving mentions against the database. Blocks run after the document read
+has finished, so hitting ActiveRecord (or the doc itself) inside one is safe:
+
+```ruby
+tiptap = Y::Tiptap.new(doc) do |rules|
+  rules.node "mention" do |node|
+    user = User.find_by(id: node.attrs["id"])
+    next "<span>@unknown</span>" unless user
+
+    %(<a class="mention" href="/users/#{user.id}">@#{ERB::Util.html_escape(user.handle)}</a>)
+  end
+end
+```
+
+Overriding a shipped rule — rendering Lexxy uploads as real image markup
+instead of the `<action-text-attachment>` elements ActionText re-renders:
+
+```ruby
+lexxy = Y::Lexxy.new(doc) do |rules|
+  rules.node "action_text_attachment" do |node|
+    src     = ERB::Util.html_escape(node.attrs["src"])
+    alt     = ERB::Util.html_escape(node.attrs["altText"].to_s)
+    caption = node.attrs["caption"].to_s
+    html = %(<img src="#{src}" alt="#{alt}" loading="lazy">)
+    html += "<figcaption>#{ERB::Util.html_escape(caption)}</figcaption>" unless caption.empty?
+    "<figure>#{html}</figure>"
+  end
+end
+```
+
+Markup that depends on structure — `node.child_types` lists the node's
+element/block children in document order, so a layout container can size
+itself by its column count while the columns themselves stay declarative:
+
+```ruby
+tiptap = Y::Tiptap.new(doc) do |rules|
+  rules.node "columns", contains: :blocks do |node|
+    %(<div class="columns columns--#{node.child_types.length}">#{node.content}</div>)
+  end
+  rules.node "column", tag: "div", attrs: { "class" => "column" }, contains: :blocks
+end
+```
+
+Content-aware overrides — dropping the empty paragraphs an editor keeps
+around the cursor, since `node.content` arrives already rendered:
+
+```ruby
+lexical = Y::Lexical.new(doc) do |rules|
+  rules.node "paragraph" do |node|
+    node.content.empty? ? "" : "<p>#{node.content}</p>"
+  end
+end
+```
+
+For a larger reference, the gem's own editor schemas ship this way — see
+`Y::Lexxy::NODES` in `lib/y/lexxy.rb` (declarative hashes for the simple
+nodes, a plain method per node that needs logic — galleries, list items,
+header cells, both attachment types — mapped with `method(:name)`) and
+`Y::Tiptap::NODES` in `lib/y/tiptap.rb` (task lists, mentions, the details
+family).
 
 ### Protocol codec (module functions)
 
@@ -251,25 +460,72 @@ Y.wrap_update(update_bytes)   # => wrap a raw doc update as a sync Update frame
 
 ### ActionCable Integration
 
-`Y::ActionCable::Sync` (from the `yrby-actioncable` gem) is a channel
-concern that implements the full y-websocket protocol (document sync +
-awareness/presence) over ActionCable:
+In a Rails app, one generator creates the channel and the migration:
+
+```bash
+bin/rails generate yrby:install
+bin/rails db:migrate
+```
+
+The models ship in the gem, the way Action Text owns
+`ActionText::RichText`:
+
+- **`Y::Document`** — one row per document, addressed two ways: by `key`
+  (what a channel addresses — one opaque, unique string, sometimes
+  app-supplied, never parsed) and, optionally, by polymorphic `record` +
+  `name` (which model attribute it backs; `name` is the attribute name,
+  `"body"` — one document per attribute per record, the
+  ActionText::RichText scheme). Key-only documents leave the binding nil.
+  Either side can arrive first: `Y::Document.for(record, name)` finds or
+  creates the binding, derives a readable key (`post/1/body`), and adopts
+  a key-only row already holding that key, so a channel writing first and
+  a binding created later converge on one document. The row also holds
+  the merged `state` snapshot — CRDT state only; derived data (rendered
+  HTML, search text) is the application's job, typically in the channel's
+  on_change. `.load_state(key)` / `.append(key, update)` are the store
+  calls the generated channel uses.
+- **`Y::DocumentUpdate`** — the uncompacted tail: one delta per row,
+  compacted into `state` and deleted once the tail reaches `compact_every`
+  (default 64). Loading reads the snapshot plus the current tail; an
+  empty tail returns `state` directly. Compaction serializes on a
+  per-document row lock and skips causally-gapped rows — they're
+  quarantined until they heal rather than compacted into state or
+  deleted. Destroying a document deletes its updates with it.
+
+The migration creates `y_documents` and `y_document_updates`. To rename
+them, edit the generated migration and point `Y::Document.table_name` /
+`Y::DocumentUpdate.table_name` at the new names in an initializer.
+
+Storage is swappable: the channel only needs `on_load` and `on_change`
+answered, and they can point at anything.
+
+`include Y::ActionCable` (from the `yrby-rails` gem) is the channel
+integration: the y-websocket protocol (document sync +
+awareness/presence) over ActionCable. (`include Y::ActionCable::Sync`
+keeps working and has the same effect.)
 
 ```ruby
 # app/channels/document_channel.rb
 class DocumentChannel < ApplicationCable::Channel
-  include Y::ActionCable::Sync
+  include Y::ActionCable
 
-  on_load { |key| MyStore.load(key) }                 # source of truth
-  on_change { |key, update| MyStore.append(key, update) } # durable record
+  on_load { |key| Y::Document.load_state(key) }          # rebuild from storage
+  on_change { |key, update| Y::Document.append(key, update) } # record, then broadcast
 
   def subscribed
+    return reject unless authorized?(params[:id])
+
     sync_subscribed params[:id]
   end
 
   def receive(data)
     sync_receive(data, params[:id])
   end
+
+  private
+
+  # Everyone is denied until you wire this to your app's auth.
+  def authorized?(_document_key) = false
 end
 ```
 
@@ -365,7 +621,7 @@ It is up to you to durably record it:
 
 ```ruby
 class DocumentChannel < ApplicationCable::Channel
-  include Y::ActionCable::Sync
+  include Y::ActionCable
 
   # ...
 

data/ext/yrby/Cargo.toml

@@ -14,6 +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" }
 
 [dev-dependencies]
 rb-sys-env = "0.1"

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

@@ -0,0 +1,15 @@
+[package]
+name = "yrs-html-core"
+description = "Internal core for the yrs-*-html renderer crates; depend on those instead"
+repository = "https://github.com/jpcamara/yrby"
+readme = "README.md"
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.85"
+authors = ["JP Camara <johnpcamara@gmail.com>"]
+license = "MIT"
+publish = false
+
+[dependencies]
+yrs = { version = "0.27", features = ["sync"] }
+serde_json = "1.0"