yrb-lite 0.1.0.beta9-x86_64-linux → 0.2.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc720a5faecec2dfb0ec89963797944f1dd57bcb97144fca78bddf6e5d80297d
-  data.tar.gz: 83823b92fc78b4b5d47256ff51b8cb61bebf16c101fb968893580792b3fa96f9
+  metadata.gz: 4f59eb8dd6932e3c2332a23da5e4c23bf772ffd24071f44e10cd0da721aa8365
+  data.tar.gz: e29d6aab6138f4d15cdffd4b1294aff9dd783b36ee99ac1af0d4a16c268fb0ce
 SHA512:
-  metadata.gz: 10dc5adae589b59709b1bb9c112971aaa98dc2c7cf9a0710fd050a6a812d35e2539a55b7793684f8d634ad9be9fbd012afc09461279c90d0c3d1ab8a134761e8
-  data.tar.gz: '08573a8e489820c01c692553f475672fa92f8b55eb14b1c9d29e1fe7707a41e4c81d4ccaa5d22001f71cd05d8af98851a7e4dd3ecc835bf80870841ec6389eba'
+  metadata.gz: 9c86354666e93c157927ca87ee246642ca558b4bfa6da340efa077864fa62099dd0e5f4e719f681c6853e2eb75c6e6c7bc447494e2d102430f9f02c8960c6ce8
+  data.tar.gz: b93343e1b592db74e92f67f88011ba549d46789cdb002c6a45ed264ff0cc066f0a7f993a35bfa207bdff976a08afaaa539581932f5c0550e825b5bf6331b6f9a

data/README.md

@@ -11,9 +11,8 @@ 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
 ```
 
@@ -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
@@ -130,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
 ```
 
@@ -182,6 +193,26 @@ servers:
   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
@@ -215,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
 ```
 
@@ -229,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.
 
@@ -267,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
 ```
 
@@ -362,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/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.beta9"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yrb-lite
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta9
+  version: 0.2.0
 platform: x86_64-linux
 authors:
 - JP Camara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-24 00:00:00.000000000 Z
+date: 2026-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest