yrby 0.2.3-aarch64-linux → 0.3.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e672475cdf4e8d6bee399365c00ca8059b192b9232767e5854a20988c7b7e629
-  data.tar.gz: 70ca13fb08dbdb54c96cdcc2c6dd5af31ef4af76af9896f15f4d17dddc4bb586
+  metadata.gz: d23cfc4529b65f1bc9b1ad727c4f21894ce336dcc4c8aac3a676ddade4557ff1
+  data.tar.gz: 0b40878c0e0fe2cbc8295a074bf6609b45beb80375713e1390a116b301b35787
 SHA512:
-  metadata.gz: 488c5e0a897958d514a5a31fd6ec488b31c84d9b54bc0ca625fdbe11a9b37e4df4102b97563316f957e4801a60f51997f7d326fb7df0e50aa6196c3e915a6408
-  data.tar.gz: 8b8d7de6765a87b218df2a3d57c541a6f678a73ed79bd6091c80b757bc2aee866fd8115d6e793d941d8665e5543ef58711ce5e014b5654899ce5a92a6d2f6c09
+  metadata.gz: 42fd99039628908e230393760a55a999652d3993441796f4bd45d7371674e80fe9a82ba103183b613608fc737a83e26bbaaeddd83bc6cc87936eea2113225ca3
+  data.tar.gz: ca67b181166c76f830a997ea0140684395ae68ed452bd1c9afd94e825ba4da64364189c47f20603837df506cd3d84b9e1edc577bc0b2585616c497e678afba78

data/CHANGELOG.md

@@ -6,6 +6,73 @@ to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.3.1] - 2026-07-01
+
+Fixes from a full source review.
+
+### Fixed
+
+- **`Doc#update_ready?` is now exact.** It previously checked only the
+  per-client clock lower bound, but yrs's real integration gate also requires
+  every block referenced by an item's origin / right-origin / parent — which
+  routinely belong to *other* clients — and post-Skip blocks in a merged update
+  sit above the lower bound. An update could pass the clock check yet park as
+  pending; downstream, `update_advances?` then misread the parked update as an
+  already-applied retry (pending doesn't move a state vector) and the sync
+  channel **acked and dropped real content**. `update_ready?` now
+  trial-integrates on a throwaway probe seeded with the doc's integrated state
+  (the clock check remains as a cheap pre-filter), so a cross-client-origin gap
+  is correctly rejected for a resync. `update_advances?` also gained defense in
+  depth: an update that would park reports as advancing, never as a duplicate.
+- **`Doc#read_text` could deadlock the process.** It opened a second read
+  transaction while still holding the first (a chained temporary); yrs's lock is
+  write-preferring, so a concurrent writer between the two acquisitions
+  deadlocked reader-vs-writer inside the GVL-released (uninterruptible) region.
+  Now uses a single transaction.
+- **TOCTOU in gap-free encoding.** The pending check and the encode ran in
+  separate transactions, so a concurrent gappy `apply_update` between them could
+  make `handle_sync_message`/`compacted_state_update` serve pending structs
+  anyway. Both now happen under one transaction.
+- `read_xml`: Lexical soft line breaks and tabs now come through as `\n`/`\t`
+  instead of vanishing (`"foo⏎bar"` no longer extracts as `"foobar"`).
+
+### Changed
+
+- `update_advances?` skips its full-document probe when the update carries
+  blocks beyond the doc's state vector (a novel update trivially advances) —
+  the common case no longer pays O(doc) per frame.
+- The gem no longer packages the `yrby-decoder` gem's files (they ship in that
+  gem; the duplicate copy could shadow a newer standalone release), and now
+  ships `Cargo.lock` so source builds compile the exact crate graph CI tested.
+
+## [0.3.0] - 2026-07-01
+
+### Fixed
+
+- **Sync no longer serves un-integrable pending structs.** When a doc holds a
+  *pending* struct (a gappy update whose causally-prior update is missing — e.g.
+  legacy data recorded before the `update_ready?` gate existed), its integrated
+  state vector is empty but `encode_state_as_update` merges the pending bytes back
+  in. Answering a peer's `SyncStep1` with that state handed the peer content it
+  couldn't integrate, so it parked the same pending forever and the empty-SV /
+  non-empty-content mismatch drove endless resync traffic (observed as a browser
+  re-sending frames several times a second). `handle_sync_message` now answers
+  `SyncStep1` with **integrated-only** state, so a server never serves a struct it
+  can't integrate itself. Neutralizes existing poisoned server state on deploy —
+  no migration needed. The server's own pending is untouched and still heals if
+  the missing dependency later arrives (only then does the content become
+  visible in sync). Live delta relay (`Update` frames) is unchanged.
+
+### Added
+
+- `Doc#pending?` — true if the doc holds un-integrable pending structs or a
+  pending delete set (content waiting on a missing causally-prior update).
+- `Doc#compacted_state_update` — like `encode_state_as_update` (full state) but
+  **gap-free**: excludes pending structs/delete set. Use it when persisting or
+  serving state other peers will apply. Non-destructive — the doc keeps its
+  pending (so it can still heal), and `encode_state_as_update` stays lossless for
+  raw-update recovery.
+
 ## [0.2.3] - 2026-07-01
 
 ### Fixed

data/README.md

@@ -142,18 +142,39 @@ doc = Y::Doc.new(12345) # specific client ID (used for CRDT identity)
 
 # Encoding
 doc.encode_state_vector           # => current state vector
-doc.encode_state_as_update        # => full update
+doc.encode_state_as_update        # => full update (lossless: keeps pending)
 doc.encode_state_as_update(sv)    # => update diff against state vector
+doc.compacted_state_update        # => full update, gap-free (excludes pending)
 
 # Applying updates
 doc.apply_update(update_bytes)    # apply raw V1 update
+doc.pending?                      # => true if holding un-integrable pending structs
 
 # 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
+                                  #    peer's SyncStep1 with an integrated-only
+                                  #    SyncStep2 (never serves pending structs)
 ```
 
+### Pending structs and gap-free state
+
+If a doc applies an update whose causally-prior update is missing (a "gappy"
+update), yrs parks it as a **pending** struct: the integrated state vector stays
+empty, but the pending block is held as a recovery buffer and heals if the
+missing dependency later arrives. `Doc#pending?` reports this.
+
+Pending structs are *not* document state, so they must not cross the sync
+boundary — a peer that receives one can't integrate it and gets stuck. Two
+guarantees keep serving safe:
+
+- `handle_sync_message` answers `SyncStep1` with **integrated-only** state, so a
+  server never serves a struct it can't integrate itself (this is automatic).
+- `Doc#compacted_state_update` gives you the same gap-free full-state update for
+  when you persist or hand off state yourself. It's non-destructive (the doc
+  keeps its pending), while `encode_state_as_update` stays lossless so you can
+  still preserve the raw pending bytes for recovery.
+
 ### Protocol codec (module functions)
 
 Classifying and unwrapping wire frames is stateless, so it's exposed as
@@ -221,6 +242,21 @@ servers:
   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.
+- **An unhealable gap is dropped, not resynced forever.** A resync heals a gap
+  whose missing dependency is still in flight. But a *permanently*-orphaned update
+  (its dependency is gone for good) stays gappy through every resync, and a client
+  retransmitting it would loop endlessly (server resyncs → client resends →
+  repeat). After `gap_strike_limit` rejections of the same update on one
+  connection (default 3, minimum 2), the channel settles it with
+  `{ "ack" => id, "dropped" => true }` and drops it instead of resyncing again —
+  breaking the loop while never dropping a *healable* gap (those heal within a
+  resync or two, and healing frees the strike). The `dropped` flag lets the
+  client surface the loss (`yrby-client` reports it via `onError`) instead of
+  silently showing synced. Set `gap_strike_limit nil` to disable. Works on both
+  transports: plain ActionCable keeps strikes on the channel instance; under
+  AnyCable (fresh instance per RPC command) they persist through
+  anycable-rails' `state_attr_accessor` (istate), declared automatically when
+  anycable-rails is loaded.
 - **`on_change` is at-least-once, and the durable guarantee is that replaying the
   log reconstructs the document.** Every update triggers `on_change` before it's acked or
   broadcast (record-before-distribute). If exactly-once updates matter for you, **you

data/lib/y/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Y
-  VERSION = "0.2.3"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yrby
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.1
 platform: aarch64-linux
 authors:
 - JP Camara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-01 00:00:00.000000000 Z
+date: 2026-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -68,10 +68,7 @@ files:
 - lib/y.rb
 - lib/y/3.4/yrby.so
 - lib/y/4.0/yrby.so
-- lib/y/decoder.rb
-- lib/y/decoder/version.rb
 - lib/y/version.rb
-- lib/yrby-decoder.rb
 - lib/yrby.rb
 homepage: https://github.com/jpcamara/yrby
 licenses:

data/lib/y/decoder/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Y
-  module Decoder
-    VERSION = "0.1.0.alpha1"
-  end
-end

data/lib/y/decoder.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require "y"
-require "y/decoder/version"
-
-module Y
-  # Plain-text reconstruction of a stored Yjs document, in pure Ruby — for search
-  # indexing and previews. The core `yrby` gem moves and stores opaque CRDT
-  # updates without reading them; this reads the text out of the shared type the
-  # editor uses (Lexical's `Y.XmlText`, plain `Y.Text`, or ProseMirror's
-  # `Y.XmlFragment`), in-process, on the native extension core already ships — no
-  # Node, no subprocess, no binary.
-  #
-  #   state = doc.encode_state_as_update        # opaque CRDT bytes from the store
-  #   Y::Decoder.text(state)              # => "hello world"
-  #   Y::Decoder.preview(state, 280)      # => "hello world…"
-  #
-  # Full-fidelity reconstruction (the exact Lexical EditorState / HTML, which
-  # needs @lexical/yjs) is a separate, opt-in concern — see the `yrby-decode`
-  # package's Bun binary. This gem stays pure Ruby on purpose.
-  module Decoder
-    class Error < Y::Error; end
-
-    module_function
-
-    # Plain text of the document. `field` pins the root key (Lexical: the editor
-    # id; ProseMirror: "default"); omit it to use the document's sole root.
-    def text(state, field: nil)
-      field ||= Y::Doc.new.tap { |d| d.apply_update(state) }.root_names.first
-      return "" unless field
-
-      # A plain `Y.Text` root (a simple shared-text editor) reads straight out.
-      # (A yrs root's type is fixed by its first typed access, so each reader
-      # gets a fresh doc to try a different shared type against the same state.)
-      direct = load(state).read_text(field)
-      return normalize(direct) if direct && !direct.strip.empty?
-
-      # Lexical (each block a sibling `Y.XmlText`) and ProseMirror (blocks are
-      # `Y.XmlElement`s) both come back from read_xml as block-per-line markup;
-      # strip any element tags to plain text.
-      markup = load(state).read_xml(field)
-      markup ? normalize(strip_tags(markup)) : ""
-    end
-
-    # A compact, single-line preview for list UIs.
-    def preview(state, limit: 280, field: nil)
-      body = text(state, field: field).gsub(/\s+/, " ").strip
-      body.length > limit ? "#{body[0, limit].rstrip}…" : body
-    end
-
-    def load(state)
-      Y::Doc.new.tap { |doc| doc.apply_update(state) }
-    end
-
-    def strip_tags(markup)
-      markup.gsub(/<[^>]*>/, " ")
-    end
-
-    def normalize(text)
-      text.gsub(/[ \t]+/, " ")     # collapse runs of spaces/tabs
-          .gsub(/ *\n */, "\n")    # trim spaces left around block separators
-          .gsub(/\n{3,}/, "\n\n")  # cap blank-line runs
-          .strip
-    end
-  end
-end

data/lib/yrby-decoder.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-# Entry point matching the gem name, so `Bundler.require` loads it automatically.
-require "y/decoder"