yrb-lite 0.1.0.beta7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea20d7a00b104460b01812d463df581b45042d63491ff1e5494acd478fa2047b
-  data.tar.gz: 731010497572899b225ff36fd792e635738d05bad0f41640a4f991af56540d3e
+  metadata.gz: 44da78141b84de4cf438a8b0315b4fdf92bf10290787f569e1c9f63087f2abf8
+  data.tar.gz: dce6b3a9227637b8e8828c8d23726b178107c19dd8670bd580da6d71d848bb6a
 SHA512:
-  metadata.gz: 83682aa86e7753b9270274051e0b9850c41e35559817cbae981debe68de53d4b1cd56cff5b21b0d63b411e87ab550cd7ffc11c0ec0c3005845e02e5af145d078
-  data.tar.gz: 282965720af81ee289feb0f555ff828fd593ba24f869054a7792f420c61ba03c87168b963adb6259e143b103c398e70855365d48c1f4cd6a7e693ae8491026b9
+  metadata.gz: d4b3df640c6e502acd8545e18e019998c8d4200f3e7c3a6e70fc9f4616dc468fd57253b55d149713d314d4b706a029716dc42a09bbbe461e22c9ec3247241689
+  data.tar.gz: 14673427e3ebd711859572c5b589cdccfb0e8727d7e767daac214e9c5cef8d35fa12c3e7192ed415a4e18c3cedae6e4bf03b08ac1070fe4bec9e160a6aede1a7

data/CHANGELOG.md

@@ -5,135 +5,3 @@ All notable changes to this project are documented here. The format is based on
 to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
-
-## [0.1.0.beta6] - 2026-06-22
-
-(yrb-lite core gem. The `yrb-lite-client` npm package ships these client changes as 0.1.2.)
-
-### Added
-
-- `yrb-lite-client`, the TypeScript client package for the yrb-lite
-  ActionCable/AnyCable protocol. It provides `ActionCableProvider`,
-  `YProtocolSession`, and the standalone `ReliableSync` delivery core.
-
-### Changed
-
-- Document delivery is ack-tracked by default in `yrb-lite-client`: document
-  frames use `{ update, id }`, acknowledgements use `{ ack }`, and pending
-  document updates stay queued until acked.
-- The ActionCable protocol surface uses a single canonical document envelope:
-  `{ "update" => "<base64 frame>" }`.
-- AnyCable awareness/presence uses an awareness-only whisper envelope,
-  `{ awareness: "<base64 awareness frame>" }`, while document frames stay on
-  the server persistence/ack path.
-
-### Fixed
-
-- Incoming protocol frames are validated before mutating documents or awareness
-  state, including trailing-byte rejection on the TypeScript client.
-- Native/Rust protocol entry points reject wire client IDs that are unsafe for
-  JavaScript clients.
-- `lib0` is declared as a direct runtime dependency of `yrb-lite-client`.
-
-## [0.1.0.beta5] - 2026-06-18
-
-### Changed
-
-- **Breaking:** the ActionCable integration has been extracted into a separate
-  gem, [`yrb-lite-actioncable`](https://rubygems.org/gems/yrb-lite-actioncable).
-  `yrb-lite` is now a standalone y-crdt wrapper: CRDT documents, awareness, and
-  the y-websocket sync protocol primitives, with no Rails/ActionCable coupling
-  (mirrors the `y-rb` / `yrb-actioncable` split). The `base64` runtime
-  dependency moved with it.
-
-### Migration
-
-- Using `YrbLite::Sync`? Add `gem "yrb-lite-actioncable"` and change
-  `include YrbLite::Sync` to `include YrbLite::ActionCable::Sync`. The concern's
-  API is otherwise unchanged. If you only use `YrbLite::Doc`/`YrbLite::Awareness`,
-  nothing changes.
-
-## [0.1.0.beta4] - 2026-06-18
-
-### Changed
-
-- `on_change` block recorders now run in the **channel instance's context**
-  (via `instance_exec`), so a recorder can call the channel's own methods --
-  `current_user`, `params`, request/connection-scoped accessors -- directly,
-  instead of plumbing them in through a thread-local. A non-Proc callable (an
-  object responding to `#call`) is still invoked with `#call` and its own
-  context. Existing block recorders that use
-  only the `(key, update)` arguments and lexically-scoped constants are
-  unaffected; the only behavioral change is `self` inside the block.
-
-## [0.1.0.beta3] - 2026-06-18
-
-### Changed
-
-- Upgraded the bundled `yrs` (y-crdt) from 0.21 to 0.27.2. No change to the
-  `YrbLite::Doc`, `YrbLite::Awareness`, or `YrbLite::Sync` public API; existing
-  code and the wire protocol are unaffected.
-- Thread-safety is preserved across the upgrade. yrs 0.27 dropped `Awareness`'s
-  internal locking (its mutating methods now take `&mut self`, and `Awareness`
-  is no longer `Sync`), so `YrbLite::Awareness` now serializes access through an
-  internal `Mutex`. The lock is taken only while the GVL is released and is
-  never held across the GVL boundary, so concurrent access from multiple Ruby
-  threads stays safe and deadlock-free, and document reads still run in parallel
-  (they operate on a cheaply-cloned, `Arc`-backed `Doc` handle, not under the
-  presence lock).
-
-### Build
-
-- Building the gem from source now requires **Rust 1.94 or newer** (yrs 0.27.2
-  uses `let`-chains). The precompiled platform gems are unaffected -- they need
-  no Rust toolchain to install.
-
-## [0.1.0.beta2] - 2026-06-16
-
-### Added
-
-- Reliable delivery (opt-in, client-driven). A client may tag a document update
-  with an `"id"`; the server replies `{ "ack": <id> }` once the update has been
-  durably recorded. This lets an
-  ack-aware client retain and retransmit an update until delivery is confirmed,
-  so an edit can't be silently lost on a flaky connection. Clients that omit
-  `"id"` are still accepted, but their delivery is not ack-tracked.
-- Demo coverage for reliable delivery with "sync-since-last-ack" framing (the
-  unacknowledged tail is sent as one merged, causally-complete delta), plus a
-  minimal reference client and an intensive message-loss stress test.
-
-### Fixed
-
-- Causal-gap protection. The authoritative, fast, and store paths now reject a
-  document update that isn't causally ready -- one whose dependencies are
-  missing because an earlier update was lost in transit or its durable record
-  failed -- and ask the client to resync, instead of recording or relaying an
-  un-integrable update that would leave the log permanently pending. Adds native
-  `Doc#update_ready?`/`#pending?` (cheap, read-only checks) used to gate the
-  record-before-distribute path.
-
-## [0.1.0.beta1]
-
-### Added
-
-- Thread-safe `YrbLite::Doc` and `YrbLite::Awareness` over `yrs` (magnus/rb-sys
-  native extension). The GVL is released during CRDT work so docs can run in
-  parallel on MRI.
-- `YrbLite::Sync` ActionCable channel concern implementing the y-websocket
-  protocol (document sync plus awareness/presence).
-- A "record-before-distribute" mode via an `on_change` hook, so every change is
-  recorded durably before it's applied or relayed.
-- Presence cleanup on disconnect, and idle-document eviction.
-- Store-backed ActionCable delivery for AnyCable and multi-process use.
-- Hardening against bad input: malformed or multi-message frames are dropped
-  before processing or relay, and native panics are contained at the FFI
-  boundary.
-- Precompiled native gems for common platforms (no Rust toolchain needed to
-  install) via the cross-gem workflow.
-
-[Unreleased]: https://github.com/jpcamara/yrb-lite/compare/v0.1.0.beta5...main
-[0.1.0.beta5]: https://github.com/jpcamara/yrb-lite/compare/v0.1.0.beta4...v0.1.0.beta5
-[0.1.0.beta4]: https://github.com/jpcamara/yrb-lite/compare/v0.1.0.beta3...v0.1.0.beta4
-[0.1.0.beta3]: https://github.com/jpcamara/yrb-lite/compare/v0.1.0.beta2...v0.1.0.beta3
-[0.1.0.beta2]: https://github.com/jpcamara/yrb-lite/compare/v0.1.0.beta1...v0.1.0.beta2
-[0.1.0.beta1]: https://github.com/jpcamara/yrb-lite/releases/tag/v0.1.0.beta1

data/README.md

@@ -11,20 +11,19 @@ documents.
 class DocumentChannel < ApplicationCable::Channel
   include YrbLite::ActionCable::Sync
 
-  def subscribed   = sync_for(params[:id])
+  def subscribed   = sync_subscribed(params[:id])
   def receive(data) = sync_receive(data)
-  def unsubscribed = sync_unsubscribed(params[:id])
 end
 ```
 
 On the browser, use the `yrb-lite-client` `ActionCableProvider`. Tiptap,
 ProseMirror, and BlockNote all sync through the `Y.Doc` you pass in and the
-provider's Awareness instance, unless you supply your own.
+provider's Awareness instance.
 
 ## What you get
 
-- Thread-safe Ruby wrappers for `Doc` and `Awareness`. You can share them
-  across Puma threads; native CRDT work runs with the GVL released.
+- A thread-safe Ruby `Doc` you can share across Puma threads; native CRDT work
+  runs with the GVL released.
 - The y-websocket protocol (document sync plus awareness/presence) as a
   one-include ActionCable concern.
 - Store-backed ActionCable/AnyCable delivery for multi-process deployments.
@@ -35,6 +34,22 @@ What it doesn't do: auth, read-only connections, rate limiting, webhooks,
 metrics. Hocuspocus ships extensions for those; here you'd build them with
 Rails.
 
+## Why "lite"
+
+The "lite" is the size of the surface. yrb-lite binds just the part of y-crdt you
+need to *sync and persist* collaborative documents — a `Doc`, awareness, and the
+y-websocket protocol primitives. The Ruby side treats a document as opaque CRDT
+state: it applies updates, answers sync handshakes, and records deltas, but never
+reaches in to read or edit the contents. The browser editor owns the document's
+shape; Rails owns durability and delivery.
+
+A full y-crdt Ruby binding like `y-rb` gives you the whole type system — shared
+text, arrays, maps, XML — to build and query documents in Ruby. yrb-lite leaves
+that out on purpose. What's left is a sync engine plus a one-include ActionCable
+concern, with the server concerns it skips (auth, rate limiting, metrics — see
+above) built from the Rails you already run, and no Node process hosting the
+documents.
+
 ## Testing
 
 Ruby and Rust unit tests cover the core. CI also runs the npm client tests and a
@@ -86,11 +101,7 @@ require "yrb_lite"
 
 # Create docs
 doc = YrbLite::Doc.new        # random client ID
-doc = YrbLite::Doc.new(12345) # specific client ID
-
-# Get document info
-doc.client_id  # => unique client identifier
-doc.guid       # => document GUID
+doc = YrbLite::Doc.new(12345) # specific client ID (used for CRDT identity)
 
 # Encoding
 doc.encode_state_vector           # => current state vector
@@ -100,36 +111,23 @@ doc.encode_state_as_update(sv)    # => update diff against state vector
 # Applying updates
 doc.apply_update(update_bytes)    # apply raw V1 update
 
-# Sync protocol messages
-doc.sync_step1                    # => SyncStep1 message (contains state vector)
-doc.sync_step2(state_vector)      # => SyncStep2 message (contains update)
-doc.handle_sync_message(data)     # => [msg_type, sync_type, response]
-doc.encode_update_message(update) # => wrap update as sync Update message
+# Sync protocol
+doc.sync_step1                    # => SyncStep1 message (this doc's state vector)
+doc.handle_sync_message(data)     # => [msg_type, sync_type, response]; answers a
+                                  #    peer's SyncStep1 with a SyncStep2
 ```
 
-### Awareness (Document + Presence)
+### Protocol codec (module functions)
 
-```ruby
-# Create awareness instances (each contains a Doc)
-awareness = YrbLite::Awareness.new        # random client ID
-awareness = YrbLite::Awareness.new(12345) # specific client ID
-
-# Get document info
-awareness.client_id  # => unique client identifier
-awareness.guid       # => document GUID
-```
-
-### Handling Sync Messages
+Classifying and unwrapping wire frames is stateless, so it's exposed as
+`YrbLite` module functions rather than a class. The server never holds presence
+or document state to route a frame — presence lives in the browser clients, and
+the server only relays awareness frames opaquely.
 
 ```ruby
-# When connection opens, send initial sync messages
-initial_message = awareness.start
-# Send initial_message to peer via WebSocket
-
-# When receiving messages from peer
-response = awareness.handle(incoming_data)
-# Send response back to peer if not empty
-send_to_peer(response) unless response.empty?
+YrbLite.message_kind(frame)         # => 0 drop / 1 step1 / 2 update / 3 awareness / 4 query
+YrbLite.update_from_message(frame)  # => the document delta carried by a frame, or nil
+YrbLite.wrap_update(update_bytes)   # => wrap a raw doc update as a sync Update frame
 ```
 
 ### ActionCable Integration
@@ -147,16 +145,12 @@ class DocumentChannel < ApplicationCable::Channel
   on_change { |key, update| MyStore.append(key, update) } # durable record
 
   def subscribed
-    sync_for params[:id]
+    sync_subscribed params[:id]
   end
 
   def receive(data)
     sync_receive(data, params[:id])
   end
-
-  def unsubscribed
-    sync_unsubscribed(params[:id])
-  end
 end
 ```
 
@@ -178,6 +172,54 @@ oversized, or unknown frames are dropped. A bad frame can't crash the process: a
 Rust panic is caught at the FFI boundary and re-raised as a Ruby exception. And
 no single client can relay garbage that breaks the others in a room.
 
+#### Delivery guarantees
+
+The contract is the same at every scale — one process, or hundreds across many
+servers:
+
+- **The document always converges.** CRDT updates are commutative and
+  idempotent, so out-of-order, duplicate, or concurrent delivery all converge to
+  the same correct document. This needs no coordination and holds everywhere.
+- **The durable log never goes gappy.** An update is recorded only once its
+  causal dependencies are already in the store (checked against `on_load`); a
+  causally-incomplete update triggers a resync instead, so the log always
+  rebuilds cleanly.
+- **`on_change` is at-least-once, and the durable guarantee is that replaying the
+  log reconstructs the document.** Every change is recorded before it's acked or
+  broadcast (record-before-distribute). Entry count is not 1:1 with edits: a
+  best-effort check skips most lost-ack retries but isn't cross-process exact (a
+  retry on another process can record the same update twice), and a resync can
+  coalesce a client's un-acked tail into a single record. So **make `on_change`
+  idempotent** if duplicate side effects would matter (a webhook, a counter) — a
+  raw append-only delta log is naturally fine, since it replays to the same
+  document either way.
+- **A raising `on_change` rejects the update implicitly.** If the block raises,
+  the update is neither acked nor broadcast (record-before-distribute stops both).
+  There is no negative-ack: the client simply never receives the ack, keeps the
+  update pending, and retransmits on its timer/reconnect. This is built for
+  *transient* failures (the store is briefly down → a retry lands). A block that
+  raises *deterministically* — a validation that always fails for this edit —
+  will be retried forever, since nothing tells the client to stop. Enforce hard
+  rejections before the edit reaches `on_change` (channel authorization in
+  `subscribed`), not by raising inside it.
+- **An over-cap frame is dropped the same silent way.** A frame larger than
+  `max_frame_bytes` (default 8 MiB) is dropped before decoding — no ack, no
+  broadcast — to bound the work a client can force. For a genuine document
+  update that means the same implicit rejection as above: unacked, retransmitted
+  forever. Normal typing never approaches the cap, but a large paste, an embedded
+  image, or a big initial `SyncStep2` can. The drop is logged (`warn` for
+  over-cap, `debug` for undecodable) with the document key and update id so it's
+  findable; override `sync_log_context` on the channel to add a user/connection
+  id. Size the cap for your largest expected payload, and reject
+  genuinely-too-big content upstream rather than relying on the cap to reject it
+  gracefully.
+
+There is deliberately no in-gem cross-process lock. One that only spanned a
+single process would give exactly-once at small scale and silently degrade as
+you scale out, so the guarantee is uniform instead. If you need exactly-once
+*side effects*, enforce it in your store (a unique key on the update) or with
+your own distributed lock — the gem stays storage-agnostic and assumes neither.
+
 #### Multi-process deployments
 
 Most Rails apps run several processes (Puma workers, multiple dynos), and any of
@@ -204,9 +246,8 @@ class DocumentChannel < ApplicationCable::Channel
   on_load  { |key| MyStore.load(key) }          # required: source of truth
   on_change { |key, update| MyStore.append(key, update) }  # required: record
 
-  def subscribed   = sync_for(params[:id])
+  def subscribed   = sync_subscribed(params[:id])
   def receive(data) = sync_receive(data, params[:id])   # pass the key each call
-  def unsubscribed = sync_unsubscribed(params[:id])
 end
 ```
 
@@ -218,8 +259,8 @@ end
   separate awareness stream with AnyCable `whisper: true`, so cursor traffic can
   take the low-latency client-to-client path without bypassing document
   durability.
-- Pass `params[:id]` into `sync_receive`/`sync_unsubscribed` so the document key
-  survives AnyCable's per-command instances.
+- Pass `params[:id]` into `sync_receive` so the document key survives AnyCable's
+  per-command instances.
 - The sender gets its own updates echoed back (no Ruby callback to filter them).
   That's a no-op, since applying an update twice does nothing.
 
@@ -256,9 +297,8 @@ class DocumentChannel < ApplicationCable::Channel
     AuditLog.append!(key, update)   # raise to REJECT the change
   end
 
-  def subscribed = sync_for(params[:id])
+  def subscribed = sync_subscribed(params[:id])
   def receive(data) = sync_receive(data, params[:id])
-  def unsubscribed = sync_unsubscribed(params[:id])
 end
 ```
 
@@ -295,43 +335,15 @@ one `{ ack: id }` cumulatively confirms everything up to it. Because CRDT apply
 is idempotent, a resend that already landed is a harmless no-op that just
 re-acks. Awareness stays ephemeral and is not acked.
 
-### User Awareness/Presence
-
-```ruby
-# Set local user state (cursor position, name, etc.)
-awareness.set_local_state('{"user": {"name": "Alice", "color": "#ff0000"}}')
-
-# Get local state
-awareness.local_state  # => '{"user": {"name": "Alice", "color": "#ff0000"}}'
-
-# Clear local state (e.g., when disconnecting)
-awareness.clear_local_state
-
-# Encode awareness update for broadcasting
-update = awareness.encode_awareness_update
-```
-
-### Low-Level Access
-
-```ruby
-# Get state vector for manual sync
-sv = awareness.encode_state_vector
-
-# Get update diffed against a state vector
-update = awareness.encode_state_as_update(remote_state_vector)
-
-# Apply raw update to the document
-awareness.apply_update(update_bytes)
-
-# Wrap raw update data in a sync message
-message = awareness.encode_update(update_bytes)
-```
+Presence (cursors, selections) is owned by the browser clients — the server
+never sets or holds presence state, it only relays awareness frames opaquely.
+See `yrb-lite-client` for the client-side awareness API.
 
 ## Thread Safety
 
-`Doc` and `Awareness` are safe to share across Ruby threads. A `Doc` or
-`Awareness` can be used concurrently from Puma workers, ActionCable connection
-threads, or background jobs without external locking.
+A `Doc` is safe to share across Ruby threads — used concurrently from Puma
+workers, ActionCable connection threads, or background jobs without external
+locking.
 
 That comes from how the underlying types work, not from locking on top:
 
@@ -379,8 +391,6 @@ exceptions.
 ```ruby
 YrbLite::MSG_SYNC            # 0 - Document sync messages
 YrbLite::MSG_AWARENESS       # 1 - User presence data
-YrbLite::MSG_AUTH            # 2 - Authentication
-YrbLite::MSG_QUERY_AWARENESS # 3 - Request awareness state
 
 YrbLite::MSG_SYNC_STEP1      # 0 - State vector request
 YrbLite::MSG_SYNC_STEP2      # 1 - Update response

data/ext/yrb_lite/src/lib.rs

@@ -1,16 +1,13 @@
 use magnus::{
     function, method, prelude::*, Error, ExceptionClass, RString, Ruby, TryConvert, Value,
 };
-use std::sync::Mutex;
-use yrs::sync::{Awareness, DefaultProtocol, Message, Protocol, SyncMessage};
+use yrs::sync::{Message, SyncMessage};
 use yrs::updates::decoder::Decode;
-use yrs::updates::encoder::{Encode, Encoder, EncoderV1};
+use yrs::updates::encoder::Encode;
 use yrs::{Doc, ReadTxn, Transact};
 
 mod protocol;
-use protocol::{
-    classify_message, doc_has_pending, merged_doc_update, update_advances_doc, update_is_ready,
-};
+use protocol::{classify_message, merged_doc_update, update_advances_doc, update_is_ready};
 
 /// Wrapper around yrs Doc.
 ///
@@ -22,37 +19,13 @@ use protocol::{
 #[magnus::wrap(class = "YrbLite::Doc", free_immediately, size)]
 struct RbDoc(Doc);
 
-/// Wrapper around yrs Awareness (which contains a Doc).
-///
-/// Thread safety: as of yrs 0.27 `Awareness` dropped its internal locking and
-/// its mutating methods (`handle`, `set_local_state`, `clean_local_state`,
-/// `remove_state`, `update_with_clients`) take `&mut self`. It is `Send` but no
-/// longer `Sync`, so we serialize all access through a `Mutex`.
-///
-/// CRITICAL: the `Mutex` is ALWAYS locked inside the `nogvl` closure (never with
-/// the GVL held) and the guard is dropped before the closure returns. This obeys
-/// the same rule as the doc's RwLock (see `nogvl`): a thread never waits on this
-/// lock while holding the GVL, and never reacquires the GVL while holding this
-/// lock, so the GVL and this `Mutex` can't deadlock on lock order. Locking with
-/// the GVL held (outside `nogvl`) reintroduces that deadlock -- don't.
-///
-/// For doc-only reads we clone the (Arc-backed) `Doc` out under the brief lock
-/// and operate on the owned clone, so a long encode holds only the doc's own
-/// RwLock, not this `Mutex`, and never blocks presence updates on another
-/// thread. Lock order is always Mutex-then-doc-RwLock (or doc-RwLock alone),
-/// never the reverse.
-#[magnus::wrap(class = "YrbLite::Awareness", free_immediately, size)]
-struct RbAwareness(Mutex<Awareness>);
-
-/// Compile-time proof that the wrapped types are thread-safe. If a future
-/// yrs upgrade makes Doc lose Send/Sync, or Awareness lose Send, this fails the
-/// build instead of silently shipping a thread-unsafe gem. (Awareness is no
-/// longer `Sync` as of yrs 0.27, hence the `Mutex` wrapper, which restores it.)
+/// Compile-time proof that the wrapped Doc is thread-safe. If a future yrs
+/// upgrade makes Doc lose Send/Sync, this fails the build instead of silently
+/// shipping a thread-unsafe gem.
 #[allow(dead_code)]
 fn assert_thread_safe() {
     fn is_send_sync<T: Send + Sync>() {}
     is_send_sync::<Doc>();
-    is_send_sync::<Mutex<Awareness>>();
 }
 
 /// Run `f` with the GVL (Global VM Lock) released, so other Ruby threads,
@@ -62,14 +35,17 @@ fn assert_thread_safe() {
 /// - It must not touch any Ruby object or call any Ruby API. Inputs are copied
 ///   out of Ruby strings before entering, and results are converted to Ruby
 ///   objects after returning.
-/// - It must be `Send` (it runs while other threads own the GVL). `&Doc` and
-///   `&Mutex<Awareness>` are fine: both are `Sync` (asserted above).
-/// - LOCK DISCIPLINE: any native lock it takes -- the doc's internal RwLock OR
-///   the awareness `Mutex` (`self.0.lock()`) -- must be acquired AND released
-///   inside this closure (GVL already dropped). Never lock with the GVL held
-///   (e.g. before calling `nogvl`), or a thread waiting on the lock while
-///   holding the GVL can deadlock against the GVL reacquire. Same reason we
-///   never hold a lock across the GVL boundary.
+/// - It must be `Send` (it runs while other threads own the GVL). `&Doc` is
+///   fine: it's `Sync` (asserted above).
+/// - Lock discipline: any native lock it takes (the doc's internal RwLock) must
+///   be acquired and released inside this closure, with the GVL already dropped.
+///   Never lock with the GVL held (e.g. before calling `nogvl`), or a thread
+///   waiting on the lock while holding the GVL can deadlock against the GVL
+///   reacquire. Same reason we never hold a lock across the GVL boundary.
+///
+/// The closure runs with no unblock function, so it is not interruptible: a
+/// Thread#kill, timeout, or signal can't preempt it mid-run. That's fine for the
+/// bounded CRDT work it does; never call anything blocking or unbounded inside it.
 ///
 /// Panics inside the closure are caught and re-raised (resumed) after the GVL
 /// is reacquired, where magnus converts them to Ruby exceptions.
@@ -140,11 +116,6 @@ fn yrb_error(msg: String) -> Error {
     Error::new(class, msg)
 }
 
-// CLIENT IDs ARE NOT VALIDATED -- whoever supplies the id (the app via
-// `Doc.new(id)` / `Awareness.new(id)`, or a remote peer over the wire) is
-// responsible for keeping it JS-safe (<= 2^53 - 1). See the protocol.rs header
-// for why (and `ClientID::try_new`, proposed upstream, for strict rejection).
-
 // ============================================================================
 // Doc Implementation
 // ============================================================================
@@ -161,14 +132,6 @@ impl RbDoc {
         Ok(RbDoc(doc))
     }
 
-    fn client_id(&self) -> u64 {
-        self.0.client_id().get()
-    }
-
-    fn guid(&self) -> String {
-        self.0.guid().to_string()
-    }
-
     fn encode_state_vector(&self) -> RString {
         let doc = &self.0;
         let sv = nogvl(move || {
@@ -211,7 +174,7 @@ impl RbDoc {
     }
 
     /// True if applying `update` would integrate cleanly (its dependencies are
-    /// all present). False means it would leave a pending struct -- an earlier
+    /// all present). False means it would leave a pending struct, i.e. an earlier
     /// update is missing. Pure read; does not mutate.
     fn update_ready(&self, update: RString) -> Result<bool, Error> {
         let update_bytes = copy_bytes(update);
@@ -228,13 +191,6 @@ impl RbDoc {
         nogvl(move || update_advances_doc(doc, &update_bytes)).map_err(yrb_error)
     }
 
-    /// True if the document holds pending (un-integrable) structs waiting on a
-    /// missing dependency.
-    fn pending(&self) -> bool {
-        let doc = &self.0;
-        nogvl(move || doc_has_pending(doc))
-    }
-
     /// Sync step 1: Create a sync message with our state vector
     fn sync_step1(&self) -> RString {
         let doc = &self.0;
@@ -246,23 +202,10 @@ impl RbDoc {
         binary_string(&encoded)
     }
 
-    /// Sync step 2: Create a sync message with updates for the given state vector
-    fn sync_step2(&self, sv_bytes: RString) -> Result<RString, Error> {
-        let sv_data = copy_bytes(sv_bytes);
-        let doc = &self.0;
-        let encoded = nogvl(move || -> Result<Vec<u8>, String> {
-            let sv = yrs::StateVector::decode_v1(&sv_data).map_err(|e| e.to_string())?;
-            let txn = doc.transact();
-            let update = txn.encode_state_as_update_v1(&sv);
-            Ok(Message::Sync(SyncMessage::SyncStep2(update)).encode_v1())
-        })
-        .map_err(yrb_error)?;
-        Ok(binary_string(&encoded))
-    }
-
-    /// Handle a sync message and return response (if any)
-    /// Returns [message_type, sync_type, response_bytes] or nil
-    fn handle_sync_message(&self, data: RString) -> Result<Option<(u8, u8, RString)>, Error> {
+    /// Handle a Sync or Awareness message, returning
+    /// [message_type, sync_type, response_bytes]. Only Sync (step1/step2/update)
+    /// and Awareness are handled; any other frame type is rejected.
+    fn handle_sync_message(&self, data: RString) -> Result<(u8, u8, RString), Error> {
         let data_bytes = copy_bytes(data);
         let doc = &self.0;
 
@@ -297,264 +240,55 @@ impl RbDoc {
                         }
                     },
                     Message::Awareness(_) => Ok((1, 0, Vec::new())),
-                    Message::AwarenessQuery => Ok((3, 0, Vec::new())),
-                    Message::Auth(_) => Ok((2, 0, Vec::new())),
-                    Message::Custom(tag, _) => Ok((tag, 0, Vec::new())),
+                    // Auth, awareness-query, and custom frames aren't part of this
+                    // protocol; reject rather than pretend to handle them.
+                    _ => Err("unsupported message type".to_string()),
                 }
             })
             .map_err(yrb_error)?;
 
-        Ok(Some((msg_type, sync_type, binary_string(&response))))
-    }
-
-    /// Encode raw update bytes as a sync Update message
-    fn encode_update_message(&self, update: RString) -> RString {
-        let update_bytes = copy_bytes(update);
-        let msg = Message::Sync(SyncMessage::Update(update_bytes));
-        binary_string(&msg.encode_v1())
+        Ok((msg_type, sync_type, binary_string(&response)))
     }
 }
 
 // ============================================================================
-// Awareness Implementation (includes Doc + presence)
+// Protocol codec (stateless), exposed as `YrbLite` module functions
 // ============================================================================
+//
+// The server never holds presence or document state to classify a frame; these
+// are pure functions of their bytes. (Presence lives in the browser clients; the
+// server only relays awareness frames opaquely.)
+
+/// Wrap a raw document update in a sync Update message frame, ready to relay.
+fn wrap_update(update: RString) -> RString {
+    let update_bytes = copy_bytes(update);
+    let msg = Message::Sync(SyncMessage::Update(update_bytes));
+    binary_string(&msg.encode_v1())
+}
 
-impl RbAwareness {
-    /// Create a new Awareness with an optional client_id
-    fn new(args: &[Value]) -> Result<Self, Error> {
-        let awareness = if args.is_empty() {
-            Awareness::new(Doc::new())
-        } else {
-            let client_id: u64 = TryConvert::try_convert(args[0])?;
-            Awareness::new(Doc::with_client_id(client_id))
-        };
-        Ok(RbAwareness(Mutex::new(awareness)))
-    }
-
-    fn client_id(&self) -> u64 {
-        let awareness = &self.0;
-        nogvl(move || awareness.lock().unwrap().doc().client_id().get())
-    }
-
-    fn guid(&self) -> String {
-        let awareness = &self.0;
-        nogvl(move || awareness.lock().unwrap().doc().guid().to_string())
-    }
-
-    /// A standalone SyncStep1 message (the server's state vector). Sent as its
-    /// own frame in the opening handshake so providers that parse one message
-    /// per frame (e.g. @y-rb/actioncable) handle it correctly.
-    fn sync_step1(&self) -> RString {
-        let awareness = &self.0;
-        let encoded = nogvl(move || {
-            let doc = awareness.lock().unwrap().doc().clone();
-            let txn = doc.transact();
-            let sv = txn.state_vector();
-            Message::Sync(SyncMessage::SyncStep1(sv)).encode_v1()
-        });
-        binary_string(&encoded)
-    }
-
-    /// Create initial sync messages to send when connection opens.
-    /// Returns binary data containing SyncStep1 + Awareness update.
-    fn start(&self) -> Result<RString, Error> {
-        let awareness = &self.0;
-        let encoded = nogvl(move || -> Result<Vec<u8>, String> {
-            let awareness = awareness.lock().unwrap();
-            let protocol = DefaultProtocol;
-            let mut encoder = EncoderV1::new();
-            protocol
-                .start(&awareness, &mut encoder)
-                .map_err(|e| e.to_string())?;
-            Ok(encoder.to_vec())
-        })
-        .map_err(yrb_error)?;
-        Ok(binary_string(&encoded))
-    }
-
-    /// Handle incoming message and return response messages (if any).
-    /// Returns binary data containing response messages, or empty if no response needed.
-    fn handle(&self, data: RString) -> Result<RString, Error> {
-        let data_bytes = copy_bytes(data);
-        let awareness = &self.0;
-
-        let encoded = nogvl(move || -> Result<Vec<u8>, String> {
-            let mut awareness = awareness.lock().unwrap();
-            let protocol = DefaultProtocol;
-            let responses = protocol
-                .handle(&mut awareness, &data_bytes)
-                .map_err(|e| e.to_string())?;
-
-            if responses.is_empty() {
-                return Ok(Vec::new());
-            }
-
-            let mut encoder = EncoderV1::new();
-            for msg in responses {
-                msg.encode(&mut encoder);
-            }
-            Ok(encoder.to_vec())
-        })
-        .map_err(yrb_error)?;
-        Ok(binary_string(&encoded))
-    }
-
-    /// Encode an update message for broadcasting changes to peers.
-    fn encode_update(&self, update: RString) -> RString {
-        let update_bytes = copy_bytes(update);
-        let msg = Message::Sync(SyncMessage::Update(update_bytes));
-        binary_string(&msg.encode_v1())
-    }
-
-    fn encode_state_vector(&self) -> RString {
-        let awareness = &self.0;
-        let sv = nogvl(move || {
-            let doc = awareness.lock().unwrap().doc().clone();
-            let txn = doc.transact();
-            txn.state_vector().encode_v1()
-        });
-        binary_string(&sv)
-    }
-
-    /// Encode state as update (optionally diffed against a state vector)
-    fn encode_state_as_update(&self, args: &[Value]) -> Result<RString, Error> {
-        let sv_bytes: Option<Vec<u8>> = if args.is_empty() {
-            None
-        } else {
-            let sv_string: RString = TryConvert::try_convert(args[0])?;
-            Some(copy_bytes(sv_string))
-        };
-        let awareness = &self.0;
-        let update = nogvl(move || -> Result<Vec<u8>, String> {
-            let sv = match &sv_bytes {
-                None => yrs::StateVector::default(),
-                Some(bytes) => yrs::StateVector::decode_v1(bytes).map_err(|e| e.to_string())?,
-            };
-            let doc = awareness.lock().unwrap().doc().clone();
-            let txn = doc.transact();
-            Ok(txn.encode_state_as_update_v1(&sv))
-        })
-        .map_err(yrb_error)?;
-        Ok(binary_string(&update))
-    }
-
-    /// Set local awareness state (JSON string)
-    fn set_local_state(&self, json: String) -> Result<(), Error> {
-        let value: serde_json::Value =
-            serde_json::from_str(&json).map_err(|e| yrb_error(e.to_string()))?;
-        let awareness = &self.0;
-        nogvl(move || -> Result<(), String> {
-            awareness
-                .lock()
-                .unwrap()
-                .set_local_state(value)
-                .map_err(|e| e.to_string())
-        })
-        .map_err(yrb_error)
-    }
-
-    /// Get local awareness state as JSON string (or nil if not set)
-    fn local_state(&self) -> Option<String> {
-        let awareness = &self.0;
-        nogvl(move || {
-            awareness
-                .lock()
-                .unwrap()
-                .local_state::<serde_json::Value>()
-                .map(|v| v.to_string())
-        })
-    }
-
-    /// Clear local awareness state
-    fn clear_local_state(&self) {
-        let awareness = &self.0;
-        nogvl(move || awareness.lock().unwrap().clean_local_state());
-    }
-
-    /// Get awareness update for broadcasting to peers
-    fn encode_awareness_update(&self) -> Result<RString, Error> {
-        let awareness = &self.0;
-        let encoded = nogvl(move || -> Result<Vec<u8>, String> {
-            let awareness = awareness.lock().unwrap();
-            let update = awareness.update().map_err(|e| e.to_string())?;
-            Ok(Message::Awareness(update).encode_v1())
-        })
-        .map_err(yrb_error)?;
-        Ok(binary_string(&encoded))
-    }
-
-    fn apply_update(&self, update: RString) -> Result<(), Error> {
-        let update_bytes = copy_bytes(update);
-        let awareness = &self.0;
-        nogvl(move || -> Result<(), String> {
-            let update = yrs::Update::decode_v1(&update_bytes).map_err(|e| e.to_string())?;
-            let doc = awareness.lock().unwrap().doc().clone();
-            let mut txn = doc.transact_mut();
-            txn.apply_update(update).map_err(|e| e.to_string())
-        })
-        .map_err(yrb_error)
-    }
-
-    /// True if applying `update` would integrate cleanly (its dependencies are
-    /// all present). False means it depends on a missing, causally-prior update.
-    /// Pure read; does not mutate.
-    fn update_ready(&self, update: RString) -> Result<bool, Error> {
-        let update_bytes = copy_bytes(update);
-        let awareness = &self.0;
-        nogvl(move || {
-            let doc = awareness.lock().unwrap().doc().clone();
-            update_is_ready(&doc, &update_bytes)
-        })
-        .map_err(yrb_error)
-    }
-
-    /// True if applying `update` would change the document, false if it's an
-    /// already-applied retry. See `update_advances_doc`. Pure read.
-    fn update_advances(&self, update: RString) -> Result<bool, Error> {
-        let update_bytes = copy_bytes(update);
-        let awareness = &self.0;
-        nogvl(move || {
-            let doc = awareness.lock().unwrap().doc().clone();
-            update_advances_doc(&doc, &update_bytes)
-        })
-        .map_err(yrb_error)
-    }
-
-    /// True if the document holds pending (un-integrable) structs waiting on a
-    /// missing dependency.
-    fn pending(&self) -> bool {
-        let awareness = &self.0;
-        nogvl(move || {
-            let doc = awareness.lock().unwrap().doc().clone();
-            doc_has_pending(&doc)
-        })
-    }
-
-    /// Classify a frame for safe routing and relay. Returns a code only when
-    /// the frame is exactly one well-formed message that consumes the whole
-    /// buffer, so a malformed, truncated, multi-message, or trailing-garbage
-    /// frame (which a malicious client could craft to disrupt others if
-    /// relayed) is rejected up front:
-    ///   0 = drop (malformed, multiple, unknown, or empty)
-    ///   1 = sync step1       (a request: respond, do not relay)
-    ///   2 = sync step2/update (a document change: record/apply/relay)
-    ///   3 = awareness        (presence: relay)
-    ///   4 = awareness query  (a request: respond, do not relay)
-    fn message_kind(&self, data: RString) -> u8 {
-        let data_bytes = copy_bytes(data);
-        nogvl(move || classify_message(&data_bytes))
-    }
+/// Classify a frame for safe routing and relay. Returns a code only when the
+/// frame is exactly one well-formed message that consumes the whole buffer, so
+/// a malformed, truncated, multi-message, or trailing-garbage frame (which a
+/// malicious client could craft to disrupt others if relayed) is rejected up
+/// front:
+///   0 = drop (malformed, multiple, unknown, or empty)
+///   1 = sync step1       (a request: respond, do not relay)
+///   2 = sync step2/update (a document change: record/apply/relay)
+///   3 = awareness        (presence: relay)
+///   4 = awareness query  (a request: respond, do not relay)
+fn message_kind(data: RString) -> u8 {
+    let data_bytes = copy_bytes(data);
+    nogvl(move || classify_message(&data_bytes))
+}
 
-    /// Extract the document-update delta carried by a protocol message: the
-    /// payloads of any Update or SyncStep2 sub-messages, merged into a single
-    /// update. Returns nil if the message carries no document change (for
-    /// instance a SyncStep1 request or an awareness update). The store-backed
-    /// path records this exact delta before relaying it.
-    fn update_from_message(&self, data: RString) -> Result<Option<RString>, Error> {
-        let data_bytes = copy_bytes(data);
-        let merged = nogvl(move || merged_doc_update(&data_bytes)).map_err(yrb_error)?;
-        Ok(merged.map(|b| binary_string(&b)))
-    }
+/// Extract the document-update delta carried by a protocol message: the payloads
+/// of any Update or SyncStep2 sub-messages, merged into a single update. Returns
+/// nil if the message carries no document change (a SyncStep1 request or an
+/// awareness update). The store-backed path records this exact delta before relay.
+fn update_from_message(data: RString) -> Result<Option<RString>, Error> {
+    let data_bytes = copy_bytes(data);
+    let merged = nogvl(move || merged_doc_update(&data_bytes)).map_err(yrb_error)?;
+    Ok(merged.map(|b| binary_string(&b)))
 }
 
 // ============================================================================
@@ -572,8 +306,6 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     // Define Doc class
     let doc_class = module.define_class("Doc", ruby.class_object())?;
     doc_class.define_singleton_method("new", function!(RbDoc::new, -1))?;
-    doc_class.define_method("client_id", method!(RbDoc::client_id, 0))?;
-    doc_class.define_method("guid", method!(RbDoc::guid, 0))?;
     doc_class.define_method(
         "encode_state_vector",
         method!(RbDoc::encode_state_vector, 0),
@@ -585,60 +317,19 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     doc_class.define_method("apply_update", method!(RbDoc::apply_update, 1))?;
     doc_class.define_method("update_ready?", method!(RbDoc::update_ready, 1))?;
     doc_class.define_method("update_advances?", method!(RbDoc::update_advances, 1))?;
-    doc_class.define_method("pending?", method!(RbDoc::pending, 0))?;
     doc_class.define_method("sync_step1", method!(RbDoc::sync_step1, 0))?;
-    doc_class.define_method("sync_step2", method!(RbDoc::sync_step2, 1))?;
     doc_class.define_method(
         "handle_sync_message",
         method!(RbDoc::handle_sync_message, 1),
     )?;
-    doc_class.define_method(
-        "encode_update_message",
-        method!(RbDoc::encode_update_message, 1),
-    )?;
-
-    // Define Awareness class
-    let awareness_class = module.define_class("Awareness", ruby.class_object())?;
-    awareness_class.define_singleton_method("new", function!(RbAwareness::new, -1))?;
-    awareness_class.define_method("client_id", method!(RbAwareness::client_id, 0))?;
-    awareness_class.define_method("guid", method!(RbAwareness::guid, 0))?;
-    awareness_class.define_method("start", method!(RbAwareness::start, 0))?;
-    awareness_class.define_method("sync_step1", method!(RbAwareness::sync_step1, 0))?;
-    awareness_class.define_method("handle", method!(RbAwareness::handle, 1))?;
-    awareness_class.define_method("encode_update", method!(RbAwareness::encode_update, 1))?;
-    awareness_class.define_method(
-        "encode_state_vector",
-        method!(RbAwareness::encode_state_vector, 0),
-    )?;
-    awareness_class.define_method(
-        "encode_state_as_update",
-        method!(RbAwareness::encode_state_as_update, -1),
-    )?;
-    awareness_class.define_method("apply_update", method!(RbAwareness::apply_update, 1))?;
-    awareness_class.define_method("update_ready?", method!(RbAwareness::update_ready, 1))?;
-    awareness_class.define_method("update_advances?", method!(RbAwareness::update_advances, 1))?;
-    awareness_class.define_method("pending?", method!(RbAwareness::pending, 0))?;
-    awareness_class.define_method("set_local_state", method!(RbAwareness::set_local_state, 1))?;
-    awareness_class.define_method("local_state", method!(RbAwareness::local_state, 0))?;
-    awareness_class.define_method(
-        "clear_local_state",
-        method!(RbAwareness::clear_local_state, 0),
-    )?;
-    awareness_class.define_method(
-        "encode_awareness_update",
-        method!(RbAwareness::encode_awareness_update, 0),
-    )?;
-    awareness_class.define_method(
-        "update_from_message",
-        method!(RbAwareness::update_from_message, 1),
-    )?;
-    awareness_class.define_method("message_kind", method!(RbAwareness::message_kind, 1))?;
+    // Stateless protocol codec, as YrbLite module functions.
+    module.define_module_function("wrap_update", function!(wrap_update, 1))?;
+    module.define_module_function("message_kind", function!(message_kind, 1))?;
+    module.define_module_function("update_from_message", function!(update_from_message, 1))?;
 
     // Define message type constants
     module.const_set("MSG_SYNC", 0u8)?;
     module.const_set("MSG_AWARENESS", 1u8)?;
-    module.const_set("MSG_AUTH", 2u8)?;
-    module.const_set("MSG_QUERY_AWARENESS", 3u8)?;
     module.const_set("MSG_SYNC_STEP1", 0u8)?;
     module.const_set("MSG_SYNC_STEP2", 1u8)?;
     module.const_set("MSG_SYNC_UPDATE", 2u8)?;

data/ext/yrb_lite/src/protocol.rs

@@ -1,9 +1,9 @@
-// Pure rust protocol helpers (ie, no Ruby interop).
+// Pure Rust protocol helpers (no Ruby interop).
 //
-// CLIENT IDs ARE NOT VALIDATED HERE -- on purpose. We deliberately don't police it -- every
-// legitimate peer (browser Yjs, and yrs's own `ClientID::random`) already emits
-// 53-bit ids, so it's the client's responsibility not to send a bad one, and we
-// don't want to own that logic.
+// Client ids are not validated here, on purpose: every legitimate peer (browser
+// Yjs, and yrs's own `ClientID::random`) already emits 53-bit ids, so it's the
+// client's responsibility not to send a bad one, and we don't want to own that
+// logic.
 use yrs::encoding::read::{Cursor, Read};
 use yrs::sync::protocol::MessageReader;
 use yrs::sync::{Message, SyncMessage};
@@ -11,7 +11,7 @@ use yrs::updates::decoder::{Decode, DecoderV1};
 use yrs::{Doc, ReadTxn, Transact};
 
 /// Classify a frame: a non-zero code only for exactly one well-formed message
-/// that consumes the whole buffer (see `RbAwareness::message_kind` for codes).
+/// that consumes the whole buffer (the codes are the match arms below).
 pub(crate) fn classify_message(bytes: &[u8]) -> u8 {
     let mut decoder = DecoderV1::new(Cursor::new(bytes));
     let msg = match Message::decode(&mut decoder) {
@@ -53,7 +53,7 @@ pub(crate) fn merged_doc_update(bytes: &[u8]) -> Result<Option<Vec<u8>>, String>
     let update = yrs::Update::decode_v1(&merged).map_err(|e| e.to_string())?;
     // A genuine no-op (e.g. the empty SyncStep2 in an opening handshake) carries
     // no structs, no deletes, and no dependencies. We must NOT treat a causally-
-    // pending update as a no-op: since yrs 0.26 such an update reports an empty
+    // pending update as a no-op: such an update reports an empty
     // state_vector (its structs can't integrate yet), but it still carries
     // content and a non-empty lower bound (the deps it's waiting on). Dropping it
     // here would silently swallow a gappy update instead of rejecting + resyncing.
@@ -69,29 +69,29 @@ pub(crate) fn merged_doc_update(bytes: &[u8]) -> Result<Option<Vec<u8>>, String>
 /// True if applying `update_bytes` to `doc` would integrate cleanly: every
 /// dependency the update references is already present (the doc's state vector
 /// covers the update's lower bound). A pure read; does not mutate the doc.
-/// When false, applying it would park a pending struct -- the signal that an
+/// When false, applying it would park a pending struct, the signal that an
 /// earlier, causally-prior update is missing.
 pub(crate) fn update_is_ready(doc: &Doc, update_bytes: &[u8]) -> Result<bool, String> {
     let update = yrs::Update::decode_v1(update_bytes).map_err(|e| e.to_string())?;
     Ok(doc.transact().state_vector() >= update.state_vector_lower())
 }
 
-/// True if applying `update_bytes` would actually change `doc` -- i.e. it carries
-/// content the doc doesn't already have. Lets the server make durable side
+/// True if applying `update_bytes` would actually change `doc`, i.e. it carries
+/// content the doc doesn't already have. This lets the server make durable side
 /// effects exactly-once: a lost-ack retry re-sends an update the server already
 /// applied; that retry is causally ready (so `update_is_ready` is true) but must
-/// NOT re-run `on_change`.
+/// not re-run `on_change`.
 ///
 /// We can't read the update's own state vector to decide this: yrs reports an
-/// EMPTY state_vector() for a causally-pending diff (e.g. a resync delta whose
+/// empty state_vector() for a causally-pending diff (e.g. a resync delta whose
 /// structs depend on updates the doc has but the standalone update doesn't),
 /// which would look identical to a no-op. So measure the real effect: seed an
 /// independent probe with the doc's current state, apply the update there, and
 /// see whether the state vector grew. Deletes don't move the state vector, so we
-/// can't cheaply prove a delete-bearing update is a duplicate -- we
-/// conservatively report it as advancing (record it). That can still
-/// double-record a pure-delete retry, but it NEVER drops a real deletion, which
-/// is the safe direction. Assumes the update is already causally ready.
+/// can't cheaply prove a delete-bearing update is a duplicate; we conservatively
+/// report it as advancing (record it). That can still double-record a pure-delete
+/// retry, but it never drops a real deletion, which is the safe direction.
+/// Assumes the update is already causally ready.
 pub(crate) fn update_advances_doc(doc: &Doc, update_bytes: &[u8]) -> Result<bool, String> {
     let update = yrs::Update::decode_v1(update_bytes).map_err(|e| e.to_string())?;
     if !update.delete_set().is_empty() {
@@ -114,9 +114,10 @@ pub(crate) fn update_advances_doc(doc: &Doc, update_bytes: &[u8]) -> Result<bool
     Ok(after != before)
 }
 
-/// True if the doc holds pending structs or a pending delete set -- blocks that
-/// couldn't integrate because a dependency is missing. Used as a backstop after
-/// loading from storage: leftover pending means the stored log has a causal gap.
+/// True if the doc holds pending structs or a pending delete set: blocks that
+/// couldn't integrate because a dependency is missing. Test-only: asserts the
+/// causal-chain parking behavior in the unit tests below.
+#[cfg(test)]
 pub(crate) fn doc_has_pending(doc: &Doc) -> bool {
     let txn = doc.transact();
     txn.store().pending_update().is_some() || txn.store().pending_ds().is_some()
@@ -212,8 +213,8 @@ mod tests {
     #[test]
     fn update_advances_handles_a_dependent_diff_update() {
         // A causally-pending diff (its structs depend on content the doc already
-        // has) reports an EMPTY state_vector() in isolation -- a naive check would
-        // misread it as a no-op. Verify the trial-apply gets it right.
+        // has) reports an empty state_vector() in isolation, which a naive check
+        // would misread as a no-op. Verify the trial-apply gets it right.
         let doc = Doc::new();
         let text = doc.get_or_insert_text("content");
         text.insert(&mut doc.transact_mut(), 0, "a");

data/lib/yrb-lite.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
-# Entry point matching the gem name, so `Bundler.require` works out of the box.
+# Entry point matching the gem name, so `Bundler.require` loads it automatically.
 require "yrb_lite"

data/lib/yrb_lite/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module YrbLite
-  VERSION = "0.1.0.beta7"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yrb-lite
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta7
+  version: 0.2.0
 platform: ruby
 authors:
 - JP Camara