@abraca/resend 2.16.0 → 2.17.0

package/dist/index.d.ts

@@ -18,6 +18,7 @@ declare class AbracadabraResendServer {
   private _connection;
   private childCache;
   private evictionTimer;
+  private heartbeatTimer;
   private _userId;
   private _signFn;
   private _reconnecting;
@@ -123,11 +124,15 @@ declare class OutboxWatcher {
   private readonly bootstrap;
   private readonly defaultFrom;
   private readonly inFlight;
-  private readonly handled;
   private observer;
   private treeMap;
   private rootDoc;
   private txHandler;
+  private subdocsHandler;
+  private updateHandler;
+  private reconnectedHandler;
+  private reconnectProvider;
+  private readonly subdocHandlers;
   constructor(opts: OutboxWatcherOptions);
   start(): void;
   stop(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/resend",
-  "version": "2.16.0",
+  "version": "2.17.0",
   "description": "Resend bridge for Abracadabra — Inbox + Outbox documents wired to email send/receive",
   "license": "MIT",
   "type": "module",
@@ -33,8 +33,8 @@
     "resend": "^4.0.0",
     "yjs": "^13.6.8",
     "zod": "^4.3.6",
-    "@abraca/convert": "2.16.0",
-    "@abraca/dabra": "2.16.0"
+    "@abraca/convert": "2.17.0",
+    "@abraca/dabra": "2.17.0"
   },
   "scripts": {
     "test": "node --no-warnings --conditions=source --experimental-transform-types --test 'tests/*.test.ts'"

package/src/outbox-watcher.ts

@@ -54,12 +54,41 @@ export class OutboxWatcher {
 	private readonly sender: ResendSender;
 	private readonly bootstrap: BootstrapResult;
 	private readonly defaultFrom: string;
+	// Transient mid-dispatch guard ONLY: holds ids whose send is in flight RIGHT
+	// NOW, so a burst of observe events doesn't fire a second concurrent send
+	// before `meta.resendId` lands. Cleared the instant a dispatch settles — it
+	// is NEVER a durable "already sent" marker. The ONLY durable sent-state is
+	// `meta.resendId` on the document (set on success); a failed send is durably
+	// recorded by the move to the Failed column + `meta.error`. There is no
+	// in-memory "handled" set: a card re-queued into Ready (resendId cleared) is
+	// re-sent, and the bridge's view never diverges from the persisted tree.
 	private readonly inFlight = new Set<string>();
-	private readonly handled = new Set<string>();
 	private observer: ((events: Y.YEvent<any>[]) => void) | null = null;
 	private treeMap: Y.Map<any> | null = null;
 	private rootDoc: Y.Doc | null = null;
 	private txHandler: ((tx: Y.Transaction) => void) | null = null;
+	private subdocsHandler:
+		| ((changes: {
+				added: Set<Y.Doc>;
+				removed: Set<Y.Doc>;
+				loaded: Set<Y.Doc>;
+		  }) => void)
+		| null = null;
+	private updateHandler:
+		| ((update: Uint8Array, origin: unknown) => void)
+		| null = null;
+	private reconnectedHandler: (() => void) | null = null;
+	// The provider we attached `reconnected` to, kept so stop() can detach.
+	private reconnectProvider: { off(ev: string, cb: () => void): void } | null =
+		null;
+	// Per-subdoc afterTransaction handlers. Tracked so we (a) detach them on
+	// stop() and (b) never stack a second listener when the same subdoc reloads
+	// (the old code re-`on`'d every subdoc on every `subdocs` event — an
+	// unbounded listener leak that grew for the life of the daemon).
+	private readonly subdocHandlers = new Map<
+		Y.Doc,
+		(tx: Y.Transaction) => void
+	>();
 
 	constructor(opts: OutboxWatcherOptions) {
 		this.server = opts.server;
@@ -114,31 +143,65 @@ export class OutboxWatcher {
 
 		// Belt-and-suspenders: subdocs. abracadabra-rs may route some space-tree
 		// edits through subdoc payloads that don't fire transactions on the root
-		// doc directly. Watch every subdoc's transactions too.
-		const onSubdocs = (changes: { added: Set<Y.Doc>; removed: Set<Y.Doc>; loaded: Set<Y.Doc> }) => {
+		// doc directly. Watch every subdoc's transactions too — but dedup, so a
+		// subdoc that loads/unloads/reloads doesn't accumulate listeners.
+		const onSubdocs = (changes: {
+			added: Set<Y.Doc>;
+			removed: Set<Y.Doc>;
+			loaded: Set<Y.Doc>;
+		}) => {
 			console.error(
-				`[abracadabra-resend] subdocs: added=${changes.added.size} loaded=${changes.loaded.size}`,
+				`[abracadabra-resend] subdocs: added=${changes.added.size} loaded=${changes.loaded.size} removed=${changes.removed.size}`,
 			);
+			for (const sub of changes.removed) {
+				const handler = this.subdocHandlers.get(sub);
+				if (handler) {
+					sub.off("afterTransaction", handler);
+					this.subdocHandlers.delete(sub);
+				}
+			}
 			for (const sub of [...changes.added, ...changes.loaded]) {
-				sub.on("afterTransaction", (tx: Y.Transaction) => {
+				if (this.subdocHandlers.has(sub)) continue;
+				const handler = (tx: Y.Transaction) => {
 					console.error(
 						`[abracadabra-resend] subdoc afterTransaction (guid=${sub.guid}, local=${tx.local})`,
 					);
 					void this.scan("subdoc");
-				});
+				};
+				sub.on("afterTransaction", handler);
+				this.subdocHandlers.set(sub, handler);
 			}
 		};
 		rootDoc.on("subdocs", onSubdocs);
+		this.subdocsHandler = onSubdocs;
 
 		// Raw doc update — fires for every binary Yjs update applied to the doc,
 		// from any origin. If THIS doesn't fire when a remote writer changes
 		// state, the bridge's WS isn't delivering updates.
-		rootDoc.on("update", (_update: Uint8Array, origin: unknown) => {
+		const onUpdate = (_update: Uint8Array, origin: unknown) => {
 			console.error(
 				`[abracadabra-resend] root update applied (origin=${String(origin)})`,
 			);
 			void this.scan("update");
-		});
+		};
+		rootDoc.on("update", onUpdate);
+		this.updateHandler = onUpdate;
+
+		// Re-scan whenever the provider's socket reconnects. The doc (and these
+		// observers) survive a reconnect untouched, and the post-reconnect sync
+		// re-fires them for anything that changed while we were offline — but an
+		// explicit, idempotent catch-up scan guarantees we don't sit on a Ready
+		// doc that landed during the outage.
+		const provider = this.server.rootProvider;
+		if (provider && typeof (provider as any).on === "function") {
+			const onReconnected = () => {
+				console.error("[abracadabra-resend] provider reconnected — re-scanning");
+				void this.scan("reconnected");
+			};
+			(provider as any).on("reconnected", onReconnected);
+			this.reconnectedHandler = onReconnected;
+			this.reconnectProvider = provider as any;
+		}
 
 		console.error(
 			`[abracadabra-resend] Outbox watcher attached (ready column ${this.bootstrap.columns.Ready})`,
@@ -149,10 +212,27 @@ export class OutboxWatcher {
 		if (this.rootDoc && this.txHandler) {
 			this.rootDoc.off("afterTransaction", this.txHandler);
 		}
+		if (this.rootDoc && this.subdocsHandler) {
+			this.rootDoc.off("subdocs", this.subdocsHandler);
+		}
+		if (this.rootDoc && this.updateHandler) {
+			this.rootDoc.off("update", this.updateHandler);
+		}
+		for (const [sub, handler] of this.subdocHandlers) {
+			sub.off("afterTransaction", handler);
+		}
+		this.subdocHandlers.clear();
 		if (this.treeMap && this.observer) {
 			this.treeMap.unobserveDeep(this.observer);
 		}
+		if (this.reconnectProvider && this.reconnectedHandler) {
+			this.reconnectProvider.off("reconnected", this.reconnectedHandler);
+		}
 		this.txHandler = null;
+		this.subdocsHandler = null;
+		this.updateHandler = null;
+		this.reconnectedHandler = null;
+		this.reconnectProvider = null;
 		this.rootDoc = null;
 		this.observer = null;
 		this.treeMap = null;
@@ -189,9 +269,12 @@ export class OutboxWatcher {
 			}
 			if (e.parentId !== readyColId) return;
 			inReadyCount++;
-			if (this.inFlight.has(id) || this.handled.has(id)) return;
+			// Transient: a send for this id is already in flight in THIS process.
+			if (this.inFlight.has(id)) return;
+			// Durable: already sent (resendId persisted on the doc). Never re-send;
+			// just reconcile its column to Sent. This is the single source of truth
+			// for "done" — survives restarts, lives in document metadata.
 			if (typeof e.meta.resendId === "string" && e.meta.resendId.length > 0) {
-				this.handled.add(id);
 				this.moveTo(id, this.bootstrap.columns.Sent);
 				return;
 			}
@@ -219,14 +302,15 @@ export class OutboxWatcher {
 			const { id: resendId } = await this.sender.send(payload, {
 				"X-Abra-Doc-Id": id,
 			});
-			this.handled.add(id);
+			// Durable sent-marker: persisted on the doc, the only record of "sent".
 			this.patchMeta(id, { resendId, sentAt: Date.now(), error: null });
 			this.moveTo(id, this.bootstrap.columns.Sent);
 			console.error(
 				`[abracadabra-resend] sent "${payload.subject}" (resend=${resendId}, doc=${id})`,
 			);
 		} catch (err: any) {
-			this.handled.add(id);
+			// Durable failure record: meta.error + the move to the Failed column
+			// (below) — left for human triage. No in-memory marker.
 			const message =
 				err instanceof RenderError
 					? err.message

package/src/server.ts

@@ -48,6 +48,7 @@ export class AbracadabraResendServer {
 	private _connection: SpaceConnection | null = null;
 	private childCache = new Map<string, CachedProvider>();
 	private evictionTimer: ReturnType<typeof setInterval> | null = null;
+	private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
 	private _userId: string | null = null;
 	private _signFn: ((challenge: string) => Promise<string>) | null = null;
 	private _reconnecting: Promise<void> | null = null;
@@ -152,6 +153,16 @@ export class AbracadabraResendServer {
 		console.error("[abracadabra-resend] Space doc synced");
 
 		this.evictionTimer = setInterval(() => this.evictIdle(), 60_000);
+
+		// Connection heartbeat. The bridge is a long-running daemon that can sit
+		// idle for hours; its JWT will expire and the socket can drop with no
+		// dispatch to trigger a heal. `ensureConnected` is a no-op while healthy
+		// (just refreshes the token if it's near expiry), and revives the socket
+		// on the SAME doc — keeping the outbox watcher's observers alive — if it
+		// died. This is what makes "once connected, STAY connected" true when idle.
+		this.heartbeatTimer = setInterval(() => {
+			void this.ensureConnected();
+		}, 30_000);
 	}
 
 	private async _connectToSpace(docId: string): Promise<SpaceConnection> {
@@ -206,35 +217,36 @@ export class AbracadabraResendServer {
 				const conn = this._connection;
 				if (!conn) return;
 				if (this._wsConnected(conn.provider)) return;
+
+				// Give the SDK's own auto-reconnect a bounded window before forcing
+				// one ourselves.
 				try {
 					await waitForSync(conn.provider, 6000);
 				} catch {
-					/* fall through to rebuild */
+					/* fall through to forced reconnect */
 				}
 				if (this._wsConnected(conn.provider)) return;
 
+				// Still dead → force a reconnect on the SAME Y.Doc. Critically we do
+				// NOT destroy + recreate the provider: the outbox watcher's
+				// observeDeep / afterTransaction listeners are attached to THIS doc,
+				// and swapping the doc out from under them is exactly what made the
+				// bridge go silent ("works until it doesn't") after a drop. The doc
+				// survives, observers keep firing, and step 1's token refresh lets
+				// the recycled socket re-authenticate cleanly. Cached child providers
+				// multiplex this same socket and re-sync on reopen, so we keep them.
 				console.error(
-					"[abracadabra-resend] Active connection dead — rebuilding…",
+					"[abracadabra-resend] Socket dead — forcing reconnect on the same doc…",
 				);
-				const docId = conn.docId;
+				conn.provider.reconnect();
 				try {
-					conn.provider.destroy();
-				} catch {
-					/* already gone */
-				}
-				for (const [, cached] of this.childCache) {
-					try {
-						cached.provider.destroy();
-					} catch {
-						/* already gone */
-					}
-				}
-				this.childCache.clear();
-				try {
-					await this._connectToSpace(docId);
-					console.error("[abracadabra-resend] Space provider rebuilt + synced");
+					await waitForSync(conn.provider, 10000);
+					console.error("[abracadabra-resend] Reconnected + re-synced");
 				} catch (e) {
-					console.error("[abracadabra-resend] Connection rebuild failed:", e);
+					console.error(
+						"[abracadabra-resend] Reconnect did not re-sync in time:",
+						e,
+					);
 				}
 			} finally {
 				this._reconnecting = null;
@@ -301,6 +313,10 @@ export class AbracadabraResendServer {
 			clearInterval(this.evictionTimer);
 			this.evictionTimer = null;
 		}
+		if (this.heartbeatTimer) {
+			clearInterval(this.heartbeatTimer);
+			this.heartbeatTimer = null;
+		}
 		for (const [, cached] of this.childCache) {
 			try {
 				cached.provider.destroy();