yrb-lite 0.1.0.beta5-aarch64-linux → 0.1.0.beta6-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fce4e6337e2a2df0f2f44db2b5df7447a1b05b2cddd5976d99975c6a1fa62a1
-  data.tar.gz: 55c409d86e2f27b69eac45e2f909b8a87d3ff4ef5e8cb7b7e68db3c94b1174fe
+  metadata.gz: 2730b0d6a2bc31a36de1f842d7345659788d4c45968a895dfbbf7855ee6be21d
+  data.tar.gz: 9731717390fc3e45c983f20dd51429c214a6aaca85cb75b0e375a34390a785e0
 SHA512:
-  metadata.gz: ad0f9a7c036b495e331ea12c0929fc9d7a0dbbebdf5e65e5477366ee60f744b37b25c3fd590a33a4b7434091c30d3ef2865b8d7ef5a3fdb426fe11b3d0e265b9
-  data.tar.gz: 5fe28a7bc60182a5e268baf5543ea10dc57b6950951f4c18db606db60422759cd8f6b4be5caf04bbfba56938aad283a8cd41e96ca5e55ddd63d0a94354c3cba3
+  metadata.gz: '0913343e81dd6564a2ce23f058ec63cadb23917a105a86e430d859df77856054a8c0e4c02051a28a0dc8903c916f8c7ea60dd051ae8cbc022064d28539610680'
+  data.tar.gz: fb98a8a3e81ec173f812618dce6075a84f6516e4c7991c650c35835958465312b5b0380176a1e5628fdf302de8faa0ec05d3df64b1f78533c96820825ec4d2bc

data/CHANGELOG.md

@@ -6,6 +6,35 @@ 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
@@ -33,9 +62,7 @@ to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   `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. `on_load`/`on_save` are unchanged: they can run in the shared
-  document registry during a cold load or eviction, where no connection
-  instance exists, so they remain key-only. Existing block recorders that use
+  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.
 
@@ -67,15 +94,13 @@ to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 - 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
-  accepted (recorded in audit mode, applied in fast mode). This lets an
+  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. Stock clients send no
-  `"id"`, never get acks, and behave exactly as before.
-- A vendored, ack-aware `@y-rb/actioncable` provider in the demo
-  (`reliable_actioncable_provider.mjs`) that adds 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.
+  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
 
@@ -95,14 +120,11 @@ to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   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). It's wire-compatible with
-  the [`@y-rb/actioncable`](https://www.npmjs.com/package/@y-rb/actioncable)
-  browser provider, and accepts its `{ update: ... }` envelope and `{ m: ... }`.
+  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.
-- Two backends: `sync_backend :memory` (default, classic ActionCable) and
-  `sync_backend :store` (stateless, AnyCable-ready, multi-process).
+- 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.

data/README.md

@@ -9,26 +9,27 @@ documents.
 
 ```ruby
 class DocumentChannel < ApplicationCable::Channel
-  include YrbLite::Sync
+  include YrbLite::ActionCable::Sync
 
   def subscribed   = sync_for(params[:id])
   def receive(data) = sync_receive(data)
-  def unsubscribed = sync_clear_presence
+  def unsubscribed = sync_unsubscribed(params[:id])
 end
 ```
 
-On the browser, use the [`@y-rb/actioncable`](https://www.npmjs.com/package/@y-rb/actioncable)
-provider as-is. Tiptap, ProseMirror, and BlockNote all sync through it.
+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.
 
 ## What you get
 
-- Thread-safe `Doc` and `Awareness`. You can share them across Puma threads,
-  and the GVL is released while yrs does the actual work.
+- Thread-safe Ruby wrappers for `Doc` and `Awareness`. You can share them
+  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.
-- A store-backed mode for AnyCable and multi-process deployments.
-- An optional authoritative mode that records each change durably before it
-  goes out to anyone.
+- Store-backed ActionCable/AnyCable delivery for multi-process deployments.
+- Authoritative record-before-distribute semantics: each document change is
+  recorded durably before it goes out to anyone.
 
 What it doesn't do: auth, read-only connections, rate limiting, webhooks,
 metrics. Hocuspocus ships extensions for those; here you'd build them with
@@ -36,21 +37,26 @@ Rails.
 
 ## Testing
 
-Ruby and Rust unit tests cover the core, and an end-to-end suite runs the real
-stack: it fuzzes the protocol, throws garbage and chaos at the server, kills the
-server mid-write to check crash recovery, and drives real browsers under load.
-The benchmark numbers below are from a single laptop. Issues and PRs are
-welcome.
+Ruby and Rust unit tests cover the core. CI also runs the npm client tests and a
+Rails demo smoke slice against the real ActionCable stack. The demo includes
+heavier local suites for hostile input, crash recovery, multi-browser editing,
+AnyCable, and load testing. The benchmark note below is from a single laptop.
+Issues and PRs are welcome.
 
 ## Install
 
 ```ruby
+# Core CRDT + protocol primitives:
 gem "yrb-lite"
+
+# For the Rails/ActionCable server concern (YrbLite::ActionCable::Sync):
+gem "yrb-lite-actioncable"
 ```
 
-Requires Ruby 3.4 or newer. Precompiled gems ship for Linux and macOS on Ruby
-3.4 and 4.0, so installing there needs no Rust. Other platforms (and any other
-Ruby version) build from source, which needs [Rust](https://rustup.rs).
+Requires Ruby 3.4 or newer. The release workflow builds precompiled gems for
+Ruby 3.4 and 4.0 across the supported Ruby platforms, with native smoke tests
+on Linux x86_64 and macOS arm64. Installing from a matching platform gem needs
+no Rust; a source build needs [Rust](https://rustup.rs).
 
 To work on the gem itself:
 
@@ -128,44 +134,43 @@ send_to_peer(response) unless response.empty?
 
 ### ActionCable Integration
 
-`YrbLite::Sync` is a channel concern that implements the full y-websocket
-protocol (document sync + awareness/presence) over ActionCable:
+`YrbLite::ActionCable::Sync` (from the `yrb-lite-actioncable` gem) is a channel
+concern that implements the full y-websocket protocol (document sync +
+awareness/presence) over ActionCable:
 
 ```ruby
 # app/channels/document_channel.rb
 class DocumentChannel < ApplicationCable::Channel
-  include YrbLite::Sync
+  include YrbLite::ActionCable::Sync
 
-  # Optional persistence:
-  # on_load { |key| Document.find_by(key: key)&.content }
-  # on_save { |key, update| Document.find_by(key: key)&.update!(content: update) }
+  on_load { |key| MyStore.load(key) }                 # source of truth
+  on_change { |key, update| MyStore.append(key, update) } # durable record
 
   def subscribed
     sync_for params[:id]
   end
 
   def receive(data)
-    sync_receive(data)
+    sync_receive(data, params[:id])
   end
 
   def unsubscribed
-    sync_clear_presence
+    sync_unsubscribed(params[:id])
   end
 end
 ```
 
-One `YrbLite::Awareness` is shared per document key. Creating it is
-mutex-serialized; after that everything runs lock-free on the thread-safe
-native types. The concern answers SyncStep1 directly, relays document and
-awareness changes to the other subscribers (not back to the sender), and calls
-`on_save` after any message that changed the document.
+The concern is store-backed. A handshake is answered from `on_load`; document
+changes are checked against that durable state, recorded through `on_change`,
+then broadcast. Nothing authoritative is kept in ActionCable process memory, so
+AnyCable RPC workers, Puma workers, and separate dynos can all handle messages
+for the same document as long as they share the same store and cable adapter.
 
-`sync_unsubscribed` clears the connection's presence, so a closed tab doesn't
-leave a stale cursor hanging until the client-side timeout. It also unloads the
-document from memory once the last subscriber disconnects, which keeps the
-process from holding onto every document it ever served. That unload only
-happens when `on_load` is set and the document can be reloaded later; without
-it, the in-memory copy is the only one and stays put.
+`on_load` and `on_change` are required. If either is missing, the channel fails
+closed before it can acknowledge or broadcast edits. Presence is ephemeral:
+awareness frames are relayed, and `yrb-lite-client` sends a best-effort
+presence-removal frame on disconnect/pagehide, with the client-side awareness
+timeout as the fallback for abrupt disconnects.
 
 Incoming frames are validated as a single well-formed protocol message before
 anything processes or relays them. Malformed, truncated, multi-message,
@@ -182,37 +187,19 @@ Broadcasts cross processes through the Action Cable adapter, so it needs to be a
 real one (`redis` or `solid_cable`, not `async`). With that in place, a change
 on one process reaches clients on all of them.
 
-Each process also keeps its own copy of the document and applies broadcasts from
-the others. The merge is an ordinary CRDT apply, idempotent and
-order-independent, which keeps server reads and new-client handshakes current on
-every process. Each broadcast carries a per-process id (`Sync.process_id`) that
-tells a process to skip its own.
-
-A cold process (no copy yet) rebuilds from the durable store through `on_load`.
-In authoritative mode the store is always current, since changes are recorded
-before they go out. Record-before-distribute therefore holds across processes:
-whichever process receives a change records it to the shared store before
-anyone, anywhere, sees it.
+Every process rebuilds document state from the durable store through `on_load`.
+Because changes are recorded before broadcast, record-before-distribute holds
+across processes: whichever process receives a change records it to the shared
+store before anyone, anywhere, sees it.
 
 `bun multiprocess.mjs` in the demo runs clients across two processes and checks
-the lot: convergence, fresh copies on both, presence across processes, and one
-shared log.
-
-##### AnyCable (`sync_backend :store`)
+convergence, fresh reads on both, presence across processes, and one shared log.
 
-The default backend keeps that warm in-memory copy and relies on a `stream_from`
-block running in Ruby for each broadcast. AnyCable breaks both assumptions.
-anycable-go delivers broadcasts outside Ruby, so the block never runs. Each RPC
-gets a fresh channel instance, which means ivars set in `subscribed` are gone by
-`receive`. And there's no fixed worker-to-document mapping to lean on.
-
-`sync_backend :store` is the path for that: stateless per message, no warm
-copy.
+##### AnyCable
 
 ```ruby
 class DocumentChannel < ApplicationCable::Channel
-  include YrbLite::Sync
-  sync_backend :store
+  include YrbLite::ActionCable::Sync
 
   on_load  { |key| MyStore.load(key) }          # required: source of truth
   on_change { |key, update| MyStore.append(key, update) }  # required: record
@@ -227,6 +214,10 @@ end
 - A handshake (SyncStep1) is answered from the store. Changes are recorded, then
   broadcast. Nothing is held in Ruby between calls, so any worker can handle any
   message.
+- Document frames use the normal server path. Awareness/presence uses a
+  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.
 - The sender gets its own updates echoed back (no Ruby callback to filter them).
@@ -234,34 +225,31 @@ end
 
 The demo checks this against a real anycable-go + RPC server
 (`frontend/anycable_probe.mjs`, `anycable_concurrent.mjs`): liveness, the
-`@y-rb/actioncable` provider, cross-process reads, and concurrent convergence.
+yrb-lite client provider, cross-process reads, and concurrent convergence.
 
 The wire format is the standard y-protocols binary messages, base64-encoded in
-the ActionCable envelope. The server accepts the `@y-rb/actioncable` provider's
-`{ "update" => ... }` envelope (and its own `{ "m" => ... }`) and sends one
-message per frame, so the off-the-shelf provider works with no custom client
-code:
+the ActionCable envelope. yrb-lite uses one canonical document envelope,
+`{ "update" => ... }`, and sends one message per frame.
 
 ```js
-import { createConsumer } from "@rails/actioncable"
-import { WebsocketProvider } from "@y-rb/actioncable"
+import { createConsumer } from "@anycable/web"
+import { ActionCableProvider } from "yrb-lite-client"
 
-const provider = new WebsocketProvider(ydoc, createConsumer(), "DocumentChannel", { id: docId })
+const provider = new ActionCableProvider(ydoc, createConsumer(), "DocumentChannel", { id: docId })
+provider.connect()
 ```
 
 [`examples/actioncable-demo`](examples/actioncable-demo) is a full Rails + Tiptap
-app using that provider, with end-to-end tests.
+app using the yrb-lite provider, with end-to-end tests.
 
-#### Authoritative audit mode (record before distribute)
+#### Record Before Distribute
 
-By default a change is applied and broadcast immediately (the fast path). If you
-need to durably record every change before anyone else sees it, whether for
-auditing or to guarantee nothing is distributed until it's stored, register an
-`on_change` recorder:
+Every document change is durably recorded before anyone else sees it. Register
+an `on_change` recorder:
 
 ```ruby
 class DocumentChannel < ApplicationCable::Channel
-  include YrbLite::Sync
+  include YrbLite::ActionCable::Sync
 
   on_change do |key, update|
     # Synchronous, durable write. `update` is the exact CRDT delta.
@@ -269,78 +257,43 @@ class DocumentChannel < ApplicationCable::Channel
   end
 
   def subscribed = sync_for(params[:id])
-  def receive(data) = sync_receive(data)
-  def unsubscribed = sync_clear_presence
+  def receive(data) = sync_receive(data, params[:id])
+  def unsubscribed = sync_unsubscribed(params[:id])
 end
 ```
 
 With `on_change` registered, a change is recorded before it goes anywhere. The
 recorder writes the raw CRDT delta synchronously; only then is the change
-applied to the shared document and broadcast. The whole sequence runs under a
-per-document lock, so every change to a document is recorded in the same order
-it's applied. That's what makes the log authoritative. Replay the deltas onto a
-fresh `Y.Doc` and you get the document back exactly.
+broadcast. Replay the deltas onto a fresh `Y.Doc` and you get the document back
+exactly.
 
 If the recorder raises (say the store is down), the change is rejected: not
 applied, not sent to anyone. The cost is a synchronous durable write per change,
 which serializes that document's writes. Other documents use other locks and run
 in parallel.
 
-`on_change` and `on_save` are separate. `on_save` snapshots the whole document
-when it gets a chance; `on_change` is the per-change log. The demo's `AUDIT=1`
-mode (in [`examples/actioncable-demo`](examples/actioncable-demo)) wires
-`on_change` to an fsync'd append-only log and checks, end to end, that the log
-alone rebuilds the document.
+The demo wires `on_change` to a durable Postgres-backed log by default, with an
+fsync'd file log available via `STORE_KIND=file`, and checks end to end that the
+log alone rebuilds the document.
 
 #### Reliable delivery (acks)
 
-The y-websocket protocol is fire-and-forget. If a client's update is lost in
-transit (a flaky socket, a send that never lands) and the client makes no
-further edits, the server stays idle and never asks anyone to resync, so that
-edit is gone -- even though the client believes it was saved. CRDTs converge the
-state everyone *has*; they don't recover an update that never arrived.
-
-yrb-lite closes that gap with an opt-in, client-driven acknowledgement. If an
-incoming frame carries an `"id"`, the server replies `{ "ack": <id> }` once the
-update has been **accepted** -- recorded in audit mode, applied in fast mode. A
-causally-gapped update is not acked (it gets a resync instead), so the client
-knows it hasn't landed yet.
+yrb-lite document delivery is ack-tracked. Browser document updates carry an
+`"id"`, and the server replies `{ "ack": <id> }` once the update has been
+**durably recorded**. A causally-gapped update is not acked; the server sends a
+resync request, and the client keeps the update queued until it lands.
 
 ```
-client -> server   { "m": "<base64 update>", "id": 42 }
+client -> server   { "update": "<base64 update>", "id": 42 }
 server -> client    { "ack": 42 }     # update accepted; safe to forget
 ```
 
-That's the whole server side. A reliable client tags each outgoing update with
-an incrementing id, keeps it in a pending buffer, and retransmits on a timer (and
-on reconnect) until the matching ack returns. Because CRDT apply is idempotent, a
-resend that already landed is a harmless no-op that just re-acks. An update lost
-in transit is recovered by the client's own retransmit -- no reconnect required,
-and no dependence on a later edit happening to trigger a resync.
-
-This is entirely **self-gating**: stock clients send no `"id"`, so they never get
-acks and behave exactly as before. Only a client that opts in by tagging its
-frames participates.
-
-Two client examples ship in the demo:
-
-- [`frontend/reliable.mjs`](examples/actioncable-demo/frontend/reliable.mjs) — a
-  minimal reference client showing the raw mechanism (tag with an id, retain,
-  retransmit on a timer, drain on ack), with an end-to-end test that loses an
-  update mid-flight and recovers it purely by retransmit.
-- [`frontend/provider/reliable_actioncable_provider.mjs`](examples/actioncable-demo/frontend/provider/reliable_actioncable_provider.mjs)
-  — the standard `@y-rb/actioncable` `WebsocketProvider`, vendored and augmented
-  for production use. It's a drop-in replacement that speaks the same protocol
-  and envelope, and adds reliability with **sync-since-last-ack** framing: rather
-  than retransmitting updates one by one, it keeps the unacknowledged local
-  updates in a queue and sends their *merge* as a single causally-complete delta,
-  with the id being the highest sequence in the batch (so one `{ ack: id }`
-  cumulatively confirms everything up to it). Because the whole unacked tail goes
-  as one self-contained delta, the server never sees an internal gap and never
-  has to round-trip a resync for a lost middle update — the next edit, or the
-  next timer tick, carries it. Awareness stays fire-and-forget; against a server
-  that doesn't implement acks it warns once and falls back to plain delivery; and
-  `reliable: false` opts out entirely. The demo's editor uses this provider.
+`yrb-lite-client`'s `ActionCableProvider` handles this automatically. It keeps
+the unacknowledged local document tail in a queue and sends the merged tail as a
+single causally-complete delta. The id is the highest sequence in the batch, so
+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
 
@@ -376,24 +329,24 @@ message = awareness.encode_update(update_bytes)
 
 ## Thread Safety
 
-Unlike the official `y-rb` gem, yrb-lite is 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.
+`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.
 
 That comes from how the underlying types work, not from locking on top:
 
 - `yrs::Doc` is `Send + Sync`. Every operation takes the document's internal
   RwLock with blocking semantics (`read_blocking`/`write_blocking`), so
   concurrent access serializes instead of erroring or corrupting state.
-- `yrs::sync::Awareness` is built for multi-threaded servers: client states
-  live in a `DashMap` and the whole API is `&self`.
-- The extension adds no interior-mutability tricks. There's no `RefCell`, where
-  a re-entrant borrow would panic and take the Ruby process down with it.
-  Each native method opens and closes its transaction in one call, so no lock
-  or borrow outlives a call and there's nothing to deadlock on.
-- A `Send + Sync` static assertion for both wrapped types lives in `lib.rs`. If
-  a yrs upgrade regressed this, the gem would fail to compile instead of quietly
-  turning thread-unsafe.
+- `yrs::sync::Awareness` is `Send` but not `Sync` in the current yrs version,
+  so the Ruby wrapper stores it in a `Mutex`. The mutex is always acquired
+  inside the no-GVL native section and released before Ruby runs again.
+- The extension uses no `RefCell`-style runtime borrows that could panic under
+  re-entrancy. Each native method opens and closes its transaction or mutex
+  guard inside one call.
+- Static assertions in `lib.rs` prove `Doc` and `Mutex<Awareness>` are
+  `Send + Sync`. If a yrs upgrade regressed either wrapper's thread-safety, the
+  gem would fail to compile instead of quietly turning thread-unsafe.
 
 `test/thread_safety_test.rb` runs shared docs, the full sync handshake, fan-in
 sync, and awareness state across 8 threads at once, and checks the interleaving
@@ -414,11 +367,12 @@ A slow operation also can't stall the VM. A thread applying a large update holds
 the doc's write lock without holding the GVL, so other Ruby threads keep running
 instead of queuing behind it.
 
-Each method has the same shape: copy the Ruby byte string, drop the GVL, do the
-yrs work (taking and releasing the doc lock entirely inside the closure), take
-the GVL back, then build Ruby objects. No Ruby API is touched without the GVL,
-and the doc lock is never held across a GVL boundary, so the lock order can't
-deadlock. Panics in native code are caught and re-raised as Ruby exceptions.
+Each method has the same shape: copy Ruby byte strings first, drop the GVL, do
+the yrs work while taking and releasing native locks entirely inside the
+closure, take the GVL back, then build Ruby objects. No Ruby API is touched
+without the GVL, and no native lock is held while reacquiring it, so the lock
+order can't deadlock. Panics in native code are caught and re-raised as Ruby
+exceptions.
 
 ## Message Type Constants
 

data/lib/yrb_lite/version.rb

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

metadata

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