@abraca/dabra 1.0.14 → 1.0.16

package/src/FileBlobStore.ts

@@ -75,7 +75,7 @@ export class FileBlobStore extends EventEmitter {
 	private static readonly NOT_FOUND_TTL = 5 * 60 * 1000;
 
 	/** Prevents concurrent flush runs. */
-	private _flushing = false;
+	private _flushPromise: Promise<void> | null = null;
 
 	private readonly _onlineHandler: () => void;
 
@@ -272,6 +272,21 @@ export class FileBlobStore extends EventEmitter {
 		});
 	}
 
+	/**
+	 * Revoke the in-memory object URL without touching the IDB cache.
+	 * The next call to getBlobUrl() will re-create a fresh URL from IDB.
+	 * Use this when an <img> @error fires — the blob data is fine, only
+	 * the object URL reference is stale.
+	 */
+	invalidateUrl(docId: string, uploadId: string): void {
+		const key = this.blobKey(docId, uploadId);
+		const url = this.objectUrls.get(key);
+		if (url) {
+			URL.revokeObjectURL(url);
+			this.objectUrls.delete(key);
+		}
+	}
+
 	/** Revoke the object URL and remove the blob from cache. */
 	async evictBlob(docId: string, uploadId: string): Promise<void> {
 		const key = this.blobKey(docId, uploadId);
@@ -344,29 +359,33 @@ export class FileBlobStore extends EventEmitter {
 	 * Entries that fail are marked with status "error" and left in the queue.
 	 */
 	async flushQueue(): Promise<void> {
-		if (this._flushing || !this.client) return;
-		this._flushing = true;
-
+		if (this._flushPromise || !this.client) return;
+		this._flushPromise = this._doFlush();
 		try {
-			const all = await this.getQueue();
-			const pending = all.filter((e) => e.status === "pending");
-
-			for (const entry of pending) {
-				await this._updateQueueEntry(entry.id, { status: "uploading" });
-				this.emit("upload:started", { ...entry, status: "uploading" });
-
-				try {
-					await this.client.upload(entry.docId, entry.file, entry.filename);
-					await this._updateQueueEntry(entry.id, { status: "done" });
-					this.emit("upload:done", { ...entry, status: "done" });
-				} catch (err) {
-					const message = err instanceof Error ? err.message : String(err);
-					await this._updateQueueEntry(entry.id, { status: "error", error: message });
-					this.emit("upload:error", { ...entry, status: "error", error: message });
-				}
-			}
+			await this._flushPromise;
 		} finally {
-			this._flushing = false;
+			this._flushPromise = null;
+		}
+	}
+
+	private async _doFlush(): Promise<void> {
+		if (!this.client) return;
+		const all = await this.getQueue();
+		const pending = all.filter((e) => e.status === "pending");
+
+		for (const entry of pending) {
+			await this._updateQueueEntry(entry.id, { status: "uploading" });
+			this.emit("upload:started", { ...entry, status: "uploading" });
+
+			try {
+				await this.client.upload(entry.docId, entry.file, entry.filename);
+				await this._updateQueueEntry(entry.id, { status: "done" });
+				this.emit("upload:done", { ...entry, status: "done" });
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				await this._updateQueueEntry(entry.id, { status: "error", error: message });
+				this.emit("upload:error", { ...entry, status: "error", error: message });
+			}
 		}
 	}
 

package/src/OfflineStore.ts

@@ -251,6 +251,28 @@ export class OfflineStore {
 		);
 	}
 
+	/**
+	 * Clear all stored data (updates, snapshots, state vectors, subdoc queue).
+	 * The database itself is kept but emptied.
+	 */
+	async clearAll(): Promise<void> {
+		const db = await this.getDb();
+		if (!db) return;
+		const storeNames = Array.from(db.objectStoreNames);
+		if (storeNames.length === 0) return;
+		const tx = db.transaction(storeNames, "readwrite");
+		await Promise.all(
+			storeNames.map(
+				(name) =>
+					new Promise<void>((resolve, reject) => {
+						const req = tx.objectStore(name).clear();
+						req.onsuccess = () => resolve();
+						req.onerror = () => reject(req.error);
+					}),
+			),
+		);
+	}
+
 	// ── Lifecycle ─────────────────────────────────────────────────────────────
 
 	destroy() {

package/src/SearchIndex.ts

@@ -200,6 +200,8 @@ export class SearchIndex {
 		const queryTrigrams = [...extractTrigrams(query)];
 		if (queryTrigrams.length === 0) return [];
 
+		const maxScoreEntries = limit * 10;
+
 		return new Promise<SearchResult[]>((resolve, reject) => {
 			const tx = db.transaction("postings", "readonly");
 			const postings = tx.objectStore("postings");
@@ -212,6 +214,7 @@ export class SearchIndex {
 					const docIds: string[] = req.result ?? [];
 					for (const docId of docIds) {
 						scores.set(docId, (scores.get(docId) ?? 0) + 1);
+						if (scores.size >= maxScoreEntries) break;
 					}
 					remaining--;
 					if (remaining === 0) {

package/src/webrtc/DataChannelRouter.ts

@@ -94,9 +94,9 @@ export class DataChannelRouter extends EventEmitter {
 	 * Send data on a named channel, encrypting if E2EE is active.
 	 * Falls back to plaintext if no encryptor is set or for exempt channels.
 	 */
-	async send(name: string, data: Uint8Array): Promise<void> {
+	async send(name: string, data: Uint8Array): Promise<boolean> {
 		const channel = this.channels.get(name);
-		if (!channel || channel.readyState !== "open") return;
+		if (!channel || channel.readyState !== "open") return false;
 
 		if (this.encryptor?.isEstablished && !this.plaintextChannels.has(name)) {
 			const encrypted = await this.encryptor.encrypt(data);
@@ -104,6 +104,7 @@ export class DataChannelRouter extends EventEmitter {
 		} else {
 			channel.send(data);
 		}
+		return true;
 	}
 
 	private registerChannel(channel: RTCDataChannel): void {

package/src/webrtc/FileTransferChannel.ts

@@ -207,6 +207,7 @@ export class FileTransferChannel extends EventEmitter {
 		try {
 			meta = JSON.parse(json);
 		} catch {
+			this.emit("receiveError", { transferId: "unknown", error: "Malformed START message: invalid JSON" });
 			return;
 		}
 

package/src/webrtc/ManualSignaling.ts

@@ -106,7 +106,11 @@ export class ManualSignaling extends EventEmitter {
 
 		// Add remote ICE candidates.
 		for (const c of offerBlob.candidates) {
-			await this.pc.addIceCandidate(new RTCIceCandidate(JSON.parse(c)));
+			try {
+				await this.pc.addIceCandidate(new RTCIceCandidate(JSON.parse(c)));
+			} catch {
+				// Skip malformed ICE candidate
+			}
 		}
 
 		// Create answer.

package/src/webrtc/SignalingSocket.ts

@@ -87,9 +87,21 @@ export class SignalingSocket extends EventEmitter {
 		return this.config.token;
 	}
 
+	private _connectPromise: Promise<void> | null = null;
+
 	async connect(): Promise<void> {
 		if (this.isConnected) return;
+		if (this._connectPromise) return this._connectPromise;
+
+		this._connectPromise = this._doConnect();
+		try {
+			await this._connectPromise;
+		} finally {
+			this._connectPromise = null;
+		}
+	}
 
+	private async _doConnect(): Promise<void> {
 		if (this.cancelRetry) {
 			this.cancelRetry();
 			this.cancelRetry = undefined;

package/src/webrtc/YjsDataChannel.ts

@@ -18,6 +18,7 @@ import { CHANNEL_NAMES, YJS_MSG } from "./types.ts";
  * prevent echo loops with the server-based provider.
  */
 export class YjsDataChannel {
+	public isSynced = false;
 	private docUpdateHandler: ((update: Uint8Array, origin: any) => void) | null = null;
 	private awarenessUpdateHandler: ((changes: { added: number[]; updated: number[]; removed: number[] }, origin: any) => void) | null = null;
 	private channelOpenHandler: ((data: { name: string; channel: RTCDataChannel }) => void) | null = null;