yrb-lite-client 0.1.0

package/README.md

@@ -0,0 +1,126 @@
+# yrb-lite-client
+
+The **client core** for the [`yrb-lite`](https://github.com/jpcamara/yrb-lite)
+y-websocket protocol — everything a Yjs provider needs *except the transport*.
+Bring your own socket (ActionCable, AnyCable, raw WebSocket); this owns the
+protocol.
+
+Three layers, use whichever you need:
+
+- **`ActionCableProvider`** — a ready-made Yjs provider for ActionCable /
+  AnyCable. Pass a `Y.Doc`, a cable consumer, and a channel; it wires the
+  subscription and you're collaborating. Awareness/presence automatically rides
+  AnyCable's `whisper` when the consumer supports it (client-to-client, no server
+  round-trip), and falls back to a normal server-relayed send on plain
+  ActionCable — nothing to configure. Document updates always go through the
+  server (recorded/acked).
+- **`SyncEngine`** — the transport-agnostic core. Binds to a `Y.Doc` (+ optional
+  `Awareness`) and owns the y-protocols **message encode/decode**, the
+  **sync-step handshake** (SyncStep1 / SyncStep2 / Update), **awareness**, and
+  reliable delivery. Speaks raw `Uint8Array` frames; you wire any socket.
+- **`ReliableSync`** — the zero-dependency reliable-delivery state machine on its
+  own: ack-tracked queue, **sync-since-last-ack** (the unacked tail merged into
+  one causally-complete delta), cumulative acks, retransmit + "server doesn't
+  support acks" fallback, and reconnect replay. Compose it yourself if you
+  already have your own framing.
+
+## Install
+
+```bash
+npm install yrb-lite-client
+```
+
+`ActionCableProvider` and `SyncEngine` need `yjs` and `y-protocols` (peers — your
+app already has them), plus an ActionCable/AnyCable consumer. `ReliableSync` has
+**no dependencies**; import it on its own via `yrb-lite-client/reliable` if
+that's all you want.
+
+Written in **TypeScript** and ships bundled type declarations, so TS projects get
+full types (typed options, methods, and errors) with no `@types` package — and
+plain-JS projects use the same compiled ESM with nothing extra to install.
+
+## ActionCableProvider (the easy path)
+
+```js
+import { ActionCableProvider } from "yrb-lite-client";
+import * as Y from "yjs";
+import { createConsumer } from "@anycable/web"; // or @rails/actioncable
+
+const doc = new Y.Doc();
+const consumer = createConsumer();
+const provider = new ActionCableProvider(doc, consumer, "DocumentChannel", { id: docId });
+
+provider.connect(); // does not auto-connect — wire your editor binding first
+// provider.awareness  -> the Awareness instance (a fresh one unless you pass opts.awareness)
+// provider.synced     -> caught up with the server
+// provider.hasPending -> unacked local edits in flight
+// provider.destroy()  -> tear down
+```
+
+On the server, include `YrbLite::ActionCable::Sync` in a channel named
+`DocumentChannel` (the [`yrb-lite-actioncable`](https://rubygems.org/gems/yrb-lite-actioncable)
+gem), which enables AnyCable whispering on the stream automatically. Need a
+different transport or framing? Drop down to `SyncEngine` and supply your own
+`send`.
+
+## SyncEngine
+
+```js
+import { SyncEngine, toBase64, fromBase64 } from "yrb-lite-client";
+import * as Y from "yjs";
+import { Awareness } from "y-protocols/awareness";
+
+const doc = new Y.Doc();
+const awareness = new Awareness(doc);
+
+const engine = new SyncEngine(doc, {
+  awareness,
+  // transmit one raw frame; `id` is set for reliable doc updates -> tag your envelope
+  send: (frame, id) => {
+    const payload = { update: toBase64(frame) };
+    if (id !== undefined) payload.id = id;
+    subscription.send(payload);
+  },
+});
+
+// wire your transport's callbacks:
+subscription.connected    = () => engine.onConnect();      // handshake + replay
+subscription.disconnected = () => engine.onDisconnect();   // pause + clear presence
+subscription.received = (msg) => {
+  if (msg.ack !== undefined) return engine.ack(msg.ack);   // reliable ack envelope
+  const reply = engine.receive(fromBase64(msg.update || msg.m)); // decode + apply
+  if (reply) subscription.send({ update: toBase64(reply) });     // e.g. answer a SyncStep1
+};
+// engine.synced -> caught up; engine.hasPending -> unacked edits in flight
+// engine.destroy() -> detach listeners + stop retransmits
+```
+
+Local document edits and awareness changes are picked up automatically from the
+doc's / awareness's `update` events — you never call anything for outbound edits.
+
+## ReliableSync (standalone)
+
+```js
+import { ReliableSync } from "yrb-lite-client/reliable"; // zero-dep
+import * as Y from "yjs";
+
+const rs = new ReliableSync({
+  send: (update, id) => { /* frame + transmit */ },
+  merge: Y.mergeUpdates,
+});
+
+rs.enqueue(update);  // a local document update
+rs.onAck(id);        // an { ack: id } arrived
+rs.onConnect();      // (re)connected — replay the tail, resume retransmits
+rs.onDisconnect();   // dropped — keep the queue, pause
+```
+
+## How it fits
+
+The server counterpart — ack *generation*, gap detection, record-before-distribute
+— is the `yrb-lite-actioncable` gem's `YrbLite::ActionCable::Sync`. This package
+is the client half of the same protocol.
+
+## License
+
+MIT

package/dist/actioncable_provider.d.ts

@@ -0,0 +1,40 @@
+import { SyncEngine, type SyncEngineOptions } from "./sync_engine.js";
+import { Awareness } from "y-protocols/awareness";
+import type { Doc } from "yjs";
+/** The minimal slice of an ActionCable/AnyCable subscription this provider uses. */
+export interface CableSubscription {
+    send(data: unknown): unknown;
+    /** AnyCable client-to-client broadcast; absent on plain ActionCable. */
+    whisper?(data: unknown): unknown;
+    unsubscribe?(): void;
+}
+/** The minimal slice of an ActionCable/AnyCable consumer this provider uses. */
+export interface CableConsumer {
+    subscriptions: {
+        create(params: object, mixin: object): CableSubscription;
+        remove(subscription: CableSubscription): void;
+    };
+}
+export interface ActionCableProviderOptions extends Pick<SyncEngineOptions, "reliable" | "resendInterval" | "maxUnconfirmedResends" | "onFallback"> {
+    /** Awareness/presence instance. Defaults to a fresh `new Awareness(doc)`. */
+    awareness?: Awareness | null;
+}
+export declare class ActionCableProvider {
+    readonly doc: Doc;
+    readonly consumer: CableConsumer;
+    readonly channelName: string;
+    readonly channelParams: object;
+    readonly awareness: Awareness;
+    readonly engine: SyncEngine;
+    private subscription;
+    constructor(doc: Doc, consumer: CableConsumer, channelName: string, channelParams?: object, opts?: ActionCableProviderOptions);
+    /** True once the document has caught up with the server (received a SyncStep2). */
+    get synced(): boolean;
+    /** True while there are unacknowledged local document updates in flight. */
+    get hasPending(): boolean;
+    connect(): void;
+    disconnect(): void;
+    destroy(): void;
+    private _send;
+}
+//# sourceMappingURL=actioncable_provider.d.ts.map

package/dist/actioncable_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actioncable_provider.d.ts","sourceRoot":"","sources":["../src/actioncable_provider.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAe,KAAK,iBAAiB,EAAoB,MAAM,kBAAkB,CAAC;AAErG,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE/B,oFAAoF;AACpF,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IAC7B,wEAAwE;IACxE,OAAO,CAAC,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACjC,WAAW,CAAC,IAAI,IAAI,CAAC;CACtB;AAED,gFAAgF;AAChF,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE;QACb,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAAC;QACzD,MAAM,CAAC,YAAY,EAAE,iBAAiB,GAAG,IAAI,CAAC;KAC/C,CAAC;CACH;AAED,MAAM,WAAW,0BACf,SAAQ,IAAI,CAAC,iBAAiB,EAAE,UAAU,GAAG,gBAAgB,GAAG,uBAAuB,GAAG,YAAY,CAAC;IACvG,6EAA6E;IAC7E,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;CAC9B;AAQD,qBAAa,mBAAmB;IAC9B,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,OAAO,CAAC,YAAY,CAAkC;gBAGpD,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,aAAa,EACvB,WAAW,EAAE,MAAM,EACnB,aAAa,GAAE,MAAW,EAC1B,IAAI,GAAE,0BAA+B;IAkBvC,mFAAmF;IACnF,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,4EAA4E;IAC5E,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,OAAO,IAAI,IAAI;IA2Bf,UAAU,IAAI,IAAI;IAOlB,OAAO,IAAI,IAAI;IAUf,OAAO,CAAC,KAAK;CAYd"}

package/dist/actioncable_provider.js

@@ -0,0 +1,102 @@
+// A ready-made Yjs provider for the yrb-lite y-websocket protocol over
+// ActionCable / AnyCable. It owns the cable subscription and translates between
+// the cable's JSON envelope (`{ update, id }` / `{ ack }`, base64) and raw
+// protocol frames; everything else (sync steps, encode/decode, awareness,
+// reliable delivery) lives in SyncEngine. So this is just the transport glue.
+//
+// Awareness/presence frames are sent via AnyCable's `whisper` when the
+// subscription supports it (client-to-client, no server round-trip); on plain
+// ActionCable (no `whisper`) they fall back to a normal `send` and the server
+// relays them. Document updates always go through `send` (they must be
+// recorded/acked).
+//
+// The constructor does NOT auto-connect: wire your editor binding first, then
+// call `connect()`. Same `(doc, consumer, channelName, channelParams, opts)`
+// shape as a typical y-rb/actioncable provider.
+import { SyncEngine, MessageType } from "./sync_engine.js";
+import { toBase64, fromBase64 } from "./base64.js";
+import { Awareness } from "y-protocols/awareness";
+export class ActionCableProvider {
+    constructor(doc, consumer, channelName, channelParams = {}, opts = {}) {
+        this.subscription = null;
+        this.doc = doc;
+        this.consumer = consumer;
+        this.channelName = channelName;
+        this.channelParams = channelParams;
+        this.awareness = opts.awareness ?? new Awareness(doc);
+        this.engine = new SyncEngine(doc, {
+            awareness: this.awareness,
+            reliable: opts.reliable,
+            resendInterval: opts.resendInterval,
+            maxUnconfirmedResends: opts.maxUnconfirmedResends,
+            onFallback: opts.onFallback,
+            send: (frame, id, sendOpts) => this._send(frame, id, sendOpts),
+        });
+    }
+    /** True once the document has caught up with the server (received a SyncStep2). */
+    get synced() {
+        return this.engine.synced;
+    }
+    /** True while there are unacknowledged local document updates in flight. */
+    get hasPending() {
+        return this.engine.hasPending;
+    }
+    connect() {
+        if (this.subscription)
+            return;
+        const provider = this;
+        this.subscription = this.consumer.subscriptions.create({ channel: this.channelName, ...this.channelParams }, {
+            received(message) {
+                // Reliable-delivery ack: confirm + prune the local queue.
+                if (message && message.ack !== undefined) {
+                    provider.engine.ack(message.ack);
+                    return;
+                }
+                const payload = message && (message.m ?? message.update);
+                if (typeof payload !== "string")
+                    return;
+                const reply = provider.engine.receive(fromBase64(payload));
+                if (reply)
+                    provider._send(reply, undefined); // e.g. SyncStep2 answering a SyncStep1
+            },
+            connected() {
+                provider.engine.onConnect(); // handshake + replay the unacked tail
+            },
+            disconnected() {
+                provider.engine.onDisconnect(); // pause retransmits, clear remote presence
+            },
+        });
+    }
+    disconnect() {
+        if (!this.subscription)
+            return;
+        this.engine.onDisconnect();
+        this.consumer.subscriptions.remove(this.subscription);
+        this.subscription = null;
+    }
+    destroy() {
+        this.disconnect();
+        this.engine.destroy();
+    }
+    // Send one raw protocol frame over the cable. Awareness frames are whispered
+    // when the subscription supports it (AnyCable), else sent normally; document
+    // frames always go through `send`. `id` (reliable doc updates) is tagged onto
+    // the envelope so the server can ack. A no-op while disconnected: reliable
+    // frames stay queued in the engine and flush on the next connect().
+    _send(frame, id, opts) {
+        const sub = this.subscription;
+        if (!sub)
+            return;
+        const update = toBase64(frame);
+        const payload = id === undefined ? { update } : { update, id };
+        const isAwareness = opts?.awareness ?? frame[0] === MessageType.Awareness;
+        // Awareness rides AnyCable's whisper automatically when the subscription
+        // supports it (client-to-client, no server round-trip); otherwise a normal
+        // send the server relays. Document updates always send (recorded/acked).
+        if (isAwareness && typeof sub.whisper === "function")
+            sub.whisper(payload);
+        else
+            sub.send(payload);
+    }
+}
+//# sourceMappingURL=actioncable_provider.js.map

package/dist/actioncable_provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actioncable_provider.js","sourceRoot":"","sources":["../src/actioncable_provider.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,gFAAgF;AAChF,2EAA2E;AAC3E,0EAA0E;AAC1E,8EAA8E;AAC9E,EAAE;AACF,uEAAuE;AACvE,8EAA8E;AAC9E,8EAA8E;AAC9E,uEAAuE;AACvE,mBAAmB;AACnB,EAAE;AACF,8EAA8E;AAC9E,6EAA6E;AAC7E,gDAAgD;AAChD,OAAO,EAAE,UAAU,EAAE,WAAW,EAA4C,MAAM,kBAAkB,CAAC;AACrG,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AA+BlD,MAAM,OAAO,mBAAmB;IAS9B,YACE,GAAQ,EACR,QAAuB,EACvB,WAAmB,EACnB,gBAAwB,EAAE,EAC1B,OAAmC,EAAE;QAP/B,iBAAY,GAA6B,IAAI,CAAC;QASpD,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC;QAEtD,IAAI,CAAC,MAAM,GAAG,IAAI,UAAU,CAAC,GAAG,EAAE;YAChC,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,qBAAqB,EAAE,IAAI,CAAC,qBAAqB;YACjD,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,QAAQ,CAAC;SAC/D,CAAC,CAAC;IACL,CAAC;IAED,mFAAmF;IACnF,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;IAC5B,CAAC;IAED,4EAA4E;IAC5E,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;IAChC,CAAC;IAED,OAAO;QACL,IAAI,IAAI,CAAC,YAAY;YAAE,OAAO;QAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,MAAM,CACpD,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,aAAa,EAAE,EACpD;YACE,QAAQ,CAAC,OAAqB;gBAC5B,0DAA0D;gBAC1D,IAAI,OAAO,IAAI,OAAO,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;oBACzC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;oBACjC,OAAO;gBACT,CAAC;gBACD,MAAM,OAAO,GAAG,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;gBACzD,IAAI,OAAO,OAAO,KAAK,QAAQ;oBAAE,OAAO;gBACxC,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;gBAC3D,IAAI,KAAK;oBAAE,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,uCAAuC;YACtF,CAAC;YACD,SAAS;gBACP,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,sCAAsC;YACrE,CAAC;YACD,YAAY;gBACV,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,2CAA2C;YAC7E,CAAC;SACF,CACF,CAAC;IACJ,CAAC;IAED,UAAU;QACR,IAAI,CAAC,IAAI,CAAC,YAAY;YAAE,OAAO;QAC/B,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;QAC3B,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACtD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IAC3B,CAAC;IAED,OAAO;QACL,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;IAED,6EAA6E;IAC7E,6EAA6E;IAC7E,8EAA8E;IAC9E,2EAA2E;IAC3E,oEAAoE;IAC5D,KAAK,CAAC,KAAiB,EAAE,EAAsB,EAAE,IAAkB;QACzE,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC;QAC9B,IAAI,CAAC,GAAG;YAAE,OAAO;QACjB,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC/B,MAAM,OAAO,GAAG,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;QAC/D,MAAM,WAAW,GAAG,IAAI,EAAE,SAAS,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,SAAS,CAAC;QAC1E,yEAAyE;QACzE,2EAA2E;QAC3E,yEAAyE;QACzE,IAAI,WAAW,IAAI,OAAO,GAAG,CAAC,OAAO,KAAK,UAAU;YAAE,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;;YACtE,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC;CACF"}

package/dist/base64.d.ts

@@ -0,0 +1,3 @@
+export declare const toBase64: (bytes: Uint8Array) => string;
+export declare const fromBase64: (str: string) => Uint8Array;
+//# sourceMappingURL=base64.d.ts.map

package/dist/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../src/base64.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ,GAAI,OAAO,UAAU,KAAG,MACoB,CAAC;AAElE,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,UAAgE,CAAC"}

package/dist/base64.js

@@ -0,0 +1,6 @@
+// Convenience codecs for transports that carry binary frames as base64 strings
+// (e.g. ActionCable's JSON envelope). Optional -- a binary WebSocket transport
+// sends the raw frames directly and never needs these.
+export const toBase64 = (bytes) => btoa(Array.from(bytes, (b) => String.fromCharCode(b)).join(""));
+export const fromBase64 = (str) => Uint8Array.from(atob(str), (c) => c.charCodeAt(0));
+//# sourceMappingURL=base64.js.map

package/dist/base64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.js","sourceRoot":"","sources":["../src/base64.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,+EAA+E;AAC/E,uDAAuD;AAEvD,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAiB,EAAU,EAAE,CACpD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;AAElE,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,GAAW,EAAc,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { ReliableSync } from "./reliable_sync.js";
+export type { ReliableSyncOptions, TimerHandle } from "./reliable_sync.js";
+export { SyncEngine, MessageType } from "./sync_engine.js";
+export type { SyncEngineOptions, SendOptions } from "./sync_engine.js";
+export { ActionCableProvider } from "./actioncable_provider.js";
+export type { ActionCableProviderOptions, CableConsumer, CableSubscription } from "./actioncable_provider.js";
+export { toBase64, fromBase64 } from "./base64.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAI3E,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC3D,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAIvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,YAAY,EAAE,0BAA0B,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAG9G,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+// Zero-dependency reliable-delivery core. Safe to import on its own.
+export { ReliableSync } from "./reliable_sync.js";
+// Batteries-included protocol client (sync steps + encode/decode + awareness).
+// Requires `yjs` and `y-protocols` as peers.
+export { SyncEngine, MessageType } from "./sync_engine.js";
+// Ready-made ActionCable / AnyCable provider built on SyncEngine (with awareness
+// whisper support). Bring your own provider instead by composing SyncEngine.
+export { ActionCableProvider } from "./actioncable_provider.js";
+// Optional base64 helpers for transports that carry frames as strings.
+export { toBase64, fromBase64 } from "./base64.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,+EAA+E;AAC/E,6CAA6C;AAC7C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG3D,iFAAiF;AACjF,6EAA6E;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAGhE,uEAAuE;AACvE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC"}

package/dist/reliable_sync.d.ts

@@ -0,0 +1,78 @@
+/** An opaque timer handle (number in browsers, Timeout in Node). */
+export type TimerHandle = unknown;
+export interface ReliableSyncOptions {
+    /**
+     * Transmit one update. `update` is the raw merged update bytes; `id` is the
+     * cumulative sequence to ack against (undefined once we've fallen back).
+     */
+    send: (update: Uint8Array, id: number | undefined) => void;
+    /** Merge an array of update byte-arrays into one (typically Y.mergeUpdates). */
+    merge: (updates: Uint8Array[]) => Uint8Array;
+    /** Milliseconds between retransmits of the unacked tail (default 1000). */
+    resendInterval?: number;
+    /**
+     * Number of resends with no ack before deciding the server doesn't support
+     * reliable delivery and falling back to fire-and-forget (default 8).
+     */
+    maxUnconfirmedResends?: number;
+    /** Called once if that fallback trips. */
+    onFallback?: () => void;
+    /** Injectable timer hooks (default to globals); handy for tests. */
+    setInterval?: (handler: () => void, ms: number) => TimerHandle;
+    clearInterval?: (handle: TimerHandle) => void;
+}
+interface Pending {
+    seq: number;
+    update: Uint8Array;
+}
+export declare class ReliableSync {
+    /** False after the no-ack fallback trips; updates then go fire-and-forget. */
+    reliable: boolean;
+    /** Unacked local updates, in order. */
+    pending: Pending[];
+    private _send;
+    private _merge;
+    private resendInterval;
+    private maxUnconfirmedResends;
+    private _onFallback?;
+    private _setInterval;
+    private _clearInterval;
+    private nextSeq;
+    private everAcked;
+    private _resendsSinceProgress;
+    private _connected;
+    private _timer;
+    constructor(opts: ReliableSyncOptions);
+    /** True while there are unacknowledged local updates. */
+    get hasPending(): boolean;
+    /**
+     * Record a local document update. While reliable, it's queued and the unacked
+     * tail is flushed; once we've fallen back, it's sent fire-and-forget.
+     */
+    enqueue(update: Uint8Array): void;
+    /**
+     * Send the whole unacked tail as one merged delta. The id is the highest seq
+     * in the batch, so a single { ack } cumulatively confirms everything up to it.
+     * No-op while disconnected (the tail is replayed on the next onConnect).
+     */
+    flush(): void;
+    /** Confirm delivery up to `id`: prune every queued update with seq <= id. */
+    onAck(id: number): void;
+    /** Transport (re)connected: replay the unacked tail and resume retransmits. */
+    onConnect(): void;
+    /** Transport dropped: keep the queue (for reconnect replay), pause the timer. */
+    onDisconnect(): void;
+    /**
+     * One retransmit tick. Exposed for deterministic testing; normally driven by
+     * the internal timer. If we keep resending on a live connection and never get
+     * an ack, the server doesn't support reliable delivery, so fall back to
+     * fire-and-forget (and stop tracking, since idempotent CRDT sync covers it).
+     */
+    onTick(): void;
+    /** Stop timers and drop references. Call when the provider is destroyed. */
+    destroy(): void;
+    private _startTimer;
+    private _stopTimer;
+}
+export {};
+//# sourceMappingURL=reliable_sync.d.ts.map

package/dist/reliable_sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reliable_sync.d.ts","sourceRoot":"","sources":["../src/reliable_sync.ts"],"names":[],"mappings":"AAqBA,oEAAoE;AACpE,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC;AAElC,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,IAAI,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC;IAC3D,gFAAgF;IAChF,KAAK,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,CAAC;IAC7C,2EAA2E;IAC3E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,oEAAoE;IACpE,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,WAAW,CAAC;IAC/D,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;CAC/C;AAID,UAAU,OAAO;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,UAAU,CAAC;CACpB;AAED,qBAAa,YAAY;IACvB,8EAA8E;IAC9E,QAAQ,UAAQ;IAChB,uCAAuC;IACvC,OAAO,EAAE,OAAO,EAAE,CAAM;IAExB,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,qBAAqB,CAAS;IACtC,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,OAAO,CAAC,YAAY,CAAmD;IACvE,OAAO,CAAC,cAAc,CAAgC;IAEtD,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,qBAAqB,CAAK;IAClC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAsC;gBAExC,IAAI,EAAE,mBAAmB;IAerC,yDAAyD;IACzD,IAAI,UAAU,IAAI,OAAO,CAExB;IAED;;;OAGG;IACH,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IASjC;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAQb,6EAA6E;IAC7E,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAMvB,+EAA+E;IAC/E,SAAS,IAAI,IAAI;IAMjB,iFAAiF;IACjF,YAAY,IAAI,IAAI;IAKpB;;;;;OAKG;IACH,MAAM,IAAI,IAAI;IAYd,4EAA4E;IAC5E,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,UAAU;CAInB"}

package/dist/reliable_sync.js

@@ -0,0 +1,130 @@
+// Transport-agnostic reliable-delivery core for the yrb-lite y-websocket
+// protocol. This owns the "nuances" a provider would otherwise re-implement:
+// an ack-tracked queue of unacknowledged local updates, "sync since last ack"
+// (the unacked tail is sent as one MERGED, causally-complete delta so the server
+// never sees an internal gap), cumulative acks, periodic retransmit with a
+// "server doesn't support acks" fallback, and reconnect replay.
+//
+// It does NOT touch any transport, Yjs binding, or wire encoding. You inject:
+//   - send(update, id):  transmit one update. `update` is the raw merged update
+//                        bytes; `id` is the cumulative sequence (or undefined,
+//                        post-fallback). Frame + base64 + put it on your socket.
+//   - merge(updates):    merge an array of update byte-arrays into one
+//                        (typically Y.mergeUpdates from yjs).
+// and you drive it from your provider's lifecycle:
+//   - enqueue(update)         on every local document update (not server echoes)
+//   - onAck(id)               when an { ack: id } frame arrives
+//   - onConnect()/onDisconnect()  on transport (re)connect / drop
+//
+// Awareness/presence is intentionally out of scope -- it stays fire-and-forget
+// in the provider.
+const DEFAULTS = { resendInterval: 1000, maxUnconfirmedResends: 8 };
+export class ReliableSync {
+    constructor(opts) {
+        /** False after the no-ack fallback trips; updates then go fire-and-forget. */
+        this.reliable = true;
+        /** Unacked local updates, in order. */
+        this.pending = [];
+        this.nextSeq = 1;
+        this.everAcked = false;
+        this._resendsSinceProgress = 0;
+        this._connected = false;
+        this._timer = undefined;
+        const { send, merge, resendInterval, maxUnconfirmedResends, onFallback } = opts ?? {};
+        if (typeof send !== "function")
+            throw new TypeError("ReliableSync requires a send(update, id) function");
+        if (typeof merge !== "function")
+            throw new TypeError("ReliableSync requires a merge(updates) function");
+        this._send = send;
+        this._merge = merge;
+        this.resendInterval = resendInterval ?? DEFAULTS.resendInterval;
+        this.maxUnconfirmedResends = maxUnconfirmedResends ?? DEFAULTS.maxUnconfirmedResends;
+        this._onFallback = onFallback;
+        // Injectable timer hooks make the resend loop testable; default to globals.
+        this._setInterval = opts.setInterval ?? ((fn, ms) => setInterval(fn, ms));
+        this._clearInterval = opts.clearInterval ?? ((h) => clearInterval(h));
+    }
+    /** True while there are unacknowledged local updates. */
+    get hasPending() {
+        return this.pending.length > 0;
+    }
+    /**
+     * Record a local document update. While reliable, it's queued and the unacked
+     * tail is flushed; once we've fallen back, it's sent fire-and-forget.
+     */
+    enqueue(update) {
+        if (!this.reliable) {
+            this._send(update, undefined);
+            return;
+        }
+        this.pending.push({ seq: this.nextSeq++, update });
+        this.flush();
+    }
+    /**
+     * Send the whole unacked tail as one merged delta. The id is the highest seq
+     * in the batch, so a single { ack } cumulatively confirms everything up to it.
+     * No-op while disconnected (the tail is replayed on the next onConnect).
+     */
+    flush() {
+        if (!this._connected || this.pending.length === 0)
+            return;
+        const updates = this.pending.map((p) => p.update);
+        const merged = updates.length === 1 ? updates[0] : this._merge(updates);
+        const id = this.pending[this.pending.length - 1].seq;
+        this._send(merged, id);
+    }
+    /** Confirm delivery up to `id`: prune every queued update with seq <= id. */
+    onAck(id) {
+        this.everAcked = true;
+        this._resendsSinceProgress = 0;
+        this.pending = this.pending.filter((p) => p.seq > id);
+    }
+    /** Transport (re)connected: replay the unacked tail and resume retransmits. */
+    onConnect() {
+        this._connected = true;
+        this.flush();
+        this._startTimer();
+    }
+    /** Transport dropped: keep the queue (for reconnect replay), pause the timer. */
+    onDisconnect() {
+        this._connected = false;
+        this._stopTimer();
+    }
+    /**
+     * One retransmit tick. Exposed for deterministic testing; normally driven by
+     * the internal timer. If we keep resending on a live connection and never get
+     * an ack, the server doesn't support reliable delivery, so fall back to
+     * fire-and-forget (and stop tracking, since idempotent CRDT sync covers it).
+     */
+    onTick() {
+        if (!this._connected || this.pending.length === 0)
+            return;
+        if (!this.everAcked && ++this._resendsSinceProgress > this.maxUnconfirmedResends) {
+            this.reliable = false;
+            this.pending = [];
+            this._stopTimer();
+            this._onFallback?.();
+            return;
+        }
+        this.flush();
+    }
+    /** Stop timers and drop references. Call when the provider is destroyed. */
+    destroy() {
+        this._stopTimer();
+        this.pending = [];
+    }
+    _startTimer() {
+        if (this._timer !== undefined || !this.reliable)
+            return;
+        this._timer = this._setInterval(() => this.onTick(), this.resendInterval);
+        const t = this._timer;
+        if (t && typeof t.unref === "function")
+            t.unref();
+    }
+    _stopTimer() {
+        if (this._timer !== undefined)
+            this._clearInterval(this._timer);
+        this._timer = undefined;
+    }
+}
+//# sourceMappingURL=reliable_sync.js.map

package/dist/reliable_sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reliable_sync.js","sourceRoot":"","sources":["../src/reliable_sync.ts"],"names":[],"mappings":"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"}

package/dist/sync_engine.d.ts

@@ -0,0 +1,73 @@
+import { type Doc } from "yjs";
+import { type Awareness } from "y-protocols/awareness";
+import { type TimerHandle } from "./reliable_sync.js";
+export declare const MessageType: {
+    readonly Sync: 0;
+    readonly Awareness: 1;
+    readonly Auth: 2;
+    readonly QueryAwareness: 3;
+};
+/** Hints about an outgoing frame, so the transport can route it appropriately. */
+export interface SendOptions {
+    /**
+     * True for awareness/presence frames. These are ephemeral and fire-and-forget,
+     * so a transport that supports it (e.g. AnyCable `whisper`) can broadcast them
+     * client-to-client without a server round-trip. Transports without that just
+     * send normally.
+     */
+    awareness?: boolean;
+}
+export interface SyncEngineOptions {
+    /**
+     * Transmit one raw protocol frame. `id` is set only for reliable document
+     * updates (tag it onto your envelope so the server can ack). `opts.awareness`
+     * marks presence frames so the transport can whisper them where supported.
+     */
+    send: (frame: Uint8Array, id: number | undefined, opts?: SendOptions) => void;
+    /** Optional awareness/presence. When omitted, awareness frames are ignored. */
+    awareness?: Awareness | null;
+    /** Use ack-tracked reliable delivery (default true). */
+    reliable?: boolean;
+    /** Forwarded to ReliableSync. */
+    resendInterval?: number;
+    /** Forwarded to ReliableSync. */
+    maxUnconfirmedResends?: number;
+    /** Forwarded to ReliableSync. */
+    onFallback?: () => void;
+    /** Injectable timer hooks (forwarded to ReliableSync); handy for tests. */
+    setInterval?: (handler: () => void, ms: number) => TimerHandle;
+    clearInterval?: (handle: TimerHandle) => void;
+}
+export declare class SyncEngine {
+    readonly doc: Doc;
+    readonly awareness: Awareness | null;
+    reliable: boolean;
+    private _send;
+    private _synced;
+    private _delivery;
+    private _onDocUpdate;
+    private _onAwarenessUpdate?;
+    constructor(doc: Doc, opts: SyncEngineOptions);
+    /** True once we've received the server's SyncStep2 (the document is caught up). */
+    get synced(): boolean;
+    /** True while there are unacknowledged local document updates in flight. */
+    get hasPending(): boolean;
+    /** Transport connected: send the opening handshake and replay the unacked tail. */
+    onConnect(): void;
+    /** Transport dropped: pause retransmits (queue kept) and clear remote presence. */
+    onDisconnect(): void;
+    /** A reliable-delivery `{ ack: id }` envelope arrived. */
+    ack(id: number): void;
+    /**
+     * Decode and apply one incoming binary protocol frame (document sync, awareness,
+     * query, or auth). Returns a reply frame to transmit (e.g. SyncStep2 answering a
+     * SyncStep1, or an awareness reply to a query), or null if there's nothing to send.
+     */
+    receive(frame: Uint8Array): Uint8Array | null;
+    /** Detach doc/awareness listeners and stop retransmits. */
+    destroy(): void;
+    private _frameSyncStep1;
+    private _frameUpdate;
+    private _frameAwareness;
+}
+//# sourceMappingURL=sync_engine.d.ts.map

package/dist/sync_engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync_engine.d.ts","sourceRoot":"","sources":["../src/sync_engine.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAgB,KAAK,GAAG,EAAE,MAAM,KAAK,CAAC;AAI7C,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEpE,eAAO,MAAM,WAAW;;;;;CAAiE,CAAC;AAE1F,kFAAkF;AAClF,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,CAAC;IAC9E,+EAA+E;IAC/E,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iCAAiC;IACjC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iCAAiC;IACjC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,iCAAiC;IACjC,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,WAAW,CAAC;IAC/D,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;CAC/C;AAID,qBAAa,UAAU;IACrB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IACrC,QAAQ,EAAE,OAAO,CAAC;IAElB,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAe;IAChC,OAAO,CAAC,YAAY,CAAgD;IACpE,OAAO,CAAC,kBAAkB,CAAC,CAAqD;gBAEpE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,iBAAiB;IA6C7C,mFAAmF;IACnF,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,4EAA4E;IAC5E,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,mFAAmF;IACnF,SAAS,IAAI,IAAI;IAQjB,mFAAmF;IACnF,YAAY,IAAI,IAAI;IASpB,0DAA0D;IAC1D,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIrB;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI;IA+B7C,2DAA2D;IAC3D,OAAO,IAAI,IAAI;IAMf,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,eAAe;CAMxB"}

package/dist/sync_engine.js

@@ -0,0 +1,155 @@
+// A batteries-included client core for the yrb-lite y-websocket protocol.
+//
+// SyncEngine composes ReliableSync and additionally owns the parts a provider
+// would otherwise re-implement: the y-protocols message framing (encode/decode),
+// the sync-step handshake (SyncStep1 / SyncStep2 / Update), and awareness
+// encode/apply. It binds to a Y.Doc (and optional Awareness) and speaks in raw
+// Uint8Array frames -- you bring only the transport: base64 + the
+// `{ update, id }` / `{ ack }` envelope and the socket.
+//
+// Drive it from your transport:
+//   onConnect()          -> sends the opening handshake, replays the unacked tail
+//   onDisconnect()       -> pauses retransmits, clears remote presence
+//   ack(id)              -> a `{ ack: id }` envelope arrived
+//   const reply = receive(frame)  -> a binary protocol frame arrived; send `reply` if non-null
+// Local document edits and awareness changes are picked up automatically via the
+// doc's / awareness's "update" events.
+import { mergeUpdates } from "yjs";
+import * as encoding from "lib0/encoding";
+import * as decoding from "lib0/decoding";
+import { readSyncMessage, writeSyncStep1, writeUpdate, messageYjsSyncStep2 } from "y-protocols/sync";
+import { encodeAwarenessUpdate, applyAwarenessUpdate, removeAwarenessStates, } from "y-protocols/awareness";
+import { readAuthMessage } from "y-protocols/auth";
+import { ReliableSync } from "./reliable_sync.js";
+export const MessageType = { Sync: 0, Awareness: 1, Auth: 2, QueryAwareness: 3 };
+export class SyncEngine {
+    constructor(doc, opts) {
+        this._synced = false;
+        const { send, awareness = null, reliable = true, resendInterval, maxUnconfirmedResends, onFallback, setInterval: setIntervalFn, clearInterval: clearIntervalFn, } = opts ?? {};
+        if (!doc)
+            throw new TypeError("SyncEngine requires a Y.Doc");
+        if (typeof send !== "function")
+            throw new TypeError("SyncEngine requires a send(frame, id) function");
+        this.doc = doc;
+        this.awareness = awareness;
+        this.reliable = reliable;
+        this._send = send;
+        this._delivery = new ReliableSync({
+            merge: mergeUpdates,
+            send: (update, id) => this._send(this._frameUpdate(update), id),
+            resendInterval,
+            maxUnconfirmedResends,
+            onFallback,
+            setInterval: setIntervalFn,
+            clearInterval: clearIntervalFn,
+        });
+        this._onDocUpdate = (update, origin) => {
+            if (origin === this)
+                return; // applied from the server; don't echo it back
+            if (this.reliable && this._delivery.reliable)
+                this._delivery.enqueue(update);
+            else
+                this._send(this._frameUpdate(update), undefined);
+        };
+        this.doc.on("update", this._onDocUpdate);
+        if (this.awareness) {
+            this._onAwarenessUpdate = ({ added, updated, removed }) => {
+                const changed = added.concat(updated, removed);
+                this._send(this._frameAwareness(changed), undefined, { awareness: true }); // fire-and-forget
+            };
+            this.awareness.on("update", this._onAwarenessUpdate);
+        }
+    }
+    /** True once we've received the server's SyncStep2 (the document is caught up). */
+    get synced() {
+        return this._synced;
+    }
+    /** True while there are unacknowledged local document updates in flight. */
+    get hasPending() {
+        return this._delivery.hasPending;
+    }
+    /** Transport connected: send the opening handshake and replay the unacked tail. */
+    onConnect() {
+        this._send(this._frameSyncStep1(), undefined);
+        if (this.awareness && this.awareness.getLocalState() !== null) {
+            this._send(this._frameAwareness([this.doc.clientID]), undefined, { awareness: true });
+        }
+        if (this.reliable)
+            this._delivery.onConnect();
+    }
+    /** Transport dropped: pause retransmits (queue kept) and clear remote presence. */
+    onDisconnect() {
+        this._synced = false;
+        this._delivery.onDisconnect();
+        if (this.awareness) {
+            const remote = [...this.awareness.getStates().keys()].filter((c) => c !== this.doc.clientID);
+            if (remote.length)
+                removeAwarenessStates(this.awareness, remote, this);
+        }
+    }
+    /** A reliable-delivery `{ ack: id }` envelope arrived. */
+    ack(id) {
+        this._delivery.onAck(id);
+    }
+    /**
+     * Decode and apply one incoming binary protocol frame (document sync, awareness,
+     * query, or auth). Returns a reply frame to transmit (e.g. SyncStep2 answering a
+     * SyncStep1, or an awareness reply to a query), or null if there's nothing to send.
+     */
+    receive(frame) {
+        const decoder = decoding.createDecoder(frame);
+        const encoder = encoding.createEncoder();
+        const type = decoding.readVarUint(decoder);
+        switch (type) {
+            case MessageType.Sync: {
+                encoding.writeVarUint(encoder, MessageType.Sync);
+                const syncType = readSyncMessage(decoder, encoder, this.doc, this);
+                if (!this._synced && syncType === messageYjsSyncStep2)
+                    this._synced = true;
+                break;
+            }
+            case MessageType.Awareness:
+                if (this.awareness)
+                    applyAwarenessUpdate(this.awareness, decoding.readVarUint8Array(decoder), this);
+                return null;
+            case MessageType.QueryAwareness:
+                if (!this.awareness)
+                    return null;
+                encoding.writeVarUint(encoder, MessageType.Awareness);
+                encoding.writeVarUint8Array(encoder, encodeAwarenessUpdate(this.awareness, [...this.awareness.getStates().keys()]));
+                break;
+            case MessageType.Auth:
+                readAuthMessage(decoder, this.doc, (_doc, reason) => console.warn(`[yrb-lite] auth denied: ${reason}`));
+                return null;
+            default:
+                return null;
+        }
+        return encoding.length(encoder) > 1 ? encoding.toUint8Array(encoder) : null;
+    }
+    /** Detach doc/awareness listeners and stop retransmits. */
+    destroy() {
+        this.doc.off("update", this._onDocUpdate);
+        if (this.awareness && this._onAwarenessUpdate)
+            this.awareness.off("update", this._onAwarenessUpdate);
+        this._delivery.destroy();
+    }
+    _frameSyncStep1() {
+        const e = encoding.createEncoder();
+        encoding.writeVarUint(e, MessageType.Sync);
+        writeSyncStep1(e, this.doc);
+        return encoding.toUint8Array(e);
+    }
+    _frameUpdate(update) {
+        const e = encoding.createEncoder();
+        encoding.writeVarUint(e, MessageType.Sync);
+        writeUpdate(e, update);
+        return encoding.toUint8Array(e);
+    }
+    _frameAwareness(clients) {
+        const e = encoding.createEncoder();
+        encoding.writeVarUint(e, MessageType.Awareness);
+        encoding.writeVarUint8Array(e, encodeAwarenessUpdate(this.awareness, clients));
+        return encoding.toUint8Array(e);
+    }
+}
+//# sourceMappingURL=sync_engine.js.map

package/dist/sync_engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync_engine.js","sourceRoot":"","sources":["../src/sync_engine.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "yrb-lite-client",
+  "version": "0.1.0",
+  "description": "JavaScript client for the yrb-lite y-websocket protocol: a ready-made ActionCable/AnyCable provider, a transport-agnostic sync engine (sync steps, encode/decode, awareness), and a reliable-delivery core (ack-tracked queue, sync-since-last-ack, retransmit + reconnect replay). Written in TypeScript with bundled types; usable from plain JS.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./reliable": {
+      "types": "./dist/reliable_sync.d.ts",
+      "default": "./dist/reliable_sync.js"
+    },
+    "./base64": {
+      "types": "./dist/base64.d.ts",
+      "default": "./dist/base64.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepack": "npm run build",
+    "test": "npm run build && node --test"
+  },
+  "license": "MIT",
+  "author": "JP Camara <jp@jpcamara.com>",
+  "homepage": "https://github.com/jpcamara/yrb-lite/tree/main/packages/yrb-lite-client#readme",
+  "bugs": {
+    "url": "https://github.com/jpcamara/yrb-lite/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jpcamara/yrb-lite.git",
+    "directory": "packages/yrb-lite-client"
+  },
+  "keywords": [
+    "yjs",
+    "crdt",
+    "yrb-lite",
+    "reliable-delivery",
+    "actioncable",
+    "y-websocket",
+    "typescript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "yjs": "^13.6.0",
+    "y-protocols": "^1.0.5"
+  },
+  "peerDependenciesMeta": {
+    "yjs": {
+      "optional": true
+    },
+    "y-protocols": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "yjs": "^13.6.0",
+    "y-protocols": "^1.0.5",
+    "typescript": "^5.6.0"
+  }
+}