@abraca/dabra 2.16.0 → 2.17.0

package/dist/abracadabra-provider.cjs

@@ -1470,6 +1470,32 @@ var AbracadabraWS = class extends EventEmitter {
 			console.error(e);
 		}
 	}
+	/**
+	* Force a fresh socket on the SAME WS manager: drop the current connection
+	* (if any) and reconnect immediately.
+	*
+	* Unlike {@link disconnect} (which clears `shouldConnect` and gives up) this
+	* re-arms `shouldConnect`, so it also revives a socket that a permanent
+	* permission-denial turned off (see `AbracadabraBaseProvider.permissionDeniedHandler`).
+	* The WS manager and its `providerMap` are preserved, so every attached
+	* provider — and every Y.Doc + observer riding this socket — survives
+	* untouched; only the transport is recycled.
+	*
+	* The existing socket is torn down silently (handlers removed first), so no
+	* `close` event fires and no second reconnect is scheduled — `connect()`
+	* below is the single path that re-opens. Returns the `connect()` promise.
+	*/
+	reconnect() {
+		this.shouldConnect = true;
+		if (this.cancelWebsocketRetry) {
+			this.cancelWebsocketRetry();
+			this.cancelWebsocketRetry = void 0;
+		}
+		if (this.webSocket) this.cleanupWebSocket();
+		this.status = WebSocketStatus.Disconnected;
+		this.emit("status", { status: WebSocketStatus.Disconnected });
+		return this.connect();
+	}
 	send(message) {
 		if (this.webSocket?.readyState === WsReadyStates.Open) this.webSocket.send(message);
 		else this.messageQueue.push(message);
@@ -2460,6 +2486,7 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 			onAuthenticationFailed: () => null,
 			onRateLimited: () => null,
 			onOpen: () => null,
+			onReconnected: () => null,
 			onConnect: () => null,
 			onMessage: () => null,
 			onOutgoingMessage: () => null,
@@ -2478,6 +2505,7 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 		this.unsyncedChanges = 0;
 		this.isAuthenticated = false;
 		this._hasEverAuthenticated = false;
+		this._hasOpenedBefore = false;
 		this.authorizedScope = void 0;
 		this.manageSocket = false;
 		this._isAttached = false;
@@ -2498,6 +2526,7 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 		this.configuration.awareness = configuration.awareness !== void 0 ? configuration.awareness : new Awareness(this.document);
 		if (this.awareness && this.awareness.getLocalState() === null) this.awareness.setLocalState({});
 		this.on("open", this.configuration.onOpen);
+		this.on("reconnected", this.configuration.onReconnected);
 		this.on("message", this.configuration.onMessage);
 		this.on("outgoingMessage", this.configuration.onOutgoingMessage);
 		this.on("synced", this.configuration.onSynced);
@@ -2647,9 +2676,41 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 		if (this.manageSocket) return this.configuration.websocketProvider.disconnect();
 		console.warn("AbracadabraBaseProvider::disconnect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.");
 	}
+	/**
+	* Force the underlying socket to drop and reconnect on the SAME Y.Doc.
+	*
+	* Unlike destroying and re-creating the provider, the document is never
+	* replaced — so every `observe`/`observeDeep` listener attached to it (and
+	* its subdocs) keeps firing once the socket comes back. This also revives a
+	* socket that a permanent permission-denial gave up on (see
+	* {@link permissionDeniedHandler}). Pair it with a freshly-minted token (the
+	* `token` callback is re-invoked on every reconnect) when healing a drop that
+	* was caused by an expired JWT.
+	*
+	* Every provider multiplexed onto this socket is marked unsynced so a
+	* subsequent `waitForSync` actually waits for the post-reconnect handshake
+	* instead of short-circuiting on the stale `isSynced` flag.
+	*
+	* No-op (with a warning) for a provider on a shared, externally-managed
+	* socket — reconnect the owning `websocketProvider` directly in that case.
+	*/
+	reconnect() {
+		if (!this.manageSocket) {
+			console.warn("AbracadabraBaseProvider::reconnect() — this provider shares an externally-managed socket; call reconnect() on the websocketProvider instead.");
+			return;
+		}
+		for (const provider of this.configuration.websocketProvider.configuration.providerMap.values()) {
+			provider.synced = false;
+			provider.isAuthenticated = false;
+		}
+		return this.configuration.websocketProvider.reconnect();
+	}
 	async onOpen(event) {
+		const isReopen = this._hasOpenedBefore;
+		this._hasOpenedBefore = true;
 		this.isAuthenticated = false;
 		this.emit("open", { event });
+		if (isReopen) this.emit("reconnected", { event });
 		await this.sendToken();
 		this.startSync();
 	}
@@ -19177,6 +19238,93 @@ var TreeManager = class {
 	}
 };
 
+//#endregion
+//#region packages/provider/src/CoverReconcile.ts
+/**
+* CoverReconcile — keep a document's cover-image metadata in sync with the
+* image/video file blocks that actually live in its content.
+*
+* The cover (`meta.coverUploadId` / `coverDocId` / `coverMimeType` on the
+* doc's own tree entry) is *persisted* metadata, not derived live — the
+* kanban/gallery/table views read it without loading each card's content.
+* Historically the only thing that reconciled it was cou-sh's TipTap editor
+* (`reconcileCover` in DocRenderer.vue), so any write that did NOT go through
+* that editor — MCP `write_document`, `@abraca/convert`, the CLI, another SDK
+* — could leave an orphaned cover pointing at an image the body no longer
+* contains. This is the shared, write-path-level reconciliation so every
+* content write through the SDK keeps the cover honest.
+*
+* Semantics mirror cou-sh's editor reconciler exactly:
+*  - cover set + still references a present image/video → leave it (a
+*    user-chosen cover is preserved as long as its image is in the doc);
+*  - cover set + its image is gone, others remain → swap to the first;
+*  - cover set + no image/video remains → clear the three cover keys;
+*  - no cover + at least one image/video → adopt the first as the cover.
+*/
+/**
+* Recursively collect image/video `fileBlock` nodes from a Y.XmlFragment (or
+* element subtree), in document order. Mirrors the TipTap
+* `doc.descendants()` walk used by cou-sh — fileBlocks may be nested inside
+* other block nodes, so this recurses rather than scanning only top level.
+*/
+function collectMediaFileBlocks(root) {
+	const out = [];
+	const visit = (node) => {
+		if (node instanceof yjs.XmlElement && node.nodeName === "fileBlock") {
+			const mimeType = node.getAttribute("mimeType");
+			if (typeof mimeType === "string" && (mimeType.startsWith("image/") || mimeType.startsWith("video/"))) {
+				const uploadId = node.getAttribute("uploadId");
+				if (typeof uploadId === "string" && uploadId) {
+					const docId = node.getAttribute("docId");
+					out.push({
+						uploadId,
+						docId: typeof docId === "string" ? docId : "",
+						mimeType
+					});
+				}
+			}
+		}
+		if (node instanceof yjs.XmlElement || node instanceof yjs.XmlFragment) for (let i = 0; i < node.length; i++) visit(node.get(i));
+	};
+	visit(root);
+	return out;
+}
+/**
+* Reconcile the cover metadata of `docId`'s tree entry against the media file
+* blocks currently present in `fragment`. No-op when the entry is missing or
+* the cover is already valid, so it is safe (and cheap) to call after every
+* content write. The `treeMap` is the root doc-tree Y.Map; the cover lives on
+* the doc's OWN self-entry (`treeMap.get(docId).meta`).
+*/
+function reconcileDocCover(treeMap, docId, fragment) {
+	const raw = treeMap.get(docId);
+	if (!raw) return;
+	const meta = toPlain(raw).meta ?? {};
+	const currentCoverId = meta.coverUploadId;
+	const media = collectMediaFileBlocks(fragment);
+	if (currentCoverId && media.some((b) => b.uploadId === currentCoverId)) return;
+	if (media.length > 0) {
+		const best = media[0];
+		if (currentCoverId === best.uploadId && meta.coverDocId === (best.docId || docId) && meta.coverMimeType === best.mimeType) return;
+		patchEntry(treeMap, docId, {
+			meta: {
+				...meta,
+				coverUploadId: best.uploadId,
+				coverDocId: best.docId || docId,
+				coverMimeType: best.mimeType
+			},
+			updatedAt: Date.now()
+		});
+		return;
+	}
+	if (!currentCoverId && !meta.coverDocId && !meta.coverMimeType) return;
+	const { coverUploadId: _cu, coverDocId: _cd, coverMimeType: _cm, ...rest } = meta;
+	patchEntry(treeMap, docId, {
+		meta: rest,
+		updatedAt: Date.now()
+	});
+}
+
 //#endregion
 //#region packages/provider/src/DocConverters.ts
 /**
@@ -20583,6 +20731,8 @@ var ContentManager = class {
 			while (fragment.length > 0) fragment.delete(0);
 		});
 		populateYDocFromMarkdown(fragment, body || markdown, title || "Untitled");
+		const reconcileTree = this.dm.getTreeMap();
+		if (reconcileTree) reconcileDocCover(reconcileTree, docId, fragment);
 	}
 	async _appendElements(docId, els) {
 		const doc = (await this.dm.getChildProvider(docId)).document;
@@ -21054,6 +21204,7 @@ exports.buildHorizontalRuleElement = buildHorizontalRuleElement;
 exports.buildOrderedListElement = buildOrderedListElement;
 exports.buildParagraphElement = buildParagraphElement;
 exports.buildTaskListElement = buildTaskListElement;
+exports.collectMediaFileBlocks = collectMediaFileBlocks;
 exports.decryptChatContent = decryptChatContent;
 exports.decryptField = decryptField;
 exports.deriveIdentityDocId = deriveIdentityDocId;
@@ -21076,6 +21227,7 @@ exports.patchEntry = patchEntry;
 exports.populateYDocFromMarkdown = populateYDocFromMarkdown;
 exports.readAuthMessage = readAuthMessage;
 exports.readBlocksFromFragment = readBlocksFromFragment;
+exports.reconcileDocCover = reconcileDocCover;
 exports.recordFromYAny = recordFromYAny;
 exports.resolvePageType = resolvePageType;
 exports.toPlain = toPlain;