reflet-sdk 0.7.10 → 0.7.12

package/dist/{use-sheet-tab-QLQ1oeso.js → use-sheet-tab-DTGgQ_1c.js}

@@ -1,5 +1,5 @@
-import { a as EDITORS, n as DEVTOOLS_REQUEST_HEADER, r as DEVTOOLS_ROUTE_BASE, t as DEVTOOLS_ENDPOINTS } from "./protocol-ClxYWmhu.js";
-import { $ as inspectReactElement, A as PencilIcon, B as DEFAULT_WIDGET_LABELS, C as CheckIcon, D as GripIcon, E as CodeIcon, G as buildElementSelection, H as clip, I as TrashIcon, J as getElementRect, K as buildSelector, N as Svg, P as TargetIcon, Q as getFiberFromNode, T as CloseIcon, U as collectPageContext, V as SDK_VERSION, Y as REDACT_ATTRIBUTE, Z as redactUrl, _ as isSubmitEnter, a as uploadBlob, at as capturedViewportSize, c as useFloatingPosition, d as SelectionOutline, et as resolveComponentStack, h as startsInWidget, it as capturedFromCanvas, k as MoreIcon, l as onViewportChange, m as listenToKeydown, o as ElementPicker, ot as releaseCapture, p as listenOnPageAndWidget, q as describeElement, r as deriveTitle, rt as captureViewport, s as isWidgetOwned, tt as shortenSourcePath, u as visibleViewport, v as matchesHotkey } from "./submit-D7XKlgee.js";
+import { a as EDITORS, n as DEVTOOLS_REQUEST_HEADER, r as DEVTOOLS_ROUTE_BASE, t as DEVTOOLS_ENDPOINTS } from "./protocol-P5T66Bs3.js";
+import { $ as inspectReactElement, A as PencilIcon, B as DEFAULT_WIDGET_LABELS, C as CheckIcon, D as GripIcon, E as CodeIcon, G as buildElementSelection, H as clip, I as TrashIcon, J as getElementRect, K as buildSelector, N as Svg, P as TargetIcon, Q as getFiberFromNode, T as CloseIcon, U as collectPageContext, V as SDK_VERSION, Y as REDACT_ATTRIBUTE, Z as redactUrl, _ as isSubmitEnter, a as uploadBlob, at as capturedViewportSize, c as useFloatingPosition, d as SelectionOutline, et as resolveComponentStack, h as startsInWidget, it as capturedFromCanvas, k as MoreIcon, l as onViewportChange, m as listenToKeydown, o as ElementPicker, ot as releaseCapture, p as listenOnPageAndWidget, q as describeElement, r as deriveTitle, rt as captureViewport, s as isWidgetOwned, tt as shortenSourcePath, u as visibleViewport, v as matchesHotkey } from "./submit-CqeMuBPt.js";
 import { t as REFLET_Z_INDEX } from "./z-index-CwokqVq_.js";
 import { z } from "zod";
 import * as G$1 from "react";
@@ -271,6 +271,7 @@ const sessionIdentitySchema = z.object({
 	limits: sessionLimitsSchema,
 	organizationId: z.string(),
 	organizationName: z.string(),
+	speakersConfigured: z.boolean().default(false),
 	transcriptionConfigured: z.boolean(),
 	user: z.object({
 		email: z.string().nullable(),
@@ -448,6 +449,20 @@ const contextOptionSchema = z.object({
 	item: segmentContextSchema,
 	selected: z.boolean()
 });
+const spokenRunSchema = z.object({
+	speaker: z.string().nullable(),
+	text: z.string()
+});
+z.object({
+	endMs: z.number(),
+	speaker: z.string(),
+	startMs: z.number()
+});
+const speakerTokenSchema = z.object({
+	expiresAt: z.number(),
+	token: z.string(),
+	url: z.string()
+});
 const sessionSegmentSchema = z.object({
 	audioExpiresAt: z.number().nullable(),
 	context: z.array(segmentContextSchema),
@@ -464,6 +479,7 @@ const sessionSegmentSchema = z.object({
 	language: z.string().nullable(),
 	revision: z.number(),
 	source: z.enum(["voice", "typed"]),
+	speech: z.array(spokenRunSchema).nullable().default(null),
 	startMs: z.number(),
 	text: z.string(),
 	textOrigin: z.enum(["transcription", "human"]),
@@ -662,6 +678,10 @@ const segmentResponse = z.object({ segment: sessionSegmentSchema });
 function createRecordingEndpoints({ post }) {
 	return {
 		addEvidence: async (body) => (await post("/api/v1/sessions/evidence", body, z.object({ evidence: sessionEvidenceSchema }))).evidence,
+		addSpeakerTurns: (body) => post("/api/v1/sessions/speakers", body, z.object({
+			accepted: z.number(),
+			dropped: z.number()
+		})),
 		addVoiceSegment: async (body) => (await post("/api/v1/sessions/segments", body, segmentResponse)).segment,
 		collection: async (body) => (await post("/api/v1/sessions/collection", body, summaryResponse)).session,
 		events: (body) => post("/api/v1/sessions/events", body, z.object({
@@ -669,6 +689,7 @@ function createRecordingEndpoints({ post }) {
 			dropped: z.number(),
 			limitReached: z.boolean()
 		})),
+		speakerToken: () => post("/api/v1/sessions/speakers/token", {}, speakerTokenSchema),
 		start: async (body) => (await post("/api/v1/sessions/start", body, summaryResponse)).session,
 		uploadUrl: async (body) => (await post("/api/v1/sessions/upload-url", body, z.object({ uploadUrl: z.string() }))).uploadUrl
 	};
@@ -1125,6 +1146,7 @@ function operationBytes(payload) {
 		case "voice": return payload.audio?.size ?? SMALL_OPERATION_BYTES;
 		case "evidence": return (payload.image?.blob?.size ?? 0) + JSON.stringify(payload.evidence).length + SMALL_OPERATION_BYTES;
 		case "events": return JSON.stringify(payload.events).length;
+		case "speakers": return JSON.stringify(payload.turns).length;
 		default: return SMALL_OPERATION_BYTES;
 	}
 }
@@ -1228,6 +1250,13 @@ async function sendSessionOperation(context, payload) {
 			kind: "limit",
 			limit: "events"
 		} : { kind: "done" };
+		case "speakers":
+			await api.addSpeakerTurns({
+				clientKey: payload.clientKey,
+				sessionId,
+				turns: payload.turns
+			});
+			return { kind: "done" };
 		case "voice":
 			await sendVoice(context, payload);
 			return { kind: "done" };
@@ -1328,7 +1357,7 @@ var SessionOutbox = class {
 	}
 	async enqueue(sessionKey, payload) {
 		const bytes = operationBytes(payload);
-		if (this.snapshot.pendingBytes + bytes > this.options.maxLocalBufferBytes) this.failStorage(BUFFER_FULL);
+		if (this.snapshot.pendingBytes + bytes > this.options.limits.maxLocalBufferBytes) this.failStorage(BUFFER_FULL);
 		try {
 			await this.options.store.addOperation({
 				accountKey: this.options.accountKey,
@@ -1401,6 +1430,7 @@ var SessionOutbox = class {
 			pendingOperations: remaining.length
 		});
 		await this.forgetFinishedDrafts(remaining);
+		await this.forgetOldVoices();
 		this.afterPass(pass);
 	}
 	async dropAbandonedUploads(drafts) {
@@ -1486,6 +1516,12 @@ var SessionOutbox = class {
 		await Promise.all(finished.map((draft) => store.deleteDraft(draft.sessionKey)));
 		if (finished.length > 0) this.options.onDraftsChanged();
 	}
+	async forgetOldVoices() {
+		const { accountKey, limits, store } = this.options;
+		const keptSince = Date.now() - limits.audioRetentionMs;
+		const expired = (await store.readDrafts(accountKey)).filter((draft) => draft.lastActiveAt < keptSince && Object.keys(draft.speakerReferences ?? {}).length > 0);
+		await Promise.all(expired.map((draft) => store.patchDraft(draft.sessionKey, { speakerReferences: {} })));
+	}
 };
 function createOutbox(options) {
 	return new SessionOutbox(options);
@@ -1502,6 +1538,10 @@ const IDLE_SYNC = {
 	pendingBytes: 0,
 	pendingOperations: 0
 };
+const UNBOUNDED_LIMITS = {
+	audioRetentionMs: Number.POSITIVE_INFINITY,
+	maxLocalBufferBytes: Number.POSITIVE_INFINITY
+};
 function visibleDraft(stored, isLive) {
 	if (stored.state === "cancelled") return [];
 	const leftOpen = stored.state === "recording" || stored.state === "paused";
@@ -1553,7 +1593,7 @@ var LocalSessionsRegistry = class {
 		if (!stored || this.live.has(sessionKey) || isClosed) return;
 		const { outbox } = this.ensureOutbox({
 			...options,
-			maxLocalBufferBytes: null
+			limits: null
 		});
 		const atMs = Math.max(0, stored.lastActiveAt - stored.startedAt);
 		await outbox.enqueue(sessionKey, {
@@ -1615,11 +1655,11 @@ var LocalSessionsRegistry = class {
 		const existing = this.accounts.get(accountKey);
 		if (existing && !existing.stopped && existing.api === api && existing.outbox.getSnapshot().blockedBy !== "auth") return existing;
 		existing?.outbox.stop();
-		const maxLocalBufferBytes = options.maxLocalBufferBytes ?? existing?.maxLocalBufferBytes ?? Number.POSITIVE_INFINITY;
+		const limits = options.limits ?? existing?.limits ?? UNBOUNDED_LIMITS;
 		const outbox = createOutbox({
 			accountKey,
 			api,
-			maxLocalBufferBytes,
+			limits,
 			onDraftsChanged: () => this.draftsChanged(accountKey),
 			store: this.store
 		});
@@ -1629,7 +1669,7 @@ var LocalSessionsRegistry = class {
 		});
 		const connected = {
 			api,
-			maxLocalBufferBytes,
+			limits,
 			outbox,
 			stopped: false
 		};
@@ -1826,7 +1866,7 @@ async function openMicrophone(options) {
 //#endregion
 //#region src/sessions/capture/audio/speech-chunker.ts
 const SPEECH_SAMPLE_RATE = 16e3;
-const SAMPLES_PER_MS = SPEECH_SAMPLE_RATE / 1e3;
+const SAMPLES_PER_MS$3 = SPEECH_SAMPLE_RATE / 1e3;
 const WINDOW_MS = 30;
 const WINDOW_SAMPLES = 480;
 const POST_ROLL_WINDOWS = 300 / WINDOW_MS;
@@ -1897,9 +1937,9 @@ var UtteranceChunker = class {
 		this.preRoll = [];
 		if (open.speechWindows * WINDOW_MS < MIN_SPEECH_MS) return;
 		const samples = concatenate(open.windows.slice(0, keptWindows));
-		const startMs = this.options.startMs + Math.round(open.startSample / SAMPLES_PER_MS);
+		const startMs = this.options.startMs + Math.round(open.startSample / SAMPLES_PER_MS$3);
 		this.options.onChunk({
-			endMs: startMs + Math.round(samples.length / SAMPLES_PER_MS),
+			endMs: startMs + Math.round(samples.length / SAMPLES_PER_MS$3),
 			samples,
 			startMs
 		});
@@ -1947,6 +1987,18 @@ const MAX_NEGATIVE_SAMPLE = 32768;
 function writeText(view, offset, text) {
 	for (let index = 0; index < text.length; index += 1) view.setUint8(offset + index, text.charCodeAt(index));
 }
+function writePcm16(view, offset, samples) {
+	samples.forEach((sample, index) => {
+		const clamped = Math.max(-1, Math.min(1, sample));
+		const scale = clamped < 0 ? MAX_NEGATIVE_SAMPLE : MAX_POSITIVE_SAMPLE;
+		view.setInt16(offset + index * BYTES_PER_SAMPLE, Math.round(clamped * scale), true);
+	});
+}
+function encodePcm16(samples) {
+	const buffer = /* @__PURE__ */ new ArrayBuffer(samples.length * BYTES_PER_SAMPLE);
+	writePcm16(new DataView(buffer), 0, samples);
+	return buffer;
+}
 /** 16-bit mono PCM WAV, the format the transcription endpoint expects. */
 function encodeWav(samples, sampleRate) {
 	const dataBytes = samples.length * BYTES_PER_SAMPLE;
@@ -1964,11 +2016,7 @@ function encodeWav(samples, sampleRate) {
 	view.setUint16(34, 16, true);
 	writeText(view, 36, "data");
 	view.setUint32(40, dataBytes, true);
-	samples.forEach((sample, index) => {
-		const clamped = Math.max(-1, Math.min(1, sample));
-		const scale = clamped < 0 ? MAX_NEGATIVE_SAMPLE : MAX_POSITIVE_SAMPLE;
-		view.setInt16(WAV_HEADER_BYTES + index * BYTES_PER_SAMPLE, Math.round(clamped * scale), true);
-	});
+	writePcm16(view, WAV_HEADER_BYTES, samples);
 	return buffer;
 }
 function maxWavDurationMs(maxBytes) {
@@ -2276,6 +2324,7 @@ async function openVoiceCapture() {
 				const samples = downsample(frame);
 				options.onLevel(meterLevel(samples));
 				speech.push(samples);
+				options.onSamples?.(samples);
 			};
 		},
 		stop: () => {
@@ -2309,7 +2358,8 @@ function startCollectionRun$1(options) {
 		maxSegmentMs: options.maxSegmentMs,
 		onChunk: options.onChunk,
 		onLevel: options.onLevel,
-		startMs: options.atMs()
+		onSamples: options.onSamples,
+		startMs: options.startMs
 	});
 	let interactions = options.collectEvents ? startInteractionRecorder(options) : null;
 	const navigation = startNavigationWatch(options);
@@ -2506,6 +2556,542 @@ function createEvidenceScheduler(options) {
 	};
 }
 //#endregion
+//#region src/sessions/capture/speakers/stream/base64.ts
+const BYTES_PER_CONVERSION = 32768;
+function bytesToBase64(buffer) {
+	const bytes = new Uint8Array(buffer);
+	let binary = "";
+	for (let offset = 0; offset < bytes.length; offset += BYTES_PER_CONVERSION) binary += String.fromCharCode(...bytes.subarray(offset, offset + BYTES_PER_CONVERSION));
+	return btoa(binary);
+}
+//#endregion
+//#region src/sessions/capture/speakers/reference-clips.ts
+const SAMPLES_PER_MS$2 = SPEECH_SAMPLE_RATE / 1e3;
+const MIN_PIECE_MS = 1e3;
+const MIN_REFERENCE_SAMPLES = 3e3 * SAMPLES_PER_MS$2;
+const MAX_REFERENCE_SAMPLES = 6e3 * SAMPLES_PER_MS$2;
+const PIECE_END_MARGIN_MS = 250;
+const MAX_REFERENCES = 8;
+function referencePiece(chunk, turn) {
+	const fromMs = Math.max(turn.startMs, chunk.startMs);
+	const toMs = Math.min(turn.endMs - PIECE_END_MARGIN_MS, chunk.endMs);
+	if (toMs - fromMs < MIN_PIECE_MS) return null;
+	return chunk.samples.slice(Math.round((fromMs - chunk.startMs) * SAMPLES_PER_MS$2), Math.round((toMs - chunk.startMs) * SAMPLES_PER_MS$2));
+}
+function joined(voice) {
+	const samples = new Float32Array(voice.samples);
+	let offset = 0;
+	for (const piece of voice.pieces) {
+		samples.set(piece, offset);
+		offset += piece.length;
+	}
+	return samples;
+}
+function becameUsable(before, after) {
+	return before < MIN_REFERENCE_SAMPLES && after >= MIN_REFERENCE_SAMPLES || before < MAX_REFERENCE_SAMPLES && after >= MAX_REFERENCE_SAMPLES;
+}
+var ReferenceClips = class {
+	saved;
+	voices = /* @__PURE__ */ new Map();
+	constructor(saved) {
+		this.saved = saved;
+	}
+	keepFrom(chunk, turns) {
+		let changed = false;
+		for (const turn of turns) {
+			const voice = this.voices.get(turn.speaker) ?? {
+				pieces: [],
+				samples: 0
+			};
+			const room = MAX_REFERENCE_SAMPLES - voice.samples;
+			const isSaved = turn.speaker in this.saved;
+			const piece = room > 0 && !isSaved ? referencePiece(chunk, turn) : null;
+			if (piece) {
+				const kept = piece.subarray(0, room);
+				const before = voice.samples;
+				voice.pieces.push(kept);
+				voice.samples += kept.length;
+				this.voices.set(turn.speaker, voice);
+				changed ||= becameUsable(before, voice.samples);
+			}
+		}
+		return changed;
+	}
+	references() {
+		const references = { ...this.saved };
+		for (const [speaker, voice] of this.voices) if (voice.samples >= MIN_REFERENCE_SAMPLES) references[speaker] = bytesToBase64(encodeWav(joined(voice), SPEECH_SAMPLE_RATE));
+		return Object.fromEntries(Object.entries(references).slice(0, MAX_REFERENCES));
+	}
+};
+var SpeakerLabels = class {
+	handedOut;
+	onHandOut;
+	constructor(options) {
+		this.handedOut = options.handedOut;
+		this.onHandOut = options.onHandOut;
+	}
+	handOut() {
+		if (this.handedOut >= 10) return null;
+		this.handedOut += 1;
+		this.onHandOut(this.handedOut);
+		return `S${this.handedOut}`;
+	}
+};
+function createSpeakerIdMap(labels, referenceNames) {
+	const known = new Map(referenceNames.map((name) => [name, name]));
+	return (speakerId) => {
+		const label = known.get(speakerId);
+		if (label !== void 0) return label;
+		const handedOut = labels.handOut();
+		known.set(speakerId, handedOut);
+		return handedOut;
+	};
+}
+const EVENT_ARRIVAL_LAG_MS = 250;
+const SAMPLES_PER_MS$1 = SPEECH_SAMPLE_RATE / 1e3;
+function speakerEventMs(stream) {
+	const sentMs = stream.samplesSent / SAMPLES_PER_MS$1;
+	const streamStartMs = stream.streamStartSample / SAMPLES_PER_MS$1;
+	const spokenMs = sentMs - 480 - EVENT_ARRIVAL_LAG_MS;
+	return Math.round(stream.runStartMs + Math.max(streamStartMs, spokenMs));
+}
+var SpeakerTurns = class {
+	closed = [];
+	open = null;
+	undrained = [];
+	add(speaker, atMs) {
+		const { open } = this;
+		if (open !== null && open.speaker === speaker) {
+			open.undrainedFromMs ??= open.endMs;
+			open.endMs = atMs;
+			return;
+		}
+		this.closeOpenTurn();
+		this.open = speaker === null ? null : {
+			endMs: atMs,
+			speaker,
+			startMs: atMs,
+			undrainedFromMs: atMs
+		};
+	}
+	drain() {
+		const drained = this.undrained;
+		this.undrained = [];
+		const { open } = this;
+		if (open && open.undrainedFromMs !== null) {
+			drained.push(undrainedPart(open, open.undrainedFromMs));
+			open.undrainedFromMs = null;
+		}
+		return drained;
+	}
+	takeTurnsOverlapping(range) {
+		const { open } = this;
+		const candidates = open ? [...this.closed, wholeTurn(open)] : this.closed;
+		this.closed = this.closed.filter((turn) => turn.endMs > range.endMs);
+		return candidates.filter((turn) => turn.startMs < range.endMs && turn.endMs > range.startMs);
+	}
+	closeOpenTurn() {
+		const { open } = this;
+		if (open === null) return;
+		if (open.undrainedFromMs !== null) this.undrained.push(undrainedPart(open, open.undrainedFromMs));
+		this.closed.push(wholeTurn(open));
+		this.open = null;
+	}
+};
+function undrainedPart(turn, fromMs) {
+	return {
+		endMs: turn.endMs,
+		speaker: turn.speaker,
+		startMs: fromMs
+	};
+}
+function wholeTurn(turn) {
+	return {
+		endMs: turn.endMs,
+		speaker: turn.speaker,
+		startMs: turn.startMs
+	};
+}
+//#endregion
+//#region src/sessions/capture/speakers/stream/realtime-connection.ts
+const serverMessageSchema = z.discriminatedUnion("type", [
+	z.object({ type: z.literal("session.created") }),
+	z.object({ type: z.literal("session.updated") }),
+	z.object({
+		speaker_id: z.string().nullish(),
+		type: z.literal("transcription.segment")
+	}),
+	z.object({ type: z.literal("transcription.done") }),
+	z.object({
+		error: z.object({ message: z.unknown() }),
+		type: z.literal("error")
+	})
+]);
+const HANDLED_MESSAGE_TYPES = new Set(serverMessageSchema.options.map((option) => option.shape.type.value));
+const envelopeSchema = z.object({ type: z.string() });
+function readServerMessage(data) {
+	if (typeof data !== "string") throw new Error("Mistral sent a binary message.");
+	const message = JSON.parse(data);
+	const { type } = envelopeSchema.parse(message);
+	return HANDLED_MESSAGE_TYPES.has(type) ? serverMessageSchema.parse(message) : null;
+}
+function sessionUpdate(references) {
+	const hasReferences = Object.keys(references).length > 0;
+	return {
+		session: {
+			audio_format: {
+				encoding: "pcm_s16le",
+				sample_rate: SPEECH_SAMPLE_RATE
+			},
+			diarize: true,
+			...hasReferences ? { speaker_references: references } : {},
+			target_streaming_delay_ms: 480
+		},
+		type: "session.update"
+	};
+}
+function openRealtimeConnection(options) {
+	const socket = new WebSocket(options.token.url, ["realtime", options.token.token]);
+	let phase = "connecting";
+	let markClosed = () => void 0;
+	const closed = new Promise((resolve) => {
+		markClosed = resolve;
+	});
+	const shutDown = () => {
+		phase = "closed";
+		socket.close();
+		markClosed();
+	};
+	const fail = (failure) => {
+		if (phase !== "closed") {
+			shutDown();
+			options.onFailure(failure);
+		}
+	};
+	const send = (message) => socket.send(JSON.stringify(message));
+	const handle = (message) => {
+		switch (message.type) {
+			case "session.created":
+				phase = "configuring";
+				send(sessionUpdate(options.references));
+				return;
+			case "session.updated":
+				phase = "streaming";
+				options.onReady();
+				return;
+			case "transcription.segment":
+				if (message.speaker_id) options.onSpeaker(message.speaker_id);
+				return;
+			case "transcription.done":
+				if (phase === "ending") {
+					shutDown();
+					return;
+				}
+				fail({
+					kind: "closed",
+					message: "Mistral ended the speaker stream."
+				});
+				return;
+			default: {
+				const reason = message.error.message;
+				fail({
+					kind: "error",
+					message: typeof reason === "string" ? reason : JSON.stringify(reason)
+				});
+			}
+		}
+	};
+	socket.addEventListener("message", (event) => {
+		let message;
+		try {
+			message = readServerMessage(event.data);
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			fail({
+				kind: "error",
+				message: `Unreadable speaker event: ${reason}`
+			});
+			return;
+		}
+		if (message && phase !== "closed") handle(message);
+	});
+	const lose = (message) => {
+		if (phase === "ending") {
+			shutDown();
+			return;
+		}
+		fail({
+			kind: "closed",
+			message
+		});
+	};
+	socket.addEventListener("error", () => lose("The speaker stream failed, or the page's security policy blocked it."));
+	socket.addEventListener("close", (event) => lose(`The speaker stream closed (${event.code}).`));
+	return {
+		close: shutDown,
+		end: () => {
+			if (phase === "streaming") {
+				phase = "ending";
+				send({ type: "input_audio.end" });
+			} else if (phase !== "ending") shutDown();
+			return closed;
+		},
+		sendAudio: (samples) => {
+			if (phase !== "streaming") throw new Error("The speaker stream is not ready for audio.");
+			send({
+				audio: bytesToBase64(encodePcm16(samples)),
+				type: "input_audio.append"
+			});
+		}
+	};
+}
+//#endregion
+//#region src/sessions/capture/speakers/stream/sample-queue.ts
+var SampleQueue = class {
+	maxSamples;
+	parts = [];
+	queuedSamples = 0;
+	constructor(maxSamples) {
+		this.maxSamples = maxSamples;
+	}
+	get size() {
+		return this.queuedSamples;
+	}
+	clear() {
+		this.parts = [];
+		this.queuedSamples = 0;
+	}
+	push(samples) {
+		if (this.queuedSamples + samples.length > this.maxSamples) return false;
+		this.parts.push(samples);
+		this.queuedSamples += samples.length;
+		return true;
+	}
+	take(maxSamples) {
+		const taken = new Float32Array(Math.min(maxSamples, this.queuedSamples));
+		let filled = 0;
+		while (filled < taken.length) {
+			const part = this.parts[0];
+			if (!part) break;
+			const used = Math.min(part.length, taken.length - filled);
+			taken.set(part.subarray(0, used), filled);
+			filled += used;
+			if (used === part.length) this.parts.shift();
+			else this.parts[0] = part.subarray(used);
+		}
+		this.queuedSamples -= taken.length;
+		return taken;
+	}
+};
+//#endregion
+//#region src/sessions/capture/speakers/speaker-tracker.ts
+const SAMPLES_PER_MS = SPEECH_SAMPLE_RATE / 1e3;
+const PACE_INTERVAL_MS = 100;
+const MAX_SAMPLES_PER_PACE = 2e3;
+const MAX_QUEUED_SAMPLES = 3e4 * SAMPLES_PER_MS;
+const FINISH_TIMEOUT_MS = 3e3;
+const RECONNECT_DELAYS_MS = [
+	1e3,
+	2e3,
+	4e3
+];
+var SpeakerTracker = class {
+	connection = null;
+	failedAttempts = 0;
+	finished;
+	finishTimer;
+	isStreaming = false;
+	markFinished = () => void 0;
+	options;
+	pacer;
+	queue = new SampleQueue(MAX_QUEUED_SAMPLES);
+	reconnectTimer;
+	samplesSent = 0;
+	state = "running";
+	streamStartSample = 0;
+	turns = new SpeakerTurns();
+	constructor(options) {
+		this.options = options;
+		this.finished = new Promise((resolve) => {
+			this.markFinished = resolve;
+		});
+		this.pacer = window.setInterval(this.pace, PACE_INTERVAL_MS);
+		this.connect();
+	}
+	close() {
+		this.stop();
+	}
+	drain() {
+		return this.turns.drain();
+	}
+	finish() {
+		if (this.state === "running") {
+			this.state = "finishing";
+			this.finishTimer = window.setTimeout(this.stop, FINISH_TIMEOUT_MS);
+			if (!this.isStreaming) this.stop();
+		}
+		return this.finished;
+	}
+	heardUntilMs() {
+		return speakerEventMs({
+			runStartMs: this.options.startMs,
+			samplesSent: this.samplesSent,
+			streamStartSample: this.streamStartSample
+		});
+	}
+	push(samples) {
+		if (this.state === "running" && !this.queue.push(samples)) this.giveUp();
+	}
+	takeTurnsOverlapping(range) {
+		return this.turns.takeTurnsOverlapping(range);
+	}
+	connect = () => {
+		this.options.requestToken().then((token) => token ? this.open(token) : this.giveUp()).catch(() => this.retry());
+	};
+	giveUp() {
+		if (this.state !== "stopped") {
+			this.stop();
+			this.options.onUnavailable();
+		}
+	}
+	lose(failure) {
+		this.connection = null;
+		this.isStreaming = false;
+		if (this.state !== "running") this.stop();
+		else if (failure.kind === "error") this.giveUp();
+		else this.retry();
+	}
+	open = (token) => {
+		if (this.state !== "running") return;
+		const references = this.options.references();
+		const labelOf = createSpeakerIdMap(this.options.labels, Object.keys(references));
+		this.connection = openRealtimeConnection({
+			onFailure: (failure) => this.lose(failure),
+			onReady: () => {
+				this.failedAttempts = 0;
+				this.streamStartSample = this.samplesSent;
+				this.isStreaming = true;
+			},
+			onSpeaker: (speakerId) => this.turns.add(labelOf(speakerId), this.heardUntilMs()),
+			references,
+			token
+		});
+	};
+	pace = () => {
+		const { connection } = this;
+		if (!(connection && this.isStreaming)) return;
+		const samples = this.queue.take(MAX_SAMPLES_PER_PACE);
+		if (samples.length > 0) {
+			connection.sendAudio(samples);
+			this.samplesSent += samples.length;
+		}
+		if (this.state === "finishing" && this.queue.size === 0) {
+			this.isStreaming = false;
+			connection.end().then(this.stop, this.stop);
+		}
+	};
+	retry() {
+		if (this.state !== "running") return;
+		const delayMs = RECONNECT_DELAYS_MS[this.failedAttempts];
+		if (delayMs === void 0) {
+			this.giveUp();
+			return;
+		}
+		this.failedAttempts += 1;
+		this.reconnectTimer = window.setTimeout(this.connect, delayMs);
+	}
+	stop = () => {
+		if (this.state === "stopped") return;
+		this.state = "stopped";
+		window.clearInterval(this.pacer);
+		window.clearTimeout(this.reconnectTimer);
+		window.clearTimeout(this.finishTimer);
+		this.isStreaming = false;
+		this.connection?.close();
+		this.connection = null;
+		this.queue.clear();
+		this.markFinished();
+	};
+};
+//#endregion
+//#region src/sessions/capture/speakers/speaker-detection.ts
+const REFERENCE_SETTLE_MS = 1e3;
+const MAX_UNSETTLED_CHUNKS = 3;
+var SpeakerDetection = class {
+	clips;
+	labels;
+	options;
+	run = null;
+	unsettled = [];
+	previousRunSettled = Promise.resolve();
+	constructor(options) {
+		this.options = options;
+		this.clips = new ReferenceClips(options.references);
+		this.labels = new SpeakerLabels({
+			handedOut: options.labelCount,
+			onHandOut: options.onLabelCount
+		});
+	}
+	closeRun() {
+		const { run } = this;
+		this.run = null;
+		if (!run) return [];
+		run.close();
+		this.keepVoices(run, this.unsettled.splice(0));
+		return run.drain();
+	}
+	drainTurns() {
+		return this.run?.drain() ?? [];
+	}
+	async finishRun() {
+		const { run } = this;
+		this.run = null;
+		if (!run) return [];
+		const unsettled = this.unsettled.splice(0);
+		const settled = run.finish().then(() => this.keepVoices(run, unsettled));
+		this.previousRunSettled = settled;
+		await settled;
+		return run.drain();
+	}
+	keepReferences(chunk) {
+		if (this.run) {
+			this.unsettled.push(chunk);
+			this.settleReferences();
+		}
+	}
+	settleReferences() {
+		const { run } = this;
+		if (!run) return;
+		const heardMs = run.heardUntilMs();
+		const overflow = this.unsettled.length - MAX_UNSETTLED_CHUNKS;
+		const firstUnsettled = this.unsettled.findIndex((chunk, index) => index >= overflow && chunk.endMs + REFERENCE_SETTLE_MS > heardMs);
+		const settledCount = firstUnsettled === -1 ? this.unsettled.length : firstUnsettled;
+		this.keepVoices(run, this.unsettled.splice(0, settledCount));
+	}
+	pushSamples = (samples) => {
+		this.run?.push(samples);
+	};
+	startRun(startMs) {
+		const { previousRunSettled } = this;
+		this.run = new SpeakerTracker({
+			labels: this.labels,
+			onUnavailable: () => this.options.onState("unavailable"),
+			references: () => this.clips.references(),
+			requestToken: async () => {
+				await previousRunSettled;
+				return await this.options.requestToken();
+			},
+			startMs
+		});
+		this.options.onState("detecting");
+	}
+	keepVoices(run, chunks) {
+		let changed = false;
+		for (const chunk of chunks) changed = this.clips.keepFrom(chunk, run.takeTurnsOverlapping(chunk)) || changed;
+		if (changed) this.options.onReferences(this.clips.references());
+	}
+};
+//#endregion
 //#region src/sessions/recorder/live/event-batcher.ts
 const FLUSH_INTERVAL_MS = 5e3;
 const NOTE_WAIT_MS = 6e4;
@@ -2565,6 +3151,7 @@ function createEventBatcher(options) {
 }
 //#endregion
 //#region src/sessions/recorder/live/session-payloads.ts
+const MAX_TURNS_PER_UPLOAD = 200;
 function newSessionDraft(options) {
 	const startedAt = Date.now();
 	return {
@@ -2598,7 +3185,8 @@ function startPayload(draft) {
 			startedAt: draft.startedAt,
 			surface: draft.surface,
 			...draft.title ? { title: draft.title } : {},
-			...draft.continues ? { continues: draft.continues } : {}
+			...draft.continues ? { continues: draft.continues } : {},
+			...draft.detectSpeakers ? { detectSpeakers: true } : {}
 		},
 		kind: "start"
 	};
@@ -2634,6 +3222,15 @@ function voicePayload(chunk) {
 		storageId: null
 	};
 }
+function speakerPayloads(turns) {
+	const payloads = [];
+	for (let from = 0; from < turns.length; from += MAX_TURNS_PER_UPLOAD) payloads.push({
+		clientKey: crypto.randomUUID(),
+		kind: "speakers",
+		turns: turns.slice(from, from + MAX_TURNS_PER_UPLOAD)
+	});
+	return payloads;
+}
 //#endregion
 //#region src/sessions/recorder/live/session-quota.ts
 var SessionQuota = class {
@@ -2667,6 +3264,7 @@ var SessionQuota = class {
 const LARGEST_EVENT_BATCH = 100;
 const TICK_MS = 1e3;
 const DRAFT_SAVE_INTERVAL_MS = 5e3;
+const SPEAKER_SETTLE_MS = 2500;
 var LiveSession = class {
 	clock;
 	sessionKey;
@@ -2677,6 +3275,8 @@ var LiveSession = class {
 	options;
 	quota;
 	run = null;
+	speakers;
+	speakersSettling;
 	stopListening = null;
 	tick;
 	constructor(options) {
@@ -2695,6 +3295,7 @@ var LiveSession = class {
 			limits: options.limits,
 			onEvidence: (captured) => this.persist(evidencePayload(captured))
 		});
+		this.speakers = options.speakers && this.detectSpeakers(options.speakers);
 	}
 	annotate(key, note) {
 		this.events.annotate(key, note);
@@ -2708,9 +3309,11 @@ var LiveSession = class {
 		if (Date.now() - this.lastSavedAt >= DRAFT_SAVE_INTERVAL_MS) this.saveDraft();
 	}
 	async end() {
+		this.stopRun();
+		const atMs = this.clock.atMs();
+		await this.finishSpeakers();
 		this.stop();
 		const { outbox, store } = this.options.account;
-		const atMs = this.clock.atMs();
 		await outbox.enqueue(this.sessionKey, {
 			action: "end",
 			atMs,
@@ -2739,7 +3342,9 @@ var LiveSession = class {
 		};
 	}
 	pause(reason) {
-		this.stopCollecting();
+		this.stopRun();
+		if (reason === "interrupted") this.persistTurns(this.speakers?.closeRun() ?? []);
+		else this.finishSpeakers().catch(this.hooks.onStorageFailure);
 		if (!this.clock.isPaused()) {
 			const atMs = this.clock.pause(reason);
 			this.persist({
@@ -2782,6 +3387,9 @@ var LiveSession = class {
 		const { limits } = this.options;
 		const hasVoiceRoom = this.hasVoiceRoom();
 		if (!hasVoiceRoom) voice.stop();
+		const startMs = this.clock.atMs();
+		const speakers = hasVoiceRoom ? this.speakers : null;
+		speakers?.startRun(startMs);
 		this.run = startCollectionRun$1({
 			atMs: this.clock.atMs,
 			collectEvents: !this.quota.stopped.has("events"),
@@ -2802,6 +3410,8 @@ var LiveSession = class {
 				});
 				this.evidence.navigated();
 			},
+			onSamples: speakers?.pushSamples,
+			startMs,
 			voice: hasVoiceRoom ? voice : null
 		});
 		this.listen();
@@ -2812,17 +3422,15 @@ var LiveSession = class {
 		this.events.stop();
 	}
 	stopCollecting() {
-		this.run?.stop();
-		this.run = null;
-		this.stopListening?.abort();
-		this.stopListening = null;
-		this.evidence.cancelPending();
-		window.clearInterval(this.tick);
-		this.events.flushAll();
+		this.stopRun();
+		this.speakers?.closeRun();
 	}
 	stopKind(limit) {
 		this.quota.stopped.add(limit);
-		if (limit === "segments") this.run?.stopVoice();
+		if (limit === "segments") {
+			this.run?.stopVoice();
+			this.finishSpeakers().catch(this.hooks.onStorageFailure);
+		}
 		if (limit === "events") this.run?.stopEvents();
 	}
 	draftPatch(state) {
@@ -2833,6 +3441,21 @@ var LiveSession = class {
 			lastActiveAt: this.lastSavedAt
 		};
 	}
+	detectSpeakers(setup) {
+		const { store } = this.options.account;
+		return new SpeakerDetection({
+			labelCount: setup.labelCount,
+			onLabelCount: (speakerLabelCount) => store.patchDraft(this.sessionKey, { speakerLabelCount }).catch(this.hooks.onStorageFailure),
+			onReferences: (speakerReferences) => store.patchDraft(this.sessionKey, { speakerReferences }).catch(this.hooks.onStorageFailure),
+			onState: this.hooks.onSpeakers,
+			references: setup.references,
+			requestToken: setup.requestToken
+		});
+	}
+	async finishSpeakers() {
+		const turns = await this.speakers?.finishRun() ?? [];
+		for (const payload of speakerPayloads(turns)) await this.options.account.outbox.enqueue(this.sessionKey, payload);
+	}
 	listen() {
 		this.stopListening = new AbortController();
 		const listen = { signal: this.stopListening.signal };
@@ -2844,9 +3467,23 @@ var LiveSession = class {
 	}
 	recordChunk = (chunk) => {
 		if (!this.quota.acceptSegment()) return;
+		this.persistTurns(this.speakers?.drainTurns() ?? []);
 		this.persist(voicePayload(chunk));
+		this.speakers?.keepReferences(chunk);
+		this.settleSpeakers();
 		if (this.quota.segmentsFull()) this.hooks.reachLimit("segments");
 	};
+	persistTurns(turns) {
+		for (const payload of speakerPayloads(turns)) this.persist(payload);
+	}
+	settleSpeakers() {
+		if (!this.speakers) return;
+		window.clearTimeout(this.speakersSettling);
+		this.speakersSettling = window.setTimeout(() => {
+			this.persistTurns(this.speakers?.drainTurns() ?? []);
+			this.speakers?.settleReferences();
+		}, SPEAKER_SETTLE_MS);
+	}
 	saveDraft(state) {
 		this.options.account.store.patchDraft(this.sessionKey, this.draftPatch(state)).catch(this.hooks.onStorageFailure);
 	}
@@ -2862,8 +3499,32 @@ var LiveSession = class {
 		}
 		if (this.quota.eventsFull()) this.hooks.reachLimit("events");
 	};
+	stopRun() {
+		this.run?.stop();
+		this.run = null;
+		this.stopListening?.abort();
+		this.stopListening = null;
+		this.evidence.cancelPending();
+		window.clearInterval(this.tick);
+		window.clearTimeout(this.speakersSettling);
+		this.events.flushAll();
+	}
 };
 //#endregion
+//#region src/sessions/recorder/live/speaker-token.ts
+const RETRYABLE_TOKEN_STATUSES = /* @__PURE__ */ new Set([
+	408,
+	500,
+	502,
+	504
+]);
+function requestSpeakerToken(api) {
+	return () => api.speakerToken().catch((error) => {
+		if (error instanceof SessionApiError && !RETRYABLE_TOKEN_STATUSES.has(error.status)) return null;
+		throw error;
+	});
+}
+//#endregion
 //#region src/sessions/recorder/recording-controller.ts
 const MAX_NOTE_CHARS = 1e3;
 const MAX_TITLE_CHARS = 120;
@@ -2879,6 +3540,7 @@ const IDLE = {
 	phase: "idle",
 	sessionId: null,
 	sessionKey: null,
+	speakers: "off",
 	startedAt: null
 };
 function cleanText(text, maxChars) {
@@ -2900,7 +3562,7 @@ var RecordingController = class {
 		this.account = localSessions.connect({
 			accountKey: options.account.key,
 			api: options.api,
-			maxLocalBufferBytes: options.limits.maxLocalBufferBytes
+			limits: options.limits
 		});
 		this.stopIssues = this.account.outbox.subscribeIssues(this.handleIssue);
 		this.stopSessionIds = localSessions.subscribe(this.syncSessionId);
@@ -2998,6 +3660,7 @@ var RecordingController = class {
 		const draft = newSessionDraft({
 			accountKey: this.options.account.key,
 			continues: options.continues,
+			detectSpeakers: options.detectSpeakers,
 			surface: this.options.surface,
 			title: cleanText(options.title, MAX_TITLE_CHARS) ?? ""
 		});
@@ -3044,13 +3707,21 @@ var RecordingController = class {
 				onHidden: () => this.pauseFor("hidden"),
 				onLevel: (level) => this.emitLevel(level),
 				onPageHide: () => this.interrupt(),
+				onSpeakers: (speakers) => {
+					if (this.live === live) this.publish({ speakers });
+				},
 				onStorageFailure: (error) => this.failStorage(live, error),
 				onTick: () => this.onTick(live),
 				reachLimit: (limit) => this.reachLimit(live, limit)
 			},
 			includeSource: this.options.surface === "devtools",
 			limits: this.options.limits,
-			sessionKey
+			sessionKey,
+			speakers: draft.detectSpeakers ? {
+				labelCount: draft.speakerLabelCount ?? 0,
+				references: draft.speakerReferences ?? {},
+				requestToken: requestSpeakerToken(this.options.api)
+			} : null
 		});
 		this.live = live;
 		this.releaseClaim = this.account.claim({
@@ -3336,6 +4007,14 @@ function formatClock(ms) {
 function countLabel(count, noun) {
 	return `${count} ${noun}${count === 1 ? "" : "s"}`;
 }
+const SPEAKER_LABEL_PREFIX = /^S/;
+function speakerLabel(speaker) {
+	return speaker.replace(SPEAKER_LABEL_PREFIX, "Speaker ");
+}
+function attributedText(said) {
+	if (!said.speech) return said.text;
+	return said.speech.map((run) => run.speaker ? `${speakerLabel(run.speaker)}: ${run.text}` : run.text).join(" ");
+}
 function spokenDuration(ms) {
 	const totalSeconds = Math.max(0, Math.floor(ms / SECOND_MS));
 	const minutes = Math.floor(totalSeconds / 60);
@@ -3768,7 +4447,8 @@ function statusText(snapshot, sync, maxDurationMs) {
 	if (snapshot.limitsReached.length > 0) return `Limit reached for ${snapshot.limitsReached.join(", ")}`;
 	const problem = syncProblem(sync);
 	if (problem) return problem;
-	return snapshot.nearLimit ? `${minutesLeft(maxDurationMs - snapshot.activeMs)} min left` : "";
+	if (snapshot.nearLimit) return `${minutesLeft(maxDurationMs - snapshot.activeMs)} min left`;
+	return snapshot.speakers === "unavailable" ? "Speakers aren't being detected" : "";
 }
 function markMoment(recorder, focus, setOpenMark) {
 	const key = recorder.mark();
@@ -4889,7 +5569,7 @@ function ExtractList({ detail, extracts }) {
 			children: quotes.map((segment) => /* @__PURE__ */ jsxs("li", { children: [/* @__PURE__ */ jsx("span", {
 				className: "dt-ses-time",
 				children: formatClock(segment.startMs)
-			}), ` “${segment.text}”`] }, segment.id))
+			}), ` “${attributedText(segment)}”`] }, segment.id))
 		}),
 		/* @__PURE__ */ jsx("div", {
 			className: "dt-ses-thumbs",
@@ -4967,7 +5647,7 @@ function ChangeSources({ change, context }) {
 		children: [/* @__PURE__ */ jsx("span", {
 			className: "dt-ses-time",
 			children: formatClock(segment.startMs)
-		}), ` “${segment.text}”`]
+		}), ` “${attributedText(segment)}”`]
 	}, segment.id)), evidence.length > 0 && /* @__PURE__ */ jsx("div", {
 		className: "dt-ses-thumbs",
 		children: evidence.map((item) => /* @__PURE__ */ jsx(EvidenceThumb, { evidence: item }, item.id))
@@ -5294,7 +5974,7 @@ function VerdictQuotes({ context, segmentIds }) {
 		children: [/* @__PURE__ */ jsx("span", {
 			className: "dt-ses-time",
 			children: formatClock(segment.startMs)
-		}), ` “${segment.text}”`]
+		}), ` “${attributedText(segment)}”`]
 	}, segment.id));
 }
 const CHECK_LABELS = {
@@ -5984,7 +6664,7 @@ function MomentView({ handlers, segmentId, session }) {
 			segment ? /* @__PURE__ */ jsxs(Fragment, { children: [
 				/* @__PURE__ */ jsx("blockquote", {
 					className: "dt-ses-moment-quote",
-					children: segment.text || "No speech was heard here."
+					children: attributedText(segment) || "No speech was heard here."
 				}),
 				/* @__PURE__ */ jsx(MomentContext, {
 					detail,
@@ -6807,7 +7487,8 @@ function DisclosureList() {
 		}), /* @__PURE__ */ jsxs("ul", {
 			className: "dt-ses-list",
 			children: [
-				/* @__PURE__ */ jsx("li", { children: "Your voice while recording. It is sent to Reflet and transcribed by Whisper through OpenRouter with zero data retention. The audio is deleted as soon as its transcript is saved, within 24 hours at most." }),
+				/* @__PURE__ */ jsx("li", { children: "Your voice while recording. It is sent to Reflet and transcribed by ElevenLabs Scribe through OpenRouter with zero data retention. The audio is deleted as soon as its transcript is saved, within 24 hours at most." }),
+				/* @__PURE__ */ jsx("li", { children: "If you tick “Several people are talking”, your voice is also streamed live to Mistral (Voxtral) to tell the voices apart. Mistral keeps it up to 30 days and does not train on it." }),
 				/* @__PURE__ */ jsx("li", { children: "The page: its address without sensitive parameters, its title, the scroll position and the window size." }),
 				/* @__PURE__ */ jsx("li", { children: "What you click, point at and mark: element names and positions, never your keystrokes." }),
 				/* @__PURE__ */ jsxs("li", { children: [
@@ -6869,23 +7550,44 @@ function StartProblem({ failure, onRetry, onWriteNote }) {
 		})]
 	});
 }
-function StartActions({ isBusy, onStart }) {
+function SpeakersChoice({ detectSpeakers, isBusy, onChange }) {
+	const hintId = useId();
+	return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs("label", {
+		className: "dt-ses-check",
+		children: [/* @__PURE__ */ jsx("input", {
+			"aria-describedby": hintId,
+			checked: detectSpeakers,
+			disabled: isBusy,
+			onChange: (event) => onChange(event.target.checked),
+			type: "checkbox"
+		}), /* @__PURE__ */ jsx("span", { children: "Several people are talking" })]
+	}), /* @__PURE__ */ jsx("p", {
+		className: "dt-meta",
+		id: hintId,
+		children: "Mistral tells the voices apart so each passage shows who spoke."
+	})] });
+}
+function StartActions({ children, isBusy, onStart }) {
 	return /* @__PURE__ */ jsxs("div", {
 		className: "dt-ses-start",
-		children: [/* @__PURE__ */ jsx("p", {
-			className: "dt-meta",
-			children: "Talk while you use the app. Reflet turns what you say and show into intentions you can brief an agent with."
-		}), /* @__PURE__ */ jsx("div", {
-			className: "dt-actions",
-			children: /* @__PURE__ */ jsxs("button", {
-				className: "dt-btn",
-				"data-variant": "primary",
-				disabled: isBusy,
-				onClick: onStart,
-				type: "button",
-				children: [/* @__PURE__ */ jsx(MicIcon, {}), "Start session"]
+		children: [
+			/* @__PURE__ */ jsx("p", {
+				className: "dt-meta",
+				children: "Talk while you use the app. Reflet turns what you say and show into intentions you can brief an agent with."
+			}),
+			children,
+			/* @__PURE__ */ jsx("div", {
+				className: "dt-actions",
+				children: /* @__PURE__ */ jsxs("button", {
+					className: "dt-btn",
+					"data-variant": "primary",
+					disabled: isBusy,
+					onClick: onStart,
+					type: "button",
+					children: [/* @__PURE__ */ jsx(MicIcon, {}), "Start session"]
+				})
 			})
-		})]
+		]
 	});
 }
 function useRecorderStart(onStarted) {
@@ -6914,20 +7616,26 @@ function MicrophonePrompt({ isRequesting }) {
 	});
 }
 function StartSession({ onStarted, onWriteNote }) {
-	const { account } = useSessionWorkspace();
+	const { account, identity } = useSessionWorkspace();
 	const { failure, isBusy, isRequesting, start } = useRecorderStart(onStarted);
 	const [isFirstVisit] = useState(() => !hasSeenDisclosure(account.key));
-	const startBlank = () => start({});
+	const [detectSpeakers, setDetectSpeakers] = useState(false);
+	const startSession = () => start({ detectSpeakers });
 	const disclosure = /* @__PURE__ */ jsx(SessionDisclosure, { accountKey: account.key });
 	return /* @__PURE__ */ jsxs(Fragment, { children: [
 		isFirstVisit && disclosure,
 		failure ? /* @__PURE__ */ jsx(StartProblem, {
 			failure,
-			onRetry: startBlank,
+			onRetry: startSession,
 			onWriteNote
 		}) : /* @__PURE__ */ jsx(StartActions, {
 			isBusy,
-			onStart: startBlank
+			onStart: startSession,
+			children: identity.speakersConfigured && /* @__PURE__ */ jsx(SpeakersChoice, {
+				detectSpeakers,
+				isBusy,
+				onChange: setDetectSpeakers
+			})
 		}),
 		/* @__PURE__ */ jsx(MicrophonePrompt, { isRequesting }),
 		!isFirstVisit && disclosure
@@ -7089,7 +7797,7 @@ function Sources({ context, proposal }) {
 			children: [/* @__PURE__ */ jsx("span", {
 				className: "dt-ses-time",
 				children: formatClock(segment.startMs)
-			}), ` “${segment.text}”`]
+			}), ` “${attributedText(segment)}”`]
 		}, segment.id)),
 		/* @__PURE__ */ jsx("div", {
 			className: "dt-ses-thumbs",
@@ -7257,7 +7965,7 @@ function IntentionSource({ context, proposal }) {
 					children: range
 				}),
 				" “",
-				segment.text,
+				attributedText(segment),
 				"”"
 			]
 		}), firstContext && /* @__PURE__ */ jsx("span", {
@@ -8525,11 +9233,30 @@ function SegmentBody({ onType, review, segment }) {
 		className: "dt-meta",
 		children: "No speech was heard here."
 	});
+	if (segment.speech) return /* @__PURE__ */ jsx(SpokenRuns, { speech: segment.speech });
 	return /* @__PURE__ */ jsx("p", {
 		className: "dt-note-text",
 		children: segment.text
 	});
 }
+function SpokenRuns({ speech }) {
+	let startsAt = 0;
+	const lines = speech.map((run) => {
+		const line = {
+			...run,
+			startsAt
+		};
+		startsAt += run.text.length;
+		return line;
+	});
+	return /* @__PURE__ */ jsx(Fragment, { children: lines.map((line) => /* @__PURE__ */ jsxs("p", {
+		className: "dt-note-text",
+		children: [line.speaker && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+			className: "dt-ses-speaker",
+			children: speakerLabel(line.speaker)
+		}), " "] }), line.text]
+	}, line.startsAt)) });
+}
 function ContextChips({ segment }) {
 	if (segment.context.length === 0) return null;
 	return /* @__PURE__ */ jsxs("div", {
@@ -8649,7 +9376,8 @@ function contextLine(item, detail) {
 	].filter((part) => part !== null).join(" — ");
 }
 function spokenText(segment) {
-	if (segment.text) return segment.text.replace(WHITESPACE_RUN, " ");
+	const text = attributedText(segment);
+	if (text) return text.replace(WHITESPACE_RUN, " ");
 	return segment.transcription.state === "empty" ? "(no speech heard)" : "(not transcribed)";
 }
 function passageLines(segment, detail) {
@@ -9425,6 +10153,7 @@ ${`
 .dt-ses-seg:focus { outline: 2px solid var(--rf-accent); outline-offset: -2px; }
 .dt-ses-seg[data-kind="note"] { padding-block: 2px; }
 .dt-ses-seg-body { display: flex; flex: 1; flex-direction: column; gap: 4px; min-width: 0; }
+.dt-ses-speaker { color: var(--rf-text-muted); font-size: 11.5px; font-weight: 600; }
 `}${`
 .dt-ses-thumbs { display: flex; flex-wrap: wrap; gap: 6px; }
 .dt-ses-shot { position: relative; display: inline-block; max-width: 100%; line-height: 0; }
@@ -13595,4 +14324,4 @@ function useSheetTab() {
 //#endregion
 export { sessionSheetPlace as A, teamTransport as B, AccountFooter as C, MissingRouteHint as D, MISSING_SECRET_KEY_HINT as E, useWorkspaceLoader as F, SessionApiError as G, disconnectBoard as H, purgeAccount as I, reportFailure as J, sessionApiErrorSchema as K, bridgeBoardCall as L, RecordingLayer as M, SessionWorkspaceProvider as N, SESSIONS_STYLES as O, failureMessage as P, bridgeTransport as R, InboxPanel as S, CONNECT_REQUIREMENT as T, probeDevRoute as U, callReflet as V, startBoardConnect as W, DevtoolsBarButtons as _, NotePicker as a, CodeTab as b, isActiveNote as c, useNotes as d, findOnPage as f, DevtoolsBar as g, DevtoolsSheet as h, NotesPanel as i, useSessionNavigation as j, SessionsPanel as k, isNoteOnPage as l, DEVTOOLS_STYLES as m, useSheetTab as n, enrichNote as o, usePageHighlight as p, Notices as q, NotePins as r, hasTriedToLocate as s, FIRST_SHEET_TAB as t, unsentNoteCount as u, SHEET_TABS as v, AccountNote as w, useCodeLookup as x, SessionsBarButton as y, devtoolsTransport as z };
 
-//# sourceMappingURL=use-sheet-tab-QLQ1oeso.js.map
+//# sourceMappingURL=use-sheet-tab-DTGgQ_1c.js.map