@ephia/dova-sdk 1.0.0

package/dist/core/bindings/index.js

@@ -0,0 +1,1025 @@
+import {
+  NativeBinding
+} from "../../chunk-A5UEXJ5R.js";
+import {
+  EphiaV2CommittedMark,
+  EphiaV2PreviewMark,
+  TiptapBinding
+} from "../../chunk-W2ZP674X.js";
+import {
+  textToDocumentOperations
+} from "../../chunk-VSLGR64U.js";
+
+// src/core/bindings/TargetBinding.ts
+function pickJoiner(before, next) {
+  if (!before || !next) return "";
+  const lastChar = before[before.length - 1];
+  const firstChar = next[0];
+  if (/\s/.test(lastChar)) return "";
+  if (/\s/.test(firstChar)) return "";
+  if (/^[,.;:!?)\]]/.test(firstChar)) return "";
+  if (/[(\[]/.test(lastChar)) return "";
+  return " ";
+}
+
+// src/core/bindings/targets/tiptap.binding.ts
+import { Mark } from "@tiptap/core";
+import { Plugin, PluginKey, TextSelection } from "@tiptap/pm/state";
+
+// src/shared/store/document-store.ts
+import { create } from "zustand";
+import { subscribeWithSelector } from "zustand/middleware";
+var documentStore = create()(
+  subscribeWithSelector((set) => ({
+    content: "",
+    segments: [],
+    selectedText: null,
+    cursorSection: null,
+    syncFromEditor: (content, segments) => set({ content, segments }),
+    setSelection: (text, section) => set({ selectedText: text, cursorSection: section })
+  }))
+);
+
+// src/core/text-processing/overlap.ts
+var TOKEN_RE = /\S+/g;
+var PUNCT_EDGE_RE = /^[.,;:!?"'«»“”‘’()[\]{}]+|[.,;:!?"'«»“”‘’()[\]{}]+$/g;
+var ELISION_RE = /^(?:qu['’]|[dlsnmtcj]['’])/i;
+function normalizeToken(token) {
+  return token.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(PUNCT_EDGE_RE, "").replace(ELISION_RE, "");
+}
+function tokenize(text) {
+  const out = [];
+  for (const match of text.matchAll(TOKEN_RE)) {
+    const raw = match[0];
+    const start = match.index ?? 0;
+    const norm = normalizeToken(raw);
+    if (!norm) continue;
+    out.push({ raw, norm, start, end: start + raw.length });
+  }
+  return out;
+}
+function prefixCharsForNormalizedPrefix(raw, normalizedPrefix) {
+  if (!normalizedPrefix) return 0;
+  for (let i = 1; i <= raw.length; i++) {
+    const norm = normalizeToken(raw.slice(0, i));
+    if (norm.length >= normalizedPrefix.length && norm.startsWith(normalizedPrefix)) {
+      return i;
+    }
+  }
+  return 0;
+}
+function stripLeadingOverlapFromTextWithInfo(before, incoming, maxTokens = 24) {
+  const left = tokenize(before);
+  const right = tokenize(incoming);
+  if (!left.length || !right.length) {
+    return { text: incoming, partialWord: false, overlapTokens: 0 };
+  }
+  const limit = Math.min(left.length, right.length, maxTokens);
+  for (let size = limit; size > 0; size--) {
+    const leftSlice = left.slice(left.length - size);
+    const rightSlice = right.slice(0, size);
+    let partialLast = false;
+    let matches = true;
+    for (let i = 0; i < size; i++) {
+      const l = leftSlice[i].norm;
+      const r = rightSlice[i].norm;
+      if (l === r) continue;
+      if (i === size - 1 && l.length >= 3 && r.startsWith(l)) {
+        partialLast = true;
+        continue;
+      }
+      matches = false;
+      break;
+    }
+    if (!matches) continue;
+    const lastRight = rightSlice[rightSlice.length - 1];
+    let cut = lastRight.end;
+    if (partialLast) {
+      cut = lastRight.start + prefixCharsForNormalizedPrefix(lastRight.raw, leftSlice[size - 1].norm);
+    }
+    return {
+      text: incoming.slice(cut).replace(/^[ \t]+/, ""),
+      partialWord: partialLast,
+      overlapTokens: size
+    };
+  }
+  return { text: incoming, partialWord: false, overlapTokens: 0 };
+}
+
+// src/core/bindings/targets/tiptap.binding.ts
+var ephiaTiptapKey = new PluginKey("ephiaTiptap");
+function createEphiaTiptapPlugin() {
+  return new Plugin({
+    key: ephiaTiptapKey,
+    state: {
+      init() {
+        return { segments: {}, anchor: null };
+      },
+      apply(tr, value) {
+        const docSize = tr.doc.content.size;
+        const mappedSegments = {};
+        for (const [id, pos] of Object.entries(value.segments)) {
+          const mappedFrom = Math.min(Math.max(tr.mapping.map(pos.from), 0), docSize);
+          const mappedTo = Math.min(Math.max(tr.mapping.map(pos.to), 0), docSize);
+          if (mappedFrom < 0 || mappedTo < 0 || mappedFrom > docSize || mappedTo > docSize || mappedFrom > mappedTo) {
+            continue;
+          }
+          mappedSegments[id] = {
+            from: mappedFrom,
+            to: mappedTo,
+            revision: pos.revision,
+            joinerLength: pos.joinerLength
+          };
+        }
+        let mappedAnchor = value.anchor ? {
+          initialStart: Math.min(Math.max(tr.mapping.map(value.anchor.initialStart), 0), docSize),
+          initialEnd: Math.min(Math.max(tr.mapping.map(value.anchor.initialEnd), 0), docSize),
+          hadSelection: value.anchor.hadSelection,
+          end: Math.min(Math.max(tr.mapping.map(value.anchor.end), 0), docSize),
+          selectionPendingDelete: value.anchor.selectionPendingDelete
+        } : null;
+        if (mappedAnchor && (mappedAnchor.initialStart > docSize || mappedAnchor.initialEnd > docSize || mappedAnchor.end > docSize)) {
+          mappedAnchor = null;
+        }
+        const meta = tr.getMeta(ephiaTiptapKey);
+        if (meta) {
+          if (meta.segments) {
+            for (const [id, pos] of Object.entries(meta.segments)) {
+              if (pos === null) delete mappedSegments[id];
+              else mappedSegments[id] = pos;
+            }
+          }
+          if (meta.anchor) {
+            if (meta.anchor.kind === "clear") {
+              mappedAnchor = null;
+            } else if (meta.anchor.kind === "set") {
+              mappedAnchor = meta.anchor.value;
+            } else if (meta.anchor.kind === "patch" && mappedAnchor) {
+              mappedAnchor = {
+                ...mappedAnchor,
+                end: meta.anchor.end ?? mappedAnchor.end
+              };
+            }
+          }
+        }
+        return { segments: mappedSegments, anchor: mappedAnchor };
+      }
+    }
+  });
+}
+function getPluginState(editor) {
+  return ephiaTiptapKey.getState(editor.state) ?? { segments: {}, anchor: null };
+}
+function setSegmentMeta(tr, segmentId, pos) {
+  const current = tr.getMeta(ephiaTiptapKey) ?? {};
+  current.segments = { ...current.segments ?? {}, [segmentId]: pos };
+  tr.setMeta(ephiaTiptapKey, current);
+}
+function setAnchorMeta(tr, update) {
+  const current = tr.getMeta(ephiaTiptapKey) ?? {};
+  current.anchor = update;
+  tr.setMeta(ephiaTiptapKey, current);
+}
+function getCommonPrefix(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i++;
+  return i;
+}
+function getCommonSuffix(a, b, prefixLen) {
+  let i = 0;
+  while (i < a.length - prefixLen && i < b.length - prefixLen && a[a.length - 1 - i] === b[b.length - 1 - i]) {
+    i++;
+  }
+  return i;
+}
+var SCROLL_THROTTLE_MS = 300;
+var USER_SCROLL_QUIET_MS = 500;
+var PARTIAL_DEBOUNCE_MS = 60;
+var SKIP_STORE_SYNC_META = "ephiaSkipStoreSync";
+function isPosVisible(editor, pos) {
+  try {
+    const coords = editor.view.coordsAtPos(pos);
+    const rect = editor.view.dom.getBoundingClientRect();
+    return coords.top >= rect.top && coords.bottom <= rect.bottom;
+  } catch {
+    return true;
+  }
+}
+function textBetweenWithHardBreaks(doc, from, to, blockSeparator) {
+  return doc.textBetween(from, to, blockSeparator, "\n");
+}
+function getTextFromDoc(doc) {
+  return textBetweenWithHardBreaks(doc, 0, doc.content.size, "\n\n");
+}
+function resolveInsertPosition(editor, position) {
+  if (typeof position === "number") {
+    return Math.min(Math.max(position, 0), editor.state.doc.content.size);
+  }
+  if (position === "start") return 1;
+  if (position === "end") return Math.max(1, editor.state.doc.content.size - 1);
+  return editor.state.selection.from;
+}
+function insertOperationsAt(editor, tr, pos, operations, mark) {
+  let cursor = pos;
+  const fallbackSteps = [];
+  const hardBreak = editor.schema.nodes.hardBreak;
+  const marks = mark ? [mark] : [];
+  const insertText = (text) => {
+    if (!text) return;
+    const node = editor.schema.text(text, marks);
+    tr.insert(cursor, node);
+    cursor += node.nodeSize;
+  };
+  const insertHardBreakOrFallback = () => {
+    if (hardBreak) {
+      const node2 = hardBreak.create();
+      tr.insert(cursor, node2);
+      cursor += node2.nodeSize;
+      return;
+    }
+    const node = editor.schema.text("\n", marks);
+    tr.insert(cursor, node);
+    cursor += node.nodeSize;
+    fallbackSteps.push("fallback_plain_newline_no_hardbreak_node");
+  };
+  for (const operation of operations) {
+    if (operation.type === "insert_text" || operation.type === "insert") {
+      insertText(operation.text);
+    } else if (operation.type === "line_break") {
+      insertHardBreakOrFallback();
+    } else if (operation.type === "paragraph_break") {
+      insertHardBreakOrFallback();
+      insertHardBreakOrFallback();
+    }
+  }
+  return { from: pos, to: cursor, fallbackSteps };
+}
+function measureOperationsSize(editor, operations) {
+  const hardBreak = editor.schema.nodes.hardBreak;
+  let size = 0;
+  for (const operation of operations) {
+    if (operation.type === "insert_text" || operation.type === "insert") {
+      if (operation.text) {
+        size += editor.schema.text(operation.text).nodeSize;
+      }
+    } else if (operation.type === "line_break") {
+      size += hardBreak ? hardBreak.create().nodeSize : editor.schema.text("\n").nodeSize;
+    } else if (operation.type === "paragraph_break") {
+      const breakSize = hardBreak ? hardBreak.create().nodeSize : editor.schema.text("\n").nodeSize;
+      size += breakSize * 2;
+    }
+  }
+  return size;
+}
+function measureTextAsOperationsSize(editor, text) {
+  return measureOperationsSize(editor, textToDocumentOperations(text));
+}
+function parseSegmentsFromDoc(doc) {
+  const segments = [];
+  let currentSection = null;
+  let offset = 0;
+  doc.descendants((node, _pos) => {
+    if (node.type.name === "heading") {
+      if (currentSection) currentSection.end = offset;
+      currentSection = {
+        id: `sec_${segments.length}`,
+        title: node.textContent,
+        text: "",
+        level: node.attrs.level || 1,
+        start: offset,
+        end: offset
+      };
+      segments.push(currentSection);
+    } else if (currentSection && node.isTextblock) {
+      currentSection.text += (currentSection.text ? "\n" : "") + node.textContent;
+    }
+    offset += node.nodeSize;
+    return true;
+  });
+  if (currentSection) {
+    currentSection.end = offset;
+  }
+  return segments;
+}
+function parseSegmentsFromEditor(editor) {
+  return parseSegmentsFromDoc(editor.state.doc);
+}
+function toPublicAnchor(anchor) {
+  return {
+    initialStart: anchor.initialStart,
+    initialEnd: anchor.initialEnd,
+    hadSelection: anchor.hadSelection,
+    end: anchor.end,
+    selectionPendingDelete: anchor.selectionPendingDelete
+  };
+}
+var EphiaPreviewMark = Mark.create({
+  name: "ephiaPreview",
+  parseHTML() {
+    return [{ tag: "span[data-ephia-streaming]" }];
+  },
+  renderHTML() {
+    return [
+      "span",
+      {
+        "data-ephia-streaming": "true",
+        class: "ephia-text--streaming"
+      },
+      0
+    ];
+  }
+});
+var EphiaCommittedMark = Mark.create({
+  name: "ephiaCommitted",
+  parseHTML() {
+    return [{ tag: "span[data-ephia-committed]" }];
+  },
+  renderHTML() {
+    return [
+      "span",
+      {
+        "data-ephia-committed": "true",
+        class: "ephia-text--committed"
+      },
+      0
+    ];
+  }
+});
+var EphiaRevisedMark = Mark.create({
+  name: "ephiaRevised",
+  parseHTML() {
+    return [{ tag: "span[data-ephia-revised]" }];
+  },
+  renderHTML() {
+    return [
+      "span",
+      {
+        "data-ephia-revised": "true",
+        class: "ephia-text--revised"
+      },
+      0
+    ];
+  }
+});
+var EphiaPlaceholderMark = Mark.create({
+  name: "ephiaPlaceholder",
+  parseHTML() {
+    return [{ tag: "span[data-ephia-placeholder]" }];
+  },
+  renderHTML() {
+    return [
+      "span",
+      {
+        "data-ephia-placeholder": "true",
+        class: "ephia-text--placeholder"
+      },
+      0
+    ];
+  }
+});
+function createTiptapBinding(editor, wrapperEl) {
+  const plugin = createEphiaTiptapPlugin();
+  editor.registerPlugin(plugin);
+  let lastScrollTime = 0;
+  let lastUserScrollTime = 0;
+  let lastDictationEnd = null;
+  let cachedSectionsDoc = editor.state.doc;
+  let cachedSections = parseSegmentsFromEditor(editor);
+  const markUserScroll = () => {
+    lastUserScrollTime = Date.now();
+  };
+  const maybeScrollIntoView = (tr, ed, pos) => {
+    const now = Date.now();
+    if (now - lastUserScrollTime < USER_SCROLL_QUIET_MS) return;
+    if (now - lastScrollTime < SCROLL_THROTTLE_MS) return;
+    if (isPosVisible(ed, pos)) return;
+    tr.scrollIntoView();
+    lastScrollTime = now;
+  };
+  editor.view.dom.addEventListener("scroll", markUserScroll, { passive: true });
+  const committedTimeouts = /* @__PURE__ */ new Map();
+  const knownSegmentIds = /* @__PURE__ */ new Set();
+  const clearCommittedTimeout = (segmentId) => {
+    const timeoutId = committedTimeouts.get(segmentId);
+    if (timeoutId !== void 0) {
+      window.clearTimeout(timeoutId);
+      committedTimeouts.delete(segmentId);
+    }
+  };
+  let syncRaf = null;
+  let pendingSyncDoc = null;
+  const getCachedSections = () => cachedSections;
+  const syncToStore = (event) => {
+    if (event?.transaction?.getMeta(SKIP_STORE_SYNC_META)) return;
+    pendingSyncDoc = event?.transaction?.doc ?? editor.state.doc;
+    if (syncRaf !== null) return;
+    syncRaf = (typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : (cb) => setTimeout(cb, 16))(
+      () => {
+        syncRaf = null;
+        const doc = pendingSyncDoc ?? editor.state.doc;
+        pendingSyncDoc = null;
+        const text = getTextFromDoc(doc);
+        cachedSectionsDoc = doc;
+        cachedSections = parseSegmentsFromDoc(doc);
+        const segments = cachedSections;
+        documentStore.getState().syncFromEditor(text, segments);
+      }
+    );
+  };
+  const syncSelection = () => {
+    const { from, to } = editor.state.selection;
+    const selectedText = from !== to ? textBetweenWithHardBreaks(editor.state.doc, from, to) : null;
+    if (cachedSectionsDoc !== editor.state.doc && cachedSections.length === 0) {
+      cachedSectionsDoc = editor.state.doc;
+      cachedSections = parseSegmentsFromEditor(editor);
+    }
+    const cursor = editor.state.selection.from;
+    const section = getCachedSections().find((seg) => cursor >= seg.start && cursor <= seg.end)?.title ?? null;
+    documentStore.getState().setSelection(selectedText, section);
+  };
+  editor.on("update", syncToStore);
+  editor.on("selectionUpdate", syncSelection);
+  syncToStore();
+  syncSelection();
+  const _applyPartial = (segmentId, text, revision) => {
+    const state = getPluginState(editor);
+    const existing = state.segments[segmentId];
+    const isPlaceholder = segmentId === "ephia-startup-placeholder";
+    const mark = isPlaceholder ? editor.schema.marks.ephiaPlaceholder?.create() : editor.schema.marks.ephiaPreview?.create();
+    if (existing) {
+      if (revision <= existing.revision) return;
+      const oldText = textBetweenWithHardBreaks(editor.state.doc, existing.from, existing.to);
+      if (oldText === text) return;
+      const tr = editor.state.tr;
+      tr.setMeta("addToHistory", false);
+      tr.setMeta(SKIP_STORE_SYNC_META, true);
+      const prefixLen = getCommonPrefix(oldText, text);
+      const suffixLen = getCommonSuffix(oldText, text, prefixLen);
+      if (prefixLen > 0 || suffixLen > 0) {
+        const deleteFrom = existing.from + prefixLen;
+        const deleteTo = existing.to - suffixLen;
+        const insertText = text.slice(prefixLen, text.length - suffixLen);
+        if (deleteFrom < deleteTo) tr.delete(deleteFrom, deleteTo);
+        if (insertText) {
+          insertOperationsAt(
+            editor,
+            tr,
+            deleteFrom,
+            textToDocumentOperations(insertText),
+            mark
+          );
+        }
+        const newEnd = existing.from + measureTextAsOperationsSize(editor, text);
+        setSegmentMeta(tr, segmentId, {
+          from: existing.from,
+          to: newEnd,
+          revision,
+          joinerLength: existing.joinerLength
+        });
+      } else {
+        tr.delete(existing.from, existing.to);
+        const inserted = insertOperationsAt(
+          editor,
+          tr,
+          existing.from,
+          textToDocumentOperations(text),
+          mark
+        );
+        setSegmentMeta(tr, segmentId, {
+          from: existing.from,
+          to: inserted.to,
+          revision,
+          joinerLength: existing.joinerLength
+        });
+      }
+      maybeScrollIntoView(tr, editor, existing.to);
+      editor.view.dispatch(tr);
+      knownSegmentIds.add(segmentId);
+    } else {
+      if (!state.anchor) {
+        return;
+      }
+      const tr = editor.state.tr;
+      tr.setMeta("addToHistory", false);
+      tr.setMeta(SKIP_STORE_SYNC_META, true);
+      let pos = state.anchor.end;
+      if (state.anchor.selectionPendingDelete && state.anchor.initialEnd > state.anchor.initialStart) {
+        tr.delete(state.anchor.initialStart, state.anchor.initialEnd);
+        pos = state.anchor.initialStart;
+        setAnchorMeta(tr, {
+          kind: "set",
+          value: {
+            ...state.anchor,
+            selectionPendingDelete: false,
+            initialEnd: state.anchor.initialStart,
+            end: state.anchor.initialStart
+          }
+        });
+      }
+      const before = textBetweenWithHardBreaks(editor.state.doc, Math.max(0, pos - 500), pos);
+      const overlap = stripLeadingOverlapFromTextWithInfo(before, text);
+      text = overlap.text;
+      if (!text) return;
+      const joiner = overlap.partialWord ? "" : pickJoiner(before, text);
+      const fullText = joiner + text;
+      const inserted = insertOperationsAt(
+        editor,
+        tr,
+        pos,
+        textToDocumentOperations(fullText),
+        mark
+      );
+      const segFrom = pos + measureTextAsOperationsSize(editor, joiner);
+      const segTo = inserted.to;
+      setSegmentMeta(tr, segmentId, { from: segFrom, to: segTo, revision, joinerLength: joiner.length });
+      setAnchorMeta(tr, { kind: "patch", end: segTo });
+      maybeScrollIntoView(tr, editor, segTo);
+      editor.view.dispatch(tr);
+      knownSegmentIds.add(segmentId);
+    }
+  };
+  const pendingPartials = /* @__PURE__ */ new Map();
+  const flushPendingPartial = (segmentId) => {
+    const pending = pendingPartials.get(segmentId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    pendingPartials.delete(segmentId);
+    _applyPartial(segmentId, pending.text, pending.revision);
+  };
+  const cancelPendingPartial = (segmentId) => {
+    const pending = pendingPartials.get(segmentId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    pendingPartials.delete(segmentId);
+  };
+  const cancelAllPendingPartials = () => {
+    for (const { timer } of pendingPartials.values()) {
+      clearTimeout(timer);
+    }
+    pendingPartials.clear();
+  };
+  const schedulePartial = (segmentId, text, revision) => {
+    const existing = pendingPartials.get(segmentId);
+    if (existing) {
+      if (revision < existing.revision) return;
+      clearTimeout(existing.timer);
+    }
+    const timer = setTimeout(() => flushPendingPartial(segmentId), PARTIAL_DEBOUNCE_MS);
+    pendingPartials.set(segmentId, { text, revision, timer });
+  };
+  const trimOverlappingPreviewSegments = (tr, state, committedSegmentId, committedText) => {
+    const previewMark = editor.schema.marks.ephiaPreview?.create();
+    for (const [otherId, other] of Object.entries(state.segments)) {
+      if (otherId === committedSegmentId || other.revision === Number.MAX_SAFE_INTEGER) {
+        continue;
+      }
+      const previewText = textBetweenWithHardBreaks(editor.state.doc, other.from, other.to);
+      const overlap = stripLeadingOverlapFromTextWithInfo(committedText, previewText);
+      const trimmed = overlap.text;
+      if (trimmed === previewText) continue;
+      let from = tr.mapping.map(other.from);
+      let to = tr.mapping.map(other.to);
+      if (overlap.partialWord && from > 0 && /\s/.test(textBetweenWithHardBreaks(tr.doc, from - 1, from))) {
+        tr.delete(from - 1, from);
+        from -= 1;
+        to -= 1;
+      }
+      if (trimmed) {
+        tr.delete(from, to);
+        const inserted = insertOperationsAt(
+          editor,
+          tr,
+          from,
+          textToDocumentOperations(trimmed),
+          previewMark
+        );
+        setSegmentMeta(tr, otherId, {
+          from,
+          to: inserted.to,
+          revision: other.revision + 1
+        });
+      } else {
+        tr.delete(from, to);
+        setSegmentMeta(tr, otherId, null);
+      }
+    }
+  };
+  return {
+    kind: "tiptap",
+    attach() {
+    },
+    detach() {
+      editor.view.dom.removeEventListener("scroll", markUserScroll);
+      editor.unregisterPlugin(ephiaTiptapKey);
+      editor.off("update", syncToStore);
+      editor.off("selectionUpdate", syncSelection);
+      cancelAllPendingPartials();
+      if (syncRaf !== null && typeof cancelAnimationFrame !== "undefined") {
+        cancelAnimationFrame(syncRaf);
+        syncRaf = null;
+      }
+      for (const timeoutId of committedTimeouts.values()) {
+        clearTimeout(timeoutId);
+      }
+      committedTimeouts.clear();
+      knownSegmentIds.clear();
+    },
+    // ─── Session lifecycle ──────────────────────────────────────────────────
+    beginSession(opts = {}) {
+      const replaceSelection = opts.replaceSelection ?? true;
+      const isFocused = editor.isFocused;
+      let from = editor.state.selection.from;
+      let to = editor.state.selection.to;
+      if (!isFocused && from === to) {
+        const docSize = editor.state.doc.content.size;
+        const resumePos = lastDictationEnd !== null ? Math.min(lastDictationEnd, Math.max(1, docSize - 1)) : Math.max(1, docSize - 1);
+        from = resumePos;
+        to = resumePos;
+      }
+      const hadSelection = from !== to;
+      const selectionPendingDelete = hadSelection && replaceSelection;
+      const tr = editor.state.tr;
+      tr.setMeta("addToHistory", false);
+      tr.setMeta(SKIP_STORE_SYNC_META, true);
+      const anchorValue = {
+        initialStart: from,
+        initialEnd: to,
+        // conserver la vraie fin de sélection
+        hadSelection,
+        end: from,
+        // point d'insertion = début de sélection
+        selectionPendingDelete
+      };
+      try {
+        const resolved = tr.doc.resolve(from);
+        tr.setSelection(TextSelection.near(resolved));
+      } catch {
+      }
+      setAnchorMeta(tr, { kind: "set", value: anchorValue });
+      editor.view.dispatch(tr);
+      if (!isFocused) {
+        try {
+          editor.view.focus();
+        } catch {
+        }
+      }
+      return toPublicAnchor(anchorValue);
+    },
+    endSession() {
+      cancelAllPendingPartials();
+      const anchor = getPluginState(editor).anchor;
+      if (anchor) lastDictationEnd = anchor.end;
+      const tr = editor.state.tr;
+      tr.setMeta("addToHistory", false);
+      tr.setMeta(SKIP_STORE_SYNC_META, true);
+      setAnchorMeta(tr, { kind: "clear" });
+      const committedMark = editor.schema.marks.ephiaCommitted;
+      if (committedMark) {
+        tr.removeMark(0, editor.state.doc.content.size, committedMark);
+      }
+      editor.view.dispatch(tr);
+      syncToStore();
+    },
+    getSessionAnchor() {
+      const anchor = getPluginState(editor).anchor;
+      return anchor ? toPublicAnchor(anchor) : null;
+    },
+    getCursorRect() {
+      const anchor = getPluginState(editor).anchor;
+      const pos = anchor ? anchor.end : editor.state.selection.from;
+      try {
+        const coords = editor.view.coordsAtPos(pos);
+        return new DOMRect(
+          coords.left,
+          coords.top,
+          coords.right - coords.left,
+          coords.bottom - coords.top
+        );
+      } catch {
+        const dom = editor.view.dom;
+        return dom.getBoundingClientRect();
+      }
+    },
+    getRangeRect(start, end) {
+      if (end <= start) return null;
+      try {
+        const a = editor.view.coordsAtPos(start);
+        const b = editor.view.coordsAtPos(end);
+        const top = Math.min(a.top, b.top);
+        const bottom = Math.max(a.bottom, b.bottom);
+        const left = Math.min(a.left, b.left);
+        const right = Math.max(a.right, b.right);
+        return new DOMRect(left, top, Math.max(2, right - left), bottom - top);
+      } catch {
+        return null;
+      }
+    },
+    // ─── Streaming insertion ────────────────────────────────────────────────
+    insertPartial(segmentId, text, revision) {
+      schedulePartial(segmentId, text, revision);
+    },
+    commitFinal(segmentId, text, options) {
+      clearCommittedTimeout(segmentId);
+      flushPendingPartial(segmentId);
+      const state = getPluginState(editor);
+      const existing = state.segments[segmentId];
+      if (!existing && knownSegmentIds.has(segmentId)) {
+        console.warn("[ephia:tiptap] known segmentId lost range; refusing append", {
+          segmentId,
+          text
+        });
+        return;
+      }
+      if (existing) {
+        const tr = editor.state.tr;
+        const oldText = textBetweenWithHardBreaks(editor.state.doc, existing.from, existing.to);
+        let newEnd = existing.from + measureTextAsOperationsSize(editor, text);
+        if (oldText !== text) {
+          const prefixLen = getCommonPrefix(oldText, text);
+          const suffixLen = getCommonSuffix(oldText, text, prefixLen);
+          if (prefixLen > 0 || suffixLen > 0) {
+            const deleteFrom = existing.from + prefixLen;
+            const deleteTo = existing.to - suffixLen;
+            const insertText = text.slice(prefixLen, text.length - suffixLen);
+            if (deleteFrom < deleteTo) tr.delete(deleteFrom, deleteTo);
+            if (insertText) {
+              insertOperationsAt(
+                editor,
+                tr,
+                deleteFrom,
+                textToDocumentOperations(insertText)
+              );
+            }
+            newEnd = existing.from + measureTextAsOperationsSize(editor, text);
+          } else {
+            tr.delete(existing.from, existing.to);
+            const inserted = insertOperationsAt(
+              editor,
+              tr,
+              existing.from,
+              textToDocumentOperations(text)
+            );
+            newEnd = inserted.to;
+          }
+        }
+        tr.removeMark(existing.from, newEnd, editor.schema.marks.ephiaPreview);
+        const committedMark = editor.schema.marks.ephiaCommitted?.create();
+        if (committedMark) {
+          tr.addMark(existing.from, newEnd, committedMark);
+        }
+        setSegmentMeta(tr, segmentId, {
+          from: existing.from,
+          to: newEnd,
+          revision: Number.MAX_SAFE_INTEGER,
+          joinerLength: existing.joinerLength
+        });
+        if (state.anchor) {
+          setAnchorMeta(tr, { kind: "patch", end: newEnd });
+        }
+        lastDictationEnd = newEnd;
+        trimOverlappingPreviewSegments(tr, state, segmentId, text);
+        for (const absorbedId of options?.absorbedSegmentIds ?? []) {
+          if (absorbedId === segmentId) continue;
+          cancelPendingPartial(absorbedId);
+          const absorbedSeg = state.segments[absorbedId];
+          if (!absorbedSeg) continue;
+          const aFrom = tr.mapping.map(absorbedSeg.from - (absorbedSeg.joinerLength ?? 0));
+          const aTo = tr.mapping.map(absorbedSeg.to);
+          if (aFrom < aTo) tr.delete(aFrom, aTo);
+          setSegmentMeta(tr, absorbedId, null);
+        }
+        maybeScrollIntoView(tr, editor, newEnd);
+        editor.view.dispatch(tr);
+        knownSegmentIds.add(segmentId);
+        if (committedMark) {
+          const timeoutId = window.setTimeout(() => {
+            committedTimeouts.delete(segmentId);
+            const freshState = getPluginState(editor);
+            const seg = freshState.segments[segmentId];
+            if (seg && editor.schema.marks.ephiaCommitted) {
+              const tr2 = editor.state.tr;
+              tr2.setMeta("addToHistory", false);
+              tr2.setMeta(SKIP_STORE_SYNC_META, true);
+              tr2.removeMark(seg.from, seg.to, editor.schema.marks.ephiaCommitted);
+              editor.view.dispatch(tr2);
+            }
+          }, 1300);
+          committedTimeouts.set(segmentId, timeoutId);
+        }
+      } else {
+        const tr = editor.state.tr;
+        let pos = state.anchor ? state.anchor.end : editor.state.selection.from;
+        if (state.anchor?.selectionPendingDelete && state.anchor.initialEnd > state.anchor.initialStart) {
+          tr.delete(state.anchor.initialStart, state.anchor.initialEnd);
+          pos = state.anchor.initialStart;
+          setAnchorMeta(tr, {
+            kind: "set",
+            value: {
+              ...state.anchor,
+              selectionPendingDelete: false,
+              initialEnd: state.anchor.initialStart,
+              end: state.anchor.initialStart
+            }
+          });
+        }
+        let joiner = "";
+        if (state.anchor) {
+          const before = textBetweenWithHardBreaks(editor.state.doc, Math.max(0, pos - 500), pos);
+          const overlap = stripLeadingOverlapFromTextWithInfo(before, text);
+          text = overlap.text;
+          if (!text) return;
+          joiner = overlap.partialWord ? "" : pickJoiner(before, text);
+        }
+        const fullText = joiner + text;
+        const inserted = insertOperationsAt(
+          editor,
+          tr,
+          pos,
+          textToDocumentOperations(fullText)
+        );
+        const segFrom = pos + measureTextAsOperationsSize(editor, joiner);
+        const segTo = inserted.to;
+        setSegmentMeta(tr, segmentId, {
+          from: segFrom,
+          to: segTo,
+          revision: Number.MAX_SAFE_INTEGER,
+          joinerLength: joiner.length
+        });
+        if (state.anchor) {
+          setAnchorMeta(tr, { kind: "patch", end: segTo });
+        }
+        lastDictationEnd = segTo;
+        trimOverlappingPreviewSegments(tr, state, segmentId, text);
+        for (const absorbedId of options?.absorbedSegmentIds ?? []) {
+          if (absorbedId === segmentId) continue;
+          cancelPendingPartial(absorbedId);
+          const absorbedSeg = state.segments[absorbedId];
+          if (!absorbedSeg) continue;
+          const aFrom = tr.mapping.map(absorbedSeg.from - (absorbedSeg.joinerLength ?? 0));
+          const aTo = tr.mapping.map(absorbedSeg.to);
+          if (aFrom < aTo) tr.delete(aFrom, aTo);
+          setSegmentMeta(tr, absorbedId, null);
+        }
+        maybeScrollIntoView(tr, editor, segTo);
+        editor.view.dispatch(tr);
+        knownSegmentIds.add(segmentId);
+      }
+    },
+    clearPartial(segmentId) {
+      cancelPendingPartial(segmentId);
+      const state = getPluginState(editor);
+      const existing = state.segments[segmentId];
+      if (existing) {
+        if (existing.revision === Number.MAX_SAFE_INTEGER) {
+          return;
+        }
+        const tr = editor.state.tr;
+        tr.setMeta("addToHistory", false);
+        tr.setMeta(SKIP_STORE_SYNC_META, true);
+        tr.delete(existing.from - (existing.joinerLength ?? 0), existing.to);
+        setSegmentMeta(tr, segmentId, null);
+        editor.view.dispatch(tr);
+      }
+    },
+    clearAll() {
+      cancelAllPendingPartials();
+      const state = getPluginState(editor);
+      const previewEntries = Object.entries(state.segments).filter(
+        ([, seg]) => seg.revision !== Number.MAX_SAFE_INTEGER
+      );
+      if (previewEntries.length === 0) return;
+      const tr = editor.state.tr;
+      tr.setMeta("addToHistory", false);
+      tr.setMeta(SKIP_STORE_SYNC_META, true);
+      for (const [segmentId, seg] of previewEntries.sort(
+        (a, b) => b[1].from - a[1].from
+      )) {
+        const from = tr.mapping.map(seg.from - (seg.joinerLength ?? 0));
+        const to = tr.mapping.map(seg.to);
+        if (from < to) tr.delete(from, to);
+        setSegmentMeta(tr, segmentId, null);
+      }
+      editor.view.dispatch(tr);
+    },
+    getText() {
+      return getTextFromDoc(editor.state.doc);
+    },
+    getSelection() {
+      const { from, to } = editor.state.selection;
+      if (from === to) return null;
+      return {
+        text: textBetweenWithHardBreaks(editor.state.doc, from, to),
+        range: { start: from, end: to }
+      };
+    },
+    getCursorOffset() {
+      return editor.state.selection.from;
+    },
+    applyOperation(operation) {
+      switch (operation.type) {
+        case "replace": {
+          let start;
+          let end;
+          if (operation.range) {
+            start = operation.range.start;
+            end = operation.range.end;
+          } else if (operation.targetText) {
+            const text = editor.getText();
+            const idx = text.indexOf(operation.targetText);
+            if (idx === -1) {
+              console.warn(
+                "[tiptapBinding] replace ignored: targetText not found"
+              );
+              return;
+            }
+            start = idx;
+            end = idx + operation.targetText.length;
+          } else {
+            console.warn(
+              "[tiptapBinding] replace ignored: missing range or targetText"
+            );
+            return;
+          }
+          editor.chain().deleteRange({ from: start, to: end }).insertContentAt(start, [{ type: "text", text: operation.replacement }]).run();
+          break;
+        }
+        case "insert":
+        case "insert_text":
+        case "line_break":
+        case "paragraph_break": {
+          const pos = resolveInsertPosition(editor, operation.position);
+          const tr = editor.state.tr;
+          insertOperationsAt(editor, tr, pos, [operation]);
+          editor.view.dispatch(tr);
+          break;
+        }
+        case "delete": {
+          let start;
+          let end;
+          if (operation.range) {
+            start = operation.range.start;
+            end = operation.range.end;
+          } else if (operation.targetText) {
+            const text = editor.getText();
+            const idx = text.indexOf(operation.targetText);
+            if (idx === -1) {
+              console.warn(
+                "[tiptapBinding] delete ignored: targetText not found"
+              );
+              return;
+            }
+            start = idx;
+            end = idx + operation.targetText.length;
+          } else {
+            console.warn(
+              "[tiptapBinding] delete ignored: missing range or targetText"
+            );
+            return;
+          }
+          editor.chain().deleteRange({ from: start, to: end }).run();
+          break;
+        }
+        case "replace_all": {
+          editor.chain().setContent([{ type: "paragraph", content: [{ type: "text", text: operation.replacement }] }]).run();
+          break;
+        }
+        default:
+          console.warn(
+            "[tiptapBinding] Operation not supported:",
+            operation.type
+          );
+      }
+    },
+    applyOperations(operations) {
+      if (operations.length === 0) return;
+      const firstInsertOperation = operations.find(
+        (operation) => operation.type === "insert" || operation.type === "insert_text" || operation.type === "line_break" || operation.type === "paragraph_break"
+      );
+      if (!firstInsertOperation) {
+        for (const operation of operations) {
+          console.warn(
+            "[tiptapBinding] Operation not supported in applyOperations:",
+            operation.type
+          );
+        }
+        return;
+      }
+      const tr = editor.state.tr;
+      const pos = resolveInsertPosition(editor, firstInsertOperation.position);
+      insertOperationsAt(editor, tr, pos, operations);
+      editor.view.dispatch(tr);
+    }
+  };
+}
+export {
+  EphiaCommittedMark,
+  EphiaPlaceholderMark,
+  EphiaPreviewMark,
+  EphiaRevisedMark,
+  EphiaV2CommittedMark,
+  EphiaV2PreviewMark,
+  NativeBinding,
+  TiptapBinding,
+  createTiptapBinding as createLegacyTiptapBinding
+};
+//# sourceMappingURL=index.js.map