@abraca/dabra 2.16.0 → 2.17.1

package/dist/abracadabra-provider.esm.js

@@ -1440,6 +1440,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);
@@ -2430,6 +2456,7 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 			onAuthenticationFailed: () => null,
 			onRateLimited: () => null,
 			onOpen: () => null,
+			onReconnected: () => null,
 			onConnect: () => null,
 			onMessage: () => null,
 			onOutgoingMessage: () => null,
@@ -2448,6 +2475,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;
@@ -2468,6 +2496,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);
@@ -2617,9 +2646,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();
 	}
@@ -19117,6 +19178,125 @@ 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.
+*/
+const EXT_MIME = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	avif: "image/avif",
+	svg: "image/svg+xml",
+	bmp: "image/bmp",
+	heic: "image/heic",
+	heif: "image/heif",
+	mp4: "video/mp4",
+	webm: "video/webm",
+	mov: "video/quicktime",
+	m4v: "video/x-m4v",
+	ogv: "video/ogg",
+	mkv: "video/x-matroska"
+};
+function attr(node, name) {
+	const v = node.getAttribute(name);
+	return typeof v === "string" && v ? v : void 0;
+}
+/**
+* Resolve a file node's mime type. A `fileBlock` may carry the mime under
+* `mimeType` (cou-sh's TipTap/y-prosemirror node attr) or `mime` (the
+* `@abraca/convert` markdown path), and may carry neither — in which case we
+* infer it from the filename/src extension (the convert sidecar `src` is
+* `.abracadabra/files/<id>-<filename>`). Returns "" when it can't be
+* classified as image/video.
+*/
+function resolveMime(node) {
+	const explicit = attr(node, "mimeType") ?? attr(node, "mime");
+	if (explicit) return explicit;
+	return EXT_MIME[(attr(node, "filename") ?? attr(node, "src") ?? "").split(".").pop()?.toLowerCase() ?? ""] ?? "";
+}
+/**
+* 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 Y.XmlElement && node.nodeName === "fileBlock") {
+			const uploadId = attr(node, "uploadId") ?? attr(node, "upload-id");
+			if (uploadId) {
+				const mimeType = resolveMime(node);
+				if (mimeType.startsWith("image/") || mimeType.startsWith("video/")) out.push({
+					uploadId,
+					docId: attr(node, "docId") ?? "",
+					mimeType
+				});
+			}
+		}
+		if (node instanceof Y.XmlElement || node instanceof Y.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
 /**
@@ -20518,6 +20698,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;
@@ -20908,5 +21090,5 @@ var DocumentManager = class {
 };
 
 //#endregion
-export { AbracadabraBaseProvider, AbracadabraClient, AbracadabraProvider, AbracadabraWS, AbracadabraWebRTC, AuthMessageType, AwarenessError, BackgroundSyncManager, BackgroundSyncPersistence, BroadcastChannelSync, CHANNEL_NAMES, ChannelKeyResolver, ChatClient, ConnectionTimeout, ContentManager, CryptoIdentityKeystore, DEFAULT_FILE_CHUNK_SIZE, DEFAULT_ICE_SERVERS, DataChannelRouter, DevicePairingChannel, DeviceRegistrationService, DocKeyManager, DocumentCache, DocumentManager, E2EAbracadabraProvider, E2EEChannel, E2EOfflineStore, EncryptedChatClient, EncryptedYMap, EncryptedYText, FileBlobStore, FileTransferChannel, FileTransferHandle, Forbidden, GEO_TYPE_META_SCHEMAS, HocuspocusProvider, HocuspocusProviderWebsocket, IdentityDocProvider, KEY_EXCHANGE_CHANNEL, Kind, LocalStorageDeviceSessionStorage, ManualSignaling, MessageTooBig, MessageType, MetaManager, MetaValidationError, NotificationsClient, OfflineStore, PAGE_TYPES, PeerConnection, QUERY_PREFIX, QueryClient, QueryError, RPC_PREFIX, ResetConnection, RpcClient, RpcError, SERVER_ROOT_ID, SearchIndex, SignalingSocket, SubdocMessage, TYPE_ALIASES, TokenManager, TreeManager, TypedDocTypeMismatchError, Unauthorized, WebSocketStatus, WsReadyStates, YjsDataChannel, attachUpdatedAtObserver, awarenessStatesToArray, wordlist as bip39Wordlist, buildBlockquoteElement, buildBlocksFromMarkdown, buildBulletListElement, buildCodeBlockElement, buildHeadingElement, buildHorizontalRuleElement, buildOrderedListElement, buildParagraphElement, buildTaskListElement, decryptChatContent, decryptField, deriveIdentityDocId, deriveSeedWrappingKey, encryptChatContent, encryptField, filenameToLabel, foldRecords, generateMnemonic, isEncryptedContent, isPlaceholderLabel, makeEncryptedYMap, makeEncryptedYText, makeEntryMap, mnemonicToEd25519Seed, mnemonicToKeyPair, normalizeRootId, parseFrontmatter, patchEntry, populateYDocFromMarkdown, readAuthMessage, readBlocksFromFragment, recordFromYAny, resolvePageType, toPlain, unwrapSeed, validateMnemonic, waitForSync, withTimeout, wrapSeed, writeAuthenticated, writeAuthentication, writePermissionDenied, writeTokenSyncRequest, yjsToMarkdown };
+export { AbracadabraBaseProvider, AbracadabraClient, AbracadabraProvider, AbracadabraWS, AbracadabraWebRTC, AuthMessageType, AwarenessError, BackgroundSyncManager, BackgroundSyncPersistence, BroadcastChannelSync, CHANNEL_NAMES, ChannelKeyResolver, ChatClient, ConnectionTimeout, ContentManager, CryptoIdentityKeystore, DEFAULT_FILE_CHUNK_SIZE, DEFAULT_ICE_SERVERS, DataChannelRouter, DevicePairingChannel, DeviceRegistrationService, DocKeyManager, DocumentCache, DocumentManager, E2EAbracadabraProvider, E2EEChannel, E2EOfflineStore, EncryptedChatClient, EncryptedYMap, EncryptedYText, FileBlobStore, FileTransferChannel, FileTransferHandle, Forbidden, GEO_TYPE_META_SCHEMAS, HocuspocusProvider, HocuspocusProviderWebsocket, IdentityDocProvider, KEY_EXCHANGE_CHANNEL, Kind, LocalStorageDeviceSessionStorage, ManualSignaling, MessageTooBig, MessageType, MetaManager, MetaValidationError, NotificationsClient, OfflineStore, PAGE_TYPES, PeerConnection, QUERY_PREFIX, QueryClient, QueryError, RPC_PREFIX, ResetConnection, RpcClient, RpcError, SERVER_ROOT_ID, SearchIndex, SignalingSocket, SubdocMessage, TYPE_ALIASES, TokenManager, TreeManager, TypedDocTypeMismatchError, Unauthorized, WebSocketStatus, WsReadyStates, YjsDataChannel, attachUpdatedAtObserver, awarenessStatesToArray, wordlist as bip39Wordlist, buildBlockquoteElement, buildBlocksFromMarkdown, buildBulletListElement, buildCodeBlockElement, buildHeadingElement, buildHorizontalRuleElement, buildOrderedListElement, buildParagraphElement, buildTaskListElement, collectMediaFileBlocks, decryptChatContent, decryptField, deriveIdentityDocId, deriveSeedWrappingKey, encryptChatContent, encryptField, filenameToLabel, foldRecords, generateMnemonic, isEncryptedContent, isPlaceholderLabel, makeEncryptedYMap, makeEncryptedYText, makeEntryMap, mnemonicToEd25519Seed, mnemonicToKeyPair, normalizeRootId, parseFrontmatter, patchEntry, populateYDocFromMarkdown, readAuthMessage, readBlocksFromFragment, reconcileDocCover, recordFromYAny, resolvePageType, toPlain, unwrapSeed, validateMnemonic, waitForSync, withTimeout, wrapSeed, writeAuthenticated, writeAuthentication, writePermissionDenied, writeTokenSyncRequest, yjsToMarkdown };
 //# sourceMappingURL=abracadabra-provider.esm.js.map