Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

fix(meetings): serialize diarization completions to preserve speaker labels

Chadpiha1dfc36cd96a2
diff --git a/src/stores/meetingRecordingStore.ts b/src/stores/meetingRecordingStore.ts
index 7f5f42008..f1ea53b91 100644
--- a/src/stores/meetingRecordingStore.ts
+++ b/src/stores/meetingRecordingStore.ts
@@ -39,6 +39,7 @@ import {
} from "../utils/transcriptSpeakerState";
import { parseTranscriptSegments } from "../utils/parseTranscriptSegments";
import { resolveDiarizationTarget, selectBaseSegments } from "../utils/diarizationCompletion";
+import { createSerialQueue } from "../utils/serialQueue";
export interface TranscriptSegment {
id: string;
@@ -1384,72 +1385,84 @@ export function cancelPreparedTranscription(): void {
// session (#1495). Registered once at module load so results survive the
// notes view unmounting; NoteEditor only mirrors `completedDiarization`.
if (typeof window !== "undefined") {
- window.electronAPI?.onMeetingDiarizationComplete?.(async (data) => {
- const {
- diarizationSessionId,
- recordingNoteId,
- segments: liveSegments,
- } = useMeetingRecordingStore.getState();
- const { targetNoteId, isCurrentSession } = resolveDiarizationTarget({
- payloadNoteId: data?.noteId,
- payloadSessionId: data?.sessionId,
- currentSessionId: diarizationSessionId,
- recordingNoteId,
- });
- if (targetNoteId == null) return;
+ // Serialized so rapid re-record completions can't interleave around the
+ // getNote await and overwrite each other's speaker labels — the later
+ // result merges on top of the earlier one's persisted transcript.
+ const enqueueDiarizationCompletion = createSerialQueue();
+ window.electronAPI?.onMeetingDiarizationComplete?.((data) => {
+ enqueueDiarizationCompletion(async () => {
+ const {
+ diarizationSessionId,
+ recordingNoteId,
+ segments: liveSegments,
+ } = useMeetingRecordingStore.getState();
+ const { targetNoteId, isCurrentSession } = resolveDiarizationTarget({
+ payloadNoteId: data?.noteId,
+ payloadSessionId: data?.sessionId,
+ currentSessionId: diarizationSessionId,
+ recordingNoteId,
+ });
+ if (targetNoteId == null) return;
- const publish = (segments: TranscriptSegment[]) => {
- if (isCurrentSession) {
- useMeetingRecordingStore.setState({
- completedDiarization: { noteId: targetNoteId, segments },
- });
+ const publish = (segments: TranscriptSegment[]) => {
+ if (isCurrentSession) {
+ useMeetingRecordingStore.setState({
+ completedDiarization: { noteId: targetNoteId, segments },
+ });
+ }
+ };
+
+ if (!data?.segments?.length) {
+ // Diarization failed or was skipped — publish so a waiting editor can
+ // clear its spinner, but there is nothing to persist.
+ publish([]);
+ return;
}
- };
- if (!data?.segments?.length) {
- // Diarization failed or was skipped — publish so a waiting editor can
- // clear its spinner, but there is nothing to persist.
- publish([]);
- return;
- }
+ let persisted;
+ try {
+ persisted = await window.electronAPI?.getNote?.(targetNoteId);
+ } catch {
+ // Without the persisted note there is no safe base to merge into —
+ // publish the empty result so a waiting editor still clears its spinner.
+ publish([]);
+ return;
+ }
+ // Writing to a deleted note would resurrect its tombstone in the
+ // sidebar, cloud mirror, and vector index.
+ if (!persisted || persisted.deleted_at) return;
+
+ const existing = selectBaseSegments({
+ persistedSegments: persisted.transcript
+ ? parseTranscriptSegments(persisted.transcript)
+ : null,
+ liveSegments,
+ recordingNoteId,
+ targetNoteId,
+ });
+ const enriched = mergeTranscriptSegments(
+ existing,
+ data.segments.map((segment, index) => ({
+ ...segment,
+ id: segment.id || `diarized-${index}`,
+ }))
+ );
- let persisted;
- try {
- persisted = await window.electronAPI?.getNote?.(targetNoteId);
- } catch {
- // Without the persisted note there is no safe base to merge into —
- // publish the empty result so a waiting editor still clears its spinner.
- publish([]);
- return;
- }
- // Writing to a deleted note would resurrect its tombstone in the
- // sidebar, cloud mirror, and vector index.
- if (!persisted || persisted.deleted_at) return;
-
- const existing = selectBaseSegments({
- persistedSegments: persisted.transcript
- ? parseTranscriptSegments(persisted.transcript)
- : null,
- liveSegments,
- recordingNoteId,
- targetNoteId,
- });
- const enriched = mergeTranscriptSegments(
- existing,
- data.segments.map((segment, index) => ({
- ...segment,
- id: segment.id || `diarized-${index}`,
- }))
- );
+ window.electronAPI?.updateNote?.(targetNoteId, {
+ transcript: serializeTranscriptSegments(enriched),
+ });
+ if (data.speakerEmbeddings) {
+ window.electronAPI?.saveNoteSpeakerEmbeddings?.(targetNoteId, data.speakerEmbeddings);
+ }
- window.electronAPI?.updateNote?.(targetNoteId, {
- transcript: serializeTranscriptSegments(enriched),
+ publish(enriched);
+ }).catch((error) => {
+ logger.error(
+ "Diarization completion handling failed",
+ { error: (error as Error).message },
+ "meeting"
+ );
});
- if (data.speakerEmbeddings) {
- window.electronAPI?.saveNoteSpeakerEmbeddings?.(targetNoteId, data.speakerEmbeddings);
- }
-
- publish(enriched);
});
}
diff --git a/src/utils/serialQueue.ts b/src/utils/serialQueue.ts
new file mode 100644
index 000000000..e3192d03f
--- /dev/null
+++ b/src/utils/serialQueue.ts
@@ -0,0 +1,10 @@
+// Runs enqueued async tasks strictly one at a time, in enqueue order. A
+// rejected task rejects its own returned promise but never stalls the queue.
+export function createSerialQueue(): <Result>(task: () => Promise<Result>) => Promise<Result> {
+ let tail: Promise<unknown> = Promise.resolve();
+ return (task) => {
+ const run = tail.then(() => task());
+ tail = run.catch(() => undefined);
+ return run;
+ };
+}
diff --git a/test/utils/serialQueue.test.js b/test/utils/serialQueue.test.js
new file mode 100644
index 000000000..bade32a9c
--- /dev/null
+++ b/test/utils/serialQueue.test.js
@@ -0,0 +1,51 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { createSerialQueue } = require("../../src/utils/serialQueue.ts");
+
+test("runs tasks one at a time in enqueue order", async () => {
+ const run = createSerialQueue();
+ const events = [];
+ let releaseFirst;
+ const firstGate = new Promise((resolve) => {
+ releaseFirst = resolve;
+ });
+
+ run(async () => {
+ events.push("start1");
+ await firstGate;
+ events.push("end1");
+ });
+ const second = run(async () => {
+ events.push("start2");
+ });
+
+ await Promise.resolve();
+ assert.deepEqual(events, ["start1"], "second task must not start while the first is pending");
+
+ releaseFirst();
+ await second;
+ assert.deepEqual(events, ["start1", "end1", "start2"]);
+});
+
+test("resolves each task with its own result", async () => {
+ const run = createSerialQueue();
+ assert.equal(await run(async () => "a"), "a");
+ assert.equal(await run(async () => "b"), "b");
+});
+
+test("a rejected task does not stall the queue", async () => {
+ const run = createSerialQueue();
+ const events = [];
+
+ const failing = run(async () => {
+ throw new Error("boom");
+ });
+ const following = run(async () => {
+ events.push("ran");
+ });
+
+ await assert.rejects(failing, /boom/);
+ await following;
+ assert.deepEqual(events, ["ran"]);
+});