@ephia/dova-sdk 1.0.0

package/dist/core/index.js

@@ -0,0 +1,1284 @@
+import {
+  pickEffectiveText
+} from "../chunk-7E43RY75.js";
+import {
+  initialConnectionState,
+  mapTransportStateToConnectionState
+} from "../chunk-RFQRV7ML.js";
+import {
+  LiveKitTransport,
+  TargetManager,
+  TranscriptApplier,
+  canTransition,
+  initialClientState,
+  transitionSessionStatus
+} from "../chunk-LXMCRXXF.js";
+import "../chunk-N7U5M3VZ.js";
+import {
+  documentOperationsToPlainText,
+  textToDocumentOperations
+} from "../chunk-VSLGR64U.js";
+
+// src/core/transport/MockTransport.ts
+import { PROTOCOL_VERSION, ephiaAudioEventSchema } from "ephia-protocol";
+var MockTransport = class {
+  _state = {
+    status: "idle",
+    localAudioPublished: false,
+    localAudioMuted: false,
+    reconnectCount: 0
+  };
+  _eventCallbacks = [];
+  _serverEventCallbacks = [];
+  _stateCallbacks = [];
+  _errorCallbacks = [];
+  _running = false;
+  _scriptTimer = null;
+  _options;
+  constructor(options = {}) {
+    this._options = options;
+  }
+  async connect(params) {
+    this._running = true;
+    this._setState({ status: "connecting", roomName: params.roomName });
+    await this._delay(this._options.latencyMs ?? 100);
+    if (!this._running) return;
+    this._setState({ status: "connected" });
+    if (this._options.autoEmitReady !== false) {
+      this._emit({
+        protocolVersion: PROTOCOL_VERSION,
+        eventId: "00000000-0000-4000-8000-000000000001",
+        sessionId: "mock-session",
+        type: "session.ready",
+        seq: 0,
+        timestampMs: Date.now(),
+        payload: { roomName: params.roomName }
+      });
+    }
+    this._runScript();
+  }
+  async disconnect(_reason) {
+    this._running = false;
+    if (this._scriptTimer) {
+      clearTimeout(this._scriptTimer);
+      this._scriptTimer = null;
+    }
+    this._setState({ status: "disconnected" });
+  }
+  async publishAudio(_track) {
+    this._setState({ localAudioPublished: true });
+  }
+  async unpublishAudio() {
+    this._setState({ localAudioPublished: false });
+  }
+  async sendMessage(message) {
+    if (message.type === "session.stop") {
+      this._emit({
+        protocolVersion: PROTOCOL_VERSION,
+        eventId: "00000000-0000-4000-8000-000000000002",
+        sessionId: "mock-session",
+        type: "session.closed",
+        seq: 999,
+        timestampMs: Date.now(),
+        payload: { reason: "user_stop" }
+      });
+    }
+  }
+  onEvent(callback) {
+    this._eventCallbacks.push(callback);
+    return () => {
+      this._eventCallbacks = this._eventCallbacks.filter((c) => c !== callback);
+    };
+  }
+  onServerEvent(callback) {
+    this._serverEventCallbacks.push(callback);
+    return () => {
+      this._serverEventCallbacks = this._serverEventCallbacks.filter((c) => c !== callback);
+    };
+  }
+  onTransportState(callback) {
+    this._stateCallbacks.push(callback);
+    return () => {
+      this._stateCallbacks = this._stateCallbacks.filter((c) => c !== callback);
+    };
+  }
+  onError(callback) {
+    this._errorCallbacks.push(callback);
+    return () => {
+      this._errorCallbacks = this._errorCallbacks.filter((c) => c !== callback);
+    };
+  }
+  getState() {
+    return { ...this._state };
+  }
+  async prepareConnection(_url, _token) {
+  }
+  async performRpc(method, payload, _timeout) {
+    if (method === "ephia.session.sync") {
+      const lastSeq = Number(payload?.lastSeq ?? 0);
+      return JSON.stringify({
+        status: "ok",
+        mode: "replay",
+        fromSeq: lastSeq,
+        toSeq: lastSeq,
+        events: []
+      });
+    }
+    const msgType = method.replace("ephia.", "");
+    await this.sendMessage({ type: msgType, payload });
+    return JSON.stringify({ status: "ok" });
+  }
+  /** Émet manuellement un event legacy (utile pour les tests). */
+  simulateEvent(event) {
+    this._emit(event);
+  }
+  /** Émet manuellement un event serveur V2 (utile pour les tests de TranscriptApplier). */
+  simulateServerEvent(event) {
+    this._serverEventCallbacks.forEach((cb) => cb(event));
+  }
+  /** Force manuellement un état transport (utile pour les tests). */
+  simulateState(state) {
+    this._setState(state);
+  }
+  // ------------------------------------------------------------------
+  // Internals
+  // ------------------------------------------------------------------
+  _setState(partial) {
+    this._state = { ...this._state, ...partial };
+    this._stateCallbacks.forEach((cb) => cb(this._state));
+  }
+  _emit(event) {
+    const parsed = ephiaAudioEventSchema.safeParse(event);
+    if (!parsed.success) {
+      console.warn(
+        "[MockTransport] invalid event schema (ignored):",
+        parsed.error.issues
+      );
+      return;
+    }
+    this._eventCallbacks.forEach((cb) => cb(parsed.data));
+  }
+  async _delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  _runScript() {
+    const script = this._options.script ?? [];
+    let index = 0;
+    const runNext = () => {
+      if (!this._running || index >= script.length) return;
+      const step = script[index];
+      index++;
+      this._scriptTimer = setTimeout(() => {
+        if (!this._running) return;
+        const baseEvent = {
+          protocolVersion: PROTOCOL_VERSION,
+          eventId: `00000000-0000-4000-8000-${String(index).padStart(12, "0")}`,
+          sessionId: "mock-session",
+          type: step.type,
+          seq: index,
+          timestampMs: Date.now(),
+          payload: step.payload ?? {}
+        };
+        this._emit(baseEvent);
+        runNext();
+      }, step.delayMs);
+    };
+    runNext();
+  }
+};
+
+// src/core/transcript/client-transcript.state.ts
+var initialTranscriptState = {
+  segments: [],
+  currentSegmentId: null,
+  documentText: ""
+};
+
+// src/core/transcript/transcript.assembler.ts
+function trimBoundarySpaces(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/^[ \t]+|[ \t]+$/g, "");
+}
+function joinWithSpacing(prev, next) {
+  if (!prev) return next;
+  if (!next) return prev;
+  const lastChar = prev.slice(-1);
+  const firstChar = next.charAt(0);
+  if (lastChar === " " && firstChar === " ") return prev + next.trimStart();
+  if (/\s/.test(lastChar) || /\s/.test(firstChar)) return prev + next;
+  if (/[,.;:!?)\]]/.test(firstChar)) return prev + next;
+  return prev + " " + next;
+}
+function assembleTranscript(chunks) {
+  const sorted = [...chunks].filter((c) => (c.status === "done" || c.finalizedText) && (c.text || c.finalizedText)).sort((a, b) => a.segmentSeq - b.segmentSeq);
+  if (sorted.length === 0) return "";
+  let result = "";
+  for (let i = 0; i < sorted.length; i++) {
+    const chunk = sorted[i];
+    let text = trimBoundarySpaces(chunk.text || chunk.finalizedText || "");
+    if (i === 0) {
+      result = text;
+      continue;
+    }
+    const prev = result;
+    const lastChar = prev.slice(-1);
+    const firstChar = text.charAt(0);
+    if (lastChar.match(/[.!?;,:\)]/) && firstChar.match(/[a-zA-ZÀ-ÿ0-9]/)) {
+      result = prev + " " + text;
+    } else if (/\s/.test(lastChar) && /\s/.test(firstChar)) {
+      result = prev + text.trimStart();
+    } else if (!/\s/.test(lastChar) && !/\s/.test(firstChar) && firstChar.match(/[a-zA-ZÀ-ÿ0-9]/)) {
+      result = prev + " " + text;
+    } else {
+      result = prev + text;
+    }
+  }
+  return result;
+}
+function assembleCommittedDocument(chunks, orderedSegmentIds) {
+  const sorted = [...orderedSegmentIds].map((id) => chunks[id]).filter((c) => !!c && c.status === "done").filter((c) => !c.mergedWith || Array.isArray(c.mergedWith)).sort((a, b) => a.segmentSeq - b.segmentSeq);
+  if (sorted.length === 0) return "";
+  let result = "";
+  for (let i = 0; i < sorted.length; i++) {
+    const chunk = sorted[i];
+    const text = trimBoundarySpaces(chunk.committedText ?? chunk.text ?? "");
+    if (!text) continue;
+    if (i === 0) {
+      result = text;
+      continue;
+    }
+    const prev = result;
+    const lastChar = prev.slice(-1);
+    const firstChar = text.charAt(0);
+    if (lastChar.match(/[.!?;,:\)]/) && firstChar.match(/[a-zA-ZÀ-ÿ0-9]/)) {
+      result = prev + " " + text;
+    } else if (/\s/.test(lastChar) && /\s/.test(firstChar)) {
+      result = prev + text.trimStart();
+    } else if (!/\s/.test(lastChar) && !/\s/.test(firstChar) && firstChar.match(/[a-zA-ZÀ-ÿ0-9]/)) {
+      result = prev + " " + text;
+    } else {
+      result = prev + text;
+    }
+  }
+  return result;
+}
+var PUNCTUATION_NO_SPACE = /* @__PURE__ */ new Set([",", ".", ";", ":", "!", "?", ")", "]", "}"]);
+function buildDisplayText(finalText, previewText, previewContinuesPreviousWord2 = false) {
+  if (!finalText && !previewText) return "";
+  if (!finalText) return previewText;
+  if (!previewText) return finalText;
+  const prev = finalText.replace(/[ \t]+$/, "");
+  const next = previewText.trimStart();
+  if (!next) return prev;
+  if (previewContinuesPreviousWord2) return prev + next;
+  const firstChar = next[0];
+  if (firstChar && PUNCTUATION_NO_SPACE.has(firstChar)) {
+    return prev + next;
+  }
+  if (prev.endsWith("\n")) return prev + next;
+  return prev + " " + next;
+}
+
+// src/core/transcript/client-transcript.reducer.ts
+function eventReducer(state, event) {
+  switch (event.type) {
+    case "transcript.preview":
+      return handlePartial(state, event);
+    case "transcript.preview.stable":
+      return handleStable(state, event);
+    case "transcript.final":
+      return handleFinal(state, event);
+    case "transcript.segment.ready":
+      return handleChunkFinalized(state, event);
+    case "transcript.segment.committed":
+      return handleChunkCommitted(state, event);
+    case "session.context.reset":
+      return handleSessionContextReset(state, event);
+    case "document.patch":
+      return handleDocumentPatch(state, event);
+    case "segment.absorbed": {
+      const absorbedId = event.payload.segmentId;
+      const absorbedInto = event.payload.absorbedInto;
+      const newSegments = state.segments.map(
+        (s) => s.segmentId === absorbedId ? {
+          ...s,
+          isCommitted: true,
+          committedText: null,
+          partialText: null,
+          finalText: null,
+          mergedWith: absorbedInto
+        } : s
+      );
+      return { ...state, segments: newSegments };
+    }
+    default:
+      return state;
+  }
+}
+function handlePartial(state, event) {
+  const existing = state.segments.find(
+    (s) => s.segmentId === event.payload.segmentId
+  );
+  if (existing) {
+    if (existing.isCommitted) {
+      return state;
+    }
+    if (event.payload.revision < existing.revision || event.payload.revision === existing.revision && event.payload.text === existing.partialText) {
+      return state;
+    }
+    return {
+      ...state,
+      segments: state.segments.map(
+        (s) => s.segmentId === event.payload.segmentId ? {
+          ...s,
+          partialText: event.payload.text,
+          revision: event.payload.revision,
+          stable: event.payload.stable ?? false
+        } : s
+      )
+    };
+  }
+  return {
+    ...state,
+    currentSegmentId: event.payload.segmentId,
+    segments: [
+      ...state.segments,
+      {
+        segmentId: event.payload.segmentId,
+        segmentSeq: event.payload.segmentSeq,
+        partialText: event.payload.text,
+        finalText: null,
+        committedText: null,
+        isFinalized: false,
+        isCommitted: false,
+        revision: event.payload.revision,
+        stable: event.payload.stable ?? false,
+        source: null,
+        mergedWith: null
+      }
+    ]
+  };
+}
+function handleStable(state, event) {
+  return {
+    ...state,
+    segments: state.segments.map(
+      (s) => s.segmentId === event.payload.segmentId ? { ...s, stable: true, partialText: event.payload.text } : s
+    )
+  };
+}
+function handleFinal(state, event) {
+  const existing = state.segments.find(
+    (s) => s.segmentId === event.payload.segmentId
+  );
+  if (!existing) {
+    return {
+      ...state,
+      segments: [
+        ...state.segments,
+        {
+          segmentId: event.payload.segmentId,
+          segmentSeq: event.payload.segmentSeq,
+          partialText: null,
+          finalText: event.payload.text,
+          committedText: null,
+          isFinalized: true,
+          isCommitted: false,
+          revision: 0,
+          stable: true,
+          source: null,
+          mergedWith: null
+        }
+      ]
+    };
+  }
+  return {
+    ...state,
+    segments: state.segments.map(
+      (s) => s.segmentId === event.payload.segmentId ? {
+        ...s,
+        finalText: event.payload.text,
+        isFinalized: true,
+        partialText: null
+      } : s
+    )
+  };
+}
+function handleChunkFinalized(state, event) {
+  const effectiveText = pickEffectiveText(event.payload);
+  const existing = state.segments.find(
+    (s) => s.segmentId === event.payload.segmentId
+  );
+  if (!existing) {
+    return {
+      ...state,
+      segments: [
+        ...state.segments,
+        {
+          segmentId: event.payload.segmentId,
+          segmentSeq: event.payload.segmentSeq,
+          partialText: null,
+          finalText: effectiveText,
+          committedText: null,
+          isFinalized: true,
+          isCommitted: false,
+          revision: 0,
+          stable: true,
+          source: event.payload.provider ?? null,
+          mergedWith: null
+        }
+      ]
+    };
+  }
+  return {
+    ...state,
+    segments: state.segments.map(
+      (s) => s.segmentId === event.payload.segmentId ? {
+        ...s,
+        finalText: effectiveText,
+        isFinalized: true
+      } : s
+    )
+  };
+}
+function handleChunkCommitted(state, event) {
+  const { segmentId, source, mergedWith } = event.payload;
+  const text = pickEffectiveText(event.payload);
+  const mergedIds = mergedWith ? Array.isArray(mergedWith) ? mergedWith : [mergedWith] : [];
+  const existing = state.segments.find(
+    (s) => s.segmentId === segmentId
+  );
+  let newSegments = existing ? state.segments.map(
+    (s) => s.segmentId === segmentId ? {
+      ...s,
+      committedText: text,
+      isCommitted: true,
+      partialText: null,
+      finalText: text,
+      source: source ?? null,
+      mergedWith: mergedIds.length > 0 ? mergedIds : null
+    } : s
+  ) : [
+    ...state.segments,
+    {
+      segmentId,
+      segmentSeq: event.payload.segmentSeq,
+      partialText: null,
+      finalText: text,
+      committedText: text,
+      isFinalized: true,
+      isCommitted: true,
+      revision: 0,
+      stable: true,
+      source: source ?? null,
+      mergedWith: mergedIds.length > 0 ? mergedIds : null
+    }
+  ];
+  for (const absorbedId of mergedIds) {
+    newSegments = newSegments.map(
+      (s) => s.segmentId === absorbedId ? {
+        ...s,
+        isCommitted: true,
+        committedText: null,
+        partialText: null,
+        finalText: null,
+        mergedWith: segmentId
+      } : s
+    );
+  }
+  const documentText = newSegments.filter(
+    (s) => s.isCommitted && s.committedText && typeof s.mergedWith !== "string"
+  ).map((s) => s.committedText).reduce((acc, text2) => joinWithSpacing(acc, text2), "");
+  return {
+    ...state,
+    segments: newSegments,
+    documentText
+  };
+}
+function handleSessionContextReset(state, event) {
+  const contextOnly = event.payload.contextOnly ?? false;
+  if (!contextOnly) {
+    return { ...initialTranscriptState };
+  }
+  const committedSegments = state.segments.filter((s) => s.isCommitted);
+  const documentText = committedSegments.filter(
+    (s) => s.committedText && typeof s.mergedWith !== "string"
+  ).map((s) => s.committedText).reduce((acc, t) => joinWithSpacing(acc, t), "");
+  return {
+    ...state,
+    segments: committedSegments,
+    currentSegmentId: null,
+    documentText
+  };
+}
+function handleDocumentPatch(state, event) {
+  let segments = [...state.segments];
+  for (const op of event.payload.ops) {
+    switch (op.type) {
+      case "merge": {
+        const fromSeg = segments.find((s) => s.segmentId === op.from);
+        const toSeg = segments.find((s) => s.segmentId === op.to);
+        if (fromSeg && toSeg) {
+          segments = segments.map(
+            (s) => s.segmentId === op.to ? { ...s, committedText: op.text ?? null, mergedWith: op.from ?? null } : s
+          );
+        }
+        break;
+      }
+      case "replace": {
+        segments = segments.map(
+          (s) => s.segmentId === op.blockId ? { ...s, committedText: op.text ?? null } : s
+        );
+        break;
+      }
+    }
+  }
+  const documentText = segments.filter(
+    (s) => s.isCommitted && s.committedText && typeof s.mergedWith !== "string"
+  ).map((s) => s.committedText).reduce((acc, text) => joinWithSpacing(acc, text), "");
+  return { ...state, segments, documentText };
+}
+
+// src/core/transcript/transcript.state.ts
+var initialLiveTranscriptState = {
+  sessionId: null,
+  status: "idle",
+  events: [],
+  chunks: {},
+  orderedSegmentIds: [],
+  finalText: "",
+  previewText: "",
+  displayText: "",
+  documentText: "",
+  lastEvent: null,
+  diagnostics: {
+    eventsCount: 0,
+    chunksCount: 0,
+    processingChunks: 0,
+    doneChunks: 0,
+    errorChunks: 0,
+    seqValid: true,
+    finalTextLength: 0,
+    previewActive: false,
+    uncertainChunks: 0,
+    parseFallbackChunks: 0,
+    contextChars: 0
+  },
+  error: null,
+  spinnerTick: 0
+};
+
+// src/core/transcript/transcript.reducer.ts
+function liveTranscriptReducer(state, action) {
+  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 = {};
+    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;
+  const lastSeq = state.lastEvent?.seq;
+  const isFirstEvent = lastSeq === void 0;
+  const isConsecutive = lastSeq !== void 0 && event.seq === lastSeq + 1;
+  const isRecoveredFromSync = !state.diagnostics.seqValid && isConsecutive;
+  const seqValid = (state.diagnostics.seqValid || isRecoveredFromSync) && (isFirstEvent || isConsecutive);
+  const base = {
+    ...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.payload.contextOnly ?? false;
+      if (!contextOnly) {
+        const finalizedBeforeReset = {};
+        for (const [id, chunk] of Object.entries(base.chunks)) {
+          if (chunk.status === "done") finalizedBeforeReset[id] = true;
+        }
+        return { ...initialLiveTranscriptState, finalizedBeforeReset };
+      }
+      const newChunks = {};
+      const newOrdered = [];
+      for (const id of base.orderedSegmentIds) {
+        const chunk = base.chunks[id];
+        if (chunk && (chunk.committedText || chunk.status === "done")) {
+          newChunks[id] = { ...chunk, previewText: void 0 };
+          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 = {
+        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 = { ...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 = {
+        ...base.chunks,
+        [event.payload.segmentId]: {
+          ...existing,
+          status: "processing",
+          durationMs: event.payload.durationMs
+        }
+      };
+      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) {
+        if (existing.status === "done") {
+          return base;
+        }
+        if (event.payload.revision <= existing.revision) {
+          return base;
+        }
+        const newChunks2 = {
+          ...base.chunks,
+          [event.payload.segmentId]: {
+            ...existing,
+            status: "preview",
+            previewText: partialText,
+            previewContinuesPreviousWord: false,
+            stablePrefix: event.payload.text,
+            revision: event.payload.revision
+          }
+        };
+        const previewText2 = buildPreviewText(newChunks2, base.orderedSegmentIds, base.spinnerTick);
+        return {
+          ...base,
+          chunks: newChunks2,
+          previewText: previewText2,
+          displayText: buildLiveDisplayText(newChunks2, base.orderedSegmentIds, base.finalText, previewText2),
+          diagnostics: computeDiagnostics(newChunks2, base.orderedSegmentIds, base.diagnostics, base.finalText, previewText2)
+        };
+      }
+      const chunk = {
+        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 = { ...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 = { ...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 = {
+        ...base.chunks,
+        [absorbedId]: {
+          ...existing,
+          status: "done",
+          text: "",
+          committedText: "",
+          previewText: void 0,
+          mergedWith: event.payload.absorbedInto
+        }
+      };
+      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 = {
+        ...base.chunks,
+        [event.payload.segmentId]: {
+          ...existing,
+          status: "preview",
+          previewText: event.payload.text,
+          previewContinuesPreviousWord: false,
+          stablePrefix: event.payload.text,
+          revision: event.payload.revision
+        }
+      };
+      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;
+      let ordered = base.orderedSegmentIds;
+      const meta = event.meta || {};
+      const chunkUpdate = {
+        status: "done",
+        text: event.payload.text,
+        previewText: void 0,
+        provider: event.payload.provider,
+        uncertain: meta.uncertain,
+        reason: meta.reason ? meta.reason : void 0,
+        reasonCodes: meta.reasonCodes,
+        parseFallback: meta.parseFallback
+      };
+      if (!existing) {
+        const chunk = {
+          segmentId: event.payload.segmentId,
+          segmentSeq: event.payload.segmentSeq,
+          revision: 0,
+          ...chunkUpdate
+        };
+        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
+          }
+        };
+      }
+      const finalText = assembleTranscript(Object.values(newChunks));
+      const previewText = buildPreviewText(newChunks, ordered, base.spinnerTick);
+      const latency = event.meta?.latencyMs;
+      const contextChars = event.meta?.contextChars;
+      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 = {
+        ...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: void 0
+        }
+      };
+      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 = event.payload.mergedWith ? Array.isArray(event.payload.mergedWith) ? event.payload.mergedWith : [event.payload.mergedWith] : [];
+      let newChunks = {
+        ...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 : void 0,
+          previewText: void 0,
+          // 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
+        }
+      };
+      for (const absorbedId of mergedIds) {
+        const absorbed = newChunks[absorbedId];
+        if (absorbed) {
+          newChunks = {
+            ...newChunks,
+            [absorbedId]: {
+              ...absorbed,
+              status: "done",
+              text: "",
+              committedText: "",
+              previewText: void 0,
+              mergedWith: event.payload.segmentId
+            }
+          };
+        }
+      }
+      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 = {
+        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.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
+            }
+          };
+        } 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
+            }
+          };
+        }
+      }
+      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 = {
+        ...base.chunks,
+        [event.payload.segmentId]: {
+          ...existing,
+          status: existing.status === "done" || existing.status === "preview" ? existing.status : "done",
+          durationMs: event.payload.durationMs,
+          provider: event.payload.provider
+        }
+      };
+      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 = {
+        ...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 = {
+        ...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
+        }
+      };
+      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;
+  }
+}
+var SPINNER_CHARS = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function buildPreviewText(chunks, orderedSegmentIds, spinnerTick = 0) {
+  const sorted = [...orderedSegmentIds].map((id) => chunks[id]).filter((c) => !!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, orderedSegmentIds) {
+  const sorted = [...orderedSegmentIds].map((id) => chunks[id]).filter((c) => !!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, orderedSegmentIds, finalText, previewText) {
+  return buildDisplayText(
+    finalText,
+    previewText,
+    previewContinuesPreviousWord(chunks, orderedSegmentIds)
+  );
+}
+function computeDiagnostics(chunks, orderedSegmentIds, prevDiagnostics, finalText, previewText, newLatencyMs, newContextChars, newProvider) {
+  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;
+  let averageLatencyMs = prevDiagnostics.averageLatencyMs;
+  let lastLatencyMs = prevDiagnostics.lastLatencyMs;
+  if (newLatencyMs !== void 0) {
+    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
+  };
+}
+
+// src/core/targets/EditorContextCollector.ts
+var EditorContextCollector = class {
+  maxContextChars;
+  constructor(options = {}) {
+    this.maxContextChars = options.maxContextChars ?? 600;
+  }
+  collect(target) {
+    const text = target.binding?.getText?.() ?? "";
+    const selection = target.binding?.getSelection?.() ?? null;
+    const cursorOffset = this.resolveCursorOffset(target.binding, text, selection);
+    const leftRaw = text.slice(0, cursorOffset);
+    const rightRaw = text.slice(cursorOffset);
+    return {
+      targetId: target.id,
+      documentEmpty: text.trim().length === 0,
+      insertionMode: this.resolveInsertionMode(text, cursorOffset, selection),
+      leftContext: leftRaw.slice(-this.maxContextChars),
+      rightContext: rightRaw.slice(0, this.maxContextChars),
+      selectedText: selection?.text || null,
+      cursorOffset
+    };
+  }
+  resolveCursorOffset(binding, text, selection) {
+    if (selection?.range) return clamp(selection.range.start, 0, text.length);
+    const cursor = binding?.getCursorOffset?.();
+    if (typeof cursor === "number") return clamp(cursor, 0, text.length);
+    return text.length;
+  }
+  resolveInsertionMode(text, cursorOffset, selection) {
+    if (selection?.text) return "replace_selection";
+    if (text.trim().length === 0) return "document_start";
+    if (cursorOffset >= text.length) return "append";
+    return "middle_of_sentence";
+  }
+};
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+export {
+  EditorContextCollector,
+  LiveKitTransport,
+  MockTransport,
+  TargetManager,
+  TranscriptApplier,
+  assembleCommittedDocument,
+  assembleTranscript,
+  buildDisplayText,
+  canTransition,
+  documentOperationsToPlainText,
+  eventReducer,
+  initialClientState,
+  initialConnectionState,
+  initialLiveTranscriptState,
+  initialTranscriptState,
+  liveTranscriptReducer,
+  mapTransportStateToConnectionState,
+  textToDocumentOperations,
+  transitionSessionStatus
+};
+//# sourceMappingURL=index.js.map