@abraca/dabra 1.9.1 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/dabra",
-  "version": "1.9.1",
+  "version": "2.0.1",
   "description": "abracadabra provider",
   "keywords": [
     "abracadabra",

package/src/AbracadabraBaseProvider.ts

@@ -11,6 +11,7 @@ import { MessageSender } from "./MessageSender.ts";
 import { AuthenticationMessage } from "./OutgoingMessages/AuthenticationMessage.ts";
 import { AwarenessMessage } from "./OutgoingMessages/AwarenessMessage.ts";
 import { StatelessMessage } from "./OutgoingMessages/StatelessMessage.ts";
+import { RpcClient } from "./RpcClient.ts";
 import { SyncStepOneMessage } from "./OutgoingMessages/SyncStepOneMessage.ts";
 import { UpdateMessage } from "./OutgoingMessages/UpdateMessage.ts";
 import type {
@@ -157,6 +158,19 @@ export class AbracadabraBaseProvider extends EventEmitter {
     forceSync: null,
   };
 
+  /**
+   * Lazily-constructed RPC v1 client. See `RpcClient`/`docs/rpc-v1.md`.
+   * Bound to this provider's stateless transport, so calls and handlers
+   * ride the doc this provider is subscribed to.
+   */
+  private _rpc: RpcClient | undefined;
+  get rpc(): RpcClient {
+    if (!this._rpc) {
+      this._rpc = new RpcClient(this);
+    }
+    return this._rpc;
+  }
+
   constructor(configuration: AbracadabraBaseProviderConfiguration) {
     super();
     this.setConfiguration(configuration);
@@ -167,6 +181,15 @@ export class AbracadabraBaseProvider extends EventEmitter {
         ? configuration.awareness
         : new Awareness(this.document);
 
+    // y-protocols' setLocalStateField silently no-ops when getLocalState() is null.
+    // Seeding with {} once ensures the *first* setLocalStateField call from any
+    // consumer (TipTap CollaborationCaret, DocumentManager, app code) actually
+    // publishes — instead of vanishing without a trace. Idempotent for callers
+    // that pass their own awareness instance with state already set.
+    if (this.awareness && this.awareness.getLocalState() === null) {
+      this.awareness.setLocalState({});
+    }
+
     this.on("open", this.configuration.onOpen);
     this.on("message", this.configuration.onMessage);
     this.on("outgoingMessage", this.configuration.onOutgoingMessage);
@@ -264,7 +287,12 @@ export class AbracadabraBaseProvider extends EventEmitter {
   }
 
   private resetUnsyncedChanges() {
-    this.unsyncedChanges = 1;
+    // The unsynced counter tracks pending UpdateMessage acks (decremented by
+    // SyncStatusMessage). The handshake itself is a connection-level concern,
+    // not a doc update — reflect that by resetting to 0. The synced flag and
+    // status: 'connecting' already surface in-flight sync to the UI; bumping
+    // this counter to 1 would leave it stuck (SyncStep2 doesn't decrement).
+    this.unsyncedChanges = 0;
     this.emit("unsyncedChanges", { number: this.unsyncedChanges });
   }
 
@@ -367,7 +395,18 @@ export class AbracadabraBaseProvider extends EventEmitter {
     this.isSynced = state;
 
     if (state) {
-      this.emit("synced", { state });
+      // Defer the emit one microtask. Y.applyUpdate dispatches Y.Map /
+      // Y.Array observer notifications via microtasks; emitting `synced`
+      // synchronously would let listeners read `getArray("messages")` (or
+      // any sub-type populated by the just-applied state) and see length
+      // 0 even though the wire delivered the full state. Deferring one
+      // microtask lets the observers run first so everyone reading after
+      // the synced event sees the populated state.
+      queueMicrotask(() => {
+        // Re-check in case `synced` flipped back to false between the
+        // mutation and this microtask (e.g. a reconnect aborted sync).
+        if (this.isSynced) this.emit("synced", { state });
+      });
     }
   }
 
@@ -481,6 +520,16 @@ export class AbracadabraBaseProvider extends EventEmitter {
   destroy() {
     this.emit("destroy");
 
+    if (this._rpc) {
+      // Keep the (now-destroyed) RpcClient bound to `_rpc` rather than
+      // setting it back to `undefined`. The lazy getter would otherwise
+      // construct a fresh client wired against a provider whose listeners
+      // are gone, leaving any subsequent `rpc.call(...)` to hang forever.
+      // The client's own `destroyed` flag now turns `call()` into an
+      // immediate `CANCELLED` rejection — the right terminal outcome.
+      this._rpc.destroy();
+    }
+
     if (this.intervals.forceSync) {
       clearInterval(this.intervals.forceSync);
     }
@@ -562,6 +611,25 @@ export class AbracadabraBaseProvider extends EventEmitter {
   permissionDeniedHandler(reason: string) {
     this.emit("authenticationFailed", { reason });
     this.isAuthenticated = false;
+
+    // Stop the reconnect loop on a permanent denial. Without this the WS
+    // closes after every server-side rejection, AbracadabraWS schedules a
+    // retry, the new connection sends the same Subscribe → server denies
+    // again, ad infinitum (CPU/log/network spam, page looks "broken" to
+    // the user). The dominant cases:
+    //   * "document not found" — entry-doc-id pinned to something that
+    //     doesn't exist on this server
+    //   * "permission denied" — operator never granted the user access
+    // Both are config issues; retrying won't fix them. We only stop the
+    // socket when this provider OWNS it (`manageSocket`); shared sockets
+    // (e.g. multiplexed child providers) leave the parent's lifecycle
+    // alone and just give up on this doc.
+    if (this.manageSocket) {
+      try {
+        this.configuration.websocketProvider.disconnect();
+      }
+      catch { /* WS may already be torn down — best effort */ }
+    }
   }
 
   authenticatedHandler(scope: string) {