@ephia/dova-sdk 1.0.0

package/src/core/transcript/transcript.reducer.ts

@@ -0,0 +1,771 @@
+import type { EphiaAudioEvent, DocumentPatchEvent } from "ephia-protocol";
+import type { LiveTranscriptState, LiveTranscriptChunk, LiveTranscriptDiagnostics } from "./transcript.state";
+import { initialLiveTranscriptState } from "./transcript.state";
+import { assembleTranscript, buildDisplayText, assembleCommittedDocument, joinWithSpacing } from "./transcript.assembler";
+import { pickEffectiveText } from "../../shared/effective-text";
+
+export type LiveTranscriptAction =
+  | { type: "event"; event: EphiaAudioEvent }
+  | { type: "reset" }
+  | { type: "remove_segments"; segmentIds: string[] }
+  | { type: "client_error"; error: { code: string; message: string } }
+  | { type: "tick" };
+
+export function liveTranscriptReducer(
+  state: LiveTranscriptState,
+  action: LiveTranscriptAction
+): LiveTranscriptState {
+  if (action.type === "reset") {
+    return { ...initialLiveTranscriptState };
+  }
+
+  if (action.type === "remove_segments") {
+    const removeSet = new Set(action.segmentIds);
+    if (removeSet.size === 0) return state;
+    const newChunks: Record<string, LiveTranscriptChunk> = {};
+    for (const [id, chunk] of Object.entries(state.chunks)) {
+      if (!removeSet.has(id)) {
+        newChunks[id] = chunk;
+      }
+    }
+    const orderedSegmentIds = state.orderedSegmentIds.filter(
+      (id) => !removeSet.has(id)
+    );
+    const documentText = assembleCommittedDocument(newChunks, orderedSegmentIds);
+    return {
+      ...state,
+      chunks: newChunks,
+      orderedSegmentIds,
+      documentText,
+      diagnostics: computeDiagnostics(
+        newChunks,
+        orderedSegmentIds,
+        state.diagnostics,
+        state.finalText,
+        state.previewText
+      ),
+    };
+  }
+
+  if (action.type === "client_error") {
+    return {
+      ...state,
+      status: "error",
+      error: action.error,
+    };
+  }
+
+  if (action.type === "tick") {
+    const hasProcessing = Object.values(state.chunks).some(
+      (c) => c.status === "opened" || c.status === "processing"
+    );
+    if (!hasProcessing) return state;
+    const nextTick = state.spinnerTick + 1;
+    const previewText = buildPreviewText(state.chunks, state.orderedSegmentIds, nextTick);
+    return {
+      ...state,
+      spinnerTick: nextTick,
+      previewText,
+      displayText: buildLiveDisplayText(state.chunks, state.orderedSegmentIds, state.finalText, previewText),
+      diagnostics: computeDiagnostics(state.chunks, state.orderedSegmentIds, state.diagnostics, state.finalText, previewText),
+    };
+  }
+
+  if (action.type !== "event") {
+    return state;
+  }
+
+  const event = action.event;
+
+  // Vérifier séquence monotone (strictement consécutive)
+  // Après un session.sync réussi, les events redeviennent consécutifs :
+  // on autorise la réparation automatique de seqValid.
+  const lastSeq = state.lastEvent?.seq;
+  const isFirstEvent = lastSeq === undefined;
+  const isConsecutive = lastSeq !== undefined && event.seq === lastSeq + 1;
+  const isRecoveredFromSync = !state.diagnostics.seqValid && isConsecutive;
+  const seqValid =
+    (state.diagnostics.seqValid || isRecoveredFromSync) &&
+    (isFirstEvent || isConsecutive);
+
+  const base: LiveTranscriptState = {
+    ...state,
+    events: [...state.events, event],
+    lastEvent: event,
+    diagnostics: {
+      ...state.diagnostics,
+      eventsCount: state.diagnostics.eventsCount + 1,
+      seqValid,
+    },
+  };
+
+  switch (event.type) {
+    case "session.started":
+      return {
+        ...base,
+        sessionId: event.sessionId,
+        status: "connecting",
+      };
+
+    case "session.ready":
+      return {
+        ...base,
+        status: "recording",
+      };
+
+    case "session.paused":
+      return {
+        ...base,
+        status: "ended",
+        diagnostics: {
+          ...base.diagnostics,
+          previewActive: false,
+        },
+      };
+
+    case "session.closed":
+      return {
+        ...base,
+        status: "ended",
+        diagnostics: {
+          ...base.diagnostics,
+          previewActive: false,
+        },
+      };
+
+    case "session.error":
+      return {
+        ...base,
+        status: "error",
+        error: {
+          code: event.payload.code,
+          message: event.payload.message,
+        },
+      };
+
+    case "session.context.reset": {
+      const contextOnly = (event as { payload: { contextOnly?: boolean } }).payload.contextOnly ?? false;
+      if (!contextOnly) {
+        const finalizedBeforeReset: Record<string, true> = {};
+        for (const [id, chunk] of Object.entries(base.chunks)) {
+          if (chunk.status === "done") finalizedBeforeReset[id] = true;
+        }
+        return { ...initialLiveTranscriptState, finalizedBeforeReset };
+      }
+      // contextOnly=true : conserver les chunks committés, vider les previews
+      const newChunks: Record<string, LiveTranscriptChunk> = {};
+      const newOrdered: string[] = [];
+      for (const id of base.orderedSegmentIds) {
+        const chunk = base.chunks[id];
+        if (chunk && (chunk.committedText || chunk.status === "done")) {
+          newChunks[id] = { ...chunk, previewText: undefined };
+          newOrdered.push(id);
+        }
+      }
+      const documentText = assembleCommittedDocument(newChunks, newOrdered);
+      return {
+        ...base,
+        chunks: newChunks,
+        orderedSegmentIds: newOrdered,
+        documentText,
+        previewText: "",
+        displayText: documentText,
+        diagnostics: computeDiagnostics(newChunks, newOrdered, base.diagnostics, base.finalText, ""),
+      };
+    }
+
+    case "transcript.segment.opened": {
+      const chunk: LiveTranscriptChunk = {
+        segmentId: event.payload.segmentId,
+        segmentSeq: event.payload.segmentSeq,
+        status: "opened",
+        text: "",
+        revision: 0,
+        startedAtMs: event.payload.startedAtMs,
+      };
+      const ordered = base.orderedSegmentIds.includes(event.payload.segmentId)
+        ? base.orderedSegmentIds
+        : [...base.orderedSegmentIds, event.payload.segmentId];
+      const newChunks: Record<string, LiveTranscriptChunk> = { ...base.chunks, [event.payload.segmentId]: chunk };
+      const previewText = buildPreviewText(newChunks, ordered, base.spinnerTick);
+      return {
+        ...base,
+        chunks: newChunks,
+        orderedSegmentIds: ordered,
+        previewText,
+        displayText: buildLiveDisplayText(newChunks, ordered, base.finalText, previewText),
+        diagnostics: computeDiagnostics(newChunks, ordered, base.diagnostics, base.finalText, previewText),
+      };
+    }
+
+    case "transcript.segment.processing": {
+      const existing = base.chunks[event.payload.segmentId];
+      if (!existing) return base;
+      const newChunks: Record<string, LiveTranscriptChunk> = {
+        ...base.chunks,
+        [event.payload.segmentId]: {
+          ...existing,
+          status: "processing",
+          durationMs: event.payload.durationMs,
+        } as LiveTranscriptChunk,
+      };
+      const previewText = buildPreviewText(newChunks, base.orderedSegmentIds, base.spinnerTick);
+      return {
+        ...base,
+        chunks: newChunks,
+        previewText,
+        displayText: buildLiveDisplayText(newChunks, base.orderedSegmentIds, base.finalText, previewText),
+        diagnostics: computeDiagnostics(newChunks, base.orderedSegmentIds, base.diagnostics, base.finalText, previewText),
+      };
+    }
+
+    case "transcript.preview": {
+      const existing = base.chunks[event.payload.segmentId];
+      const partialText = event.payload.text;
+      if (!partialText) {
+        return base;
+      }
+      if (existing) {
+        // Ignorer si chunk déjà finalisé
+        if (existing.status === "done") {
+          return base;
+        }
+        // Ignorer si révision non croissante
+        if (event.payload.revision <= existing.revision) {
+          return base;
+        }
+        const newChunks: Record<string, LiveTranscriptChunk> = {
+          ...base.chunks,
+          [event.payload.segmentId]: {
+            ...existing,
+            status: "preview",
+            previewText: partialText,
+            previewContinuesPreviousWord: false,
+            stablePrefix: event.payload.text,
+            revision: event.payload.revision,
+          } as LiveTranscriptChunk,
+        };
+        const previewText = buildPreviewText(newChunks, base.orderedSegmentIds, base.spinnerTick);
+        return {
+          ...base,
+          chunks: newChunks,
+          previewText,
+          displayText: buildLiveDisplayText(newChunks, base.orderedSegmentIds, base.finalText, previewText),
+          diagnostics: computeDiagnostics(newChunks, base.orderedSegmentIds, base.diagnostics, base.finalText, previewText),
+        };
+      }
+      // Partial sans chunk connu (fallback)
+      const chunk: LiveTranscriptChunk = {
+        segmentId: event.payload.segmentId,
+        segmentSeq: event.payload.segmentSeq,
+        status: "preview",
+        text: "",
+        previewText: partialText,
+        previewContinuesPreviousWord: false,
+        stablePrefix: event.payload.text,
+        revision: event.payload.revision,
+      };
+      const ordered = base.orderedSegmentIds.includes(event.payload.segmentId)
+        ? base.orderedSegmentIds
+        : [...base.orderedSegmentIds, event.payload.segmentId];
+      const newChunks: Record<string, LiveTranscriptChunk> = { ...base.chunks, [event.payload.segmentId]: chunk };
+      const previewText = buildPreviewText(newChunks, ordered, base.spinnerTick);
+      return {
+        ...base,
+        chunks: newChunks,
+        orderedSegmentIds: ordered,
+        previewText,
+        displayText: buildLiveDisplayText(newChunks, ordered, base.finalText, previewText),
+        diagnostics: computeDiagnostics(newChunks, ordered, base.diagnostics, base.finalText, previewText),
+      };
+    }
+
+    case "segment.dropped": {
+      const newChunks: Record<string, LiveTranscriptChunk> = { ...base.chunks };
+      delete newChunks[event.payload.segmentId];
+      const orderedSegmentIds = base.orderedSegmentIds.filter(
+        (id) => id !== event.payload.segmentId
+      );
+      const finalText = assembleTranscript(Object.values(newChunks));
+      const documentText = assembleCommittedDocument(newChunks, orderedSegmentIds);
+      const previewText = buildPreviewText(newChunks, orderedSegmentIds, base.spinnerTick);
+      return {
+        ...base,
+        chunks: newChunks,
+        orderedSegmentIds,
+        finalText,
+        documentText,
+        previewText,
+        displayText: buildLiveDisplayText(newChunks, orderedSegmentIds, finalText, previewText),
+        diagnostics: computeDiagnostics(
+          newChunks,
+          orderedSegmentIds,
+          base.diagnostics,
+          finalText,
+          previewText
+        ),
+      };
+    }
+
+    case "segment.absorbed": {
+      if (base.finalizedBeforeReset?.[event.payload.segmentId]) return base;
+      const absorbedId = event.payload.segmentId;
+      const existing = base.chunks[absorbedId];
+      if (!existing) return base;
+      const newChunks: Record<string, LiveTranscriptChunk> = {
+        ...base.chunks,
+        [absorbedId]: {
+          ...existing,
+          status: "done",
+          text: "",
+          committedText: "",
+          previewText: undefined,
+          mergedWith: event.payload.absorbedInto,
+        } as LiveTranscriptChunk,
+      };
+      const orderedSegmentIds = base.orderedSegmentIds.filter(id => id !== absorbedId);
+      const documentText = assembleCommittedDocument(newChunks, orderedSegmentIds);
+      const previewText = buildPreviewText(newChunks, orderedSegmentIds, base.spinnerTick);
+      return {
+        ...base,
+        chunks: newChunks,
+        orderedSegmentIds,
+        documentText,
+        previewText,
+        displayText: buildLiveDisplayText(newChunks, orderedSegmentIds, base.finalText, previewText),
+        diagnostics: computeDiagnostics(newChunks, orderedSegmentIds, base.diagnostics, base.finalText, previewText),
+      };
+    }
+
+    case "transcript.preview.stable": {
+      const existing = base.chunks[event.payload.segmentId];
+      if (!existing) return base;
+      const newChunks: Record<string, LiveTranscriptChunk> = {
+        ...base.chunks,
+        [event.payload.segmentId]: {
+          ...existing,
+          status: "preview",
+          previewText: event.payload.text,
+          previewContinuesPreviousWord: false,
+          stablePrefix: event.payload.text,
+          revision: event.payload.revision,
+        } as LiveTranscriptChunk,
+      };
+      const previewText = buildPreviewText(newChunks, base.orderedSegmentIds, base.spinnerTick);
+      return {
+        ...base,
+        chunks: newChunks,
+        previewText,
+        displayText: buildLiveDisplayText(newChunks, base.orderedSegmentIds, base.finalText, previewText),
+        diagnostics: computeDiagnostics(newChunks, base.orderedSegmentIds, base.diagnostics, base.finalText, previewText),
+      };
+    }
+
+    case "transcript.final": {
+      const existing = base.chunks[event.payload.segmentId];
+      let newChunks: Record<string, LiveTranscriptChunk>;
+      let ordered = base.orderedSegmentIds;
+
+      const meta = event.meta || {};
+      const chunkUpdate: Partial<LiveTranscriptChunk> = {
+        status: "done",
+        text: event.payload.text,
+        previewText: undefined,
+        provider: event.payload.provider,
+        uncertain: meta.uncertain as boolean | undefined,
+        reason: meta.reason ? (meta.reason as string) : undefined,
+        reasonCodes: meta.reasonCodes as string[] | undefined,
+        parseFallback: meta.parseFallback as boolean | undefined,
+      };
+
+      if (!existing) {
+        const chunk: LiveTranscriptChunk = {
+          segmentId: event.payload.segmentId,
+          segmentSeq: event.payload.segmentSeq,
+          revision: 0,
+          ...chunkUpdate,
+        } as LiveTranscriptChunk;
+        ordered = base.orderedSegmentIds.includes(event.payload.segmentId)
+          ? base.orderedSegmentIds
+          : [...base.orderedSegmentIds, event.payload.segmentId];
+        newChunks = { ...base.chunks, [event.payload.segmentId]: chunk };
+      } else {
+        newChunks = {
+          ...base.chunks,
+          [event.payload.segmentId]: {
+            ...existing,
+            ...chunkUpdate,
+          } as LiveTranscriptChunk,
+        };
+      }
+
+      const finalText = assembleTranscript(Object.values(newChunks));
+      const previewText = buildPreviewText(newChunks, ordered, base.spinnerTick);
+      const latency = event.meta?.latencyMs as number | undefined;
+      const contextChars = event.meta?.contextChars as number | undefined;
+      const provider = event.payload.provider;
+
+      return {
+        ...base,
+        chunks: newChunks,
+        orderedSegmentIds: ordered,
+        finalText,
+        previewText,
+        displayText: buildLiveDisplayText(newChunks, ordered, finalText, previewText),
+        diagnostics: computeDiagnostics(newChunks, ordered, base.diagnostics, finalText, previewText, latency, contextChars, provider),
+      };
+    }
+
+    case "transcript.segment.ready": {
+      const existing = base.chunks[event.payload.segmentId];
+      const effectiveText = pickEffectiveText(event.payload) || event.payload.text;
+      const ordered = base.orderedSegmentIds.includes(event.payload.segmentId)
+        ? base.orderedSegmentIds
+        : [...base.orderedSegmentIds, event.payload.segmentId];
+      const newChunks: Record<string, LiveTranscriptChunk> = {
+        ...base.chunks,
+        [event.payload.segmentId]: {
+          ...(existing ?? {
+            segmentId: event.payload.segmentId,
+            segmentSeq: event.payload.segmentSeq,
+            status: "processing",
+            text: "",
+            revision: 0,
+          }),
+          finalizedText: effectiveText,
+          provider: event.payload.provider,
+          previewText: undefined,
+        } as LiveTranscriptChunk,
+      };
+      const previewText = buildPreviewText(newChunks, ordered, base.spinnerTick);
+      return {
+        ...base,
+        chunks: newChunks,
+        orderedSegmentIds: ordered,
+        previewText,
+        displayText: buildLiveDisplayText(newChunks, ordered, base.finalText, previewText),
+        diagnostics: computeDiagnostics(newChunks, ordered, base.diagnostics, base.finalText, previewText),
+      };
+    }
+
+    case "transcript.segment.committed": {
+      if (base.finalizedBeforeReset?.[event.payload.segmentId]) return base;
+      const existing = base.chunks[event.payload.segmentId];
+      const effectiveText = pickEffectiveText(event.payload) || event.payload.text;
+      const ordered = base.orderedSegmentIds.includes(event.payload.segmentId)
+        ? base.orderedSegmentIds
+        : [...base.orderedSegmentIds, event.payload.segmentId];
+      const mergedIds: string[] = event.payload.mergedWith
+        ? Array.isArray(event.payload.mergedWith)
+          ? event.payload.mergedWith
+          : [event.payload.mergedWith]
+        : [];
+
+      let newChunks: Record<string, LiveTranscriptChunk> = {
+        ...base.chunks,
+        [event.payload.segmentId]: {
+          ...(existing ?? {
+            segmentId: event.payload.segmentId,
+            segmentSeq: event.payload.segmentSeq,
+            revision: 0,
+          }),
+          status: "done",
+          committedText: effectiveText,
+          text: effectiveText,
+          source: event.payload.source,
+          mergedWith: mergedIds.length > 0 ? mergedIds : undefined,
+          previewText: undefined,
+          // P1 backend : additif, n'affecte ni le statut ni le texte affiché.
+          effectiveSource: event.payload.effectiveSource,
+          correctionPending: event.payload.correctionPending,
+          correctionAccepted: event.payload.correctionAccepted,
+          correctionRejectedReason: event.payload.correctionRejectedReason,
+          commandsApplied: event.payload.commandsApplied,
+          normalizationsApplied: event.payload.normalizationsApplied,
+          safety: event.payload.safety,
+          layout: event.payload.layout,
+          rawStt: event.payload.rawStt,
+          realtimeText: event.payload.realtimeText,
+          hintSentToSmall: event.payload.hintSentToSmall,
+          fallbackText: event.payload.fallbackText,
+          smallRawText: event.payload.smallRawText,
+          correctionOutcome: event.payload.correctionOutcome,
+          debug: event.payload.debug,
+        } as LiveTranscriptChunk,
+      };
+
+      // Purger les segments absorbés pour qu'ils ne polluent plus previewText
+      for (const absorbedId of mergedIds) {
+        const absorbed = newChunks[absorbedId];
+        if (absorbed) {
+          newChunks = {
+            ...newChunks,
+            [absorbedId]: {
+              ...absorbed,
+              status: "done",
+              text: "",
+              committedText: "",
+              previewText: undefined,
+              mergedWith: event.payload.segmentId,
+            } as LiveTranscriptChunk,
+          };
+        }
+      }
+      const finalText = assembleTranscript(Object.values(newChunks));
+      const documentText = assembleCommittedDocument(newChunks, ordered);
+      const previewText = buildPreviewText(newChunks, ordered, base.spinnerTick);
+      return {
+        ...base,
+        chunks: newChunks,
+        orderedSegmentIds: ordered,
+        finalText,
+        documentText,
+        previewText,
+        displayText: buildLiveDisplayText(newChunks, ordered, finalText, previewText),
+        diagnostics: computeDiagnostics(newChunks, ordered, base.diagnostics, finalText, previewText),
+      };
+    }
+
+    case "segment.opened": {
+      const id = event.payload.segmentId;
+      if (base.chunks[id]) return base;
+      const chunk: LiveTranscriptChunk = {
+        segmentId: id,
+        segmentSeq: event.payload.segmentSeq,
+        status: "opened",
+        text: "",
+        revision: 0,
+        startedAtMs: event.payload.startMs,
+      };
+      const ordered = [...base.orderedSegmentIds, id];
+      const newChunks = { ...base.chunks, [id]: chunk };
+      return {
+        ...base,
+        chunks: newChunks,
+        orderedSegmentIds: ordered,
+        diagnostics: computeDiagnostics(newChunks, ordered, base.diagnostics, base.finalText, base.previewText),
+      };
+    }
+
+    case "document.patch": {
+      let newChunks = { ...base.chunks };
+      for (const op of (event as DocumentPatchEvent).payload.ops) {
+        if (op.type === "merge" && op.to && newChunks[op.to]) {
+          newChunks = {
+            ...newChunks,
+            [op.to]: {
+              ...newChunks[op.to],
+              committedText: op.text ?? newChunks[op.to].committedText,
+              text: op.text ?? newChunks[op.to].text,
+              mergedWith: op.from,
+            } as LiveTranscriptChunk,
+          };
+        } else if (op.type === "replace" && op.blockId && newChunks[op.blockId]) {
+          newChunks = {
+            ...newChunks,
+            [op.blockId]: {
+              ...newChunks[op.blockId],
+              committedText: op.text ?? newChunks[op.blockId].committedText,
+              text: op.text ?? newChunks[op.blockId].text,
+            } as LiveTranscriptChunk,
+          };
+        }
+      }
+      const documentText = assembleCommittedDocument(newChunks, base.orderedSegmentIds);
+      return {
+        ...base,
+        chunks: newChunks,
+        documentText,
+        diagnostics: computeDiagnostics(newChunks, base.orderedSegmentIds, base.diagnostics, base.finalText, base.previewText),
+      };
+    }
+
+    case "transcript.segment.completed": {
+      const existing = base.chunks[event.payload.segmentId];
+      if (!existing) return base;
+      const newChunks: Record<string, LiveTranscriptChunk> = {
+        ...base.chunks,
+        [event.payload.segmentId]: {
+          ...existing,
+          status: existing.status === "done" || existing.status === "preview" ? existing.status : "done",
+          durationMs: event.payload.durationMs,
+          provider: event.payload.provider,
+        } as LiveTranscriptChunk,
+      };
+      return {
+        ...base,
+        chunks: newChunks,
+        diagnostics: computeDiagnostics(newChunks, base.orderedSegmentIds, base.diagnostics, base.finalText, base.previewText),
+      };
+    }
+
+    case "transcript.segment.error": {
+      const existing = base.chunks[event.payload.segmentId];
+      const chunk: LiveTranscriptChunk = {
+        ...(existing ?? {
+          segmentId: event.payload.segmentId,
+          segmentSeq: event.payload.segmentSeq,
+          text: "",
+          revision: 0,
+        }),
+        status: "error",
+        error: `${event.payload.code}: ${event.payload.message}`,
+      };
+      const ordered = base.orderedSegmentIds.includes(event.payload.segmentId)
+        ? base.orderedSegmentIds
+        : [...base.orderedSegmentIds, event.payload.segmentId];
+      const newChunks = { ...base.chunks, [event.payload.segmentId]: chunk };
+      return {
+        ...base,
+        chunks: newChunks,
+        orderedSegmentIds: ordered,
+        diagnostics: computeDiagnostics(newChunks, ordered, base.diagnostics, base.finalText, base.previewText),
+      };
+    }
+
+    case "audio.vad.start":
+      return {
+        ...base,
+        diagnostics: { ...base.diagnostics, mode: "vad" },
+      };
+
+    case "segment.audio.closed": {
+      const existing = base.chunks[event.payload.segmentId];
+      if (!existing) return base;
+      const newChunks: Record<string, LiveTranscriptChunk> = {
+        ...base.chunks,
+        [event.payload.segmentId]: {
+          ...existing,
+          audioClosedAtMs: event.payload.endMs,
+          // Conserver le dernier preview jusqu'au committed — évite le flash vide
+          // entre la fin audio VAD et la finalisation Voxtral.
+          status: existing.status === "preview" ? "processing" : existing.status,
+        } as LiveTranscriptChunk,
+      };
+      const previewText = buildPreviewText(newChunks, base.orderedSegmentIds, base.spinnerTick);
+      return {
+        ...base,
+        chunks: newChunks,
+        previewText,
+        displayText: buildLiveDisplayText(newChunks, base.orderedSegmentIds, base.finalText, previewText),
+        diagnostics: computeDiagnostics(newChunks, base.orderedSegmentIds, base.diagnostics, base.finalText, previewText),
+      };
+    }
+
+    case "audio.vad.end":
+    case "session.pong":
+    default:
+      return base;
+  }
+}
+
+const SPINNER_CHARS = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+function buildPreviewText(
+  chunks: Record<string, LiveTranscriptChunk>,
+  orderedSegmentIds: string[],
+  spinnerTick: number = 0
+): string {
+  const sorted = [...orderedSegmentIds]
+    .map((id) => chunks[id])
+    .filter((c): c is LiveTranscriptChunk => !!c)
+    .sort((a, b) => a.segmentSeq - b.segmentSeq);
+  let result = "";
+  let hasPendingWithoutPreview = false;
+  for (const chunk of sorted) {
+    if (chunk.status === "done") continue;
+    if ((chunk.status === "preview" || chunk.status === "processing" || chunk.status === "opened") && chunk.previewText) {
+      result = joinWithSpacing(result, chunk.previewText);
+    } else if (chunk.status === "processing" || chunk.status === "opened") {
+      hasPendingWithoutPreview = true;
+    }
+  }
+  if (hasPendingWithoutPreview && !result) {
+    return SPINNER_CHARS[spinnerTick % SPINNER_CHARS.length];
+  }
+  return result;
+}
+
+function previewContinuesPreviousWord(
+  chunks: Record<string, LiveTranscriptChunk>,
+  orderedSegmentIds: string[]
+): boolean {
+  const sorted = [...orderedSegmentIds]
+    .map((id) => chunks[id])
+    .filter((c): c is LiveTranscriptChunk => !!c)
+    .sort((a, b) => a.segmentSeq - b.segmentSeq);
+  const firstPreview = sorted.find(
+    (chunk) =>
+      chunk.status !== "done" &&
+      !!chunk.previewText &&
+      (chunk.status === "preview" ||
+        chunk.status === "processing" ||
+        chunk.status === "opened")
+  );
+  return !!firstPreview?.previewContinuesPreviousWord;
+}
+
+function buildLiveDisplayText(
+  chunks: Record<string, LiveTranscriptChunk>,
+  orderedSegmentIds: string[],
+  finalText: string,
+  previewText: string
+): string {
+  return buildDisplayText(
+    finalText,
+    previewText,
+    previewContinuesPreviousWord(chunks, orderedSegmentIds)
+  );
+}
+
+
+function computeDiagnostics(
+  chunks: Record<string, LiveTranscriptChunk>,
+  orderedSegmentIds: string[],
+  prevDiagnostics: LiveTranscriptDiagnostics,
+  finalText: string,
+  previewText: string,
+  newLatencyMs?: number,
+  newContextChars?: number,
+  newProvider?: string,
+): LiveTranscriptDiagnostics {
+  const all = Object.values(chunks);
+  const processingChunks = all.filter((c) => c.status === "opened" || c.status === "processing").length;
+  const doneChunks = all.filter((c) => c.status === "done").length;
+  const errorChunks = all.filter((c) => c.status === "error").length;
+  const previewActive = all.some((c) =>
+    (c.status === "preview" || c.status === "processing" || c.status === "opened") && !!c.previewText
+  );
+  const uncertainChunks = all.filter((c) => c.uncertain).length;
+  const parseFallbackChunks = all.filter((c) => c.parseFallback).length;
+
+  // Moyenne glissante de latence
+  let averageLatencyMs = prevDiagnostics.averageLatencyMs;
+  let lastLatencyMs = prevDiagnostics.lastLatencyMs;
+  if (newLatencyMs !== undefined) {
+    lastLatencyMs = newLatencyMs;
+    const prevAvg = prevDiagnostics.averageLatencyMs ?? 0;
+    const count = doneChunks;
+    if (count <= 1) {
+      averageLatencyMs = newLatencyMs;
+    } else {
+      averageLatencyMs = Math.round((prevAvg * (count - 1) + newLatencyMs) / count);
+    }
+  }
+
+  return {
+    ...prevDiagnostics,
+    chunksCount: orderedSegmentIds.length,
+    processingChunks,
+    doneChunks,
+    errorChunks,
+    averageLatencyMs,
+    lastLatencyMs,
+    lastProvider: newProvider ?? prevDiagnostics.lastProvider,
+    finalTextLength: finalText.length,
+    previewActive,
+    uncertainChunks,
+    parseFallbackChunks,
+    contextChars: newContextChars ?? prevDiagnostics.contextChars ?? 0,
+  };
+}